[Cast for ATV] Enable UMP on Cast for ATV

media/blink/webmediaplayer_impl.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 "media/blink/webmediaplayer_impl.h"
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <string>
@@ skipping 161 matching lines @@
           base::Bind(&WebMediaPlayerImpl::OnPipelineSuspended, AsWeakPtr()),
           base::Bind(&WebMediaPlayerImpl::OnError, AsWeakPtr())),
       load_type_(LoadTypeURL),
       opaque_(false),
       playback_rate_(0.0),
       paused_(true),
       seeking_(false),
       pending_suspend_resume_cycle_(false),
       ended_(false),
       should_notify_time_changed_(false),
-      fullscreen_(false),
-      decoder_requires_restart_for_fullscreen_(false),
+      overlay_enabled_(false),
+      decoder_requires_restart_for_overlay_(false),
       client_(client),
       encrypted_client_(encrypted_client),
       delegate_(delegate),
       delegate_id_(0),
       defer_load_cb_(params.defer_load_cb()),
       context_3d_cb_(params.context_3d_cb()),
       adjust_allocated_memory_cb_(params.adjust_allocated_memory_cb()),
       last_reported_memory_usage_(0),
       supports_save_(true),
       chunk_demuxer_(NULL),
       url_index_(url_index),
       // Threaded compositing isn't enabled universally yet.
       compositor_task_runner_(params.compositor_task_runner()
                                   ? params.compositor_task_runner()
                                   : base::ThreadTaskRunnerHandle::Get()),
       compositor_(new VideoFrameCompositor(compositor_task_runner_)),
       is_cdm_attached_(false),
 #if defined(OS_ANDROID)  // WMPI_CAST
       cast_impl_(this, client_, params.context_3d_cb()),
 #endif
       volume_(1.0),
       volume_multiplier_(1.0),
       renderer_factory_(std::move(renderer_factory)),
       surface_manager_(params.surface_manager()),
-      fullscreen_surface_id_(SurfaceManager::kNoSurfaceID),
+      overlay_surface_id_(SurfaceManager::kNoSurfaceID),
       suppress_destruction_errors_(false),
       can_suspend_state_(CanSuspendState::UNKNOWN) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
   DCHECK(client_);
 
+  force_video_overlays_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kForceVideoOverlays);
+
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   if (params.initial_cdm()) {
     SetCdm(base::Bind(&IgnoreCdmAttached),
            ToWebContentDecryptionModuleImpl(params.initial_cdm())
                ->GetCdmContext());
@@ skipping 51 matching lines @@
 }
 
 bool WebMediaPlayerImpl::supportsOverlayFullscreenVideo() {
 #if defined(OS_ANDROID)
   return true;
 #else
   return false;
 #endif
 }
 
-void WebMediaPlayerImpl::enteredFullscreen() {
-  fullscreen_ = true;
+void WebMediaPlayerImpl::EnableOverlay() {
+  overlay_enabled_ = true;
   if (surface_manager_) {
     surface_created_cb_.Reset(
         base::Bind(&WebMediaPlayerImpl::OnSurfaceCreated, AsWeakPtr()));
     surface_manager_->CreateFullscreenSurface(pipeline_metadata_.natural_size,
                                               surface_created_cb_.callback());
   }
-  if (decoder_requires_restart_for_fullscreen_)
+
+  if (decoder_requires_restart_for_overlay_)
     ScheduleRestart();
 }
 
+void WebMediaPlayerImpl::DisableOverlay() {
+  overlay_enabled_ = false;
+  surface_created_cb_.Cancel();
+  overlay_surface_id_ = SurfaceManager::kNoSurfaceID;
+
+  if (decoder_requires_restart_for_overlay_)
+    ScheduleRestart();
+}
+
+void WebMediaPlayerImpl::enteredFullscreen() {
+  if (!force_video_overlays_)
+    EnableOverlay();
+}
+
 void WebMediaPlayerImpl::exitedFullscreen() {
-  fullscreen_ = false;
-  surface_created_cb_.Cancel();
-  fullscreen_surface_id_ = SurfaceManager::kNoSurfaceID;
-  if (decoder_requires_restart_for_fullscreen_)
-    ScheduleRestart();
+  if (!force_video_overlays_)
+    DisableOverlay();
 }
 
 void WebMediaPlayerImpl::DoLoad(LoadType load_type,
                                 const blink::WebURL& url,
                                 CORSMode cors_mode) {
   DVLOG(1) << __FUNCTION__;
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   GURL gurl(url);
   ReportMetrics(load_type, gurl, frame_->getSecurityOrigin());
@@ skipping 691 matching lines @@
                             VIDEO_ROTATION_MAX + 1);
   SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
 
   if (hasVideo()) {
     if (pipeline_metadata_.video_rotation == VIDEO_ROTATION_90 ||
         pipeline_metadata_.video_rotation == VIDEO_ROTATION_270) {
       gfx::Size size = pipeline_metadata_.natural_size;
       pipeline_metadata_.natural_size = gfx::Size(size.height(), size.width());
     }
 
-    if (fullscreen_ && surface_manager_)
+    if (overlay_enabled_ && surface_manager_)
       surface_manager_->NaturalSizeChanged(pipeline_metadata_.natural_size);
 
     DCHECK(!video_weblayer_);
     video_weblayer_.reset(new cc_blink::WebLayerImpl(cc::VideoLayer::Create(
         compositor_, pipeline_metadata_.video_rotation)));
     video_weblayer_->layer()->SetContentsOpaque(opaque_);
     video_weblayer_->SetContentsOpaqueIsFixed(true);
     client_->setWebLayer(video_weblayer_.get());
   }
 
@@ skipping 85 matching lines @@
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
 
   if (size == pipeline_metadata_.natural_size)
     return;
 
   TRACE_EVENT0("media", "WebMediaPlayerImpl::OnNaturalSizeChanged");
   media_log_->AddEvent(
       media_log_->CreateVideoSizeSetEvent(size.width(), size.height()));
 
-  if (fullscreen_ && surface_manager_)
+  if (overlay_enabled_ && surface_manager_)
     surface_manager_->NaturalSizeChanged(size);
 
   pipeline_metadata_.natural_size = size;
   client_->sizeChanged();
 }
 
 void WebMediaPlayerImpl::OnVideoOpacityChange(bool opaque) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK_NE(ready_state_, WebMediaPlayer::ReadyStateHaveNothing);
 
