base: Add AsBinary() function to Value API.

base/values.cc

 // Copyright (c) 2011 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 "base/values.h"
 
 #include "base/float_util.h"
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 namespace {
 
 // Make a deep copy of |node|, but don't include empty lists or dictionaries
 // in the copy. It's possible for this function to return NULL and it
 // expects |node| to always be non-NULL.
 Value* CopyWithoutEmptyChildren(Value* node) {
   DCHECK(node);
   switch (node->GetType()) {
     case Value::TYPE_LIST: {
-      ListValue* list = static_cast<ListValue*>(node);
+      ListValue* list = node->AsList();
       ListValue* copy = new ListValue;
       for (ListValue::const_iterator it = list->begin(); it != list->end();
            ++it) {
         Value* child_copy = CopyWithoutEmptyChildren(*it);
         if (child_copy)
           copy->Append(child_copy);
       }
       if (!copy->empty())
         return copy;
 
@@ skipping 58 matching lines @@
 // static
 StringValue* Value::CreateStringValue(const std::string& in_value) {
   return new StringValue(in_value);
 }
 
 // static
 StringValue* Value::CreateStringValue(const string16& in_value) {
   return new StringValue(in_value);
 }
 
+BinaryValue* Value::AsBinary() {
+  return NULL;
+}
+
 ListValue* Value::AsList() {
   return NULL;
 }
 
 bool Value::GetAsBoolean(bool* out_value) const {
   return false;
 }
 
 bool Value::GetAsInteger(int* out_value) const {
   return false;
@@ skipping 184 matching lines @@
 BinaryValue* BinaryValue::CreateWithCopiedBuffer(const char* buffer,
                                                  size_t size) {
   if (!buffer)
     return NULL;
 
   char* buffer_copy = new char[size];
   memcpy(buffer_copy, buffer, size);
   return new BinaryValue(buffer_copy, size);
 }
 
+BinaryValue* BinaryValue::AsBinary() {
+  return this;
+}
+
 BinaryValue* BinaryValue::DeepCopy() const {
   return CreateWithCopiedBuffer(buffer_, size_);
 }
 
 bool BinaryValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
   const BinaryValue* other_binary = static_cast<const BinaryValue*>(other);
   if (other_binary->size_ != size_)
     return false;
@@ skipping 168 matching lines @@
   }
 
   out_value->assign(out);
   return true;
 }
 
 bool DictionaryValue::GetBinary(const std::string& path,
                                 BinaryValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
-  if (!result || !value->IsType(TYPE_BINARY))
+  if (!result || !value->AsBinary())
     return false;
 
   if (out_value)
-    *out_value = static_cast<BinaryValue*>(value);
+    *out_value = value->AsBinary();
 
   return true;
 }
 
 bool DictionaryValue::GetDictionary(const std::string& path,
                                     DictionaryValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(TYPE_DICTIONARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<DictionaryValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetList(const std::string& path,
                               ListValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
   if (!result || !value->AsList())
     return false;
 
   if (out_value)
-    *out_value = static_cast<ListValue*>(value);
+    *out_value = value->AsList();
 
   return true;
 }
 
 bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
                                               Value** out_value) const {
   DCHECK(IsStringUTF8(key));
   ValueMap::const_iterator entry_iterator = dictionary_.find(key);
   if (entry_iterator == dictionary_.end())
     return false;
@@ skipping 57 matching lines @@
 }
 
 bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
                                                   ListValue** out_value) const {
   Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
   if (!result || !value->AsList())
     return false;
 
   if (out_value)
-    *out_value = static_cast<ListValue*>(value);
+    *out_value = value->AsList();
 
   return true;
 }
 
 bool DictionaryValue::Remove(const std::string& path, Value** out_value) {
   DCHECK(IsStringUTF8(path));
   std::string current_path(path);
   DictionaryValue* current_dictionary = this;
   size_t delimiter_position = current_path.rfind('.');
   if (delimiter_position != std::string::npos) {
@@ skipping 192 matching lines @@
   return true;
 }
 
 bool ListValue::GetList(size_t index, ListValue** out_value) const {
   Value* value;
   bool result = Get(index, &value);
   if (!result || !value->AsList())
     return false;
 
   if (out_value)
-    *out_value = static_cast<ListValue*>(value);
+    *out_value = value->AsList();
 
   return true;
 }
 
 bool ListValue::Remove(size_t index, Value** out_value) {
   if (index >= list_.size())
     return false;
 
   if (out_value)
     *out_value = list_[index];
@@ skipping 86 matching lines @@
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }
 
 ValueSerializer::~ValueSerializer() {
 }
 
 }  // namespace base