Fix autoplay during prerendering for media elements on Android.

content/renderer/media/android/webmediaplayer_android.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/renderer/media/android/webmediaplayer_android.h"
 
 #include <limits>
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
@@ skipping 136 matching lines @@
 
 namespace content {
 
 WebMediaPlayerAndroid::WebMediaPlayerAndroid(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     blink::WebMediaPlayerEncryptedMediaClient* encrypted_client,
     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
     RendererMediaPlayerManager* player_manager,
     media::CdmFactory* cdm_factory,
-    media::MediaPermission* media_permission,
-    blink::WebContentDecryptionModule* initial_cdm,
     scoped_refptr<StreamTextureFactory> factory,
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
-    media::MediaLog* media_log)
+    const media::WebMediaPlayerParams& params)
     : RenderFrameObserver(RenderFrame::FromWebFrame(frame)),
       frame_(frame),
       client_(client),
       encrypted_client_(encrypted_client),
       delegate_(delegate),
+      defer_load_cb_(params.defer_load_cb()),
       buffered_(static_cast<size_t>(1)),
-      media_task_runner_(task_runner),
+      media_task_runner_(params.media_task_runner()),
       ignore_metadata_duration_change_(false),
       pending_seek_(false),
       seeking_(false),
       did_loading_progress_(false),
       player_manager_(player_manager),
       cdm_factory_(cdm_factory),
-      media_permission_(media_permission),
+      media_permission_(params.media_permission()),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       texture_id_(0),
       stream_id_(0),
       is_player_initialized_(false),
       is_playing_(false),
       needs_establish_peer_(true),
       has_size_info_(false),
-      // Compositor thread does not exist in layout tests.
-      compositor_loop_(
-          RenderThreadImpl::current()->compositor_task_runner().get()
-              ? RenderThreadImpl::current()->compositor_task_runner()
+      // Threaded compositing isn't enabled universally yet.
+      compositor_task_runner_(
+          params.compositor_task_runner()
+              ? params.compositor_task_runner()
               : base::ThreadTaskRunnerHandle::Get()),
       stream_texture_factory_(factory),
       needs_external_surface_(false),
       is_fullscreen_(false),
       video_frame_provider_client_(NULL),
       player_type_(MEDIA_PLAYER_TYPE_URL),
       is_remote_(false),
-      media_log_(media_log),
+      media_log_(params.media_log()),
       init_data_type_(media::EmeInitDataType::UNKNOWN),
       cdm_context_(NULL),
       allow_stored_credentials_(false),
       is_local_resource_(false),
       interpolator_(&default_tick_clock_),
       weak_factory_(this) {
   DCHECK(player_manager_);
   DCHECK(cdm_factory_);
 
   DCHECK(main_thread_checker_.CalledOnValidThread());
@@ skipping 10 matching lines @@
   if (force_use_overlay_embedded_video_ ||
     player_manager_->ShouldUseVideoOverlayForEmbeddedEncryptedVideo()) {
     // Defer stream texture creation until we are sure it's necessary.
     needs_establish_peer_ = false;
     current_frame_ = VideoFrame::CreateBlackFrame(gfx::Size(1, 1));
   }
 #endif  // defined(VIDEO_HOLE)
   TryCreateStreamTextureProxyIfNeeded();
   interpolator_.SetUpperBound(base::TimeDelta());
 
-  if (initial_cdm) {
-    cdm_context_ =
-        media::ToWebContentDecryptionModuleImpl(initial_cdm)->GetCdmContext();
+  if (params.initial_cdm()) {
+    cdm_context_ = media::ToWebContentDecryptionModuleImpl(params.initial_cdm())
+                       ->GetCdmContext();
   }
 }
 
 WebMediaPlayerAndroid::~WebMediaPlayerAndroid() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   SetVideoFrameProviderClient(NULL);
   client_->setWebLayer(NULL);
 
   if (is_player_initialized_)
     player_manager_->DestroyPlayer(player_id_);
@@ skipping 27 matching lines @@
     base::WaitableEvent waiter(false, false);
     media_source_delegate_->Stop(
         base::Bind(&base::WaitableEvent::Signal, base::Unretained(&waiter)));
     waiter.Wait();
   }
 }
 
 void WebMediaPlayerAndroid::load(LoadType load_type,
                                  const blink::WebURL& url,
                                  CORSMode cors_mode) {
+  if (!defer_load_cb_.is_null()) {
+    defer_load_cb_.Run(base::Bind(&WebMediaPlayerAndroid::DoLoad,
+                                  weak_factory_.GetWeakPtr(), load_type, url,
+                                  cors_mode));
+    return;
+  }
+  DoLoad(load_type, url, cors_mode);
+}
+
+void WebMediaPlayerAndroid::DoLoad(LoadType load_type,
+                                   const blink::WebURL& url,
+                                   CORSMode cors_mode) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
 
   media::ReportMetrics(load_type, GURL(url),
                        GURL(frame_->document().securityOrigin().toString()));
 
   switch (load_type) {
     case LoadTypeURL:
       player_type_ = MEDIA_PLAYER_TYPE_URL;
       break;
 
@@ skipping 965 matching lines @@
   }
 }
 
 void WebMediaPlayerAndroid::SetVideoFrameProviderClient(
     cc::VideoFrameProvider::Client* client) {
   // This is called from both the main renderer thread and the compositor
   // thread (when the main thread is blocked).
 
   // Set the callback target when a frame is produced. Need to do this before
   // StopUsingProvider to ensure we really stop using the client.
-  if (stream_texture_proxy_)
-    stream_texture_proxy_->BindToLoop(stream_id_, client, compositor_loop_);
+  if (stream_texture_proxy_) {
+    stream_texture_proxy_->BindToLoop(stream_id_, client,
+                                      compositor_task_runner_);
+  }
 
   if (video_frame_provider_client_ && video_frame_provider_client_ != client)
     video_frame_provider_client_->StopUsingProvider();
   video_frame_provider_client_ = client;
 }
 
 void WebMediaPlayerAndroid::SetCurrentFrameInternal(
     scoped_refptr<media::VideoFrame>& video_frame) {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(current_frame_lock_);
@@ skipping 65 matching lines @@
   // Not needed for hole punching.
   if (!needs_establish_peer_)
     return;
 
   stream_texture_proxy_.reset(stream_texture_factory_->CreateProxy());
   if (stream_texture_proxy_) {
     DoCreateStreamTexture();
     ReallocateVideoFrame();
     if (video_frame_provider_client_) {
       stream_texture_proxy_->BindToLoop(
-          stream_id_, video_frame_provider_client_, compositor_loop_);
+          stream_id_, video_frame_provider_client_, compositor_task_runner_);
     }
   }
 }
 
 void WebMediaPlayerAndroid::EstablishSurfaceTexturePeer() {
   DCHECK(main_thread_checker_.CalledOnValidThread());
   if (!stream_texture_proxy_)
     return;
 
   if (stream_texture_factory_.get() && stream_id_)
@@ skipping 529 matching lines @@
 
   bool is_hls = IsHLSStream();
   UMA_HISTOGRAM_BOOLEAN("Media.Android.IsHttpLiveStreamingMedia", is_hls);
   if (is_hls) {
     media::RecordOriginOfHLSPlayback(
         GURL(frame_->document().securityOrigin().toString()));
   }
 }
 
 }  // namespace content