cc_blink: Remove ownership of cc::Layer from WebLayer.

This is a precursor to deleting WebLayer. It makes WebLayer hold a raw
cc::Layer* pointer, forcing each owner of a WebLayer to also own a
scoped_refptr<cc::Layer>. Then we can remove the unique_ptr<WebLayer>s
in the future.

R=pdr@chromium.org

Bug: 838693
Cq-Include-Trybots: luci.chromium.try:android_optional_gpu_tests_rel;master.tryserver.blink:linux_trusty_blink_rel
Change-Id: If0f3f68a4fb741acea33b81a1b468a6a3d0a93ad
Reviewed-on: https://chromium-review.googlesource.com/1054589Reviewed-by: Antoine Labour <piman@chromium.org>
Reviewed-by: Philip Rogers <pdr@chromium.org>
Reviewed-by: Xiaohan Wang <xhwang@chromium.org>
Commit-Queue: danakj <danakj@chromium.org>
Cr-Commit-Position: refs/heads/master@{#557948}

cc/blink/web_layer_impl.cc

@@ -36,9 +36,7 @@ using blink::WebLayer;
 
 namespace cc_blink {
 
-WebLayerImpl::WebLayerImpl() : layer_(Layer::Create()) {}
-
-WebLayerImpl::WebLayerImpl(scoped_refptr<Layer> layer) : layer_(layer) {}
+WebLayerImpl::WebLayerImpl(Layer* layer) : layer_(layer) {}
 
 WebLayerImpl::~WebLayerImpl() = default;
 
@@ -326,11 +324,11 @@ void WebLayerImpl::SetLayerClient(base::WeakPtr<cc::LayerClient> client) {
 }
 
 const cc::Layer* WebLayerImpl::CcLayer() const {
-  return layer_.get();
+  return layer_;
 }
 
 cc::Layer* WebLayerImpl::CcLayer() {
-  return layer_.get();
+  return layer_;
 }
 
 void WebLayerImpl::SetElementId(const cc::ElementId& id) {
@@ -352,7 +350,7 @@ void WebLayerImpl::SetClipParent(blink::WebLayer* parent) {
 }
 
 Layer* WebLayerImpl::layer() const {
-  return layer_.get();
+  return layer_;
 }
 
 void WebLayerImpl::SetHasWillChangeTransformHint(bool has_will_change) {

cc/blink/web_layer_impl.h

@@ -29,8 +29,7 @@ namespace cc_blink {
 
 class CC_BLINK_EXPORT WebLayerImpl : public blink::WebLayer {
  public:
-  WebLayerImpl();
-  explicit WebLayerImpl(scoped_refptr<cc::Layer>);
+  explicit WebLayerImpl(cc::Layer*);
   ~WebLayerImpl() override;
 
   cc::Layer* layer() const;
@@ -126,7 +125,7 @@ class CC_BLINK_EXPORT WebLayerImpl : public blink::WebLayer {
   void SetClipParent(blink::WebLayer* parent) override;
 
  protected:
-  scoped_refptr<cc::Layer> layer_;
+  cc::Layer* layer_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(WebLayerImpl);

content/renderer/browser_plugin/browser_plugin.cc

@@ -18,6 +18,7 @@
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "cc/blink/web_layer_impl.h"
 #include "components/viz/common/features.h"
 #include "components/viz/common/surfaces/surface_info.h"
 #include "content/common/browser_plugin/browser_plugin_constants.h"
@@ -860,11 +861,14 @@ blink::WebLayer* BrowserPlugin::GetLayer() {
   return web_layer_.get();
 }
 
-void BrowserPlugin::SetLayer(std::unique_ptr<blink::WebLayer> web_layer,
+void BrowserPlugin::SetLayer(scoped_refptr<cc::Layer> layer,
                              bool prevent_contents_opaque_changes) {
+  auto web_layer = std::make_unique<cc_blink::WebLayerImpl>(layer.get());
+
   if (container_) {
     container_->SetWebLayer(web_layer.get(), prevent_contents_opaque_changes);
   }
+  embedded_layer_ = std::move(layer);
   web_layer_ = std::move(web_layer);
 }
 

content/renderer/browser_plugin/browser_plugin.h

@@ -221,7 +221,7 @@ class CONTENT_EXPORT BrowserPlugin : public blink::WebPlugin,
 
   // ChildFrameCompositor:
   blink::WebLayer* GetLayer() override;
-  void SetLayer(std::unique_ptr<blink::WebLayer> web_layer,
+  void SetLayer(scoped_refptr<cc::Layer> layer,
                 bool prevent_contents_opaque_changes) override;
   SkBitmap* GetSadPageBitmap() override;
 
@@ -284,6 +284,7 @@ class CONTENT_EXPORT BrowserPlugin : public blink::WebPlugin,
   base::WeakPtr<RenderWidget> embedding_render_widget_;
 
   // The layer used to embed the out-of-process content.
+  scoped_refptr<cc::Layer> embedded_layer_;
   std::unique_ptr<blink::WebLayer> web_layer_;
 
   // Weak factory used in v8 |MakeWeak| callback, since the v8 callback might

content/renderer/child_frame_compositing_helper.cc

@@ -67,9 +67,8 @@ void ChildFrameCompositingHelper::ChildFrameGone(
   }
 
   bool prevent_contents_opaque_changes = false;
-  child_frame_compositor_->SetLayer(
-      std::make_unique<cc_blink::WebLayerImpl>(crashed_layer),
-      prevent_contents_opaque_changes);
+  child_frame_compositor_->SetLayer(std::move(crashed_layer),
+                                    prevent_contents_opaque_changes);
 }
 
 void ChildFrameCompositingHelper::SetPrimarySurfaceId(
@@ -89,18 +88,15 @@ void ChildFrameCompositingHelper::SetPrimarySurfaceId(
   surface_layer_->SetPrimarySurfaceId(surface_id, deadline);
   surface_layer_->SetFallbackSurfaceId(fallback_surface_id_);
 
-  auto layer_owned = std::make_unique<cc_blink::WebLayerImpl>(surface_layer_);
-  auto* layer = layer_owned.get();
-
   // TODO(lfg): Investigate if it's possible to propagate the information
   // about the child surface's opacity. https://crbug.com/629851.
   bool prevent_contents_opaque_changes = true;
-  child_frame_compositor_->SetLayer(std::move(layer_owned),
+  child_frame_compositor_->SetLayer(surface_layer_,
                                     prevent_contents_opaque_changes);
 
   UpdateVisibility(true);
 
-  layer->SetBounds(frame_size_in_dip);
+  surface_layer_->SetBounds(frame_size_in_dip);
 }
 
 void ChildFrameCompositingHelper::SetFallbackSurfaceId(

content/renderer/child_frame_compositing_helper_unittest.cc

@@ -22,14 +22,16 @@ class MockChildFrameCompositor : public ChildFrameCompositor {
 
   blink::WebLayer* GetLayer() override { return web_layer_.get(); }
 
-  void SetLayer(std::unique_ptr<blink::WebLayer> web_layer,
+  void SetLayer(scoped_refptr<cc::Layer> layer,
                 bool prevent_contents_opaque_changes) override {
-    web_layer_ = std::move(web_layer);
+    layer_ = std::move(layer);
+    web_layer_ = std::make_unique<cc_blink::WebLayerImpl>(layer_.get());
   }
 
   SkBitmap* GetSadPageBitmap() override { return &sad_page_bitmap_; }
 
  private:
+  scoped_refptr<cc::Layer> layer_;
   std::unique_ptr<blink::WebLayer> web_layer_;
   SkBitmap sad_page_bitmap_;
 

content/renderer/child_frame_compositor.h

@@ -9,17 +9,21 @@ namespace blink {
 class WebLayer;
 }  // namespace blink
 
+namespace cc {
+class Layer;
+}
+
 namespace content {
 
 // A ChildFrameCompositor is an owner of a blink::WebLayer that embeds a child
 // frame.
 class ChildFrameCompositor {
  public:
-  // Get the child frame's blink::WebLayer.
+  // Get the child frame's cc::Layer wrapped as a blink::WebLayer.
   virtual blink::WebLayer* GetLayer() = 0;
 
-  // Passes ownership of a blink::WebLayer to the ChildFrameCompositor.
-  virtual void SetLayer(std::unique_ptr<blink::WebLayer> web_layer,
+  // Passes ownership of a cc::Layer to the ChildFrameCompositor.
+  virtual void SetLayer(scoped_refptr<cc::Layer> layer,
                         bool prevent_contents_opaque_changes) = 0;
 
   // Returns a sad page bitmap used when the child frame has crashed.

content/renderer/media/stream/webmediaplayer_ms.cc

@@ -295,8 +295,8 @@ WebMediaPlayerMS::~WebMediaPlayerMS() {
 
   // Destruct compositor resources in the proper order.
   get_client()->SetWebLayer(nullptr);
-  if (video_weblayer_)
-    static_cast<cc::VideoLayer*>(video_weblayer_->layer())->StopUsingProvider();
+  if (video_layer_)
+    video_layer_->StopUsingProvider();
 
   if (frame_deliverer_)
     io_task_runner_->DeleteSoon(FROM_HERE, frame_deliverer_.release());
@@ -979,12 +979,12 @@ void WebMediaPlayerMS::OnRotationChanged(media::VideoRotation video_rotation,
   DCHECK(thread_checker_.CalledOnValidThread());
   video_rotation_ = video_rotation;
 
-  std::unique_ptr<cc_blink::WebLayerImpl> rotated_weblayer =
-      base::WrapUnique(new cc_blink::WebLayerImpl(
-          cc::VideoLayer::Create(compositor_.get(), video_rotation)));
-  rotated_weblayer->SetOpaque(is_opaque);
-  get_client()->SetWebLayer(rotated_weblayer.get());
-  video_weblayer_ = std::move(rotated_weblayer);
+  video_layer_ = cc::VideoLayer::Create(compositor_.get(), video_rotation);
+  video_layer_->SetContentsOpaque(is_opaque);
+
+  video_weblayer_ =
+      std::make_unique<cc_blink::WebLayerImpl>(video_layer_.get());
+  get_client()->SetWebLayer(video_weblayer_.get());
 }
 
 void WebMediaPlayerMS::RepaintInternal() {

content/renderer/media/stream/webmediaplayer_ms.h

@@ -33,6 +33,10 @@ class GpuMemoryBufferVideoFramePool;
 class MediaLog;
 }
 
+namespace cc {
+class VideoLayer;
+}
+
 namespace cc_blink {
 class WebLayerImpl;
 }
@@ -259,6 +263,7 @@ class CONTENT_EXPORT WebMediaPlayerMS
 
   scoped_refptr<MediaStreamVideoRenderer> video_frame_provider_;  // Weak
 
+  scoped_refptr<cc::VideoLayer> video_layer_;
   std::unique_ptr<cc_blink::WebLayerImpl> video_weblayer_;
 
   scoped_refptr<MediaStreamAudioRenderer> audio_renderer_;  // Weak

content/renderer/pepper/pepper_plugin_instance_impl.cc

@@ -2236,16 +2236,16 @@ void PepperPluginInstanceImpl::UpdateLayer(bool force_creation) {
       texture_layer_->SetFlipped(false);
     }
 
-    auto layer = std::make_unique<cc_blink::WebLayerImpl>(texture_layer_);
     // Ignore transparency in fullscreen, since that's what Flash always
     // wants to do, and that lets it not recreate a context if
     // wmode=transparent was specified.
     opaque = opaque || fullscreen_container_;
-    layer->SetOpaque(opaque);
-    web_layer_ = std::move(layer);
+    texture_layer_->SetContentsOpaque(opaque);
+    web_layer_ = std::make_unique<cc_blink::WebLayerImpl>(texture_layer_.get());
   } else if (want_compositor_layer) {
     compositor_layer_ = bound_compositor_->layer();
-    web_layer_ = std::make_unique<cc_blink::WebLayerImpl>(compositor_layer_);
+    web_layer_ =
+        std::make_unique<cc_blink::WebLayerImpl>(compositor_layer_.get());
   }
 
   if (web_layer_) {

content/renderer/render_frame_proxy.cc

@@ -10,6 +10,7 @@
 
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
+#include "cc/blink/web_layer_impl.h"
 #include "components/viz/common/features.h"
 #include "content/common/content_switches_internal.h"
 #include "content/common/frame_message_structs.h"
@@ -868,10 +869,12 @@ blink::WebLayer* RenderFrameProxy::GetLayer() {
   return web_layer_.get();
 }
 
-void RenderFrameProxy::SetLayer(std::unique_ptr<blink::WebLayer> web_layer,
+void RenderFrameProxy::SetLayer(scoped_refptr<cc::Layer> layer,
                                 bool prevent_contents_opaque_changes) {
+  auto web_layer = std::make_unique<cc_blink::WebLayerImpl>(layer.get());
   if (web_frame())
     web_frame()->SetWebLayer(web_layer.get(), prevent_contents_opaque_changes);
+  embedded_layer_ = std::move(layer);
   web_layer_ = std::move(web_layer);
 }
 

content/renderer/render_frame_proxy.h

@@ -265,7 +265,7 @@ class CONTENT_EXPORT RenderFrameProxy : public IPC::Listener,
 
   // ChildFrameCompositor:
   blink::WebLayer* GetLayer() override;
-  void SetLayer(std::unique_ptr<blink::WebLayer> web_layer,
+  void SetLayer(scoped_refptr<cc::Layer> layer,
                 bool prevent_contents_opaque_changes) override;
   SkBitmap* GetSadPageBitmap() override;
 
@@ -316,6 +316,7 @@ class CONTENT_EXPORT RenderFrameProxy : public IPC::Listener,
 #endif
 
   // The layer used to embed the out-of-process content.
+  scoped_refptr<cc::Layer> embedded_layer_;
   std::unique_ptr<blink::WebLayer> web_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameProxy);

content/shell/test_runner/test_plugin.cc

@@ -187,7 +187,7 @@ bool TestPlugin::Initialize(blink::WebPluginContainer* container) {
     return false;
 
   layer_ = cc::TextureLayer::CreateForMailbox(this);
-  web_layer_ = std::make_unique<cc_blink::WebLayerImpl>(layer_);
+  web_layer_ = std::make_unique<cc_blink::WebLayerImpl>(layer_.get());
   bool prevent_contents_opaque_changes = false;
   container_->SetWebLayer(web_layer_.get(), prevent_contents_opaque_changes);
   if (re_request_touch_events_) {

media/blink/webmediaplayer_impl.cc

@@ -320,8 +320,8 @@ WebMediaPlayerImpl::~WebMediaPlayerImpl() {
 
   ExitPictureInPicture(base::DoNothing());
 
-  if (!surface_layer_for_video_enabled_ && video_weblayer_) {
-    static_cast<cc::VideoLayer*>(video_weblayer_->layer())->StopUsingProvider();
+  if (!surface_layer_for_video_enabled_ && video_layer_) {
+    video_layer_->StopUsingProvider();
   }
 
   vfc_task_runner_->DeleteSoon(FROM_HERE, std::move(compositor_));
@@ -1610,9 +1610,11 @@ void WebMediaPlayerImpl::OnMetadata(PipelineMetadata metadata) {
 
     if (!surface_layer_for_video_enabled_) {
       DCHECK(!video_weblayer_);
-      video_weblayer_.reset(new cc_blink::WebLayerImpl(cc::VideoLayer::Create(
+      video_layer_ = cc::VideoLayer::Create(
           compositor_.get(),
-          pipeline_metadata_.video_decoder_config.video_rotation())));
+          pipeline_metadata_.video_decoder_config.video_rotation());
+      video_weblayer_ =
+          std::make_unique<cc_blink::WebLayerImpl>(video_layer_.get());
       video_weblayer_->SetOpaque(opaque_);
       client_->SetWebLayer(video_weblayer_.get());
     } else {

media/blink/webmediaplayer_impl.h

@@ -63,6 +63,10 @@ class SingleThreadTaskRunner;
 class TaskRunner;
 }
 
+namespace cc {
+class VideoLayer;
+}
+
 namespace cc_blink {
 class WebLayerImpl;
 }
@@ -714,6 +718,7 @@ class MEDIA_BLINK_EXPORT WebMediaPlayerImpl
 
   // The compositor layer for displaying the video content when using composited
   // playback.
+  scoped_refptr<cc::VideoLayer> video_layer_;
   std::unique_ptr<cc_blink::WebLayerImpl> video_weblayer_;
 
   std::unique_ptr<blink::WebContentDecryptionModuleResult> set_cdm_result_;

media/blink/webmediaplayer_impl_unittest.cc

@@ -1316,13 +1316,13 @@ TEST_F(WebMediaPlayerImplTest, SetContentsLayerGetsWebLayerFromBridge) {
 
   InitializeWebMediaPlayerImpl();
 
+  scoped_refptr<cc::Layer> layer = cc::Layer::Create();
   std::unique_ptr<cc_blink::WebLayerImpl> web_layer =
-      std::make_unique<cc_blink::WebLayerImpl>();
-  cc_blink::WebLayerImpl* web_layer_ptr = web_layer.get();
+      std::make_unique<cc_blink::WebLayerImpl>(layer.get());
 
   EXPECT_CALL(*surface_layer_bridge_ptr_, GetWebLayer())
-      .WillRepeatedly(Return(web_layer_ptr));
-  EXPECT_CALL(client_, SetWebLayer(Eq(web_layer_ptr)));
+      .WillRepeatedly(Return(web_layer.get()));
+  EXPECT_CALL(client_, SetWebLayer(Eq(web_layer.get())));
   wmpi_->RegisterContentsLayer(web_layer.get());
 }