managed_state.cc revision 010d83a9304c5a91596085d917d248abff47903a 
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
80void ManagedState::GetStateProperties(base::DictionaryValue* dictionary) const {
81  dictionary->SetStringWithoutPathExpansion(shill::kNameProperty, name());
82  dictionary->SetStringWithoutPathExpansion(shill::kTypeProperty, type());
83}
84
85bool ManagedState::ManagedStatePropertyChanged(const std::string& key,
86                                               const base::Value& value) {
87  if (key == shill::kNameProperty) {
88    return GetStringValue(key, value, &name_);
89  } else if (key == shill::kTypeProperty) {
90    return GetStringValue(key, value, &type_);
91  }
92  return false;
93}
94
95bool ManagedState::GetBooleanValue(const std::string& key,
96                                   const base::Value& value,
97                                   bool* out_value) {
98  bool new_value;
99  if (!value.GetAsBoolean(&new_value)) {
100    NET_LOG_ERROR("Error parsing state value", path() + "." + key);
101    return false;
102  }
103  if (*out_value == new_value)
104    return false;
105  *out_value = new_value;
106  return true;
107}
108
109bool ManagedState::GetIntegerValue(const std::string& key,
110                                   const base::Value& value,
111                                   int* out_value) {
112  int new_value;
113  if (!value.GetAsInteger(&new_value)) {
114    NET_LOG_ERROR("Error parsing state value", path() + "." + key);
115    return false;
116  }
117  if (*out_value == new_value)
118    return false;
119  *out_value = new_value;
120  return true;
121}
122
123bool ManagedState::GetStringValue(const std::string& key,
124                                  const base::Value& value,
125                                  std::string* out_value) {
126  std::string new_value;
127  if (!value.GetAsString(&new_value)) {
128    NET_LOG_ERROR("Error parsing state: " + key, path());
129    return false;
130  }
131  if (*out_value == new_value)
132    return false;
133  *out_value = new_value;
134  return true;
135}
136
137bool ManagedState::GetUInt32Value(const std::string& key,
138                                  const base::Value& value,
139                                  uint32* out_value) {
140  // base::Value restricts the number types to BOOL, INTEGER, and DOUBLE only.
141  // uint32 will automatically get converted to a double, which is why we try
142  // to obtain the value as a double (see dbus/values_util.h).
143  uint32 new_value;
144  double double_value;
145  if (!value.GetAsDouble(&double_value) || double_value < 0) {
146    NET_LOG_ERROR("Error parsing state value", path() + "." + key);
147    return false;
148  }
149  new_value = static_cast<uint32>(double_value);
150  if (*out_value == new_value)
151    return false;
152  *out_value = new_value;
153  return true;
154}
155
156}  // namespace chromeos
157