Rename WebKit namespace to blink (part 3)

content/browser/renderer_host/input/immediate_input_router.h

 // Copyright 2013 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.
 
 #ifndef CONTENT_BROWSER_RENDERER_HOST_INPUT_IMMEDIATE_INPUT_ROUTER_H_
 #define CONTENT_BROWSER_RENDERER_HOST_INPUT_IMMEDIATE_INPUT_ROUTER_H_
 
 #include <queue>
 
 #include "base/basictypes.h"
@@ skipping 73 matching lines @@
   virtual void SendGestureEventImmediately(
       const GestureEventWithLatencyInfo& gesture_event) OVERRIDE;
   virtual void OnGestureEventAck(const GestureEventWithLatencyInfo& event,
                                  InputEventAckState ack_result) OVERRIDE;
 
   bool SendMoveCaret(scoped_ptr<IPC::Message> message);
   bool SendSelectRange(scoped_ptr<IPC::Message> message);
   bool Send(IPC::Message* message);
 
   // Filters and forwards |input_event| to the appropriate handler.
-  void FilterAndSendWebInputEvent(const WebKit::WebInputEvent& input_event,
+  void FilterAndSendWebInputEvent(const blink::WebInputEvent& input_event,
                                   const ui::LatencyInfo& latency_info,
                                   bool is_keyboard_shortcut);
 
   // Utility routine for filtering and forwarding |input_event| to the
   // appropriate handler. |input_event| will be offered to the overscroll
   // controller, client and renderer, in that order.
-  void OfferToHandlers(const WebKit::WebInputEvent& input_event,
+  void OfferToHandlers(const blink::WebInputEvent& input_event,
                        const ui::LatencyInfo& latency_info,
                        bool is_keyboard_shortcut);
 
   // Returns true if |input_event| was consumed by the overscroll controller.
-  bool OfferToOverscrollController(const WebKit::WebInputEvent& input_event,
+  bool OfferToOverscrollController(const blink::WebInputEvent& input_event,
                                    const ui::LatencyInfo& latency_info);
 
   // Returns true if |input_event| was consumed by the client.
-  bool OfferToClient(const WebKit::WebInputEvent& input_event,
+  bool OfferToClient(const blink::WebInputEvent& input_event,
                      const ui::LatencyInfo& latency_info);
 
   // Returns true if |input_event| was successfully sent to the renderer
   // as an async IPC Message.
-  bool OfferToRenderer(const WebKit::WebInputEvent& input_event,
+  bool OfferToRenderer(const blink::WebInputEvent& input_event,
                        const ui::LatencyInfo& latency_info,
                        bool is_keyboard_shortcut);
 
   // IPC message handlers
-  void OnInputEventAck(WebKit::WebInputEvent::Type event_type,
+  void OnInputEventAck(blink::WebInputEvent::Type event_type,
                        InputEventAckState ack_result,
                        const ui::LatencyInfo& latency_info);
   void OnMsgMoveCaretAck();
   void OnSelectRangeAck();
   void OnHasTouchEventHandlers(bool has_handlers);
 
   // Indicates the source of an ack provided to |ProcessInputEventAck()|.
   // The source is tracked by |current_ack_source_|, which aids in ack routing.
   enum AckSource {
     RENDERER,
     CLIENT,
     OVERSCROLL_CONTROLLER,
     ACK_SOURCE_NONE
   };
   // Note: This function may result in |this| being deleted, and as such
   // should be the last method called in any internal chain of event handling.
-  void ProcessInputEventAck(WebKit::WebInputEvent::Type event_type,
+  void ProcessInputEventAck(blink::WebInputEvent::Type event_type,
                             InputEventAckState ack_result,
                             const ui::LatencyInfo& latency_info,
                             AckSource ack_source);
 
   // Dispatches the ack'ed event to |ack_handler_|.
-  void ProcessKeyboardAck(WebKit::WebInputEvent::Type type,
+  void ProcessKeyboardAck(blink::WebInputEvent::Type type,
                           InputEventAckState ack_result);
 
   // Forwards a valid |next_mouse_move_| if |type| is MouseMove.
-  void ProcessMouseAck(WebKit::WebInputEvent::Type type,
+  void ProcessMouseAck(blink::WebInputEvent::Type type,
                        InputEventAckState ack_result);
 
   // Dispatches the ack'ed event to |ack_handler_|, forwarding queued events
   // from |coalesced_mouse_wheel_events_|.
   void ProcessWheelAck(InputEventAckState ack_result,
                        const ui::LatencyInfo& latency);
 
   // Forwards the event ack to |gesture_event_filter|, potentially triggering
   // dispatch of queued gesture events.
-  void ProcessGestureAck(WebKit::WebInputEvent::Type type,
+  void ProcessGestureAck(blink::WebInputEvent::Type type,
                          InputEventAckState ack_result,
                          const ui::LatencyInfo& latency);
 
   // Forwards the event ack to |touch_event_queue_|, potentially triggering
   // dispatch of queued touch events, or the creation of gesture events.
   void ProcessTouchAck(InputEventAckState ack_result,
                        const ui::LatencyInfo& latency);
 
   // Forwards |ack_result| to the client's OverscrollController, if necessary.
-  void ProcessAckForOverscroll(const WebKit::WebInputEvent& event,
+  void ProcessAckForOverscroll(const blink::WebInputEvent& event,
                                InputEventAckState ack_result);
 
   void HandleGestureScroll(const GestureEventWithLatencyInfo& gesture_event);
 
   void SimulateTouchGestureWithMouse(
       const MouseEventWithLatencyInfo& mouse_event);
 
   bool IsInOverscrollGesture() const;
 
   int routing_id() const { return routing_id_; }
@@ skipping 62 matching lines @@
 
   scoped_ptr<TouchEventQueue> touch_event_queue_;
   scoped_ptr<GestureEventFilter> gesture_event_filter_;
 
   DISALLOW_COPY_AND_ASSIGN(ImmediateInputRouter);
 };
 
 }  // namespace content
 
 #endif // CONTENT_BROWSER_RENDERER_HOST_INPUT_IMMEDIATE_INPUT_ROUTER_H_