Revert of [M55] 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"
+#include "ash/common/wm/forwarding_layer_delegate.h"
 #include "ash/display/window_tree_host_manager.h"
 #include "ash/screen_util.h"
 #include "ash/shell.h"
 #include "ash/wm/window_util.h"
 #include "base/memory/ptr_util.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_event_dispatcher.h"
 #include "ui/base/hit_test.h"
 #include "ui/compositor/layer.h"
 #include "ui/compositor/layer_tree_owner.h"
 #include "ui/compositor/paint_context.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 
 // This keeps track of the drag window's state. It creates/destroys/updates
 // bounds and opacity based on the current bounds.
-class DragWindowController::DragWindowDetails : public aura::WindowDelegate {
+class DragWindowController::DragWindowDetails
+    : public aura::WindowDelegate,
+      public ::wm::LayerDelegateFactory {
  public:
   DragWindowDetails(const display::Display& display,
                     aura::Window* original_window)
       : root_window_(Shell::GetInstance()
                          ->window_tree_host_manager()
                          ->GetRootWindowForDisplayId(display.id())) {}
 
   ~DragWindowDetails() override {
     delete drag_window_;
     DCHECK(!drag_window_);
@@ skipping 59 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::MirrorLayers(original_window, true /* sync_bounds */);
+    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 {
+    if (!layer || !layer->delegate())
+      return nullptr;
+    wm::ForwardingLayerDelegate* new_delegate =
+        new wm::ForwardingLayerDelegate(foo, 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 {
     return gfx::kNullCursor;
   }
   int GetNonClientComponent(const gfx::Point& point) const override {
     return HTNOWHERE;
   }
@@ skipping 14 matching lines @@
     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;
 
+  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
 float DragWindowController::GetDragWindowOpacity(
     const gfx::Rect& window_bounds,
     const gfx::Rect& visible_bounds) {
@@ skipping 69 matching lines @@
       layers.pop_back();
       if (layer->delegate())
         layer->delegate()->OnPaintLayer(context);
       for (auto* child : layer->children())
         layers.push_back(child);
     }
   }
 }
 
 }  // namespace ash