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