Home | History | Annotate | Download | only in automation 
      1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/test/automation/value_conversion_traits.h"
      6 
      7 #include "base/values.h"
      8 
      9 using base::DictionaryValue;
     10 using base::ListValue;
     11 using base::Value;
     12 
     13 Value* ValueConversionTraits<int>::CreateValueFrom(int t) {
     14   return new base::FundamentalValue(t);
     15 }
     16 
     17 bool ValueConversionTraits<int>::SetFromValue(const Value* value, int* t) {
     18   return value->GetAsInteger(t);
     19 }
     20 
     21 bool ValueConversionTraits<int>::CanConvert(const Value* value) {
     22   int t;
     23   return SetFromValue(value, &t);
     24 }
     25 
     26 Value* ValueConversionTraits<bool>::CreateValueFrom(bool t) {
     27   return new base::FundamentalValue(t);
     28 }
     29 
     30 bool ValueConversionTraits<bool>::SetFromValue(const Value* value, bool* t) {
     31   return value->GetAsBoolean(t);
     32 }
     33 
     34 bool ValueConversionTraits<bool>::CanConvert(const Value* value) {
     35   bool t;
     36   return SetFromValue(value, &t);
     37 }
     38 
     39 Value* ValueConversionTraits<std::string>::CreateValueFrom(
     40     const std::string& t) {
     41   return new base::StringValue(t);
     42 }
     43 
     44 bool ValueConversionTraits<std::string>::SetFromValue(
     45     const Value* value, std::string* t) {
     46   return value->GetAsString(t);
     47 }
     48 
     49 bool ValueConversionTraits<std::string>::CanConvert(const Value* value) {
     50   std::string t;
     51   return SetFromValue(value, &t);
     52 }
     53 
     54 Value* ValueConversionTraits<Value*>::CreateValueFrom(const Value* t) {
     55   return t->DeepCopy();
     56 }
     57 
     58 bool ValueConversionTraits<Value*>::SetFromValue(
     59     const Value* value, Value** t) {
     60   *t = value->DeepCopy();
     61   return true;
     62 }
     63 
     64 bool ValueConversionTraits<Value*>::CanConvert(const Value* value) {
     65   return true;
     66 }
     67 
     68 Value* ValueConversionTraits<ListValue*>::CreateValueFrom(const ListValue* t) {
     69   return t->DeepCopy();
     70 }
     71 
     72 bool ValueConversionTraits<ListValue*>::SetFromValue(const Value* value,
     73                                                      ListValue** t) {
     74   if (!value->IsType(Value::TYPE_LIST))
     75     return false;
     76   *t = static_cast<const ListValue*>(value)->DeepCopy();
     77   return true;
     78 }
     79 
     80 bool ValueConversionTraits<ListValue*>::CanConvert(const Value* value) {
     81   return value->IsType(Value::TYPE_LIST);
     82 }
     83 
     84 Value* ValueConversionTraits<DictionaryValue*>::CreateValueFrom(
     85     const DictionaryValue* t) {
     86   return t->DeepCopy();
     87 }
     88 
     89 bool ValueConversionTraits<DictionaryValue*>::SetFromValue(
     90     const Value* value, DictionaryValue** t) {
     91   if (!value->IsType(Value::TYPE_DICTIONARY))
     92     return false;
     93   *t = static_cast<const DictionaryValue*>(value)->DeepCopy();
     94   return true;
     95 }
     96 
     97 bool ValueConversionTraits<DictionaryValue*>::CanConvert(const Value* value) {
     98   return value->IsType(Value::TYPE_DICTIONARY);
     99 }
    100