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

ui/wm/core/window_util_unittest.cc

 // Copyright 2014 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/wm/core/window_util.h"
 
 #include <memory>
 
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/test_windows.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/compositor/paint_context.h"
 
 namespace wm {
 namespace {
 
 // Used to check if the delegate for recreated layer is created for
 // the correct delegate.
 class TestLayerDelegate : public ui::LayerDelegate {
  public:
-  explicit TestLayerDelegate(ui::LayerDelegate* original_delegate)
-      : original_delegate_(original_delegate) {}
+  explicit TestLayerDelegate(ui::Layer* original_layer)
+      : original_layer_(original_layer) {}
   ~TestLayerDelegate() override = default;
 
   // ui::LayerDelegate:
   void OnPaintLayer(const ui::PaintContext& context) override {}
   void OnDelegatedFrameDamage(const gfx::Rect& damage_rect_in_dip) override {}
   void OnDeviceScaleFactorChanged(float device_scale_factor) override {}
   base::Closure PrepareForLayerBoundsChange() override {
     return base::Closure();
   }
 
-  ui::LayerDelegate* original_delegate() { return original_delegate_; }
+  ui::Layer* original_layer() { return original_layer_; }
 
  private:
-  ui::LayerDelegate* original_delegate_;
+  ui::Layer* original_layer_;
 
   DISALLOW_COPY_AND_ASSIGN(TestLayerDelegate);
 };
 
 // Used to create a TestLayerDelegate for recreated layers.
 class TestLayerDelegateFactory : public ::wm::LayerDelegateFactory {
  public:
   TestLayerDelegateFactory() = default;
   ~TestLayerDelegateFactory() override = default;
 
   // ::wm::LayerDelegateFactory:
-  ui::LayerDelegate* CreateDelegate(ui::LayerDelegate* delegate) override {
-    TestLayerDelegate* new_delegate = new TestLayerDelegate(delegate);
-    delegates_.push_back(base::WrapUnique(new_delegate));
-    return new_delegate;
+  ui::LayerDelegate* CreateDelegate(ui::Layer* new_layer,
+                                    ui::Layer* original_layer) override {
+    delegates_.push_back(base::MakeUnique<TestLayerDelegate>(original_layer));
+    return delegates_.back().get();
   }
 
   size_t delegate_count() const { return delegates_.size(); }
 
   TestLayerDelegate* GetDelegateAt(int index) {
     return delegates_[index].get();
   }
 
  private:
   std::vector<std::unique_ptr<TestLayerDelegate>> delegates_;
@@ skipping 53 matching lines @@
 
   std::unique_ptr<ui::LayerTreeOwner> tree =
       wm::RecreateLayers(window1.get(), &factory);
 
   ASSERT_EQ(3u, factory.delegate_count());
 
   TestLayerDelegate* new_delegate_1 = factory.GetDelegateAt(0);
   TestLayerDelegate* new_delegate_11 = factory.GetDelegateAt(1);
   TestLayerDelegate* new_delegate_12 = factory.GetDelegateAt(2);
 
-  EXPECT_EQ(window1->layer()->delegate(), new_delegate_1->original_delegate());
-  EXPECT_EQ(window11->layer()->delegate(),
-            new_delegate_11->original_delegate());
-  EXPECT_EQ(window12->layer()->delegate(),
-            new_delegate_12->original_delegate());
+  EXPECT_EQ(window1->layer(), new_delegate_1->original_layer());
+  EXPECT_EQ(window11->layer(),
+            new_delegate_11->original_layer());
+  EXPECT_EQ(window12->layer(),
+            new_delegate_12->original_layer());
 
   EXPECT_EQ(tree->root()->delegate(), new_delegate_1);
   EXPECT_EQ(tree->root()->children()[0]->delegate(), new_delegate_11);
   EXPECT_EQ(tree->root()->children()[1]->delegate(), new_delegate_12);
 }
 
 }  // namespace wm