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..7f3142000082fe801b605bd4e3f2678b9867c85e 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,34 @@ 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) {
+  // The layer recreation step isn't recursive, but layers with surfaces don't
+  // tend to have children anyway.

[sky, 2016/08/30 00:03:13]

I'm nervous about this DCHECK. It's seems entirely possible to hit it when
dragging browser windows across displays or other complex objects. I'm ok if you
want to punt on it, but I think this DHECK will hit, so it shouldn't be a
DCHECK.

+  DCHECK(layer->children().empty());
+
+  // This will delete the old layer.
+  ui::LayerOwner old_client;
+  old_client.SetLayer(client_layer_);
+
+  ui::LayerOwner* owner = layer->owner();
+  std::unique_ptr<ui::Layer> recreated = owner->RecreateLayer();
+  client_layer_ = recreated.get();
+  old_client.layer()->parent()->Add(recreated.release());
+  old_client.layer()->parent()->Remove(old_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