Rename WebKit namespace to blink (part 3)

content/browser/renderer_host/input/immediate_input_router.cc

 // 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.
 
 #include "content/browser/renderer_host/input/immediate_input_router.h"
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "content/browser/renderer_host/input/gesture_event_filter.h"
@@ skipping 12 matching lines @@
 #include "content/public/browser/notification_types.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_sender.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
-using WebKit::WebGestureEvent;
-using WebKit::WebInputEvent;
-using WebKit::WebKeyboardEvent;
-using WebKit::WebMouseEvent;
-using WebKit::WebMouseWheelEvent;
+using blink::WebGestureEvent;
+using blink::WebInputEvent;
+using blink::WebKeyboardEvent;
+using blink::WebMouseEvent;
+using blink::WebMouseWheelEvent;
 
 namespace content {
 namespace {
 
 GestureEventWithLatencyInfo MakeGestureEvent(WebInputEvent::Type type,
                                              double timestamp_seconds,
                                              int x,
                                              int y,
                                              int modifiers,
                                              const ui::LatencyInfo latency) {
@@ skipping 300 matching lines @@
   if (!controller)
     return false;
 
   OverscrollController::Disposition disposition =
       controller->DispatchEvent(input_event, latency_info);
 
   bool consumed = disposition == OverscrollController::CONSUMED;
 
   if (disposition == OverscrollController::SHOULD_FORWARD_TO_GESTURE_FILTER) {
     DCHECK(WebInputEvent::isGestureEventType(input_event.type));
-    const WebKit::WebGestureEvent& gesture_event =
-        static_cast<const WebKit::WebGestureEvent&>(input_event);
+    const blink::WebGestureEvent& gesture_event =
+        static_cast<const blink::WebGestureEvent&>(input_event);
     // An ACK is expected for the event, so mark it as consumed.
     consumed = !gesture_event_filter_->ShouldForward(
         GestureEventWithLatencyInfo(gesture_event, latency_info));
   }
 
   if (consumed) {
     InputEventAckState overscroll_ack =
         WebInputEvent::isTouchEventType(input_event.type) ?
             INPUT_EVENT_ACK_STATE_NOT_CONSUMED : INPUT_EVENT_ACK_STATE_CONSUMED;
     ProcessInputEventAck(input_event.type,
@@ skipping 120 matching lines @@
   } else if (WebInputEvent::isTouchEventType(event_type)) {
     ProcessTouchAck(ack_result, latency_info);
   } else if (WebInputEvent::isGestureEventType(event_type)) {
     ProcessGestureAck(event_type, ack_result, latency_info);
   } else if (event_type != WebInputEvent::Undefined) {
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::BAD_ACK_MESSAGE);
   }
 }
 
 void ImmediateInputRouter::ProcessKeyboardAck(
-    WebKit::WebInputEvent::Type type,
+    blink::WebInputEvent::Type type,
     InputEventAckState ack_result) {
   if (key_queue_.empty()) {
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_ACK);
   } else if (key_queue_.front().type != type) {
     // Something must be wrong. Clear the |key_queue_| and char event
     // suppression so that we can resume from the error.
     key_queue_.clear();
     ack_handler_->OnUnexpectedEventAck(InputAckHandler::UNEXPECTED_EVENT_TYPE);
   } else {
     NativeWebKeyboardEvent front_item = key_queue_.front();
     key_queue_.pop_front();
 
     ack_handler_->OnKeyboardEventAck(front_item, ack_result);
     // WARNING: This ImmediateInputRouter can be deallocated at this point
     // (i.e.  in the case of Ctrl+W, where the call to
     // HandleKeyboardEvent destroys this ImmediateInputRouter).
     // TODO(jdduke): crbug.com/274029 - Make ack-triggered shutdown async.
   }
 }
 
-void ImmediateInputRouter::ProcessMouseAck(WebKit::WebInputEvent::Type type,
+void ImmediateInputRouter::ProcessMouseAck(blink::WebInputEvent::Type type,
                                            InputEventAckState ack_result) {
   if (type != WebInputEvent::MouseMove)
     return;
 
   mouse_move_pending_ = false;
 
   if (next_mouse_move_) {
     DCHECK(next_mouse_move_->event.type == WebInputEvent::MouseMove);
     scoped_ptr<MouseEventWithLatencyInfo> next_mouse_move
         = next_mouse_move_.Pass();
@@ skipping 143 matching lines @@
       break;
   }
 }
 
 bool ImmediateInputRouter::IsInOverscrollGesture() const {
   OverscrollController* controller = client_->GetOverscrollController();
   return controller && controller->overscroll_mode() != OVERSCROLL_NONE;
 }
 
 }  // namespace content