Rename WebKit namespace to blink (part 3)

content/browser/renderer_host/render_widget_host_view_win.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/browser/renderer_host/render_widget_host_view_win.h"
 
 #include <InputScope.h>
 #include <wtsapi32.h>
 #pragma comment(lib, "wtsapi32.lib")
 
@@ skipping 65 matching lines @@
 #include "ui/gfx/sequential_id_generator.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/gfx/win/dpi.h"
 #include "ui/gfx/win/hwnd_util.h"
 #include "webkit/common/cursors/webcursor.h"
 #include "win8/util/win8_util.h"
 
 using base::TimeDelta;
 using base::TimeTicks;
 using ui::ViewProp;
-using WebKit::WebInputEvent;
-using WebKit::WebMouseEvent;
-using WebKit::WebTextDirection;
+using blink::WebInputEvent;
+using blink::WebMouseEvent;
+using blink::WebTextDirection;
 
 namespace content {
 namespace {
 
 // Tooltips will wrap after this width. Yes, wrap. Imagine that!
 const int kTooltipMaxWidthPixels = 300;
 
 // Maximum number of characters we allow in a tooltip.
 const int kMaxTooltipLength = 1024;
 
@@ skipping 96 matching lines @@
   } else {
     delta->x = gi.ptsLocation.x - last_pt.x;
     delta->y = gi.ptsLocation.y - last_pt.y;
   }
   last_pt.x = gi.ptsLocation.x;
   last_pt.y = gi.ptsLocation.y;
   *start = start_pt;
   return true;
 }
 
