Do not use overlays when VR shell is enabled.

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 229 matching lines @@
       use_fallback_path_(false),
       is_encrypted_(false),
       underflow_count_(0),
       observer_(params.media_observer()) {
   DCHECK(!adjust_allocated_memory_cb_.is_null());
   DCHECK(renderer_factory_);
   DCHECK(client_);
 
   tick_clock_.reset(new base::DefaultTickClock());
 
   force_video_overlays_ = base::CommandLine::ForCurrentProcess()->HasSwitch(

[ddorwin, 2016/12/15 01:23:52]

Even more so than base:Features, command line switches should not be accessed in
media/.

I filed https://bugs.chromium.org/p/chromium/issues/detail?id=674349 to switch
this one.

If we had all of this set in one place, we could use this being true to cause
enable_fullscreen_video_overlays_ to be set to true and ignore all other logic
for setting that value. That would allow us to simplify lines 348 and 355 and
maybe simplify the member description.

[amp, 2016/12/15 21:49:02]

Ack. It seems to operate slightly differently by creating the surface up front
(on line 1569 in the 'CreateRenderer' method) and then stops creating and
removing surface on lines 348 and 355.  I agree it is confusing and a few of my
patches probably break it (I think the latest few are fine).

So I'll leave cleaning up the flag to a future change.  :)

       switches::kForceVideoOverlays);
 
-  disable_fullscreen_video_overlays_ =
-      !base::FeatureList::IsEnabled(media::kOverlayFullscreenVideo);
+  enable_fullscreen_video_overlays_ =
+      base::FeatureList::IsEnabled(media::kOverlayFullscreenVideo);
 
   if (delegate_)
     delegate_id_ = delegate_->AddObserver(this);
 
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::WEBMEDIAPLAYER_CREATED));
 
   if (params.initial_cdm())
     SetCdm(params.initial_cdm());
 
@@ skipping 73 matching lines @@
   surface_created_cb_.Cancel();
   overlay_surface_id_ = SurfaceManager::kNoSurfaceID;
 
   if (decoder_requires_restart_for_overlay_)
     ScheduleRestart();
   else if (!set_surface_cb_.is_null())
     set_surface_cb_.Run(overlay_surface_id_);
 }
 
 void WebMediaPlayerImpl::enteredFullscreen() {
-  if (!force_video_overlays_ && !disable_fullscreen_video_overlays_)
+  if (!force_video_overlays_ && enable_fullscreen_video_overlays_)
     EnableOverlay();
   if (observer_)
     observer_->OnEnteredFullscreen();
 }
 
 void WebMediaPlayerImpl::exitedFullscreen() {
-  if (!force_video_overlays_ && !disable_fullscreen_video_overlays_)
+  if (!force_video_overlays_ && enable_fullscreen_video_overlays_)
     DisableOverlay();
   if (observer_)
     observer_->OnExitedFullscreen();
 }
 
 void WebMediaPlayerImpl::becameDominantVisibleContent(bool isDominant) {
   if (observer_)
     observer_->OnBecameDominantVisibleContent(isDominant);
 }
 
@@ skipping 1094 matching lines @@
   if (!video_weblayer_)
     return pipeline_metadata_.natural_size;
 
   return video_weblayer_->bounds();
 }
 
 void WebMediaPlayerImpl::SetDeviceScaleFactor(float scale_factor) {
   cast_impl_.SetDeviceScaleFactor(scale_factor);
 }
 
+void WebMediaPlayerImpl::SetEnableFullscreenOverlays(bool enable_overlays) {
+  enable_fullscreen_video_overlays_ = enable_overlays;
+}
+
 void WebMediaPlayerImpl::setPoster(const blink::WebURL& poster) {
   cast_impl_.setPoster(poster);
 }
 
 void WebMediaPlayerImpl::SetUseFallbackPath(bool use_fallback_path) {
   use_fallback_path_ = use_fallback_path;
 }
 #endif  // defined(OS_ANDROID)  // WMPI_CAST
 
 void WebMediaPlayerImpl::DataSourceInitialized(bool success) {
@@ skipping 79 matching lines @@
 
   // If we're waiting for the surface to arrive, OnSurfaceCreated() will be
   // called later when it arrives; so do nothing for now.
   if (overlay_enabled_ && overlay_surface_id_ == SurfaceManager::kNoSurfaceID)
     return;
 
   OnSurfaceCreated(overlay_surface_id_);
 }
 
 std::unique_ptr<Renderer> WebMediaPlayerImpl::CreateRenderer() {
   if (force_video_overlays_)

[ddorwin, 2016/12/15 01:23:52]

This is the only instance that is not related to
enable_fullscreen_video_overlays_.

[amp, 2016/12/15 21:49:02]

Yea, the EnableOverlay call will create a surface and get a callback with the
id.  The check here just does it at initialization and then makes sure no other
overlay methods are called again for the lifetime of WMPI so it can use the one
surface the whole time.

     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 400 matching lines @@
     watch_time_reporter_->OnShown();
 }
 
 bool WebMediaPlayerImpl::IsHidden() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return delegate_ && delegate_->IsHidden();
 }
 
 }  // namespace media