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

chrome/browser/automation/automation_provider_observers.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_observers.h"
 
 #include "base/basictypes.h"
 #include "base/json/json_writer.h"
 #include "base/string_util.h"
 #include "chrome/app/chrome_dll_resource.h"
@@ skipping 82 matching lines @@
 }
 
 DictionaryValue* InitialLoadObserver::GetTimingInformation() const {
   ListValue* items = new ListValue;
   for (TabTimeMap::const_iterator it = loading_tabs_.begin();
        it != loading_tabs_.end();
        ++it) {
     DictionaryValue* item = new DictionaryValue;
     base::TimeDelta delta_start = it->second.start_time() - init_time_;
 
-    item->SetReal(L"load_start_ms", delta_start.InMillisecondsF());
+    item->SetReal("load_start_ms", delta_start.InMillisecondsF());
     if (it->second.stop_time().is_null()) {
-      item->Set(L"load_stop_ms", Value::CreateNullValue());
+      item->Set("load_stop_ms", Value::CreateNullValue());
     } else {
       base::TimeDelta delta_stop = it->second.stop_time() - init_time_;
-      item->SetReal(L"load_stop_ms", delta_stop.InMillisecondsF());
+      item->SetReal("load_stop_ms", delta_stop.InMillisecondsF());
     }
     items->Append(item);
   }
   DictionaryValue* return_value = new DictionaryValue;
-  return_value->Set(L"tabs", items);
+  return_value->Set("tabs", items);
   return return_value;
 }
 
 void InitialLoadObserver::ConditionMet() {
   registrar_.RemoveAll();
   automation_->Send(new AutomationMsg_InitialLoadsComplete(0));
 }
 
 NewTabUILoadObserver::NewTabUILoadObserver(AutomationProvider* automation)
     : automation_(automation) {
@@ skipping 819 matching lines @@
 void PageTranslatedObserver::Observe(NotificationType type,
                                      const NotificationSource& source,
                                      const NotificationDetails& details) {
   DCHECK(type == NotificationType::PAGE_TRANSLATED);
   AutomationJSONReply reply(automation_, reply_message_);
 
   PageTranslatedDetails* translated_details =
       Details<PageTranslatedDetails>(details).ptr();
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
   return_value->SetBoolean(
-      L"translation_success",
+      "translation_success",
       translated_details->error_type == TranslateErrors::NONE);
   reply.SendSuccess(return_value.get());
   delete this;
 }
 
 TabLanguageDeterminedObserver::TabLanguageDeterminedObserver(
     AutomationProvider* automation, IPC::Message* reply_message,
     TabContents* tab_contents, TranslateInfoBarDelegate* translate_bar)
   : automation_(automation),
     reply_message_(reply_message),
     tab_contents_(tab_contents),
     translate_bar_(translate_bar) {
   registrar_.Add(this, NotificationType::TAB_LANGUAGE_DETERMINED,
                  Source<TabContents>(tab_contents));
 }
 
 void TabLanguageDeterminedObserver::Observe(
     NotificationType type, const NotificationSource& source,
     const NotificationDetails& details) {
   DCHECK(type == NotificationType::TAB_LANGUAGE_DETERMINED);
 
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
-  return_value->SetBoolean(L"page_translated",
+  return_value->SetBoolean("page_translated",
                            tab_contents_->language_state().IsPageTranslated());
   return_value->SetBoolean(
-      L"can_translate_page", TranslatePrefs::CanTranslate(
+      "can_translate_page", TranslatePrefs::CanTranslate(
           automation_->profile()->GetPrefs(),
           tab_contents_->language_state().original_language(),
           tab_contents_->GetURL()));
   return_value->SetString(
-      L"original_language",
+      "original_language",
       tab_contents_->language_state().original_language());
   if (translate_bar_) {
     DictionaryValue* bar_info = new DictionaryValue;
     std::map<TranslateInfoBarDelegate::Type, std::string> type_to_string;
     type_to_string[TranslateInfoBarDelegate::BEFORE_TRANSLATE] =
         "BEFORE_TRANSLATE";
     type_to_string[TranslateInfoBarDelegate::TRANSLATING] =
         "TRANSLATING";
     type_to_string[TranslateInfoBarDelegate::AFTER_TRANSLATE] =
         "AFTER_TRANSLATE";
     type_to_string[TranslateInfoBarDelegate::TRANSLATION_ERROR] =
         "TRANSLATION_ERROR";
 
-    bar_info->SetString(L"bar_state", type_to_string[translate_bar_->type()]);
-    bar_info->SetString(L"target_lang_code",
+    bar_info->SetString("bar_state", type_to_string[translate_bar_->type()]);
+    bar_info->SetString("target_lang_code",
                         translate_bar_->GetTargetLanguageCode());
-    bar_info->SetString(L"original_lang_code",
+    bar_info->SetString("original_lang_code",
                         translate_bar_->GetOriginalLanguageCode());
-    return_value->Set(L"translate_bar", bar_info);
+    return_value->Set("translate_bar", bar_info);
   }
   AutomationJSONReply(automation_, reply_message_)
       .SendSuccess(return_value.get());
   delete this;
 }
 
 #if defined(OS_CHROMEOS)
 LoginManagerObserver::LoginManagerObserver(
     AutomationProvider* automation,
     IPC::Message* reply_message)
@@ skipping 48 matching lines @@
 
 void AutomationProviderHistoryObserver::HistoryQueryComplete(
     HistoryService::Handle request_handle,
     history::QueryResults* results) {
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   ListValue* history_list = new ListValue;
   for (size_t i = 0; i < results->size(); ++i) {
     DictionaryValue* page_value = new DictionaryValue;
     history::URLResult const &page = (*results)[i];
-    page_value->SetStringFromUTF16(L"title", page.title());
-    page_value->SetString(L"url", page.url().spec());
-    page_value->SetReal(L"time",
+    page_value->SetString("title", page.title());
+    page_value->SetString("url", page.url().spec());
+    page_value->SetReal("time",
                         static_cast<double>(page.visit_time().ToDoubleT()));
-    page_value->SetStringFromUTF16(L"snippet", page.snippet().text());
+    page_value->SetString("snippet", page.snippet().text());
     page_value->SetBoolean(
-        L"starred",
+        "starred",
         provider_->profile()->GetBookmarkModel()->IsBookmarked(page.url()));
     history_list->Append(page_value);
   }
 
-  return_value->Set(L"history", history_list);
+  return_value->Set("history", history_list);
   // Return history info.
   AutomationJSONReply reply(provider_, reply_message_);
   reply.SendSuccess(return_value.get());
   delete this;
 }
 
 void AutomationProviderImportSettingsObserver::ImportEnded() {
   // Send back an empty success message.
   AutomationJSONReply(provider_, reply_message_).SendSuccess(NULL);
   delete this;
 }
 
 void AutomationProviderGetPasswordsObserver::OnPasswordStoreRequestDone(
     int handle, const std::vector<webkit_glue::PasswordForm*>& result) {
   scoped_ptr<DictionaryValue> return_value(new DictionaryValue);
 
   ListValue* passwords = new ListValue;
   for (std::vector<webkit_glue::PasswordForm*>::const_iterator it =
           result.begin(); it != result.end(); ++it) {
     DictionaryValue* password_val = new DictionaryValue;
     webkit_glue::PasswordForm* password_form = *it;
-    password_val->SetStringFromUTF16(L"username_value",
-                                     password_form->username_value);
-    password_val->SetStringFromUTF16(L"password_value",
-                                     password_form->password_value);
-    password_val->SetString(L"signon_realm", password_form->signon_realm);
+    password_val->SetString("username_value", password_form->username_value);
+    password_val->SetString("password_value", password_form->password_value);
+    password_val->SetString("signon_realm", password_form->signon_realm);
     password_val->SetReal(
-        L"time", static_cast<double>(
-            password_form->date_created.ToDoubleT()));
-    password_val->SetString(L"origin_url", password_form->origin.spec());
-    password_val->SetStringFromUTF16(L"username_element",
-                                     password_form->username_element);
-    password_val->SetStringFromUTF16(L"password_element",
-                                     password_form->password_element);
-    password_val->SetStringFromUTF16(L"submit_element",
+        "time", static_cast<double>(password_form->date_created.ToDoubleT()));
+    password_val->SetString("origin_url", password_form->origin.spec());
+    password_val->SetString("username_element",
+                            password_form->username_element);
+    password_val->SetString("password_element",
+                            password_form->password_element);
+    password_val->SetString("submit_element",
                                      password_form->submit_element);
-    password_val->SetString(L"action_target", password_form->action.spec());
-    password_val->SetBoolean(L"blacklist", password_form->blacklisted_by_user);
+    password_val->SetString("action_target", password_form->action.spec());
+    password_val->SetBoolean("blacklist", password_form->blacklisted_by_user);
     passwords->Append(password_val);
   }
 
-  return_value->Set(L"passwords", passwords);
+  return_value->Set("passwords", passwords);
   AutomationJSONReply(provider_, reply_message_).SendSuccess(
       return_value.get());
   delete this;
 }
 
 void AutomationProviderBrowsingDataObserver::OnBrowsingDataRemoverDone() {
   // Send back an empty success message
   AutomationJSONReply(provider_, reply_message_).SendSuccess(NULL);
   delete this;
 }
@@ skipping 78 matching lines @@
   if (tab_contents_->infobar_delegate_count() == count_) {
     ConditionMet();
   }
 }
 
 void WaitForInfobarCountObserver::ConditionMet() {
   registrar_.RemoveAll();
   AutomationJSONReply(automation_, reply_message_).SendSuccess(NULL);
   delete this;
 }