Replace string16 with base::string16.

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 882 matching lines @@
   ListValue* paths = NULL;
   if (!args->GetList("paths", &paths)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'paths' missing or invalid");
     return;
   }
 
   // Emulate drag and drop to set the file paths to the file upload control.
   content::DropData drop_data;
   for (size_t path_index = 0; path_index < paths->GetSize(); ++path_index) {
-    string16 path;
+    base::string16 path;
     if (!paths->GetString(path_index, &path)) {
       AutomationJSONReply(this, reply_message)
           .SendError("'paths' contains a non-string type");
       return;
     }
 
     drop_data.filenames.push_back(
-        content::DropData::FileInfo(path, string16()));
+        content::DropData::FileInfo(path, base::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 |= blink::WebDragOperationCopy;
   operations |= blink::WebDragOperationLink;
@@ skipping 72 matching lines @@
   *success = false;
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* tab = tab_tracker_->GetResource(handle);
     // Return what the user would see in the location bar.
     *url = tab->GetActiveEntry()->GetVirtualURL();
     *success = true;
   }
 }
 
 void TestingAutomationProvider::ExecuteJavascriptInRenderViewFrame(
-    const string16& frame_xpath,
-    const string16& script,
+    const base::string16& frame_xpath,
+    const base::string16& script,
     IPC::Message* reply_message,
     RenderViewHost* render_view_host) {
   // Set the routing id of this message with the controller.
   // This routing id needs to be remembered for the reverse
   // communication while sending back the response of
   // this javascript execution.
   render_view_host->ExecuteJavascriptInWebFrame(
       frame_xpath,
       UTF8ToUTF16("window.domAutomationController.setAutomationId(0);"));
   render_view_host->ExecuteJavascriptInWebFrame(
@@ skipping 18 matching lines @@
                                      web_contents->GetRenderViewHost());
 }
 
 // Sample json input: { "command": "OpenNewBrowserWindowWithNewProfile" }
 // Sample output: {}
 void TestingAutomationProvider::OpenNewBrowserWindowWithNewProfile(
     base::DictionaryValue* args, IPC::Message* reply_message) {
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   new BrowserOpenedWithNewProfileNotificationObserver(this, reply_message);
   profile_manager->CreateMultiProfileAsync(
-      string16(), string16(), ProfileManager::CreateCallback(), std::string());
+      base::string16(), base::string16(), ProfileManager::CreateCallback(), std::string());
 }
 
 // Sample json input: { "command": "GetMultiProfileInfo" }
 // See GetMultiProfileInfo() in pyauto.py for sample output.
 void TestingAutomationProvider::GetMultiProfileInfo(
     base::DictionaryValue* args, IPC::Message* reply_message) {
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   const ProfileInfoCache& profile_info_cache =
       profile_manager->GetProfileInfoCache();
@@ skipping 236 matching lines @@
     return;
   }
 }
 
 void TestingAutomationProvider::AddBookmark(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg, url;
-  string16 title;
+  base::string16 title;
   int parent_id, index;
   bool folder;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   if (!args->GetBoolean("is_folder", &folder)) {
     reply.SendError("'is_folder' missing or invalid");
     return;
   }
@@ skipping 77 matching lines @@
   }
   model->Move(node, new_parent, index);
   reply.SendSuccess(NULL);
 }
 
 void TestingAutomationProvider::SetBookmarkTitle(DictionaryValue* args,
                                                  IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   Browser* browser;
   std::string error_msg;
-  string16 title;
+  base::string16 title;
   int id;
   if (!GetBrowserFromJSONArgs(args, &browser, &error_msg)) {
     reply.SendError(error_msg);
     return;
   }
   if (!args->GetInteger("id", &id)) {
     reply.SendError("'id' missing or invalid");
     return;
   }
   if (!args->GetString("title", &title)) {
@@ skipping 1000 matching lines @@
 }
 
 // Sample json input: { "command": "GetHistoryInfo",
 //                      "search_text": "some text" }
 // Refer chrome/test/pyautolib/history_info.py for sample json output.
 void TestingAutomationProvider::GetHistoryInfo(Browser* browser,
                                                DictionaryValue* args,
                                                IPC::Message* reply_message) {
   consumer_.CancelAllRequests();
 
-  string16 search_text;
+  base::string16 search_text;
   args->GetString("search_text", &search_text);
 
   // Fetch history.
   HistoryService* hs = HistoryServiceFactory::GetForProfile(
       browser->profile(), Profile::EXPLICIT_ACCESS);
   history::QueryOptions options;
   // The observer owns itself.  It deletes itself after it fetches history.
   AutomationProviderHistoryObserver* history_observer =
       new AutomationProviderHistoryObserver(this, reply_message);
   hs->QueryHistory(
@@ skipping 268 matching lines @@
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Refer to pyauto.py for sample JSON input.
 void TestingAutomationProvider::AddOrEditSearchEngine(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   TemplateURLService* url_model =
       TemplateURLServiceFactory::GetForProfile(browser->profile());
-  string16 new_title;
-  string16 new_keyword;
+  base::string16 new_title;
+  base::string16 new_keyword;
   std::string new_url;
   std::string keyword;
   if (!args->GetString("new_title", &new_title) ||
       !args->GetString("new_keyword", &new_keyword) ||
       !args->GetString("new_url", &new_url)) {
     AutomationJSONReply(this, reply_message).SendError(
         "One or more inputs invalid");
     return;
   }
   std::string new_ref_url = TemplateURLRef::DisplayURLToURLRef(
@@ skipping 195 matching lines @@
   return_value->Set("properties", properties);
 
   reply.SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "SetOmniboxText",
 //                      "text": "goog" }
 void TestingAutomationProvider::SetOmniboxText(Browser* browser,
                                                DictionaryValue* args,
                                                IPC::Message* reply_message) {
-  string16 text;
+  base::string16 text;
   AutomationJSONReply reply(this, reply_message);
   if (!args->GetString("text", &text)) {
     reply.SendError("text missing");
     return;
   }
   chrome::FocusLocationBar(browser);
   LocationBar* loc_bar = browser->window()->GetLocationBar();
   if (!loc_bar) {
     reply.SendError("The specified browser does not have a location bar.");
     return;
@@ skipping 218 matching lines @@
   // If the time is specified, change time to the specified time.
   base::Time time = base::Time::Now();
   int it;
   double dt;
   if (password_dict.GetInteger("time", &it))
     time = base::Time::FromTimeT(it);
   else if (password_dict.GetDouble("time", &dt))
     time = base::Time::FromDoubleT(dt);
 
   std::string signon_realm;
-  string16 username_value;
-  string16 password_value;
-  string16 origin_url_text;
-  string16 username_element;
-  string16 password_element;
-  string16 submit_element;
-  string16 action_target_text;
+  base::string16 username_value;
+  base::string16 password_value;
+  base::string16 origin_url_text;
+  base::string16 username_element;
+  base::string16 password_element;
+  base::string16 submit_element;
+  base::string16 action_target_text;
   bool blacklist;
-  string16 old_password_element;
-  string16 old_password_value;
+  base::string16 old_password_element;
+  base::string16 old_password_value;
 
   // We don't care if any of these fail - they are either optional or checked
   // before this function is called.
   password_dict.GetString("signon_realm", &signon_realm);
   password_dict.GetString("username_value", &username_value);
   password_dict.GetString("password_value", &password_value);
   password_dict.GetString("origin_url", &origin_url_text);
   password_dict.GetString("username_element", &username_element);
   password_dict.GetString("password_element", &password_element);
   password_dict.GetString("submit_element", &submit_element);
@@ skipping 159 matching lines @@
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   std::string error_message;
   WebContents* web_contents =
       GetWebContentsFromDict(browser, args, &error_message);
   if (!web_contents) {
     AutomationJSONReply(this, reply_message).SendError(error_message);
     return;
   }
-  string16 search_string;
+  base::string16 search_string;
   bool forward;
   bool match_case;
   bool find_next;
   if (!args->GetString("search_string", &search_string)) {
     AutomationJSONReply(this, reply_message).
         SendError("Must include search_string string.");
     return;
   }
   if (!args->GetBoolean("forward", &forward)) {
     AutomationJSONReply(this, reply_message).
@@ skipping 705 matching lines @@
   base::KillProcess(process, 0, false);
   base::CloseProcessHandle(process);
 }
 
 bool TestingAutomationProvider::BuildWebKeyEventFromArgs(
     DictionaryValue* args,
     std::string* error,
     NativeWebKeyboardEvent* event) {
   int type, modifiers;
   bool is_system_key;
-  string16 unmodified_text, text;
+  base::string16 unmodified_text, text;
   std::string key_identifier;
   if (!args->GetInteger("type", &type)) {
     *error = "'type' missing or invalid.";
     return false;
   }
   if (!args->GetBoolean("isSystemKey", &is_system_key)) {
     *error = "'isSystemKey' missing or invalid.";
     return false;
   }
   if (!args->GetString("unmodifiedText", &unmodified_text)) {
@@ skipping 31 matching lines @@
     event->type = blink::WebInputEvent::KeyDown;
   } else if (type == automation::kKeyUpType) {
     event->type = blink::WebInputEvent::KeyUp;
   } else if (type == automation::kCharType) {
     event->type = blink::WebInputEvent::Char;
   } else {
     *error = "'type' refers to an unrecognized keyboard event type";
     return false;
   }
 
-  string16 unmodified_text_truncated = unmodified_text.substr(
+  base::string16 unmodified_text_truncated = unmodified_text.substr(
       0, blink::WebKeyboardEvent::textLengthCap - 1);
   memcpy(event->unmodifiedText,
          unmodified_text_truncated.c_str(),
          unmodified_text_truncated.length() + 1);
-  string16 text_truncated = text.substr(
+  base::string16 text_truncated = text.substr(
       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 |= blink::WebInputEvent::ShiftKey;
   if (modifiers & automation::kControlKeyMask)
     event->modifiers |= blink::WebInputEvent::ControlKey;
   if (modifiers & automation::kAltKeyMask)
     event->modifiers |= blink::WebInputEvent::AltKey;
@@ skipping 566 matching lines @@
     return;
   }
 }
 
 void TestingAutomationProvider::ExecuteJavascriptJSON(
     DictionaryValue* args,
     IPC::Message* reply_message) {
   if (SendErrorIfModalDialogActive(this, reply_message))
     return;
 
-  string16 frame_xpath, javascript;
+  base::string16 frame_xpath, javascript;
   std::string error;
   RenderViewHost* render_view;
   if (!GetRenderViewFromJSONArgs(args, profile(), &render_view, &error)) {
     AutomationJSONReply(this, reply_message).SendError(error);
     return;
   }
   if (!args->GetString("frame_xpath", &frame_xpath)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'frame_xpath' missing or invalid");
     return;
   }
   if (!args->GetString("javascript", &javascript)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'javascript' missing or invalid");
     return;
   }
 
   new DomOperationMessageSender(this, reply_message, true);
   ExecuteJavascriptInRenderViewFrame(frame_xpath, javascript, reply_message,
                                      render_view);
 }
 
 void TestingAutomationProvider::ExecuteJavascriptInRenderView(
     DictionaryValue* args,
     IPC::Message* reply_message) {
-  string16 frame_xpath, javascript, extension_id, url_text;
+  base::string16 frame_xpath, javascript, extension_id, url_text;
   int render_process_id, render_view_id;
   if (!args->GetString("frame_xpath", &frame_xpath)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'frame_xpath' missing or invalid");
     return;
   }
   if (!args->GetString("javascript", &javascript)) {
     AutomationJSONReply(this, reply_message)
         .SendError("'javascript' missing or invalid");
     return;
@@ skipping 691 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);
 }