Generalize layer mirroring for phantom windows

ash/wm/drag_window_controller.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 "ash/wm/drag_window_controller.h"
 
 #include <algorithm>
 
 #include "ash/aura/wm_window_aura.h"
 #include "ash/common/shell_window_ids.h"
@@ skipping 40 matching lines @@
   void Update(aura::Window* original_window,
               const gfx::Rect& bounds_in_screen,
               const gfx::Point& drag_location_in_screen) {
     gfx::Rect root_bounds_in_screen = root_window_->GetBoundsInScreen();
     if (!root_bounds_in_screen.Intersects(bounds_in_screen)) {
       delete drag_window_;
       // Make sure drag_window_ is reset so that new drag window will be created
       // when it becomes necessary again.
       DCHECK(!drag_window_);
       layer_owner_.reset();
+      delegates_.clear();  // Stop observing layers.
       return;
     }
     if (!drag_window_)
       CreateDragWindow(original_window, bounds_in_screen);
 
     gfx::Rect bounds_in_root = ScreenUtil::ConvertRectFromScreen(
         drag_window_->parent(), bounds_in_screen);
     drag_window_->SetBounds(bounds_in_root);
     if (root_bounds_in_screen.Contains(drag_location_in_screen)) {
       SetOpacity(original_window, 1.f);
@@ skipping 37 matching lines @@
 
     // Fade the window in.
     ui::Layer* drag_layer = drag_window_->layer();
     drag_layer->SetOpacity(0);
     ui::ScopedLayerAnimationSettings scoped_setter(drag_layer->GetAnimator());
     drag_layer->SetOpacity(1);
   }
 
   void RecreateWindowLayers(aura::Window* original_window) {
     DCHECK(!layer_owner_.get());
-    layer_owner_ = ::wm::RecreateLayers(original_window, this);
+    layer_owner_ = ::wm::MirrorLayers(original_window, this);
     // Place the layer at (0, 0) of the DragWindowController's window.
     gfx::Rect layer_bounds = layer_owner_->root()->bounds();
     layer_bounds.set_origin(gfx::Point(0, 0));
     layer_owner_->root()->SetBounds(layer_bounds);
     layer_owner_->root()->SetVisible(false);
-    // Detach it from the current container.
-    layer_owner_->root()->parent()->Remove(layer_owner_->root());
   }
 
   void SetOpacity(const aura::Window* original_window, float opacity) {
     ui::Layer* layer = drag_window_->layer();
     ui::ScopedLayerAnimationSettings scoped_setter(layer->GetAnimator());
     layer->SetOpacity(opacity);
     layer_owner_->root()->SetOpacity(1.0f);
   }
 
-  // aura::WindowDelegate:
-  ui::LayerDelegate* CreateDelegate(ui::Layer* foo, ui::Layer* layer) override {
+  // wm::LayerDelegateFactory:
+  ui::LayerDelegate* CreateDelegate(ui::Layer* new_layer,
+                                    ui::Layer* layer) override {
     if (!layer || !layer->delegate())
       return nullptr;
     wm::ForwardingLayerDelegate* new_delegate =
-        new wm::ForwardingLayerDelegate(foo, layer);
+        new wm::ForwardingLayerDelegate(new_layer, layer);
     delegates_.push_back(base::WrapUnique(new_delegate));
     return new_delegate;
   }
 
   // aura::WindowDelegate:
   gfx::Size GetMinimumSize() const override { return gfx::Size(); }
   gfx::Size GetMaximumSize() const override { return gfx::Size(); }
   void OnBoundsChanged(const gfx::Rect& old_bounds,
                        const gfx::Rect& new_bounds) override {}
   gfx::NativeCursor GetCursor(const gfx::Point& point) override {
@@ skipping 110 matching lines @@
       layers.pop_back();
       if (layer->delegate())
         layer->delegate()->OnPaintLayer(context);
       for (auto* child : layer->children())
         layers.push_back(child);
     }
   }
 }
 
 }  // namespace ash