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

ui/wm/core/window_util.cc

 // Copyright (c) 2012 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 "ui/aura/window.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/wm/core/transient_window_manager.h"
@@ skipping 10 matching lines @@
                    wm::LayerDelegateFactory* factory) {
   typedef std::vector<ui::Layer*> Layers;
   // Make a copy of the children since RecreateLayer() mutates it.
   Layers children(to_clone->children());
   for (Layers::const_iterator i = children.begin(); i != children.end(); ++i) {
     ui::LayerOwner* owner = (*i)->owner();
     ui::Layer* old_layer = owner ? owner->RecreateLayer().release() : NULL;
     if (old_layer) {
       if (factory && owner->layer()->delegate())
         old_layer->set_delegate(
-            factory->CreateDelegate(owner->layer()->delegate()));
+            factory->CreateDelegate(old_layer, owner->layer()));
       parent->Add(old_layer);
       // RecreateLayer() moves the existing children to the new layer. Create a
       // copy of those.
       CloneChildren(owner->layer(), old_layer, factory);
     }
   }
 }
 
 }  // namespace
 
@@ skipping 42 matching lines @@
       aura::client::GetActivationClient(window->GetRootWindow());
   return client ? client->GetToplevelWindow(window) : NULL;
 }
 
 std::unique_ptr<ui::LayerTreeOwner> RecreateLayers(
     ui::LayerOwner* root,
     LayerDelegateFactory* factory) {
   std::unique_ptr<ui::LayerTreeOwner> old_layer(
       new ui::LayerTreeOwner(root->RecreateLayer().release()));
   if (old_layer->root()) {
-    if (factory) {

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

optional: personally I would leave the {} here as the body spans multiple lines.
But I realize the style guide is unclear on this.

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

oops, this was not intentional

+    if (factory)
       old_layer->root()->set_delegate(
-          factory->CreateDelegate(root->layer()->delegate()));
-    }
+          factory->CreateDelegate(old_layer->root(), root->layer()));
     CloneChildren(root->layer(), old_layer->root(), factory);
   }
   return old_layer;
 }
 
 aura::Window* GetTransientParent(aura::Window* window) {
   return const_cast<aura::Window*>(GetTransientParent(
                                  const_cast<const aura::Window*>(window)));
 }
 
@@ skipping 23 matching lines @@
 bool HasTransientAncestor(const aura::Window* window,
                           const aura::Window* ancestor) {
   const aura::Window* transient_parent = GetTransientParent(window);
   if (transient_parent == ancestor)
     return true;
   return transient_parent ?
       HasTransientAncestor(transient_parent, ancestor) : false;
 }
 
 }  // namespace wm