Add scoped_ptr-safe base::Value to Dictionary/List conversion functions.

extensions/common/file_util.cc

 // Copyright 2013 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 "extensions/common/file_util.h"
 
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 176 matching lines @@
                                        int flags,
                                        std::string* error) {
   return LoadExtension(extension_path, std::string(), location, flags, error);
 }
 
 scoped_refptr<Extension> LoadExtension(const base::FilePath& extension_path,
                                        const std::string& extension_id,
                                        Manifest::Location location,
                                        int flags,
                                        std::string* error) {
-  scoped_ptr<base::DictionaryValue> manifest(
-      LoadManifest(extension_path, error));
+  scoped_ptr<base::DictionaryValue> manifest =
+      LoadManifest(extension_path, error);
   if (!manifest.get())
     return NULL;
   if (!extension_l10n_util::LocalizeExtension(
           extension_path, manifest.get(), error)) {
     return NULL;
   }
 
   scoped_refptr<Extension> extension(Extension::Create(
       extension_path, location, *manifest, flags, extension_id, error));
   if (!extension.get())
     return NULL;
 
   std::vector<InstallWarning> warnings;
   if (!ValidateExtension(extension.get(), error, &warnings))
     return NULL;
   extension->AddInstallWarnings(warnings);
 
   return extension;
 }
 
-base::DictionaryValue* LoadManifest(const base::FilePath& extension_path,
-                                    std::string* error) {
+scoped_ptr<base::DictionaryValue> LoadManifest(
+    const base::FilePath& extension_path,
+    std::string* error) {
   return LoadManifest(extension_path, kManifestFilename, error);
 }
 
-base::DictionaryValue* LoadManifest(
+scoped_ptr<base::DictionaryValue> LoadManifest(
     const base::FilePath& extension_path,
     const base::FilePath::CharType* manifest_filename,
     std::string* error) {
   base::FilePath manifest_path = extension_path.Append(manifest_filename);
   if (!base::PathExists(manifest_path)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_UNREADABLE);
     return NULL;
   }
 
   JSONFileValueDeserializer deserializer(manifest_path);
@@ skipping 10 matching lines @@
           "%s  %s", manifest_errors::kManifestParseError, error->c_str());
     }
     return NULL;
   }
 
   if (!root->IsType(base::Value::TYPE_DICTIONARY)) {
     *error = l10n_util::GetStringUTF8(IDS_EXTENSION_MANIFEST_INVALID);
     return NULL;
   }
 
-  return static_cast<base::DictionaryValue*>(root.release());
+  return base::DictionaryValue::From(root.Pass());
 }
 
 bool ValidateExtension(const Extension* extension,
                        std::string* error,
                        std::vector<InstallWarning>* warnings) {
   // Ask registered manifest handlers to validate their paths.
   if (!ManifestHandler::ValidateExtension(extension, error, warnings))
     return false;
 
   // Check children of extension root to see if any of them start with _ and is
@@ skipping 336 matching lines @@
 base::FilePath GetVerifiedContentsPath(const base::FilePath& extension_path) {
   return extension_path.Append(kMetadataFolder)
       .Append(kVerifiedContentsFilename);
 }
 base::FilePath GetComputedHashesPath(const base::FilePath& extension_path) {
   return extension_path.Append(kMetadataFolder).Append(kComputedHashesFilename);
 }
 
 }  // namespace file_util
 }  // namespace extensions