[WIP] BufferedInputRouter

content/renderer/render_widget.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 "content/renderer/render_widget.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
@@ skipping 355 matching lines @@
   return SynchronousCompositorFactory::GetInstance() != NULL;
 #else
   return false;
 #endif
 }
 
 bool RenderWidget::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(RenderWidget, message)
     IPC_MESSAGE_HANDLER(InputMsg_HandleInputEvent, OnHandleInputEvent)
+    IPC_MESSAGE_HANDLER(InputMsg_HandleEventPacket, OnHandleEventPacket)
     IPC_MESSAGE_HANDLER(InputMsg_CursorVisibilityChange,
                         OnCursorVisibilityChange)
     IPC_MESSAGE_HANDLER(InputMsg_MouseCaptureLost, OnMouseCaptureLost)
     IPC_MESSAGE_HANDLER(InputMsg_SetFocus, OnSetFocus)
     IPC_MESSAGE_HANDLER(ViewMsg_Close, OnClose)
     IPC_MESSAGE_HANDLER(ViewMsg_CreatingNew_ACK, OnCreatingNewAck)
     IPC_MESSAGE_HANDLER(ViewMsg_Resize, OnResize)
     IPC_MESSAGE_HANDLER(ViewMsg_ChangeResizeRect, OnChangeResizeRect)
     IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
     IPC_MESSAGE_HANDLER(ViewMsg_WasShown, OnWasShown)
@@ skipping 418 matching lines @@
   // generated it.
   if (!animation_update_pending_ && !paint_aggregator_.HasPendingUpdate()) {
     TRACE_EVENT0("renderer", "EarlyOut_NoPendingUpdate");
     return;
   }
 
   // Continue painting if necessary...
   DoDeferredUpdateAndSendInputAck();
 }
 
