Made return types of various Value::DeepCopy() implementations more specific

chrome/common/extensions/extension.cc

 // Copyright (c) 2010 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.h"
 
 #include <algorithm>
 
 #include "app/l10n_util.h"
 #include "base/base64.h"
@@ skipping 1235 matching lines @@
     // development mode, because it keeps the ID stable across restarts and
     // reloading the extension.
     id_ = Extension::GenerateIdForPath(path());
     if (id_.empty()) {
       NOTREACHED() << "Could not create ID from path.";
       return false;
     }
   }
 
   // Make a copy of the manifest so we can store it in prefs.
-  manifest_value_.reset(
-      static_cast<DictionaryValue*>(source.DeepCopy()));
+  manifest_value_.reset(source.DeepCopy());
 
   // Initialize the URL.
   extension_url_ =
       Extension::GetBaseURLFromExtensionId(id());
 
   // Initialize version.
   std::string version_str;
   if (!source.GetString(keys::kVersion, &version_str)) {
     *error = errors::kInvalidVersion;
     return false;
@@ skipping 151 matching lines @@
     if (theme_value->GetDictionary(keys::kThemeImages, &images_value)) {
       // Validate that the images are all strings
       for (DictionaryValue::key_iterator iter = images_value->begin_keys();
            iter != images_value->end_keys(); ++iter) {
         std::string val;
         if (!images_value->GetString(*iter, &val)) {
           *error = errors::kInvalidThemeImages;
           return false;
         }
       }
-      theme_images_.reset(
-          static_cast<DictionaryValue*>(images_value->DeepCopy()));
+      theme_images_.reset(images_value->DeepCopy());
     }
 
     DictionaryValue* colors_value;
     if (theme_value->GetDictionary(keys::kThemeColors, &colors_value)) {
       // Validate that the colors are RGB or RGBA lists
       for (DictionaryValue::key_iterator iter = colors_value->begin_keys();
            iter != colors_value->end_keys(); ++iter) {
         ListValue* color_list;
         double alpha;
         int alpha_int;
         int color;
         // The color must be a list
         if (!colors_value->GetListWithoutPathExpansion(*iter, &color_list) ||
             // And either 3 items (RGB) or 4 (RGBA)
             ((color_list->GetSize() != 3) &&
              ((color_list->GetSize() != 4) ||
               // For RGBA, the fourth item must be a real or int alpha value
               (!color_list->GetReal(3, &alpha) &&
                !color_list->GetInteger(3, &alpha_int)))) ||
             // For both RGB and RGBA, the first three items must be ints (R,G,B)
             !color_list->GetInteger(0, &color) ||
             !color_list->GetInteger(1, &color) ||
             !color_list->GetInteger(2, &color)) {
           *error = errors::kInvalidThemeColors;
           return false;
         }
       }
-      theme_colors_.reset(
-          static_cast<DictionaryValue*>(colors_value->DeepCopy()));
+      theme_colors_.reset(colors_value->DeepCopy());
     }
 
     DictionaryValue* tints_value;
     if (theme_value->GetDictionary(keys::kThemeTints, &tints_value)) {
       // Validate that the tints are all reals.
       for (DictionaryValue::key_iterator iter = tints_value->begin_keys();
            iter != tints_value->end_keys(); ++iter) {
         ListValue* tint_list;
         double v;
         int vi;
         if (!tints_value->GetListWithoutPathExpansion(*iter, &tint_list) ||
             tint_list->GetSize() != 3 ||
             !(tint_list->GetReal(0, &v) || tint_list->GetInteger(0, &vi)) ||
             !(tint_list->GetReal(1, &v) || tint_list->GetInteger(1, &vi)) ||
             !(tint_list->GetReal(2, &v) || tint_list->GetInteger(2, &vi))) {
           *error = errors::kInvalidThemeTints;
           return false;
         }
       }
-      theme_tints_.reset(
-          static_cast<DictionaryValue*>(tints_value->DeepCopy()));
+      theme_tints_.reset(tints_value->DeepCopy());
     }
 
     DictionaryValue* display_properties_value;
     if (theme_value->GetDictionary(keys::kThemeDisplayProperties,
         &display_properties_value)) {
       theme_display_properties_.reset(
-          static_cast<DictionaryValue*>(display_properties_value->DeepCopy()));
+          display_properties_value->DeepCopy());
     }
 
     return true;
   }
 
   // Initialize plugins (optional).
   if (source.HasKey(keys::kPlugins)) {
     ListValue* list_value;
     if (!source.GetList(keys::kPlugins, &list_value)) {
       *error = errors::kInvalidPlugins;
@@ skipping 791 matching lines @@
 }
 
 ExtensionInfo::ExtensionInfo(const DictionaryValue* manifest,
                              const std::string& id,
                              const FilePath& path,
                              Extension::Location location)
     : extension_id(id),
       extension_path(path),
       extension_location(location) {
   if (manifest)
-    extension_manifest.reset(
-        static_cast<DictionaryValue*>(manifest->DeepCopy()));
+    extension_manifest.reset(manifest->DeepCopy());
 }
 
 ExtensionInfo::~ExtensionInfo() {}
 
 UninstalledExtensionInfo::UninstalledExtensionInfo(
     const Extension& extension)
     : extension_id(extension.id()),
       extension_api_permissions(extension.api_permissions()),
       extension_type(extension.GetType()),
       update_url(extension.update_url()) {}
 
 UninstalledExtensionInfo::~UninstalledExtensionInfo() {}
 
 
 UnloadedExtensionInfo::UnloadedExtensionInfo(
     const Extension* extension,
     Reason reason)
   : reason(reason),
     already_disabled(false),
     extension(extension) {}