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

ash/common/wm/forwarding_layer_delegate.cc

 // Copyright 2016 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 "ash/common/wm/forwarding_layer_delegate.h"
 
 #include "ash/common/wm_window.h"
 #include "base/callback.h"
 #include "ui/compositor/layer.h"
+#include "ui/compositor/layer_owner.h"
 
 namespace ash {
 namespace wm {
 
-ForwardingLayerDelegate::ForwardingLayerDelegate(WmWindow* original_window,
-                                                 ui::LayerDelegate* delegate)
-    : original_window_(original_window), original_delegate_(delegate) {}
+ForwardingLayerDelegate::ForwardingLayerDelegate(ui::Layer* new_layer,
+                                                 ui::Layer* original_layer)
+    : client_layer_(new_layer),
+      original_layer_(original_layer),
+      scoped_observer_(this) {
+  scoped_observer_.Add(original_layer);
+}
 
 ForwardingLayerDelegate::~ForwardingLayerDelegate() {}
 
 void ForwardingLayerDelegate::OnPaintLayer(const ui::PaintContext& context) {
-  if (!original_delegate_)
-    return;
-  // |original_delegate_| may have already been deleted or
-  // disconnected by this time. Check if |original_delegate_| is still
-  // used by the original_window tree, or skip otherwise.
-  if (IsDelegateValid(original_window_->GetLayer()))
-    original_delegate_->OnPaintLayer(context);
-  else
-    original_delegate_ = nullptr;
+  if (original_layer_)
+    original_layer_->delegate()->OnPaintLayer(context);
 }
 
 void ForwardingLayerDelegate::OnDelegatedFrameDamage(
     const gfx::Rect& damage_rect_in_dip) {}
 
 void ForwardingLayerDelegate::OnDeviceScaleFactorChanged(
     float device_scale_factor) {
   // Don't tell the original delegate about device scale factor change
   // on cloned layer because the original layer is still on the same display.
 }
 
 base::Closure ForwardingLayerDelegate::PrepareForLayerBoundsChange() {
   return base::Closure();
 }
 
-bool ForwardingLayerDelegate::IsDelegateValid(ui::Layer* layer) const {
-  if (layer->delegate() == original_delegate_)
-    return true;
-  for (auto* child : layer->children()) {
-    if (IsDelegateValid(child))
-      return true;
-  }
-  return false;
+void ForwardingLayerDelegate::DidPaintLayer(ui::Layer* layer,
+                                            const gfx::Rect& rect) {
+  client_layer_->SchedulePaint(rect);
+}
+
+void ForwardingLayerDelegate::SurfaceChanged(ui::Layer* layer) {
+  ui::LayerOwner* owner = layer->owner();
+  std::unique_ptr<ui::Layer> recreated = owner->RecreateLayer();

[sky, 2016/08/23 17:15:07]

Don't you need to reset client_layer_ to recreated? When recreating the layer
shouldn't you also recreate any children?

[Evan Stade, 2016/08/29 23:51:54]

yes indeed.
good call. I think this works as is though because layers with surfaces don't
generally have children. I added a CHECK and tried to trigger it without
success, so instead of adding complexity to handle a case that doesn't seem to
come up, I just left a DCHECK. I think the worst case scenario if a surface
layer did have children would be a messed up preview (i.e. missing child
layers). 

Relatedly, there's nothing to keep the layer trees in sync, in case the base
window is adding or removing layers for example. Until it becomes apparent how
this is a practical problem, I'd just as soon not deal with it.

+  client_layer_->parent()->Add(recreated.release());
+  client_layer_->parent()->Remove(client_layer_);
+
+  // This will delete the old layer and all of its descendants.
+  ui::LayerOwner client_owner;
+  client_owner.SetLayer(client_layer_);
+
+  scoped_observer_.Remove(original_layer_);
+  original_layer_ = owner->layer();
+  scoped_observer_.Add(original_layer_);
+}
+
+void ForwardingLayerDelegate::LayerDestroyed(ui::Layer* layer) {
+  original_layer_ = nullptr;
+  scoped_observer_.Remove(layer);
 }
 
 }  // namespace wm
 }  // namespace ash