Remove deprecated wstring Get(As)String() methods from Value, etc.

chrome/browser/safe_browsing/safe_browsing_blocking_page.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.
 //
 // Implementation of the SafeBrowsingBlockingPage class.
 
 #include "chrome/browser/safe_browsing/safe_browsing_blocking_page.h"
 
 #include <string>
 
@@ skipping 128 matching lines @@
   return jstemplate_builder::GetTemplatesHtml(html, &strings, "template_root");
 }
 
 void SafeBrowsingBlockingPage::PopulateStringDictionary(
     DictionaryValue* strings,
     const std::wstring& title,
     const std::wstring& headline,
     const std::wstring& description1,
     const std::wstring& description2,
     const std::wstring& description3) {
-  strings->SetString(L"title", title);
-  strings->SetString(L"headLine", headline);
-  strings->SetString(L"description1", description1);
-  strings->SetString(L"description2", description2);
-  strings->SetString(L"description3", description3);
+  strings->SetString("title", WideToUTF16Hack(title));
+  strings->SetString("headLine", WideToUTF16Hack(headline));
+  strings->SetString("description1", WideToUTF16Hack(description1));
+  strings->SetString("description2", WideToUTF16Hack(description2));
+  strings->SetString("description3", WideToUTF16Hack(description3));
 }
 
 void SafeBrowsingBlockingPage::PopulateMultipleThreatStringDictionary(
     DictionaryValue* strings) {
   bool malware = false;
   bool phishing = false;
 
-  std::wstring phishing_label =
-      l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_LABEL);
-  std::wstring phishing_link =
-      l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR);
-  std::wstring malware_label =
-      l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_LABEL);
-  std::wstring malware_link =
-      l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE);
+  string16 malware_label =
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_LABEL);
+  string16 malware_link =
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE);
+  string16 phishing_label =
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_LABEL);
+  string16 phishing_link =
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR);
 
   ListValue* error_strings = new ListValue;
   for (UnsafeResourceList::const_iterator iter = unsafe_resources_.begin();
        iter != unsafe_resources_.end(); ++iter) {
     const SafeBrowsingService::UnsafeResource& resource = *iter;
     DictionaryValue* current_error_strings = new DictionaryValue;
     if (resource.threat_type == SafeBrowsingService::URL_MALWARE) {
       malware = true;
-      current_error_strings->SetString(L"type", L"malware");
-      current_error_strings->SetString(L"typeLabel", malware_label);
-      current_error_strings->SetString(L"errorLink", malware_link);
+      current_error_strings->SetString("type", "malware");
+      current_error_strings->SetString("typeLabel", malware_label);
+      current_error_strings->SetString("errorLink", malware_link);
     } else {
       DCHECK(resource.threat_type == SafeBrowsingService::URL_PHISHING);
       phishing = true;
-      current_error_strings->SetString(L"type", L"phishing");
-      current_error_strings->SetString(L"typeLabel", phishing_label);
-      current_error_strings->SetString(L"errorLink", phishing_link);
+      current_error_strings->SetString("type", "phishing");
+      current_error_strings->SetString("typeLabel", phishing_label);
+      current_error_strings->SetString("errorLink", phishing_link);
     }
-    current_error_strings->SetString(L"url", UTF8ToWide(resource.url.spec()));
+    current_error_strings->SetString("url", resource.url.spec());
     error_strings->Append(current_error_strings);
   }
-  strings->Set(L"errors", error_strings);
+  strings->Set("errors", error_strings);
   DCHECK(phishing || malware);
 
   if (malware && phishing) {
     PopulateStringDictionary(
         strings,
         // Use the malware headline, it is the scariest one.
         l10n_util::GetString(IDS_SAFE_BROWSING_MULTI_THREAT_TITLE),
         l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
         l10n_util::GetStringF(IDS_SAFE_BROWSING_MULTI_THREAT_DESCRIPTION1,
                               UTF8ToWide(tab()->GetURL().host())),
@@ skipping 13 matching lines @@
     // Just phishing.
     PopulateStringDictionary(
         strings,
         l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_TITLE),
         l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_HEADLINE),
         l10n_util::GetStringF(IDS_SAFE_BROWSING_MULTI_PHISHING_DESCRIPTION1,
                               UTF8ToWide(tab()->GetURL().host())),
         L"", L"");
   }
 
