aura:Delay call to DispatchHeldMouseMove from RootWindow::ReleaseMouseMoves

ui/aura/root_window.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 "ui/aura/root_window.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 112 matching lines @@
       last_cursor_(ui::kCursorNull),
       mouse_pressed_handler_(NULL),
       mouse_moved_handler_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(
           gesture_recognizer_(ui::GestureRecognizer::Create(this))),
       synthesize_mouse_move_(false),
       waiting_on_compositing_end_(false),
       draw_on_compositing_end_(false),
       defer_draw_scheduling_(false),
       mouse_move_hold_count_(0),
+      ALLOW_THIS_IN_INITIALIZER_LIST(held_mouse_event_factory_(this)),
       compositor_lock_(NULL),
       draw_on_compositor_unlock_(false) {
   SetName("RootWindow");
 
   compositor_.reset(new ui::Compositor(this, host_->GetAcceleratedWidget()));
   DCHECK(compositor_.get());
   compositor_->AddObserver(this);
 }
 
 RootWindow::~RootWindow() {
@@ skipping 100 matching lines @@
                            compositor_->last_started_frame() + 1);
 
   compositor_->Draw(false);
 }
 
 void RootWindow::ScheduleFullDraw() {
   compositor_->ScheduleFullDraw();
 }
 
 bool RootWindow::DispatchMouseEvent(MouseEvent* event) {
-  if (mouse_move_hold_count_) {
-    if (event->type() == ui::ET_MOUSE_DRAGGED ||
-        (event->flags() & ui::EF_IS_SYNTHESIZED)) {
+  if (event->type() == ui::ET_MOUSE_DRAGGED ||
+      (event->flags() & ui::EF_IS_SYNTHESIZED)) {
+    if (mouse_move_hold_count_) {
       held_mouse_move_.reset(new MouseEvent(*event, NULL, NULL));
       return true;
     } else {
-      DispatchHeldMouseMove();
+      // We may have a held event for a period between the time
+      // mouse_move_hold_count_ fell to 0 and the DispatchHeldMouseMove
+      // executes. Since we're going to dispatch the new event directly below,
+      // we can reset the old one.
+      held_mouse_move_.reset();
     }
   }
+  DispatchHeldMouseMove();
   return DispatchMouseEventImpl(event);
 }
 
 bool RootWindow::DispatchKeyEvent(KeyEvent* event) {
   DispatchHeldMouseMove();
   KeyEvent translated_event(*event);
   if (translated_event.key_code() == ui::VKEY_UNKNOWN)
     return false;
   client::EventClient* client = client::GetEventClient(GetRootWindow());
   Window* focused_window = focus_manager_->GetFocusedWindow();
@@ skipping 206 matching lines @@
   return host_->GetAcceleratedWidget();
 }
 
 #if !defined(NDEBUG)
 void RootWindow::ToggleFullScreen() {
   host_->ToggleFullScreen();
 }
 #endif
 
 void RootWindow::HoldMouseMoves() {
+  if (!mouse_move_hold_count_)
+    held_mouse_event_factory_.InvalidateWeakPtrs();
   ++mouse_move_hold_count_;
 }
 
 void RootWindow::ReleaseMouseMoves() {
   --mouse_move_hold_count_;
   DCHECK_GE(mouse_move_hold_count_, 0);
-  if (!mouse_move_hold_count_)
-    DispatchHeldMouseMove();
+  if (!mouse_move_hold_count_ && held_mouse_move_.get()) {
+    // We don't want to call DispatchHeldMouseMove directly, because this might
+    // be called from a deep stack while another event, in which case
+    // dispatching another one may not be safe/expected.
+    // Instead we post a task, that we may cancel if HoldMouseMoves is called
+    // again before it executes.
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&RootWindow::DispatchHeldMouseMove,
+                   held_mouse_event_factory_.GetWeakPtr()));
+  }
 }
 
 scoped_refptr<CompositorLock> RootWindow::GetCompositorLock() {
   if (!compositor_lock_)
     compositor_lock_ = new CompositorLock(this);
   return compositor_lock_;
 }
 
 void RootWindow::SetFocusWhenShown(bool focused) {
   host_->SetFocusWhenShown(focused);
@@ skipping 510 matching lines @@
 void RootWindow::UnlockCompositor() {
   DCHECK(compositor_lock_);
   compositor_lock_ = NULL;
   if (draw_on_compositor_unlock_) {
     draw_on_compositor_unlock_ = false;
     ScheduleDraw();
   }
 }
 
 }  // namespace aura