Rename WebKit namespace to blink (part 4)

chrome/browser/automation/testing_automation_provider.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 "chrome/browser/automation/testing_automation_provider.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
@@ skipping 646 matching lines @@
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
-  WebKit::WebMouseEvent mouse_event;
+  blink::WebMouseEvent mouse_event;
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
   int button;
   if (!args->GetInteger("button", &button)) {
     AutomationJSONReply(this, reply_message)
         .SendError("Mouse button missing or invalid");
     return;
   }
   if (button == automation::kLeftButton) {
-    mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
+    mouse_event.button = blink::WebMouseEvent::ButtonLeft;
   } else if (button == automation::kRightButton) {
-    mouse_event.button = WebKit::WebMouseEvent::ButtonRight;
+    mouse_event.button = blink::WebMouseEvent::ButtonRight;
   } else if (button == automation::kMiddleButton) {
-    mouse_event.button = WebKit::WebMouseEvent::ButtonMiddle;
+    mouse_event.button = blink::WebMouseEvent::ButtonMiddle;
   } else {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid button press requested");
     return;
   }
 
-  mouse_event.type = WebKit::WebInputEvent::MouseDown;
+  mouse_event.type = blink::WebInputEvent::MouseDown;
   mouse_event.clickCount = 1;
 
   view->ForwardMouseEvent(mouse_event);
 
