Rename WebKit namespace to blink (part 3)

content/browser/renderer_host/input/touch_event_queue.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/touch_event_queue.h"
 
 #include "base/auto_reset.h"
 #include "base/debug/trace_event.h"
 #include "base/stl_util.h"
 
@@ skipping 102 matching lines @@
   touch_queue_.push_back(new CoalescedWebTouchEvent(event));
 }
 
 void TouchEventQueue::ProcessTouchAck(InputEventAckState ack_result,
                                       const ui::LatencyInfo& latency_info) {
   DCHECK(!dispatching_touch_ack_);
   if (touch_queue_.empty())
     return;
 
   // Update the ACK status for each touch point in the ACKed event.
-  const WebKit::WebTouchEvent& event =
+  const blink::WebTouchEvent& event =
       touch_queue_.front()->coalesced_event().event;
-  if (event.type == WebKit::WebInputEvent::TouchEnd ||
-      event.type == WebKit::WebInputEvent::TouchCancel) {
+  if (event.type == blink::WebInputEvent::TouchEnd ||
+      event.type == blink::WebInputEvent::TouchCancel) {
     // The points have been released. Erase the ACK states.
     for (unsigned i = 0; i < event.touchesLength; ++i) {
-      const WebKit::WebTouchPoint& point = event.touches[i];
-      if (point.state == WebKit::WebTouchPoint::StateReleased ||
-          point.state == WebKit::WebTouchPoint::StateCancelled)
+      const blink::WebTouchPoint& point = event.touches[i];
+      if (point.state == blink::WebTouchPoint::StateReleased ||
+          point.state == blink::WebTouchPoint::StateCancelled)
         touch_ack_states_.erase(point.id);
     }
-  } else if (event.type == WebKit::WebInputEvent::TouchStart) {
+  } else if (event.type == blink::WebInputEvent::TouchStart) {
     for (unsigned i = 0; i < event.touchesLength; ++i) {
-      const WebKit::WebTouchPoint& point = event.touches[i];
-      if (point.state == WebKit::WebTouchPoint::StatePressed)
+      const blink::WebTouchPoint& point = event.touches[i];
+      if (point.state == blink::WebTouchPoint::StatePressed)
         touch_ack_states_[point.id] = ack_result;
     }
   }
 
   PopTouchEventToClient(ack_result, latency_info);
   TryForwardNextEventToRenderer();
 }
 
 void TouchEventQueue::TryForwardNextEventToRenderer() {
   DCHECK(!dispatching_touch_ack_);
   // If there are queued touch events, then try to forward them to the renderer
   // immediately, or ACK the events back to the client if appropriate.
   while (!touch_queue_.empty()) {
     const TouchEventWithLatencyInfo& touch =
         touch_queue_.front()->coalesced_event();
     if (ShouldForwardToRenderer(touch.event)) {
       client_->SendTouchEventImmediately(touch);
       break;
     }
     PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS,
                           ui::LatencyInfo());
   }
 }
 
 void TouchEventQueue::OnGestureScrollEvent(
     const GestureEventWithLatencyInfo& gesture_event) {
-  WebKit::WebInputEvent::Type type = gesture_event.event.type;
-  if (type == WebKit::WebInputEvent::GestureScrollBegin) {
+  blink::WebInputEvent::Type type = gesture_event.event.type;
+  if (type == blink::WebInputEvent::GestureScrollBegin) {
     // We assume the scroll event are generated synchronously from
     // dispatching a touch event ack, so that we can fake a cancel
     // event that has the correct touch ids as the touch event that
     // is being acked. If not, we don't do the touch-cancel optimization.
     if (no_touch_to_renderer_ || !dispatching_touch_ack_)
       return;
     no_touch_to_renderer_ = true;
     // Fake a TouchCancel to cancel the touch points of the touch event
     // that is currently being acked.
     TouchEventWithLatencyInfo cancel_event =
         dispatching_touch_ack_->coalesced_event();
-    cancel_event.event.type = WebKit::WebInputEvent::TouchCancel;
+    cancel_event.event.type = blink::WebInputEvent::TouchCancel;
     for (size_t i = 0; i < cancel_event.event.touchesLength; i++)
       cancel_event.event.touches[i].state =
-          WebKit::WebTouchPoint::StateCancelled;
+          blink::WebTouchPoint::StateCancelled;
     CoalescedWebTouchEvent* coalesced_cancel_event =
         new CoalescedWebTouchEvent(cancel_event);
     // Ignore the ack of the touch cancel so when it is acked, it won't get
     // sent to gesture recognizer.
     coalesced_cancel_event->set_ignore_ack(true);
     // |dispatching_touch_ack_| is non-null when we reach here, meaning we
     // are in the scope of PopTouchEventToClient() and that no touch event
     // in the queue is waiting for ack from renderer. So we can just insert
     // the touch cancel at the beginning of the queue.
     touch_queue_.push_front(coalesced_cancel_event);
-  } else if (type == WebKit::WebInputEvent::GestureScrollEnd ||
-             type == WebKit::WebInputEvent::GestureFlingStart) {
+  } else if (type == blink::WebInputEvent::GestureScrollEnd ||
+             type == blink::WebInputEvent::GestureFlingStart) {
     no_touch_to_renderer_ = false;
   }
 }
 
 void TouchEventQueue::FlushQueue() {
   DCHECK(!dispatching_touch_ack_);
   while (!touch_queue_.empty())
     PopTouchEventToClient(INPUT_EVENT_ACK_STATE_NOT_CONSUMED,
                           ui::LatencyInfo());
 }
@@ skipping 24 matching lines @@
 
   for (WebTouchEventWithLatencyList::iterator iter = acked_event->begin(),
        end = acked_event->end();
        iter != end; ++iter) {
     iter->latency.AddNewLatencyFrom(renderer_latency_info);
     client_->OnTouchEventAck((*iter), ack_result);
   }
 }
 
 bool TouchEventQueue::ShouldForwardToRenderer(
-    const WebKit::WebTouchEvent& event) const {
+    const blink::WebTouchEvent& event) const {
   if (no_touch_to_renderer_ &&
-      event.type != WebKit::WebInputEvent::TouchCancel)
+      event.type != blink::WebInputEvent::TouchCancel)
     return false;
 
   // Touch press events should always be forwarded to the renderer.
-  if (event.type == WebKit::WebInputEvent::TouchStart)
+  if (event.type == blink::WebInputEvent::TouchStart)
     return true;
 
   for (unsigned int i = 0; i < event.touchesLength; ++i) {
-    const WebKit::WebTouchPoint& point = event.touches[i];
+    const blink::WebTouchPoint& point = event.touches[i];
     // If a point has been stationary, then don't take it into account.
-    if (point.state == WebKit::WebTouchPoint::StateStationary)
+    if (point.state == blink::WebTouchPoint::StateStationary)
       continue;
 
     if (touch_ack_states_.count(point.id) > 0) {
       if (touch_ack_states_.find(point.id)->second !=
           INPUT_EVENT_ACK_STATE_NO_CONSUMER_EXISTS)
         return true;
     } else {
       // If the ACK status of a point is unknown, then the event should be
       // forwarded to the renderer.
       return true;
     }
   }
 
   return false;
 }
 
 }  // namespace content