Attach panel while dragging to bring it in front of other panels.

ash/wm/toplevel_window_event_handler.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/toplevel_window_event_handler.h"
 
 #include "ash/shell.h"
 #include "ash/wm/property_util.h"
 #include "ash/wm/resize_shadow_controller.h"
+#include "ash/wm/window_properties.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_util.h"
 #include "ash/wm/workspace/snap_sizer.h"
 #include "base/message_loop.h"
 #include "base/run_loop.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/env.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
@@ skipping 35 matching lines @@
 class ToplevelWindowEventHandler::ScopedWindowResizer
     : public aura::WindowObserver {
  public:
   ScopedWindowResizer(ToplevelWindowEventHandler* handler,
                       WindowResizer* resizer);
   virtual ~ScopedWindowResizer();
 
   WindowResizer* resizer() { return resizer_.get(); }
 
   // WindowObserver overrides:
+  virtual void OnWindowHierarchyChanging(
+      const HierarchyChangeParams& params) OVERRIDE;
   virtual void OnWindowPropertyChanged(aura::Window* window,
                                        const void* key,
                                        intptr_t old) OVERRIDE;
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
 
  private:
+  void AddHandlers(aura::Window* container);
+  void RemoveHandlers();
+
   ToplevelWindowEventHandler* handler_;
   scoped_ptr<WindowResizer> resizer_;
 
+  // If not NULL, this is an additional container that the dragged window has
+  // moved to which ScopedWindowResizer has temporarily added observers on.
+  aura::Window* target_container_;
+
   DISALLOW_COPY_AND_ASSIGN(ScopedWindowResizer);
 };
 
 ToplevelWindowEventHandler::ScopedWindowResizer::ScopedWindowResizer(
     ToplevelWindowEventHandler* handler,
     WindowResizer* resizer)
     : handler_(handler),
-      resizer_(resizer) {
+      resizer_(resizer),
+      target_container_(NULL) {
   if (resizer_.get())
     resizer_->GetTarget()->AddObserver(this);
 }
 
 ToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
+  RemoveHandlers();
   if (resizer_.get())
     resizer_->GetTarget()->RemoveObserver(this);
 }
 
+void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowHierarchyChanging(
+    const HierarchyChangeParams& params) {
+  if (params.receiver != resizer_->GetTarget())
+    return;
+
+  if (params.receiver->GetProperty(internal::kContinueDragAfterReparent)) {
+    params.receiver->SetProperty(internal::kContinueDragAfterReparent, false);
+    AddHandlers(params.new_parent);
+  } else {
+    handler_->CompleteDrag(DRAG_COMPLETE, 0);

[flackr, 2013/03/20 10:01:40]

If the new parent is also contained by handler_->owner() we could continue the
drag, but I don't think we rely on this for any current drag operations and
allowing that might just add confusion.

+  }
+}
+
 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowPropertyChanged(
     aura::Window* window,
     const void* key,
     intptr_t old) {
   if (!wm::IsWindowNormal(window))
     handler_->CompleteDrag(DRAG_COMPLETE, 0);
 }
 
 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowDestroying(
     aura::Window* window) {
   DCHECK(resizer_.get());
   DCHECK_EQ(resizer_->GetTarget(), window);
   handler_->ResizerWindowDestroyed();
 }
 
+void ToplevelWindowEventHandler::ScopedWindowResizer::AddHandlers(
+    aura::Window* container) {
+  RemoveHandlers();
+  if (!handler_->owner()->Contains(container)) {
+    container->AddPreTargetHandler(handler_);
+    container->AddPostTargetHandler(handler_);
+    target_container_ = container;
+  }
+}
+
+void ToplevelWindowEventHandler::ScopedWindowResizer::RemoveHandlers() {
+  if (target_container_) {
+    target_container_->RemovePreTargetHandler(handler_);
+    target_container_->RemovePostTargetHandler(handler_);
+    target_container_ = NULL;
+  }
+}
+
 
 // ToplevelWindowEventHandler --------------------------------------------------
 
 ToplevelWindowEventHandler::ToplevelWindowEventHandler(aura::Window* owner)
-    : in_move_loop_(false),
+    : owner_(owner),
+      in_move_loop_(false),
       move_cancelled_(false),
       in_gesture_drag_(false),
       destroyed_(NULL) {
   aura::client::SetWindowMoveClient(owner, this);
   Shell::GetInstance()->display_controller()->AddObserver(this);
   owner->AddPreTargetHandler(this);
   owner->AddPostTargetHandler(this);
 }
 
 ToplevelWindowEventHandler::~ToplevelWindowEventHandler() {
@@ skipping 335 matching lines @@
 void ToplevelWindowEventHandler::ResizerWindowDestroyed() {
   // We explicitly don't invoke RevertDrag() since that may do things to window.
   // Instead we destroy the resizer.
   window_resizer_.reset();
 
   // End the move loop. This does nothing if we're not in a move loop.
   EndMoveLoop();
 }
 
 }  // namespace ash