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) {
+  // 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
 }  // namespace ash