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

ash/common/wm/forwarding_layer_delegate.cc

Index: ash/common/wm/forwarding_layer_delegate.cc
diff --git a/ash/common/wm/forwarding_layer_delegate.cc b/ash/common/wm/forwarding_layer_delegate.cc
index 822fd675a1a16d9d2e836c752b509cd039d8dbf6..1225ffb7d68c1c66140db78304c548cc3e7b03f0 100644
--- a/ash/common/wm/forwarding_layer_delegate.cc
+++ b/ash/common/wm/forwarding_layer_delegate.cc
@@ -7,26 +7,24 @@
 #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(
@@ -42,14 +40,29 @@ 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