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

chrome/common/extensions/extension_message_bundle_unittest.cc

 // Copyright (c) 2009 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/common/extensions/extension_message_bundle.h"
 
 #include <string>
 #include <vector>
 
 #include "base/i18n/rtl.h"
@@ skipping 16 matching lines @@
     NAME_NOT_A_TREE,
     EMPTY_NAME_TREE,
     MISSING_MESSAGE,
     PLACEHOLDER_NOT_A_TREE,
     EMPTY_PLACEHOLDER_TREE,
     CONTENT_MISSING,
     MESSAGE_PLACEHOLDER_DOESNT_MATCH,
   };
 
   // Helper method for dictionary building.
-  void SetDictionary(const std::wstring name,
+  void SetDictionary(const std::string& name,
                      DictionaryValue* subtree,
                      DictionaryValue* target) {
     target->Set(name, static_cast<Value*>(subtree));
   }
 
-  void CreateContentTree(const std::wstring& name,
-                         const std::string content,
+  void CreateContentTree(const std::string& name,
+                         const std::string& content,
                          DictionaryValue* dict) {
     DictionaryValue* content_tree = new DictionaryValue;
     content_tree->SetString(ExtensionMessageBundle::kContentKey, content);
     SetDictionary(name, content_tree, dict);
   }
 
   void CreatePlaceholdersTree(DictionaryValue* dict) {
     DictionaryValue* placeholders_tree = new DictionaryValue;
-    CreateContentTree(L"a", "A", placeholders_tree);
-    CreateContentTree(L"b", "B", placeholders_tree);
-    CreateContentTree(L"c", "C", placeholders_tree);
+    CreateContentTree("a", "A", placeholders_tree);
+    CreateContentTree("b", "B", placeholders_tree);
+    CreateContentTree("c", "C", placeholders_tree);
     SetDictionary(ExtensionMessageBundle::kPlaceholdersKey,
                   placeholders_tree,
                   dict);
   }
 
-  void CreateMessageTree(const std::wstring& name,
+  void CreateMessageTree(const std::string& name,
                          const std::string& message,
                          bool create_placeholder_subtree,
                          DictionaryValue* dict) {
     DictionaryValue* message_tree = new DictionaryValue;
     if (create_placeholder_subtree)
       CreatePlaceholdersTree(message_tree);
     message_tree->SetString(ExtensionMessageBundle::kMessageKey, message);
     SetDictionary(name, message_tree, dict);
   }
 
   // Caller owns the memory.
   DictionaryValue* CreateGoodDictionary() {
     DictionaryValue* dict = new DictionaryValue;
-    CreateMessageTree(L"n1", "message1 $a$ $b$", true, dict);
-    CreateMessageTree(L"n2", "message2 $c$", true, dict);
-    CreateMessageTree(L"n3", "message3", false, dict);
+    CreateMessageTree("n1", "message1 $a$ $b$", true, dict);
+    CreateMessageTree("n2", "message2 $c$", true, dict);
+    CreateMessageTree("n3", "message3", false, dict);
     return dict;
   }
 
   // Caller owns the memory.
   DictionaryValue* CreateBadDictionary(enum BadDictionary what_is_bad) {
     DictionaryValue* dict = CreateGoodDictionary();
     // Now remove/break things.
     switch (what_is_bad) {
       case INVALID_NAME:
-        CreateMessageTree(L"n 5", "nevermind", false, dict);
+        CreateMessageTree("n 5", "nevermind", false, dict);
         break;
       case NAME_NOT_A_TREE:
-        dict->SetString(L"n4", "whatever");
+        dict->SetString("n4", "whatever");
         break;
       case EMPTY_NAME_TREE: {
           DictionaryValue* empty_tree = new DictionaryValue;
-          SetDictionary(L"n4", empty_tree, dict);
+          SetDictionary("n4", empty_tree, dict);
         }
         break;
       case MISSING_MESSAGE:
-        dict->Remove(L"n1.message", NULL);
+        dict->Remove("n1.message", NULL);
         break;
       case PLACEHOLDER_NOT_A_TREE:
-        dict->SetString(L"n1.placeholders", "whatever");
+        dict->SetString("n1.placeholders", "whatever");
         break;
       case EMPTY_PLACEHOLDER_TREE: {
           DictionaryValue* empty_tree = new DictionaryValue;
-          SetDictionary(L"n1.placeholders", empty_tree, dict);
+          SetDictionary("n1.placeholders", empty_tree, dict);
         }
         break;
       case CONTENT_MISSING:
-         dict->Remove(L"n1.placeholders.a.content", NULL);
+         dict->Remove("n1.placeholders.a.content", NULL);
         break;
       case MESSAGE_PLACEHOLDER_DOESNT_MATCH:
         DictionaryValue* value;
-        dict->Remove(L"n1.placeholders.a", NULL);
-        dict->GetDictionary(L"n1.placeholders", &value);
-        CreateContentTree(L"x", "X", value);
+        dict->Remove("n1.placeholders.a", NULL);
+        dict->GetDictionary("n1.placeholders", &value);
+        CreateContentTree("x", "X", value);
         break;
     }
 
     return dict;
   }
 
   unsigned int ReservedMessagesCount() {
     // Update when adding new reserved messages.
     return 5U;
   }
@@ skipping 56 matching lines @@
   EXPECT_EQ("message3", handler_->GetL10nMessage("n3"));
   CheckReservedMessages(handler_.get());
 }
 
 TEST_F(ExtensionMessageBundleTest, InitAppDictConsultedFirst) {
   catalogs_.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
   catalogs_.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
 
   DictionaryValue* app_dict = catalogs_[0].get();
   // Flip placeholders in message of n1 tree.
-  app_dict->SetString(L"n1.message", "message1 $b$ $a$");
+  app_dict->SetString("n1.message", "message1 $b$ $a$");
   // Remove one message from app dict.
-  app_dict->Remove(L"n2", NULL);
+  app_dict->Remove("n2", NULL);
   // Replace n3 with N3.
-  app_dict->Remove(L"n3", NULL);
-  CreateMessageTree(L"N3", "message3_app_dict", false, app_dict);
+  app_dict->Remove("n3", NULL);
+  CreateMessageTree("N3", "message3_app_dict", false, app_dict);
 
   CreateMessageBundle();
 
   EXPECT_TRUE(handler_.get() != NULL);
   EXPECT_EQ(3U + ReservedMessagesCount(), handler_->size());
 
   EXPECT_EQ("message1 B A", handler_->GetL10nMessage("n1"));
   EXPECT_EQ("message2 C", handler_->GetL10nMessage("n2"));
   EXPECT_EQ("message3_app_dict", handler_->GetL10nMessage("n3"));
   CheckReservedMessages(handler_.get());
@@ skipping 43 matching lines @@
   catalogs_[0].reset(CreateBadDictionary(MESSAGE_PLACEHOLDER_DOESNT_MATCH));
   handler_.reset(ExtensionMessageBundle::Create(catalogs_, &error));
   EXPECT_TRUE(handler_.get() == NULL);
   EXPECT_EQ("Variable $a$ used but not defined.", error);
 }
 
 TEST_F(ExtensionMessageBundleTest, ReservedMessagesOverrideDeveloperMessages) {
   catalogs_.push_back(linked_ptr<DictionaryValue>(CreateGoodDictionary()));
 
   DictionaryValue* dict = catalogs_[0].get();
-  CreateMessageTree(
-      ASCIIToWide(ExtensionMessageBundle::kUILocaleKey), "x", false, dict);
+  CreateMessageTree(ExtensionMessageBundle::kUILocaleKey, "x", false, dict);
 
   std::string error = CreateMessageBundle();
 
   EXPECT_TRUE(handler_.get() == NULL);
   std::string expected_error = ExtensionErrorUtils::FormatErrorMessage(
       errors::kReservedMessageFound, ExtensionMessageBundle::kUILocaleKey);
   EXPECT_EQ(expected_error, error);
 }
 
 TEST_F(ExtensionMessageBundleTest, AppendReservedMessagesForLTR) {
@@ skipping 144 matching lines @@
   // Store a map for given id.
   L10nMessagesMap messages;
   messages.insert(std::make_pair("message_name", "message_value"));
   (*GetExtensionToL10nMessagesMap())[extension_id] = messages;
 
   L10nMessagesMap* map = GetL10nMessagesMap(extension_id);
   ASSERT_TRUE(NULL != map);
   EXPECT_EQ(1U, map->size());
   EXPECT_EQ("message_value", (*map)["message_name"]);
 }