Use a single ToplevelWindowEventHandler for the ash::Shell

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/resize_shadow_controller.h"
 #include "ash/wm/window_resizer.h"
 #include "ash/wm/window_state.h"
@@ skipping 54 matching lines @@
   // WindowObserver overrides:
   virtual void OnWindowHierarchyChanging(
       const HierarchyChangeParams& params) OVERRIDE;
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE;
 
   // WindowStateObserver overrides:
   virtual void OnWindowShowTypeChanged(wm::WindowState* window_state,
                                        wm::WindowShowType type) 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),
       target_container_(NULL) {
   if (resizer_) {
     resizer_->GetTarget()->AddObserver(this);
     wm::GetWindowState(resizer_->GetTarget())->AddObserver(this);
   }
 }
 
 ToplevelWindowEventHandler::ScopedWindowResizer::~ScopedWindowResizer() {
-  RemoveHandlers();
   if (resizer_) {
     resizer_->GetTarget()->RemoveObserver(this);
     wm::GetWindowState(resizer_->GetTarget())->RemoveObserver(this);
   }
 }
 
 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowHierarchyChanging(
     const HierarchyChangeParams& params) {
   if (params.receiver != resizer_->GetTarget())
     return;
   wm::WindowState* state = wm::GetWindowState(params.receiver);
-  if (state->continue_drag_after_reparent()) {
+  if (state->continue_drag_after_reparent())
     state->set_continue_drag_after_reparent(false);
-    AddHandlers(params.new_parent);
-  } else {
+  else
     handler_->CompleteDrag(DRAG_COMPLETE, 0);
-  }
 }
 
 void ToplevelWindowEventHandler::ScopedWindowResizer::OnWindowShowTypeChanged(
     wm::WindowState* window_state,
     wm::WindowShowType old) {
   if (!window_state->IsNormalShowState())
     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)
-    : owner_(owner),
-      in_move_loop_(false),
+ToplevelWindowEventHandler::ToplevelWindowEventHandler()
+    : 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() {
   Shell::GetInstance()->display_controller()->RemoveObserver(this);
   if (destroyed_)
     *destroyed_ = true;
 }
 
 void ToplevelWindowEventHandler::OnKeyEvent(ui::KeyEvent* event) {
   if (window_resizer_.get() && event->type() == ui::ET_KEY_PRESSED &&
@@ skipping 250 matching lines @@
   // pressed without mouse move event.
   int component =
       target->delegate()->GetNonClientComponent(event->location());
   if ((event->flags() &
         (ui::EF_IS_DOUBLE_CLICK | ui::EF_IS_TRIPLE_CLICK)) == 0 &&
       WindowResizer::GetBoundsChangeForWindowComponent(component)) {
     gfx::Point location_in_parent(
         ConvertPointToParent(target, event->location()));
     CreateScopedWindowResizer(target, location_in_parent, component,
                               aura::client::WINDOW_MOVE_SOURCE_MOUSE);
+    event->StopPropagation();

[varkha, 2013/12/13 04:05:14]

Just a question. Previously the code was stopping propagation in all cases when
component was bounds-relevant. Now you are only stopping events other than
double/triple clicks so double and triple clicks are allowed to propagate. Does
this change any behavior such as double-click, then drag?

[pkotwicz, 2013/12/13 20:28:42]

It should not because ToplevelWindowEventHandler and WorkspaceEventHandler are
the only post target event handlers in Chrome.

   } else {
     window_resizer_.reset();
   }
-  if (WindowResizer::GetBoundsChangeForWindowComponent(component) != 0)
-    event->StopPropagation();
 }
 
 void ToplevelWindowEventHandler::HandleMouseReleased(
     aura::Window* target,
     ui::MouseEvent* event) {
   if (event->phase() != ui::EP_PRETARGET)
     return;
 
   CompleteDrag(event->type() == ui::ET_MOUSE_RELEASED ?
                     DRAG_COMPLETE : DRAG_REVERT,
@@ skipping 74 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