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

chrome/common/extensions/extension_unittest.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"
 
 #if defined(TOOLKIT_GTK)
 #include <gtk/gtk.h>
 #endif
 
@@ skipping 94 matching lines @@
   EXPECT_EQ("", error);
   EXPECT_EQ(0, error_code);
   ASSERT_TRUE(valid_value.get());
   ASSERT_TRUE(extension.InitFromValue(*valid_value, true, &error));
   ASSERT_EQ("", error);
   EXPECT_EQ("en_US", extension.default_locale());
 
   scoped_ptr<DictionaryValue> input_value;
 
   // Test missing and invalid versions
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->Remove(keys::kVersion, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_EQ(errors::kInvalidVersion, error);
 
   input_value->SetInteger(keys::kVersion, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_EQ(errors::kInvalidVersion, error);
 
   // Test missing and invalid names.
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->Remove(keys::kName, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_EQ(errors::kInvalidName, error);
 
   input_value->SetInteger(keys::kName, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_EQ(errors::kInvalidName, error);
 
   // Test invalid description
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->SetInteger(keys::kDescription, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_EQ(errors::kInvalidDescription, error);
 
   // Test invalid icons
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->SetInteger(keys::kIcons, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_EQ(errors::kInvalidIcons, error);
 
   // Test invalid icon paths
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   DictionaryValue* icons = NULL;
   input_value->GetDictionary(keys::kIcons, &icons);
   ASSERT_FALSE(NULL == icons);
   icons->SetInteger(base::IntToString(128), 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidIconPath));
 
   // Test invalid user scripts list
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->SetInteger(keys::kContentScripts, 42);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_EQ(errors::kInvalidContentScriptsList, error);
 
   // Test invalid user script item
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   ListValue* content_scripts = NULL;
   input_value->GetList(keys::kContentScripts, &content_scripts);
   ASSERT_FALSE(NULL == content_scripts);
   content_scripts->Set(0, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidContentScript));
 
   // Test missing and invalid matches array
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->GetList(keys::kContentScripts, &content_scripts);
   DictionaryValue* user_script = NULL;
   content_scripts->GetDictionary(0, &user_script);
   user_script->Remove(keys::kMatches, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatches));
 
   user_script->Set(keys::kMatches, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatches));
 
   ListValue* matches = new ListValue;
   user_script->Set(keys::kMatches, matches);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatchCount));
 
   // Test invalid match element
   matches->Set(0, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatch));
 
   matches->Set(0, Value::CreateStringValue("chrome://*/*"));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMatch));
 
   // Test missing and invalid files array
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->GetList(keys::kContentScripts, &content_scripts);
   content_scripts->GetDictionary(0, &user_script);
   user_script->Remove(keys::kJs, NULL);
   user_script->Remove(keys::kCss, NULL);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kMissingFile));
 
   user_script->Set(keys::kJs, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidJsList));
@@ skipping 21 matching lines @@
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidCssList));
 
   // Test invalid file element
   ListValue* css_files = new ListValue;
   user_script->Set(keys::kCss, css_files);
   css_files->Set(0, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidCss));
 
   // Test missing and invalid permissions array
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   EXPECT_TRUE(extension.InitFromValue(*input_value, true, &error));
   ListValue* permissions = NULL;
   input_value->GetList(keys::kPermissions, &permissions);
   ASSERT_FALSE(NULL == permissions);
 
   permissions = new ListValue;
   input_value->Set(keys::kPermissions, permissions);
   EXPECT_TRUE(extension.InitFromValue(*input_value, true, &error));
 
   input_value->Set(keys::kPermissions, Value::CreateIntegerValue(9));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidPermissions));
 
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->GetList(keys::kPermissions, &permissions);
   permissions->Set(0, Value::CreateIntegerValue(24));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidPermission));
 
   // We allow unknown API permissions, so this will be valid until we better
   // distinguish between API and host permissions.
   permissions->Set(0, Value::CreateStringValue("www.google.com"));
   EXPECT_TRUE(extension.InitFromValue(*input_value, true, &error));
 
   // Multiple page actions are not allowed.
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   DictionaryValue* action = new DictionaryValue;
   action->SetString(keys::kPageActionId, "MyExtensionActionId");
   action->SetString(keys::kName, "MyExtensionActionName");
   ListValue* action_list = new ListValue;
   action_list->Append(action->DeepCopy());
   action_list->Append(action);
   input_value->Set(keys::kPageActions, action_list);
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_STREQ(errors::kInvalidPageActionsListSize, error.c_str());
 
   // Test invalid options page url.
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->Set(keys::kOptionsPage, Value::CreateNullValue());
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidOptionsPage));
 
   // Test invalid/empty default locale.
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->Set(keys::kDefaultLocale, Value::CreateIntegerValue(5));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidDefaultLocale));
 
   input_value->Set(keys::kDefaultLocale, Value::CreateStringValue(""));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidDefaultLocale));
 
   // Test invalid minimum_chrome_version.
