Turn off video overlay on android for rotated video.

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 328 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_ && enable_fullscreen_video_overlays_)
+  // |force_video_overlays_| implies that we're already in overlay mode, so take
+  // no action here.  Otherwise, switch to an overlay if it's allowed and if
+  // it will display properly.
+  if (!force_video_overlays_ && enable_fullscreen_video_overlays_ &&
+      DoesOverlaySupportMetadata()) {
     EnableOverlay();
+  }
   if (observer_)
     observer_->OnEnteredFullscreen();
 }
 
 void WebMediaPlayerImpl::exitedFullscreen() {
-  if (!force_video_overlays_ && enable_fullscreen_video_overlays_)
+  // If we're in overlay mode, then exit it unless we're supposed to be in
+  // overlay mode all the time.
+  if (!force_video_overlays_ && overlay_enabled_)
     DisableOverlay();
   if (observer_)
     observer_->OnExitedFullscreen();
 }
 
 void WebMediaPlayerImpl::becameDominantVisibleContent(bool isDominant) {
   if (observer_)
     observer_->OnBecameDominantVisibleContent(isDominant);
 }
 
@@ skipping 781 matching lines @@
   pipeline_metadata_ = metadata;
 
   SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
   UMA_HISTOGRAM_ENUMERATION("Media.VideoRotation", metadata.video_rotation,
                             VIDEO_ROTATION_MAX + 1);
 
   if (hasVideo()) {
     pipeline_metadata_.natural_size = GetRotatedVideoSize(
         pipeline_metadata_.video_rotation, pipeline_metadata_.natural_size);
 
-    if (overlay_enabled_ && surface_manager_)
-      surface_manager_->NaturalSizeChanged(pipeline_metadata_.natural_size);
+    if (overlay_enabled_) {
+      // SurfaceView doesn't support rotated video, so transition back if
+      // the video is now rotated.  If |force_video_overlays_|, we keep the
+      // overlay anyway so that the state machine keeps working.
+      if (!force_video_overlays_ && !DoesOverlaySupportMetadata())
+        DisableOverlay();
+      else if (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());
   }
 
   if (observer_)
@@ skipping 834 matching lines @@
   else
     watch_time_reporter_->OnShown();
 }
 
 bool WebMediaPlayerImpl::IsHidden() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   return delegate_ && delegate_->IsHidden();
 }
 
+bool WebMediaPlayerImpl::DoesOverlaySupportMetadata() const {
+  return pipeline_metadata_.video_rotation == VIDEO_ROTATION_0;
+}
+
 void WebMediaPlayerImpl::ActivateViewportIntersectionMonitoring(bool activate) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
 
   client_->activateViewportIntersectionMonitoring(activate);
 }
 
 }  // namespace media