OLD | NEW |
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2011 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 "chrome/browser/chromeos/cros/native_network_parser.h" | 5 #include "chrome/browser/chromeos/cros/native_network_parser.h" |
6 | 6 |
7 #include "base/stringprintf.h" | 7 #include "base/stringprintf.h" |
8 #include "chrome/browser/chromeos/cros/native_network_constants.h" | 8 #include "chrome/browser/chromeos/cros/native_network_constants.h" |
9 #include "chrome/browser/chromeos/cros/network_library.h" | 9 #include "chrome/browser/chromeos/cros/network_library.h" |
10 #include "chrome/browser/chromeos/login/user_manager.h" | 10 #include "chrome/browser/chromeos/login/user_manager.h" |
(...skipping 129 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
140 | 140 |
141 // -------------------- NativeNetworkDeviceParser -------------------- | 141 // -------------------- NativeNetworkDeviceParser -------------------- |
142 | 142 |
143 NativeNetworkDeviceParser::NativeNetworkDeviceParser() | 143 NativeNetworkDeviceParser::NativeNetworkDeviceParser() |
144 : NetworkDeviceParser(get_native_mapper()) { | 144 : NetworkDeviceParser(get_native_mapper()) { |
145 } | 145 } |
146 | 146 |
147 NativeNetworkDeviceParser::~NativeNetworkDeviceParser() { | 147 NativeNetworkDeviceParser::~NativeNetworkDeviceParser() { |
148 } | 148 } |
149 | 149 |
150 bool NativeNetworkDeviceParser::ParseValue(PropertyIndex index, | 150 bool NativeNetworkDeviceParser::ParseValue( |
151 Value* value, | 151 PropertyIndex index, const Value& value, NetworkDevice* device) { |
152 NetworkDevice* device) { | |
153 switch (index) { | 152 switch (index) { |
154 case PROPERTY_INDEX_TYPE: { | 153 case PROPERTY_INDEX_TYPE: { |
155 std::string type_string; | 154 std::string type_string; |
156 if (value->GetAsString(&type_string)) { | 155 if (value.GetAsString(&type_string)) { |
157 device->set_type(ParseType(type_string)); | 156 device->set_type(ParseType(type_string)); |
158 return true; | 157 return true; |
159 } | 158 } |
160 break; | 159 break; |
161 } | 160 } |
162 case PROPERTY_INDEX_NAME: { | 161 case PROPERTY_INDEX_NAME: { |
163 std::string name; | 162 std::string name; |
164 if (!value->GetAsString(&name)) | 163 if (!value.GetAsString(&name)) |
165 return false; | 164 return false; |
166 device->set_name(name); | 165 device->set_name(name); |
167 return true; | 166 return true; |
168 } | 167 } |
169 case PROPERTY_INDEX_GUID: { | 168 case PROPERTY_INDEX_GUID: { |
170 std::string unique_id; | 169 std::string unique_id; |
171 if (!value->GetAsString(&unique_id)) | 170 if (!value.GetAsString(&unique_id)) |
172 return false; | 171 return false; |
173 device->set_unique_id(unique_id); | 172 device->set_unique_id(unique_id); |
174 return true; | 173 return true; |
175 } | 174 } |
176 case PROPERTY_INDEX_CARRIER: { | 175 case PROPERTY_INDEX_CARRIER: { |
177 std::string carrier; | 176 std::string carrier; |
178 if (!value->GetAsString(&carrier)) | 177 if (!value.GetAsString(&carrier)) |
179 return false; | 178 return false; |
180 device->set_carrier(carrier); | 179 device->set_carrier(carrier); |
181 return true; | 180 return true; |
182 } | 181 } |
183 case PROPERTY_INDEX_SCANNING: { | 182 case PROPERTY_INDEX_SCANNING: { |
184 bool scanning; | 183 bool scanning; |
185 if (!value->GetAsBoolean(&scanning)) | 184 if (!value.GetAsBoolean(&scanning)) |
186 return false; | 185 return false; |
187 device->set_scanning(scanning); | 186 device->set_scanning(scanning); |
188 return true; | 187 return true; |
189 } | 188 } |
190 case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING: { | 189 case PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING: { |
191 bool data_roaming_allowed; | 190 bool data_roaming_allowed; |
192 if (!value->GetAsBoolean(&data_roaming_allowed)) | 191 if (!value.GetAsBoolean(&data_roaming_allowed)) |
193 return false; | 192 return false; |
194 device->set_data_roaming_allowed(data_roaming_allowed); | 193 device->set_data_roaming_allowed(data_roaming_allowed); |
195 return true; | 194 return true; |
196 } | 195 } |
197 case PROPERTY_INDEX_CELLULAR_APN_LIST: | 196 case PROPERTY_INDEX_CELLULAR_APN_LIST: |
198 if (ListValue* list = value->AsList()) { | 197 if (value.IsType(Value::TYPE_LIST)) { |
199 CellularApnList provider_apn_list; | 198 CellularApnList provider_apn_list; |
200 if (!ParseApnList(*list, &provider_apn_list)) | 199 if (!ParseApnList(static_cast<const ListValue&>(value), |
| 200 &provider_apn_list)) |
201 return false; | 201 return false; |
202 device->set_provider_apn_list(provider_apn_list); | 202 device->set_provider_apn_list(provider_apn_list); |
203 return true; | 203 return true; |
204 } | 204 } |
205 break; | 205 break; |
206 case PROPERTY_INDEX_NETWORKS: | 206 case PROPERTY_INDEX_NETWORKS: |
207 if (value->AsList()) { | 207 if (value.IsType(Value::TYPE_LIST)) { |
208 // Ignored. | 208 // Ignored. |
209 return true; | 209 return true; |
210 } | 210 } |
211 break; | 211 break; |
212 case PROPERTY_INDEX_FOUND_NETWORKS: | 212 case PROPERTY_INDEX_FOUND_NETWORKS: |
213 if (ListValue* list = value->AsList()) { | 213 if (value.IsType(Value::TYPE_LIST)) { |
214 CellularNetworkList found_cellular_networks; | 214 CellularNetworkList found_cellular_networks; |
215 if (!ParseFoundNetworksFromList(*list, &found_cellular_networks)) | 215 if (!ParseFoundNetworksFromList( |
| 216 static_cast<const ListValue&>(value), |
| 217 &found_cellular_networks)) |
216 return false; | 218 return false; |
217 device->set_found_cellular_networks(found_cellular_networks); | 219 device->set_found_cellular_networks(found_cellular_networks); |
218 return true; | 220 return true; |
219 } | 221 } |
220 break; | 222 break; |
221 case PROPERTY_INDEX_HOME_PROVIDER: { | 223 case PROPERTY_INDEX_HOME_PROVIDER: { |
222 if (value->IsType(Value::TYPE_DICTIONARY)) { | 224 if (value.IsType(Value::TYPE_DICTIONARY)) { |
223 DictionaryValue* dict = static_cast<DictionaryValue*>(value); | 225 const DictionaryValue& dict = |
| 226 static_cast<const DictionaryValue&>(value); |
224 std::string home_provider_code; | 227 std::string home_provider_code; |
225 std::string home_provider_country; | 228 std::string home_provider_country; |
226 std::string home_provider_name; | 229 std::string home_provider_name; |
227 dict->GetStringWithoutPathExpansion(kOperatorCodeKey, | 230 dict.GetStringWithoutPathExpansion(kOperatorCodeKey, |
228 &home_provider_code); | 231 &home_provider_code); |
229 dict->GetStringWithoutPathExpansion(kOperatorCountryKey, | 232 dict.GetStringWithoutPathExpansion(kOperatorCountryKey, |
230 &home_provider_country); | 233 &home_provider_country); |
231 dict->GetStringWithoutPathExpansion(kOperatorNameKey, | 234 dict.GetStringWithoutPathExpansion(kOperatorNameKey, |
232 &home_provider_name); | 235 &home_provider_name); |
233 device->set_home_provider_code(home_provider_code); | 236 device->set_home_provider_code(home_provider_code); |
234 device->set_home_provider_country(home_provider_country); | 237 device->set_home_provider_country(home_provider_country); |
235 device->set_home_provider_name(home_provider_name); | 238 device->set_home_provider_name(home_provider_name); |
236 if (!device->home_provider_name().empty() && | 239 if (!device->home_provider_name().empty() && |
237 !device->home_provider_country().empty()) { | 240 !device->home_provider_country().empty()) { |
238 device->set_home_provider_id(base::StringPrintf( | 241 device->set_home_provider_id(base::StringPrintf( |
239 kCarrierIdFormat, | 242 kCarrierIdFormat, |
240 device->home_provider_name().c_str(), | 243 device->home_provider_name().c_str(), |
241 device->home_provider_country().c_str())); | 244 device->home_provider_country().c_str())); |
242 } else { | 245 } else { |
(...skipping 10 matching lines...) Expand all Loading... |
253 case PROPERTY_INDEX_IMSI: | 256 case PROPERTY_INDEX_IMSI: |
254 case PROPERTY_INDEX_ESN: | 257 case PROPERTY_INDEX_ESN: |
255 case PROPERTY_INDEX_MDN: | 258 case PROPERTY_INDEX_MDN: |
256 case PROPERTY_INDEX_MIN: | 259 case PROPERTY_INDEX_MIN: |
257 case PROPERTY_INDEX_MODEL_ID: | 260 case PROPERTY_INDEX_MODEL_ID: |
258 case PROPERTY_INDEX_MANUFACTURER: | 261 case PROPERTY_INDEX_MANUFACTURER: |
259 case PROPERTY_INDEX_FIRMWARE_REVISION: | 262 case PROPERTY_INDEX_FIRMWARE_REVISION: |
260 case PROPERTY_INDEX_HARDWARE_REVISION: | 263 case PROPERTY_INDEX_HARDWARE_REVISION: |
261 case PROPERTY_INDEX_SELECTED_NETWORK: { | 264 case PROPERTY_INDEX_SELECTED_NETWORK: { |
262 std::string item; | 265 std::string item; |
263 if (!value->GetAsString(&item)) | 266 if (!value.GetAsString(&item)) |
264 return false; | 267 return false; |
265 switch (index) { | 268 switch (index) { |
266 case PROPERTY_INDEX_MEID: | 269 case PROPERTY_INDEX_MEID: |
267 device->set_meid(item); | 270 device->set_meid(item); |
268 break; | 271 break; |
269 case PROPERTY_INDEX_IMEI: | 272 case PROPERTY_INDEX_IMEI: |
270 device->set_imei(item); | 273 device->set_imei(item); |
271 break; | 274 break; |
272 case PROPERTY_INDEX_IMSI: | 275 case PROPERTY_INDEX_IMSI: |
273 device->set_imsi(item); | 276 device->set_imsi(item); |
(...skipping 21 matching lines...) Expand all Loading... |
295 break; | 298 break; |
296 case PROPERTY_INDEX_SELECTED_NETWORK: | 299 case PROPERTY_INDEX_SELECTED_NETWORK: |
297 device->set_selected_cellular_network(item); | 300 device->set_selected_cellular_network(item); |
298 break; | 301 break; |
299 default: | 302 default: |
300 break; | 303 break; |
301 } | 304 } |
302 return true; | 305 return true; |
303 } | 306 } |
304 case PROPERTY_INDEX_SIM_LOCK: | 307 case PROPERTY_INDEX_SIM_LOCK: |
305 if (value->IsType(Value::TYPE_DICTIONARY)) { | 308 if (value.IsType(Value::TYPE_DICTIONARY)) { |
306 SimLockState sim_lock_state; | 309 SimLockState sim_lock_state; |
307 int sim_retries_left; | 310 int sim_retries_left; |
308 if (!ParseSimLockStateFromDictionary( | 311 if (!ParseSimLockStateFromDictionary( |
309 static_cast<const DictionaryValue&>(*value), | 312 static_cast<const DictionaryValue&>(value), |
310 &sim_lock_state, | 313 &sim_lock_state, |
311 &sim_retries_left)) | 314 &sim_retries_left)) |
312 return false; | 315 return false; |
313 device->set_sim_lock_state(sim_lock_state); | 316 device->set_sim_lock_state(sim_lock_state); |
314 device->set_sim_retries_left(sim_retries_left); | 317 device->set_sim_retries_left(sim_retries_left); |
315 // Initialize PinRequired value only once. | 318 // Initialize PinRequired value only once. |
316 // See SimPinRequire enum comments. | 319 // See SimPinRequire enum comments. |
317 if (device->sim_pin_required() == SIM_PIN_REQUIRE_UNKNOWN) { | 320 if (device->sim_pin_required() == SIM_PIN_REQUIRE_UNKNOWN) { |
318 if (device->sim_lock_state() == SIM_UNLOCKED) { | 321 if (device->sim_lock_state() == SIM_UNLOCKED) { |
319 device->set_sim_pin_required(SIM_PIN_NOT_REQUIRED); | 322 device->set_sim_pin_required(SIM_PIN_NOT_REQUIRED); |
320 } else if (device->sim_lock_state() == SIM_LOCKED_PIN || | 323 } else if (device->sim_lock_state() == SIM_LOCKED_PIN || |
321 device->sim_lock_state() == SIM_LOCKED_PUK) { | 324 device->sim_lock_state() == SIM_LOCKED_PUK) { |
322 device->set_sim_pin_required(SIM_PIN_REQUIRED); | 325 device->set_sim_pin_required(SIM_PIN_REQUIRED); |
323 } | 326 } |
324 } | 327 } |
325 return true; | 328 return true; |
326 } | 329 } |
327 break; | 330 break; |
328 case PROPERTY_INDEX_POWERED: | 331 case PROPERTY_INDEX_POWERED: |
329 // we don't care about the value, just the fact that it changed | 332 // we don't care about the value, just the fact that it changed |
330 return true; | 333 return true; |
331 case PROPERTY_INDEX_PRL_VERSION: { | 334 case PROPERTY_INDEX_PRL_VERSION: { |
332 int prl_version; | 335 int prl_version; |
333 if (!value->GetAsInteger(&prl_version)) | 336 if (!value.GetAsInteger(&prl_version)) |
334 return false; | 337 return false; |
335 device->set_prl_version(prl_version); | 338 device->set_prl_version(prl_version); |
336 return true; | 339 return true; |
337 } | 340 } |
338 case PROPERTY_INDEX_SUPPORT_NETWORK_SCAN: { | 341 case PROPERTY_INDEX_SUPPORT_NETWORK_SCAN: { |
339 bool support_network_scan; | 342 bool support_network_scan; |
340 if (!value->GetAsBoolean(&support_network_scan)) | 343 if (!value.GetAsBoolean(&support_network_scan)) |
341 return false; | 344 return false; |
342 device->set_support_network_scan(support_network_scan); | 345 device->set_support_network_scan(support_network_scan); |
343 return true; | 346 return true; |
344 } | 347 } |
345 case PROPERTY_INDEX_TECHNOLOGY_FAMILY: { | 348 case PROPERTY_INDEX_TECHNOLOGY_FAMILY: { |
346 std::string technology_family_string; | 349 std::string technology_family_string; |
347 if (value->GetAsString(&technology_family_string)) { | 350 if (value.GetAsString(&technology_family_string)) { |
348 device->set_technology_family( | 351 device->set_technology_family( |
349 ParseTechnologyFamily(technology_family_string)); | 352 ParseTechnologyFamily(technology_family_string)); |
350 return true; | 353 return true; |
351 } | 354 } |
352 break; | 355 break; |
353 } | 356 } |
354 default: | 357 default: |
355 break; | 358 break; |
356 } | 359 } |
357 return false; | 360 return false; |
(...skipping 109 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
467 return get_native_mapper(); | 470 return get_native_mapper(); |
468 | 471 |
469 } | 472 } |
470 | 473 |
471 const ConnectionType NativeNetworkParser::ParseConnectionType( | 474 const ConnectionType NativeNetworkParser::ParseConnectionType( |
472 const std::string& connection_type) { | 475 const std::string& connection_type) { |
473 return ParseNetworkType(connection_type); | 476 return ParseNetworkType(connection_type); |
474 } | 477 } |
475 | 478 |
476 bool NativeNetworkParser::ParseValue(PropertyIndex index, | 479 bool NativeNetworkParser::ParseValue(PropertyIndex index, |
477 Value* value, | 480 const Value& value, |
478 Network* network) { | 481 Network* network) { |
479 switch (index) { | 482 switch (index) { |
480 case PROPERTY_INDEX_TYPE: { | 483 case PROPERTY_INDEX_TYPE: { |
481 std::string type_string; | 484 std::string type_string; |
482 if (value->GetAsString(&type_string)) { | 485 if (value.GetAsString(&type_string)) { |
483 ConnectionType type = ParseType(type_string); | 486 ConnectionType type = ParseType(type_string); |
484 LOG_IF(ERROR, type != network->type()) | 487 LOG_IF(ERROR, type != network->type()) |
485 << "Network with mismatched type: " << network->service_path() | 488 << "Network with mismatched type: " << network->service_path() |
486 << " " << type << " != " << network->type(); | 489 << " " << type << " != " << network->type(); |
487 return true; | 490 return true; |
488 } | 491 } |
489 break; | 492 break; |
490 } | 493 } |
491 case PROPERTY_INDEX_DEVICE: { | 494 case PROPERTY_INDEX_DEVICE: { |
492 std::string device_path; | 495 std::string device_path; |
493 if (!value->GetAsString(&device_path)) | 496 if (!value.GetAsString(&device_path)) |
494 return false; | 497 return false; |
495 network->set_device_path(device_path); | 498 network->set_device_path(device_path); |
496 return true; | 499 return true; |
497 } | 500 } |
498 case PROPERTY_INDEX_NAME: { | 501 case PROPERTY_INDEX_NAME: { |
499 std::string name; | 502 std::string name; |
500 if (!value->GetAsString(&name)) | 503 if (!value.GetAsString(&name)) |
501 return false; | 504 return false; |
502 network->SetName(name); | 505 network->SetName(name); |
503 return true; | 506 return true; |
504 } | 507 } |
505 case PROPERTY_INDEX_GUID: { | 508 case PROPERTY_INDEX_GUID: { |
506 std::string unique_id; | 509 std::string unique_id; |
507 if (!value->GetAsString(&unique_id)) | 510 if (!value.GetAsString(&unique_id)) |
508 return false; | 511 return false; |
509 network->set_unique_id(unique_id); | 512 network->set_unique_id(unique_id); |
510 return true; | 513 return true; |
511 } | 514 } |
512 case PROPERTY_INDEX_PROFILE: { | 515 case PROPERTY_INDEX_PROFILE: { |
513 // Note: currently this is only provided for non remembered networks. | 516 // Note: currently this is only provided for non remembered networks. |
514 std::string profile_path; | 517 std::string profile_path; |
515 if (!value->GetAsString(&profile_path)) | 518 if (!value.GetAsString(&profile_path)) |
516 return false; | 519 return false; |
517 network->set_profile_path(profile_path); | 520 network->set_profile_path(profile_path); |
518 return true; | 521 return true; |
519 } | 522 } |
520 case PROPERTY_INDEX_STATE: { | 523 case PROPERTY_INDEX_STATE: { |
521 std::string state_string; | 524 std::string state_string; |
522 if (value->GetAsString(&state_string)) { | 525 if (value.GetAsString(&state_string)) { |
523 network->SetState(ParseState(state_string)); | 526 network->SetState(ParseState(state_string)); |
524 return true; | 527 return true; |
525 } | 528 } |
526 break; | 529 break; |
527 } | 530 } |
528 case PROPERTY_INDEX_MODE: { | 531 case PROPERTY_INDEX_MODE: { |
529 std::string mode_string; | 532 std::string mode_string; |
530 if (value->GetAsString(&mode_string)) { | 533 if (value.GetAsString(&mode_string)) { |
531 network->set_mode(ParseMode(mode_string)); | 534 network->set_mode(ParseMode(mode_string)); |
532 return true; | 535 return true; |
533 } | 536 } |
534 break; | 537 break; |
535 } | 538 } |
536 case PROPERTY_INDEX_ERROR: { | 539 case PROPERTY_INDEX_ERROR: { |
537 std::string error_string; | 540 std::string error_string; |
538 if (value->GetAsString(&error_string)) { | 541 if (value.GetAsString(&error_string)) { |
539 network->set_error(ParseError(error_string)); | 542 network->set_error(ParseError(error_string)); |
540 return true; | 543 return true; |
541 } | 544 } |
542 break; | 545 break; |
543 } | 546 } |
544 case PROPERTY_INDEX_CONNECTABLE: { | 547 case PROPERTY_INDEX_CONNECTABLE: { |
545 bool connectable; | 548 bool connectable; |
546 if (!value->GetAsBoolean(&connectable)) | 549 if (!value.GetAsBoolean(&connectable)) |
547 return false; | 550 return false; |
548 network->set_connectable(connectable); | 551 network->set_connectable(connectable); |
549 return true; | 552 return true; |
550 } | 553 } |
551 case PROPERTY_INDEX_IS_ACTIVE: { | 554 case PROPERTY_INDEX_IS_ACTIVE: { |
552 bool is_active; | 555 bool is_active; |
553 if (!value->GetAsBoolean(&is_active)) | 556 if (!value.GetAsBoolean(&is_active)) |
554 return false; | 557 return false; |
555 network->set_is_active(is_active); | 558 network->set_is_active(is_active); |
556 return true; | 559 return true; |
557 } | 560 } |
558 case PROPERTY_INDEX_FAVORITE: | 561 case PROPERTY_INDEX_FAVORITE: |
559 // This property is ignored. | 562 // This property is ignored. |
560 return true; | 563 return true; |
561 case PROPERTY_INDEX_AUTO_CONNECT: { | 564 case PROPERTY_INDEX_AUTO_CONNECT: { |
562 bool auto_connect; | 565 bool auto_connect; |
563 if (!value->GetAsBoolean(&auto_connect)) | 566 if (!value.GetAsBoolean(&auto_connect)) |
564 return false; | 567 return false; |
565 network->set_auto_connect(auto_connect); | 568 network->set_auto_connect(auto_connect); |
566 return true; | 569 return true; |
567 } | 570 } |
568 case PROPERTY_INDEX_SAVE_CREDENTIALS: { | 571 case PROPERTY_INDEX_SAVE_CREDENTIALS: { |
569 bool save_credentials; | 572 bool save_credentials; |
570 if (!value->GetAsBoolean(&save_credentials)) | 573 if (!value.GetAsBoolean(&save_credentials)) |
571 return false; | 574 return false; |
572 network->set_save_credentials(save_credentials); | 575 network->set_save_credentials(save_credentials); |
573 return true; | 576 return true; |
574 } | 577 } |
575 case PROPERTY_INDEX_PROXY_CONFIG: { | 578 case PROPERTY_INDEX_PROXY_CONFIG: { |
576 std::string proxy_config; | 579 std::string proxy_config; |
577 if (!value->GetAsString(&proxy_config)) | 580 if (!value.GetAsString(&proxy_config)) |
578 return false; | 581 return false; |
579 network->set_proxy_config(proxy_config); | 582 network->set_proxy_config(proxy_config); |
580 return true; | 583 return true; |
581 } | 584 } |
582 default: | 585 default: |
583 break; | 586 break; |
584 } | 587 } |
585 return false; | 588 return false; |
586 } | 589 } |
587 | 590 |
(...skipping 62 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
650 | 653 |
651 NativeEthernetNetworkParser::NativeEthernetNetworkParser() {} | 654 NativeEthernetNetworkParser::NativeEthernetNetworkParser() {} |
652 NativeEthernetNetworkParser::~NativeEthernetNetworkParser() {} | 655 NativeEthernetNetworkParser::~NativeEthernetNetworkParser() {} |
653 | 656 |
654 // -------------------- NativeWirelessNetworkParser -------------------- | 657 // -------------------- NativeWirelessNetworkParser -------------------- |
655 | 658 |
656 NativeWirelessNetworkParser::NativeWirelessNetworkParser() {} | 659 NativeWirelessNetworkParser::NativeWirelessNetworkParser() {} |
657 NativeWirelessNetworkParser::~NativeWirelessNetworkParser() {} | 660 NativeWirelessNetworkParser::~NativeWirelessNetworkParser() {} |
658 | 661 |
659 bool NativeWirelessNetworkParser::ParseValue(PropertyIndex index, | 662 bool NativeWirelessNetworkParser::ParseValue(PropertyIndex index, |
660 Value* value, | 663 const Value& value, |
661 Network* network) { | 664 Network* network) { |
662 DCHECK_NE(TYPE_ETHERNET, network->type()); | 665 DCHECK_NE(TYPE_ETHERNET, network->type()); |
663 DCHECK_NE(TYPE_VPN, network->type()); | 666 DCHECK_NE(TYPE_VPN, network->type()); |
664 WirelessNetwork* wireless_network = static_cast<WirelessNetwork*>(network); | 667 WirelessNetwork* wireless_network = static_cast<WirelessNetwork*>(network); |
665 switch (index) { | 668 switch (index) { |
666 case PROPERTY_INDEX_SIGNAL_STRENGTH: { | 669 case PROPERTY_INDEX_SIGNAL_STRENGTH: { |
667 int strength; | 670 int strength; |
668 if (!value->GetAsInteger(&strength)) | 671 if (!value.GetAsInteger(&strength)) |
669 return false; | 672 return false; |
670 wireless_network->set_strength(strength); | 673 wireless_network->set_strength(strength); |
671 return true; | 674 return true; |
672 } | 675 } |
673 default: | 676 default: |
674 return NativeNetworkParser::ParseValue(index, value, network); | 677 return NativeNetworkParser::ParseValue(index, value, network); |
675 break; | 678 break; |
676 } | 679 } |
677 return false; | 680 return false; |
678 } | 681 } |
679 | 682 |
680 // -------------------- NativeCellularNetworkParser -------------------- | 683 // -------------------- NativeCellularNetworkParser -------------------- |
681 | 684 |
682 NativeCellularNetworkParser::NativeCellularNetworkParser() {} | 685 NativeCellularNetworkParser::NativeCellularNetworkParser() {} |
683 NativeCellularNetworkParser::~NativeCellularNetworkParser() {} | 686 NativeCellularNetworkParser::~NativeCellularNetworkParser() {} |
684 | 687 |
685 bool NativeCellularNetworkParser::ParseValue(PropertyIndex index, | 688 bool NativeCellularNetworkParser::ParseValue(PropertyIndex index, |
686 Value* value, | 689 const Value& value, |
687 Network* network) { | 690 Network* network) { |
688 DCHECK_EQ(TYPE_CELLULAR, network->type()); | 691 DCHECK_EQ(TYPE_CELLULAR, network->type()); |
689 CellularNetwork* cellular_network = static_cast<CellularNetwork*>(network); | 692 CellularNetwork* cellular_network = static_cast<CellularNetwork*>(network); |
690 switch (index) { | 693 switch (index) { |
691 case PROPERTY_INDEX_ACTIVATION_STATE: { | 694 case PROPERTY_INDEX_ACTIVATION_STATE: { |
692 std::string activation_state_string; | 695 std::string activation_state_string; |
693 if (value->GetAsString(&activation_state_string)) { | 696 if (value.GetAsString(&activation_state_string)) { |
694 ActivationState prev_state = cellular_network->activation_state(); | 697 ActivationState prev_state = cellular_network->activation_state(); |
695 cellular_network->set_activation_state( | 698 cellular_network->set_activation_state( |
696 ParseActivationState(activation_state_string)); | 699 ParseActivationState(activation_state_string)); |
697 if (cellular_network->activation_state() != prev_state) | 700 if (cellular_network->activation_state() != prev_state) |
698 cellular_network->RefreshDataPlansIfNeeded(); | 701 cellular_network->RefreshDataPlansIfNeeded(); |
699 return true; | 702 return true; |
700 } | 703 } |
701 break; | 704 break; |
702 } | 705 } |
703 case PROPERTY_INDEX_CELLULAR_APN: { | 706 case PROPERTY_INDEX_CELLULAR_APN: { |
704 if (value->IsType(Value::TYPE_DICTIONARY)) { | 707 if (value.IsType(Value::TYPE_DICTIONARY)) { |
705 cellular_network->set_apn(static_cast<const DictionaryValue&>(*value)); | 708 cellular_network->set_apn(static_cast<const DictionaryValue&>(value)); |
706 return true; | 709 return true; |
707 } | 710 } |
708 break; | 711 break; |
709 } | 712 } |
710 case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: { | 713 case PROPERTY_INDEX_CELLULAR_LAST_GOOD_APN: { |
711 if (value->IsType(Value::TYPE_DICTIONARY)) { | 714 if (value.IsType(Value::TYPE_DICTIONARY)) { |
712 cellular_network->set_last_good_apn( | 715 cellular_network->set_last_good_apn( |
713 static_cast<const DictionaryValue&>(*value)); | 716 static_cast<const DictionaryValue&>(value)); |
714 return true; | 717 return true; |
715 } | 718 } |
716 break; | 719 break; |
717 } | 720 } |
718 case PROPERTY_INDEX_NETWORK_TECHNOLOGY: { | 721 case PROPERTY_INDEX_NETWORK_TECHNOLOGY: { |
719 std::string network_technology_string; | 722 std::string network_technology_string; |
720 if (value->GetAsString(&network_technology_string)) { | 723 if (value.GetAsString(&network_technology_string)) { |
721 cellular_network->set_network_technology( | 724 cellular_network->set_network_technology( |
722 ParseNetworkTechnology(network_technology_string)); | 725 ParseNetworkTechnology(network_technology_string)); |
723 return true; | 726 return true; |
724 } | 727 } |
725 break; | 728 break; |
726 } | 729 } |
727 case PROPERTY_INDEX_ROAMING_STATE: { | 730 case PROPERTY_INDEX_ROAMING_STATE: { |
728 std::string roaming_state_string; | 731 std::string roaming_state_string; |
729 if (value->GetAsString(&roaming_state_string)) { | 732 if (value.GetAsString(&roaming_state_string)) { |
730 cellular_network->set_roaming_state( | 733 cellular_network->set_roaming_state( |
731 ParseRoamingState(roaming_state_string)); | 734 ParseRoamingState(roaming_state_string)); |
732 return true; | 735 return true; |
733 } | 736 } |
734 break; | 737 break; |
735 } | 738 } |
736 case PROPERTY_INDEX_OPERATOR_NAME: { | 739 case PROPERTY_INDEX_OPERATOR_NAME: { |
737 std::string value_str; | 740 std::string value_str; |
738 if (!value->GetAsString(&value_str)) | 741 if (!value.GetAsString(&value_str)) |
739 break; | 742 break; |
740 cellular_network->set_operator_name(value_str); | 743 cellular_network->set_operator_name(value_str); |
741 return true; | 744 return true; |
742 } | 745 } |
743 case PROPERTY_INDEX_OPERATOR_CODE: { | 746 case PROPERTY_INDEX_OPERATOR_CODE: { |
744 std::string value_str; | 747 std::string value_str; |
745 if (!value->GetAsString(&value_str)) | 748 if (!value.GetAsString(&value_str)) |
746 break; | 749 break; |
747 cellular_network->set_operator_code(value_str); | 750 cellular_network->set_operator_code(value_str); |
748 return true; | 751 return true; |
749 } | 752 } |
750 case PROPERTY_INDEX_SERVING_OPERATOR: { | 753 case PROPERTY_INDEX_SERVING_OPERATOR: { |
751 if (value->IsType(Value::TYPE_DICTIONARY)) { | 754 if (value.IsType(Value::TYPE_DICTIONARY)) { |
752 const DictionaryValue& dict = | 755 const DictionaryValue& dict = |
753 static_cast<const DictionaryValue&>(*value); | 756 static_cast<const DictionaryValue&>(value); |
754 std::string value_str; | 757 std::string value_str; |
755 dict.GetStringWithoutPathExpansion(kOperatorNameKey, &value_str); | 758 dict.GetStringWithoutPathExpansion(kOperatorNameKey, &value_str); |
756 cellular_network->set_operator_name(value_str); | 759 cellular_network->set_operator_name(value_str); |
757 value_str.clear(); | 760 value_str.clear(); |
758 dict.GetStringWithoutPathExpansion(kOperatorCodeKey, &value_str); | 761 dict.GetStringWithoutPathExpansion(kOperatorCodeKey, &value_str); |
759 cellular_network->set_operator_code(value_str); | 762 cellular_network->set_operator_code(value_str); |
760 value_str.clear(); | 763 value_str.clear(); |
761 dict.GetStringWithoutPathExpansion(kOperatorCountryKey, &value_str); | 764 dict.GetStringWithoutPathExpansion(kOperatorCountryKey, &value_str); |
762 cellular_network->set_operator_country(value_str); | 765 cellular_network->set_operator_country(value_str); |
763 return true; | 766 return true; |
764 } | 767 } |
765 break; | 768 break; |
766 } | 769 } |
767 case PROPERTY_INDEX_PAYMENT_URL: { | 770 case PROPERTY_INDEX_PAYMENT_URL: { |
768 std::string value_str; | 771 std::string value_str; |
769 if (!value->GetAsString(&value_str)) | 772 if (!value.GetAsString(&value_str)) |
770 break; | 773 break; |
771 cellular_network->set_payment_url(value_str); | 774 cellular_network->set_payment_url(value_str); |
772 return true; | 775 return true; |
773 } | 776 } |
774 case PROPERTY_INDEX_USAGE_URL: { | 777 case PROPERTY_INDEX_USAGE_URL: { |
775 std::string value_str; | 778 std::string value_str; |
776 if (!value->GetAsString(&value_str)) | 779 if (!value.GetAsString(&value_str)) |
777 break; | 780 break; |
778 cellular_network->set_usage_url(value_str); | 781 cellular_network->set_usage_url(value_str); |
779 return true; | 782 return true; |
780 } | 783 } |
781 case PROPERTY_INDEX_STATE: { | 784 case PROPERTY_INDEX_STATE: { |
782 // Save previous state before calling WirelessNetwork::ParseValue. | 785 // Save previous state before calling WirelessNetwork::ParseValue. |
783 ConnectionState prev_state = cellular_network->state(); | 786 ConnectionState prev_state = cellular_network->state(); |
784 if (NativeWirelessNetworkParser::ParseValue(index, value, network)) { | 787 if (NativeWirelessNetworkParser::ParseValue(index, value, network)) { |
785 if (cellular_network->state() != prev_state) | 788 if (cellular_network->state() != prev_state) |
786 cellular_network->RefreshDataPlansIfNeeded(); | 789 cellular_network->RefreshDataPlansIfNeeded(); |
(...skipping 51 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
838 table, arraysize(table), ROAMING_STATE_UNKNOWN); | 841 table, arraysize(table), ROAMING_STATE_UNKNOWN); |
839 return parser.Get(roaming_state); | 842 return parser.Get(roaming_state); |
840 } | 843 } |
841 | 844 |
842 // -------------------- NativeWifiNetworkParser -------------------- | 845 // -------------------- NativeWifiNetworkParser -------------------- |
843 | 846 |
844 NativeWifiNetworkParser::NativeWifiNetworkParser() {} | 847 NativeWifiNetworkParser::NativeWifiNetworkParser() {} |
845 NativeWifiNetworkParser::~NativeWifiNetworkParser() {} | 848 NativeWifiNetworkParser::~NativeWifiNetworkParser() {} |
846 | 849 |
847 bool NativeWifiNetworkParser::ParseValue(PropertyIndex index, | 850 bool NativeWifiNetworkParser::ParseValue(PropertyIndex index, |
848 Value* value, | 851 const Value& value, |
849 Network* network) { | 852 Network* network) { |
850 DCHECK_EQ(TYPE_WIFI, network->type()); | 853 DCHECK_EQ(TYPE_WIFI, network->type()); |
851 WifiNetwork* wifi_network = static_cast<WifiNetwork*>(network); | 854 WifiNetwork* wifi_network = static_cast<WifiNetwork*>(network); |
852 switch (index) { | 855 switch (index) { |
853 case PROPERTY_INDEX_WIFI_HEX_SSID: { | 856 case PROPERTY_INDEX_WIFI_HEX_SSID: { |
854 std::string ssid_hex; | 857 std::string ssid_hex; |
855 if (!value->GetAsString(&ssid_hex)) | 858 if (!value.GetAsString(&ssid_hex)) |
856 return false; | 859 return false; |
857 | 860 |
858 wifi_network->SetHexSsid(ssid_hex); | 861 wifi_network->SetHexSsid(ssid_hex); |
859 return true; | 862 return true; |
860 } | 863 } |
861 case PROPERTY_INDEX_WIFI_AUTH_MODE: | 864 case PROPERTY_INDEX_WIFI_AUTH_MODE: |
862 case PROPERTY_INDEX_WIFI_PHY_MODE: | 865 case PROPERTY_INDEX_WIFI_PHY_MODE: |
863 case PROPERTY_INDEX_WIFI_HIDDEN_SSID: | 866 case PROPERTY_INDEX_WIFI_HIDDEN_SSID: |
864 case PROPERTY_INDEX_WIFI_FREQUENCY: | 867 case PROPERTY_INDEX_WIFI_FREQUENCY: |
865 // These properties are currently not used in the UI. | 868 // These properties are currently not used in the UI. |
866 return true; | 869 return true; |
867 case PROPERTY_INDEX_NAME: { | 870 case PROPERTY_INDEX_NAME: { |
868 // Does not change network name when it was already set by WiFi.HexSSID. | 871 // Does not change network name when it was already set by WiFi.HexSSID. |
869 if (!wifi_network->name().empty()) | 872 if (!wifi_network->name().empty()) |
870 return true; | 873 return true; |
871 else | 874 else |
872 return NativeWirelessNetworkParser::ParseValue(index, value, network); | 875 return NativeWirelessNetworkParser::ParseValue(index, value, network); |
873 } | 876 } |
874 case PROPERTY_INDEX_GUID: { | 877 case PROPERTY_INDEX_GUID: { |
875 std::string unique_id; | 878 std::string unique_id; |
876 if (!value->GetAsString(&unique_id)) | 879 if (!value.GetAsString(&unique_id)) |
877 break; | 880 break; |
878 wifi_network->set_unique_id(unique_id); | 881 wifi_network->set_unique_id(unique_id); |
879 return true; | 882 return true; |
880 } | 883 } |
881 case PROPERTY_INDEX_SECURITY: { | 884 case PROPERTY_INDEX_SECURITY: { |
882 std::string security_string; | 885 std::string security_string; |
883 if (!value->GetAsString(&security_string)) | 886 if (!value.GetAsString(&security_string)) |
884 break; | 887 break; |
885 wifi_network->set_encryption(ParseSecurity(security_string)); | 888 wifi_network->set_encryption(ParseSecurity(security_string)); |
886 return true; | 889 return true; |
887 } | 890 } |
888 case PROPERTY_INDEX_PASSPHRASE: { | 891 case PROPERTY_INDEX_PASSPHRASE: { |
889 std::string passphrase; | 892 std::string passphrase; |
890 if (!value->GetAsString(&passphrase)) | 893 if (!value.GetAsString(&passphrase)) |
891 break; | 894 break; |
892 // Only store the passphrase if we are the owner. | 895 // Only store the passphrase if we are the owner. |
893 // TODO(stevenjb): Remove this when chromium-os:12948 is resolved. | 896 // TODO(stevenjb): Remove this when chromium-os:12948 is resolved. |
894 if (chromeos::UserManager::Get()->current_user_is_owner()) | 897 if (chromeos::UserManager::Get()->current_user_is_owner()) |
895 wifi_network->set_passphrase(passphrase); | 898 wifi_network->set_passphrase(passphrase); |
896 return true; | 899 return true; |
897 } | 900 } |
898 case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { | 901 case PROPERTY_INDEX_PASSPHRASE_REQUIRED: { |
899 bool passphrase_required; | 902 bool passphrase_required; |
900 value->GetAsBoolean(&passphrase_required); | 903 value.GetAsBoolean(&passphrase_required); |
901 if (!value->GetAsBoolean(&passphrase_required)) | 904 if (!value.GetAsBoolean(&passphrase_required)) |
902 break; | 905 break; |
903 wifi_network->set_passphrase_required(passphrase_required); | 906 wifi_network->set_passphrase_required(passphrase_required); |
904 return true; | 907 return true; |
905 } | 908 } |
906 case PROPERTY_INDEX_IDENTITY: { | 909 case PROPERTY_INDEX_IDENTITY: { |
907 std::string identity; | 910 std::string identity; |
908 if (!value->GetAsString(&identity)) | 911 if (!value.GetAsString(&identity)) |
909 break; | 912 break; |
910 wifi_network->set_identity(identity); | 913 wifi_network->set_identity(identity); |
911 return true; | 914 return true; |
912 } | 915 } |
913 case PROPERTY_INDEX_EAP_IDENTITY: { | 916 case PROPERTY_INDEX_EAP_IDENTITY: { |
914 std::string eap_identity; | 917 std::string eap_identity; |
915 if (!value->GetAsString(&eap_identity)) | 918 if (!value.GetAsString(&eap_identity)) |
916 break; | 919 break; |
917 wifi_network->set_eap_identity(eap_identity); | 920 wifi_network->set_eap_identity(eap_identity); |
918 return true; | 921 return true; |
919 } | 922 } |
920 case PROPERTY_INDEX_EAP_METHOD: { | 923 case PROPERTY_INDEX_EAP_METHOD: { |
921 std::string eap_method; | 924 std::string eap_method; |
922 if (!value->GetAsString(&eap_method)) | 925 if (!value.GetAsString(&eap_method)) |
923 break; | 926 break; |
924 wifi_network->set_eap_method(ParseEAPMethod(eap_method)); | 927 wifi_network->set_eap_method(ParseEAPMethod(eap_method)); |
925 return true; | 928 return true; |
926 } | 929 } |
927 case PROPERTY_INDEX_EAP_PHASE_2_AUTH: { | 930 case PROPERTY_INDEX_EAP_PHASE_2_AUTH: { |
928 std::string eap_phase_2_auth; | 931 std::string eap_phase_2_auth; |
929 if (!value->GetAsString(&eap_phase_2_auth)) | 932 if (!value.GetAsString(&eap_phase_2_auth)) |
930 break; | 933 break; |
931 wifi_network->set_eap_phase_2_auth(ParseEAPPhase2Auth(eap_phase_2_auth)); | 934 wifi_network->set_eap_phase_2_auth(ParseEAPPhase2Auth(eap_phase_2_auth)); |
932 return true; | 935 return true; |
933 } | 936 } |
934 case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY: { | 937 case PROPERTY_INDEX_EAP_ANONYMOUS_IDENTITY: { |
935 std::string eap_anonymous_identity; | 938 std::string eap_anonymous_identity; |
936 if (!value->GetAsString(&eap_anonymous_identity)) | 939 if (!value.GetAsString(&eap_anonymous_identity)) |
937 break; | 940 break; |
938 wifi_network->set_eap_anonymous_identity(eap_anonymous_identity); | 941 wifi_network->set_eap_anonymous_identity(eap_anonymous_identity); |
939 return true; | 942 return true; |
940 } | 943 } |
941 case PROPERTY_INDEX_EAP_CERT_ID: { | 944 case PROPERTY_INDEX_EAP_CERT_ID: { |
942 std::string eap_client_cert_pkcs11_id; | 945 std::string eap_client_cert_pkcs11_id; |
943 if (!value->GetAsString(&eap_client_cert_pkcs11_id)) | 946 if (!value.GetAsString(&eap_client_cert_pkcs11_id)) |
944 break; | 947 break; |
945 wifi_network->set_eap_client_cert_pkcs11_id(eap_client_cert_pkcs11_id); | 948 wifi_network->set_eap_client_cert_pkcs11_id(eap_client_cert_pkcs11_id); |
946 return true; | 949 return true; |
947 } | 950 } |
948 case PROPERTY_INDEX_EAP_CA_CERT_NSS: { | 951 case PROPERTY_INDEX_EAP_CA_CERT_NSS: { |
949 std::string eap_server_ca_cert_nss_nickname; | 952 std::string eap_server_ca_cert_nss_nickname; |
950 if (!value->GetAsString(&eap_server_ca_cert_nss_nickname)) | 953 if (!value.GetAsString(&eap_server_ca_cert_nss_nickname)) |
951 break; | 954 break; |
952 wifi_network->set_eap_server_ca_cert_nss_nickname( | 955 wifi_network->set_eap_server_ca_cert_nss_nickname( |
953 eap_server_ca_cert_nss_nickname); | 956 eap_server_ca_cert_nss_nickname); |
954 return true; | 957 return true; |
955 } | 958 } |
956 case PROPERTY_INDEX_EAP_USE_SYSTEM_CAS: { | 959 case PROPERTY_INDEX_EAP_USE_SYSTEM_CAS: { |
957 bool eap_use_system_cas; | 960 bool eap_use_system_cas; |
958 if (!value->GetAsBoolean(&eap_use_system_cas)) | 961 if (!value.GetAsBoolean(&eap_use_system_cas)) |
959 break; | 962 break; |
960 wifi_network->set_eap_use_system_cas(eap_use_system_cas); | 963 wifi_network->set_eap_use_system_cas(eap_use_system_cas); |
961 return true; | 964 return true; |
962 } | 965 } |
963 case PROPERTY_INDEX_EAP_PASSWORD: { | 966 case PROPERTY_INDEX_EAP_PASSWORD: { |
964 std::string eap_passphrase; | 967 std::string eap_passphrase; |
965 if (!value->GetAsString(&eap_passphrase)) | 968 if (!value.GetAsString(&eap_passphrase)) |
966 break; | 969 break; |
967 wifi_network->set_eap_passphrase(eap_passphrase); | 970 wifi_network->set_eap_passphrase(eap_passphrase); |
968 return true; | 971 return true; |
969 } | 972 } |
970 case PROPERTY_INDEX_EAP_CLIENT_CERT: | 973 case PROPERTY_INDEX_EAP_CLIENT_CERT: |
971 case PROPERTY_INDEX_EAP_CLIENT_CERT_NSS: | 974 case PROPERTY_INDEX_EAP_CLIENT_CERT_NSS: |
972 case PROPERTY_INDEX_EAP_PRIVATE_KEY: | 975 case PROPERTY_INDEX_EAP_PRIVATE_KEY: |
973 case PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD: | 976 case PROPERTY_INDEX_EAP_PRIVATE_KEY_PASSWORD: |
974 case PROPERTY_INDEX_EAP_KEY_ID: | 977 case PROPERTY_INDEX_EAP_KEY_ID: |
975 case PROPERTY_INDEX_EAP_CA_CERT: | 978 case PROPERTY_INDEX_EAP_CA_CERT: |
(...skipping 69 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1045 << " Type: " | 1048 << " Type: " |
1046 << ProviderTypeToString(virtual_network->provider_type()); | 1049 << ProviderTypeToString(virtual_network->provider_type()); |
1047 if (virtual_network->provider_type() == PROVIDER_TYPE_L2TP_IPSEC_PSK) { | 1050 if (virtual_network->provider_type() == PROVIDER_TYPE_L2TP_IPSEC_PSK) { |
1048 if (!virtual_network->client_cert_id().empty()) | 1051 if (!virtual_network->client_cert_id().empty()) |
1049 virtual_network->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT); | 1052 virtual_network->set_provider_type(PROVIDER_TYPE_L2TP_IPSEC_USER_CERT); |
1050 } | 1053 } |
1051 return true; | 1054 return true; |
1052 } | 1055 } |
1053 | 1056 |
1054 bool NativeVirtualNetworkParser::ParseValue(PropertyIndex index, | 1057 bool NativeVirtualNetworkParser::ParseValue(PropertyIndex index, |
1055 Value* value, | 1058 const Value& value, |
1056 Network* network) { | 1059 Network* network) { |
1057 DCHECK_EQ(TYPE_VPN, network->type()); | 1060 DCHECK_EQ(TYPE_VPN, network->type()); |
1058 VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network); | 1061 VirtualNetwork* virtual_network = static_cast<VirtualNetwork*>(network); |
1059 switch (index) { | 1062 switch (index) { |
1060 case PROPERTY_INDEX_PROVIDER: { | 1063 case PROPERTY_INDEX_PROVIDER: { |
1061 DCHECK_EQ(value->GetType(), Value::TYPE_DICTIONARY); | 1064 DCHECK_EQ(value.GetType(), Value::TYPE_DICTIONARY); |
1062 const DictionaryValue& dict = static_cast<const DictionaryValue&>(*value); | 1065 const DictionaryValue& dict = static_cast<const DictionaryValue&>(value); |
1063 for (DictionaryValue::key_iterator iter = dict.begin_keys(); | 1066 for (DictionaryValue::key_iterator iter = dict.begin_keys(); |
1064 iter != dict.end_keys(); ++iter) { | 1067 iter != dict.end_keys(); ++iter) { |
1065 const std::string& key = *iter; | 1068 const std::string& key = *iter; |
1066 Value* provider_value; | 1069 Value* provider_value; |
1067 bool res = dict.GetWithoutPathExpansion(key, &provider_value); | 1070 bool res = dict.GetWithoutPathExpansion(key, &provider_value); |
1068 DCHECK(res); | 1071 DCHECK(res); |
1069 if (res) { | 1072 if (res) { |
1070 PropertyIndex index = mapper().Get(key); | 1073 PropertyIndex index = mapper().Get(key); |
1071 if (!ParseProviderValue(index, *provider_value, virtual_network)) | 1074 if (!ParseProviderValue(index, *provider_value, virtual_network)) |
1072 VLOG(1) << network->name() << ": Provider unhandled key: " << key | 1075 VLOG(1) << network->name() << ": Provider unhandled key: " << key |
(...skipping 80 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
1153 static EnumMapper<ProviderType>::Pair table[] = { | 1156 static EnumMapper<ProviderType>::Pair table[] = { |
1154 { kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK }, | 1157 { kProviderL2tpIpsec, PROVIDER_TYPE_L2TP_IPSEC_PSK }, |
1155 { kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN }, | 1158 { kProviderOpenVpn, PROVIDER_TYPE_OPEN_VPN }, |
1156 }; | 1159 }; |
1157 static EnumMapper<ProviderType> parser( | 1160 static EnumMapper<ProviderType> parser( |
1158 table, arraysize(table), PROVIDER_TYPE_MAX); | 1161 table, arraysize(table), PROVIDER_TYPE_MAX); |
1159 return parser.Get(type); | 1162 return parser.Get(type); |
1160 } | 1163 } |
1161 | 1164 |
1162 } // namespace chromeos | 1165 } // namespace chromeos |
OLD | NEW |