Rename WebKit namespace to blink (part 3)

content/public/test/browser_test_utils.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/public/test/browser_test_utils.h"
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/path_service.h"
 #include "base/process/kill.h"
@@ skipping 100 matching lines @@
   base::JSONReader reader(base::JSON_ALLOW_TRAILING_COMMAS);
   result->reset(reader.ReadToValue(json));
   if (!result->get()) {
     DLOG(ERROR) << reader.GetErrorMessage();
     return false;
   }
 
   return true;
 }
 
-void BuildSimpleWebKeyEvent(WebKit::WebInputEvent::Type type,
+void BuildSimpleWebKeyEvent(blink::WebInputEvent::Type type,
                             ui::KeyboardCode key_code,
                             int native_key_code,
                             int modifiers,
                             NativeWebKeyboardEvent* event) {
   event->nativeKeyCode = native_key_code;
   event->windowsKeyCode = key_code;
   event->setKeyIdentifierFromWindowsKeyCode();
   event->type = type;
   event->modifiers = modifiers;
   event->isSystemKey = false;
   event->timeStampSeconds = base::Time::Now().ToDoubleT();
   event->skip_in_browser = true;
 
-  if (type == WebKit::WebInputEvent::Char ||
-      type == WebKit::WebInputEvent::RawKeyDown) {
+  if (type == blink::WebInputEvent::Char ||
+      type == blink::WebInputEvent::RawKeyDown) {
     event->text[0] = key_code;
     event->unmodifiedText[0] = key_code;
   }
 }
 
 void InjectRawKeyEvent(WebContents* web_contents,
-                       WebKit::WebInputEvent::Type type,
+                       blink::WebInputEvent::Type type,
                        ui::KeyboardCode key_code,
                        int native_key_code,
                        int modifiers) {
   NativeWebKeyboardEvent event;
   BuildSimpleWebKeyEvent(type, key_code, native_key_code, modifiers, &event);
   web_contents->GetRenderViewHost()->ForwardKeyboardEvent(event);
 }
 
 void GetCookiesCallback(std::string* cookies_out,
                         base::WaitableEvent* event,
@@ skipping 61 matching lines @@
   RenderProcessHost* rph = web_contents->GetRenderProcessHost();
   WindowedNotificationObserver observer(
       NOTIFICATION_RENDERER_PROCESS_CLOSED,
       Source<RenderProcessHost>(rph));
   base::KillProcess(rph->GetHandle(), 0, false);
   observer.Wait();
 }
 
 void SimulateMouseClick(WebContents* web_contents,
                         int modifiers,
-                        WebKit::WebMouseEvent::Button button) {
+                        blink::WebMouseEvent::Button button) {
   int x = web_contents->GetView()->GetContainerSize().width() / 2;
   int y = web_contents->GetView()->GetContainerSize().height() / 2;
   SimulateMouseClickAt(web_contents, modifiers, button, gfx::Point(x, y));
 }
 
 void SimulateMouseClickAt(WebContents* web_contents,
                           int modifiers,
-                          WebKit::WebMouseEvent::Button button,
+                          blink::WebMouseEvent::Button button,
                           const gfx::Point& point) {
-  WebKit::WebMouseEvent mouse_event;
-  mouse_event.type = WebKit::WebInputEvent::MouseDown;
+  blink::WebMouseEvent mouse_event;
+  mouse_event.type = blink::WebInputEvent::MouseDown;
   mouse_event.button = button;
   mouse_event.x = point.x();
   mouse_event.y = point.y();
   mouse_event.modifiers = modifiers;
   // Mac needs globalX/globalY for events to plugins.
   gfx::Rect offset;
   web_contents->GetView()->GetContainerBounds(&offset);
   mouse_event.globalX = point.x() + offset.x();
   mouse_event.globalY = point.y() + offset.y();
   mouse_event.clickCount = 1;
   web_contents->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
-  mouse_event.type = WebKit::WebInputEvent::MouseUp;
+  mouse_event.type = blink::WebInputEvent::MouseUp;
   web_contents->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
 }
 
 void SimulateMouseEvent(WebContents* web_contents,
-                        WebKit::WebInputEvent::Type type,
+                        blink::WebInputEvent::Type type,
                         const gfx::Point& point) {
-  WebKit::WebMouseEvent mouse_event;
+  blink::WebMouseEvent mouse_event;
   mouse_event.type = type;
   mouse_event.x = point.x();
   mouse_event.y = point.y();
   web_contents->GetRenderViewHost()->ForwardMouseEvent(mouse_event);
 }
 
 void SimulateKeyPress(WebContents* web_contents,
                       ui::KeyboardCode key_code,
                       bool control,
                       bool shift,
@@ skipping 11 matching lines @@
                               bool alt,
                               bool command) {
   ui::KeycodeConverter* key_converter = ui::KeycodeConverter::GetInstance();
   int native_key_code = key_converter->CodeToNativeKeycode(code);
 
   int modifiers = 0;
 
   // The order of these key down events shouldn't matter for our simulation.
   // For our simulation we can use either the left keys or the right keys.
   if (control) {
-    modifiers |= WebKit::WebInputEvent::ControlKey;
+    modifiers |= blink::WebInputEvent::ControlKey;
     InjectRawKeyEvent(
         web_contents,
-        WebKit::WebInputEvent::RawKeyDown,
+        blink::WebInputEvent::RawKeyDown,
         ui::VKEY_CONTROL,
         key_converter->CodeToNativeKeycode("ControlLeft"),
         modifiers);
   }
 
   if (shift) {
-    modifiers |= WebKit::WebInputEvent::ShiftKey;
+    modifiers |= blink::WebInputEvent::ShiftKey;
     InjectRawKeyEvent(
         web_contents,
-        WebKit::WebInputEvent::RawKeyDown,
+        blink::WebInputEvent::RawKeyDown,
         ui::VKEY_SHIFT,
         key_converter->CodeToNativeKeycode("ShiftLeft"),
         modifiers);
   }
 
   if (alt) {
-    modifiers |= WebKit::WebInputEvent::AltKey;
+    modifiers |= blink::WebInputEvent::AltKey;
     InjectRawKeyEvent(
         web_contents,
-        WebKit::WebInputEvent::RawKeyDown,
+        blink::WebInputEvent::RawKeyDown,
         ui::VKEY_MENU,
         key_converter->CodeToNativeKeycode("AltLeft"),
         modifiers);
   }
 
   if (command) {
-    modifiers |= WebKit::WebInputEvent::MetaKey;
+    modifiers |= blink::WebInputEvent::MetaKey;
     InjectRawKeyEvent(
         web_contents,
-        WebKit::WebInputEvent::RawKeyDown,
+        blink::WebInputEvent::RawKeyDown,
         ui::VKEY_COMMAND,
         key_converter->CodeToNativeKeycode("OSLeft"),
         modifiers);
   }
 
   InjectRawKeyEvent(
       web_contents,
-      WebKit::WebInputEvent::RawKeyDown,
+      blink::WebInputEvent::RawKeyDown,
       key_code,
       native_key_code,
       modifiers);
 
   InjectRawKeyEvent(
       web_contents,
-      WebKit::WebInputEvent::Char,
+      blink::WebInputEvent::Char,
       key_code,
       native_key_code,
       modifiers);
 
   InjectRawKeyEvent(
       web_contents,
-      WebKit::WebInputEvent::KeyUp,
+      blink::WebInputEvent::KeyUp,
       key_code,
       native_key_code,
       modifiers);
 
   // The order of these key releases shouldn't matter for our simulation.
   if (control) {
-    modifiers &= ~WebKit::WebInputEvent::ControlKey;
+    modifiers &= ~blink::WebInputEvent::ControlKey;
     InjectRawKeyEvent(
         web_contents,
-        WebKit::WebInputEvent::KeyUp,
+        blink::WebInputEvent::KeyUp,
         ui::VKEY_CONTROL,
         key_converter->CodeToNativeKeycode("ControlLeft"),
         modifiers);
   }
 
   if (shift) {
-    modifiers &= ~WebKit::WebInputEvent::ShiftKey;
+    modifiers &= ~blink::WebInputEvent::ShiftKey;
     InjectRawKeyEvent(
         web_contents,
-        WebKit::WebInputEvent::KeyUp,
+        blink::WebInputEvent::KeyUp,
         ui::VKEY_SHIFT,
         key_converter->CodeToNativeKeycode("ShiftLeft"),
         modifiers);
   }
 
   if (alt) {
-    modifiers &= ~WebKit::WebInputEvent::AltKey;
+    modifiers &= ~blink::WebInputEvent::AltKey;
     InjectRawKeyEvent(
         web_contents,
-        WebKit::WebInputEvent::KeyUp,
+        blink::WebInputEvent::KeyUp,
         ui::VKEY_MENU,
         key_converter->CodeToNativeKeycode("AltLeft"),
         modifiers);
   }
 
   if (command) {
-    modifiers &= ~WebKit::WebInputEvent::MetaKey;
+    modifiers &= ~blink::WebInputEvent::MetaKey;
     InjectRawKeyEvent(
         web_contents,
-        WebKit::WebInputEvent::KeyUp,
+        blink::WebInputEvent::KeyUp,
         ui::VKEY_COMMAND,
         key_converter->CodeToNativeKeycode("OSLeft"),
         modifiers);
   }
 
   ASSERT_EQ(modifiers, 0);
 }
 
 namespace internal {
 
@@ skipping 241 matching lines @@
   // The queue should not be empty, unless we were quit because of a timeout.
   if (message_queue_.empty())
     return false;
   if (message)
     *message = message_queue_.front();
   message_queue_.pop();
   return true;
 }
 
 }  // namespace content