-  mouse_event.type = WebKit::WebInputEvent::MouseUp;
+  mouse_event.type = blink::WebInputEvent::MouseUp;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseMove(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
-  WebKit::WebMouseEvent mouse_event;
+  blink::WebMouseEvent mouse_event;
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
-  mouse_event.type = WebKit::WebInputEvent::MouseMove;
+  mouse_event.type = blink::WebInputEvent::MouseMove;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseDrag(DictionaryValue* args,
                                                 IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
-  WebKit::WebMouseEvent mouse_event;
+  blink::WebMouseEvent mouse_event;
   int start_x, start_y, end_x, end_y;
   if (!args->GetInteger("start_x", &start_x) ||
       !args->GetInteger("start_y", &start_y) ||
       !args->GetInteger("end_x", &end_x) ||
       !args->GetInteger("end_y", &end_y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("Invalid start/end positions");
     return;
   }
 
-  mouse_event.type = WebKit::WebInputEvent::MouseMove;
+  mouse_event.type = blink::WebInputEvent::MouseMove;
   // Step 1- Move the mouse to the start position.
   mouse_event.x = start_x;
   mouse_event.y = start_y;
   view->ForwardMouseEvent(mouse_event);
 
   // Step 2- Left click mouse down, the mouse button is fixed.
-  mouse_event.type = WebKit::WebInputEvent::MouseDown;
-  mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
+  mouse_event.type = blink::WebInputEvent::MouseDown;
+  mouse_event.button = blink::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   view->ForwardMouseEvent(mouse_event);
 
   // Step 3 - Move the mouse to the end position.
-  mouse_event.type = WebKit::WebInputEvent::MouseMove;
+  mouse_event.type = blink::WebInputEvent::MouseMove;
   mouse_event.x = end_x;
   mouse_event.y = end_y;
   mouse_event.clickCount = 0;
   view->ForwardMouseEvent(mouse_event);
 
   // Step 4 - Release the left mouse button.
-  mouse_event.type = WebKit::WebInputEvent::MouseUp;
+  mouse_event.type = blink::WebInputEvent::MouseUp;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseButtonDown(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
-  WebKit::WebMouseEvent mouse_event;
+  blink::WebMouseEvent mouse_event;
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
-  mouse_event.type = WebKit::WebInputEvent::MouseDown;
-  mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
+  mouse_event.type = blink::WebInputEvent::MouseDown;
+  mouse_event.button = blink::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseButtonUp(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
-  WebKit::WebMouseEvent mouse_event;
+  blink::WebMouseEvent mouse_event;
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
-  mouse_event.type = WebKit::WebInputEvent::MouseUp;
-  mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
+  mouse_event.type = blink::WebInputEvent::MouseUp;
+  mouse_event.button = blink::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         1);
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::WebkitMouseDoubleClick(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
   if (!GetRenderViewFromJSONArgs(args, profile(), &view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
 
-  WebKit::WebMouseEvent mouse_event;
+  blink::WebMouseEvent mouse_event;
   if (!args->GetInteger("x", &mouse_event.x) ||
       !args->GetInteger("y", &mouse_event.y)) {
     AutomationJSONReply(this, reply_message)
         .SendError("(X,Y) coordinates missing or invalid");
     return;
   }
 
-  mouse_event.type = WebKit::WebInputEvent::MouseDown;
-  mouse_event.button = WebKit::WebMouseEvent::ButtonLeft;
+  mouse_event.type = blink::WebInputEvent::MouseDown;
+  mouse_event.button = blink::WebMouseEvent::ButtonLeft;
   mouse_event.clickCount = 1;
   view->ForwardMouseEvent(mouse_event);
 
-  mouse_event.type = WebKit::WebInputEvent::MouseUp;
+  mouse_event.type = blink::WebInputEvent::MouseUp;
   new InputEventAckNotificationObserver(this, reply_message, mouse_event.type,
                                         2);
   view->ForwardMouseEvent(mouse_event);
 
-  mouse_event.type = WebKit::WebInputEvent::MouseDown;
+  mouse_event.type = blink::WebInputEvent::MouseDown;
   mouse_event.clickCount = 2;
   view->ForwardMouseEvent(mouse_event);
 
-  mouse_event.type = WebKit::WebInputEvent::MouseUp;
+  mouse_event.type = blink::WebInputEvent::MouseUp;
   view->ForwardMouseEvent(mouse_event);
 }
 
 void TestingAutomationProvider::DragAndDropFilePaths(
     DictionaryValue* args, IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
   RenderViewHost* view;
   std::string error;
@@ skipping 29 matching lines @@
     drop_data.filenames.push_back(
         content::DropData::FileInfo(path, string16()));
   }
 
   const gfx::Point client(x, y);
   // We don't set any values in screen variable because DragTarget*** ignore the
   // screen argument.
   const gfx::Point screen;
 
   int operations = 0;
-  operations |= WebKit::WebDragOperationCopy;
-  operations |= WebKit::WebDragOperationLink;
-  operations |= WebKit::WebDragOperationMove;
+  operations |= blink::WebDragOperationCopy;
+  operations |= blink::WebDragOperationLink;
+  operations |= blink::WebDragOperationMove;
 
   view->DragTargetDragEnter(
       drop_data, client, screen,
-      static_cast<WebKit::WebDragOperationsMask>(operations), 0);
+      static_cast<blink::WebDragOperationsMask>(operations), 0);
   new DragTargetDropAckNotificationObserver(this, reply_message);
   view->DragTargetDrop(client, screen, 0);
 }
 
 void TestingAutomationProvider::GetTabCount(int handle, int* tab_count) {
   *tab_count = -1;  // -1 is the error code
 
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     *tab_count = browser->tab_strip_model()->count();
@@ skipping 3166 matching lines @@
     *error = "'windowsKeyCode' missing or invalid.";
     return false;
   }
   if (!args->GetInteger("modifiers", &modifiers)) {
     *error = "'modifiers' missing or invalid.";
     return false;
   }
   if (args->GetString("keyIdentifier", &key_identifier)) {
     base::strlcpy(event->keyIdentifier,
                   key_identifier.c_str(),
-                  WebKit::WebKeyboardEvent::keyIdentifierLengthCap);
+                  blink::WebKeyboardEvent::keyIdentifierLengthCap);
   } else {
     *error = "'keyIdentifier' missing or invalid.";
     return false;
   }
 
   if (type == automation::kRawKeyDownType) {
-    event->type = WebKit::WebInputEvent::RawKeyDown;
+    event->type = blink::WebInputEvent::RawKeyDown;
   } else if (type == automation::kKeyDownType) {
-    event->type = WebKit::WebInputEvent::KeyDown;
+    event->type = blink::WebInputEvent::KeyDown;
   } else if (type == automation::kKeyUpType) {
-    event->type = WebKit::WebInputEvent::KeyUp;
+    event->type = blink::WebInputEvent::KeyUp;
   } else if (type == automation::kCharType) {
-    event->type = WebKit::WebInputEvent::Char;
+    event->type = blink::WebInputEvent::Char;
   } else {
     *error = "'type' refers to an unrecognized keyboard event type";
     return false;
   }
 
   string16 unmodified_text_truncated = unmodified_text.substr(
-      0, WebKit::WebKeyboardEvent::textLengthCap - 1);
+      0, blink::WebKeyboardEvent::textLengthCap - 1);
   memcpy(event->unmodifiedText,
          unmodified_text_truncated.c_str(),
          unmodified_text_truncated.length() + 1);
   string16 text_truncated = text.substr(
-      0, WebKit::WebKeyboardEvent::textLengthCap - 1);
+      0, blink::WebKeyboardEvent::textLengthCap - 1);
   memcpy(event->text, text_truncated.c_str(), text_truncated.length() + 1);
 
   event->modifiers = 0;
   if (modifiers & automation::kShiftKeyMask)
-    event->modifiers |= WebKit::WebInputEvent::ShiftKey;
+    event->modifiers |= blink::WebInputEvent::ShiftKey;
   if (modifiers & automation::kControlKeyMask)
-    event->modifiers |= WebKit::WebInputEvent::ControlKey;
+    event->modifiers |= blink::WebInputEvent::ControlKey;
   if (modifiers & automation::kAltKeyMask)
-    event->modifiers |= WebKit::WebInputEvent::AltKey;
+    event->modifiers |= blink::WebInputEvent::AltKey;
   if (modifiers & automation::kMetaKeyMask)
-    event->modifiers |= WebKit::WebInputEvent::MetaKey;
+    event->modifiers |= blink::WebInputEvent::MetaKey;
 
   event->isSystemKey = is_system_key;
   event->timeStampSeconds = base::Time::Now().ToDoubleT();
   event->skip_in_browser = true;
   return true;
 }
 
 void TestingAutomationProvider::SendWebkitKeyEvent(
     DictionaryValue* args,
     IPC::Message* reply_message) {
@@ skipping 1292 matching lines @@
   if (g_browser_process)
     g_browser_process->GetAutomationProviderList()->RemoveProvider(this);
 }
 
 void TestingAutomationProvider::EnsureTabSelected(Browser* browser,
                                                   WebContents* tab) {
   TabStripModel* tab_strip = browser->tab_strip_model();
   if (tab_strip->GetActiveWebContents() != tab)
     tab_strip->ActivateTabAt(tab_strip->GetIndexOfWebContents(tab), true);
 }