chromeos/network/managed_state.cc

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