Issue 71980: Extensions code should use UTF-16 for user-visible Unicode strings

chrome/common/extensions/manifest_unittest.cc

 // Copyright (c) 2011 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/manifest.h"
 
 #include <algorithm>
 #include <set>
 #include <string>
 
@@ skipping 126 matching lines @@
     EXPECT_EQ(type == Manifest::kTypeHostedApp, manifest->IsHostedApp());
   }
 
   void TestRestrictedKeys(Manifest* manifest,
                           const char* restricted_keys[],
                           size_t restricted_keys_length) {
     // Verify that the keys on the restricted key list for the given manifest
     // fail validation and are filtered out.
     DictionaryValue* value = manifest->value();
     for (size_t i = 0; i < restricted_keys_length; ++i) {
-      std::string error, str;
+      std::string str;
+      string16 error;
       value->Set(restricted_keys[i], Value::CreateStringValue(default_value_));
       EXPECT_FALSE(manifest->ValidateManifest(&error));
-      EXPECT_EQ(error, ExtensionErrorUtils::FormatErrorMessage(
+      EXPECT_EQ(error, ExtensionErrorUtils::FormatErrorMessageUTF16(
           errors::kFeatureNotAllowed, restricted_keys[i]));
       EXPECT_FALSE(manifest->GetString(restricted_keys[i], &str));
       EXPECT_TRUE(value->Remove(restricted_keys[i], NULL));
     }
   }
 
   std::string default_value_;
 };
 
 // Verifies that extensions can access the correct keys.
 TEST_F(ManifestTest, Extension) {
   // Generate the list of keys accessible by extensions.
   std::set<std::string> extension_keys = GetAccessibleKeys(NULL, 0u);
 
   // Construct the underlying value using every single key other than those
   // on the restricted list.. We can use the same value for every key because we
   // validate only by checking the presence of the keys.
   DictionaryValue* value = new DictionaryValue();
   for (std::set<std::string>::iterator i = extension_keys.begin();
        i != extension_keys.end(); ++i)
     value->Set(*i, Value::CreateStringValue(default_value_));
 
   scoped_ptr<Manifest> manifest(new Manifest(value));
-  std::string error;
+  string16 error;
   EXPECT_TRUE(manifest->ValidateManifest(&error));
-  EXPECT_EQ("", error);
+  EXPECT_EQ(ASCIIToUTF16(""), error);
   AssertType(manifest.get(), Manifest::kTypeExtension);
 
   // Verify that all the extension keys are accessible.
   for (std::set<std::string>::iterator i = extension_keys.begin();
        i != extension_keys.end(); ++i) {
     std::string value;
     manifest->GetString(*i, &value);
     EXPECT_EQ(default_value_, value) << *i;
   }
 
@@ skipping 12 matching lines @@
 
   DictionaryValue* value = new DictionaryValue();
   for (std::set<std::string>::iterator i = theme_keys.begin();
        i != theme_keys.end(); ++i)
     value->Set(*i, Value::CreateStringValue(default_value_));
 
   std::string theme_key = keys::kTheme + std::string(".test");
   value->Set(theme_key, Value::CreateStringValue(default_value_));
 
   scoped_ptr<Manifest> manifest(new Manifest(value));
-  std::string error;
+  string16 error;
   EXPECT_TRUE(manifest->ValidateManifest(&error));
-  EXPECT_EQ("", error);
+  EXPECT_EQ(ASCIIToUTF16(""), error);
   AssertType(manifest.get(), Manifest::kTypeTheme);
 
   // Verify that all the theme keys are accessible.
   std::string str;
   for (std::set<std::string>::iterator i = theme_keys.begin();
        i != theme_keys.end(); ++i) {
     EXPECT_TRUE(manifest->GetString(*i, &str));
     EXPECT_EQ(default_value_, str) << *i;
   }
   EXPECT_TRUE(manifest->GetString(theme_key, &str));
@@ skipping 11 matching lines @@
       ARRAYSIZE_UNSAFE(kNotPlatformAppKeys));
 
   DictionaryValue* value = new DictionaryValue();
   for (std::set<std::string>::iterator i = platform_keys.begin();
        i != platform_keys.end(); ++i)
     value->Set(*i, Value::CreateStringValue(default_value_));
 
   value->Set(keys::kPlatformApp, Value::CreateBooleanValue(true));
 
   scoped_ptr<Manifest> manifest(new Manifest(value));
-  std::string error;
+  string16 error;
   EXPECT_TRUE(manifest->ValidateManifest(&error));
-  EXPECT_EQ("", error);
+  EXPECT_EQ(ASCIIToUTF16(""), error);
   AssertType(manifest.get(), Manifest::kTypePlatformApp);
 
   // Verify that all the platform app keys are accessible.
   std::string str;
   for (std::set<std::string>::iterator i = platform_keys.begin();
        i != platform_keys.end(); ++i) {
     EXPECT_TRUE(manifest->GetString(*i, &str));
     EXPECT_EQ(default_value_, str) << *i;
   }
   bool is_platform_app = false;
@@ skipping 12 matching lines @@
       ARRAYSIZE_UNSAFE(kNotHostedAppKeys));
 
   DictionaryValue* value = new DictionaryValue();
   for (std::set<std::string>::iterator i = keys.begin();
        i != keys.end(); ++i)
     value->Set(*i, Value::CreateStringValue(default_value_));
 
   value->Set(keys::kWebURLs, Value::CreateStringValue(default_value_));
 
   scoped_ptr<Manifest> manifest(new Manifest(value));