-  strings->SetString(L"confirm_text",
-      l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION_AGREE));
-  strings->SetString(L"continue_button",
-      l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_PROCEED_BUTTON));
-  strings->SetString(L"back_button",
-      l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
-  strings->SetString(L"textdirection", base::i18n::IsRTL() ? L"rtl" : L"ltr");
+  strings->SetString("confirm_text",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION_AGREE));
+  strings->SetString("continue_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_PROCEED_BUTTON));
+  strings->SetString("back_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
+  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
 }
 
 void SafeBrowsingBlockingPage::PopulateMalwareStringDictionary(
     DictionaryValue* strings) {
   std::wstring link = StringPrintf(kSbDiagnosticHtml,
       l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE).c_str());
 
-  strings->SetString(L"badURL", UTF8ToWide(url().host()));
+  strings->SetString("badURL", url().host());
   // Check to see if we're blocking the main page, or a sub-resource on the
   // main page.
   std::wstring description1, description2;
   if (is_main_frame_) {
     description1 = l10n_util::GetStringF(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION1,
                                          UTF8ToWide(url().host()));
     description2 = l10n_util::GetStringF(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION2,
                                          link,
                                          UTF8ToWide(url().host()));
   } else {
     description1 = l10n_util::GetStringF(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION4,
                                          UTF8ToWide(tab()->GetURL().host()),
                                          UTF8ToWide(url().host()));
     description2 = l10n_util::GetStringF(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION5,
                                          link,
                                          UTF8ToWide(url().host()));
   }
 
   PopulateStringDictionary(
       strings,
       l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_TITLE),
       l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_HEADLINE),
       description1, description2,
       l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION3));
 
-  strings->SetString(L"confirm_text",
-      l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION_AGREE));
-  strings->SetString(L"continue_button",
-      l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_PROCEED_BUTTON));
-  strings->SetString(L"back_button",
-      l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
-  strings->SetString(L"textdirection", base::i18n::IsRTL() ? L"rtl" : L"ltr");
+  strings->SetString("confirm_text",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_DESCRIPTION_AGREE));
+  strings->SetString("continue_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_PROCEED_BUTTON));
+  strings->SetString("back_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON));
+  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
 }
 
 void SafeBrowsingBlockingPage::PopulatePhishingStringDictionary(
     DictionaryValue* strings) {
   PopulateStringDictionary(
       strings,
       l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_TITLE),
       l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_HEADLINE),
       l10n_util::GetStringF(IDS_SAFE_BROWSING_PHISHING_DESCRIPTION1,
                             UTF8ToWide(url().host())),
       l10n_util::GetStringF(IDS_SAFE_BROWSING_PHISHING_DESCRIPTION2,
                             UTF8ToWide(url().host())),
       L"");
 
-  strings->SetString(L"continue_button",
-      l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_PROCEED_BUTTON));
-  strings->SetString(L"back_button",
-      l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_BACK_BUTTON));
-  strings->SetString(L"report_error",
-      l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR));
-  strings->SetString(L"textdirection", base::i18n::IsRTL() ? L"rtl" : L"ltr");
+  strings->SetString("continue_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_PROCEED_BUTTON));
+  strings->SetString("back_button",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_BACK_BUTTON));
+  strings->SetString("report_error",
+      l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR));
+  strings->SetString("textdirection", base::i18n::IsRTL() ? "rtl" : "ltr");
 }
 
 void SafeBrowsingBlockingPage::CommandReceived(const std::string& cmd) {
   std::string command(cmd);  // Make a local copy so we can modify it.
   // The Jasonified response has quotes, remove them.
   if (command.length() > 1 && command[0] == '"') {
     command = command.substr(1, command.length() - 2);
   }
 
   if (command == kLearnMoreCommand) {
@@ skipping 134 matching lines @@
 }
 
 void SafeBrowsingBlockingPage::RecordUserAction(BlockingPageEvent event) {
   // Determine the interstitial type from the blocked resources.
   // This is the same logic that is used to actually construct the
   // page contents; we can look at the title to see which type of
   // interstitial is being displayed.
   DictionaryValue strings;
   PopulateMultipleThreatStringDictionary(&strings);
 
-  std::wstring title;
-  DCHECK(strings.GetString(L"title", &title));
+  string16 title;
+  DCHECK(strings.GetString("title", &title));
 
   std::string action = "SBInterstitial";
-  if (title == l10n_util::GetString(IDS_SAFE_BROWSING_MULTI_THREAT_TITLE)) {
+  if (title ==
+          l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MULTI_THREAT_TITLE)) {
     action.append("Multiple");
-  } else if (title == l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_TITLE)) {
+  } else if (title ==
+                 l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_MALWARE_TITLE)) {
     action.append("Malware");
   } else {
-    DCHECK_EQ(title, l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_TITLE));
+    DCHECK_EQ(title,
+              l10n_util::GetStringUTF16(IDS_SAFE_BROWSING_PHISHING_TITLE));
     action.append("Phishing");
   }
 
   switch (event) {
     case SHOW:
       action.append("Show");
       break;
     case PROCEED:
       action.append("Proceed");
       break;
@@ skipping 62 matching lines @@
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   (*unsafe_resource_map)[tab_contents].push_back(unsafe_resource);
 }
 
 // static
 bool SafeBrowsingBlockingPage::IsMainPage(
     const UnsafeResourceList& unsafe_resources) {
   return unsafe_resources.size() == 1 &&
          unsafe_resources[0].resource_type == ResourceType::MAIN_FRAME;
 }