Reset WebMediaPlayerMS video layer on rotation change

content/renderer/media/webmediaplayer_ms.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/webmediaplayer_ms.h"
 
 #include <stddef.h>
 #include <limits>
 #include <string>
 #include <utility>
@@ skipping 33 matching lines @@
 // It is created on the main thread, but methods should be called and class
 // should be destructed on the compositor thread.
 class WebMediaPlayerMS::FrameDeliverer {
  public:
   typedef base::Callback<void(scoped_refptr<media::VideoFrame>)>
       EnqueueFrameCallback;
 
   FrameDeliverer(const base::WeakPtr<WebMediaPlayerMS>& player,
                  const EnqueueFrameCallback& enqueue_frame_cb)
       : last_frame_opaque_(true),
+        last_frame_rotation_(media::VIDEO_ROTATION_0),
         received_first_frame_(false),
         main_task_runner_(base::ThreadTaskRunnerHandle::Get()),
         player_(player),
         enqueue_frame_cb_(enqueue_frame_cb),
         weak_factory_for_compositor_(this) {
     compositor_thread_checker_.DetachFromThread();
   }
 
   ~FrameDeliverer() {
     DCHECK(compositor_thread_checker_.CalledOnValidThread());
   }
 
   void OnVideoFrame(scoped_refptr<media::VideoFrame> frame) {
     DCHECK(compositor_thread_checker_.CalledOnValidThread());
 
 #if defined(OS_ANDROID)
     if (render_frame_suspended_)
       return;
 #endif  // defined(OS_ANDROID)
 
     base::TimeTicks render_time;
     if (frame->metadata()->GetTimeTicks(
             media::VideoFrameMetadata::REFERENCE_TIME, &render_time)) {
       TRACE_EVENT1("webrtc", "WebMediaPlayerMS::OnFrameAvailable",
                    "Ideal Render Instant", render_time.ToInternalValue());
     } else {
       TRACE_EVENT0("webrtc", "WebMediaPlayerMS::OnFrameAvailable");
     }
+
     const bool is_opaque = media::IsOpaque(frame->format());
+    media::VideoRotation video_rotation = media::VIDEO_ROTATION_0;
+    ignore_result(frame->metadata()->GetRotation(
+        media::VideoFrameMetadata::ROTATION, &video_rotation));
 
     if (!received_first_frame_) {
       received_first_frame_ = true;
       last_frame_opaque_ = is_opaque;
-      media::VideoRotation video_rotation = media::VIDEO_ROTATION_0;
-      ignore_result(frame->metadata()->GetRotation(
-          media::VideoFrameMetadata::ROTATION, &video_rotation));
+      last_frame_rotation_ = video_rotation;
       main_task_runner_->PostTask(
           FROM_HERE, base::Bind(&WebMediaPlayerMS::OnFirstFrameReceived,
                                 player_, video_rotation, is_opaque));
     }
 
     if (last_frame_opaque_ != is_opaque) {
       last_frame_opaque_ = is_opaque;
       main_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&WebMediaPlayerMS::OnOpacityChanged, player_, is_opaque));
     }
 
+    if (last_frame_rotation_ != video_rotation) {
+      last_frame_rotation_ = video_rotation;
+      main_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&WebMediaPlayerMS::OnRotationChanged, player_,
+                                video_rotation, is_opaque));
+    }
+
     enqueue_frame_cb_.Run(frame);
   }
 
 #if defined(OS_ANDROID)
   void SetRenderFrameSuspended(bool render_frame_suspended) {
     DCHECK(compositor_thread_checker_.CalledOnValidThread());
     render_frame_suspended_ = render_frame_suspended;
   }
 #endif  // defined(OS_ANDROID)
 
   MediaStreamVideoRenderer::RepaintCB GetRepaintCallback() {
     return base::Bind(&FrameDeliverer::OnVideoFrame,
                       weak_factory_for_compositor_.GetWeakPtr());
   }
 
  private:
   bool last_frame_opaque_;
+  media::VideoRotation last_frame_rotation_;
   bool received_first_frame_;
 
 #if defined(OS_ANDROID)
   bool render_frame_suspended_ = false;
 #endif  // defined(OS_ANDROID)
 
   const scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   const base::WeakPtr<WebMediaPlayerMS> player_;
   const EnqueueFrameCallback enqueue_frame_cb_;
 
@@ skipping 472 matching lines @@
 }
 
 void WebMediaPlayerMS::OnFirstFrameReceived(media::VideoRotation video_rotation,
                                             bool is_opaque) {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   video_rotation_ = video_rotation;
   SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
   SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
-  video_weblayer_.reset(new cc_blink::WebLayerImpl(
-      cc::VideoLayer::Create(compositor_.get(), video_rotation_)));
-  video_weblayer_->layer()->SetContentsOpaque(is_opaque);
-  video_weblayer_->SetContentsOpaqueIsFixed(true);
-  get_client()->setWebLayer(video_weblayer_.get());
+  ResetVideoLayer(video_rotation, is_opaque);
 }
 
 void WebMediaPlayerMS::OnOpacityChanged(bool is_opaque) {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   video_weblayer_->layer()->SetContentsOpaque(is_opaque);
 }
 
+void WebMediaPlayerMS::OnRotationChanged(media::VideoRotation video_rotation,
+                                         bool is_opaque) {
+  DVLOG(1) << __func__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+  video_rotation_ = video_rotation;
+
+  ResetVideoLayer(video_rotation, is_opaque);
+}
+
+void WebMediaPlayerMS::ResetVideoLayer(media::VideoRotation video_rotation,

[mcasas, 2016/11/29 01:04:31]

You could remove OnRotationChanged(), moving l.636 
  video_rotation_ = video_rotation;

to WebMediaPlayerMS::ResetVideoLayer(), and deleting 
it from l.618 (and adapting l.108 Task method of course).

WDYT?

[emircan, 2016/11/29 18:19:21]

Done. I was trying to be consistent with On*Changed observer pattern. However, I
dont have a strong feeling since |video_rotation_| is actually tied to
|video_weblayer_| lifetime. 

[mcasas, 2016/11/29 19:23:42]

Yeah, the names are misleading since they don't
actually listen to anything, they are just methods
to be posted to... maybe 
s/ResetVideoLayer/OnRotationChanged/ to keep 
the naming convention?

[emircan, 2016/11/29 19:48:25]

Done.

+                                       bool is_opaque) {
+  DVLOG(1) << __func__;
+  DCHECK(thread_checker_.CalledOnValidThread());
+
+  video_weblayer_.reset(new cc_blink::WebLayerImpl(
+      cc::VideoLayer::Create(compositor_.get(), video_rotation)));
+  video_weblayer_->layer()->SetContentsOpaque(is_opaque);
+  video_weblayer_->SetContentsOpaqueIsFixed(true);
+  get_client()->setWebLayer(video_weblayer_.get());
+}
+
 void WebMediaPlayerMS::RepaintInternal() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   get_client()->repaint();
 }
 
 void WebMediaPlayerMS::OnSourceError() {
   DCHECK(thread_checker_.CalledOnValidThread());
   SetNetworkState(WebMediaPlayer::NetworkStateFormatError);
   RepaintInternal();
@@ skipping 20 matching lines @@
 void WebMediaPlayerMS::ResetCanvasCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_.ResetCache();
 }
 
 void WebMediaPlayerMS::TriggerResize() {
   get_client()->sizeChanged();
 }
 
 }  // namespace content