@@ skipping 160 matching lines @@
     SetNetworkState(WebMediaPlayer::NetworkStateIdle);
   else if (is_downloading && network_state_ == WebMediaPlayer::NetworkStateIdle)
     SetNetworkState(WebMediaPlayer::NetworkStateLoading);
   media_log_->AddEvent(
       media_log_->CreateBooleanEvent(
           MediaLogEvent::NETWORK_ACTIVITY_SET,
           "is_downloading_data", is_downloading));
 }
 
 void WebMediaPlayerImpl::OnSurfaceCreated(int surface_id) {
-  fullscreen_surface_id_ = surface_id;
+  if (force_video_overlays_ && surface_id == SurfaceManager::kNoSurfaceID)
+    LOG(ERROR) << "Create surface failed.";
+
+  overlay_surface_id_ = surface_id;
   if (!pending_surface_request_cb_.is_null())
     base::ResetAndReturn(&pending_surface_request_cb_).Run(surface_id);
 }
 
 // TODO(watk): Move this state management out of WMPI.
 void WebMediaPlayerImpl::OnSurfaceRequested(
     const SurfaceCreatedCB& surface_created_cb) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(surface_manager_);
 
   // A null callback indicates that the decoder is going away.
   if (surface_created_cb.is_null()) {
-    decoder_requires_restart_for_fullscreen_ = false;
+    decoder_requires_restart_for_overlay_ = false;
     pending_surface_request_cb_.Reset();
     return;
   }
 
   // If we're getting a surface request it means GVD is initializing, so until
   // we get a null surface request, GVD is the active decoder. While that's the
   // case we should restart the pipeline on fullscreen transitions so that when
   // we create a new GVD it will request a surface again and get the right kind
   // of surface for the fullscreen state.
   // TODO(watk): Don't require a pipeline restart to switch surfaces for
   // cases where it isn't necessary.
-  decoder_requires_restart_for_fullscreen_ = true;
-  if (fullscreen_) {
-    if (fullscreen_surface_id_ != SurfaceManager::kNoSurfaceID)
-      surface_created_cb.Run(fullscreen_surface_id_);
+  decoder_requires_restart_for_overlay_ = true;
+  if (overlay_enabled_) {
+    if (overlay_surface_id_ != SurfaceManager::kNoSurfaceID)
+      surface_created_cb.Run(overlay_surface_id_);
     else
       pending_surface_request_cb_ = surface_created_cb;
   } else {
     // Tell the decoder to create its own surface.
     surface_created_cb.Run(SurfaceManager::kNoSurfaceID);
   }
 }
 
 std::unique_ptr<Renderer> WebMediaPlayerImpl::CreateRenderer() {
+  if (force_video_overlays_)
+    EnableOverlay();
+
   RequestSurfaceCB request_surface_cb;
 #if defined(OS_ANDROID)
   request_surface_cb =
       BIND_TO_RENDER_LOOP(&WebMediaPlayerImpl::OnSurfaceRequested);
 #endif
   return renderer_factory_->CreateRenderer(
       media_task_runner_, worker_task_runner_, audio_source_provider_.get(),
       compositor_, request_surface_cb);
 }
 
@@ skipping 270 matching lines @@
   //     correctly configure the session.
   //
   // TODO(sandersd): If Blink told us the paused state sooner, we could create
   // the media session sooner.
   bool can_play = !has_error && !is_remote && have_future_data;
   bool has_session = can_play && !must_suspend_ && !background_suspended;
 
   if (!has_session) {
     result.delegate_state = DelegateState::GONE;
   } else if (paused_) {
-    if (seeking() || fullscreen_) {
+    if (seeking() || overlay_enabled_) {
       result.delegate_state = DelegateState::PAUSED_BUT_NOT_IDLE;
     } else if (ended_) {
       result.delegate_state = DelegateState::ENDED;
     } else {
       result.delegate_state = DelegateState::PAUSED;
     }
   } else {
     result.delegate_state = DelegateState::PLAYING;
   }
 
@@ skipping 57 matching lines @@
   if (isRemote())
     return;
 #endif
 
   // Idle timeout chosen arbitrarily.
   background_pause_timer_.Start(FROM_HERE, base::TimeDelta::FromSeconds(5),
                                 this, &WebMediaPlayerImpl::OnPause);
 }
 
 }  // namespace media