Mac: Coalesce scroll events.

chrome/browser/renderer_host/render_widget_host.cc

 // Copyright (c) 2010 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 "chrome/browser/renderer_host/render_widget_host.h"
 
 #include "base/auto_reset.h"
 #include "base/histogram.h"
 #include "base/keyboard_codes.h"
 #include "base/message_loop.h"
@@ skipping 48 matching lines @@
     : renderer_initialized_(false),
       view_(NULL),
       process_(process),
       painting_observer_(NULL),
       routing_id_(routing_id),
       is_loading_(false),
       is_hidden_(false),
       repaint_ack_pending_(false),
       resize_ack_pending_(false),
       mouse_move_pending_(false),
+      mouse_wheel_pending_(false),
       needs_repainting_on_restore_(false),
       is_unresponsive_(false),
       in_get_backing_store_(false),
       view_being_painted_(false),
       text_direction_updated_(false),
       text_direction_(WebKit::WebTextDirectionLeftToRight),
       text_direction_canceled_(false),
       suppress_next_char_events_(false) {
   if (routing_id_ == MSG_ROUTING_NONE)
     routing_id_ = process_->GetNextRoutingID();
@@ skipping 290 matching lines @@
   }
 
   ForwardInputEvent(mouse_event, sizeof(WebMouseEvent), false);
 }
 
 void RenderWidgetHost::ForwardWheelEvent(
     const WebMouseWheelEvent& wheel_event) {
   if (process_->ignore_input_events())
     return;
 
+  // If there's already a mouse wheel event waiting to be sent to the renderer,
+  // add the new deltas to that event. Not doing so (e.g., by dropping the old
+  // event, as for mouse moves) results in very slow scrolling on the Mac (on
+  // which many, very small wheel events are sent).
+  if (mouse_wheel_pending_) {
+    if (coalesced_mouse_wheel_events_.empty() ||
+        coalesced_mouse_wheel_events_.back().modifiers
+            != wheel_event.modifiers ||
+        coalesced_mouse_wheel_events_.back().scrollByPage
+            != wheel_event.scrollByPage) {
+      coalesced_mouse_wheel_events_.push_back(wheel_event);
+    } else {
+      coalesced_mouse_wheel_events_.back().deltaX += wheel_event.deltaX;
+      coalesced_mouse_wheel_events_.back().deltaY += wheel_event.deltaY;
+      DCHECK_GE(wheel_event.timeStampSeconds,
+                coalesced_mouse_wheel_events_.back().timeStampSeconds);
+      coalesced_mouse_wheel_events_.back().timeStampSeconds =
+          wheel_event.timeStampSeconds;
+    }
+    return;
+  }
+  mouse_wheel_pending_ = true;
+
+  HISTOGRAM_COUNTS_100("MPArch.RWH_WheelQueueSize",
+                       coalesced_mouse_wheel_events_.size());
   ForwardInputEvent(wheel_event, sizeof(WebMouseWheelEvent), false);
 }
 
 void RenderWidgetHost::ForwardKeyboardEvent(
     const NativeWebKeyboardEvent& key_event) {
   if (process_->ignore_input_events())
     return;
 
   if (key_event.type == WebKeyboardEvent::Char &&
       (key_event.windowsKeyCode == base::VKEY_RETURN ||
@@ skipping 60 matching lines @@
       reinterpret_cast<const char*>(&input_event), event_size);
   // |is_keyboard_shortcut| only makes sense for RawKeyDown events.
   if (input_event.type == WebInputEvent::RawKeyDown)
     message->WriteBool(is_keyboard_shortcut);
   input_event_start_time_ = TimeTicks::Now();
   Send(message);
 
   // Any input event cancels a pending mouse move event.
   next_mouse_move_.reset();
 
+  // Any non-wheel input event cancels pending wheel events.
+  if (input_event.type != WebInputEvent::MouseWheel)
+    coalesced_mouse_wheel_events_.clear();
+
   StartHangMonitorTimeout(TimeDelta::FromMilliseconds(kHungRendererDelayMs));
 }
 
 void RenderWidgetHost::ForwardEditCommand(const std::string& name,
       const std::string& value) {
   // We don't need an implementation of this function here since the
   // only place we use this is for the case of dropdown menus and other
   // edge cases for which edit commands don't make sense.
 }
 
 void RenderWidgetHost::ForwardEditCommandsForNextKeyEvent(
     const EditCommands& edit_commands) {
   // We don't need an implementation of this function here since this message is
   // only handled by RenderView.
 }
 
 void RenderWidgetHost::RendererExited() {
   // Clearing this flag causes us to re-create the renderer when recovering
   // from a crashed renderer.
   renderer_initialized_ = false;
 
-  // Must reset these to ensure that mouse move events work with a new renderer.
+  // Must reset these to ensure that mouse move/wheel events work with a new
+  // renderer.
   mouse_move_pending_ = false;
   next_mouse_move_.reset();
+  mouse_wheel_pending_ = false;
+  coalesced_mouse_wheel_events_.clear();
 
   // Must reset these to ensure that keyboard events work with a new renderer.
   key_queue_.clear();
   suppress_next_char_events_ = false;
 
   // Reset some fields in preparation for recovering from a crash.
   resize_ack_pending_ = false;
   repaint_ack_pending_ = false;
 
   in_flight_size_.SetSize(0, 0);
@@ skipping 242 matching lines @@
   if (!message.ReadInt(&iter, &type) || (type < WebInputEvent::Undefined)) {
     process()->ReceivedBadMessage(message.type());
   } else if (type == WebInputEvent::MouseMove) {
     mouse_move_pending_ = false;
 
     // now, we can send the next mouse move event
     if (next_mouse_move_.get()) {
       DCHECK(next_mouse_move_->type == WebInputEvent::MouseMove);
       ForwardMouseEvent(*next_mouse_move_);
     }
+  } else if (type == WebInputEvent::MouseWheel) {
+    mouse_wheel_pending_ = false;
+
+    // Now send the next (coalesced) mouse wheel event.
+    if (!coalesced_mouse_wheel_events_.empty()) {
+      WebMouseWheelEvent next_wheel_event =
+          coalesced_mouse_wheel_events_.front();
+      coalesced_mouse_wheel_events_.pop_front();
+      ForwardWheelEvent(next_wheel_event);
+    }
   } else if (WebInputEvent::isKeyboardEventType(type)) {
     bool processed = false;
     if (!message.ReadBool(&iter, &processed))
       process()->ReceivedBadMessage(message.type());
 
     ProcessKeyboardEventAck(type, processed);
   }
 }
 
 void RenderWidgetHost::OnMsgFocus() {
@@ skipping 161 matching lines @@
 
     if (!processed) {
       UnhandledKeyboardEvent(front_item);
 
       // WARNING: This RenderWidgetHost can be deallocated at this point
       // (i.e.  in the case of Ctrl+W, where the call to
       // UnhandledKeyboardEvent destroys this RenderWidgetHost).
     }
   }
 }