OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 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 | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "chromeos/dbus/shill_device_client.h" | 5 #include "chromeos/dbus/shill_device_client.h" |
6 | 6 |
7 #include "base/bind.h" | 7 #include "base/bind.h" |
8 #include "base/message_loop/message_loop.h" | 8 #include "base/message_loop/message_loop.h" |
9 #include "base/stl_util.h" | 9 #include "base/stl_util.h" |
10 #include "base/values.h" | 10 #include "base/values.h" |
(...skipping 26 matching lines...) Expand all Loading... |
37 CHECK(iter->second) << "NULL Helper found in helper list."; | 37 CHECK(iter->second) << "NULL Helper found in helper list."; |
38 delete iter->second; | 38 delete iter->second; |
39 } | 39 } |
40 helpers_.clear(); | 40 helpers_.clear(); |
41 } | 41 } |
42 | 42 |
43 /////////////////////////////////////// | 43 /////////////////////////////////////// |
44 // ShillDeviceClient overrides. | 44 // ShillDeviceClient overrides. |
45 virtual void AddPropertyChangedObserver( | 45 virtual void AddPropertyChangedObserver( |
46 const dbus::ObjectPath& device_path, | 46 const dbus::ObjectPath& device_path, |
47 ShillPropertyChangedObserver* observer) OVERRIDE { | 47 ShillPropertyChangedObserver* observer) override { |
48 GetHelper(device_path)->AddPropertyChangedObserver(observer); | 48 GetHelper(device_path)->AddPropertyChangedObserver(observer); |
49 } | 49 } |
50 | 50 |
51 virtual void RemovePropertyChangedObserver( | 51 virtual void RemovePropertyChangedObserver( |
52 const dbus::ObjectPath& device_path, | 52 const dbus::ObjectPath& device_path, |
53 ShillPropertyChangedObserver* observer) OVERRIDE { | 53 ShillPropertyChangedObserver* observer) override { |
54 GetHelper(device_path)->RemovePropertyChangedObserver(observer); | 54 GetHelper(device_path)->RemovePropertyChangedObserver(observer); |
55 } | 55 } |
56 | 56 |
57 virtual void GetProperties(const dbus::ObjectPath& device_path, | 57 virtual void GetProperties(const dbus::ObjectPath& device_path, |
58 const DictionaryValueCallback& callback) OVERRIDE { | 58 const DictionaryValueCallback& callback) override { |
59 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 59 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
60 shill::kGetPropertiesFunction); | 60 shill::kGetPropertiesFunction); |
61 GetHelper(device_path)->CallDictionaryValueMethod(&method_call, callback); | 61 GetHelper(device_path)->CallDictionaryValueMethod(&method_call, callback); |
62 } | 62 } |
63 | 63 |
64 virtual void ProposeScan(const dbus::ObjectPath& device_path, | 64 virtual void ProposeScan(const dbus::ObjectPath& device_path, |
65 const VoidDBusMethodCallback& callback) OVERRIDE { | 65 const VoidDBusMethodCallback& callback) override { |
66 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 66 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
67 shill::kProposeScanFunction); | 67 shill::kProposeScanFunction); |
68 GetHelper(device_path)->CallVoidMethod(&method_call, callback); | 68 GetHelper(device_path)->CallVoidMethod(&method_call, callback); |
69 } | 69 } |
70 | 70 |
71 virtual void SetProperty(const dbus::ObjectPath& device_path, | 71 virtual void SetProperty(const dbus::ObjectPath& device_path, |
72 const std::string& name, | 72 const std::string& name, |
73 const base::Value& value, | 73 const base::Value& value, |
74 const base::Closure& callback, | 74 const base::Closure& callback, |
75 const ErrorCallback& error_callback) OVERRIDE { | 75 const ErrorCallback& error_callback) override { |
76 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 76 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
77 shill::kSetPropertyFunction); | 77 shill::kSetPropertyFunction); |
78 dbus::MessageWriter writer(&method_call); | 78 dbus::MessageWriter writer(&method_call); |
79 writer.AppendString(name); | 79 writer.AppendString(name); |
80 ShillClientHelper::AppendValueDataAsVariant(&writer, value); | 80 ShillClientHelper::AppendValueDataAsVariant(&writer, value); |
81 GetHelper(device_path)->CallVoidMethodWithErrorCallback(&method_call, | 81 GetHelper(device_path)->CallVoidMethodWithErrorCallback(&method_call, |
82 callback, | 82 callback, |
83 error_callback); | 83 error_callback); |
84 } | 84 } |
85 | 85 |
86 virtual void ClearProperty(const dbus::ObjectPath& device_path, | 86 virtual void ClearProperty(const dbus::ObjectPath& device_path, |
87 const std::string& name, | 87 const std::string& name, |
88 const VoidDBusMethodCallback& callback) OVERRIDE { | 88 const VoidDBusMethodCallback& callback) override { |
89 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 89 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
90 shill::kClearPropertyFunction); | 90 shill::kClearPropertyFunction); |
91 dbus::MessageWriter writer(&method_call); | 91 dbus::MessageWriter writer(&method_call); |
92 writer.AppendString(name); | 92 writer.AppendString(name); |
93 GetHelper(device_path)->CallVoidMethod(&method_call, callback); | 93 GetHelper(device_path)->CallVoidMethod(&method_call, callback); |
94 } | 94 } |
95 | 95 |
96 virtual void AddIPConfig( | 96 virtual void AddIPConfig( |
97 const dbus::ObjectPath& device_path, | 97 const dbus::ObjectPath& device_path, |
98 const std::string& method, | 98 const std::string& method, |
99 const ObjectPathDBusMethodCallback& callback) OVERRIDE { | 99 const ObjectPathDBusMethodCallback& callback) override { |
100 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 100 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
101 shill::kAddIPConfigFunction); | 101 shill::kAddIPConfigFunction); |
102 dbus::MessageWriter writer(&method_call); | 102 dbus::MessageWriter writer(&method_call); |
103 writer.AppendString(method); | 103 writer.AppendString(method); |
104 GetHelper(device_path)->CallObjectPathMethod(&method_call, callback); | 104 GetHelper(device_path)->CallObjectPathMethod(&method_call, callback); |
105 } | 105 } |
106 | 106 |
107 virtual void RequirePin(const dbus::ObjectPath& device_path, | 107 virtual void RequirePin(const dbus::ObjectPath& device_path, |
108 const std::string& pin, | 108 const std::string& pin, |
109 bool require, | 109 bool require, |
110 const base::Closure& callback, | 110 const base::Closure& callback, |
111 const ErrorCallback& error_callback) OVERRIDE { | 111 const ErrorCallback& error_callback) override { |
112 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 112 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
113 shill::kRequirePinFunction); | 113 shill::kRequirePinFunction); |
114 dbus::MessageWriter writer(&method_call); | 114 dbus::MessageWriter writer(&method_call); |
115 writer.AppendString(pin); | 115 writer.AppendString(pin); |
116 writer.AppendBool(require); | 116 writer.AppendBool(require); |
117 GetHelper(device_path)->CallVoidMethodWithErrorCallback( | 117 GetHelper(device_path)->CallVoidMethodWithErrorCallback( |
118 &method_call, callback, error_callback); | 118 &method_call, callback, error_callback); |
119 } | 119 } |
120 | 120 |
121 virtual void EnterPin(const dbus::ObjectPath& device_path, | 121 virtual void EnterPin(const dbus::ObjectPath& device_path, |
122 const std::string& pin, | 122 const std::string& pin, |
123 const base::Closure& callback, | 123 const base::Closure& callback, |
124 const ErrorCallback& error_callback) OVERRIDE { | 124 const ErrorCallback& error_callback) override { |
125 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 125 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
126 shill::kEnterPinFunction); | 126 shill::kEnterPinFunction); |
127 dbus::MessageWriter writer(&method_call); | 127 dbus::MessageWriter writer(&method_call); |
128 writer.AppendString(pin); | 128 writer.AppendString(pin); |
129 GetHelper(device_path)->CallVoidMethodWithErrorCallback( | 129 GetHelper(device_path)->CallVoidMethodWithErrorCallback( |
130 &method_call, callback, error_callback); | 130 &method_call, callback, error_callback); |
131 } | 131 } |
132 | 132 |
133 virtual void UnblockPin(const dbus::ObjectPath& device_path, | 133 virtual void UnblockPin(const dbus::ObjectPath& device_path, |
134 const std::string& puk, | 134 const std::string& puk, |
135 const std::string& pin, | 135 const std::string& pin, |
136 const base::Closure& callback, | 136 const base::Closure& callback, |
137 const ErrorCallback& error_callback) OVERRIDE { | 137 const ErrorCallback& error_callback) override { |
138 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 138 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
139 shill::kUnblockPinFunction); | 139 shill::kUnblockPinFunction); |
140 dbus::MessageWriter writer(&method_call); | 140 dbus::MessageWriter writer(&method_call); |
141 writer.AppendString(puk); | 141 writer.AppendString(puk); |
142 writer.AppendString(pin); | 142 writer.AppendString(pin); |
143 GetHelper(device_path)->CallVoidMethodWithErrorCallback( | 143 GetHelper(device_path)->CallVoidMethodWithErrorCallback( |
144 &method_call, callback, error_callback); | 144 &method_call, callback, error_callback); |
145 } | 145 } |
146 | 146 |
147 virtual void ChangePin(const dbus::ObjectPath& device_path, | 147 virtual void ChangePin(const dbus::ObjectPath& device_path, |
148 const std::string& old_pin, | 148 const std::string& old_pin, |
149 const std::string& new_pin, | 149 const std::string& new_pin, |
150 const base::Closure& callback, | 150 const base::Closure& callback, |
151 const ErrorCallback& error_callback) OVERRIDE { | 151 const ErrorCallback& error_callback) override { |
152 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 152 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
153 shill::kChangePinFunction); | 153 shill::kChangePinFunction); |
154 dbus::MessageWriter writer(&method_call); | 154 dbus::MessageWriter writer(&method_call); |
155 writer.AppendString(old_pin); | 155 writer.AppendString(old_pin); |
156 writer.AppendString(new_pin); | 156 writer.AppendString(new_pin); |
157 GetHelper(device_path)->CallVoidMethodWithErrorCallback( | 157 GetHelper(device_path)->CallVoidMethodWithErrorCallback( |
158 &method_call, callback, error_callback); | 158 &method_call, callback, error_callback); |
159 } | 159 } |
160 | 160 |
161 virtual void Register(const dbus::ObjectPath& device_path, | 161 virtual void Register(const dbus::ObjectPath& device_path, |
162 const std::string& network_id, | 162 const std::string& network_id, |
163 const base::Closure& callback, | 163 const base::Closure& callback, |
164 const ErrorCallback& error_callback) OVERRIDE { | 164 const ErrorCallback& error_callback) override { |
165 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 165 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
166 shill::kRegisterFunction); | 166 shill::kRegisterFunction); |
167 dbus::MessageWriter writer(&method_call); | 167 dbus::MessageWriter writer(&method_call); |
168 writer.AppendString(network_id); | 168 writer.AppendString(network_id); |
169 GetHelper(device_path)->CallVoidMethodWithErrorCallback( | 169 GetHelper(device_path)->CallVoidMethodWithErrorCallback( |
170 &method_call, callback, error_callback); | 170 &method_call, callback, error_callback); |
171 } | 171 } |
172 | 172 |
173 virtual void SetCarrier(const dbus::ObjectPath& device_path, | 173 virtual void SetCarrier(const dbus::ObjectPath& device_path, |
174 const std::string& carrier, | 174 const std::string& carrier, |
175 const base::Closure& callback, | 175 const base::Closure& callback, |
176 const ErrorCallback& error_callback) OVERRIDE { | 176 const ErrorCallback& error_callback) override { |
177 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 177 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
178 shill::kSetCarrierFunction); | 178 shill::kSetCarrierFunction); |
179 dbus::MessageWriter writer(&method_call); | 179 dbus::MessageWriter writer(&method_call); |
180 writer.AppendString(carrier); | 180 writer.AppendString(carrier); |
181 GetHelper(device_path)->CallVoidMethodWithErrorCallback( | 181 GetHelper(device_path)->CallVoidMethodWithErrorCallback( |
182 &method_call, callback, error_callback); | 182 &method_call, callback, error_callback); |
183 } | 183 } |
184 | 184 |
185 virtual void Reset(const dbus::ObjectPath& device_path, | 185 virtual void Reset(const dbus::ObjectPath& device_path, |
186 const base::Closure& callback, | 186 const base::Closure& callback, |
187 const ErrorCallback& error_callback) OVERRIDE { | 187 const ErrorCallback& error_callback) override { |
188 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 188 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
189 shill::kResetFunction); | 189 shill::kResetFunction); |
190 GetHelper(device_path)->CallVoidMethodWithErrorCallback( | 190 GetHelper(device_path)->CallVoidMethodWithErrorCallback( |
191 &method_call, callback, error_callback); | 191 &method_call, callback, error_callback); |
192 } | 192 } |
193 | 193 |
194 virtual void PerformTDLSOperation( | 194 virtual void PerformTDLSOperation( |
195 const dbus::ObjectPath& device_path, | 195 const dbus::ObjectPath& device_path, |
196 const std::string& operation, | 196 const std::string& operation, |
197 const std::string& peer, | 197 const std::string& peer, |
198 const StringCallback& callback, | 198 const StringCallback& callback, |
199 const ErrorCallback& error_callback) OVERRIDE { | 199 const ErrorCallback& error_callback) override { |
200 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, | 200 dbus::MethodCall method_call(shill::kFlimflamDeviceInterface, |
201 shill::kPerformTDLSOperationFunction); | 201 shill::kPerformTDLSOperationFunction); |
202 dbus::MessageWriter writer(&method_call); | 202 dbus::MessageWriter writer(&method_call); |
203 writer.AppendString(operation); | 203 writer.AppendString(operation); |
204 writer.AppendString(peer); | 204 writer.AppendString(peer); |
205 GetHelper(device_path)->CallStringMethodWithErrorCallback( | 205 GetHelper(device_path)->CallStringMethodWithErrorCallback( |
206 &method_call, callback, error_callback); | 206 &method_call, callback, error_callback); |
207 } | 207 } |
208 | 208 |
209 virtual TestInterface* GetTestInterface() OVERRIDE { | 209 virtual TestInterface* GetTestInterface() override { |
210 return NULL; | 210 return NULL; |
211 } | 211 } |
212 | 212 |
213 protected: | 213 protected: |
214 virtual void Init(dbus::Bus* bus) OVERRIDE { | 214 virtual void Init(dbus::Bus* bus) override { |
215 bus_ = bus; | 215 bus_ = bus; |
216 } | 216 } |
217 | 217 |
218 private: | 218 private: |
219 typedef std::map<std::string, ShillClientHelper*> HelperMap; | 219 typedef std::map<std::string, ShillClientHelper*> HelperMap; |
220 | 220 |
221 // Returns the corresponding ShillClientHelper for the profile. | 221 // Returns the corresponding ShillClientHelper for the profile. |
222 ShillClientHelper* GetHelper(const dbus::ObjectPath& device_path) { | 222 ShillClientHelper* GetHelper(const dbus::ObjectPath& device_path) { |
223 HelperMap::iterator it = helpers_.find(device_path.value()); | 223 HelperMap::iterator it = helpers_.find(device_path.value()); |
224 if (it != helpers_.end()) { | 224 if (it != helpers_.end()) { |
(...skipping 22 matching lines...) Expand all Loading... |
247 ShillDeviceClient::ShillDeviceClient() {} | 247 ShillDeviceClient::ShillDeviceClient() {} |
248 | 248 |
249 ShillDeviceClient::~ShillDeviceClient() {} | 249 ShillDeviceClient::~ShillDeviceClient() {} |
250 | 250 |
251 // static | 251 // static |
252 ShillDeviceClient* ShillDeviceClient::Create() { | 252 ShillDeviceClient* ShillDeviceClient::Create() { |
253 return new ShillDeviceClientImpl(); | 253 return new ShillDeviceClientImpl(); |
254 } | 254 } |
255 | 255 |
256 } // namespace chromeos | 256 } // namespace chromeos |
OLD | NEW |