-void RenderWidget::OnHandleInputEvent(const WebKit::WebInputEvent* input_event,
-                                      const ui::LatencyInfo& latency_info,
-                                      bool is_keyboard_shortcut) {
+InputEventDisposition RenderWidget::HandleWebEvent(
+    const WebKit::WebInputEvent* input_event,
+    const ui::LatencyInfo& latency_info,
+    bool is_keyboard_shortcut,
+    bool send_ack) {
   handling_input_event_ = true;
   if (!input_event) {
     handling_input_event_ = false;
-    return;
+    return INPUT_EVENT_COULD_NOT_DELIVER;
   }
 
   const char* const event_name = GetEventName(input_event->type);
-  TRACE_EVENT1("renderer", "RenderWidget::OnHandleInputEvent",
+  TRACE_EVENT1("renderer", "RenderWidget::HandleInputEvent",
                "event", event_name);
 
   if (compositor_)
     compositor_->SetLatencyInfo(latency_info);
   else
     latency_info_.MergeWith(latency_info);
 
   base::TimeDelta now = base::TimeDelta::FromInternalValue(
       base::TimeTicks::Now().ToInternalValue());
 
@@ skipping 51 matching lines @@
   InputEventAckState ack_result = processed ?
       INPUT_EVENT_ACK_STATE_CONSUMED : INPUT_EVENT_ACK_STATE_NOT_CONSUMED;
   if (!processed &&  input_event->type == WebInputEvent::TouchStart) {
     const WebTouchEvent& touch_event =
         *static_cast<const WebTouchEvent*>(input_event);
     ack_result = HasTouchEventHandlersAt(touch_event.touches[0].position) ?
         INPUT_EVENT_ACK_STATE_NOT_CONSUMED :
         INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS;
   }
 
-  IPC::Message* response =
-      new InputHostMsg_HandleInputEvent_ACK(routing_id_,
-                                            input_event->type,
-                                            ack_result,
-                                            latency_info);
-  bool event_type_gets_rate_limited =
-      input_event->type == WebInputEvent::MouseMove ||
-      input_event->type == WebInputEvent::MouseWheel ||
-      WebInputEvent::isTouchEventType(input_event->type);
+  if (send_ack) {
+    IPC::Message* response =
+        new InputHostMsg_HandleInputEvent_ACK(routing_id_,
+                                              input_event->type,
+                                              ack_result,
+                                              latency_info);
 
-  bool frame_pending = paint_aggregator_.HasPendingUpdate();
-  if (is_accelerated_compositing_active_) {
-    frame_pending = compositor_ &&
-                    compositor_->commitRequested();
-  }
+    bool event_type_gets_rate_limited =
+        input_event->type == WebInputEvent::MouseMove ||
+        input_event->type == WebInputEvent::MouseWheel ||
+        WebInputEvent::isTouchEventType(input_event->type);
 
-  if (event_type_gets_rate_limited && frame_pending && !is_hidden_) {
-    // We want to rate limit the input events in this case, so we'll wait for
-    // painting to finish before ACKing this message.
-    if (pending_input_event_ack_) {
-      // As two different kinds of events could cause us to postpone an ack
-      // we send it now, if we have one pending. The Browser should never
-      // send us the same kind of event we are delaying the ack for.
-      Send(pending_input_event_ack_.release());
+    bool frame_pending = paint_aggregator_.HasPendingUpdate();
+    if (is_accelerated_compositing_active_) {
+      frame_pending = compositor_ &&
+                      compositor_->commitRequested();
     }
-    pending_input_event_ack_.reset(response);
-    if (compositor_)
-      compositor_->NotifyInputThrottledUntilCommit();
-  } else {
-    Send(response);
+
+    if (event_type_gets_rate_limited && frame_pending && !is_hidden_) {
+      // We want to rate limit the input events in this case, so we'll wait for
+      // painting to finish before ACKing this message.
+      if (pending_input_event_ack_) {
+        // As two different kinds of events could cause us to postpone an ack
+        // we send it now, if we have one pending. The Browser should never
+        // send us the same kind of event we are delaying the ack for.
+        Send(pending_input_event_ack_.release());
+      }
+      pending_input_event_ack_.reset(response);
+      if (compositor_)
+        compositor_->NotifyInputThrottledUntilCommit();
+    } else {
+      Send(response);
+    }
   }
 
 #if defined(OS_ANDROID)
   // Allow the IME to be shown when the focus changes as a consequence
   // of a processed touch end event.
   if (input_event->type == WebInputEvent::TouchEnd && processed)
     UpdateTextInputState(true, true);
 #endif
 
   handling_input_event_ = false;
 
   if (!prevent_default) {
     if (WebInputEvent::isKeyboardEventType(input_event->type))
       DidHandleKeyEvent();
     if (WebInputEvent::isMouseEventType(input_event->type))
       DidHandleMouseEvent(*(static_cast<const WebMouseEvent*>(input_event)));
     if (WebInputEvent::isTouchEventType(input_event->type))
       DidHandleTouchEvent(*(static_cast<const WebTouchEvent*>(input_event)));
   }
+
+  return ToDisposition(ack_result, true, prevent_default);
+}
+
+InputEventDisposition RenderWidget::Dispatch(const IPC::Message& message) {
+  OnMessageReceived(message);
+  return INPUT_EVENT_MAIN_THREAD_CONSUMED;
+}
+
+InputEventDisposition RenderWidget::Dispatch(
+    int routing_id,
+    const WebKit::WebInputEvent* web_event,
+    const ui::LatencyInfo& latency_info,
+    bool is_keyboard_shortcut) {
+  DCHECK_EQ(routing_id_, routing_id);
+  return HandleWebEvent(web_event, latency_info, is_keyboard_shortcut, false);
+}
+
+void RenderWidget::OnHandleInputEvent(const WebKit::WebInputEvent* input_event,
+                                      const ui::LatencyInfo& latency_info,
+                                      bool is_keyboard_shortcut) {
+  HandleWebEvent(input_event, latency_info, is_keyboard_shortcut, true);
+}
+
+void RenderWidget::OnHandleEventPacket(
+    const EventPacket& packet,
+    const InputEventDispositions& dispositions) {
+  TRACE_EVENT0("renderer", "OnHandleEventPacket");
+
+  RendererEventPacket renderer_packet(&packet, dispositions);
+
+  scoped_ptr<IPC::Message> dispatch_result =
+      renderer_packet.DispatchWith(this,
+                                   RendererEventPacket::THREAD_MAIN,
+                                   routing_id_);
+
+  DCHECK_EQ(InputHostMsg_HandleEventPacket_ACK::ID, dispatch_result->type());
+  Send(dispatch_result.release());
 }
 
 void RenderWidget::OnCursorVisibilityChange(bool is_visible) {
   if (webwidget_)
     webwidget_->setCursorVisibilityState(is_visible);
 }
 
 void RenderWidget::OnMouseCaptureLost() {
   if (webwidget_)
     webwidget_->mouseCaptureLost();
@@ skipping 1601 matching lines @@
           kDefaultCommandBufferSize,
           kDefaultStartTransferBufferSize,
           kDefaultMinTransferBufferSize,
           kDefaultMaxTransferBufferSize,
           mapped_memory_reclaim_limit))
     return scoped_ptr<WebGraphicsContext3DCommandBufferImpl>();
   return context.Pass();
 }
 
 }  // namespace content