Port DictionaryValue to use string16 instead of wstring.

chrome/browser/safe_browsing/safe_browsing_blocking_page.cc

 // Copyright (c) 2006-2008 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 "base/string_util.h"
 #include "chrome/browser/browser_process.h"
@@ skipping 85 matching lines @@
   return jstemplate_builder::GetTemplateHtml(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(ASCIIToUTF16("title"), WideToUTF16Hack(title));
+  strings->SetString(ASCIIToUTF16("headLine"), WideToUTF16Hack(headline));
+  strings->SetString(ASCIIToUTF16("description1"),
+                     WideToUTF16Hack(description1));
+  strings->SetString(ASCIIToUTF16("description2"),
+                     WideToUTF16Hack(description2));
+  strings->SetString(ASCIIToUTF16("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 phishing_label =
+      WideToUTF16Hack(l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_LABEL));
+  string16 phishing_link =
+      WideToUTF16Hack(
+          l10n_util::GetString(IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR));
+  string16 malware_label =
+      WideToUTF16Hack(
+          l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_LABEL));
+  string16 malware_link =
+      WideToUTF16Hack(
+          l10n_util::GetString(IDS_SAFE_BROWSING_MALWARE_DIAGNOSTIC_PAGE));
 
   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(ASCIIToUTF16("type"),
+                                       ASCIIToUTF16("malware"));
+      current_error_strings->SetString(ASCIIToUTF16("typeLabel"),
+                                       malware_label);
+      current_error_strings->SetString(ASCIIToUTF16("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(ASCIIToUTF16("type"),
+                                       ASCIIToUTF16("phishing"));
+      current_error_strings->SetString(ASCIIToUTF16("typeLabel"),
+                                       phishing_label);
+      current_error_strings->SetString(ASCIIToUTF16("errorLink"),
+                                       phishing_link);
     }
-    current_error_strings->SetString(L"url", UTF8ToWide(resource.url.spec()));
+    current_error_strings->SetString(ASCIIToUTF16("url"),
+                                     UTF8ToUTF16(resource.url.spec()));
     error_strings->Append(current_error_strings);
   }
-  strings->Set(L"errors", error_strings);
+  strings->Set(ASCIIToUTF16("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",
+  strings->SetString(ASCIIToUTF16("confirm_text"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_MALWARE_DESCRIPTION_AGREE)));
+  strings->SetString(ASCIIToUTF16("continue_button"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_MALWARE_PROCEED_BUTTON)));
+  strings->SetString(ASCIIToUTF16("back_button"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON)));
+  strings->SetString(ASCIIToUTF16("textdirection"),
       (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT) ?
-      L"rtl" : L"ltr");
+      ASCIIToUTF16("rtl") : ASCIIToUTF16("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(ASCIIToUTF16("badURL"), UTF8ToUTF16(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",
+  strings->SetString(ASCIIToUTF16("confirm_text"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_MALWARE_DESCRIPTION_AGREE)));
+  strings->SetString(ASCIIToUTF16("continue_button"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_MALWARE_PROCEED_BUTTON)));
+  strings->SetString(ASCIIToUTF16("back_button"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_MALWARE_BACK_BUTTON)));
+  strings->SetString(ASCIIToUTF16("textdirection"),
       (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT) ?
-      L"rtl" : L"ltr");
+      ASCIIToUTF16("rtl") : ASCIIToUTF16("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",
+  strings->SetString(ASCIIToUTF16("continue_button"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_PHISHING_PROCEED_BUTTON)));
+  strings->SetString(ASCIIToUTF16("back_button"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_PHISHING_BACK_BUTTON)));
+  strings->SetString(ASCIIToUTF16("report_error"),
+      WideToUTF16Hack(l10n_util::GetString(
+                          IDS_SAFE_BROWSING_PHISHING_REPORT_ERROR)));
+  strings->SetString(ASCIIToUTF16("textdirection"),
       (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT) ?
-      L"rtl" : L"ltr");
+      ASCIIToUTF16("rtl") : ASCIIToUTF16("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 163 matching lines @@
   UnsafeResourceMap* unsafe_resource_map = GetUnsafeResourcesMap();
   (*unsafe_resource_map)[web_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;
 }
-