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.

[oshima, 2016/10/04 21:06:31]

thanks for catching this. i believe this fixes the crash I noticed yesterday.

       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());
+    sync_bounds_ = false;
     layer_owner_ = ::wm::RecreateLayers(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, sync_bounds_);
+    sync_bounds_ = true;
     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 18 matching lines @@
   void OnWindowDestroying(aura::Window* window) override {
     DCHECK_EQ(drag_window_, window);
     drag_window_ = nullptr;
   }
 
   aura::Window* root_window_;
 
   aura::Window* drag_window_ = nullptr;  // Owned by the container.
 
   aura::Window* original_window_ = nullptr;
+  bool sync_bounds_;  // Used during cloning. True for all layers but the root.
 
   std::vector<std::unique_ptr<wm::ForwardingLayerDelegate>> delegates_;
 
   // The copy of window_->layer() and its descendants.
   std::unique_ptr<ui::LayerTreeOwner> layer_owner_;
 
   DISALLOW_COPY_AND_ASSIGN(DragWindowDetails);
 };
 
 // static
@@ skipping 72 matching lines @@
       layers.pop_back();
       if (layer->delegate())
         layer->delegate()->OnPaintLayer(context);
       for (auto* child : layer->children())
         layers.push_back(child);
     }
   }
 }
 
 }  // namespace ash