• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "content/renderer/media/android/webmediaplayer_android.h"
6 
7 #include <limits>
8 
9 #include "base/android/build_info.h"
10 #include "base/bind.h"
11 #include "base/callback_helpers.h"
12 #include "base/command_line.h"
13 #include "base/files/file_path.h"
14 #include "base/logging.h"
15 #include "base/metrics/histogram.h"
16 #include "base/single_thread_task_runner.h"
17 #include "base/strings/string_number_conversions.h"
18 #include "base/strings/utf_string_conversions.h"
19 #include "cc/blink/web_layer_impl.h"
20 #include "cc/layers/video_layer.h"
21 #include "content/public/common/content_client.h"
22 #include "content/public/common/content_switches.h"
23 #include "content/public/renderer/render_frame.h"
24 #include "content/renderer/media/android/renderer_demuxer_android.h"
25 #include "content/renderer/media/android/renderer_media_player_manager.h"
26 #include "content/renderer/media/crypto/key_systems.h"
27 #include "content/renderer/media/crypto/renderer_cdm_manager.h"
28 #include "content/renderer/media/webcontentdecryptionmodule_impl.h"
29 #include "content/renderer/render_frame_impl.h"
30 #include "content/renderer/render_thread_impl.h"
31 #include "gpu/GLES2/gl2extchromium.h"
32 #include "gpu/command_buffer/client/gles2_interface.h"
33 #include "gpu/command_buffer/common/mailbox_holder.h"
34 #include "media/base/android/media_common_android.h"
35 #include "media/base/android/media_player_android.h"
36 #include "media/base/bind_to_current_loop.h"
37 // TODO(xhwang): Remove when we remove prefixed EME implementation.
38 #include "media/base/media_keys.h"
39 #include "media/base/media_log.h"
40 #include "media/base/media_switches.h"
41 #include "media/base/video_frame.h"
42 #include "media/blink/webmediaplayer_delegate.h"
43 #include "media/blink/webmediaplayer_util.h"
44 #include "net/base/mime_util.h"
45 #include "third_party/WebKit/public/platform/Platform.h"
46 #include "third_party/WebKit/public/platform/WebContentDecryptionModuleResult.h"
47 #include "third_party/WebKit/public/platform/WebGraphicsContext3DProvider.h"
48 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
49 #include "third_party/WebKit/public/platform/WebString.h"
50 #include "third_party/WebKit/public/platform/WebURL.h"
51 #include "third_party/WebKit/public/web/WebDocument.h"
52 #include "third_party/WebKit/public/web/WebFrame.h"
53 #include "third_party/WebKit/public/web/WebRuntimeFeatures.h"
54 #include "third_party/WebKit/public/web/WebSecurityOrigin.h"
55 #include "third_party/WebKit/public/web/WebView.h"
56 #include "third_party/skia/include/core/SkCanvas.h"
57 #include "third_party/skia/include/core/SkPaint.h"
58 #include "third_party/skia/include/core/SkTypeface.h"
59 #include "ui/gfx/image/image.h"
60 
61 static const uint32 kGLTextureExternalOES = 0x8D65;
62 static const int kSDKVersionToSupportSecurityOriginCheck = 20;
63 
64 using blink::WebMediaPlayer;
65 using blink::WebSize;
66 using blink::WebString;
67 using blink::WebTimeRanges;
68 using blink::WebURL;
69 using gpu::gles2::GLES2Interface;
70 using media::MediaPlayerAndroid;
71 using media::VideoFrame;
72 
73 namespace {
74 // Prefix for histograms related to Encrypted Media Extensions.
75 const char* kMediaEme = "Media.EME.";
76 
77 // File-static function is to allow it to run even after WMPA is deleted.
OnReleaseTexture(const scoped_refptr<content::StreamTextureFactory> & factories,uint32 texture_id,uint32 release_sync_point)78 void OnReleaseTexture(
79     const scoped_refptr<content::StreamTextureFactory>& factories,
80     uint32 texture_id,
81     uint32 release_sync_point) {
82   GLES2Interface* gl = factories->ContextGL();
83   gl->WaitSyncPointCHROMIUM(release_sync_point);
84   gl->DeleteTextures(1, &texture_id);
85 }
86 
87 class SyncPointClientImpl : public media::VideoFrame::SyncPointClient {
88  public:
SyncPointClientImpl(blink::WebGraphicsContext3D * web_graphics_context)89   explicit SyncPointClientImpl(
90       blink::WebGraphicsContext3D* web_graphics_context)
91       : web_graphics_context_(web_graphics_context) {}
~SyncPointClientImpl()92   virtual ~SyncPointClientImpl() {}
InsertSyncPoint()93   virtual uint32 InsertSyncPoint() OVERRIDE {
94     return web_graphics_context_->insertSyncPoint();
95   }
WaitSyncPoint(uint32 sync_point)96   virtual void WaitSyncPoint(uint32 sync_point) OVERRIDE {
97     web_graphics_context_->waitSyncPoint(sync_point);
98   }
99 
100  private:
101   blink::WebGraphicsContext3D* web_graphics_context_;
102 };
103 
104 // Used for calls to decryptor_ready_cb_ where the result can be ignored.
DoNothing(bool)105 void DoNothing(bool) {
106 }
107 
108 }  // namespace
109 
110 namespace content {
111 
WebMediaPlayerAndroid(blink::WebFrame * frame,blink::WebMediaPlayerClient * client,base::WeakPtr<media::WebMediaPlayerDelegate> delegate,RendererMediaPlayerManager * player_manager,RendererCdmManager * cdm_manager,blink::WebContentDecryptionModule * initial_cdm,scoped_refptr<StreamTextureFactory> factory,const scoped_refptr<base::SingleThreadTaskRunner> & task_runner,media::MediaLog * media_log)112 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
113     blink::WebFrame* frame,
114     blink::WebMediaPlayerClient* client,
115     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
116     RendererMediaPlayerManager* player_manager,
117     RendererCdmManager* cdm_manager,
118     blink::WebContentDecryptionModule* initial_cdm,
119     scoped_refptr<StreamTextureFactory> factory,
120     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
121     media::MediaLog* media_log)
122     : RenderFrameObserver(RenderFrame::FromWebFrame(frame)),
123       frame_(frame),
124       client_(client),
125       delegate_(delegate),
126       buffered_(static_cast<size_t>(1)),
127       media_task_runner_(task_runner),
128       ignore_metadata_duration_change_(false),
129       pending_seek_(false),
130       seeking_(false),
131       did_loading_progress_(false),
132       player_manager_(player_manager),
133       cdm_manager_(cdm_manager),
134       network_state_(WebMediaPlayer::NetworkStateEmpty),
135       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
136       texture_id_(0),
137       stream_id_(0),
138       is_playing_(false),
139       needs_establish_peer_(true),
140       has_size_info_(false),
141       // Compositor thread does not exist in layout tests.
142       compositor_loop_(
143           RenderThreadImpl::current()->compositor_message_loop_proxy()
144               ? RenderThreadImpl::current()->compositor_message_loop_proxy()
145               : base::MessageLoopProxy::current()),
146       stream_texture_factory_(factory),
147       needs_external_surface_(false),
148       video_frame_provider_client_(NULL),
149       player_type_(MEDIA_PLAYER_TYPE_URL),
150       is_remote_(false),
151       media_log_(media_log),
152       web_cdm_(NULL),
153       allow_stored_credentials_(false),
154       is_local_resource_(false),
155       interpolator_(&default_tick_clock_),
156       weak_factory_(this) {
157   DCHECK(player_manager_);
158   DCHECK(cdm_manager_);
159 
160   DCHECK(main_thread_checker_.CalledOnValidThread());
161   stream_texture_factory_->AddObserver(this);
162 
163   player_id_ = player_manager_->RegisterMediaPlayer(this);
164 
165 #if defined(VIDEO_HOLE)
166   force_use_overlay_embedded_video_ = CommandLine::ForCurrentProcess()->
167       HasSwitch(switches::kForceUseOverlayEmbeddedVideo);
168   if (force_use_overlay_embedded_video_ ||
169     player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo()) {
170     // Defer stream texture creation until we are sure it's necessary.
171     needs_establish_peer_ = false;
172     current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
173   }
174 #endif  // defined(VIDEO_HOLE)
175   TryCreateStreamTextureProxyIfNeeded();
176   interpolator_.SetUpperBound(base::TimeDelta());
177 
178   // Set the initial CDM, if specified.
179   if (initial_cdm) {
180     web_cdm_ = ToWebContentDecryptionModuleImpl(initial_cdm);
181     if (web_cdm_->GetCdmId() != RendererCdmManager::kInvalidCdmId)
182       player_manager_->SetCdm(player_id_, web_cdm_->GetCdmId());
183   }
184 }
185 
~WebMediaPlayerAndroid()186 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
187   DCHECK(main_thread_checker_.CalledOnValidThread());
188   SetVideoFrameProviderClient(NULL);
189   client_->setWebLayer(NULL);
190 
191   if (player_manager_) {
192     player_manager_->DestroyPlayer(player_id_);
193     player_manager_->UnregisterMediaPlayer(player_id_);
194   }
195 
196   if (stream_id_) {
197     GLES2Interface* gl = stream_texture_factory_->ContextGL();
198     gl->DeleteTextures(1, &texture_id_);
199     texture_id_ = 0;
200     texture_mailbox_ = gpu::Mailbox();
201     stream_id_ = 0;
202   }
203 
204   {
205     base::AutoLock auto_lock(current_frame_lock_);
206     current_frame_ = NULL;
207   }
208 
209   if (delegate_)
210     delegate_->PlayerGone(this);
211 
212   stream_texture_factory_->RemoveObserver(this);
213 
214   if (media_source_delegate_) {
215     // Part of |media_source_delegate_| needs to be stopped on the media thread.
216     // Wait until |media_source_delegate_| is fully stopped before tearing
217     // down other objects.
218     base::WaitableEvent waiter(false, false);
219     media_source_delegate_->Stop(
220         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&waiter)));
221     waiter.Wait();
222   }
223 }
224 
load(LoadType load_type,const blink::WebURL & url,CORSMode cors_mode)225 void WebMediaPlayerAndroid::load(LoadType load_type,
226                                  const blink::WebURL& url,
227                                  CORSMode cors_mode) {
228   DCHECK(main_thread_checker_.CalledOnValidThread());
229   media::ReportMediaSchemeUma(GURL(url));
230 
231   switch (load_type) {
232     case LoadTypeURL:
233       player_type_ = MEDIA_PLAYER_TYPE_URL;
234       break;
235 
236     case LoadTypeMediaSource:
237       player_type_ = MEDIA_PLAYER_TYPE_MEDIA_SOURCE;
238       break;
239 
240     case LoadTypeMediaStream:
241       CHECK(false) << "WebMediaPlayerAndroid doesn't support MediaStream on "
242                       "this platform";
243       return;
244   }
245 
246   url_ = url;
247   is_local_resource_ = IsLocalResource();
248   int demuxer_client_id = 0;
249   if (player_type_ != MEDIA_PLAYER_TYPE_URL) {
250     RendererDemuxerAndroid* demuxer =
251         RenderThreadImpl::current()->renderer_demuxer();
252     demuxer_client_id = demuxer->GetNextDemuxerClientID();
253 
254     media_source_delegate_.reset(new MediaSourceDelegate(
255         demuxer, demuxer_client_id, media_task_runner_, media_log_));
256 
257     if (player_type_ == MEDIA_PLAYER_TYPE_MEDIA_SOURCE) {
258       media::SetDecryptorReadyCB set_decryptor_ready_cb =
259           media::BindToCurrentLoop(
260               base::Bind(&WebMediaPlayerAndroid::SetDecryptorReadyCB,
261                          weak_factory_.GetWeakPtr()));
262 
263       media_source_delegate_->InitializeMediaSource(
264           base::Bind(&WebMediaPlayerAndroid::OnMediaSourceOpened,
265                      weak_factory_.GetWeakPtr()),
266           base::Bind(&WebMediaPlayerAndroid::OnNeedKey,
267                      weak_factory_.GetWeakPtr()),
268           set_decryptor_ready_cb,
269           base::Bind(&WebMediaPlayerAndroid::UpdateNetworkState,
270                      weak_factory_.GetWeakPtr()),
271           base::Bind(&WebMediaPlayerAndroid::OnDurationChanged,
272                      weak_factory_.GetWeakPtr()));
273       InitializePlayer(url_, frame_->document().firstPartyForCookies(),
274                        true, demuxer_client_id);
275     }
276   } else {
277     info_loader_.reset(
278         new MediaInfoLoader(
279             url,
280             cors_mode,
281             base::Bind(&WebMediaPlayerAndroid::DidLoadMediaInfo,
282                        weak_factory_.GetWeakPtr())));
283     info_loader_->Start(frame_);
284   }
285 
286   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
287   UpdateReadyState(WebMediaPlayer::ReadyStateHaveNothing);
288   UMA_HISTOGRAM_BOOLEAN(
289       "Media.MSE.Playback", player_type_ == MEDIA_PLAYER_TYPE_MEDIA_SOURCE);
290 }
291 
DidLoadMediaInfo(MediaInfoLoader::Status status,const GURL & redirected_url,const GURL & first_party_for_cookies,bool allow_stored_credentials)292 void WebMediaPlayerAndroid::DidLoadMediaInfo(
293     MediaInfoLoader::Status status,
294     const GURL& redirected_url,
295     const GURL& first_party_for_cookies,
296     bool allow_stored_credentials) {
297   DCHECK(main_thread_checker_.CalledOnValidThread());
298   DCHECK(!media_source_delegate_);
299   if (status == MediaInfoLoader::kFailed) {
300     info_loader_.reset();
301     UpdateNetworkState(WebMediaPlayer::NetworkStateNetworkError);
302     return;
303   }
304   redirected_url_ = redirected_url;
305   InitializePlayer(
306       redirected_url, first_party_for_cookies, allow_stored_credentials, 0);
307 
308   UpdateNetworkState(WebMediaPlayer::NetworkStateIdle);
309 }
310 
IsLocalResource()311 bool WebMediaPlayerAndroid::IsLocalResource() {
312   if (url_.SchemeIsFile() || url_.SchemeIsBlob())
313     return true;
314 
315   std::string host = url_.host();
316   if (!host.compare("localhost") || !host.compare("127.0.0.1") ||
317       !host.compare("[::1]")) {
318     return true;
319   }
320 
321   return false;
322 }
323 
play()324 void WebMediaPlayerAndroid::play() {
325   DCHECK(main_thread_checker_.CalledOnValidThread());
326 
327   // For HLS streams, some devices cannot detect the video size unless a surface
328   // texture is bind to it. See http://crbug.com/400145.
329 #if defined(VIDEO_HOLE)
330   if ((hasVideo() || IsHLSStream()) && needs_external_surface_ &&
331       !player_manager_->IsInFullscreen(frame_)) {
332     DCHECK(!needs_establish_peer_);
333     player_manager_->RequestExternalSurface(player_id_, last_computed_rect_);
334   }
335 #endif  // defined(VIDEO_HOLE)
336 
337   TryCreateStreamTextureProxyIfNeeded();
338   // There is no need to establish the surface texture peer for fullscreen
339   // video.
340   if ((hasVideo() || IsHLSStream()) && needs_establish_peer_ &&
341       !player_manager_->IsInFullscreen(frame_)) {
342     EstablishSurfaceTexturePeer();
343   }
344 
345   if (paused())
346     player_manager_->Start(player_id_);
347   UpdatePlayingState(true);
348   UpdateNetworkState(WebMediaPlayer::NetworkStateLoading);
349 }
350 
pause()351 void WebMediaPlayerAndroid::pause() {
352   DCHECK(main_thread_checker_.CalledOnValidThread());
353   Pause(true);
354 }
355 
requestRemotePlayback()356 void WebMediaPlayerAndroid::requestRemotePlayback() {
357   player_manager_->RequestRemotePlayback(player_id_);
358 }
359 
requestRemotePlaybackControl()360 void WebMediaPlayerAndroid::requestRemotePlaybackControl() {
361   player_manager_->RequestRemotePlaybackControl(player_id_);
362 }
363 
seek(double seconds)364 void WebMediaPlayerAndroid::seek(double seconds) {
365   DCHECK(main_thread_checker_.CalledOnValidThread());
366   DVLOG(1) << __FUNCTION__ << "(" << seconds << ")";
367 
368   base::TimeDelta new_seek_time = media::ConvertSecondsToTimestamp(seconds);
369 
370   if (seeking_) {
371     if (new_seek_time == seek_time_) {
372       if (media_source_delegate_) {
373         if (!pending_seek_) {
374           // If using media source demuxer, only suppress redundant seeks if
375           // there is no pending seek. This enforces that any pending seek that
376           // results in a demuxer seek is preceded by matching
377           // CancelPendingSeek() and StartWaitingForSeek() calls.
378           return;
379         }
380       } else {
381         // Suppress all redundant seeks if unrestricted by media source
382         // demuxer API.
383         pending_seek_ = false;
384         return;
385       }
386     }
387 
388     pending_seek_ = true;
389     pending_seek_time_ = new_seek_time;
390 
391     if (media_source_delegate_)
392       media_source_delegate_->CancelPendingSeek(pending_seek_time_);
393 
394     // Later, OnSeekComplete will trigger the pending seek.
395     return;
396   }
397 
398   seeking_ = true;
399   seek_time_ = new_seek_time;
400 
401   if (media_source_delegate_)
402     media_source_delegate_->StartWaitingForSeek(seek_time_);
403 
404   // Kick off the asynchronous seek!
405   player_manager_->Seek(player_id_, seek_time_);
406 }
407 
supportsSave() const408 bool WebMediaPlayerAndroid::supportsSave() const {
409   return false;
410 }
411 
setRate(double rate)412 void WebMediaPlayerAndroid::setRate(double rate) {
413   NOTIMPLEMENTED();
414 }
415 
setVolume(double volume)416 void WebMediaPlayerAndroid::setVolume(double volume) {
417   DCHECK(main_thread_checker_.CalledOnValidThread());
418   player_manager_->SetVolume(player_id_, volume);
419 }
420 
hasVideo() const421 bool WebMediaPlayerAndroid::hasVideo() const {
422   DCHECK(main_thread_checker_.CalledOnValidThread());
423   // If we have obtained video size information before, use it.
424   if (has_size_info_)
425     return !natural_size_.isEmpty();
426 
427   // TODO(qinmin): need a better method to determine whether the current media
428   // content contains video. Android does not provide any function to do
429   // this.
430   // We don't know whether the current media content has video unless
431   // the player is prepared. If the player is not prepared, we fall back
432   // to the mime-type. There may be no mime-type on a redirect URL.
433   // In that case, we conservatively assume it contains video so that
434   // enterfullscreen call will not fail.
435   if (!url_.has_path())
436     return false;
437   std::string mime;
438   if (!net::GetMimeTypeFromFile(base::FilePath(url_.path()), &mime))
439     return true;
440   return mime.find("audio/") == std::string::npos;
441 }
442 
hasAudio() const443 bool WebMediaPlayerAndroid::hasAudio() const {
444   DCHECK(main_thread_checker_.CalledOnValidThread());
445   if (!url_.has_path())
446     return false;
447   std::string mime;
448   if (!net::GetMimeTypeFromFile(base::FilePath(url_.path()), &mime))
449     return true;
450 
451   if (mime.find("audio/") != std::string::npos ||
452       mime.find("video/") != std::string::npos ||
453       mime.find("application/ogg") != std::string::npos) {
454     return true;
455   }
456   return false;
457 }
458 
isRemote() const459 bool WebMediaPlayerAndroid::isRemote() const {
460   return is_remote_;
461 }
462 
paused() const463 bool WebMediaPlayerAndroid::paused() const {
464   return !is_playing_;
465 }
466 
seeking() const467 bool WebMediaPlayerAndroid::seeking() const {
468   return seeking_;
469 }
470 
duration() const471 double WebMediaPlayerAndroid::duration() const {
472   DCHECK(main_thread_checker_.CalledOnValidThread());
473   // HTML5 spec requires duration to be NaN if readyState is HAVE_NOTHING
474   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing)
475     return std::numeric_limits<double>::quiet_NaN();
476 
477   if (duration_ == media::kInfiniteDuration())
478     return std::numeric_limits<double>::infinity();
479 
480   return duration_.InSecondsF();
481 }
482 
timelineOffset() const483 double WebMediaPlayerAndroid::timelineOffset() const {
484   DCHECK(main_thread_checker_.CalledOnValidThread());
485   base::Time timeline_offset;
486   if (media_source_delegate_)
487     timeline_offset = media_source_delegate_->GetTimelineOffset();
488 
489   if (timeline_offset.is_null())
490     return std::numeric_limits<double>::quiet_NaN();
491 
492   return timeline_offset.ToJsTime();
493 }
494 
currentTime() const495 double WebMediaPlayerAndroid::currentTime() const {
496   DCHECK(main_thread_checker_.CalledOnValidThread());
497   // If the player is processing a seek, return the seek time.
498   // Blink may still query us if updatePlaybackState() occurs while seeking.
499   if (seeking()) {
500     return pending_seek_ ?
501         pending_seek_time_.InSecondsF() : seek_time_.InSecondsF();
502   }
503 
504   return std::min(
505       (const_cast<media::TimeDeltaInterpolator*>(
506           &interpolator_))->GetInterpolatedTime(), duration_).InSecondsF();
507 }
508 
naturalSize() const509 WebSize WebMediaPlayerAndroid::naturalSize() const {
510   return natural_size_;
511 }
512 
networkState() const513 WebMediaPlayer::NetworkState WebMediaPlayerAndroid::networkState() const {
514   return network_state_;
515 }
516 
readyState() const517 WebMediaPlayer::ReadyState WebMediaPlayerAndroid::readyState() const {
518   return ready_state_;
519 }
520 
buffered() const521 WebTimeRanges WebMediaPlayerAndroid::buffered() const {
522   if (media_source_delegate_)
523     return media_source_delegate_->Buffered();
524   return buffered_;
525 }
526 
maxTimeSeekable() const527 double WebMediaPlayerAndroid::maxTimeSeekable() const {
528   // If we haven't even gotten to ReadyStateHaveMetadata yet then just
529   // return 0 so that the seekable range is empty.
530   if (ready_state_ < WebMediaPlayer::ReadyStateHaveMetadata)
531     return 0.0;
532 
533   return duration();
534 }
535 
didLoadingProgress()536 bool WebMediaPlayerAndroid::didLoadingProgress() {
537   bool ret = did_loading_progress_;
538   did_loading_progress_ = false;
539   return ret;
540 }
541 
EnsureTextureBackedSkBitmap(GrContext * gr,SkBitmap & bitmap,const WebSize & size,GrSurfaceOrigin origin,GrPixelConfig config)542 bool WebMediaPlayerAndroid::EnsureTextureBackedSkBitmap(GrContext* gr,
543                                                         SkBitmap& bitmap,
544                                                         const WebSize& size,
545                                                         GrSurfaceOrigin origin,
546                                                         GrPixelConfig config) {
547   DCHECK(main_thread_checker_.CalledOnValidThread());
548   if (!bitmap.getTexture() || bitmap.width() != size.width
549       || bitmap.height() != size.height) {
550     if (!gr)
551       return false;
552     GrTextureDesc desc;
553     desc.fConfig = config;
554     desc.fFlags = kRenderTarget_GrTextureFlagBit | kNoStencil_GrTextureFlagBit;
555     desc.fSampleCnt = 0;
556     desc.fOrigin = origin;
557     desc.fWidth = size.width;
558     desc.fHeight = size.height;
559     skia::RefPtr<GrTexture> texture;
560     texture = skia::AdoptRef(gr->createUncachedTexture(desc, 0, 0));
561     if (!texture.get())
562       return false;
563 
564     SkImageInfo info = SkImageInfo::MakeN32Premul(desc.fWidth, desc.fHeight);
565     SkGrPixelRef* pixelRef = SkNEW_ARGS(SkGrPixelRef, (info, texture.get()));
566     if (!pixelRef)
567       return false;
568     bitmap.setInfo(info);
569     bitmap.setPixelRef(pixelRef)->unref();
570   }
571 
572   return true;
573 }
574 
paint(blink::WebCanvas * canvas,const blink::WebRect & rect,unsigned char alpha)575 void WebMediaPlayerAndroid::paint(blink::WebCanvas* canvas,
576                                   const blink::WebRect& rect,
577                                   unsigned char alpha) {
578   paint(canvas, rect, alpha, SkXfermode::kSrcOver_Mode);
579 }
580 
paint(blink::WebCanvas * canvas,const blink::WebRect & rect,unsigned char alpha,SkXfermode::Mode mode)581 void WebMediaPlayerAndroid::paint(blink::WebCanvas* canvas,
582                                   const blink::WebRect& rect,
583                                   unsigned char alpha,
584                                   SkXfermode::Mode mode) {
585   DCHECK(main_thread_checker_.CalledOnValidThread());
586   scoped_ptr<blink::WebGraphicsContext3DProvider> provider =
587     scoped_ptr<blink::WebGraphicsContext3DProvider>(blink::Platform::current(
588       )->createSharedOffscreenGraphicsContext3DProvider());
589   if (!provider)
590     return;
591   blink::WebGraphicsContext3D* context3D = provider->context3d();
592   if (!context3D)
593     return;
594 
595   // Copy video texture into a RGBA texture based bitmap first as video texture
596   // on Android is GL_TEXTURE_EXTERNAL_OES which is not supported by Skia yet.
597   // The bitmap's size needs to be the same as the video and use naturalSize()
598   // here. Check if we could reuse existing texture based bitmap.
599   // Otherwise, release existing texture based bitmap and allocate
600   // a new one based on video size.
601   if (!EnsureTextureBackedSkBitmap(provider->grContext(), bitmap_,
602       naturalSize(), kTopLeft_GrSurfaceOrigin, kSkia8888_GrPixelConfig)) {
603     return;
604   }
605 
606   unsigned textureId = static_cast<unsigned>(
607     (bitmap_.getTexture())->getTextureHandle());
608   if (!copyVideoTextureToPlatformTexture(context3D, textureId, 0,
609       GL_RGBA, GL_UNSIGNED_BYTE, true, false)) {
610     return;
611   }
612 
613   // Draw the texture based bitmap onto the Canvas. If the canvas is
614   // hardware based, this will do a GPU-GPU texture copy.
615   // If the canvas is software based, the texture based bitmap will be
616   // readbacked to system memory then draw onto the canvas.
617   SkRect dest;
618   dest.set(rect.x, rect.y, rect.x + rect.width, rect.y + rect.height);
619   SkPaint paint;
620   paint.setAlpha(alpha);
621   paint.setXfermodeMode(mode);
622   // It is not necessary to pass the dest into the drawBitmap call since all
623   // the context have been set up before calling paintCurrentFrameInContext.
624   canvas->drawBitmapRect(bitmap_, 0, dest, &paint);
625 }
626 
copyVideoTextureToPlatformTexture(blink::WebGraphicsContext3D * web_graphics_context,unsigned int texture,unsigned int level,unsigned int internal_format,unsigned int type,bool premultiply_alpha,bool flip_y)627 bool WebMediaPlayerAndroid::copyVideoTextureToPlatformTexture(
628     blink::WebGraphicsContext3D* web_graphics_context,
629     unsigned int texture,
630     unsigned int level,
631     unsigned int internal_format,
632     unsigned int type,
633     bool premultiply_alpha,
634     bool flip_y) {
635   DCHECK(main_thread_checker_.CalledOnValidThread());
636   // Don't allow clients to copy an encrypted video frame.
637   if (needs_external_surface_)
638     return false;
639 
640   scoped_refptr<VideoFrame> video_frame;
641   {
642     base::AutoLock auto_lock(current_frame_lock_);
643     video_frame = current_frame_;
644   }
645 
646   if (!video_frame ||
647       video_frame->format() != media::VideoFrame::NATIVE_TEXTURE)
648     return false;
649   const gpu::MailboxHolder* mailbox_holder = video_frame->mailbox_holder();
650   DCHECK((!is_remote_ &&
651           mailbox_holder->texture_target == GL_TEXTURE_EXTERNAL_OES) ||
652          (is_remote_ && mailbox_holder->texture_target == GL_TEXTURE_2D));
653 
654   web_graphics_context->waitSyncPoint(mailbox_holder->sync_point);
655 
656   // Ensure the target of texture is set before copyTextureCHROMIUM, otherwise
657   // an invalid texture target may be used for copy texture.
658   uint32 src_texture = web_graphics_context->createAndConsumeTextureCHROMIUM(
659       mailbox_holder->texture_target, mailbox_holder->mailbox.name);
660 
661   // The video is stored in an unmultiplied format, so premultiply if
662   // necessary.
663   web_graphics_context->pixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM,
664                                     premultiply_alpha);
665 
666   // Application itself needs to take care of setting the right flip_y
667   // value down to get the expected result.
668   // flip_y==true means to reverse the video orientation while
669   // flip_y==false means to keep the intrinsic orientation.
670   web_graphics_context->pixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, flip_y);
671   web_graphics_context->copyTextureCHROMIUM(GL_TEXTURE_2D, src_texture,
672                                             texture, level, internal_format,
673                                             type);
674   web_graphics_context->pixelStorei(GL_UNPACK_FLIP_Y_CHROMIUM, false);
675   web_graphics_context->pixelStorei(GL_UNPACK_PREMULTIPLY_ALPHA_CHROMIUM,
676                                     false);
677 
678   web_graphics_context->deleteTexture(src_texture);
679   web_graphics_context->flush();
680 
681   SyncPointClientImpl client(web_graphics_context);
682   video_frame->UpdateReleaseSyncPoint(&client);
683   return true;
684 }
685 
hasSingleSecurityOrigin() const686 bool WebMediaPlayerAndroid::hasSingleSecurityOrigin() const {
687   DCHECK(main_thread_checker_.CalledOnValidThread());
688   if (player_type_ != MEDIA_PLAYER_TYPE_URL)
689     return true;
690 
691   if (!info_loader_ || !info_loader_->HasSingleOrigin())
692     return false;
693 
694   // TODO(qinmin): The url might be redirected when android media player
695   // requests the stream. As a result, we cannot guarantee there is only
696   // a single origin. Only if the HTTP request was made without credentials,
697   // we will honor the return value from  HasSingleSecurityOriginInternal()
698   // in pre-L android versions.
699   // Check http://crbug.com/334204.
700   if (!allow_stored_credentials_)
701     return true;
702 
703   return base::android::BuildInfo::GetInstance()->sdk_int() >=
704       kSDKVersionToSupportSecurityOriginCheck;
705 }
706 
didPassCORSAccessCheck() const707 bool WebMediaPlayerAndroid::didPassCORSAccessCheck() const {
708   DCHECK(main_thread_checker_.CalledOnValidThread());
709   if (info_loader_)
710     return info_loader_->DidPassCORSAccessCheck();
711   return false;
712 }
713 
mediaTimeForTimeValue(double timeValue) const714 double WebMediaPlayerAndroid::mediaTimeForTimeValue(double timeValue) const {
715   return media::ConvertSecondsToTimestamp(timeValue).InSecondsF();
716 }
717 
decodedFrameCount() const718 unsigned WebMediaPlayerAndroid::decodedFrameCount() const {
719   if (media_source_delegate_)
720     return media_source_delegate_->DecodedFrameCount();
721   NOTIMPLEMENTED();
722   return 0;
723 }
724 
droppedFrameCount() const725 unsigned WebMediaPlayerAndroid::droppedFrameCount() const {
726   if (media_source_delegate_)
727     return media_source_delegate_->DroppedFrameCount();
728   NOTIMPLEMENTED();
729   return 0;
730 }
731 
audioDecodedByteCount() const732 unsigned WebMediaPlayerAndroid::audioDecodedByteCount() const {
733   if (media_source_delegate_)
734     return media_source_delegate_->AudioDecodedByteCount();
735   NOTIMPLEMENTED();
736   return 0;
737 }
738 
videoDecodedByteCount() const739 unsigned WebMediaPlayerAndroid::videoDecodedByteCount() const {
740   if (media_source_delegate_)
741     return media_source_delegate_->VideoDecodedByteCount();
742   NOTIMPLEMENTED();
743   return 0;
744 }
745 
OnMediaMetadataChanged(const base::TimeDelta & duration,int width,int height,bool success)746 void WebMediaPlayerAndroid::OnMediaMetadataChanged(
747     const base::TimeDelta& duration, int width, int height, bool success) {
748   DCHECK(main_thread_checker_.CalledOnValidThread());
749   bool need_to_signal_duration_changed = false;
750 
751   if (is_local_resource_)
752     UpdateNetworkState(WebMediaPlayer::NetworkStateLoaded);
753 
754   // Update duration, if necessary, prior to ready state updates that may
755   // cause duration() query.
756   if (!ignore_metadata_duration_change_ && duration_ != duration) {
757     duration_ = duration;
758     if (is_local_resource_)
759       buffered_[0].end = duration_.InSecondsF();
760     // Client readyState transition from HAVE_NOTHING to HAVE_METADATA
761     // already triggers a durationchanged event. If this is a different
762     // transition, remember to signal durationchanged.
763     // Do not ever signal durationchanged on metadata change in MSE case
764     // because OnDurationChanged() handles this.
765     if (ready_state_ > WebMediaPlayer::ReadyStateHaveNothing &&
766         player_type_ != MEDIA_PLAYER_TYPE_MEDIA_SOURCE) {
767       need_to_signal_duration_changed = true;
768     }
769   }
770 
771   if (ready_state_ != WebMediaPlayer::ReadyStateHaveEnoughData) {
772     UpdateReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
773     UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
774   }
775 
776   // TODO(wolenetz): Should we just abort early and set network state to an
777   // error if success == false? See http://crbug.com/248399
778   if (success)
779     OnVideoSizeChanged(width, height);
780 
781   if (need_to_signal_duration_changed)
782     client_->durationChanged();
783 }
784 
OnPlaybackComplete()785 void WebMediaPlayerAndroid::OnPlaybackComplete() {
786   // When playback is about to finish, android media player often stops
787   // at a time which is smaller than the duration. This makes webkit never
788   // know that the playback has finished. To solve this, we set the
789   // current time to media duration when OnPlaybackComplete() get called.
790   interpolator_.SetBounds(duration_, duration_);
791   client_->timeChanged();
792 
793   // If the loop attribute is set, timeChanged() will update the current time
794   // to 0. It will perform a seek to 0. Issue a command to the player to start
795   // playing after seek completes.
796   if (seeking_ && seek_time_ == base::TimeDelta())
797     player_manager_->Start(player_id_);
798 }
799 
OnBufferingUpdate(int percentage)800 void WebMediaPlayerAndroid::OnBufferingUpdate(int percentage) {
801   buffered_[0].end = duration() * percentage / 100;
802   did_loading_progress_ = true;
803 }
804 
OnSeekRequest(const base::TimeDelta & time_to_seek)805 void WebMediaPlayerAndroid::OnSeekRequest(const base::TimeDelta& time_to_seek) {
806   DCHECK(main_thread_checker_.CalledOnValidThread());
807   client_->requestSeek(time_to_seek.InSecondsF());
808 }
809 
OnSeekComplete(const base::TimeDelta & current_time)810 void WebMediaPlayerAndroid::OnSeekComplete(
811     const base::TimeDelta& current_time) {
812   DCHECK(main_thread_checker_.CalledOnValidThread());
813   seeking_ = false;
814   if (pending_seek_) {
815     pending_seek_ = false;
816     seek(pending_seek_time_.InSecondsF());
817     return;
818   }
819   interpolator_.SetBounds(current_time, current_time);
820 
821   UpdateReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
822 
823   client_->timeChanged();
824 }
825 
OnMediaError(int error_type)826 void WebMediaPlayerAndroid::OnMediaError(int error_type) {
827   switch (error_type) {
828     case MediaPlayerAndroid::MEDIA_ERROR_FORMAT:
829       UpdateNetworkState(WebMediaPlayer::NetworkStateFormatError);
830       break;
831     case MediaPlayerAndroid::MEDIA_ERROR_DECODE:
832       UpdateNetworkState(WebMediaPlayer::NetworkStateDecodeError);
833       break;
834     case MediaPlayerAndroid::MEDIA_ERROR_NOT_VALID_FOR_PROGRESSIVE_PLAYBACK:
835       UpdateNetworkState(WebMediaPlayer::NetworkStateFormatError);
836       break;
837     case MediaPlayerAndroid::MEDIA_ERROR_INVALID_CODE:
838       break;
839   }
840   client_->repaint();
841 }
842 
OnVideoSizeChanged(int width,int height)843 void WebMediaPlayerAndroid::OnVideoSizeChanged(int width, int height) {
844   DCHECK(main_thread_checker_.CalledOnValidThread());
845   has_size_info_ = true;
846   if (natural_size_.width == width && natural_size_.height == height)
847     return;
848 
849 #if defined(VIDEO_HOLE)
850   // Use H/W surface for encrypted video.
851   // TODO(qinmin): Change this so that only EME needs the H/W surface
852   if (force_use_overlay_embedded_video_ ||
853       (media_source_delegate_ && media_source_delegate_->IsVideoEncrypted() &&
854        player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo())) {
855     needs_external_surface_ = true;
856     if (!paused() && !player_manager_->IsInFullscreen(frame_))
857       player_manager_->RequestExternalSurface(player_id_, last_computed_rect_);
858   } else if (stream_texture_proxy_ && !stream_id_) {
859     // Do deferred stream texture creation finally.
860     DoCreateStreamTexture();
861     SetNeedsEstablishPeer(true);
862   }
863 #endif  // defined(VIDEO_HOLE)
864   natural_size_.width = width;
865   natural_size_.height = height;
866 
867   // When play() gets called, |natural_size_| may still be empty and
868   // EstablishSurfaceTexturePeer() will not get called. As a result, the video
869   // may play without a surface texture. When we finally get the valid video
870   // size here, we should call EstablishSurfaceTexturePeer() if it has not been
871   // previously called.
872   if (!paused() && needs_establish_peer_)
873     EstablishSurfaceTexturePeer();
874 
875   ReallocateVideoFrame();
876 
877   // For hidden video element (with style "display:none"), ensure the texture
878   // size is set.
879   if (!is_remote_ && cached_stream_texture_size_ != natural_size_) {
880     stream_texture_factory_->SetStreamTextureSize(
881         stream_id_, gfx::Size(natural_size_.width, natural_size_.height));
882     cached_stream_texture_size_ = natural_size_;
883   }
884 
885   // Lazily allocate compositing layer.
886   if (!video_weblayer_) {
887     video_weblayer_.reset(new cc_blink::WebLayerImpl(
888         cc::VideoLayer::Create(this, media::VIDEO_ROTATION_0)));
889     client_->setWebLayer(video_weblayer_.get());
890   }
891 
892   // TODO(qinmin): This is a hack. We need the media element to stop showing the
893   // poster image by forcing it to call setDisplayMode(video). Should move the
894   // logic into HTMLMediaElement.cpp.
895   client_->timeChanged();
896 }
897 
OnTimeUpdate(base::TimeDelta current_timestamp,base::TimeTicks current_time_ticks)898 void WebMediaPlayerAndroid::OnTimeUpdate(base::TimeDelta current_timestamp,
899                                          base::TimeTicks current_time_ticks) {
900   DCHECK(main_thread_checker_.CalledOnValidThread());
901   // Compensate the current_timestamp with the IPC latency.
902   base::TimeDelta lower_bound =
903       base::TimeTicks::Now() - current_time_ticks + current_timestamp;
904   base::TimeDelta upper_bound = lower_bound;
905   // We should get another time update in about |kTimeUpdateInterval|
906   // milliseconds.
907   if (is_playing_) {
908     upper_bound += base::TimeDelta::FromMilliseconds(
909         media::kTimeUpdateInterval);
910   }
911   // if the lower_bound is smaller than the current time, just use the current
912   // time so that the timer is always progressing.
913   lower_bound =
914       std::min(lower_bound, base::TimeDelta::FromSecondsD(currentTime()));
915   interpolator_.SetBounds(lower_bound, upper_bound);
916 }
917 
OnConnectedToRemoteDevice(const std::string & remote_playback_message)918 void WebMediaPlayerAndroid::OnConnectedToRemoteDevice(
919     const std::string& remote_playback_message) {
920   DCHECK(main_thread_checker_.CalledOnValidThread());
921   DCHECK(!media_source_delegate_);
922   DrawRemotePlaybackText(remote_playback_message);
923   is_remote_ = true;
924   SetNeedsEstablishPeer(false);
925   client_->connectedToRemoteDevice();
926 }
927 
OnDisconnectedFromRemoteDevice()928 void WebMediaPlayerAndroid::OnDisconnectedFromRemoteDevice() {
929   DCHECK(main_thread_checker_.CalledOnValidThread());
930   DCHECK(!media_source_delegate_);
931   SetNeedsEstablishPeer(true);
932   if (!paused())
933     EstablishSurfaceTexturePeer();
934   is_remote_ = false;
935   ReallocateVideoFrame();
936   client_->disconnectedFromRemoteDevice();
937 }
938 
OnDidEnterFullscreen()939 void WebMediaPlayerAndroid::OnDidEnterFullscreen() {
940   if (!player_manager_->IsInFullscreen(frame_))
941     player_manager_->DidEnterFullscreen(frame_);
942 }
943 
OnDidExitFullscreen()944 void WebMediaPlayerAndroid::OnDidExitFullscreen() {
945   // |needs_external_surface_| is always false on non-TV devices.
946   if (!needs_external_surface_)
947     SetNeedsEstablishPeer(true);
948   // We had the fullscreen surface connected to Android MediaPlayer,
949   // so reconnect our surface texture for embedded playback.
950   if (!paused() && needs_establish_peer_)
951     EstablishSurfaceTexturePeer();
952 
953 #if defined(VIDEO_HOLE)
954   if (!paused() && needs_external_surface_)
955     player_manager_->RequestExternalSurface(player_id_, last_computed_rect_);
956 #endif  // defined(VIDEO_HOLE)
957 
958   player_manager_->DidExitFullscreen();
959   client_->repaint();
960 }
961 
OnMediaPlayerPlay()962 void WebMediaPlayerAndroid::OnMediaPlayerPlay() {
963   UpdatePlayingState(true);
964   client_->playbackStateChanged();
965 }
966 
OnMediaPlayerPause()967 void WebMediaPlayerAndroid::OnMediaPlayerPause() {
968   UpdatePlayingState(false);
969   client_->playbackStateChanged();
970 }
971 
OnRequestFullscreen()972 void WebMediaPlayerAndroid::OnRequestFullscreen() {
973   client_->requestFullscreen();
974 }
975 
OnRemoteRouteAvailabilityChanged(bool routes_available)976 void WebMediaPlayerAndroid::OnRemoteRouteAvailabilityChanged(
977     bool routes_available) {
978   client_->remoteRouteAvailabilityChanged(routes_available);
979 }
980 
OnDurationChanged(const base::TimeDelta & duration)981 void WebMediaPlayerAndroid::OnDurationChanged(const base::TimeDelta& duration) {
982   DCHECK(main_thread_checker_.CalledOnValidThread());
983   // Only MSE |player_type_| registers this callback.
984   DCHECK_EQ(player_type_, MEDIA_PLAYER_TYPE_MEDIA_SOURCE);
985 
986   // Cache the new duration value and trust it over any subsequent duration
987   // values received in OnMediaMetadataChanged().
988   duration_ = duration;
989   ignore_metadata_duration_change_ = true;
990 
991   // Notify MediaPlayerClient that duration has changed, if > HAVE_NOTHING.
992   if (ready_state_ > WebMediaPlayer::ReadyStateHaveNothing)
993     client_->durationChanged();
994 }
995 
UpdateNetworkState(WebMediaPlayer::NetworkState state)996 void WebMediaPlayerAndroid::UpdateNetworkState(
997     WebMediaPlayer::NetworkState state) {
998   DCHECK(main_thread_checker_.CalledOnValidThread());
999   if (ready_state_ == WebMediaPlayer::ReadyStateHaveNothing &&
1000       (state == WebMediaPlayer::NetworkStateNetworkError ||
1001        state == WebMediaPlayer::NetworkStateDecodeError)) {
1002     // Any error that occurs before reaching ReadyStateHaveMetadata should
1003     // be considered a format error.
1004     network_state_ = WebMediaPlayer::NetworkStateFormatError;
1005   } else {
1006     network_state_ = state;
1007   }
1008   client_->networkStateChanged();
1009 }
1010 
UpdateReadyState(WebMediaPlayer::ReadyState state)1011 void WebMediaPlayerAndroid::UpdateReadyState(
1012     WebMediaPlayer::ReadyState state) {
1013   ready_state_ = state;
1014   client_->readyStateChanged();
1015 }
1016 
OnPlayerReleased()1017 void WebMediaPlayerAndroid::OnPlayerReleased() {
1018   // |needs_external_surface_| is always false on non-TV devices.
1019   if (!needs_external_surface_)
1020     needs_establish_peer_ = true;
1021 
1022   if (is_playing_)
1023     OnMediaPlayerPause();
1024 
1025 #if defined(VIDEO_HOLE)
1026   last_computed_rect_ = gfx::RectF();
1027 #endif  // defined(VIDEO_HOLE)
1028 }
1029 
ReleaseMediaResources()1030 void WebMediaPlayerAndroid::ReleaseMediaResources() {
1031   switch (network_state_) {
1032     // Pause the media player and inform WebKit if the player is in a good
1033     // shape.
1034     case WebMediaPlayer::NetworkStateIdle:
1035     case WebMediaPlayer::NetworkStateLoading:
1036     case WebMediaPlayer::NetworkStateLoaded:
1037       Pause(false);
1038       client_->playbackStateChanged();
1039       break;
1040     // If a WebMediaPlayer instance has entered into one of these states,
1041     // the internal network state in HTMLMediaElement could be set to empty.
1042     // And calling playbackStateChanged() could get this object deleted.
1043     case WebMediaPlayer::NetworkStateEmpty:
1044     case WebMediaPlayer::NetworkStateFormatError:
1045     case WebMediaPlayer::NetworkStateNetworkError:
1046     case WebMediaPlayer::NetworkStateDecodeError:
1047       break;
1048   }
1049   player_manager_->ReleaseResources(player_id_);
1050   if (!needs_external_surface_)
1051     SetNeedsEstablishPeer(true);
1052 }
1053 
OnDestruct()1054 void WebMediaPlayerAndroid::OnDestruct() {
1055   NOTREACHED() << "WebMediaPlayer should be destroyed before any "
1056                   "RenderFrameObserver::OnDestruct() gets called when "
1057                   "the RenderFrame goes away.";
1058 }
1059 
InitializePlayer(const GURL & url,const GURL & first_party_for_cookies,bool allow_stored_credentials,int demuxer_client_id)1060 void WebMediaPlayerAndroid::InitializePlayer(
1061     const GURL& url,
1062     const GURL& first_party_for_cookies,
1063     bool allow_stored_credentials,
1064     int demuxer_client_id) {
1065   if (player_type_ == MEDIA_PLAYER_TYPE_URL) {
1066     UMA_HISTOGRAM_BOOLEAN("Media.Android.IsHttpLiveStreamingMedia",
1067                           IsHLSStream());
1068   }
1069   allow_stored_credentials_ = allow_stored_credentials;
1070   player_manager_->Initialize(
1071       player_type_, player_id_, url, first_party_for_cookies, demuxer_client_id,
1072       frame_->document().url(), allow_stored_credentials);
1073   if (player_manager_->ShouldEnterFullscreen(frame_))
1074     player_manager_->EnterFullscreen(player_id_, frame_);
1075 }
1076 
Pause(bool is_media_related_action)1077 void WebMediaPlayerAndroid::Pause(bool is_media_related_action) {
1078   player_manager_->Pause(player_id_, is_media_related_action);
1079   UpdatePlayingState(false);
1080 }
1081 
DrawRemotePlaybackText(const std::string & remote_playback_message)1082 void WebMediaPlayerAndroid::DrawRemotePlaybackText(
1083     const std::string& remote_playback_message) {
1084   DCHECK(main_thread_checker_.CalledOnValidThread());
1085   if (!video_weblayer_)
1086     return;
1087 
1088   // TODO(johnme): Should redraw this frame if the layer bounds change; but
1089   // there seems no easy way to listen for the layer resizing (as opposed to
1090   // OnVideoSizeChanged, which is when the frame sizes of the video file
1091   // change). Perhaps have to poll (on main thread of course)?
1092   gfx::Size video_size_css_px = video_weblayer_->bounds();
1093   float device_scale_factor = frame_->view()->deviceScaleFactor();
1094   // canvas_size will be the size in device pixels when pageScaleFactor == 1
1095   gfx::Size canvas_size(
1096       static_cast<int>(video_size_css_px.width() * device_scale_factor),
1097       static_cast<int>(video_size_css_px.height() * device_scale_factor));
1098 
1099   SkBitmap bitmap;
1100   bitmap.allocN32Pixels(canvas_size.width(), canvas_size.height());
1101 
1102   // Create the canvas and draw the "Casting to <Chromecast>" text on it.
1103   SkCanvas canvas(bitmap);
1104   canvas.drawColor(SK_ColorBLACK);
1105 
1106   const SkScalar kTextSize(40);
1107   const SkScalar kMinPadding(40);
1108 
1109   SkPaint paint;
1110   paint.setAntiAlias(true);
1111   paint.setFilterLevel(SkPaint::kHigh_FilterLevel);
1112   paint.setColor(SK_ColorWHITE);
1113   paint.setTypeface(SkTypeface::CreateFromName("sans", SkTypeface::kBold));
1114   paint.setTextSize(kTextSize);
1115 
1116   // Calculate the vertical margin from the top
1117   SkPaint::FontMetrics font_metrics;
1118   paint.getFontMetrics(&font_metrics);
1119   SkScalar sk_vertical_margin = kMinPadding - font_metrics.fAscent;
1120 
1121   // Measure the width of the entire text to display
1122   size_t display_text_width = paint.measureText(
1123       remote_playback_message.c_str(), remote_playback_message.size());
1124   std::string display_text(remote_playback_message);
1125 
1126   if (display_text_width + (kMinPadding * 2) > canvas_size.width()) {
1127     // The text is too long to fit in one line, truncate it and append ellipsis
1128     // to the end.
1129 
1130     // First, figure out how much of the canvas the '...' will take up.
1131     const std::string kTruncationEllipsis("\xE2\x80\xA6");
1132     SkScalar sk_ellipse_width = paint.measureText(
1133         kTruncationEllipsis.c_str(), kTruncationEllipsis.size());
1134 
1135     // Then calculate how much of the text can be drawn with the '...' appended
1136     // to the end of the string.
1137     SkScalar sk_max_original_text_width(
1138         canvas_size.width() - (kMinPadding * 2) - sk_ellipse_width);
1139     size_t sk_max_original_text_length = paint.breakText(
1140         remote_playback_message.c_str(),
1141         remote_playback_message.size(),
1142         sk_max_original_text_width);
1143 
1144     // Remove the part of the string that doesn't fit and append '...'.
1145     display_text.erase(sk_max_original_text_length,
1146         remote_playback_message.size() - sk_max_original_text_length);
1147     display_text.append(kTruncationEllipsis);
1148     display_text_width = paint.measureText(
1149         display_text.c_str(), display_text.size());
1150   }
1151 
1152   // Center the text horizontally.
1153   SkScalar sk_horizontal_margin =
1154       (canvas_size.width() - display_text_width) / 2.0;
1155   canvas.drawText(display_text.c_str(),
1156       display_text.size(),
1157       sk_horizontal_margin,
1158       sk_vertical_margin,
1159       paint);
1160 
1161   GLES2Interface* gl = stream_texture_factory_->ContextGL();
1162   GLuint remote_playback_texture_id = 0;
1163   gl->GenTextures(1, &remote_playback_texture_id);
1164   GLuint texture_target = GL_TEXTURE_2D;
1165   gl->BindTexture(texture_target, remote_playback_texture_id);
1166   gl->TexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1167   gl->TexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1168   gl->TexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1169   gl->TexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1170 
1171   {
1172     SkAutoLockPixels lock(bitmap);
1173     gl->TexImage2D(texture_target,
1174                    0 /* level */,
1175                    GL_RGBA /* internalformat */,
1176                    bitmap.width(),
1177                    bitmap.height(),
1178                    0 /* border */,
1179                    GL_RGBA /* format */,
1180                    GL_UNSIGNED_BYTE /* type */,
1181                    bitmap.getPixels());
1182   }
1183 
1184   gpu::Mailbox texture_mailbox;
1185   gl->GenMailboxCHROMIUM(texture_mailbox.name);
1186   gl->ProduceTextureCHROMIUM(texture_target, texture_mailbox.name);
1187   gl->Flush();
1188   GLuint texture_mailbox_sync_point = gl->InsertSyncPointCHROMIUM();
1189 
1190   scoped_refptr<VideoFrame> new_frame = VideoFrame::WrapNativeTexture(
1191       make_scoped_ptr(new gpu::MailboxHolder(
1192           texture_mailbox, texture_target, texture_mailbox_sync_point)),
1193       media::BindToCurrentLoop(base::Bind(&OnReleaseTexture,
1194                                           stream_texture_factory_,
1195                                           remote_playback_texture_id)),
1196       canvas_size /* coded_size */,
1197       gfx::Rect(canvas_size) /* visible_rect */,
1198       canvas_size /* natural_size */,
1199       base::TimeDelta() /* timestamp */,
1200       VideoFrame::ReadPixelsCB());
1201   SetCurrentFrameInternal(new_frame);
1202 }
1203 
ReallocateVideoFrame()1204 void WebMediaPlayerAndroid::ReallocateVideoFrame() {
1205   DCHECK(main_thread_checker_.CalledOnValidThread());
1206   if (needs_external_surface_) {
1207     // VideoFrame::CreateHoleFrame is only defined under VIDEO_HOLE.
1208 #if defined(VIDEO_HOLE)
1209     if (!natural_size_.isEmpty()) {
1210       scoped_refptr<VideoFrame> new_frame =
1211           VideoFrame::CreateHoleFrame(natural_size_);
1212       SetCurrentFrameInternal(new_frame);
1213       // Force the client to grab the hole frame.
1214       client_->repaint();
1215     }
1216 #else
1217     NOTIMPLEMENTED() << "Hole punching not supported without VIDEO_HOLE flag";
1218 #endif  // defined(VIDEO_HOLE)
1219   } else if (!is_remote_ && texture_id_) {
1220     GLES2Interface* gl = stream_texture_factory_->ContextGL();
1221     GLuint texture_target = kGLTextureExternalOES;
1222     GLuint texture_id_ref = gl->CreateAndConsumeTextureCHROMIUM(
1223         texture_target, texture_mailbox_.name);
1224     gl->Flush();
1225     GLuint texture_mailbox_sync_point = gl->InsertSyncPointCHROMIUM();
1226 
1227     scoped_refptr<VideoFrame> new_frame = VideoFrame::WrapNativeTexture(
1228         make_scoped_ptr(new gpu::MailboxHolder(
1229             texture_mailbox_, texture_target, texture_mailbox_sync_point)),
1230         media::BindToCurrentLoop(base::Bind(
1231             &OnReleaseTexture, stream_texture_factory_, texture_id_ref)),
1232         natural_size_,
1233         gfx::Rect(natural_size_),
1234         natural_size_,
1235         base::TimeDelta(),
1236         VideoFrame::ReadPixelsCB());
1237     SetCurrentFrameInternal(new_frame);
1238   }
1239 }
1240 
SetVideoFrameProviderClient(cc::VideoFrameProvider::Client * client)1241 void WebMediaPlayerAndroid::SetVideoFrameProviderClient(
1242     cc::VideoFrameProvider::Client* client) {
1243   // This is called from both the main renderer thread and the compositor
1244   // thread (when the main thread is blocked).
1245 
1246   // Set the callback target when a frame is produced. Need to do this before
1247   // StopUsingProvider to ensure we really stop using the client.
1248   if (stream_texture_proxy_)
1249     stream_texture_proxy_->BindToLoop(stream_id_, client, compositor_loop_);
1250 
1251   if (video_frame_provider_client_ && video_frame_provider_client_ != client)
1252     video_frame_provider_client_->StopUsingProvider();
1253   video_frame_provider_client_ = client;
1254 }
1255 
SetCurrentFrameInternal(scoped_refptr<media::VideoFrame> & video_frame)1256 void WebMediaPlayerAndroid::SetCurrentFrameInternal(
1257     scoped_refptr<media::VideoFrame>& video_frame) {
1258   DCHECK(main_thread_checker_.CalledOnValidThread());
1259   base::AutoLock auto_lock(current_frame_lock_);
1260   current_frame_ = video_frame;
1261 }
1262 
GetCurrentFrame()1263 scoped_refptr<media::VideoFrame> WebMediaPlayerAndroid::GetCurrentFrame() {
1264   scoped_refptr<VideoFrame> video_frame;
1265   {
1266     base::AutoLock auto_lock(current_frame_lock_);
1267     video_frame = current_frame_;
1268   }
1269 
1270   return video_frame;
1271 }
1272 
PutCurrentFrame(const scoped_refptr<media::VideoFrame> & frame)1273 void WebMediaPlayerAndroid::PutCurrentFrame(
1274     const scoped_refptr<media::VideoFrame>& frame) {
1275 }
1276 
ResetStreamTextureProxy()1277 void WebMediaPlayerAndroid::ResetStreamTextureProxy() {
1278   DCHECK(main_thread_checker_.CalledOnValidThread());
1279 
1280   if (stream_id_) {
1281     GLES2Interface* gl = stream_texture_factory_->ContextGL();
1282     gl->DeleteTextures(1, &texture_id_);
1283     texture_id_ = 0;
1284     texture_mailbox_ = gpu::Mailbox();
1285     stream_id_ = 0;
1286   }
1287   stream_texture_proxy_.reset();
1288   needs_establish_peer_ = !needs_external_surface_ && !is_remote_ &&
1289                           !player_manager_->IsInFullscreen(frame_) &&
1290                           (hasVideo() || IsHLSStream());
1291 
1292   TryCreateStreamTextureProxyIfNeeded();
1293   if (needs_establish_peer_ && is_playing_)
1294     EstablishSurfaceTexturePeer();
1295 }
1296 
TryCreateStreamTextureProxyIfNeeded()1297 void WebMediaPlayerAndroid::TryCreateStreamTextureProxyIfNeeded() {
1298   DCHECK(main_thread_checker_.CalledOnValidThread());
1299   // Already created.
1300   if (stream_texture_proxy_)
1301     return;
1302 
1303   // No factory to create proxy.
1304   if (!stream_texture_factory_)
1305     return;
1306 
1307   // Not needed for hole punching.
1308   if (!needs_establish_peer_)
1309     return;
1310 
1311   stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
1312   if (stream_texture_proxy_) {
1313     DoCreateStreamTexture();
1314     ReallocateVideoFrame();
1315     if (video_frame_provider_client_) {
1316       stream_texture_proxy_->BindToLoop(
1317           stream_id_, video_frame_provider_client_, compositor_loop_);
1318     }
1319   }
1320 }
1321 
EstablishSurfaceTexturePeer()1322 void WebMediaPlayerAndroid::EstablishSurfaceTexturePeer() {
1323   DCHECK(main_thread_checker_.CalledOnValidThread());
1324   if (!stream_texture_proxy_)
1325     return;
1326 
1327   if (stream_texture_factory_.get() && stream_id_)
1328     stream_texture_factory_->EstablishPeer(stream_id_, player_id_);
1329 
1330   // Set the deferred size because the size was changed in remote mode.
1331   if (!is_remote_ && cached_stream_texture_size_ != natural_size_) {
1332     stream_texture_factory_->SetStreamTextureSize(
1333         stream_id_, gfx::Size(natural_size_.width, natural_size_.height));
1334     cached_stream_texture_size_ = natural_size_;
1335   }
1336 
1337   needs_establish_peer_ = false;
1338 }
1339 
DoCreateStreamTexture()1340 void WebMediaPlayerAndroid::DoCreateStreamTexture() {
1341   DCHECK(main_thread_checker_.CalledOnValidThread());
1342   DCHECK(!stream_id_);
1343   DCHECK(!texture_id_);
1344   stream_id_ = stream_texture_factory_->CreateStreamTexture(
1345       kGLTextureExternalOES, &texture_id_, &texture_mailbox_);
1346 }
1347 
SetNeedsEstablishPeer(bool needs_establish_peer)1348 void WebMediaPlayerAndroid::SetNeedsEstablishPeer(bool needs_establish_peer) {
1349   needs_establish_peer_ = needs_establish_peer;
1350 }
1351 
setPoster(const blink::WebURL & poster)1352 void WebMediaPlayerAndroid::setPoster(const blink::WebURL& poster) {
1353   player_manager_->SetPoster(player_id_, poster);
1354 }
1355 
UpdatePlayingState(bool is_playing)1356 void WebMediaPlayerAndroid::UpdatePlayingState(bool is_playing) {
1357   if (is_playing == is_playing_)
1358     return;
1359 
1360   is_playing_ = is_playing;
1361 
1362   if (is_playing)
1363     interpolator_.StartInterpolating();
1364   else
1365     interpolator_.StopInterpolating();
1366 
1367   if (delegate_) {
1368     if (is_playing)
1369       delegate_->DidPlay(this);
1370     else
1371       delegate_->DidPause(this);
1372   }
1373 }
1374 
1375 #if defined(VIDEO_HOLE)
UpdateBoundaryRectangle()1376 bool WebMediaPlayerAndroid::UpdateBoundaryRectangle() {
1377   if (!video_weblayer_)
1378     return false;
1379 
1380   // Compute the geometry of video frame layer.
1381   cc::Layer* layer = video_weblayer_->layer();
1382   gfx::RectF rect(layer->bounds());
1383   while (layer) {
1384     rect.Offset(layer->position().OffsetFromOrigin());
1385     layer = layer->parent();
1386   }
1387 
1388   // Return false when the geometry hasn't been changed from the last time.
1389   if (last_computed_rect_ == rect)
1390     return false;
1391 
1392   // Store the changed geometry information when it is actually changed.
1393   last_computed_rect_ = rect;
1394   return true;
1395 }
1396 
GetBoundaryRectangle()1397 const gfx::RectF WebMediaPlayerAndroid::GetBoundaryRectangle() {
1398   return last_computed_rect_;
1399 }
1400 #endif
1401 
1402 // The following EME related code is copied from WebMediaPlayerImpl.
1403 // TODO(xhwang): Remove duplicate code between WebMediaPlayerAndroid and
1404 // WebMediaPlayerImpl.
1405 
1406 // Convert a WebString to ASCII, falling back on an empty string in the case
1407 // of a non-ASCII string.
ToASCIIOrEmpty(const blink::WebString & string)1408 static std::string ToASCIIOrEmpty(const blink::WebString& string) {
1409   return base::IsStringASCII(string) ? base::UTF16ToASCII(string)
1410                                      : std::string();
1411 }
1412 
1413 // Helper functions to report media EME related stats to UMA. They follow the
1414 // convention of more commonly used macros UMA_HISTOGRAM_ENUMERATION and
1415 // UMA_HISTOGRAM_COUNTS. The reason that we cannot use those macros directly is
1416 // that UMA_* macros require the names to be constant throughout the process'
1417 // lifetime.
1418 
EmeUMAHistogramEnumeration(const std::string & key_system,const std::string & method,int sample,int boundary_value)1419 static void EmeUMAHistogramEnumeration(const std::string& key_system,
1420                                        const std::string& method,
1421                                        int sample,
1422                                        int boundary_value) {
1423   base::LinearHistogram::FactoryGet(
1424       kMediaEme + KeySystemNameForUMA(key_system) + "." + method,
1425       1, boundary_value, boundary_value + 1,
1426       base::Histogram::kUmaTargetedHistogramFlag)->Add(sample);
1427 }
1428 
EmeUMAHistogramCounts(const std::string & key_system,const std::string & method,int sample)1429 static void EmeUMAHistogramCounts(const std::string& key_system,
1430                                   const std::string& method,
1431                                   int sample) {
1432   // Use the same parameters as UMA_HISTOGRAM_COUNTS.
1433   base::Histogram::FactoryGet(
1434       kMediaEme + KeySystemNameForUMA(key_system) + "." + method,
1435       1, 1000000, 50, base::Histogram::kUmaTargetedHistogramFlag)->Add(sample);
1436 }
1437 
1438 // Helper enum for reporting generateKeyRequest/addKey histograms.
1439 enum MediaKeyException {
1440   kUnknownResultId,
1441   kSuccess,
1442   kKeySystemNotSupported,
1443   kInvalidPlayerState,
1444   kMaxMediaKeyException
1445 };
1446 
MediaKeyExceptionForUMA(WebMediaPlayer::MediaKeyException e)1447 static MediaKeyException MediaKeyExceptionForUMA(
1448     WebMediaPlayer::MediaKeyException e) {
1449   switch (e) {
1450     case WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported:
1451       return kKeySystemNotSupported;
1452     case WebMediaPlayer::MediaKeyExceptionInvalidPlayerState:
1453       return kInvalidPlayerState;
1454     case WebMediaPlayer::MediaKeyExceptionNoError:
1455       return kSuccess;
1456     default:
1457       return kUnknownResultId;
1458   }
1459 }
1460 
1461 // Helper for converting |key_system| name and exception |e| to a pair of enum
1462 // values from above, for reporting to UMA.
ReportMediaKeyExceptionToUMA(const std::string & method,const std::string & key_system,WebMediaPlayer::MediaKeyException e)1463 static void ReportMediaKeyExceptionToUMA(const std::string& method,
1464                                          const std::string& key_system,
1465                                          WebMediaPlayer::MediaKeyException e) {
1466   MediaKeyException result_id = MediaKeyExceptionForUMA(e);
1467   DCHECK_NE(result_id, kUnknownResultId) << e;
1468   EmeUMAHistogramEnumeration(
1469       key_system, method, result_id, kMaxMediaKeyException);
1470 }
1471 
IsKeySystemSupported(const std::string & key_system)1472 bool WebMediaPlayerAndroid::IsKeySystemSupported(
1473     const std::string& key_system) {
1474   // On Android, EME only works with MSE.
1475   return player_type_ == MEDIA_PLAYER_TYPE_MEDIA_SOURCE &&
1476          IsConcreteSupportedKeySystem(key_system);
1477 }
1478 
generateKeyRequest(const WebString & key_system,const unsigned char * init_data,unsigned init_data_length)1479 WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::generateKeyRequest(
1480     const WebString& key_system,
1481     const unsigned char* init_data,
1482     unsigned init_data_length) {
1483   DVLOG(1) << "generateKeyRequest: " << base::string16(key_system) << ": "
1484            << std::string(reinterpret_cast<const char*>(init_data),
1485                           static_cast<size_t>(init_data_length));
1486 
1487   std::string ascii_key_system =
1488       GetUnprefixedKeySystemName(ToASCIIOrEmpty(key_system));
1489 
1490   WebMediaPlayer::MediaKeyException e =
1491       GenerateKeyRequestInternal(ascii_key_system, init_data, init_data_length);
1492   ReportMediaKeyExceptionToUMA("generateKeyRequest", ascii_key_system, e);
1493   return e;
1494 }
1495 
1496 // Guess the type of |init_data|. This is only used to handle some corner cases
1497 // so we keep it as simple as possible without breaking major use cases.
GuessInitDataType(const unsigned char * init_data,unsigned init_data_length)1498 static std::string GuessInitDataType(const unsigned char* init_data,
1499                                      unsigned init_data_length) {
1500   // Most WebM files use KeyId of 16 bytes. MP4 init data are always >16 bytes.
1501   if (init_data_length == 16)
1502     return "video/webm";
1503 
1504   return "video/mp4";
1505 }
1506 
1507 // TODO(xhwang): Report an error when there is encrypted stream but EME is
1508 // not enabled. Currently the player just doesn't start and waits for
1509 // ever.
1510 WebMediaPlayer::MediaKeyException
GenerateKeyRequestInternal(const std::string & key_system,const unsigned char * init_data,unsigned init_data_length)1511 WebMediaPlayerAndroid::GenerateKeyRequestInternal(
1512     const std::string& key_system,
1513     const unsigned char* init_data,
1514     unsigned init_data_length) {
1515   if (!IsKeySystemSupported(key_system))
1516     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
1517 
1518   // We do not support run-time switching between key systems for now.
1519   if (current_key_system_.empty()) {
1520     if (!proxy_decryptor_) {
1521       proxy_decryptor_.reset(new ProxyDecryptor(
1522           cdm_manager_,
1523           base::Bind(&WebMediaPlayerAndroid::OnKeyAdded,
1524                      weak_factory_.GetWeakPtr()),
1525           base::Bind(&WebMediaPlayerAndroid::OnKeyError,
1526                      weak_factory_.GetWeakPtr()),
1527           base::Bind(&WebMediaPlayerAndroid::OnKeyMessage,
1528                      weak_factory_.GetWeakPtr())));
1529     }
1530 
1531     GURL security_origin(frame_->document().securityOrigin().toString());
1532     if (!proxy_decryptor_->InitializeCDM(key_system, security_origin))
1533       return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
1534 
1535     if (!decryptor_ready_cb_.is_null()) {
1536       base::ResetAndReturn(&decryptor_ready_cb_)
1537           .Run(proxy_decryptor_->GetDecryptor(), base::Bind(DoNothing));
1538     }
1539 
1540     // Only browser CDMs have CDM ID. Render side CDMs (e.g. ClearKey CDM) do
1541     // not have a CDM ID and there is no need to call player_manager_->SetCdm().
1542     if (proxy_decryptor_->GetCdmId() != RendererCdmManager::kInvalidCdmId)
1543       player_manager_->SetCdm(player_id_, proxy_decryptor_->GetCdmId());
1544 
1545     current_key_system_ = key_system;
1546   } else if (key_system != current_key_system_) {
1547     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
1548   }
1549 
1550   std::string init_data_type = init_data_type_;
1551   if (init_data_type.empty())
1552     init_data_type = GuessInitDataType(init_data, init_data_length);
1553 
1554   // TODO(xhwang): We assume all streams are from the same container (thus have
1555   // the same "type") for now. In the future, the "type" should be passed down
1556   // from the application.
1557   if (!proxy_decryptor_->GenerateKeyRequest(
1558            init_data_type, init_data, init_data_length)) {
1559     current_key_system_.clear();
1560     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
1561   }
1562 
1563   return WebMediaPlayer::MediaKeyExceptionNoError;
1564 }
1565 
addKey(const WebString & key_system,const unsigned char * key,unsigned key_length,const unsigned char * init_data,unsigned init_data_length,const WebString & session_id)1566 WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::addKey(
1567     const WebString& key_system,
1568     const unsigned char* key,
1569     unsigned key_length,
1570     const unsigned char* init_data,
1571     unsigned init_data_length,
1572     const WebString& session_id) {
1573   DVLOG(1) << "addKey: " << base::string16(key_system) << ": "
1574            << std::string(reinterpret_cast<const char*>(key),
1575                           static_cast<size_t>(key_length)) << ", "
1576            << std::string(reinterpret_cast<const char*>(init_data),
1577                           static_cast<size_t>(init_data_length)) << " ["
1578            << base::string16(session_id) << "]";
1579 
1580   std::string ascii_key_system =
1581       GetUnprefixedKeySystemName(ToASCIIOrEmpty(key_system));
1582   std::string ascii_session_id = ToASCIIOrEmpty(session_id);
1583 
1584   WebMediaPlayer::MediaKeyException e = AddKeyInternal(ascii_key_system,
1585                                                        key,
1586                                                        key_length,
1587                                                        init_data,
1588                                                        init_data_length,
1589                                                        ascii_session_id);
1590   ReportMediaKeyExceptionToUMA("addKey", ascii_key_system, e);
1591   return e;
1592 }
1593 
AddKeyInternal(const std::string & key_system,const unsigned char * key,unsigned key_length,const unsigned char * init_data,unsigned init_data_length,const std::string & session_id)1594 WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::AddKeyInternal(
1595     const std::string& key_system,
1596     const unsigned char* key,
1597     unsigned key_length,
1598     const unsigned char* init_data,
1599     unsigned init_data_length,
1600     const std::string& session_id) {
1601   DCHECK(key);
1602   DCHECK_GT(key_length, 0u);
1603 
1604   if (!IsKeySystemSupported(key_system))
1605     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
1606 
1607   if (current_key_system_.empty() || key_system != current_key_system_)
1608     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
1609 
1610   proxy_decryptor_->AddKey(
1611       key, key_length, init_data, init_data_length, session_id);
1612   return WebMediaPlayer::MediaKeyExceptionNoError;
1613 }
1614 
cancelKeyRequest(const WebString & key_system,const WebString & session_id)1615 WebMediaPlayer::MediaKeyException WebMediaPlayerAndroid::cancelKeyRequest(
1616     const WebString& key_system,
1617     const WebString& session_id) {
1618   DVLOG(1) << "cancelKeyRequest: " << base::string16(key_system) << ": "
1619            << " [" << base::string16(session_id) << "]";
1620 
1621   std::string ascii_key_system =
1622       GetUnprefixedKeySystemName(ToASCIIOrEmpty(key_system));
1623   std::string ascii_session_id = ToASCIIOrEmpty(session_id);
1624 
1625   WebMediaPlayer::MediaKeyException e =
1626       CancelKeyRequestInternal(ascii_key_system, ascii_session_id);
1627   ReportMediaKeyExceptionToUMA("cancelKeyRequest", ascii_key_system, e);
1628   return e;
1629 }
1630 
1631 WebMediaPlayer::MediaKeyException
CancelKeyRequestInternal(const std::string & key_system,const std::string & session_id)1632 WebMediaPlayerAndroid::CancelKeyRequestInternal(const std::string& key_system,
1633                                                 const std::string& session_id) {
1634   if (!IsKeySystemSupported(key_system))
1635     return WebMediaPlayer::MediaKeyExceptionKeySystemNotSupported;
1636 
1637   if (current_key_system_.empty() || key_system != current_key_system_)
1638     return WebMediaPlayer::MediaKeyExceptionInvalidPlayerState;
1639 
1640   proxy_decryptor_->CancelKeyRequest(session_id);
1641   return WebMediaPlayer::MediaKeyExceptionNoError;
1642 }
1643 
setContentDecryptionModule(blink::WebContentDecryptionModule * cdm)1644 void WebMediaPlayerAndroid::setContentDecryptionModule(
1645     blink::WebContentDecryptionModule* cdm) {
1646   DCHECK(main_thread_checker_.CalledOnValidThread());
1647 
1648   // TODO(xhwang): Support setMediaKeys(0) if necessary: http://crbug.com/330324
1649   if (!cdm)
1650     return;
1651 
1652   web_cdm_ = ToWebContentDecryptionModuleImpl(cdm);
1653   if (!web_cdm_)
1654     return;
1655 
1656   if (!decryptor_ready_cb_.is_null()) {
1657     base::ResetAndReturn(&decryptor_ready_cb_)
1658         .Run(web_cdm_->GetDecryptor(), base::Bind(DoNothing));
1659   }
1660 
1661   if (web_cdm_->GetCdmId() != RendererCdmManager::kInvalidCdmId)
1662     player_manager_->SetCdm(player_id_, web_cdm_->GetCdmId());
1663 }
1664 
setContentDecryptionModule(blink::WebContentDecryptionModule * cdm,blink::WebContentDecryptionModuleResult result)1665 void WebMediaPlayerAndroid::setContentDecryptionModule(
1666     blink::WebContentDecryptionModule* cdm,
1667     blink::WebContentDecryptionModuleResult result) {
1668   DCHECK(main_thread_checker_.CalledOnValidThread());
1669 
1670   // TODO(xhwang): Support setMediaKeys(0) if necessary: http://crbug.com/330324
1671   if (!cdm) {
1672     result.completeWithError(
1673         blink::WebContentDecryptionModuleExceptionNotSupportedError,
1674         0,
1675         "Null MediaKeys object is not supported.");
1676     return;
1677   }
1678 
1679   web_cdm_ = ToWebContentDecryptionModuleImpl(cdm);
1680   DCHECK(web_cdm_);
1681 
1682   if (!decryptor_ready_cb_.is_null()) {
1683     base::ResetAndReturn(&decryptor_ready_cb_).Run(
1684         web_cdm_->GetDecryptor(),
1685         media::BindToCurrentLoop(
1686             base::Bind(&WebMediaPlayerAndroid::ContentDecryptionModuleAttached,
1687                        weak_factory_.GetWeakPtr(),
1688                        result)));
1689   } else {
1690     // No pipeline/decoder connected, so resolve the promise. When something
1691     // is connected, setting the CDM will happen in SetDecryptorReadyCB().
1692     ContentDecryptionModuleAttached(result, true);
1693   }
1694 
1695   if (web_cdm_->GetCdmId() != RendererCdmManager::kInvalidCdmId)
1696     player_manager_->SetCdm(player_id_, web_cdm_->GetCdmId());
1697 }
1698 
ContentDecryptionModuleAttached(blink::WebContentDecryptionModuleResult result,bool success)1699 void WebMediaPlayerAndroid::ContentDecryptionModuleAttached(
1700     blink::WebContentDecryptionModuleResult result,
1701     bool success) {
1702   if (success) {
1703     result.complete();
1704     return;
1705   }
1706 
1707   result.completeWithError(
1708       blink::WebContentDecryptionModuleExceptionNotSupportedError,
1709       0,
1710       "Unable to set MediaKeys object");
1711 }
1712 
OnKeyAdded(const std::string & session_id)1713 void WebMediaPlayerAndroid::OnKeyAdded(const std::string& session_id) {
1714   EmeUMAHistogramCounts(current_key_system_, "KeyAdded", 1);
1715 
1716   client_->keyAdded(
1717       WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
1718       WebString::fromUTF8(session_id));
1719 }
1720 
OnKeyError(const std::string & session_id,media::MediaKeys::KeyError error_code,uint32 system_code)1721 void WebMediaPlayerAndroid::OnKeyError(const std::string& session_id,
1722                                        media::MediaKeys::KeyError error_code,
1723                                        uint32 system_code) {
1724   EmeUMAHistogramEnumeration(current_key_system_, "KeyError",
1725                              error_code, media::MediaKeys::kMaxKeyError);
1726 
1727   unsigned short short_system_code = 0;
1728   if (system_code > std::numeric_limits<unsigned short>::max()) {
1729     LOG(WARNING) << "system_code exceeds unsigned short limit.";
1730     short_system_code = std::numeric_limits<unsigned short>::max();
1731   } else {
1732     short_system_code = static_cast<unsigned short>(system_code);
1733   }
1734 
1735   client_->keyError(
1736       WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
1737       WebString::fromUTF8(session_id),
1738       static_cast<blink::WebMediaPlayerClient::MediaKeyErrorCode>(error_code),
1739       short_system_code);
1740 }
1741 
OnKeyMessage(const std::string & session_id,const std::vector<uint8> & message,const GURL & destination_url)1742 void WebMediaPlayerAndroid::OnKeyMessage(const std::string& session_id,
1743                                          const std::vector<uint8>& message,
1744                                          const GURL& destination_url) {
1745   DCHECK(destination_url.is_empty() || destination_url.is_valid());
1746 
1747   client_->keyMessage(
1748       WebString::fromUTF8(GetPrefixedKeySystemName(current_key_system_)),
1749       WebString::fromUTF8(session_id),
1750       message.empty() ? NULL : &message[0],
1751       message.size(),
1752       destination_url);
1753 }
1754 
OnMediaSourceOpened(blink::WebMediaSource * web_media_source)1755 void WebMediaPlayerAndroid::OnMediaSourceOpened(
1756     blink::WebMediaSource* web_media_source) {
1757   client_->mediaSourceOpened(web_media_source);
1758 }
1759 
OnNeedKey(const std::string & type,const std::vector<uint8> & init_data)1760 void WebMediaPlayerAndroid::OnNeedKey(const std::string& type,
1761                                       const std::vector<uint8>& init_data) {
1762   DCHECK(main_thread_checker_.CalledOnValidThread());
1763 
1764   // Do not fire NeedKey event if encrypted media is not enabled.
1765   if (!blink::WebRuntimeFeatures::isPrefixedEncryptedMediaEnabled() &&
1766       !blink::WebRuntimeFeatures::isEncryptedMediaEnabled()) {
1767     return;
1768   }
1769 
1770   UMA_HISTOGRAM_COUNTS(kMediaEme + std::string("NeedKey"), 1);
1771 
1772   DCHECK(init_data_type_.empty() || type.empty() || type == init_data_type_);
1773   if (init_data_type_.empty())
1774     init_data_type_ = type;
1775 
1776   const uint8* init_data_ptr = init_data.empty() ? NULL : &init_data[0];
1777   client_->keyNeeded(
1778       WebString::fromUTF8(type), init_data_ptr, init_data.size());
1779 }
1780 
SetDecryptorReadyCB(const media::DecryptorReadyCB & decryptor_ready_cb)1781 void WebMediaPlayerAndroid::SetDecryptorReadyCB(
1782     const media::DecryptorReadyCB& decryptor_ready_cb) {
1783   DCHECK(main_thread_checker_.CalledOnValidThread());
1784 
1785   // Cancels the previous decryptor request.
1786   if (decryptor_ready_cb.is_null()) {
1787     if (!decryptor_ready_cb_.is_null()) {
1788       base::ResetAndReturn(&decryptor_ready_cb_)
1789           .Run(NULL, base::Bind(DoNothing));
1790     }
1791     return;
1792   }
1793 
1794   // TODO(xhwang): Support multiple decryptor notification request (e.g. from
1795   // video and audio). The current implementation is okay for the current
1796   // media pipeline since we initialize audio and video decoders in sequence.
1797   // But WebMediaPlayerImpl should not depend on media pipeline's implementation
1798   // detail.
1799   DCHECK(decryptor_ready_cb_.is_null());
1800 
1801   // Mixed use of prefixed and unprefixed EME APIs is disallowed by Blink.
1802   DCHECK(!proxy_decryptor_ || !web_cdm_);
1803 
1804   if (proxy_decryptor_) {
1805     decryptor_ready_cb.Run(proxy_decryptor_->GetDecryptor(),
1806                            base::Bind(DoNothing));
1807     return;
1808   }
1809 
1810   if (web_cdm_) {
1811     decryptor_ready_cb.Run(web_cdm_->GetDecryptor(), base::Bind(DoNothing));
1812     return;
1813   }
1814 
1815   decryptor_ready_cb_ = decryptor_ready_cb;
1816 }
1817 
enterFullscreen()1818 void WebMediaPlayerAndroid::enterFullscreen() {
1819   if (player_manager_->CanEnterFullscreen(frame_)) {
1820     player_manager_->EnterFullscreen(player_id_, frame_);
1821     SetNeedsEstablishPeer(false);
1822   }
1823 }
1824 
canEnterFullscreen() const1825 bool WebMediaPlayerAndroid::canEnterFullscreen() const {
1826   return player_manager_->CanEnterFullscreen(frame_);
1827 }
1828 
IsHLSStream() const1829 bool WebMediaPlayerAndroid::IsHLSStream() const {
1830   std::string mime;
1831   GURL url = redirected_url_.is_empty() ? url_ : redirected_url_;
1832   if (!net::GetMimeTypeFromFile(base::FilePath(url.path()), &mime))
1833     return false;
1834   return !mime.compare("application/x-mpegurl");
1835 }
1836 
1837 }  // namespace content
1838