Remove wstring from RVH's run Javascript command....

chrome/test/automation/tab_proxy.cc

 // Copyright (c) 2010 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/test/automation/tab_proxy.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/string16.h"
 #include "base/threading/platform_thread.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/common/automation_messages.h"
 #include "chrome/common/json_value_serializer.h"
 #include "chrome/test/automation/automation_proxy.h"
 #include "googleurl/src/gurl.h"
 
 TabProxy::TabProxy(AutomationMessageSender* sender,
                    AutomationHandleTracker* tracker,
                    int handle)
     : AutomationResourceProxy(tracker, sender, handle) {
 }
 
 
-bool TabProxy::GetTabTitle(std::wstring* title) const {
+bool TabProxy::GetTabTitle(string16* title) const {
   if (!is_valid())
     return false;
 
   if (!title) {
     NOTREACHED();
     return false;
   }
 
   int tab_title_size_response = 0;
 
@@ skipping 55 matching lines @@
 
   AutomationMsg_NavigationResponseValues navigate_response =
       AUTOMATION_MSG_NAVIGATION_ERROR;
 
  sender_->Send(new AutomationMsg_NavigateToURLBlockUntilNavigationsComplete(
       handle_, url, number_of_navigations, &navigate_response));
 
   return navigate_response;
 }
 
-bool TabProxy::SetAuth(const std::wstring& username,
-                       const std::wstring& password) {
+bool TabProxy::SetAuth(const string16& username,
+                       const string16& password) {
   if (!is_valid())
     return false;
 
   AutomationMsg_NavigationResponseValues navigate_response =
       AUTOMATION_MSG_NAVIGATION_ERROR;
   sender_->Send(new AutomationMsg_SetAuth(handle_, username, password,
                                           &navigate_response));
   return navigate_response == AUTOMATION_MSG_NAVIGATION_SUCCESS;
 }
 
@@ skipping 113 matching lines @@
     return false;
 
   if (!process_id) {
     NOTREACHED();
     return false;
   }
 
   return sender_->Send(new AutomationMsg_TabProcessID(handle_, process_id));
 }
 
-bool TabProxy::ExecuteAndExtractString(const std::wstring& frame_xpath,
-                                       const std::wstring& jscript,
-                                       std::wstring* string_value) {
+bool TabProxy::ExecuteAndExtractString(const string16& frame_xpath,
+                                       const string16& jscript,
+                                       string16* string_value) {
   Value* root = NULL;
   bool succeeded = ExecuteAndExtractValue(frame_xpath, jscript, &root);
   if (!succeeded)
     return false;
 
   DCHECK(root->IsType(Value::TYPE_LIST));
   Value* value = NULL;
   succeeded = static_cast<ListValue*>(root)->Get(0, &value);
   if (succeeded) {
     string16 read_value;
     succeeded = value->GetAsString(&read_value);
-    if (succeeded) {
-      // TODO(viettrungluu): remove conversion. (But should |jscript| be UTF-8?)
-      *string_value = UTF16ToWideHack(read_value);
-    }
+    if (succeeded)
+      *string_value = read_value;
   }
 
   delete root;
   return succeeded;
 }
 
-bool TabProxy::ExecuteAndExtractBool(const std::wstring& frame_xpath,
-                                     const std::wstring& jscript,
+bool TabProxy::ExecuteAndExtractBool(const string16& frame_xpath,
+                                     const string16& jscript,
                                      bool* bool_value) {
   Value* root = NULL;
   bool succeeded = ExecuteAndExtractValue(frame_xpath, jscript, &root);
   if (!succeeded)
     return false;
 
   bool read_value = false;
   DCHECK(root->IsType(Value::TYPE_LIST));
   Value* value = NULL;
   succeeded = static_cast<ListValue*>(root)->Get(0, &value);
   if (succeeded) {
     succeeded = value->GetAsBoolean(&read_value);
     if (succeeded) {
       *bool_value = read_value;
     }
   }
 
   delete value;
   return succeeded;
 }
 
-bool TabProxy::ExecuteAndExtractInt(const std::wstring& frame_xpath,
-                                    const std::wstring& jscript,
+bool TabProxy::ExecuteAndExtractInt(const string16& frame_xpath,
+                                    const string16& jscript,
                                     int* int_value) {
   Value* root = NULL;
   bool succeeded = ExecuteAndExtractValue(frame_xpath, jscript, &root);
   if (!succeeded)
     return false;
 
   int read_value = 0;
   DCHECK(root->IsType(Value::TYPE_LIST));
   Value* value = NULL;
   succeeded = static_cast<ListValue*>(root)->Get(0, &value);
   if (succeeded) {
     succeeded = value->GetAsInteger(&read_value);
     if (succeeded) {
       *int_value = read_value;
     }
   }
 
   delete value;
   return succeeded;
 }
 
-bool TabProxy::ExecuteAndExtractValue(const std::wstring& frame_xpath,
-                                      const std::wstring& jscript,
+bool TabProxy::ExecuteAndExtractValue(const string16& frame_xpath,
+                                      const string16& jscript,
                                       Value** value) {
   if (!is_valid())
     return false;
 
   if (!value) {
     NOTREACHED();
     return false;
   }
 
   std::string json;
@@ skipping 499 matching lines @@
 TabProxy::~TabProxy() {}
 
 bool TabProxy::ExecuteJavaScriptAndGetJSON(const std::string& script,
                                            std::string* json) {
   if (!is_valid())
     return false;
   if (!json) {
     NOTREACHED();
     return false;
   }
-  return sender_->Send(new AutomationMsg_DomOperation(handle_, L"",
-                                                      UTF8ToWide(script),
+  return sender_->Send(new AutomationMsg_DomOperation(handle_, string16(),
+                                                      UTF8ToUTF16(script),
                                                       json));
 }
 
 void TabProxy::FirstObjectAdded() {
   AddRef();
 }
 
 void TabProxy::LastObjectRemoved() {
   Release();
 }