Add ui::LayerObserver and use it to update Alt+Tab previews as needed.

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 51 matching lines @@
       delegate_(NULL),
       owner_(NULL),
       cc_layer_(NULL),
       device_scale_factor_(1.0f),
       texture_x_scale_(1.0f),
       texture_y_scale_(1.0f) {
   CreateCcLayer();
 }
 
 Layer::~Layer() {
+  FOR_EACH_OBSERVER(LayerObserver, observer_list_, OnLayerDestroyed(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);
@@ skipping 32 matching lines @@
 }
 
 void Layer::ResetCompositor() {
   DCHECK(!parent_);
   if (compositor_) {
     ResetCompositorForAnimatorsInTree(compositor_);
     compositor_ = nullptr;
   }
 }
 
+void Layer::AddObserver(LayerObserver* observer) {
+  observer_list_.AddObserver(observer);
+}
+
+void Layer::RemoveObserver(LayerObserver* observer) {
+  observer_list_.RemoveObserver(observer);
+}
+
 void Layer::Add(Layer* child) {
   DCHECK(!child->compositor_);
   if (child->parent_)
     child->parent_->Remove(child);
   child->parent_ = this;
   children_.push_back(child);
   cc_layer_->AddChild(child->cc_layer_);
   child->OnDeviceScaleFactorChanged(device_scale_factor_);
   Compositor* compositor = GetCompositor();
   if (compositor)
@@ skipping 583 matching lines @@
     children_[i]->OnDeviceScaleFactorChanged(device_scale_factor);
   if (layer_mask_)
     layer_mask_->OnDeviceScaleFactorChanged(device_scale_factor);
 }
 
 void Layer::OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) {
   DCHECK(surface_layer_.get());
   if (!delegate_)
     return;
   delegate_->OnDelegatedFrameDamage(damage_rect_in_dip);
+
+  for (Layer* ancestor = this; ancestor; ancestor = ancestor->parent()) {

[sky, 2016/08/18 13:36:21]

I would like to avoid having to walk the tree on every delegatedframedamage.
CloneChildren() is iterating over the tree, can it handle the case of installing
an observer on every cloned layer? Seems like ForwardingLayerDelegate could
easily install an observer on the original layer. I think this would make
ForwardingLayerDelegate lookup of the delegate easier too (it wouldn't have to
validate).

It's not clear to me why OnDelegatedFrameDamage() means you need to recreate all
the layers. Could you motivate that better?

I'm also wondering if you make ForwardingLayerDelegate the LayerObserver that
perhaps you don't need to recreate all, or maybe you can just recreate the
subtree?

[Evan Stade, 2016/08/18 15:57:31]

This only walks up (as opposed to a full tree traversal); it's equivalent to
GetRoot(this).

It's true that we could make ForwardingLayerDelegate an observer and it might
simplify that class.
I'm using this as a pseudo-equivalent to View::ViewHierarchyChanged, except for
layers.

  // Notifies the layer that one of its children has received a new
  // delegated frame.
  void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip);

Admittedly I'm not 100% sure what a delegated frame is because I haven't found
any useful documentation ("[...]DelegatedFrameHost, which manages delegated
frames[...]"). In fact, walking up the entire callstack (SwapDelegatedFrame,
ViewHostMsg_SwapCompositorFrame, etc.) I have found essentially zero
documentation anywhere. So this is my best guess at what makes sense after
perusing the code.

OnDelegatedFrameDamage seems to only be called right after a ui::Layer gets a
new SurfaceLayer. At this point it makes sense that we need to recreate the
layers. In practice this doesn't seem to happen often (I've only seen it happen
soon after a renderer spins up).
You mean recreating just the subtree that got the notification? It seems like it
would complicate the code more than it's worth since I'm not sure how much it
would save. You have noted that it's expensive to recreate layers, but we only
do this for on-screen Alt+Tab previews (depending on display metrics, this is
probably only about 5 windows) and I haven't noticed any perceptible jankiness.

During my spelunking yesterday I did notice cc::Layer::RequestCopyOfOutput which
seems like it could be an alternative, except that I don't think it would allow
for live updates. I could be wrong.

+    FOR_EACH_OBSERVER(LayerObserver, ancestor->observer_list_,
+                      OnDelegatedFrameDamageInTree());
+  }
 }
 
 void Layer::SetScrollable(Layer* parent_clip_layer,
                           const base::Closure& on_scroll) {
   cc_layer_->SetScrollClipLayerId(parent_clip_layer->cc_layer_->id());
   cc_layer_->set_did_scroll_callback(on_scroll);
   cc_layer_->SetUserScrollable(true, true);
 }
 
 gfx::ScrollOffset Layer::CurrentScrollOffset() const {
@@ skipping 328 matching lines @@
   if (animator_) {
     animator_->ResetCompositor(compositor);
     animator_->RemoveFromCollection(collection);
   }
 
   for (auto* child : children_)
     child->ResetCompositorForAnimatorsInTree(compositor);
 }
 
 }  // namespace ui