Rename DictionaryValue's SetStringFromUTF16() to SetString() (and overload).

chrome/browser/automation/automation_provider.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/browser/automation/automation_provider.h"
 
 #include <set>
 
 #include "app/message_box_flags.h"
 #include "base/callback.h"
@@ skipping 1569 matching lines @@
     if (browser) {
       BookmarkModel* model = browser->profile()->GetBookmarkModel();
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* parent = model->GetNodeByID(parent_id);
       DCHECK(parent);
       if (parent) {
         const BookmarkNode* child = model->AddGroup(parent, index,
-                                                    WideToUTF16(title));
+                                                    WideToUTF16Hack(title));
         DCHECK(child);
         if (child)
           *success = true;
       }
     }
   }
   *success = false;
 }
 
 void AutomationProvider::AddBookmarkURL(int handle,
                                         int64 parent_id, int index,
                                         std::wstring title, const GURL& url,
                                         bool* success) {
   if (browser_tracker_->ContainsHandle(handle)) {
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
       BookmarkModel* model = browser->profile()->GetBookmarkModel();
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* parent = model->GetNodeByID(parent_id);
       DCHECK(parent);
       if (parent) {
         const BookmarkNode* child = model->AddURL(parent, index,
-                                                  WideToUTF16(title), url);
+                                                  WideToUTF16Hack(title), url);
         DCHECK(child);
         if (child)
           *success = true;
       }
     }
   }
   *success = false;
 }
 
 void AutomationProvider::ReparentBookmark(int handle,
@@ skipping 28 matching lines @@
     Browser* browser = browser_tracker_->GetResource(handle);
     if (browser) {
       BookmarkModel* model = browser->profile()->GetBookmarkModel();
       if (!model->IsLoaded()) {
         *success = false;
         return;
       }
       const BookmarkNode* node = model->GetNodeByID(id);
       DCHECK(node);
       if (node) {
-        model->SetTitle(node, WideToUTF16(title));
+        model->SetTitle(node, WideToUTF16Hack(title));
         *success = true;
       }
     }
   }
   *success = false;
 }
 
 void AutomationProvider::SetBookmarkURL(int handle,
                                         int64 id, const GURL& url,
                                         bool* success) {
@@ skipping 43 matching lines @@
 // Sample json input: { "command": "SetWindowDimensions",
 //                      "x": 20,         # optional
 //                      "y": 20,         # optional
 //                      "width": 800,    # optional
 //                      "height": 600 }  # optional
 void AutomationProvider::SetWindowDimensions(Browser* browser,
                                              DictionaryValue* args,
                                              IPC::Message* reply_message) {
   gfx::Rect rect = browser->window()->GetRestoredBounds();
   int x, y, width, height;
-  if (args->GetInteger(L"x", &x))
+  if (args->GetInteger("x", &x))
     rect.set_x(x);
-  if (args->GetInteger(L"y", &y))
+  if (args->GetInteger("y", &y))
     rect.set_y(y);
-  if (args->GetInteger(L"width", &width))
+  if (args->GetInteger("width", &width))
     rect.set_width(width);
-  if (args->GetInteger(L"height", &height))
+  if (args->GetInteger("height", &height))
     rect.set_height(height);
   browser->window()->SetBounds(rect);
   AutomationJSONReply(this, reply_message).SendSuccess(NULL);
 }
 
 ListValue* AutomationProvider::GetInfobarsInfo(TabContents* tc) {
   // Each infobar may have different properties depending on the type.
   ListValue* infobars = new ListValue;
   for (int infobar_index = 0;
        infobar_index < tc->infobar_delegate_count();
        ++infobar_index) {
     DictionaryValue* infobar_item = new DictionaryValue;
     InfoBarDelegate* infobar = tc->GetInfoBarDelegateAt(infobar_index);
     if (infobar->AsConfirmInfoBarDelegate()) {
       // Also covers ThemeInstalledInfoBarDelegate and
       // CrashedExtensionInfoBarDelegate.
-      infobar_item->SetString(L"type", "confirm_infobar");
+      infobar_item->SetString("type", "confirm_infobar");
       ConfirmInfoBarDelegate* confirm_infobar =
         infobar->AsConfirmInfoBarDelegate();
-      infobar_item->SetString(L"text", confirm_infobar->GetMessageText());
-      infobar_item->SetString(L"link_text", confirm_infobar->GetLinkText());
+      infobar_item->SetString("text",
+          WideToUTF16Hack(confirm_infobar->GetMessageText()));
+      infobar_item->SetString("link_text",
+                              WideToUTF16Hack(confirm_infobar->GetLinkText()));
       ListValue* buttons_list = new ListValue;
       int buttons = confirm_infobar->GetButtons();
       if (ConfirmInfoBarDelegate::BUTTON_OK & buttons) {
         StringValue* button_label = new StringValue(
             confirm_infobar->GetButtonLabel(
               ConfirmInfoBarDelegate::BUTTON_OK));
         buttons_list->Append(button_label);
       }
       if (ConfirmInfoBarDelegate::BUTTON_CANCEL & buttons) {
         StringValue* button_label = new StringValue(
             confirm_infobar->GetButtonLabel(
               ConfirmInfoBarDelegate::BUTTON_CANCEL));
         buttons_list->Append(button_label);
       }
-      infobar_item->Set(L"buttons", buttons_list);
+      infobar_item->Set("buttons", buttons_list);
     } else if (infobar->AsAlertInfoBarDelegate()) {
-      infobar_item->SetString(L"type", "alert_infobar");
+      infobar_item->SetString("type", "alert_infobar");
       AlertInfoBarDelegate* alert_infobar =
         infobar->AsAlertInfoBarDelegate();
-      infobar_item->SetString(L"text", alert_infobar->GetMessageText());
+      infobar_item->SetString("text",
+                              WideToUTF16Hack(alert_infobar->GetMessageText()));
     } else if (infobar->AsLinkInfoBarDelegate()) {
-      infobar_item->SetString(L"type", "link_infobar");
+      infobar_item->SetString("type", "link_infobar");
       LinkInfoBarDelegate* link_infobar = infobar->AsLinkInfoBarDelegate();
-      infobar_item->SetString(L"link_text", link_infobar->GetLinkText());
+      infobar_item->SetString("link_text",
+                              WideToUTF16Hack(link_infobar->GetLinkText()));
     } else if (infobar->AsTranslateInfoBarDelegate()) {
-      infobar_item->SetString(L"type", "translate_infobar");
+      infobar_item->SetString("type", "translate_infobar");
       TranslateInfoBarDelegate* translate_infobar =
           infobar->AsTranslateInfoBarDelegate();
-      infobar_item->SetString(L"original_lang_code",
+      infobar_item->SetString("original_lang_code",
                               translate_infobar->GetOriginalLanguageCode());
-      infobar_item->SetString(L"target_lang_code",
+      infobar_item->SetString("target_lang_code",
                               translate_infobar->GetTargetLanguageCode());
     } else if (infobar->AsExtensionInfoBarDelegate()) {
-      infobar_item->SetString(L"type", "extension_infobar");
+      infobar_item->SetString("type", "extension_infobar");
     } else {
-      infobar_item->SetString(L"type", "unknown_infobar");
+      infobar_item->SetString("type", "unknown_infobar");
     }
     infobars->Append(infobar_item);
   }
   return infobars;
 }
 
 // Sample json input: { "command": "WaitForInfobarCount",
 //                      "count": COUNT,
 //                      "tab_index": INDEX }
 // Sample output: {}
 void AutomationProvider::WaitForInfobarCount(Browser* browser,
                                         DictionaryValue* args,
                                         IPC::Message* reply_message) {
   int tab_index;
   int count;
-  if (!args->GetInteger(L"count", &count) || count < 0 ||
-      !args->GetInteger(L"tab_index", &tab_index) || tab_index < 0) {
+  if (!args->GetInteger("count", &count) || count < 0 ||
+      !args->GetInteger("tab_index", &tab_index) || tab_index < 0) {
     AutomationJSONReply(this, reply_message).SendError(
         "Missing or invalid args: 'count', 'tab_index'.");
     return;
   }
 
   TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
   // Observer deletes itself.
   new WaitForInfobarCountObserver(this, reply_message, tab_contents, count);
 }
 
 // Sample json input: { "command": "PerformActionOnInfobar",
 //                      "action": "dismiss",
 //                      "infobar_index": 0,
 //                      "tab_index": 0 }
 // Sample output: {}
 void AutomationProvider::PerformActionOnInfobar(Browser* browser,
                                                 DictionaryValue* args,
                                                 IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   int tab_index;
   int infobar_index;
   std::string action;
-  if (!args->GetInteger(L"tab_index", &tab_index) ||
-      !args->GetInteger(L"infobar_index", &infobar_index) ||
-      !args->GetString(L"action", &action)) {
+  if (!args->GetInteger("tab_index", &tab_index) ||
+      !args->GetInteger("infobar_index", &infobar_index) ||
+      !args->GetString("action", &action)) {
     reply.SendError("Invalid or missing args");
     return;
   }
   TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
   if (!tab_contents) {
     reply.SendError(StringPrintf("No such tab at index %d", tab_index));
     return;
   }
   InfoBarDelegate* infobar = NULL;
   if (infobar_index < 0 ||
@@ skipping 42 matching lines @@
   virtual void Run() {
     DCHECK(ChromeThread::CurrentlyOn(ChromeThread::IO));
     for (BrowserChildProcessHost::Iterator iter; !iter.Done(); ++iter) {
       // Only add processes which are already started,
       // since we need their handle.
       if ((*iter)->handle() == base::kNullProcessHandle) {
         continue;
       }
       ChildProcessInfo* info = *iter;
       DictionaryValue* item = new DictionaryValue;
-      item->SetString(L"name", info->name());
-      item->SetString(L"type",
-                      ChildProcessInfo::GetTypeNameInEnglish(info->type()));
-      item->SetInteger(L"pid", base::GetProcId(info->handle()));
+      item->SetString("name", WideToUTF16Hack(info->name()));
+      item->SetString("type",
+                      WideToUTF16Hack(ChildProcessInfo::GetTypeNameInEnglish(
+                          info->type())));
+      item->SetInteger("pid", base::GetProcId(info->handle()));
       child_processes_->Append(item);
     }
     event_->Signal();
   }
 
  private:
   base::WaitableEvent* const event_;  // weak
   ListValue* child_processes_;
 
   DISALLOW_COPY_AND_ASSIGN(GetChildProcessHostInfoTask);
 };
 
 }  // namespace
 
 // Sample json input: { "command": "GetBrowserInfo" }
 // Refer to GetBrowserInfo() in chrome/test/pyautolib/pyauto.py for
 // sample json output.
 void AutomationProvider::GetBrowserInfo(Browser* browser,
                                         DictionaryValue* args,
                                         IPC::Message* reply_message) {
   DictionaryValue* properties = new DictionaryValue;
-  properties->SetString(L"ChromeVersion", chrome::kChromeVersion);
-  properties->SetString(L"BrowserProcessExecutableName",
-                        chrome::kBrowserProcessExecutableName);
-  properties->SetString(L"HelperProcessExecutableName",
-                        chrome::kHelperProcessExecutableName);
-  properties->SetString(L"BrowserProcessExecutablePath",
-                        chrome::kBrowserProcessExecutablePath);
-  properties->SetString(L"HelperProcessExecutablePath",
+  properties->SetString("ChromeVersion", chrome::kChromeVersion);
+  properties->SetString("BrowserProcessExecutableName",
+                        WideToUTF16Hack(chrome::kBrowserProcessExecutableName));
+  properties->SetString("HelperProcessExecutableName",
+                        WideToUTF16Hack(chrome::kHelperProcessExecutableName));
+  properties->SetString("BrowserProcessExecutablePath",
+                        WideToUTF16Hack(chrome::kBrowserProcessExecutablePath));
+  properties->SetString("HelperProcessExecutablePath",
                         chrome::kHelperProcessExecutablePath);
-  properties->SetString(L"command_line_string",
+  properties->SetString("command_line_string",
       CommandLine::ForCurrentProcess()->command_line_string());
 
   std::string branding;
 #if defined(GOOGLE_CHROME_BUILD)
   branding = "Google Chrome";
 #elif defined(CHROMIUM_BUILD)
   branding = "Chromium";
 #else
   branding = "Unknown Branding";
 #endif
-  properties->SetString(L"branding", branding);
+  properties->SetString("branding", branding);
 
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  return_value->Set(L"properties", properties);
+  return_value->Set("properties", properties);
 
-  return_value->SetInteger(L"browser_pid", base::GetCurrentProcId());
+  return_value->SetInteger("browser_pid", base::GetCurrentProcId());
   // Add info about all windows in a list of dictionaries, one dictionary
   // item per window.
   ListValue* windows = new ListValue;
   int windex = 0;
   for (BrowserList::const_iterator it = BrowserList::begin();
        it != BrowserList::end();
        ++it, ++windex) {
     DictionaryValue* browser_item = new DictionaryValue;
     browser = *it;
-    browser_item->SetInteger(L"index", windex);
+    browser_item->SetInteger("index", windex);
     // Window properties
     gfx::Rect rect = browser->window()->GetRestoredBounds();
-    browser_item->SetInteger(L"x", rect.x());
-    browser_item->SetInteger(L"y", rect.y());
-    browser_item->SetInteger(L"width", rect.width());
-    browser_item->SetInteger(L"height", rect.height());
-    browser_item->SetBoolean(L"fullscreen",
+    browser_item->SetInteger("x", rect.x());
+    browser_item->SetInteger("y", rect.y());
+    browser_item->SetInteger("width", rect.width());
+    browser_item->SetInteger("height", rect.height());
+    browser_item->SetBoolean("fullscreen",
                              browser->window()->IsFullscreen());
-    browser_item->SetInteger(L"selected_tab", browser->selected_index());
-    browser_item->SetBoolean(L"incognito",
+    browser_item->SetInteger("selected_tab", browser->selected_index());
+    browser_item->SetBoolean("incognito",
                              browser->profile()->IsOffTheRecord());
     // For each window, add info about all tabs in a list of dictionaries,
     // one dictionary item per tab.
     ListValue* tabs = new ListValue;
     for (int i = 0; i < browser->tab_count(); ++i) {
       TabContents* tc = browser->GetTabContentsAt(i);
       DictionaryValue* tab = new DictionaryValue;
-      tab->SetInteger(L"index", i);
-      tab->SetString(L"url", tc->GetURL().spec());
-      tab->SetInteger(L"renderer_pid",
+      tab->SetInteger("index", i);
+      tab->SetString("url", tc->GetURL().spec());
+      tab->SetInteger("renderer_pid",
                       base::GetProcId(tc->GetRenderProcessHost()->GetHandle()));
-      tab->Set(L"infobars", GetInfobarsInfo(tc));
+      tab->Set("infobars", GetInfobarsInfo(tc));
       tabs->Append(tab);
     }
-    browser_item->Set(L"tabs", tabs);
+    browser_item->Set("tabs", tabs);
 
     windows->Append(browser_item);
   }
-  return_value->Set(L"windows", windows);
+  return_value->Set("windows", windows);
 
-  return_value->SetString(L"child_process_path",
+  return_value->SetString("child_process_path",
                           ChildProcessHost::GetChildPath(true).value());
   // Child processes are the processes for plugins and other workers.
   // Add all child processes in a list of dictionaries, one dictionary item
   // per child process.
   ListValue* child_processes = new ListValue;
   base::WaitableEvent event(true   /* manual reset */,
                             false  /* not initially signaled */);
   CHECK(ChromeThread::PostTask(
       ChromeThread::IO, FROM_HERE,
       new GetChildProcessHostInfoTask(&event, child_processes)));
   event.Wait();
-  return_value->Set(L"child_processes", child_processes);
+  return_value->Set("child_processes", child_processes);
 
   // Add all extension processes in a list of dictionaries, one dictionary
   // item per extension process.
   ListValue* extension_processes = new ListValue;
   ProfileManager* profile_manager = g_browser_process->profile_manager();
   for (ProfileManager::const_iterator it = profile_manager->begin();
        it != profile_manager->end(); ++it) {
     ExtensionProcessManager* process_manager =
         (*it)->GetExtensionProcessManager();
     ExtensionProcessManager::const_iterator jt;
     for (jt = process_manager->begin(); jt != process_manager->end(); ++jt) {
       ExtensionHost* ex_host = *jt;
       // Don't add dead extension processes.
       if (!ex_host->IsRenderViewLive())
         continue;
       DictionaryValue* item = new DictionaryValue;
-      item->SetString(L"name", ex_host->extension()->name());
+      item->SetString("name", ex_host->extension()->name());
       item->SetInteger(
-          L"pid",
+          "pid",
           base::GetProcId(ex_host->render_process_host()->GetHandle()));
       extension_processes->Append(item);
     }
   }
-  return_value->Set(L"extension_processes", extension_processes);
+  return_value->Set("extension_processes", extension_processes);
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "GetHistoryInfo",
 //                      "search_text": "some text" }
 // Refer chrome/test/pyautolib/history_info.py for sample json output.
 void AutomationProvider::GetHistoryInfo(Browser* browser,
                                         DictionaryValue* args,
                                         IPC::Message* reply_message) {
   consumer_.CancelAllRequests();
@@ skipping 18 matching lines @@
 // Sample json input: { "command": "AddHistoryItem",
 //                      "item": { "URL": "http://www.google.com",
 //                                "title": "Google",   # optional
 //                                "time": 12345        # optional (time_t)
 //                               } }
 // Refer chrome/test/pyautolib/pyauto.py for details on input.
 void AutomationProvider::AddHistoryItem(Browser* browser,
                                         DictionaryValue* args,
                                         IPC::Message* reply_message) {
   DictionaryValue* item = NULL;
-  args->GetDictionary(L"item", &item);
+  args->GetDictionary("item", &item);
   string16 url_text;
   string16 title;
   base::Time time = base::Time::Now();
   AutomationJSONReply reply(this, reply_message);
 
   if (!item->GetString("url", &url_text)) {
     reply.SendError("bad args (no URL in dict?)");
     return;
   }
   GURL gurl(url_text);
   item->GetString("title", &title);  // Don't care if it fails.
   int it;
   double dt;
-  if (item->GetInteger(L"time", &it))
+  if (item->GetInteger("time", &it))
     time = base::Time::FromTimeT(it);
-  else if (item->GetReal(L"time", &dt))
+  else if (item->GetReal("time", &dt))
     time = base::Time::FromDoubleT(dt);
 
   // Ideas for "dummy" values (e.g. id_scope) came from
   // chrome/browser/autocomplete/history_contents_provider_unittest.cc
   HistoryService* hs = profile_->GetHistoryService(Profile::EXPLICIT_ACCESS);
   const void* id_scope = reinterpret_cast<void*>(1);
   hs->AddPage(gurl, time,
               id_scope,
               0,
               GURL(),
@@ skipping 31 matching lines @@
   safety_state_to_string[DownloadItem::SAFE] = std::string("SAFE");
   safety_state_to_string[DownloadItem::DANGEROUS] = std::string("DANGEROUS");
   safety_state_to_string[DownloadItem::DANGEROUS_BUT_VALIDATED] =
       std::string("DANGEROUS_BUT_VALIDATED");
 
   ListValue* list_of_downloads = new ListValue;
   for (std::vector<DownloadItem*>::iterator it = downloads.begin();
        it != downloads.end();
        it++) {  // Fill info about each download item.
     DictionaryValue* dl_item_value = new DictionaryValue;
-    dl_item_value->SetInteger(L"id", static_cast<int>((*it)->id()));
-    dl_item_value->SetString(L"url", (*it)->url().spec());
-    dl_item_value->SetString(L"referrer_url", (*it)->referrer_url().spec());
-    dl_item_value->SetString(L"file_name", (*it)->GetFileName().value());
-    dl_item_value->SetString(L"full_path", (*it)->full_path().value());
-    dl_item_value->SetBoolean(L"is_paused", (*it)->is_paused());
-    dl_item_value->SetBoolean(L"open_when_complete",
+    dl_item_value->SetInteger("id", static_cast<int>((*it)->id()));
+    dl_item_value->SetString("url", (*it)->url().spec());
+    dl_item_value->SetString("referrer_url", (*it)->referrer_url().spec());
+    dl_item_value->SetString("file_name", (*it)->GetFileName().value());
+    dl_item_value->SetString("full_path", (*it)->full_path().value());
+    dl_item_value->SetBoolean("is_paused", (*it)->is_paused());
+    dl_item_value->SetBoolean("open_when_complete",
                               (*it)->open_when_complete());
-    dl_item_value->SetBoolean(L"is_extension_install",
+    dl_item_value->SetBoolean("is_extension_install",
                               (*it)->is_extension_install());
-    dl_item_value->SetBoolean(L"is_temporary", (*it)->is_temporary());
-    dl_item_value->SetBoolean(L"is_otr", (*it)->is_otr());  // off-the-record
-    dl_item_value->SetString(L"state", state_to_string[(*it)->state()]);
-    dl_item_value->SetString(L"safety_state",
+    dl_item_value->SetBoolean("is_temporary", (*it)->is_temporary());
+    dl_item_value->SetBoolean("is_otr", (*it)->is_otr());  // off-the-record
+    dl_item_value->SetString("state", state_to_string[(*it)->state()]);
+    dl_item_value->SetString("safety_state",
                              safety_state_to_string[(*it)->safety_state()]);
-    dl_item_value->SetInteger(L"PercentComplete", (*it)->PercentComplete());
+    dl_item_value->SetInteger("PercentComplete", (*it)->PercentComplete());
     list_of_downloads->Append(dl_item_value);
   }
-  return_value->Set(L"downloads", list_of_downloads);
+  return_value->Set("downloads", list_of_downloads);
 
   reply.SendSuccess(return_value.get());
   // All value objects allocated above are owned by |return_value|
   // and get freed by it.
 }
 
 void AutomationProvider::WaitForDownloadsToComplete(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
@@ skipping 29 matching lines @@
                                       DictionaryValue* args,
                                       IPC::Message* reply_message) {
   const PrefService::PreferenceSet& prefs =
       profile_->GetPrefs()->preference_set();
   DictionaryValue* items = new DictionaryValue;
   for (PrefService::PreferenceSet::const_iterator it = prefs.begin();
        it != prefs.end(); ++it) {
     items->Set((*it)->name(), (*it)->GetValue()->DeepCopy());
   }
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  return_value->Set(L"prefs", items);  // return_value owns items.
+  return_value->Set("prefs", items);  // return_value owns items.
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "SetPrefs", "path": path, "value": value }
 void AutomationProvider::SetPrefs(Browser* browser,
                                   DictionaryValue* args,
                                   IPC::Message* reply_message) {
   std::wstring path;
   Value* val;
   AutomationJSONReply reply(this, reply_message);
-  if (args->GetString(L"path", &path) && args->Get(L"value", &val)) {
+  if (args->GetString(L"path", &path) && args->Get("value", &val)) {
     PrefService* pref_service = profile_->GetPrefs();
     const PrefService::Preference* pref =
         pref_service->FindPreference(path.c_str());
     if (!pref) {  // Not a registered pref.
       reply.SendError("pref not registered.");
       return;
     } else if (pref->IsManaged()) {  // Do not attempt to change a managed pref.
       reply.SendError("pref is managed. cannot be changed.");
       return;
     } else {  // Set the pref.
@@ skipping 18 matching lines @@
   AutocompleteEditView* edit_view = loc_bar->location_entry();
   AutocompleteEditModel* model = edit_view->model();
 
   // 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(L"type", AutocompleteMatch::TypeToString(match.type));
-    item->SetBoolean(L"starred", match.starred);
-    item->SetString(L"destination_url", match.destination_url.spec());
-    item->SetString(L"contents", match.contents);
-    item->SetString(L"description", match.description);
+    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));
     matches->Append(item);
   }
-  return_value->Set(L"matches", matches);
+  return_value->Set("matches", matches);
 
   // Fill up other properties.
   DictionaryValue* properties = new DictionaryValue;  // owned by return_value
-  properties->SetBoolean(L"has_focus", model->has_focus());
-  properties->SetBoolean(L"query_in_progress", model->query_in_progress());
-  properties->SetString(L"keyword", model->keyword());
-  properties->SetString(L"text", edit_view->GetText());
-  return_value->Set(L"properties", properties);
+  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()));
+  return_value->Set("properties", properties);
 
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "SetOmniboxText",
 //                      "text": "goog" }
 void AutomationProvider::SetOmniboxText(Browser* browser,
                                         DictionaryValue* args,
                                         IPC::Message* reply_message) {
   std::wstring text;
@@ skipping 13 matching lines @@
 // 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 AutomationProvider::OmniboxMovePopupSelection(
     Browser* browser,
     DictionaryValue* args,
     IPC::Message* reply_message) {
   int count;
   AutomationJSONReply reply(this, reply_message);
-  if (!args->GetInteger(L"count", &count)) {
+  if (!args->GetInteger("count", &count)) {
     reply.SendError("count missing");
     return;
   }
   LocationBar* loc_bar = browser->window()->GetLocationBar();
   AutocompleteEditModel* model = loc_bar->location_entry()->model();
   model->OnUpOrDownKeyPressed(count);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input: { "command": "OmniboxAcceptInput" }
@@ skipping 31 matching lines @@
 void AutomationProvider::GetPluginsInfo(Browser* browser,
                                         DictionaryValue* args,
                                         IPC::Message* reply_message) {
   std::vector<WebPluginInfo> plugins;
   NPAPI::PluginList::Singleton()->GetPlugins(false, &plugins);
   ListValue* items = new ListValue;
   for (std::vector<WebPluginInfo>::const_iterator it = plugins.begin();
        it != plugins.end();
        ++it) {
     DictionaryValue* item = new DictionaryValue;
-    item->SetStringFromUTF16(L"name", it->name);
-    item->SetString(L"path", it->path.value());
-    item->SetStringFromUTF16(L"version", it->version);
-    item->SetStringFromUTF16(L"desc", it->desc);
-    item->SetBoolean(L"enabled", it->enabled);
+    item->SetString("name", it->name);
+    item->SetString("path", it->path.value());
+    item->SetString("version", it->version);
+    item->SetString("desc", it->desc);
+    item->SetBoolean("enabled", it->enabled);
     // Add info about mime types.
     ListValue* mime_types = new ListValue();
     for (std::vector<WebPluginMimeType>::const_iterator type_it =
              it->mime_types.begin();
          type_it != it->mime_types.end();
          ++type_it) {
       DictionaryValue* mime_type = new DictionaryValue();
-      mime_type->SetString(L"mimeType", type_it->mime_type);
-      mime_type->SetStringFromUTF16(L"description", type_it->description);
+      mime_type->SetString("mimeType", type_it->mime_type);
+      mime_type->SetString("description", type_it->description);
 
       ListValue* file_extensions = new ListValue();
       for (std::vector<std::string>::const_iterator ext_it =
                type_it->file_extensions.begin();
            ext_it != type_it->file_extensions.end();
            ++ext_it) {
         file_extensions->Append(new StringValue(*ext_it));
       }
-      mime_type->Set(L"fileExtensions", file_extensions);
+      mime_type->Set("fileExtensions", file_extensions);
 
       mime_types->Append(mime_type);
     }
-    item->Set(L"mimeTypes", mime_types);
+    item->Set("mimeTypes", mime_types);
     items->Append(item);
   }
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  return_value->Set(L"plugins", items);  // return_value owns items.
+  return_value->Set("plugins", items);  // return_value owns items.
 
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Sample json input:
 //    { "command": "EnablePlugin",
 //      "path": "/Library/Internet Plug-Ins/Flash Player.plugin" }
 void AutomationProvider::EnablePlugin(Browser* browser,
                                       DictionaryValue* args,
                                       IPC::Message* reply_message) {
   FilePath::StringType path;
   AutomationJSONReply reply(this, reply_message);
-  if (!args->GetString(L"path", &path)) {
+  if (!args->GetString("path", &path)) {
     reply.SendError("path not specified.");
     return;
   } else if (!NPAPI::PluginList::Singleton()->EnablePlugin(FilePath(path))) {
     reply.SendError(StringPrintf("Could not enable plugin for path %s.",
                                  path.c_str()));
     return;
   }
   reply.SendSuccess(NULL);
 }
 
 // Sample json input:
 //    { "command": "DisablePlugin",
 //      "path": "/Library/Internet Plug-Ins/Flash Player.plugin" }
 void AutomationProvider::DisablePlugin(Browser* browser,
                                        DictionaryValue* args,
                                        IPC::Message* reply_message) {
   FilePath::StringType path;
   AutomationJSONReply reply(this, reply_message);
-  if (!args->GetString(L"path", &path)) {
+  if (!args->GetString("path", &path)) {
     reply.SendError("path not specified.");
     return;
   } else if (!NPAPI::PluginList::Singleton()->DisablePlugin(FilePath(path))) {
     reply.SendError(StringPrintf("Could not disable plugin for path %s.",
                                  path.c_str()));
     return;
   }
   reply.SendSuccess(NULL);
 }
 
 // Sample json input:
 //    { "command": "SaveTabContents",
 //      "tab_index": 0,
 //      "filename": <a full pathname> }
 // Sample json output:
 //    {}
 void AutomationProvider::SaveTabContents(Browser* browser,
                                          DictionaryValue* args,
                                          IPC::Message* reply_message) {
   int tab_index = 0;
   FilePath::StringType filename;
   FilePath::StringType parent_directory;
   TabContents* tab_contents = NULL;
 
-  if (!args->GetInteger(L"tab_index", &tab_index) ||
-      !args->GetString(L"filename", &filename)) {
+  if (!args->GetInteger("tab_index", &tab_index) ||
+      !args->GetString("filename", &filename)) {
     AutomationJSONReply(this, reply_message).SendError(
         "tab_index or filename param missing");
     return;
   } else {
     tab_contents = browser->GetTabContentsAt(tab_index);
     if (!tab_contents) {
       AutomationJSONReply(this, reply_message).SendError(
           "no tab at tab_index");
       return;
     }
@@ skipping 27 matching lines @@
   string_to_import_item["SEARCH_ENGINES"] = importer::SEARCH_ENGINES;
   string_to_import_item["HOME_PAGE"] = importer::HOME_PAGE;
   string_to_import_item["ALL"] = importer::ALL;
 
   std::wstring browser_name;
   int import_items = 0;
   ListValue* import_items_list = NULL;
   bool first_run;
 
   if (!args->GetString(L"import_from", &browser_name) ||
-      !args->GetBoolean(L"first_run", &first_run) ||
-      !args->GetList(L"import_items", &import_items_list)) {
+      !args->GetBoolean("first_run", &first_run) ||
+      !args->GetList("import_items", &import_items_list)) {
     AutomationJSONReply(this, reply_message).SendError(
         "Incorrect type for one or more of the arguments.");
     return;
   }
 
   int num_items = import_items_list->GetSize();
   for (int i = 0; i < num_items; i++) {
     std::string item;
     import_items_list->GetString(i, &item);
     // If the provided string is not part of the map, error out.
@@ skipping 35 matching lines @@
 namespace {
 
 // Translates a dictionary password to a PasswordForm struct.
 webkit_glue::PasswordForm GetPasswordFormFromDict(
     const DictionaryValue& password_dict) {
 
   // 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(L"time", &it))
+  if (password_dict.GetInteger("time", &it))
     time = base::Time::FromTimeT(it);
-  else if (password_dict.GetReal(L"time", &dt))
+  else if (password_dict.GetReal("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;
   bool blacklist = false;
   string16 old_password_element;
   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(L"signon_realm", &signon_realm);
-  password_dict.GetStringAsUTF16(L"username_value", &username_value);
-  password_dict.GetStringAsUTF16(L"password_value", &password_value);
-  password_dict.GetStringAsUTF16(L"origin_url", &origin_url_text);
-  password_dict.GetStringAsUTF16(L"username_element", &username_element);
-  password_dict.GetStringAsUTF16(L"password_element", &password_element);
-  password_dict.GetStringAsUTF16(L"submit_element", &submit_element);
-  password_dict.GetStringAsUTF16(L"action_target", &action_target_text);
-  password_dict.GetBoolean(L"blacklist", &blacklist);
+  password_dict.GetString("signon_realm", &signon_realm);
+  password_dict.GetStringAsUTF16("username_value", &username_value);
+  password_dict.GetStringAsUTF16("password_value", &password_value);
+  password_dict.GetStringAsUTF16("origin_url", &origin_url_text);
+  password_dict.GetStringAsUTF16("username_element", &username_element);
+  password_dict.GetStringAsUTF16("password_element", &password_element);
+  password_dict.GetStringAsUTF16("submit_element", &submit_element);
+  password_dict.GetStringAsUTF16("action_target", &action_target_text);
+  password_dict.GetBoolean("blacklist", &blacklist);
 
   GURL origin_gurl(origin_url_text);
   GURL action_target(action_target_text);
 
   webkit_glue::PasswordForm password_form;
   password_form.signon_realm = signon_realm;
   password_form.username_value = username_value;
   password_form.password_value = password_value;
   password_form.origin = origin_gurl;
   password_form.username_element = username_element;
@@ skipping 10 matching lines @@
 
 // See AddSavedPassword() in chrome/test/functional/pyauto.py for sample json
 // input.
 // Sample json output: { "password_added": true }
 void AutomationProvider::AddSavedPassword(Browser* browser,
                                           DictionaryValue* args,
                                           IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   DictionaryValue* password_dict = NULL;
 
-  if (!args->GetDictionary(L"password", &password_dict)) {
+  if (!args->GetDictionary("password", &password_dict)) {
     reply.SendError("Password must be a dictionary.");
     return;
   }
 
   // The signon realm is effectively the primary key and must be included.
   // Check here before calling GetPasswordFormFromDict.
-  if (!password_dict->HasKey(L"signon_realm")) {
+  if (!password_dict->HasKey("signon_realm")) {
     reply.SendError("Password must include signon_realm.");
     return;
   }
   webkit_glue::PasswordForm new_password =
       GetPasswordFormFromDict(*password_dict);
 
   Profile* profile = browser->profile();
   // Use IMPLICIT_ACCESS since new passwords aren't added off the record.
   PasswordStore* password_store =
       profile->GetPasswordStore(Profile::IMPLICIT_ACCESS);
 
   // Set the return based on whether setting the password succeeded.
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   // It will be null if it's accessed in an incognito window.
   if (password_store != NULL) {
     password_store->AddLogin(new_password);
-    return_value->SetBoolean(L"password_added", true);
+    return_value->SetBoolean("password_added", true);
   } else {
-    return_value->SetBoolean(L"password_added", false);
+    return_value->SetBoolean("password_added", false);
   }
 
   reply.SendSuccess(return_value.get());
 }
 
 // See RemoveSavedPassword() in chrome/test/functional/pyauto.py for sample
 // json input.
 // Sample json output: {}
 void AutomationProvider::RemoveSavedPassword(Browser* browser,
                                              DictionaryValue* args,
                                              IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   DictionaryValue* password_dict = NULL;
 
-  if (!args->GetDictionary(L"password", &password_dict)) {
+  if (!args->GetDictionary("password", &password_dict)) {
     reply.SendError("Password must be a dictionary.");
     return;
   }
 
   // The signon realm is effectively the primary key and must be included.
   // Check here before calling GetPasswordFormFromDict.
-  if (!password_dict->HasKey(L"signon_realm")) {
+  if (!password_dict->HasKey("signon_realm")) {
     reply.SendError("Password must include signon_realm.");
     return;
   }
   webkit_glue::PasswordForm to_remove =
       GetPasswordFormFromDict(*password_dict);
 
   Profile* profile = browser->profile();
   // Use EXPLICIT_ACCESS since passwords can be removed off the record.
   PasswordStore* password_store =
       profile->GetPasswordStore(Profile::EXPLICIT_ACCESS);
@@ skipping 33 matching lines @@
   std::map<std::string, int> string_to_mask_value;
   string_to_mask_value["HISTORY"] = BrowsingDataRemover::REMOVE_HISTORY;
   string_to_mask_value["DOWNLOADS"] = BrowsingDataRemover::REMOVE_DOWNLOADS;
   string_to_mask_value["COOKIES"] = BrowsingDataRemover::REMOVE_COOKIES;
   string_to_mask_value["PASSWORDS"] = BrowsingDataRemover::REMOVE_PASSWORDS;
   string_to_mask_value["FORM_DATA"] = BrowsingDataRemover::REMOVE_FORM_DATA;
   string_to_mask_value["CACHE"] = BrowsingDataRemover::REMOVE_CACHE;
 
   std::string time_period;
   ListValue* to_remove;
-  if (!args->GetString(L"time_period", &time_period) ||
-      !args->GetList(L"to_remove", &to_remove)) {
+  if (!args->GetString("time_period", &time_period) ||
+      !args->GetList("to_remove", &to_remove)) {
     AutomationJSONReply(this, reply_message).SendError(
         "time_period must be a string and to_remove a list.");
     return;
   }
 
   int remove_mask = 0;
   int num_removals = to_remove->GetSize();
   for (int i = 0; i < num_removals; i++) {
     std::string removal;
     to_remove->GetString(i, &removal);
@@ skipping 22 matching lines @@
   // The observer also deletes itself after sending the reply.
 }
 
 namespace {
 
   // Get the TabContents from a dictionary of arguments.
   TabContents* GetTabContentsFromDict(const Browser* browser,
                                       const DictionaryValue* args,
                                       std::string* error_message) {
     int tab_index;
-    if (!args->GetInteger(L"tab_index", &tab_index)) {
+    if (!args->GetInteger("tab_index", &tab_index)) {
       *error_message = "Must include tab_index.";
       return NULL;
     }
 
     TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
     if (!tab_contents) {
       *error_message = StringPrintf("No tab at index %d.", tab_index);
       return NULL;
     }
     return tab_contents;
@@ skipping 59 matching lines @@
   }
 
   TranslateInfoBarDelegate* translate_bar =
       GetTranslateInfoBarDelegate(tab_contents);
   if (!translate_bar) {
     AutomationJSONReply(this, reply_message)
         .SendError("There is no translate bar open.");
     return;
   }
 
-  if (!args->GetString(L"option", &option)) {
+  if (!args->GetString("option", &option)) {
     AutomationJSONReply(this, reply_message).SendError("Must include option");
     return;
   }
 
   if (option == "translate_page") {
     // Make a new notification observer which will send the reply.
     new PageTranslatedObserver(this, reply_message, tab_contents);
     translate_bar->Translate();
     return;
   }
@@ skipping 42 matching lines @@
     new PageTranslatedObserver(this, reply_message, tab_contents);
     return;
   }
   // Otherwise send back the success or failure of the attempted translation
   // based on the translate bar state.
   AutomationJSONReply reply(this, reply_message);
   TranslateInfoBarDelegate* translate_bar =
       GetTranslateInfoBarDelegate(tab_contents);
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   if (!translate_bar) {
-    return_value->SetBoolean(L"translation_success", false);
+    return_value->SetBoolean("translation_success", false);
   } else {
     return_value->SetBoolean(
-        L"translation_success",
+        "translation_success",
         translate_bar->type() == TranslateInfoBarDelegate::AFTER_TRANSLATE);
   }
   reply.SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "GetThemeInfo" }
 // Refer GetThemeInfo() in chrome/test/pyautolib/pyauto.py for sample output.
 void AutomationProvider::GetThemeInfo(Browser* browser,
                                       DictionaryValue* args,
                                       IPC::Message* reply_message) {
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   Extension* theme = browser->profile()->GetTheme();
   if (theme) {
-    return_value->SetString(L"name", theme->name());
-    return_value->Set(L"images", theme->GetThemeImages()->DeepCopy());
-    return_value->Set(L"colors", theme->GetThemeColors()->DeepCopy());
-    return_value->Set(L"tints", theme->GetThemeTints()->DeepCopy());
+    return_value->SetString("name", theme->name());
+    return_value->Set("images", theme->GetThemeImages()->DeepCopy());
+    return_value->Set("colors", theme->GetThemeColors()->DeepCopy());
+    return_value->Set("tints", theme->GetThemeTints()->DeepCopy());
   }
   AutomationJSONReply(this, reply_message).SendSuccess(return_value.get());
 }
 
 // Sample json input: { "command": "GetExtensionsInfo" }
 // See GetExtensionsInfo() in chrome/test/pyautolib/pyauto.py for sample json
 // output.
 void AutomationProvider::GetExtensionsInfo(Browser* browser,
                                            DictionaryValue* args,
                                            IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   ExtensionsService* service = profile()->GetExtensionsService();
   if (!service) {
     reply.SendError("No extensions service.");
   }
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   ListValue* extensions_values = new ListValue;
   const ExtensionList* extensions = service->extensions();
   for (ExtensionList::const_iterator it = extensions->begin();
        it != extensions->end(); ++it) {
     const Extension* extension = *it;
     DictionaryValue* extension_value = new DictionaryValue;
-    extension_value->SetString(L"id", extension->id());
-    extension_value->SetString(L"version", extension->VersionString());
-    extension_value->SetString(L"name", extension->name());
-    extension_value->SetString(L"public_key", extension->public_key());
-    extension_value->SetString(L"description", extension->description());
-    extension_value->SetString(L"background_url",
+    extension_value->SetString("id", extension->id());
+    extension_value->SetString("version", extension->VersionString());
+    extension_value->SetString("name", extension->name());
+    extension_value->SetString("public_key", extension->public_key());
+    extension_value->SetString("description", extension->description());
+    extension_value->SetString("background_url",
                                extension->background_url().spec());
-    extension_value->SetString(L"options_url",
+    extension_value->SetString("options_url",
                                extension->options_url().spec());
     extensions_values->Append(extension_value);
   }
-  return_value->Set(L"extensions", extensions_values);
+  return_value->Set("extensions", extensions_values);
   reply.SendSuccess(return_value.get());
 }
 
 // See UninstallExtensionById() in chrome/test/pyautolib/pyauto.py for sample
 // json input.
 // Sample json output: {}
 void AutomationProvider::UninstallExtensionById(Browser* browser,
                                                 DictionaryValue* args,
                                                 IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   std::string id;
-  if (!args->GetString(L"id", &id)) {
+  if (!args->GetString("id", &id)) {
     reply.SendError("Must include string id.");
     return;
   }
   ExtensionsService* service = profile()->GetExtensionsService();
   if (!service) {
     reply.SendError("No extensions service.");
     return;
   }
   ExtensionUnloadNotificationObserver observer;
   service->UninstallExtension(id, false);
   reply.SendSuccess(NULL);
 }
 
 // Sample json input:
 //    { "command": "GetAutoFillProfile" }
 // Refer to GetAutoFillProfile() in chrome/test/pyautolib/pyauto.py for sample
 // json output.
 void AutomationProvider::GetAutoFillProfile(Browser* browser,
                                             DictionaryValue* args,
                                             IPC::Message* reply_message) {
   // Get the AutoFillProfiles currently in the database.
   int tab_index = 0;
-  args->GetInteger(L"tab_index", &tab_index);
+  args->GetInteger("tab_index", &tab_index);
   TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
   AutomationJSONReply reply(this, reply_message);
 
   if (tab_contents) {
     PersonalDataManager* pdm = tab_contents->profile()->GetOriginalProfile()
         ->GetPersonalDataManager();
     if (pdm) {
       std::vector<AutoFillProfile*> autofill_profiles = pdm->profiles();
       std::vector<CreditCard*> credit_cards = pdm->credit_cards();
 
       ListValue* profiles = GetListFromAutoFillProfiles(autofill_profiles);
       ListValue* cards = GetListFromCreditCards(credit_cards);
 
       scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
-      return_value->Set(L"profiles", profiles);
-      return_value->Set(L"credit_cards", cards);
+      return_value->Set("profiles", profiles);
+      return_value->Set("credit_cards", cards);
       reply.SendSuccess(return_value.get());
     } else {
       reply.SendError("No PersonalDataManager.");
       return;
     }
   } else {
     reply.SendError("No tab at that index.");
     return;
   }
 }
 
 // Refer to FillAutoFillProfile() in chrome/test/pyautolib/pyauto.py for sample
 // json input.
 // Sample json output: {}
 void AutomationProvider::FillAutoFillProfile(Browser* browser,
                                              DictionaryValue* args,
                                              IPC::Message* reply_message) {
   AutomationJSONReply reply(this, reply_message);
   ListValue* profiles = NULL;
   ListValue* cards = NULL;
-  args->GetList(L"profiles", &profiles);
-  args->GetList(L"credit_cards", &cards);
+  args->GetList("profiles", &profiles);
+  args->GetList("credit_cards", &cards);
   std::string error_mesg;
 
   std::vector<AutoFillProfile> autofill_profiles;
   std::vector<CreditCard> credit_cards;
   // Create an AutoFillProfile for each of the dictionary profiles.
   if (profiles) {
     autofill_profiles = GetAutoFillProfilesFromList(*profiles, &error_mesg);
   }
   // Create a CreditCard for each of the dictionary values.
   if (cards) {
     credit_cards = GetCreditCardsFromList(*cards, &error_mesg);
   }
   if (!error_mesg.empty()) {
     reply.SendError(error_mesg);
     return;
   }
 
   // Save the AutoFillProfiles.
   int tab_index = 0;
-  args->GetInteger(L"tab_index", &tab_index);
+  args->GetInteger("tab_index", &tab_index);
   TabContents* tab_contents = browser->GetTabContentsAt(tab_index);
 
   if (tab_contents) {
     PersonalDataManager* pdm = tab_contents->profile()
         ->GetPersonalDataManager();
     if (pdm) {
       pdm->OnAutoFillDialogApply(profiles? &autofill_profiles : NULL,
                                  cards? &credit_cards : NULL);
     } else {
       reply.SendError("No PersonalDataManager.");
@@ skipping 12 matching lines @@
   ListValue* profiles = new ListValue;
 
   std::map<AutoFillFieldType, std::wstring> autofill_type_to_string
       = GetAutoFillFieldToStringMap();
 
   // For each AutoFillProfile, transform it to a dictionary object to return.
   for (std::vector<AutoFillProfile*>::iterator it = autofill_profiles.begin();
        it != autofill_profiles.end(); ++it) {
     AutoFillProfile* profile = *it;
     DictionaryValue* profile_info = new DictionaryValue;
-    profile_info->SetStringFromUTF16(L"label", profile->Label());
+    profile_info->SetString("label", profile->Label());
     // For each of the types, if it has a value, add it to the dictionary.
     for (std::map<AutoFillFieldType, std::wstring>::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->SetStringFromUTF16(type_it->second, value);
+        profile_info->SetString(type_it->second, value);
       }
     }
     profiles->Append(profile_info);
   }
   return profiles;
 }
 
 /* static */
 ListValue* AutomationProvider::GetListFromCreditCards(
     std::vector<CreditCard*> credit_cards) {
   ListValue* cards = new ListValue;
 
   std::map<AutoFillFieldType, std::wstring> credit_card_type_to_string =
       GetCreditCardFieldToStringMap();
 
   // For each AutoFillProfile, transform it to a dictionary object to return.
   for (std::vector<CreditCard*>::iterator it = credit_cards.begin();
        it != credit_cards.end(); ++it) {
     CreditCard* card = *it;
     DictionaryValue* card_info = new DictionaryValue;
-    card_info->SetStringFromUTF16(L"label", card->Label());
+    card_info->SetString("label", card->Label());
     // For each of the types, if it has a value, add it to the dictionary.
     for (std::map<AutoFillFieldType, std::wstring>::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->SetStringFromUTF16(type_it->second, value);
+        card_info->SetString(type_it->second, value);
       }
     }
     cards->Append(card_info);
   }
   return cards;
 }
 
 /* static */
 std::vector<AutoFillProfile> AutomationProvider::GetAutoFillProfilesFromList(
     const ListValue& profiles, std::string* error_message) {
@@ skipping 1366 matching lines @@
 }
 
 void AutomationProvider::WaitForPopupMenuToOpen(IPC::Message* reply_message) {
   NOTIMPLEMENTED();
 }
 #endif  // !defined(TOOLKIT_VIEWS)
 
 void AutomationProvider::ResetToDefaultTheme() {
   profile_->ClearTheme();
 }