-  input_value.reset(static_cast<DictionaryValue*>(valid_value->DeepCopy()));
+  input_value.reset(valid_value->DeepCopy());
   input_value->Set(keys::kMinimumChromeVersion, Value::CreateIntegerValue(42));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kInvalidMinimumChromeVersion));
 
 #if !defined(OS_MACOSX)
   // TODO(aa): The version isn't stamped into the unit test binary on mac.
   input_value->Set(keys::kMinimumChromeVersion,
                    Value::CreateStringValue("88.8"));
   EXPECT_FALSE(extension.InitFromValue(*input_value, true, &error));
   EXPECT_TRUE(MatchPattern(error, errors::kChromeVersionTooLow));
@@ skipping 174 matching lines @@
   input.SetString(keys::kType, values::kPageActionTypeTab);
   action.reset(extension.LoadExtensionActionHelper(&input, &error_msg));
   ASSERT_TRUE(NULL != action.get());
   ASSERT_TRUE(error_msg.empty());
 
   // Make a deep copy of the input and remove one key at a time and see if we
   // get the right error.
   scoped_ptr<DictionaryValue> copy;
 
   // First remove id key.
-  copy.reset(static_cast<DictionaryValue*>(input.DeepCopy()));
+  copy.reset(input.DeepCopy());
   copy->Remove(keys::kPageActionId, NULL);
   action.reset(extension.LoadExtensionActionHelper(copy.get(), &error_msg));
   ASSERT_TRUE(NULL != action.get());
 
   // Then remove the name key. It's optional, so no error.
-  copy.reset(static_cast<DictionaryValue*>(input.DeepCopy()));
+  copy.reset(input.DeepCopy());
   copy->Remove(keys::kName, NULL);
   action.reset(extension.LoadExtensionActionHelper(copy.get(), &error_msg));
   ASSERT_TRUE(NULL != action.get());
   ASSERT_TRUE(action->GetTitle(1).empty());
   ASSERT_TRUE(error_msg.empty());
 
   // Then remove the icon paths key.
-  copy.reset(static_cast<DictionaryValue*>(input.DeepCopy()));
+  copy.reset(input.DeepCopy());
   copy->Remove(keys::kPageActionIcons, NULL);
   action.reset(extension.LoadExtensionActionHelper(copy.get(), &error_msg));
   ASSERT_TRUE(NULL != action.get());
   error_msg = "";
 
   // Now test that we can parse the new format for page actions.
 
   // Now setup some values to use in the page action.
   const std::string kTitle("MyExtensionActionTitle");
   const std::string kIcon("image1.png");
@@ skipping 762 matching lines @@
   EXPECT_TRUE(Extension::GenerateId("test", &result));
   EXPECT_EQ(result, "jpignaibiiemhngfjkcpokkamffknabf");
 
   EXPECT_TRUE(Extension::GenerateId("_", &result));
   EXPECT_EQ(result, "ncocknphbhhlhkikpnnlmbcnbgdempcd");
 
   EXPECT_TRUE(Extension::GenerateId(
       "this_string_is_longer_than_a_single_sha256_hash_digest", &result));
   EXPECT_EQ(result, "jimneklojkjdibfkgiiophfhjhbdgcfi");
 }