Revert dsh's change 10818

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@10821 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 48 insertions, 55 deletions

diff --git a/chrome/browser/extensions/extension.cc b/chrome/browser/extensions/extension.cc
index 1db97ceb..918268f 100644
--- a/chrome/browser/extensions/extension.cc
+++ b/chrome/browser/extensions/extension.cc
@@ -163,14 +163,14 @@ bool Extension::InitFromValue(const DictionaryValue& source,
                               std::string* error) {
   // Check format version.
   int format_version = 0;
-  if (!source.GetInteger(WideToUTF16Hack(kFormatVersionKey), &format_version) ||
+  if (!source.GetInteger(kFormatVersionKey, &format_version) ||
       static_cast<uint32>(format_version) != kExpectedFormatVersion) {
     *error = kInvalidFormatVersionError;
     return false;
   }
 
   // Initialize id.
-  if (!source.GetString(WideToUTF16Hack(kIdKey), &id_)) {
+  if (!source.GetString(kIdKey, &id_)) {
     *error = kInvalidIdError;
     return false;
   }
@@ -193,7 +193,7 @@ bool Extension::InitFromValue(const DictionaryValue& source,
 
   // Initialize version.
   std::string version_str;
-  if (!source.GetString(WideToUTF16Hack(kVersionKey), &version_str)) {
+  if (!source.GetString(kVersionKey, &version_str)) {
     *error = kInvalidVersionError;
     return false;
   }
@@ -204,14 +204,14 @@ bool Extension::InitFromValue(const DictionaryValue& source,
   }
 
   // Initialize name.
-  if (!source.GetString(WideToUTF16Hack(kNameKey), &name_)) {
+  if (!source.GetString(kNameKey, &name_)) {
     *error = kInvalidNameError;
     return false;
   }
 
   // Initialize description (optional).
-  if (source.HasKey(WideToUTF16Hack(kDescriptionKey))) {
-    if (!source.GetString(WideToUTF16Hack(kDescriptionKey), &description_)) {
+  if (source.HasKey(kDescriptionKey)) {
+    if (!source.GetString(kDescriptionKey, &description_)) {
       *error = kInvalidDescriptionError;
       return false;
     }
@@ -220,17 +220,17 @@ bool Extension::InitFromValue(const DictionaryValue& source,
   // Initialize zip hash (only present in zip)
   // There's no need to verify it at this point. If it's in a bogus format
   // it won't pass the hash verify step.
-  if (source.HasKey(WideToUTF16Hack(kZipHashKey))) {
-    if (!source.GetString(WideToUTF16Hack(kZipHashKey), &zip_hash_)) {
+  if (source.HasKey(kZipHashKey)) {
+    if (!source.GetString(kZipHashKey, &zip_hash_)) {
       *error = kInvalidZipHashError;
       return false;
     }
   }
 
   // Initialize plugins dir (optional).
-  if (source.HasKey(WideToUTF16Hack(kPluginsDirKey))) {
+  if (source.HasKey(kPluginsDirKey)) {
     std::string plugins_dir;
-    if (!source.GetString(WideToUTF16Hack(kPluginsDirKey), &plugins_dir)) {
+    if (!source.GetString(kPluginsDirKey, &plugins_dir)) {
       *error = kInvalidPluginsDirError;
       return false;
     }
@@ -238,9 +238,9 @@ bool Extension::InitFromValue(const DictionaryValue& source,
   }
 
   // Initialize content scripts (optional).
-  if (source.HasKey(WideToUTF16Hack(kContentScriptsKey))) {
+  if (source.HasKey(kContentScriptsKey)) {
     ListValue* list_value;
-    if (!source.GetList(WideToUTF16Hack(kContentScriptsKey), &list_value)) {
+    if (!source.GetList(kContentScriptsKey, &list_value)) {
       *error = kInvalidContentScriptsListError;
       return false;
     }
@@ -255,12 +255,12 @@ bool Extension::InitFromValue(const DictionaryValue& source,
       ListValue* matches;
       ListValue* js;
 
-      if (!content_script->GetList(WideToUTF16Hack(kMatchesKey), &matches)) {
+      if (!content_script->GetList(kMatchesKey, &matches)) {
         *error = FormatErrorMessage(kInvalidMatchesError, IntToString(i));
         return false;
       }
 
-      if (!content_script->GetList(WideToUTF16Hack(kJsKey), &js)) {
+      if (!content_script->GetList(kJsKey, &js)) {
         *error = FormatErrorMessage(kInvalidJsListError, IntToString(i));
         return false;
       }
@@ -277,10 +277,9 @@ bool Extension::InitFromValue(const DictionaryValue& source,
       }
 
       UserScript script;
-      if (content_script->HasKey(WideToUTF16Hack(kRunAtKey))) {
+      if (content_script->HasKey(kRunAtKey)) {
         std::string run_location;
-        if (!content_script->GetString(WideToUTF16Hack(kRunAtKey),
-                                       &run_location)) {
+        if (!content_script->GetString(kRunAtKey, &run_location)) {
           *error = FormatErrorMessage(kInvalidRunAtError, IntToString(i));
           return false;
         }
@@ -329,3 +328,4 @@ bool Extension::InitFromValue(const DictionaryValue& source,
 
   return true;
 }
+
diff --git a/chrome/browser/extensions/extension_unittest.cc b/chrome/browser/extensions/extension_unittest.cc
index 259c8db..aa8d791 100644
--- a/chrome/browser/extensions/extension_unittest.cc
+++ b/chrome/browser/extensions/extension_unittest.cc
@@ -43,65 +43,64 @@ TEST(ExtensionTest, InitFromValueInvalid) {
 
   // Test missing and invalid format versions
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
-  input_value->Remove(WideToUTF16Hack(Extension::kFormatVersionKey), NULL);
+  input_value->Remove(Extension::kFormatVersionKey, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidFormatVersionError, error);
 
-  input_value->SetString(WideToUTF16Hack(Extension::kFormatVersionKey), "foo");
+  input_value->SetString(Extension::kFormatVersionKey, "foo");
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidFormatVersionError, error);
 
-  input_value->SetInteger(WideToUTF16Hack(Extension::kFormatVersionKey), 2);
+  input_value->SetInteger(Extension::kFormatVersionKey, 2);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidFormatVersionError, error);
 
   // Test missing and invalid ids
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
-  input_value->Remove(WideToUTF16Hack(Extension::kIdKey), NULL);
+  input_value->Remove(Extension::kIdKey, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidIdError, error);
 
-  input_value->SetInteger(WideToUTF16Hack(Extension::kIdKey), 42);
+  input_value->SetInteger(Extension::kIdKey, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidIdError, error);
 
   // Test missing and invalid versions
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
-  input_value->Remove(WideToUTF16Hack(Extension::kVersionKey), NULL);
+  input_value->Remove(Extension::kVersionKey, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidVersionError, error);
 
-  input_value->SetInteger(WideToUTF16Hack(Extension::kVersionKey), 42);
+  input_value->SetInteger(Extension::kVersionKey, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidVersionError, error);
 
   // Test missing and invalid names
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
-  input_value->Remove(WideToUTF16Hack(Extension::kNameKey), NULL);
+  input_value->Remove(Extension::kNameKey, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidNameError, error);
 
-  input_value->SetInteger(WideToUTF16Hack(Extension::kNameKey), 42);
+  input_value->SetInteger(Extension::kNameKey, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidNameError, error);
 
   // Test invalid description
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
-  input_value->SetInteger(WideToUTF16Hack(Extension::kDescriptionKey), 42);
+  input_value->SetInteger(Extension::kDescriptionKey, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidDescriptionError, error);
 
   // Test invalid user scripts list
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
-  input_value->SetInteger(WideToUTF16Hack(Extension::kContentScriptsKey), 42);
+  input_value->SetInteger(Extension::kContentScriptsKey, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_EQ(Extension::kInvalidContentScriptsListError, error);
 
   // Test invalid user script item
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
   ListValue* content_scripts = NULL;
-  input_value->GetList(WideToUTF16Hack(Extension::kContentScriptsKey),
-                       &content_scripts);
+  input_value->GetList(Extension::kContentScriptsKey, &content_scripts);
   ASSERT_FALSE(NULL == content_scripts);
   content_scripts->Set(0, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
@@ -109,21 +108,19 @@ TEST(ExtensionTest, InitFromValueInvalid) {
 
   // Test missing and invalid matches array
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
-  input_value->GetList(WideToUTF16Hack(Extension::kContentScriptsKey),
-                       &content_scripts);
+  input_value->GetList(Extension::kContentScriptsKey, &content_scripts);
   DictionaryValue* user_script = NULL;
   content_scripts->GetDictionary(0, &user_script);
-  user_script->Remove(WideToUTF16Hack(Extension::kMatchesKey), NULL);
+  user_script->Remove(Extension::kMatchesKey, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_TRUE(MatchPattern(error, Extension::kInvalidMatchesError));
 
-  user_script->Set(WideToUTF16Hack(Extension::kMatchesKey),
-                   Value::CreateIntegerValue(42));
+  user_script->Set(Extension::kMatchesKey, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_TRUE(MatchPattern(error, Extension::kInvalidMatchesError));
 
   ListValue* matches = new ListValue;
-  user_script->Set(WideToUTF16Hack(Extension::kMatchesKey), matches);
+  user_script->Set(Extension::kMatchesKey, matches);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_TRUE(MatchPattern(error, Extension::kInvalidMatchCountError));
 
@@ -134,20 +131,18 @@ TEST(ExtensionTest, InitFromValueInvalid) {
 
   // Test missing and invalid files array
   input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
-  input_value->GetList(WideToUTF16Hack(Extension::kContentScriptsKey),
-                       &content_scripts);
+  input_value->GetList(Extension::kContentScriptsKey, &content_scripts);
   content_scripts->GetDictionary(0, &user_script);
-  user_script->Remove(WideToUTF16Hack(Extension::kJsKey), NULL);
+  user_script->Remove(Extension::kJsKey, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_TRUE(MatchPattern(error, Extension::kInvalidJsListError));
 
-  user_script->Set(WideToUTF16Hack(Extension::kJsKey),
-                   Value::CreateIntegerValue(42));
+  user_script->Set(Extension::kJsKey, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_TRUE(MatchPattern(error, Extension::kInvalidJsListError));
 
   ListValue* files = new ListValue;
-  user_script->Set(WideToUTF16Hack(Extension::kJsKey), files);
+  user_script->Set(Extension::kJsKey, files);
   EXPECT_FALSE(extension.InitFromValue(*input_value, &error));
   EXPECT_TRUE(MatchPattern(error, Extension::kInvalidJsCountError));
 
@@ -174,11 +169,11 @@ TEST(ExtensionTest, InitFromValueValid) {
   DictionaryValue input_value;
 
   // Test minimal extension
-  input_value.SetInteger(WideToUTF16Hack(Extension::kFormatVersionKey), 1);
-  input_value.SetString(WideToUTF16Hack(Extension::kIdKey),
+  input_value.SetInteger(Extension::kFormatVersionKey, 1);
+  input_value.SetString(Extension::kIdKey,
       "00123456789ABCDEF0123456789ABCDEF0123456");
-  input_value.SetString(WideToUTF16Hack(Extension::kVersionKey), "1.0.0.0");
-  input_value.SetString(WideToUTF16Hack(Extension::kNameKey), "my extension");
+  input_value.SetString(Extension::kVersionKey, "1.0.0.0");
+  input_value.SetString(Extension::kNameKey, "my extension");
 
   EXPECT_TRUE(extension.InitFromValue(input_value, &error));
   EXPECT_EQ("", error);
@@ -198,11 +193,11 @@ TEST(ExtensionTest, GetResourceURLAndPath) {
 #endif
   Extension extension(path);
   DictionaryValue input_value;
-  input_value.SetInteger(WideToUTF16Hack(Extension::kFormatVersionKey), 1);
-  input_value.SetString(WideToUTF16Hack(Extension::kIdKey),
+  input_value.SetInteger(Extension::kFormatVersionKey, 1);
+  input_value.SetString(Extension::kIdKey,
       "00123456789ABCDEF0123456789ABCDEF0123456");
-  input_value.SetString(WideToUTF16Hack(Extension::kVersionKey), "1.0.0.0");
-  input_value.SetString(WideToUTF16Hack(Extension::kNameKey), "my extension");
+  input_value.SetString(Extension::kVersionKey, "1.0.0.0");
+  input_value.SetString(Extension::kNameKey, "my extension");
   EXPECT_TRUE(extension.InitFromValue(input_value, NULL));
 
   EXPECT_EQ(extension.url().spec() + "bar/baz.js",
diff --git a/chrome/browser/extensions/extensions_service.cc b/chrome/browser/extensions/extensions_service.cc
index be6f068..3271920 100644
--- a/chrome/browser/extensions/extensions_service.cc
+++ b/chrome/browser/extensions/extensions_service.cc
@@ -402,15 +402,14 @@ DictionaryValue* ExtensionsServiceBackend::ReadManifest() {
   // again later, checking it here allows us to skip some potentially expensive
   // work.
   std::string id;
-  if (!manifest->GetString(WideToUTF16Hack(Extension::kIdKey), &id)) {
+  if (!manifest->GetString(Extension::kIdKey, &id)) {
     ReportExtensionInstallError("missing id key");
     return NULL;
   }
   FilePath dest_dir = install_directory_.AppendASCII(id.c_str());
   if (file_util::PathExists(dest_dir)) {
     std::string version;
-    if (!manifest->GetString(WideToUTF16Hack(Extension::kVersionKey),
-                             &version)) {
+    if (!manifest->GetString(Extension::kVersionKey, &version)) {
       ReportExtensionInstallError("missing version key");
       return NULL;
     }
@@ -422,8 +421,7 @@ DictionaryValue* ExtensionsServiceBackend::ReadManifest() {
   }
 
   std::string zip_hash;
-  if (!manifest->GetString(WideToUTF16Hack(Extension::kZipHashKey),
-                           &zip_hash)) {
+  if (!manifest->GetString(Extension::kZipHashKey, &zip_hash)) {
     ReportExtensionInstallError("missing zip_hash key");
     return NULL;
   }