base: Add AsList() function to Value API.

This function should simplify some constructions.

Instead of:

if (!value->IsType(Value::TYPE_LIST))
  return false;
ListValue* list_value = static_cast<ListValue*>(value);

You can do:

ListValue* list_value = value->AsList();
if (!list_value)
  return false;

BUG=None
TEST=base_unittests --gtest_filter=Values*

R=evan@chromium.org,tony@chromium.org

Review URL: http://codereview.chromium.org/7714004

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

4 files changed, 26 insertions, 15 deletions

diff --git a/base/json/json_reader_unittest.cc b/base/json/json_reader_unittest.cc
index a7aeaf0..7623a68 100644
--- a/base/json/json_reader_unittest.cc
+++ b/base/json/json_reader_unittest.cc
@@ -222,8 +222,8 @@ TEST(JSONReaderTest, Reading) {
   // Basic array
   root.reset(JSONReader::Read("[true, false, null]", false));
   ASSERT_TRUE(root.get());
-  ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
-  ListValue* list = static_cast<ListValue*>(root.get());
+  ListValue* list = root->AsList();
+  ASSERT_TRUE(list);
   ASSERT_EQ(3U, list->GetSize());
 
   // Test with trailing comma.  Should be parsed the same as above.
@@ -234,16 +234,16 @@ TEST(JSONReaderTest, Reading) {
   // Empty array
   root.reset(JSONReader::Read("[]", false));
   ASSERT_TRUE(root.get());
-  ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
-  list = static_cast<ListValue*>(root.get());
+  list = root->AsList();
+  ASSERT_TRUE(list);
   ASSERT_EQ(0U, list->GetSize());
 
   // Nested arrays
   root.reset(JSONReader::Read("[[true], [], [false, [], [null]], null]",
                               false));
   ASSERT_TRUE(root.get());
-  ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
-  list = static_cast<ListValue*>(root.get());
+  list = root->AsList();
+  ASSERT_TRUE(list);
   ASSERT_EQ(4U, list->GetSize());
 
   // Lots of trailing commas.
@@ -272,8 +272,8 @@ TEST(JSONReaderTest, Reading) {
   // Valid if we set |allow_trailing_comma| to true.
   root.reset(JSONReader::Read("[true,]", true));
   ASSERT_TRUE(root.get());
-  ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
-  list = static_cast<ListValue*>(root.get());
+  list = root->AsList();
+  ASSERT_TRUE(list);
   EXPECT_EQ(1U, list->GetSize());
   Value* tmp_value = NULL;
   ASSERT_TRUE(list->Get(0, &tmp_value));
@@ -435,8 +435,8 @@ TEST(JSONReaderTest, Reading) {
   not_evil.append("[]]");
   root.reset(JSONReader::Read(not_evil, false));
   ASSERT_TRUE(root.get());
-  ASSERT_TRUE(root->IsType(Value::TYPE_LIST));
-  list = static_cast<ListValue*>(root.get());
+  list = root->AsList();
+  ASSERT_TRUE(list);
   ASSERT_EQ(5001U, list->GetSize());
 
   // Test utf8 encoded input
diff --git a/base/values.cc b/base/values.cc
index 17aba16..1798695 100644
--- a/base/values.cc
+++ b/base/values.cc
@@ -97,6 +97,10 @@ StringValue* Value::CreateStringValue(const string16& in_value) {
   return new StringValue(in_value);
 }
 
+ListValue* Value::AsList() {
+  return NULL;
+}
+
 bool Value::GetAsBoolean(bool* out_value) const {
   return false;
 }
@@ -511,7 +515,7 @@ bool DictionaryValue::GetList(const std::string& path,
                               ListValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
-  if (!result || !value->IsType(TYPE_LIST))
+  if (!result || !value->AsList())
     return false;
 
   if (out_value)
@@ -589,7 +593,7 @@ bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
                                                   ListValue** out_value) const {
   Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
-  if (!result || !value->IsType(TYPE_LIST))
+  if (!result || !value->AsList())
     return false;
 
   if (out_value)
@@ -802,7 +806,7 @@ bool ListValue::GetDictionary(size_t index, DictionaryValue** out_value) const {
 bool ListValue::GetList(size_t index, ListValue** out_value) const {
   Value* value;
   bool result = Get(index, &value);
-  if (!result || !value->IsType(TYPE_LIST))
+  if (!result || !value->AsList())
     return false;
 
   if (out_value)
@@ -865,6 +869,10 @@ bool ListValue::Insert(size_t index, Value* in_value) {
   return true;
 }
 
+ListValue* ListValue::AsList() {
+  return this;
+}
+
 bool ListValue::GetAsList(ListValue** out_value) {
   if (out_value)
     *out_value = this;
diff --git a/base/values.h b/base/values.h
index a30791b..2f41215 100644
--- a/base/values.h
+++ b/base/values.h
@@ -87,6 +87,8 @@ class BASE_EXPORT Value {
   // Returns true if the current object represents a given type.
   bool IsType(Type type) const { return type == type_; }
 
+  virtual ListValue* AsList();
+
   // These methods allow the convenient retrieval of settings.
   // If the current setting object can be converted into the given type,
   // the value is returned through the |out_value| parameter and true is
@@ -431,6 +433,7 @@ class BASE_EXPORT ListValue : public Value {
   const_iterator end() const { return list_.end(); }
 
   // Overridden from Value:
+  virtual ListValue* AsList() OVERRIDE;
   virtual bool GetAsList(ListValue** out_value) OVERRIDE;
   virtual bool GetAsList(const ListValue** out_value) const OVERRIDE;
   virtual ListValue* DeepCopy() const OVERRIDE;
diff --git a/base/values_unittest.cc b/base/values_unittest.cc
index 553e8e1..c8d3e3c 100644
--- a/base/values_unittest.cc
+++ b/base/values_unittest.cc
@@ -429,8 +429,8 @@ TEST(ValuesTest, DeepCopy) {
   ASSERT_TRUE(copy_dict->Get("list", &copy_value));
   ASSERT_TRUE(copy_value);
   ASSERT_NE(copy_value, original_list);
-  ASSERT_TRUE(copy_value->IsType(Value::TYPE_LIST));
-  ListValue* copy_list = static_cast<ListValue*>(copy_value);
+  ListValue* copy_list = copy_value->AsList();
+  ASSERT_TRUE(copy_list != NULL);
   ASSERT_EQ(2U, copy_list->GetSize());
 
   Value* copy_list_element_0;