Change WebMediaPlayerMS layers transparency dynamically

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>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "build/build_config.h"
 #include "cc/blink/web_layer_impl.h"
 #include "cc/layers/video_frame_provider_client_impl.h"
 #include "cc/layers/video_layer.h"
 #include "content/common/gpu/client/context_provider_command_buffer.h"
 #include "content/public/renderer/media_stream_audio_renderer.h"
 #include "content/public/renderer/media_stream_renderer_factory.h"
 #include "content/public/renderer/media_stream_video_renderer.h"
 #include "content/renderer/media/web_media_element_source_utils.h"
 #include "content/renderer/media/webmediaplayer_ms_compositor.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_thread_impl.h"
 #include "media/base/media_log.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_rotation.h"
+#include "media/base/video_types.h"
 #include "media/blink/webmediaplayer_util.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerClient.h"
 #include "third_party/WebKit/public/platform/WebMediaPlayerSource.h"
 #include "third_party/WebKit/public/platform/WebRect.h"
 #include "third_party/WebKit/public/platform/WebSize.h"
 
 namespace content {
 
 WebMediaPlayerMS::WebMediaPlayerMS(
     blink::WebFrame* frame,
     blink::WebMediaPlayerClient* client,
     base::WeakPtr<media::WebMediaPlayerDelegate> delegate,
     media::MediaLog* media_log,
     std::unique_ptr<MediaStreamRendererFactory> factory,
     const scoped_refptr<base::SingleThreadTaskRunner>& compositor_task_runner,
     const scoped_refptr<base::SingleThreadTaskRunner>& media_task_runner,
     const scoped_refptr<base::TaskRunner>& worker_task_runner,
     media::GpuVideoAcceleratorFactories* gpu_factories,
     const blink::WebString& sink_id,
     const blink::WebSecurityOrigin& security_origin)
     : frame_(frame),
       network_state_(WebMediaPlayer::NetworkStateEmpty),
       ready_state_(WebMediaPlayer::ReadyStateHaveNothing),
       buffered_(static_cast<size_t>(0)),
       client_(client),
       delegate_(delegate),
       delegate_id_(0),
+      last_frame_opaque_(true),
       paused_(true),
       render_frame_suspended_(false),
       received_first_frame_(false),
       video_rotation_(media::VIDEO_ROTATION_0),
       media_log_(media_log),
       renderer_factory_(std::move(factory)),
       media_task_runner_(media_task_runner),
       worker_task_runner_(worker_task_runner),
       gpu_factories_(gpu_factories),
       compositor_task_runner_(compositor_task_runner),
@@ skipping 424 matching lines @@
     return;
 
   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());
 
   if (!received_first_frame_) {
     received_first_frame_ = true;
+    last_frame_opaque_ = is_opaque;
     SetReadyState(WebMediaPlayer::ReadyStateHaveMetadata);
     SetReadyState(WebMediaPlayer::ReadyStateHaveEnoughData);
 
     if (video_frame_provider_.get()) {
       ignore_result(frame->metadata()->GetRotation(
           media::VideoFrameMetadata::ROTATION, &video_rotation_));
 
       video_weblayer_.reset(new cc_blink::WebLayerImpl(
           cc::VideoLayer::Create(compositor_.get(), video_rotation_)));
-      video_weblayer_->layer()->SetContentsOpaque(false);
+      video_weblayer_->layer()->SetContentsOpaque(is_opaque);
       video_weblayer_->SetContentsOpaqueIsFixed(true);
       get_client()->setWebLayer(video_weblayer_.get());
     }
   }
 
+  // Only configure opacity on changes, since marking it as transparent is
+  // expensive, see https://crbug.com/647886.
+  if (video_weblayer_ && last_frame_opaque_ != is_opaque) {
+    last_frame_opaque_ = is_opaque;
+    video_weblayer_->layer()->SetContentsOpaque(is_opaque);
+  }
+
   compositor_->EnqueueFrame(frame);
 }
 
 void WebMediaPlayerMS::RepaintInternal() {
   DVLOG(1) << __func__;
   DCHECK(thread_checker_.CalledOnValidThread());
   get_client()->repaint();
 }
 
 void WebMediaPlayerMS::OnSourceError() {
@@ skipping 23 matching lines @@
 void WebMediaPlayerMS::ResetCanvasCache() {
   DCHECK(thread_checker_.CalledOnValidThread());
   video_renderer_.ResetCache();
 }
 
 void WebMediaPlayerMS::TriggerResize() {
   get_client()->sizeChanged();
 }
 
 }  // namespace content