Remove wstring from autocomplete....

chrome/browser/automation/testing_automation_provider.cc

 // Copyright (c) 2011 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 "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/json/string_escape.h"
@@ skipping 997 matching lines @@
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser)
       *visible = browser->window()->IsFullscreenBubbleVisible();
   }
 }
 
 void TestingAutomationProvider::GetAutocompleteEditText(
     int autocomplete_edit_handle,
     bool* success,
-    std::wstring* text) {
+    string16* text) {
   *success = false;
   if (autocomplete_edit_tracker_->ContainsHandle(autocomplete_edit_handle)) {
     *text = autocomplete_edit_tracker_->GetResource(autocomplete_edit_handle)->
         GetText();
     *success = true;
   }
 }
 
 void TestingAutomationProvider::SetAutocompleteEditText(
     int autocomplete_edit_handle,
-    const std::wstring& text,
+    const string16& text,
     bool* success) {
   *success = false;
   if (autocomplete_edit_tracker_->ContainsHandle(autocomplete_edit_handle)) {
     autocomplete_edit_tracker_->GetResource(autocomplete_edit_handle)->
         SetUserText(text);
     *success = true;
   }
 }
 
 void TestingAutomationProvider::AutocompleteEditGetMatches(
@@ skipping 74 matching lines @@
   if (!tab_contents) {
     AutomationMsg_DomOperation::WriteReplyParams(reply_message, std::string());
     Send(reply_message);
     return;
   }
 
   // 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.
-  std::wstring set_automation_id;
+  std::string set_automation_id;
   base::SStringPrintf(&set_automation_id,
-                      L"window.domAutomationController.setAutomationId(%d);",
+                      "window.domAutomationController.setAutomationId(%d);",
                       reply_message->routing_id());
 
   DCHECK(reply_message_ == NULL);
   reply_message_ = reply_message;
 
   tab_contents->render_view_host()->ExecuteJavascriptInWebFrame(
-      frame_xpath, set_automation_id);
+      frame_xpath, UTF8ToWide(set_automation_id));
   tab_contents->render_view_host()->ExecuteJavascriptInWebFrame(
       frame_xpath, script);
 }
 
 void TestingAutomationProvider::GetConstrainedWindowCount(int handle,
                                                           int* count) {
   *count = -1;  // -1 is the error code
   if (tab_tracker_->ContainsHandle(handle)) {
     NavigationController* nav_controller = tab_tracker_->GetResource(handle);
     TabContents* tab_contents = nav_controller->tab_contents();
@@ skipping 1699 matching lines @@
   // Fill up matches.
   ListValue* matches = new ListValue;
   const AutocompleteResult& result = model->result();
   for (AutocompleteResult::const_iterator i = result.begin();
        i != result.end(); ++i) {
     const AutocompleteMatch& match = *i;
     DictionaryValue* item = new DictionaryValue;  // owned by return_value
     item->SetString("type", AutocompleteMatch::TypeToString(match.type));
     item->SetBoolean("starred", match.starred);
     item->SetString("destination_url", match.destination_url.spec());
-    item->SetString("contents", WideToUTF16Hack(match.contents));
-    item->SetString("description", WideToUTF16Hack(match.description));
+    item->SetString("contents", match.contents);
+    item->SetString("description", match.description);
     matches->Append(item);
   }
   return_value->Set("matches", matches);
 
   // Fill up other properties.
   DictionaryValue* properties = new DictionaryValue;  // owned by return_value
   properties->SetBoolean("has_focus", model->has_focus());
   properties->SetBoolean("query_in_progress", model->query_in_progress());
-  properties->SetString("keyword", WideToUTF16Hack(model->keyword()));
-  properties->SetString("text", WideToUTF16Hack(edit_view->GetText()));
+  properties->SetString("keyword", model->keyword());
+  properties->SetString("text", edit_view->GetText());
   return_value->Set("properties", properties);
 
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "SetOmniboxText",
 //                      "text": "goog" }
 void TestingAutomationProvider::SetOmniboxText(Browser* browser,
                                                DictionaryValue* args,
                                                IPC::Message* reply_message) {
   string16 text;
   AutomationJSONReply reply(this, reply_message);
   if (!args->GetString("text", &text)) {
     reply.SendError("text missing");
     return;
   }
   browser->FocusLocationBar();
   LocationBar* loc_bar = browser->window()->GetLocationBar();
   AutocompleteEditView* edit_view = loc_bar->location_entry();
   edit_view->model()->OnSetFocus(false);
-  edit_view->SetUserText(UTF16ToWideHack(text));
+  edit_view->SetUserText(text);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "OmniboxMovePopupSelection",
 //                      "count": 1 }
 // Negative count implies up, positive implies down. Count values will be
 // capped by the size of the popup list.
 void TestingAutomationProvider::OmniboxMovePopupSelection(
     Browser* browser,
     DictionaryValue* args,
@@ skipping 1140 matching lines @@
       reply.SendError("Disabling sync for given datatypes was unsuccessful");
     }
   }
 }
 
 /* static */
 ListValue* TestingAutomationProvider::GetListFromAutoFillProfiles(
     const std::vector<AutoFillProfile*>& autofill_profiles) {
   ListValue* profiles = new ListValue;
 
-  std::map<AutoFillFieldType, std::wstring> autofill_type_to_string
+  std::map<AutoFillFieldType, std::string> autofill_type_to_string
       = GetAutoFillFieldToStringMap();
 
   // For each AutoFillProfile, transform it to a dictionary object to return.
   for (std::vector<AutoFillProfile*>::const_iterator it =
            autofill_profiles.begin();
        it != autofill_profiles.end(); ++it) {
     AutoFillProfile* profile = *it;
     DictionaryValue* profile_info = new DictionaryValue;
     // For each of the types, if it has a value, add it to the dictionary.
-    for (std::map<AutoFillFieldType, std::wstring>::iterator
+    for (std::map<AutoFillFieldType, std::string>::iterator
          type_it = autofill_type_to_string.begin();
          type_it != autofill_type_to_string.end(); ++type_it) {
       string16 value = profile->GetFieldText(AutoFillType(type_it->first));
       if (value.length()) {  // If there was something stored for that value.
-        profile_info->SetString(WideToUTF8(type_it->second), value);
+        profile_info->SetString(type_it->second, value);
       }
     }
     profiles->Append(profile_info);
   }
   return profiles;
 }
 
 /* static */
 ListValue* TestingAutomationProvider::GetListFromCreditCards(
     const std::vector<CreditCard*>& credit_cards) {
   ListValue* cards = new ListValue;
 
-  std::map<AutoFillFieldType, std::wstring> credit_card_type_to_string =
+  std::map<AutoFillFieldType, std::string> credit_card_type_to_string =
       GetCreditCardFieldToStringMap();
 
   // For each AutoFillProfile, transform it to a dictionary object to return.
   for (std::vector<CreditCard*>::const_iterator it =
            credit_cards.begin();
        it != credit_cards.end(); ++it) {
     CreditCard* card = *it;
     DictionaryValue* card_info = new DictionaryValue;
     // For each of the types, if it has a value, add it to the dictionary.
-    for (std::map<AutoFillFieldType, std::wstring>::iterator type_it =
+    for (std::map<AutoFillFieldType, std::string>::iterator type_it =
         credit_card_type_to_string.begin();
         type_it != credit_card_type_to_string.end(); ++type_it) {
       string16 value = card->GetFieldText(AutoFillType(type_it->first));
       // If there was something stored for that value.
       if (value.length()) {
-        card_info->SetString(WideToUTF8(type_it->second), value);
+        card_info->SetString(type_it->second, value);
       }
     }
     cards->Append(card_info);
   }
   return cards;
 }
 
 /* static */
 std::vector<AutoFillProfile>
 TestingAutomationProvider::GetAutoFillProfilesFromList(
     const ListValue& profiles, std::string* error_message) {
   std::vector<AutoFillProfile> autofill_profiles;
   DictionaryValue* profile_info = NULL;
   string16 current_value;
 
-  std::map<AutoFillFieldType, std::wstring> autofill_type_to_string =
+  std::map<AutoFillFieldType, std::string> autofill_type_to_string =
       GetAutoFillFieldToStringMap();
 
   int num_profiles = profiles.GetSize();
   for (int i = 0; i < num_profiles; i++) {
     profiles.GetDictionary(i, &profile_info);
     AutoFillProfile profile;
     // Loop through the possible profile types and add those provided.
-    for (std::map<AutoFillFieldType, std::wstring>::iterator type_it =
+    for (std::map<AutoFillFieldType, std::string>::iterator type_it =
          autofill_type_to_string.begin();
          type_it != autofill_type_to_string.end(); ++type_it) {
-      if (profile_info->HasKey(WideToUTF8(type_it->second))) {
-        if (profile_info->GetString(WideToUTF8(type_it->second),
+      if (profile_info->HasKey(type_it->second)) {
+        if (profile_info->GetString(type_it->second,
                                     &current_value)) {
           profile.SetInfo(AutoFillType(type_it->first), current_value);
         } else {
           *error_message= "All values must be strings";
           break;
         }
       }
     }
     autofill_profiles.push_back(profile);
   }
   return autofill_profiles;
 }
 
 /* static */
 std::vector<CreditCard> TestingAutomationProvider::GetCreditCardsFromList(
     const ListValue& cards, std::string* error_message) {
   std::vector<CreditCard> credit_cards;
   DictionaryValue* card_info = NULL;
   string16 current_value;
 
-  std::map<AutoFillFieldType, std::wstring> credit_card_type_to_string =
+  std::map<AutoFillFieldType, std::string> credit_card_type_to_string =
       GetCreditCardFieldToStringMap();
 
   int num_credit_cards = cards.GetSize();
   for (int i = 0; i < num_credit_cards; i++) {
     cards.GetDictionary(i, &card_info);
     CreditCard card;
     // Loop through the possible credit card fields and add those provided.
-    for (std::map<AutoFillFieldType, std::wstring>::iterator type_it =
+    for (std::map<AutoFillFieldType, std::string>::iterator type_it =
         credit_card_type_to_string.begin();
         type_it != credit_card_type_to_string.end(); ++type_it) {
-      if (card_info->HasKey(WideToUTF8(type_it->second))) {
-        if (card_info->GetString(WideToUTF8(type_it->second), &current_value)) {
+      if (card_info->HasKey(type_it->second)) {
+        if (card_info->GetString(type_it->second, &current_value)) {
           card.SetInfo(AutoFillType(type_it->first), current_value);
         } else {
           *error_message= "All values must be strings";
           break;
         }
       }
     }
     credit_cards.push_back(card);
   }
   return credit_cards;
 }
 
 /* static */
-std::map<AutoFillFieldType, std::wstring>
+std::map<AutoFillFieldType, std::string>
     TestingAutomationProvider::GetAutoFillFieldToStringMap() {
-  std::map<AutoFillFieldType, std::wstring> autofill_type_to_string;
-  autofill_type_to_string[NAME_FIRST] = L"NAME_FIRST";
-  autofill_type_to_string[NAME_MIDDLE] = L"NAME_MIDDLE";
-  autofill_type_to_string[NAME_LAST] = L"NAME_LAST";
-  autofill_type_to_string[COMPANY_NAME] = L"COMPANY_NAME";
-  autofill_type_to_string[EMAIL_ADDRESS] = L"EMAIL_ADDRESS";
-  autofill_type_to_string[ADDRESS_HOME_LINE1] = L"ADDRESS_HOME_LINE1";
-  autofill_type_to_string[ADDRESS_HOME_LINE2] = L"ADDRESS_HOME_LINE2";
-  autofill_type_to_string[ADDRESS_HOME_CITY] = L"ADDRESS_HOME_CITY";
-  autofill_type_to_string[ADDRESS_HOME_STATE] = L"ADDRESS_HOME_STATE";
-  autofill_type_to_string[ADDRESS_HOME_ZIP] = L"ADDRESS_HOME_ZIP";
-  autofill_type_to_string[ADDRESS_HOME_COUNTRY] = L"ADDRESS_HOME_COUNTRY";
+  std::map<AutoFillFieldType, std::string> autofill_type_to_string;
+  autofill_type_to_string[NAME_FIRST] = "NAME_FIRST";
+  autofill_type_to_string[NAME_MIDDLE] = "NAME_MIDDLE";
+  autofill_type_to_string[NAME_LAST] = "NAME_LAST";
+  autofill_type_to_string[COMPANY_NAME] = "COMPANY_NAME";
+  autofill_type_to_string[EMAIL_ADDRESS] = "EMAIL_ADDRESS";
+  autofill_type_to_string[ADDRESS_HOME_LINE1] = "ADDRESS_HOME_LINE1";
+  autofill_type_to_string[ADDRESS_HOME_LINE2] = "ADDRESS_HOME_LINE2";
+  autofill_type_to_string[ADDRESS_HOME_CITY] = "ADDRESS_HOME_CITY";
+  autofill_type_to_string[ADDRESS_HOME_STATE] = "ADDRESS_HOME_STATE";
+  autofill_type_to_string[ADDRESS_HOME_ZIP] = "ADDRESS_HOME_ZIP";
+  autofill_type_to_string[ADDRESS_HOME_COUNTRY] = "ADDRESS_HOME_COUNTRY";
   autofill_type_to_string[PHONE_HOME_WHOLE_NUMBER] =
-      L"PHONE_HOME_WHOLE_NUMBER";
-  autofill_type_to_string[PHONE_FAX_WHOLE_NUMBER] = L"PHONE_FAX_WHOLE_NUMBER";
-  autofill_type_to_string[NAME_FIRST] = L"NAME_FIRST";
+      "PHONE_HOME_WHOLE_NUMBER";
+  autofill_type_to_string[PHONE_FAX_WHOLE_NUMBER] = "PHONE_FAX_WHOLE_NUMBER";
+  autofill_type_to_string[NAME_FIRST] = "NAME_FIRST";
   return autofill_type_to_string;
 }
 
 /* static */
-std::map<AutoFillFieldType, std::wstring>
+std::map<AutoFillFieldType, std::string>
     TestingAutomationProvider::GetCreditCardFieldToStringMap() {
-  std::map<AutoFillFieldType, std::wstring> credit_card_type_to_string;
-  credit_card_type_to_string[CREDIT_CARD_NAME] = L"CREDIT_CARD_NAME";
-  credit_card_type_to_string[CREDIT_CARD_NUMBER] = L"CREDIT_CARD_NUMBER";
-  credit_card_type_to_string[CREDIT_CARD_EXP_MONTH] = L"CREDIT_CARD_EXP_MONTH";
+  std::map<AutoFillFieldType, std::string> credit_card_type_to_string;
+  credit_card_type_to_string[CREDIT_CARD_NAME] = "CREDIT_CARD_NAME";
+  credit_card_type_to_string[CREDIT_CARD_NUMBER] = "CREDIT_CARD_NUMBER";
+  credit_card_type_to_string[CREDIT_CARD_EXP_MONTH] = "CREDIT_CARD_EXP_MONTH";
   credit_card_type_to_string[CREDIT_CARD_EXP_4_DIGIT_YEAR] =
-      L"CREDIT_CARD_EXP_4_DIGIT_YEAR";
+      "CREDIT_CARD_EXP_4_DIGIT_YEAR";
   return credit_card_type_to_string;
 }
 
 // Refer to GetActiveNotifications() in chrome/test/pyautolib/pyauto.py for
 // sample json input/output.
 void TestingAutomationProvider::GetActiveNotifications(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   new GetActiveNotificationsObserver(this, reply_message);
@@ skipping 307 matching lines @@
     // If you change this, update Observer for NotificationType::SESSION_END
     // below.
     MessageLoop::current()->PostTask(FROM_HERE,
         NewRunnableMethod(this, &TestingAutomationProvider::OnRemoveProvider));
   }
 }
 
 void TestingAutomationProvider::OnRemoveProvider() {
   AutomationProviderList::GetInstance()->RemoveProvider(this);
 }