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 109 matching lines @@
 bool RootWindow::DispatchMouseEvent(MouseEvent* event) {
   if (mouse_move_hold_count_) {
     if (event->type() == ui::ET_MOUSE_DRAGGED ||
         (event->flags() & ui::EF_IS_SYNTHESIZED)) {
       held_mouse_move_.reset(new MouseEvent(*event, NULL, NULL));
       return true;
     } else {
       DispatchHeldMouseMove();
     }
   }
   return DispatchMouseEventImpl(event);

[sky, 2012/06/12 03:57:47]

Should this reset held_mouse_move_ now? I'm thinking of the case where
ReleaseMouseMoves() is invoked with held_mouse_move_ non-NULL and a real mouse
move event comes in before the task is processed.

[piman, 2012/06/12 04:42:05]

We wouldn't want to drop it, but we'd need to dispatch it before this incoming
one (to conserve order).
I think changing the if above to if (mouse_move_hold_count_ ||
held_mouse_move.get()) would be close to it.

[piman, 2012/06/12 19:49:49]

I changed the logic a little bit here, I think this should handle all the cases.

 }
 
 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();
   if (client && !client->CanProcessEventsWithinSubtree(focused_window)) {
@@ skipping 205 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();

[jonathan.backer, 2012/06/12 17:32:38]

Why are we invalidating? It happens all the time when I resize NYT on my
desktop. Do we always want to drop that event? Doesn't it make more sense to
defer the invalidation --- say until we have a new held_mouse_move_ to queue
up...

   ++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()) {
+    MessageLoop::current()->PostTask(

[sky, 2012/06/12 03:57:47]

Add a comment as to why we don't process immediately.

[piman, 2012/06/12 19:49:49]

Done.

+        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