Generalize layer mirroring for phantom windows

ui/compositor/layer.h

 // 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.
 
 #ifndef UI_COMPOSITOR_LAYER_H_
 #define UI_COMPOSITOR_LAYER_H_
 
 #include <stddef.h>
 
 #include <memory>
@@ skipping 10 matching lines @@
 #include "cc/layers/layer_client.h"
 #include "cc/layers/surface_layer.h"
 #include "cc/layers/texture_layer_client.h"
 #include "cc/resources/texture_mailbox.h"
 #include "cc/surfaces/surface_id.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "third_party/skia/include/core/SkRegion.h"
 #include "ui/compositor/compositor.h"
 #include "ui/compositor/layer_animation_delegate.h"
 #include "ui/compositor/layer_delegate.h"
+#include "ui/compositor/layer_observer.h"
 #include "ui/compositor/layer_type.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/image/image_skia.h"
 #include "ui/gfx/transform.h"
 
 class SkCanvas;
 
 namespace cc {
 class ContentLayer;
 class CopyOutputRequest;
 class Layer;
 class NinePatchLayer;
 class ResourceUpdateQueue;
 class SolidColorLayer;
 class SurfaceLayer;
 class TextureLayer;
 struct ReturnedResource;
 typedef std::vector<ReturnedResource> ReturnedResourceArray;
 }
 
 namespace ui {
 
 class Compositor;
 class LayerAnimator;
-class LayerObserver;
 class LayerOwner;
 class LayerThreadedAnimationDelegate;
 
 // Layer manages a texture, transform and a set of child Layers. Any View that
 // has enabled layers ends up creating a Layer to manage the texture.
 // A Layer can also be created without a texture, in which case it renders
 // nothing and is simply used as a node in a hierarchy of layers.
 // Coordinate system used in layers is DIP (Density Independent Pixel)
 // coordinates unless explicitly mentioned as pixel coordinates.
 //
 // NOTE: Unlike Views, each Layer does *not* own its child Layers. If you
 // delete a Layer and it has children, the parent of each child Layer is set to
 // NULL, but the children are not deleted.
 class COMPOSITOR_EXPORT Layer
     : public LayerAnimationDelegate,
+      public LayerObserver,
       NON_EXPORTED_BASE(public cc::ContentLayerClient),
       NON_EXPORTED_BASE(public cc::TextureLayerClient),
       NON_EXPORTED_BASE(public cc::LayerClient) {
  public:
   Layer();
   explicit Layer(LayerType type);
+  explicit Layer(const Layer&);

[sky, 2016/10/13 19:21:33]

The style guide generally frowns on this, especially for such a complex type,
and it isn't really clear what is copied and what isn't. I think it better to
inline what you need in Mirror().

[Dominik Laskowski, 2016/10/13 22:19:39]

It's also called from LayerOwner::RecreateLayer. Would a Layer::Clone be
preferable?

[sky, 2016/10/14 15:18:41]

Yes please.

[Dominik Laskowski, 2016/10/14 19:15:02]

Done.

   ~Layer() override;
 
   // Retrieves the Layer's compositor. The Layer will walk up its parent chain
   // to locate it. Returns NULL if the Layer is not attached to a compositor.
   Compositor* GetCompositor() {
     return const_cast<Compositor*>(
         const_cast<const Layer*>(this)->GetCompositor());
   }
   const Compositor* GetCompositor() const;
 
@@ skipping 200 matching lines @@
   bool TextureFlipped() const;
 
   // Begins showing content from a surface with a particular id.
   void SetShowSurface(const cc::SurfaceId& surface_id,
                       const cc::SurfaceLayer::SatisfyCallback& satisfy_callback,
                       const cc::SurfaceLayer::RequireCallback& require_callback,
                       gfx::Size surface_size,
                       float scale,
                       gfx::Size frame_size_in_dip);
 
+  // Returns a new layer that mirrors this layer and is optionally synchronized
+  // with the bounds thereof. Note that children are not mirrored, and that the
+  // content is only mirrored if backed by a surface.
+  std::unique_ptr<Layer> Mirror();
+
+  void set_sync_bounds(bool sync_bounds) { sync_bounds_ = sync_bounds; }
+
   bool has_external_content() {
     return texture_layer_.get() || surface_layer_.get();
   }
 
   // Show a solid color instead of delegated or surface contents.
   void SetShowSolidColorContent();
 
   // Sets the layer's fill color.  May only be called for LAYER_SOLID_COLOR.
   void SetColor(SkColor color);
-  SkColor GetTargetColor();
+  SkColor GetTargetColor() const;
   SkColor background_color() const;
 
   // Updates the nine patch layer's image, aperture and border. May only be
   // called for LAYER_NINE_PATCH.
   void UpdateNinePatchLayerImage(const gfx::ImageSkia& image);
   void UpdateNinePatchLayerAperture(const gfx::Rect& aperture_in_dip);
   void UpdateNinePatchLayerBorder(const gfx::Rect& border);
   // Updates the area completely occluded by another layer, this can be an
   // empty rectangle if nothing is occluded.
   void UpdateNinePatchOcclusion(const gfx::Rect& occlusion);
@@ skipping 90 matching lines @@
   float GetOpacityForAnimation() const override;
   bool GetVisibilityForAnimation() const override;
   float GetBrightnessForAnimation() const override;
   float GetGrayscaleForAnimation() const override;
   SkColor GetColorForAnimation() const override;
   float GetDeviceScaleFactor() const override;
   cc::Layer* GetCcLayer() const override;
   LayerThreadedAnimationDelegate* GetThreadedAnimationDelegate() override;
   LayerAnimatorCollection* GetLayerAnimatorCollection() override;
 
+  // LayerObserver:
+  void LayerDestroyed(Layer* layer) override;
+
   // Creates a corresponding composited layer for |type_|.
   void CreateCcLayer();
 
   // Recomputes and sets to |cc_layer_|.
   void RecomputeDrawsContentAndUVRect();
   void RecomputePosition();
 
   // Set all filters which got applied to the layer.
   void SetLayerFilters();
 
   // Set all filters which got applied to the layer background.
   void SetLayerBackgroundFilters();
 
   // Cleanup |cc_layer_| and replaces it with |new_layer|.
   void SwitchToLayer(scoped_refptr<cc::Layer> new_layer);
 
   void SetCompositorForAnimatorsInTree(Compositor* compositor);
   void ResetCompositorForAnimatorsInTree(Compositor* compositor);
 
   const LayerType type_;
 
   Compositor* compositor_;
 
   Layer* parent_;
 
   // This layer's children, in bottom-to-top stacking order.
   std::vector<Layer*> children_;
 
+  std::vector<Layer*> mirrors_;  // Not owned.

[sky, 2016/10/13 19:21:33]

std::vector->std::set as you don't need the order.

[Dominik Laskowski, 2016/10/13 22:19:39]

I started with std::unordered_set, but figured std::vector is more appropriate
given that iteration is more frequent than removal/insertion and lookup isn't
needed.

[sky, 2016/10/14 15:18:41]

I like set to convey it's unordered, but ok.

+  bool sync_bounds_ = false;     // Synchronize bounds to mirrors.
+
   gfx::Rect bounds_;
   gfx::Vector2dF subpixel_position_offset_;
 
   // Visibility of this layer. See SetVisible/IsDrawn for more details.
   bool visible_;
 
   bool fills_bounds_opaquely_;
   bool fills_bounds_completely_;
 
   // Union of damaged rects, in layer space, that SetNeedsDisplayRect should
@@ skipping 61 matching lines @@
   cc::TextureMailbox mailbox_;
 
   // The callback to release the mailbox. This is only set after
   // SetTextureMailbox is called, before we give it to the TextureLayer.
   std::unique_ptr<cc::SingleReleaseCallback> mailbox_release_callback_;
 
   // The size of the frame or texture in DIP, set when SetShowDelegatedContent
   // or SetTextureMailbox was called.
   gfx::Size frame_size_in_dip_;
 
-  DISALLOW_COPY_AND_ASSIGN(Layer);
+  DISALLOW_ASSIGN(Layer);
 };
 
 }  // namespace ui
 
 #endif  // UI_COMPOSITOR_LAYER_H_