-  std::string error;
+  string16 error;
   EXPECT_TRUE(manifest->ValidateManifest(&error));
-  EXPECT_EQ("", error);
+  EXPECT_EQ(ASCIIToUTF16(""), error);
   AssertType(manifest.get(), Manifest::kTypeHostedApp);
 
   // Verify that all the hosted app keys are accessible.
   std::string str;
   for (std::set<std::string>::iterator i = keys.begin();
        i != keys.end(); ++i) {
     EXPECT_TRUE(manifest->GetString(*i, &str));
     EXPECT_EQ(default_value_, str) << *i;
   }
   EXPECT_TRUE(manifest->GetString(keys::kWebURLs, &str));
@@ skipping 10 matching lines @@
       kNotPackagedAppKeys,
       ARRAYSIZE_UNSAFE(kNotPackagedAppKeys));
 
   DictionaryValue* value = new DictionaryValue();
   for (std::set<std::string>::iterator i = keys.begin();
        i != keys.end(); ++i)
     value->Set(*i, Value::CreateStringValue(default_value_));
   value->Set(keys::kApp, Value::CreateStringValue(default_value_));
 
   scoped_ptr<Manifest> manifest(new Manifest(value));
-  std::string error;
+  string16 error;
   EXPECT_TRUE(manifest->ValidateManifest(&error));
-  EXPECT_EQ("", error);
+  EXPECT_EQ(ASCIIToUTF16(""), error);
   AssertType(manifest.get(), Manifest::kTypePackagedApp);
 
   // Verify that all the packaged app keys are accessible.
   std::string str;
   for (std::set<std::string>::iterator i = keys.begin();
        i != keys.end(); ++i) {
     EXPECT_TRUE(manifest->GetString(*i, &str));
     EXPECT_EQ(default_value_, str) << *i;
   }
   EXPECT_TRUE(manifest->GetString(keys::kApp, &str));
@@ skipping 58 matching lines @@
   ListValue* expected_list = new ListValue();
   ListValue* actual_list = NULL;
   expected_list->Append(Value::CreateStringValue("blah"));
   value->Set(unknown_key, expected_list);
   EXPECT_FALSE(manifest->GetList(unknown_key, &actual_list));
   EXPECT_EQ(NULL, actual_list);
   EXPECT_TRUE(value->Remove(unknown_key, NULL));
 }
 
 }  // namespace extensions