-WebKit::WebMouseWheelEvent MakeFakeScrollWheelEvent(HWND hwnd,
+blink::WebMouseWheelEvent MakeFakeScrollWheelEvent(HWND hwnd,
                                                     POINT start,
                                                     POINT delta) {
-  WebKit::WebMouseWheelEvent result;
+  blink::WebMouseWheelEvent result;
   result.type = WebInputEvent::MouseWheel;
   result.timeStampSeconds = ::GetMessageTime() / 1000.0;
   result.button = WebMouseEvent::ButtonNone;
   result.globalX = start.x;
   result.globalY = start.y;
   // Map to window coordinates.
   POINT client_point = { result.globalX, result.globalY };
   MapWindowPoints(0, hwnd, &client_point, 1);
   result.x = client_point.x;
   result.y = client_point.y;
@@ skipping 10 matching lines @@
 static const int kTouchMask = 0x7;
 
 inline int GetTouchType(const TOUCHINPUT& point) {
   return point.dwFlags & kTouchMask;
 }
 
 inline void SetTouchType(TOUCHINPUT* point, int type) {
   point->dwFlags = (point->dwFlags & kTouchMask) | type;
 }
 
-ui::EventType ConvertToUIEvent(WebKit::WebTouchPoint::State t) {
+ui::EventType ConvertToUIEvent(blink::WebTouchPoint::State t) {
   switch (t) {
-    case WebKit::WebTouchPoint::StatePressed:
+    case blink::WebTouchPoint::StatePressed:
       return ui::ET_TOUCH_PRESSED;
-    case WebKit::WebTouchPoint::StateMoved:
+    case blink::WebTouchPoint::StateMoved:
       return ui::ET_TOUCH_MOVED;
-    case WebKit::WebTouchPoint::StateStationary:
+    case blink::WebTouchPoint::StateStationary:
       return ui::ET_TOUCH_STATIONARY;
-    case WebKit::WebTouchPoint::StateReleased:
+    case blink::WebTouchPoint::StateReleased:
       return ui::ET_TOUCH_RELEASED;
-    case WebKit::WebTouchPoint::StateCancelled:
+    case blink::WebTouchPoint::StateCancelled:
       return ui::ET_TOUCH_CANCELLED;
     default:
       DCHECK(false) << "Unexpected ui type. " << t;
       return ui::ET_UNKNOWN;
   }
 }
 
 // Creates a WebGestureEvent corresponding to the given |gesture|
-WebKit::WebGestureEvent CreateWebGestureEvent(HWND hwnd,
+blink::WebGestureEvent CreateWebGestureEvent(HWND hwnd,
                                               const ui::GestureEvent& gesture) {
-  WebKit::WebGestureEvent gesture_event =
+  blink::WebGestureEvent gesture_event =
       MakeWebGestureEventFromUIEvent(gesture);
 
   POINT client_point = gesture.location().ToPOINT();
   POINT screen_point = gesture.location().ToPOINT();
   MapWindowPoints(hwnd, HWND_DESKTOP, &screen_point, 1);
 
   gesture_event.x = client_point.x;
   gesture_event.y = client_point.y;
   gesture_event.globalX = screen_point.x;
   gesture_event.globalY = screen_point.y;
 
   return gesture_event;
 }
 
-WebKit::WebGestureEvent CreateFlingCancelEvent(double time_stamp) {
-  WebKit::WebGestureEvent gesture_event;
+blink::WebGestureEvent CreateFlingCancelEvent(double time_stamp) {
+  blink::WebGestureEvent gesture_event;
   gesture_event.timeStampSeconds = time_stamp;
-  gesture_event.type = WebKit::WebGestureEvent::GestureFlingCancel;
-  gesture_event.sourceDevice = WebKit::WebGestureEvent::Touchscreen;
+  gesture_event.type = blink::WebGestureEvent::GestureFlingCancel;
+  gesture_event.sourceDevice = blink::WebGestureEvent::Touchscreen;
   return gesture_event;
 }
 
 class TouchEventFromWebTouchPoint : public ui::TouchEvent {
  public:
-  TouchEventFromWebTouchPoint(const WebKit::WebTouchPoint& touch_point,
+  TouchEventFromWebTouchPoint(const blink::WebTouchPoint& touch_point,
                               base::TimeDelta& timestamp)
       : ui::TouchEvent(ConvertToUIEvent(touch_point.state),
                        touch_point.position,
                        touch_point.id,
                        timestamp) {
     set_radius(touch_point.radiusX, touch_point.radiusY);
     set_rotation_angle(touch_point.rotationAngle);
     set_force(touch_point.force);
     set_flags(ui::GetModifiersFromKeyState());
   }
 
   virtual ~TouchEventFromWebTouchPoint() {}
 
  private:
   DISALLOW_COPY_AND_ASSIGN(TouchEventFromWebTouchPoint);
 };
 
 bool ShouldSendPinchGesture() {
   static bool pinch_allowed =
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kEnablePinch);
   return pinch_allowed;
 }
 
 void GetScreenInfoForWindow(gfx::NativeViewId id,
-                            WebKit::WebScreenInfo* results) {
+                            blink::WebScreenInfo* results) {
   HWND window = gfx::NativeViewFromId(id);
 
   HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTOPRIMARY);
 
   MONITORINFOEX monitor_info;
   monitor_info.cbSize = sizeof(MONITORINFOEX);
   if (!base::win::GetMonitorInfoWrapper(monitor, &monitor_info))
     return;
 
   DEVMODE dev_mode;
   dev_mode.dmSize = sizeof(dev_mode);
   dev_mode.dmDriverExtra = 0;
   EnumDisplaySettings(monitor_info.szDevice, ENUM_CURRENT_SETTINGS, &dev_mode);
 
-  WebKit::WebScreenInfo screen_info;
+  blink::WebScreenInfo screen_info;
   screen_info.depth = dev_mode.dmBitsPerPel;
   screen_info.depthPerComponent = 8;
   screen_info.deviceScaleFactor = gfx::win::GetDeviceScaleFactor();
   screen_info.isMonochrome = dev_mode.dmColor == DMCOLOR_MONOCHROME;
   screen_info.rect = gfx::Rect(monitor_info.rcMonitor);
   screen_info.availableRect = gfx::Rect(monitor_info.rcWork);
 
   *results = screen_info;
 }
 
 }  // namespace
 
 const wchar_t kRenderWidgetHostHWNDClass[] = L"Chrome_RenderWidgetHostHWND";
 
 // Wrapper for maintaining touchstate associated with a WebTouchEvent.
 class WebTouchState {
  public:
   explicit WebTouchState(const RenderWidgetHostViewWin* window);
 
   // Updates the current touchpoint state with the supplied touches.
   // Touches will be consumed only if they are of the same type (e.g. down,
   // up, move). Returns the number of consumed touches.
   size_t UpdateTouchPoints(TOUCHINPUT* points, size_t count);
 
   // Marks all active touchpoints as released.
   bool ReleaseTouchPoints();
 
   // The contained WebTouchEvent.
-  const WebKit::WebTouchEvent& touch_event() { return touch_event_; }
+  const blink::WebTouchEvent& touch_event() { return touch_event_; }
 
   // Returns if any touches are modified in the event.
   bool is_changed() { return touch_event_.changedTouchesLength != 0; }
 
  private:
   // Adds a touch point or returns NULL if there's not enough space.
-  WebKit::WebTouchPoint* AddTouchPoint(TOUCHINPUT* touch_input);
+  blink::WebTouchPoint* AddTouchPoint(TOUCHINPUT* touch_input);
 
   // Copy details from a TOUCHINPUT to an existing WebTouchPoint, returning
   // true if the resulting point is a stationary move.
-  bool UpdateTouchPoint(WebKit::WebTouchPoint* touch_point,
+  bool UpdateTouchPoint(blink::WebTouchPoint* touch_point,
                         TOUCHINPUT* touch_input);
 
   // Find (or create) a mapping for _os_touch_id_.
   unsigned int GetMappedTouch(unsigned int os_touch_id);
 
   // Remove any mappings that are no longer in use.
   void RemoveExpiredMappings();
 
-  WebKit::WebTouchEvent touch_event_;
+  blink::WebTouchEvent touch_event_;
   const RenderWidgetHostViewWin* const window_;
 
   ui::SequentialIDGenerator id_generator_;
 
   DISALLOW_COPY_AND_ASSIGN(WebTouchState);
 };
 
 typedef void (*MetroSetFrameWindow)(HWND window);
 typedef void (*MetroCloseFrameWindow)(HWND window);
 
@@ skipping 203 matching lines @@
       FROM_HERE,
       base::Bind(base::IgnoreResult(&::DestroyWindow),
                  compositor_host_window_),
       base::TimeDelta::FromMilliseconds(kDestroyCompositorHostWindowDelay));
 
   compositor_host_window_ = NULL;
 }
 
 bool RenderWidgetHostViewWin::IsActivatable() const {
   // Popups should not be activated.
-  return popup_type_ == WebKit::WebPopupTypeNone;
+  return popup_type_ == blink::WebPopupTypeNone;
 }
 
 void RenderWidgetHostViewWin::Focus() {
   if (IsWindow())
     SetFocus();
 }
 
 void RenderWidgetHostViewWin::Blur() {
   NOTREACHED();
 }
@@ skipping 346 matching lines @@
     ui::GestureEvent* event) {
   ForwardGestureEventToRenderer(event);
 }
 
 void RenderWidgetHostViewWin::DispatchCancelTouchEvent(
     ui::TouchEvent* event) {
   if (!render_widget_host_ || !touch_events_enabled_ ||
       !render_widget_host_->ShouldForwardTouchEvent()) {
     return;
   }
-  DCHECK(event->type() == WebKit::WebInputEvent::TouchCancel);
-  WebKit::WebTouchEvent cancel_event;
-  cancel_event.type = WebKit::WebInputEvent::TouchCancel;
+  DCHECK(event->type() == blink::WebInputEvent::TouchCancel);
+  blink::WebTouchEvent cancel_event;
+  cancel_event.type = blink::WebInputEvent::TouchCancel;
   cancel_event.timeStampSeconds = event->time_stamp().InSecondsF();
   render_widget_host_->ForwardTouchEventWithLatencyInfo(
       cancel_event, *event->latency());
 }
 
 void RenderWidgetHostViewWin::SetHasHorizontalScrollbar(
     bool has_horizontal_scrollbar) {
 }
 
 void RenderWidgetHostViewWin::SetScrollOffsetPinning(
     bool is_pinned_to_left, bool is_pinned_to_right) {
 }
 
 void RenderWidgetHostViewWin::SetCompositionText(
     const ui::CompositionText& composition) {
   if (!base::win::IsTSFAwareRequired()) {
     NOTREACHED();
     return;
   }
   if (!render_widget_host_)
      return;
   // ui::CompositionUnderline should be identical to
-  // WebKit::WebCompositionUnderline, so that we can do reinterpret_cast safely.
+  // blink::WebCompositionUnderline, so that we can do reinterpret_cast safely.
   COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
-                 sizeof(WebKit::WebCompositionUnderline),
+                 sizeof(blink::WebCompositionUnderline),
                  ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
-  const std::vector<WebKit::WebCompositionUnderline>& underlines =
-      reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
+  const std::vector<blink::WebCompositionUnderline>& underlines =
+      reinterpret_cast<const std::vector<blink::WebCompositionUnderline>&>(
           composition.underlines);
   render_widget_host_->ImeSetComposition(composition.text, underlines,
                                          composition.selection.end(),
                                          composition.selection.end());
 }
 
 void RenderWidgetHostViewWin::ConfirmCompositionText()  {
   if (!base::win::IsTSFAwareRequired()) {
     NOTREACHED();
     return;
@@ skipping 651 matching lines @@
 LRESULT RenderWidgetHostViewWin::OnImeComposition(
     UINT message, WPARAM wparam, LPARAM lparam, BOOL& handled) {
   TRACE_EVENT0("browser", "RenderWidgetHostViewWin::OnImeComposition");
   if (!render_widget_host_)
     return 0;
 
   // At first, update the position of the IME window.
   imm32_manager_->UpdateImeWindow(m_hWnd);
 
   // ui::CompositionUnderline should be identical to
-  // WebKit::WebCompositionUnderline, so that we can do reinterpret_cast safely.
+  // blink::WebCompositionUnderline, so that we can do reinterpret_cast safely.
   COMPILE_ASSERT(sizeof(ui::CompositionUnderline) ==
-                 sizeof(WebKit::WebCompositionUnderline),
+                 sizeof(blink::WebCompositionUnderline),
                  ui_CompositionUnderline__WebKit_WebCompositionUnderline_diff);
 
   // Retrieve the result string and its attributes of the ongoing composition
   // and send it to a renderer process.
   ui::CompositionText composition;
   if (imm32_manager_->GetResult(m_hWnd, lparam, &composition.text)) {
     render_widget_host_->ImeConfirmComposition(
         composition.text, gfx::Range::InvalidRange(), false);
     imm32_manager_->ResetComposition(m_hWnd);
     // Fall though and try reading the composition string.
     // Japanese IMEs send a message containing both GCS_RESULTSTR and
     // GCS_COMPSTR, which means an ongoing composition has been finished
     // by the start of another composition.
   }
   // Retrieve the composition string and its attributes of the ongoing
   // composition and send it to a renderer process.
   if (imm32_manager_->GetComposition(m_hWnd, lparam, &composition)) {
     // TODO(suzhe): due to a bug of webkit, we can't use selection range with
     // composition string. See: https://bugs.webkit.org/show_bug.cgi?id=37788
     composition.selection = gfx::Range(composition.selection.end());
 
     // TODO(suzhe): convert both renderer_host and renderer to use
     // ui::CompositionText.
-    const std::vector<WebKit::WebCompositionUnderline>& underlines =
-        reinterpret_cast<const std::vector<WebKit::WebCompositionUnderline>&>(
+    const std::vector<blink::WebCompositionUnderline>& underlines =
+        reinterpret_cast<const std::vector<blink::WebCompositionUnderline>&>(
             composition.underlines);
     render_widget_host_->ImeSetComposition(
         composition.text, underlines,
         composition.selection.start(), composition.selection.end());
   }
   // We have to prevent WTL from calling ::DefWindowProc() because we do not
   // want for the IMM (Input Method Manager) to send WM_IME_CHAR messages.
   handled = TRUE;
   if (!can_compose_inline_) {
     // When the focus is on an element that does not draw composition by itself
@@ skipping 216 matching lines @@
   // Bug 9718: http://crbug.com/9718 To investigate IE and notepad, this
   // shortcut is enabled only on a PC having RTL keyboard layouts installed.
   // We should emulate them.
   if (ui::IMM32Manager::IsRTLKeyboardLayoutInstalled()) {
     if (message == WM_KEYDOWN) {
       if (wparam == VK_SHIFT) {
         base::i18n::TextDirection dir;
         if (ui::IMM32Manager::IsCtrlShiftPressed(&dir)) {
           render_widget_host_->UpdateTextDirection(
               dir == base::i18n::RIGHT_TO_LEFT ?
-              WebKit::WebTextDirectionRightToLeft :
-              WebKit::WebTextDirectionLeftToRight);
+              blink::WebTextDirectionRightToLeft :
+              blink::WebTextDirectionLeftToRight);
         }
       } else if (wparam != VK_CONTROL) {
         // Bug 9762: http://crbug.com/9762 A user pressed a key except shift
         // and control keys.
         // When a user presses a key while he/she holds control and shift keys,
         // we cancel sending an IPC message in NotifyTextDirection() below and
         // ignore succeeding UpdateTextDirection() calls while we call
         // NotifyTextDirection().
         // To cancel it, this call set a flag that prevents sending an IPC
         // message in NotifyTextDirection() only if we are going to send it.
@@ skipping 56 matching lines @@
   // dismiss them.
   if (m_hWnd != GetForegroundWindow()) {
     HWND toplevel_hwnd = ::GetAncestor(m_hWnd, GA_ROOT);
     EnumThreadWindows(
         GetCurrentThreadId(),
         DismissOwnedPopups,
         reinterpret_cast<LPARAM>(toplevel_hwnd));
   }
 
   if (render_widget_host_) {
-    WebKit::WebMouseWheelEvent wheel_event =
+    blink::WebMouseWheelEvent wheel_event =
         WebMouseWheelEventBuilder::Build(m_hWnd, message, wparam, lparam);
     float scale = gfx::win::GetDeviceScaleFactor();
     wheel_event.x /= scale;
     wheel_event.y /= scale;
     wheel_event.deltaX /= scale;
     wheel_event.deltaY /= scale;
 
     render_widget_host_->ForwardWheelEvent(wheel_event);
   }
   handled = TRUE;
   return 0;
 }
 
 WebTouchState::WebTouchState(const RenderWidgetHostViewWin* window)
     : window_(window),
       id_generator_(0) {
 }
 
 size_t WebTouchState::UpdateTouchPoints(
     TOUCHINPUT* points, size_t count) {
   // First we reset all touch event state. This involves removing any released
   // touchpoints and marking the rest as stationary. After that we go through
   // and alter/add any touchpoints (from the touch input buffer) that we can
   // coalesce into a single message. The return value is the number of consumed
   // input message.
-  WebKit::WebTouchPoint* point = touch_event_.touches;
-  WebKit::WebTouchPoint* end = point + touch_event_.touchesLength;
+  blink::WebTouchPoint* point = touch_event_.touches;
+  blink::WebTouchPoint* end = point + touch_event_.touchesLength;
   while (point < end) {
-    if (point->state == WebKit::WebTouchPoint::StateReleased) {
+    if (point->state == blink::WebTouchPoint::StateReleased) {
       *point = *(--end);
       --touch_event_.touchesLength;
     } else {
-      point->state = WebKit::WebTouchPoint::StateStationary;
+      point->state = blink::WebTouchPoint::StateStationary;
       point++;
     }
   }
   touch_event_.changedTouchesLength = 0;
   touch_event_.modifiers = content::EventFlagsToWebEventModifiers(
       ui::GetModifiersFromKeyState());
 
   // Consume all events of the same type and add them to the changed list.
   int last_type = 0;
   for (size_t i = 0; i < count; ++i) {
     unsigned int mapped_id = GetMappedTouch(points[i].dwID);
 
-    WebKit::WebTouchPoint* point = NULL;
+    blink::WebTouchPoint* point = NULL;
     for (unsigned j = 0; j < touch_event_.touchesLength; ++j) {
       if (static_cast<DWORD>(touch_event_.touches[j].id) == mapped_id) {
         point =  &touch_event_.touches[j];
         break;
       }
     }
 
     // Use a move instead if we see a down on a point we already have.
     int type = GetTouchType(points[i]);
     if (point && type == TOUCHEVENTF_DOWN)
       SetTouchType(&points[i], TOUCHEVENTF_MOVE);
 
     // Stop processing when the event type changes.
     if (touch_event_.changedTouchesLength && type != last_type)
       return i;
 
     touch_event_.timeStampSeconds = points[i].dwTime / 1000.0;
 
     last_type = type;
     switch (type) {
       case TOUCHEVENTF_DOWN: {
         if (!(point = AddTouchPoint(&points[i])))
           continue;
-        touch_event_.type = WebKit::WebInputEvent::TouchStart;
+        touch_event_.type = blink::WebInputEvent::TouchStart;
         break;
       }
 
       case TOUCHEVENTF_UP: {
         if (!point)  // Just throw away a stray up.
           continue;
-        point->state = WebKit::WebTouchPoint::StateReleased;
+        point->state = blink::WebTouchPoint::StateReleased;
         UpdateTouchPoint(point, &points[i]);
-        touch_event_.type = WebKit::WebInputEvent::TouchEnd;
+        touch_event_.type = blink::WebInputEvent::TouchEnd;
         break;
       }
 
       case TOUCHEVENTF_MOVE: {
         if (point) {
-          point->state = WebKit::WebTouchPoint::StateMoved;
+          point->state = blink::WebTouchPoint::StateMoved;
           // Don't update the message if the point didn't really move.
           if (UpdateTouchPoint(point, &points[i]))
             continue;
-          touch_event_.type = WebKit::WebInputEvent::TouchMove;
+          touch_event_.type = blink::WebInputEvent::TouchMove;
         } else if (touch_event_.changedTouchesLength) {
           RemoveExpiredMappings();
           // Can't add a point if we're already handling move events.
           return i;
         } else {
           // Treat a move with no existing point as a down.
           if (!(point = AddTouchPoint(&points[i])))
             continue;
           last_type = TOUCHEVENTF_DOWN;
           SetTouchType(&points[i], TOUCHEVENTF_DOWN);
-          touch_event_.type = WebKit::WebInputEvent::TouchStart;
+          touch_event_.type = blink::WebInputEvent::TouchStart;
         }
         break;
       }
 
       default:
         NOTREACHED();
         continue;
     }
     touch_event_.changedTouches[touch_event_.changedTouchesLength++] = *point;
   }
 
   RemoveExpiredMappings();
   return count;
 }
 
 void WebTouchState::RemoveExpiredMappings() {
-  WebKit::WebTouchPoint* point = touch_event_.touches;
-  WebKit::WebTouchPoint* end = point + touch_event_.touchesLength;
+  blink::WebTouchPoint* point = touch_event_.touches;
+  blink::WebTouchPoint* end = point + touch_event_.touchesLength;
   for (; point < end; ++point) {
-    if (point->state == WebKit::WebTouchPoint::StateReleased)
+    if (point->state == blink::WebTouchPoint::StateReleased)
       id_generator_.ReleaseGeneratedID(point->id);
   }
 }
 
 
 bool WebTouchState::ReleaseTouchPoints() {
   if (touch_event_.touchesLength == 0)
     return false;
   // Mark every active touchpoint as released.
-  touch_event_.type = WebKit::WebInputEvent::TouchEnd;
+  touch_event_.type = blink::WebInputEvent::TouchEnd;
   touch_event_.changedTouchesLength = touch_event_.touchesLength;
   for (unsigned int i = 0; i < touch_event_.touchesLength; ++i) {
-    touch_event_.touches[i].state = WebKit::WebTouchPoint::StateReleased;
+    touch_event_.touches[i].state = blink::WebTouchPoint::StateReleased;
     touch_event_.changedTouches[i].state =
-        WebKit::WebTouchPoint::StateReleased;
+        blink::WebTouchPoint::StateReleased;
   }
 
   return true;
 }
 
-WebKit::WebTouchPoint* WebTouchState::AddTouchPoint(
+blink::WebTouchPoint* WebTouchState::AddTouchPoint(
     TOUCHINPUT* touch_input) {
   DCHECK(touch_event_.touchesLength <
-      WebKit::WebTouchEvent::touchesLengthCap);
+      blink::WebTouchEvent::touchesLengthCap);
   if (touch_event_.touchesLength >=
-      WebKit::WebTouchEvent::touchesLengthCap)
+      blink::WebTouchEvent::touchesLengthCap)
     return NULL;
-  WebKit::WebTouchPoint* point =
+  blink::WebTouchPoint* point =
       &touch_event_.touches[touch_event_.touchesLength++];
-  point->state = WebKit::WebTouchPoint::StatePressed;
+  point->state = blink::WebTouchPoint::StatePressed;
   point->id = GetMappedTouch(touch_input->dwID);
   UpdateTouchPoint(point, touch_input);
   return point;
 }
 
 bool WebTouchState::UpdateTouchPoint(
-    WebKit::WebTouchPoint* touch_point,
+    blink::WebTouchPoint* touch_point,
     TOUCHINPUT* touch_input) {
   CPoint coordinates(
       TOUCH_COORD_TO_PIXEL(touch_input->x) /
       gfx::win::GetUndocumentedDPITouchScale(),
       TOUCH_COORD_TO_PIXEL(touch_input->y) /
       gfx::win::GetUndocumentedDPITouchScale());
   int radius_x = 1;
   int radius_y = 1;
   if (touch_input->dwMask & TOUCHINPUTMASKF_CONTACTAREA) {
     // Some touch drivers send a contact area of "-1", yet flag it as valid.
     radius_x = std::max(1,
         static_cast<int>(TOUCH_COORD_TO_PIXEL(touch_input->cxContact) /
                          gfx::win::GetUndocumentedDPITouchScale()));
     radius_y = std::max(1,
         static_cast<int>(TOUCH_COORD_TO_PIXEL(touch_input->cyContact) /
                          gfx::win::GetUndocumentedDPITouchScale()));
   }
 
   // Detect and exclude stationary moves.
   if (GetTouchType(*touch_input) == TOUCHEVENTF_MOVE &&
       touch_point->screenPosition.x == coordinates.x &&
       touch_point->screenPosition.y == coordinates.y &&
       touch_point->radiusX == radius_x &&
       touch_point->radiusY == radius_y) {
-    touch_point->state = WebKit::WebTouchPoint::StateStationary;
+    touch_point->state = blink::WebTouchPoint::StateStationary;
     return true;
   }
 
   touch_point->screenPosition.x = coordinates.x;
   touch_point->screenPosition.y = coordinates.y;
   window_->ScreenToClient(&coordinates);
   static float scale = gfx::win::GetDeviceScaleFactor();
   touch_point->position.x = coordinates.x / scale;
   touch_point->position.y = coordinates.y / scale;
   touch_point->radiusX = radius_x;
@@ skipping 14 matching lines @@
   // Finish the ongoing composition whenever a touch event happens.
   // It matches IE's behavior.
   if (base::win::IsTSFAwareRequired()) {
     ui::TSFBridge::GetInstance()->CancelComposition();
   } else {
     imm32_manager_->CleanupComposition(m_hWnd);
   }
 
   // TODO(jschuh): Add support for an arbitrary number of touchpoints.
   size_t total = std::min(static_cast<int>(LOWORD(wparam)),
-      static_cast<int>(WebKit::WebTouchEvent::touchesLengthCap));
-  TOUCHINPUT points[WebKit::WebTouchEvent::touchesLengthCap];
+      static_cast<int>(blink::WebTouchEvent::touchesLengthCap));
+  TOUCHINPUT points[blink::WebTouchEvent::touchesLengthCap];
 
   if (!total || !ui::GetTouchInputInfoWrapper((HTOUCHINPUT)lparam, total,
                                               points, sizeof(TOUCHINPUT))) {
     TRACE_EVENT0("browser", "EarlyOut_NothingToDo");
     return 0;
   }
 
   if (total == 1 && (points[0].dwFlags & TOUCHEVENTF_DOWN)) {
     pointer_down_context_ = true;
     last_touch_location_ = gfx::Point(
         TOUCH_COORD_TO_PIXEL(points[0].x) /
         gfx::win::GetUndocumentedDPITouchScale(),
         TOUCH_COORD_TO_PIXEL(points[0].y) /
         gfx::win::GetUndocumentedDPITouchScale());
   }
 
   bool should_forward = render_widget_host_->ShouldForwardTouchEvent() &&
       touch_events_enabled_;
 
   // Send a copy of the touch events on to the gesture recognizer.
   for (size_t start = 0; start < total;) {
     start += touch_state_->UpdateTouchPoints(points + start, total - start);
     if (should_forward) {
       if (touch_state_->is_changed())
         render_widget_host_->ForwardTouchEventWithLatencyInfo(
             touch_state_->touch_event(), ui::LatencyInfo());
     } else {
-      const WebKit::WebTouchEvent& touch_event = touch_state_->touch_event();
+      const blink::WebTouchEvent& touch_event = touch_state_->touch_event();
       base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(
           touch_event.timeStampSeconds * 1000);
       for (size_t i = 0; i < touch_event.touchesLength; ++i) {
         scoped_ptr<ui::GestureRecognizer::Gestures> gestures;
         gestures.reset(gesture_recognizer_->ProcessTouchEventForGesture(
             TouchEventFromWebTouchPoint(touch_event.touches[i], timestamp),
             ui::ER_UNHANDLED, this));
         ProcessGestures(gestures.get());
       }
     }
@@ skipping 210 matching lines @@
   }
 }
 
 void RenderWidgetHostViewWin::AcceleratedPaint(HDC dc) {
   if (render_widget_host_)
     render_widget_host_->ScheduleComposite();
   if (accelerated_surface_)
     accelerated_surface_->Present(dc);
 }
 
-void RenderWidgetHostViewWin::GetScreenInfo(WebKit::WebScreenInfo* results) {
+void RenderWidgetHostViewWin::GetScreenInfo(blink::WebScreenInfo* results) {
   GetScreenInfoForWindow(GetNativeViewId(), results);
 }
 
 gfx::Rect RenderWidgetHostViewWin::GetBoundsInRootWindow() {
   RECT window_rect = {0};
   HWND root_window = GetAncestor(m_hWnd, GA_ROOT);
   ::GetWindowRect(root_window, &window_rect);
   gfx::Rect rect(window_rect);
 
   // Maximized windows are outdented from the work area by the frame thickness
@@ skipping 371 matching lines @@
 
   // Pinch gestures are disabled by default on windows desktop. See
   // crbug.com/128477 and crbug.com/148816
   if ((gesture->type() == ui::ET_GESTURE_PINCH_BEGIN ||
       gesture->type() == ui::ET_GESTURE_PINCH_UPDATE ||
       gesture->type() == ui::ET_GESTURE_PINCH_END) &&
       !ShouldSendPinchGesture()) {
     return true;
   }
 
-  WebKit::WebGestureEvent web_gesture = CreateWebGestureEvent(m_hWnd, *gesture);
-  if (web_gesture.type == WebKit::WebGestureEvent::Undefined)
+  blink::WebGestureEvent web_gesture = CreateWebGestureEvent(m_hWnd, *gesture);
+  if (web_gesture.type == blink::WebGestureEvent::Undefined)
     return false;
-  if (web_gesture.type == WebKit::WebGestureEvent::GestureTapDown) {
+  if (web_gesture.type == blink::WebGestureEvent::GestureTapDown) {
     render_widget_host_->ForwardGestureEvent(
         CreateFlingCancelEvent(gesture->time_stamp().InSecondsF()));
   }
   render_widget_host_->ForwardGestureEventWithLatencyInfo(web_gesture,
                                                           *gesture->latency());
   return true;
 }
 
 void RenderWidgetHostViewWin::ForwardMouseEventToRenderer(UINT message,
                                                           WPARAM wparam,
@@ skipping 305 matching lines @@
 // RenderWidgetHostView, public:
 
 // static
 RenderWidgetHostView* RenderWidgetHostView::CreateViewForWidget(
     RenderWidgetHost* widget) {
   return new RenderWidgetHostViewWin(widget);
 }
 
 // static
 void RenderWidgetHostViewPort::GetDefaultScreenInfo(
-      WebKit::WebScreenInfo* results) {
+      blink::WebScreenInfo* results) {
   GetScreenInfoForWindow(0, results);
 }
 
 }  // namespace content