Dragging panels near screen edge

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"
@@ skipping 45 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(
+  virtual void OnWindowHierarchyChanged(

[varkha, 2013/06/20 04:09:22]

PTAL. I think this is a cleaner solution. This avoids reentrant calls to
AddChild and mean that CompleteDrag only gets called after the window has been
reparented. In our case it will get reparented by SetBounds to a container with
the same id ("Panel") in second root window and then in FinishDragging will get
reparented to workspace (because it is not attached). So it will end up in
workspace as we want it to be. Interestingly this does not break any tests - at
least in ash_unittests. I will try some more but I doubt we consciously designed
with that AddChild reentrancy in mind.

[flackr, 2013/06/20 13:08:45]

I had assumed this wouldn't work. When the window is added to the panel
container on the second display, that PanelLayoutManager should be notified that
it was added, and not knowing that the panel is being dragged would proceed to
move it over the panel icon. This doesn't happen?

I don't think this is the right thing to do, given that the WindowResizer code
doesn't know that the dragged panel has been reparented out from under it and
the state at the time it was reparented may have been some temporary state just
for the purposes of dragging.

       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();
 
@@ skipping 16 matching lines @@
   if (resizer_)
     resizer_->GetTarget()->AddObserver(this);
 }
 
 ToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
   RemoveHandlers();
   if (resizer_)
     resizer_->GetTarget()->RemoveObserver(this);
 }
 
-void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowHierarchyChanging(
+void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowHierarchyChanged(
     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);
   }
@@ skipping 390 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