Home | History | Annotate | Download | only in network 
      1 // Copyright (c) 2012 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 "chromeos/network/managed_state.h"
      6 
      7 #include "base/logging.h"
      8 #include "base/values.h"
      9 #include "chromeos/network/device_state.h"
     10 #include "chromeos/network/favorite_state.h"
     11 #include "chromeos/network/network_event_log.h"
     12 #include "chromeos/network/network_state.h"
     13 #include "third_party/cros_system_api/dbus/service_constants.h"
     14 
     15 namespace chromeos {
     16 
     17 ManagedState::ManagedState(ManagedType type, const std::string& path)
     18     : managed_type_(type),
     19       path_(path),
     20       update_received_(false),
     21       update_requested_(false) {
     22 }
     23 
     24 ManagedState::~ManagedState() {
     25 }
     26 
     27 ManagedState* ManagedState::Create(ManagedType type, const std::string& path) {
     28   switch (type) {
     29     case MANAGED_TYPE_NETWORK:
     30       return new NetworkState(path);
     31     case MANAGED_TYPE_FAVORITE:
     32       return new FavoriteState(path);
     33     case MANAGED_TYPE_DEVICE:
     34       return new DeviceState(path);
     35   }
     36   return NULL;
     37 }
     38 
     39 NetworkState* ManagedState::AsNetworkState() {
     40   if (managed_type() == MANAGED_TYPE_NETWORK)
     41     return static_cast<NetworkState*>(this);
     42   return NULL;
     43 }
     44 
     45 DeviceState* ManagedState::AsDeviceState() {
     46   if (managed_type() == MANAGED_TYPE_DEVICE)
     47     return static_cast<DeviceState*>(this);
     48   return NULL;
     49 }
     50 
     51 FavoriteState* ManagedState::AsFavoriteState() {
     52   if (managed_type() == MANAGED_TYPE_FAVORITE)
     53     return static_cast<FavoriteState*>(this);
     54   return NULL;
     55 }
     56 
     57 bool ManagedState::InitialPropertiesReceived(
     58     const base::DictionaryValue& properties) {
     59   return false;
     60 }
     61 
     62 bool ManagedState::ManagedStatePropertyChanged(const std::string& key,
     63                                                const base::Value& value) {
     64   if (key == flimflam::kNameProperty) {
     65     return GetStringValue(key, value, &name_);
     66   } else if (key == flimflam::kTypeProperty) {
     67     return GetStringValue(key, value, &type_);
     68   }
     69   return false;
     70 }
     71 
     72 bool ManagedState::GetBooleanValue(const std::string& key,
     73                                    const base::Value& value,
     74                                    bool* out_value) {
     75   bool new_value;
     76   if (!value.GetAsBoolean(&new_value)) {
     77     NET_LOG_ERROR("Error parsing state value", path() + "." + key);
     78     return false;
     79   }
     80   if (*out_value == new_value)
     81     return false;
     82   *out_value = new_value;
     83   return true;
     84 }
     85 
     86 bool ManagedState::GetIntegerValue(const std::string& key,
     87                                    const base::Value& value,
     88                                    int* out_value) {
     89   int new_value;
     90   if (!value.GetAsInteger(&new_value)) {
     91     NET_LOG_ERROR("Error parsing state value", path() + "." + key);
     92     return false;
     93   }
     94   if (*out_value == new_value)
     95     return false;
     96   *out_value = new_value;
     97   return true;
     98 }
     99 
    100 bool ManagedState::GetStringValue(const std::string& key,
    101                                   const base::Value& value,
    102                                   std::string* out_value) {
    103   std::string new_value;
    104   if (!value.GetAsString(&new_value)) {
    105     NET_LOG_ERROR("Error parsing state value", path() + "." + key);
    106     return false;
    107   }
    108   if (*out_value == new_value)
    109     return false;
    110   *out_value = new_value;
    111   return true;
    112 }
    113 
    114 bool ManagedState::GetUInt32Value(const std::string& key,
    115                                   const base::Value& value,
    116                                   uint32* out_value) {
    117   // base::Value restricts the number types to BOOL, INTEGER, and DOUBLE only.
    118   // uint32 will automatically get converted to a double, which is why we try
    119   // to obtain the value as a double (see dbus/values_util.h).
    120   uint32 new_value;
    121   double double_value;
    122   if (!value.GetAsDouble(&double_value) || double_value < 0) {
    123     NET_LOG_ERROR("Error parsing state value", path() + "." + key);
    124     return false;
    125   }
    126   new_value = static_cast<uint32>(double_value);
    127   if (*out_value == new_value)
    128     return false;
    129   *out_value = new_value;
    130   return true;
    131 }
    132 
    133 }  // namespace chromeos
    134