Port DictionaryValue to use string16 instead of wstring.

chrome/browser/extensions/extension.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.
 
 #include "chrome/browser/extensions/extension.h"
 
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "net/base/net_util.h"
@@ skipping 145 matching lines @@
   path_ = FilePath(path_str);
 #else
   path_ = path;
 #endif
 }
 
 bool Extension::InitFromValue(const DictionaryValue& source,
                               std::string* error) {
   // Check format version.
   int format_version = 0;
-  if (!source.GetInteger(kFormatVersionKey, &format_version) ||
+  if (!source.GetInteger(WideToUTF16Hack(kFormatVersionKey), &format_version) ||
       static_cast<uint32>(format_version) != kExpectedFormatVersion) {
     *error = kInvalidFormatVersionError;
     return false;
   }
 
   // Initialize id.
-  if (!source.GetString(kIdKey, &id_)) {
+  if (!source.GetString(WideToUTF16Hack(kIdKey), &id_)) {
     *error = kInvalidIdError;
     return false;
   }
 
   // Normalize the string to lowercase, so it can be used as an URL component
   // (where GURL will lowercase it).
   StringToLowerASCII(&id_);
 
   // Verify that the id is legal.  The id is a hex string of the SHA-1 hash of
   // the public key.
   std::vector<uint8> id_bytes;
   if (!HexStringToBytes(id_, &id_bytes) || id_bytes.size() != kIdSize) {
     *error = kInvalidIdError;
     return false;
   }
 
   // Initialize URL.
   extension_url_ = GURL(std::string(chrome::kExtensionScheme) +
                         chrome::kStandardSchemeSeparator + id_ + "/");
 
   // Initialize version.
   std::string version_str;
-  if (!source.GetString(kVersionKey, &version_str)) {
+  if (!source.GetString(WideToUTF16Hack(kVersionKey), &version_str)) {
     *error = kInvalidVersionError;
     return false;
   }
   version_.reset(Version::GetVersionFromString(version_str));
   if (!version_.get()) {
     *error = kInvalidVersionError;
     return false;
   }
 
   // Initialize name.
-  if (!source.GetString(kNameKey, &name_)) {
+  if (!source.GetString(WideToUTF16Hack(kNameKey), &name_)) {
     *error = kInvalidNameError;
     return false;
   }
 
   // Initialize description (optional).
-  if (source.HasKey(kDescriptionKey)) {
-    if (!source.GetString(kDescriptionKey, &description_)) {
+  if (source.HasKey(WideToUTF16Hack(kDescriptionKey))) {
+    if (!source.GetString(WideToUTF16Hack(kDescriptionKey), &description_)) {
       *error = kInvalidDescriptionError;
       return false;
     }
   }
 
   // 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(kZipHashKey)) {
-    if (!source.GetString(kZipHashKey, &zip_hash_)) {
+  if (source.HasKey(WideToUTF16Hack(kZipHashKey))) {
+    if (!source.GetString(WideToUTF16Hack(kZipHashKey), &zip_hash_)) {
       *error = kInvalidZipHashError;
       return false;
     }
   }
 
   // Initialize plugins dir (optional).
-  if (source.HasKey(kPluginsDirKey)) {
+  if (source.HasKey(WideToUTF16Hack(kPluginsDirKey))) {
     std::string plugins_dir;
-    if (!source.GetString(kPluginsDirKey, &plugins_dir)) {
+    if (!source.GetString(WideToUTF16Hack(kPluginsDirKey), &plugins_dir)) {
       *error = kInvalidPluginsDirError;
       return false;
     }
     plugins_dir_ = path_.AppendASCII(plugins_dir);
   }
 
   // Initialize content scripts (optional).
-  if (source.HasKey(kContentScriptsKey)) {
+  if (source.HasKey(WideToUTF16Hack(kContentScriptsKey))) {
     ListValue* list_value;
-    if (!source.GetList(kContentScriptsKey, &list_value)) {
+    if (!source.GetList(WideToUTF16Hack(kContentScriptsKey), &list_value)) {
       *error = kInvalidContentScriptsListError;
       return false;
     }
 
     for (size_t i = 0; i < list_value->GetSize(); ++i) {
       DictionaryValue* content_script;
       if (!list_value->GetDictionary(i, &content_script)) {
         *error = FormatErrorMessage(kInvalidContentScriptError, IntToString(i));
         return false;
       }
 
       ListValue* matches;
       ListValue* js;
 
-      if (!content_script->GetList(kMatchesKey, &matches)) {
+      if (!content_script->GetList(WideToUTF16Hack(kMatchesKey), &matches)) {
         *error = FormatErrorMessage(kInvalidMatchesError, IntToString(i));
         return false;
       }
 
-      if (!content_script->GetList(kJsKey, &js)) {
+      if (!content_script->GetList(WideToUTF16Hack(kJsKey), &js)) {
         *error = FormatErrorMessage(kInvalidJsListError, IntToString(i));
         return false;
       }
 
       if (matches->GetSize() == 0) {
         *error = FormatErrorMessage(kInvalidMatchCountError, IntToString(i));
         return false;
       }
 
       // NOTE: Only one file is supported right now.
       if (js->GetSize() != 1) {
         *error = FormatErrorMessage(kInvalidJsCountError, IntToString(i));
         return false;
       }
 
       UserScript script;
-      if (content_script->HasKey(kRunAtKey)) {
+      if (content_script->HasKey(WideToUTF16Hack(kRunAtKey))) {
         std::string run_location;
-        if (!content_script->GetString(kRunAtKey, &run_location)) {
+        if (!content_script->GetString(WideToUTF16Hack(kRunAtKey),
+                                       &run_location)) {
           *error = FormatErrorMessage(kInvalidRunAtError, IntToString(i));
           return false;
         }
 
         if (run_location == kRunAtDocumentStartValue) {
           script.set_run_location(UserScript::DOCUMENT_START);
         } else if (run_location == kRunAtDocumentEndValue) {
           script.set_run_location(UserScript::DOCUMENT_END);
         } else {
           *error = FormatErrorMessage(kInvalidRunAtError, IntToString(i));
@@ skipping 28 matching lines @@
       }
       script.set_path(Extension::GetResourcePath(path(), file));
       script.set_url(Extension::GetResourceURL(url(), file));
 
       content_scripts_.push_back(script);
     }
   }
 
   return true;
 }
-