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

base/values.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 "base/values.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
@@ skipping 52 matching lines @@
 
 Value::~Value() {
 }
 
 // static
 Value* Value::CreateNullValue() {
   return new Value(TYPE_NULL);
 }
 
 // static
-Value* Value::CreateBooleanValue(bool in_value) {
+FundamentalValue* Value::CreateBooleanValue(bool in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
-Value* Value::CreateIntegerValue(int in_value) {
+FundamentalValue* Value::CreateIntegerValue(int in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
-Value* Value::CreateRealValue(double in_value) {
+FundamentalValue* Value::CreateRealValue(double in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
-Value* Value::CreateStringValue(const std::string& in_value) {
+StringValue* Value::CreateStringValue(const std::string& in_value) {
   return new StringValue(in_value);
 }
 
 // static
-Value* Value::CreateStringValue(const string16& in_value) {
+StringValue* Value::CreateStringValue(const string16& in_value) {
   return new StringValue(in_value);
 }
 
 // static
 BinaryValue* Value::CreateBinaryValue(char* buffer, size_t size) {
   return BinaryValue::Create(buffer, size);
 }
 
 bool Value::GetAsBoolean(bool* out_value) const {
   return false;
@@ skipping 71 matching lines @@
     *out_value = integer_value_;
   return (IsType(TYPE_INTEGER));
 }
 
 bool FundamentalValue::GetAsReal(double* out_value) const {
   if (out_value && IsType(TYPE_REAL))
     *out_value = real_value_;
   return (IsType(TYPE_REAL));
 }
 
-Value* FundamentalValue::DeepCopy() const {
+FundamentalValue* FundamentalValue::DeepCopy() const {
   switch (GetType()) {
     case TYPE_BOOLEAN:
       return CreateBooleanValue(boolean_value_);
 
     case TYPE_INTEGER:
       return CreateIntegerValue(integer_value_);
 
     case TYPE_REAL:
       return CreateRealValue(real_value_);
 
@@ skipping 47 matching lines @@
     *out_value = value_;
   return true;
 }
 
 bool StringValue::GetAsString(string16* out_value) const {
   if (out_value)
     *out_value = UTF8ToUTF16(value_);
   return true;
 }
 
-Value* StringValue::DeepCopy() const {
+StringValue* StringValue::DeepCopy() const {
   return CreateStringValue(value_);
 }
 
 bool StringValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
   std::string lhs, rhs;
   return GetAsString(&lhs) && other->GetAsString(&rhs) && lhs == rhs;
 }
 
@@ skipping 17 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);
 }
 
-Value* BinaryValue::DeepCopy() const {
+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;
   return !memcmp(buffer_, other_binary->buffer_, size_);
@@ skipping 337 matching lines @@
               static_cast<const DictionaryValue*>(merge_value));
           continue;
         }
       }
       // All other cases: Make a copy and hook it up.
       SetWithoutPathExpansion(*key, merge_value->DeepCopy());
     }
   }
 }
 
-Value* DictionaryValue::DeepCopy() const {
+DictionaryValue* DictionaryValue::DeepCopy() const {
   DictionaryValue* result = new DictionaryValue;
 
   for (ValueMap::const_iterator current_entry(dictionary_.begin());
        current_entry != dictionary_.end(); ++current_entry) {
     result->SetWithoutPathExpansion(current_entry->first,
                                     current_entry->second->DeepCopy());
   }
 
   return result;
 }
@@ skipping 195 matching lines @@
   list_.insert(list_.begin() + index, in_value);
   return true;
 }
 
 bool ListValue::GetAsList(ListValue** out_value) {
   if (out_value)
     *out_value = this;
   return true;
 }
 
-Value* ListValue::DeepCopy() const {
+ListValue* ListValue::DeepCopy() const {
   ListValue* result = new ListValue;
 
   for (ValueVector::const_iterator i(list_.begin()); i != list_.end(); ++i)
     result->Append((*i)->DeepCopy());
 
   return result;
 }
 
 bool ListValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
 
   const ListValue* other_list =
       static_cast<const ListValue*>(other);
   const_iterator lhs_it, rhs_it;
   for (lhs_it = begin(), rhs_it = other_list->begin();
        lhs_it != end() && rhs_it != other_list->end();
        ++lhs_it, ++rhs_it) {
     if (!(*lhs_it)->Equals(*rhs_it))
       return false;
   }
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }
 
 ValueSerializer::~ValueSerializer() {
 }