Generalize layer mirroring for phantom windows

ui/compositor/layer.cc

 // Copyright (c) 2012 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 "ui/compositor/layer.h"
 
 #include <algorithm>
 #include <memory>
 #include <utility>
 
@@ skipping 10 matching lines @@
 #include "cc/layers/texture_layer.h"
 #include "cc/output/copy_output_request.h"
 #include "cc/output/filter_operation.h"
 #include "cc/output/filter_operations.h"
 #include "cc/playback/display_item_list_settings.h"
 #include "cc/resources/transferable_resource.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "ui/compositor/compositor_switches.h"
 #include "ui/compositor/dip_util.h"
 #include "ui/compositor/layer_animator.h"
-#include "ui/compositor/layer_observer.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/gfx/animation/animation.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/point_conversions.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/interpolated_transform.h"
 
 namespace {
 
@@ skipping 47 matching lines @@
       zoom_(1),
       zoom_inset_(0),
       delegate_(NULL),
       owner_(NULL),
       cc_layer_(NULL),
       device_scale_factor_(1.0f) {
   CreateCcLayer();
 }
 
 Layer::~Layer() {
+  for (auto* mirror : mirrors_)
+    mirror->RemoveObserver(this);
+
   for (auto& observer : observer_list_)
     observer.LayerDestroyed(this);
 
   // Destroying the animator may cause observers to use the layer (and
   // indirectly the WebLayer). Destroy the animator first so that the WebLayer
   // is still around.
   SetAnimator(nullptr);
   if (compositor_)
     compositor_->SetRootLayer(NULL);
   if (parent_)
     parent_->Remove(this);
   if (layer_mask_)
     SetMaskLayer(NULL);
   if (layer_mask_back_link_)
     layer_mask_back_link_->SetMaskLayer(NULL);
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->parent_ = NULL;
 
   cc_layer_->RemoveFromParent();
   if (mailbox_release_callback_)
     mailbox_release_callback_->Run(gpu::SyncToken(), false);
 }
 
+std::unique_ptr<Layer> Layer::Clone() const {
+  auto clone = base::MakeUnique<Layer>(type_);
+
+  clone->SetVisible(GetTargetVisibility());
+  clone->SetOpacity(GetTargetOpacity());

[sky, 2016/10/14 22:36:37]

What about
int background_blur_radius_, satuations, brightness, grayscale, inverted, mask,
zoom...?

ALso, how about changing the name of the clone to be name_ + "clone" ?

[Dominik Laskowski, 2016/10/17 19:53:21]

This code was pulled from LayerOwner::RecreateLayer, so this subset was
apparently sufficient. Anyway, I've updated it to copy the remaining Layer
state. The cc::Layer content isn't copied for all layer types, but this patch is
only intended for surface mirroring, so I've added a cautionary comment for now.

Based on a quick code search, the convention is to delimit layer names with
colons, so I've changed the name accordingly.

+  clone->SetBounds(bounds_);
+  clone->SetMasksToBounds(GetMasksToBounds());
+  clone->set_name(name_);
+  clone->SetFillsBoundsOpaquely(fills_bounds_opaquely_);
+  clone->SetFillsBoundsCompletely(fills_bounds_completely_);
+  clone->SetSubpixelPositionOffset(subpixel_position_offset_);
+  clone->SetLayerInverted(layer_inverted_);
+  clone->SetTransform(GetTargetTransform());
+
+  if (type_ == LAYER_SOLID_COLOR)
+    clone->SetColor(GetTargetColor());
+  if (alpha_shape_)
+    clone->SetAlphaShape(base::MakeUnique<SkRegion>(*alpha_shape_));
+
+  if (surface_layer_ && !surface_layer_->surface_id().is_null()) {
+    clone->SetShowSurface(
+        surface_layer_->surface_id(),
+        surface_layer_->satisfy_callback(),
+        surface_layer_->require_callback(),
+        surface_layer_->surface_size(),
+        surface_layer_->surface_scale(),
+        frame_size_in_dip_);
+  }
+  return clone;
+}
+
 const Compositor* Layer::GetCompositor() const {
   return GetRoot(this)->compositor_;
 }
 
 float Layer::opacity() const {
   return cc_layer_->opacity();
 }
 
 void Layer::SetCompositor(Compositor* compositor,
                           scoped_refptr<cc::Layer> root_layer) {
@@ skipping 454 matching lines @@
 
   scoped_refptr<cc::SurfaceLayer> new_layer =
       cc::SurfaceLayer::Create(satisfy_callback, require_callback);
   new_layer->SetSurfaceId(surface_id, scale, surface_size);
   SwitchToLayer(new_layer);
   surface_layer_ = new_layer;
 
   frame_size_in_dip_ = frame_size_in_dip;
   RecomputeDrawsContentAndUVRect();
 
-  for (auto& observer : observer_list_)
-    observer.SurfaceChanged(this);
+  for (auto* mirror : mirrors_) {
+    mirror->SetShowSurface(surface_id, satisfy_callback, require_callback,
+                           surface_size, scale, frame_size_in_dip);
+  }
+}
+
+std::unique_ptr<Layer> Layer::Mirror() {
+  std::unique_ptr<Layer> mirror = Clone();
+  mirror->AddObserver(this);
+  mirrors_.push_back(mirror.get());
+  return mirror;
 }
 
 void Layer::SetShowSolidColorContent() {
   DCHECK_EQ(type_, LAYER_SOLID_COLOR);
 
   if (solid_color_layer_.get())
     return;
 
   scoped_refptr<cc::SolidColorLayer> new_layer = cc::SolidColorLayer::Create();
   SwitchToLayer(new_layer);
@@ skipping 36 matching lines @@
   nine_patch_layer_->SetBorder(border);
 }
 
 void Layer::UpdateNinePatchOcclusion(const gfx::Rect& occlusion) {
   DCHECK(type_ == LAYER_NINE_PATCH && nine_patch_layer_.get());
   nine_patch_layer_->SetLayerOcclusion(occlusion);
 }
 
 void Layer::SetColor(SkColor color) { GetAnimator()->SetColor(color); }
 
-SkColor Layer::GetTargetColor() {
-  if (GetAnimator()->IsAnimatingProperty(LayerAnimationElement::COLOR))
-    return GetAnimator()->GetTargetColor();
+SkColor Layer::GetTargetColor() const {
+  if (animator_.get() && animator_->IsAnimatingProperty(
+      LayerAnimationElement::COLOR))
+    return animator_->GetTargetColor();
   return cc_layer_->background_color();
 }
 
 SkColor Layer::background_color() const {
   return cc_layer_->background_color();
 }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   if ((type_ == LAYER_SOLID_COLOR && !texture_layer_.get()) ||
       type_ == LAYER_NINE_PATCH || (!delegate_ && !mailbox_.IsValid()))
@@ skipping 242 matching lines @@
 
   if (bounds.size() == old_bounds.size()) {
     // Don't schedule a draw if we're invisible. We'll schedule one
     // automatically when we get visible.
     if (IsDrawn())
       ScheduleDraw();
   } else {
     // Always schedule a paint, even if we're invisible.
     SchedulePaint(gfx::Rect(bounds.size()));
   }
+
+  if (sync_bounds_) {
+    for (auto* mirror : mirrors_)
+      mirror->SetBounds(bounds);
+  }
 }
 
 void Layer::SetTransformFromAnimation(const gfx::Transform& transform) {
   cc_layer_->SetTransform(transform);
 }
 
 void Layer::SetOpacityFromAnimation(float opacity) {
   cc_layer_->SetOpacity(opacity);
   ScheduleDraw();
 }
@@ skipping 69 matching lines @@
 
 cc::Layer* Layer::GetCcLayer() const {
   return cc_layer_;
 }
 
 LayerThreadedAnimationDelegate* Layer::GetThreadedAnimationDelegate() {
   DCHECK(animator_);
   return animator_.get();
 }
 
+void Layer::LayerDestroyed(Layer* mirror) {
+  const auto it = std::find(mirrors_.begin(), mirrors_.end(), mirror);
+  DCHECK(it != mirrors_.end());
+  mirrors_.erase(it);
+}
+
 void Layer::CreateCcLayer() {
   if (type_ == LAYER_SOLID_COLOR) {
     solid_color_layer_ = cc::SolidColorLayer::Create();
     cc_layer_ = solid_color_layer_.get();
   } else if (type_ == LAYER_NINE_PATCH) {
     nine_patch_layer_ = cc::NinePatchLayer::Create();
     cc_layer_ = nine_patch_layer_.get();
   } else {
     content_layer_ = cc::PictureLayer::Create(this);
     cc_layer_ = content_layer_.get();
@@ skipping 52 matching lines @@
   if (animator_) {
     animator_->DetachLayerAndTimeline(compositor);
     animator_->RemoveFromCollection(collection);
   }
 
   for (auto* child : children_)
     child->ResetCompositorForAnimatorsInTree(compositor);
 }
 
 }  // namespace ui