Eliminate use of sim unlock UI notifications

chromeos/dbus/fake_shill_manager_client.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chromeos/dbus/fake_shill_manager_client.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 87 matching lines @@
 void UpdatePortaledWifiState(const std::string& service_path) {
   DBusThreadManager::Get()->GetShillServiceClient()->GetTestInterface()
       ->SetServiceProperty(service_path,
                            shill::kStateProperty,
                            base::StringValue(shill::kStatePortal));
 }
 
 const char* kTechnologyUnavailable = "unavailable";
 const char* kNetworkActivated = "activated";
 const char* kNetworkDisabled = "disabled";
+const char* kCellularServicePath = "/service/cellular1";
 
 }  // namespace
 
 // static
 const char FakeShillManagerClient::kFakeEthernetNetworkGuid[] = "eth1_guid";
 
 FakeShillManagerClient::FakeShillManagerClient()
     : interactive_delay_(0),
       weak_ptr_factory_(this) {
   ParseCommandLineSwitch();
@@ skipping 457 matching lines @@
   DCHECK(devices);
   ShillIPConfigClient::TestInterface* ip_configs =
       dbus_manager->GetShillIPConfigClient()->GetTestInterface();
   DCHECK(ip_configs);
 
   const std::string shared_profile = ShillProfileClient::GetSharedProfilePath();
   profiles->AddProfile(shared_profile, std::string());
 
   const bool add_to_visible = true;
 
-  bool enabled;
-  std::string state;
-
   // IPConfigs
   base::DictionaryValue ipconfig_v4_dictionary;
   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
       shill::kAddressProperty, "0.0.0.0");
   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
       shill::kGatewayProperty, "0.0.0.1");
   ipconfig_v4_dictionary.SetIntegerWithoutPathExpansion(
       shill::kPrefixlenProperty, 0);
   ipconfig_v4_dictionary.SetStringWithoutPathExpansion(
       shill::kMethodProperty, shill::kTypeIPv4);
   ip_configs->AddIPConfig("ipconfig_v4_path", ipconfig_v4_dictionary);
   base::DictionaryValue ipconfig_v6_dictionary;
   ipconfig_v6_dictionary.SetStringWithoutPathExpansion(
       shill::kAddressProperty, "0:0:0:0:0:0:0:0");
   ipconfig_v6_dictionary.SetStringWithoutPathExpansion(
       shill::kMethodProperty, shill::kTypeIPv6);
   ip_configs->AddIPConfig("ipconfig_v6_path", ipconfig_v6_dictionary);
 
+  bool enabled;
+  std::string state;
+
   // Ethernet
   state = GetInitialStateForType(shill::kTypeEthernet, &enabled);
   if (state == shill::kStateOnline) {
     AddTechnology(shill::kTypeEthernet, enabled);
     devices->AddDevice(
         "/device/eth1", shill::kTypeEthernet, "stub_eth_device1");
     devices->SetDeviceProperty("/device/eth1",
                                shill::kAddressProperty,
                                base::StringValue("0123456789ab"));
     base::ListValue eth_ip_configs;
@@ skipping 110 matching lines @@
       activated = true;
       state = shill::kStateIdle;
     }
     AddTechnology(shill::kTypeCellular, enabled);
     devices->AddDevice(
         "/device/cellular1", shill::kTypeCellular, "stub_cellular_device1");
     devices->SetDeviceProperty("/device/cellular1",
                                shill::kCarrierProperty,
                                base::StringValue(shill::kCarrierSprint));
 
-    services->AddService("/service/cellular1",
+    services->AddService(kCellularServicePath,
                          "cellular1_guid",
                          "cellular1" /* name */,
                          shill::kTypeCellular,
                          state,
                          add_to_visible);
     base::StringValue technology_value(shill::kNetworkTechnologyGsm);
-    services->SetServiceProperty("/service/cellular1",
+    services->SetServiceProperty(kCellularServicePath,
                                  shill::kNetworkTechnologyProperty,
                                  technology_value);
 
     if (activated) {
       services->SetServiceProperty(
-          "/service/cellular1",
+          kCellularServicePath,
           shill::kActivationStateProperty,
           base::StringValue(shill::kActivationStateActivated));
-      services->SetServiceProperty("/service/cellular1",
+      services->SetServiceProperty(kCellularServicePath,
                                    shill::kConnectableProperty,
                                    base::FundamentalValue(true));
     } else {
       services->SetServiceProperty(
-          "/service/cellular1",
+          kCellularServicePath,
           shill::kActivationStateProperty,
           base::StringValue(shill::kActivationStateNotActivated));
     }
 
-    services->SetServiceProperty("/service/cellular1",
+    services->SetServiceProperty(kCellularServicePath,
                                  shill::kRoamingStateProperty,
                                  base::StringValue(shill::kRoamingStateHome));
   }
 
   // VPN
   state = GetInitialStateForType(shill::kTypeVPN, &enabled);
   if (state != kTechnologyUnavailable) {
     // Set the "Provider" dictionary properties. Note: when setting these in
     // Shill, "Provider.Type", etc keys are used, but when reading the values
     // "Provider" . "Type", etc keys are used. Here we are setting the values
@@ skipping 16 matching lines @@
     services->AddService("/service/vpn2",
                          "vpn2_guid",
                          "vpn2" /* name */,
                          shill::kTypeVPN,
                          shill::kStateIdle,
                          add_to_visible);
     services->SetServiceProperty(
         "/service/vpn2", shill::kProviderProperty, provider_properties);
   }
 
+  // Additional device states
+  for (DevicePropertyMap::iterator iter1 = shill_device_property_map_.begin();
+       iter1 != shill_device_property_map_.end(); ++iter1) {
+    std::string device_type = iter1->first;
+    std::string device_path = devices->GetDevicePathForType(device_type);
+    for (ShillPropertyMap::iterator iter2 = iter1->second.begin();
+         iter2 != iter1->second.end(); ++iter2) {
+      devices->SetDeviceProperty(device_path, iter2->first, *(iter2->second));
+      delete iter2->second;
+    }
+  }
+
   SortManagerServices(true);
 }
 
 // Private methods
 
 void FakeShillManagerClient::PassStubProperties(
     const DictionaryValueCallback& callback) const {
   scoped_ptr<base::DictionaryValue> stub_properties(
       stub_properties_.DeepCopy());
   stub_properties->SetWithoutPathExpansion(
@@ skipping 116 matching lines @@
         SetDeviceProperty(device_path,
                           shill::kScanningProperty,
                           base::FundamentalValue(false));
   }
   DVLOG(2) << "ScanCompleted";
   CallNotifyObserversPropertyChanged(shill::kServiceCompleteListProperty);
   base::MessageLoop::current()->PostTask(FROM_HERE, callback);
 }
 
 void FakeShillManagerClient::ParseCommandLineSwitch() {
-  CommandLine* command_line = CommandLine::ForCurrentProcess();
-  if (command_line->HasSwitch(switches::kShillStub)) {
-    std::string option_str =
-        command_line->GetSwitchValueASCII(switches::kShillStub);
-    base::StringPairs string_pairs;
-    base::SplitStringIntoKeyValuePairs(option_str, '=', ',', &string_pairs);
-    for (base::StringPairs::iterator iter = string_pairs.begin();
-         iter != string_pairs.end(); ++iter) {
-      ParseOption((*iter).first, (*iter).second);
-    }
-    return;
-  }
   // Default setup
   SetInitialNetworkState(shill::kTypeEthernet, shill::kStateOnline);
   SetInitialNetworkState(shill::kTypeWifi, shill::kStateOnline);
   SetInitialNetworkState(shill::kTypeCellular, shill::kStateIdle);
   SetInitialNetworkState(shill::kTypeVPN, shill::kStateIdle);
+
+  // Parse additional options
+  CommandLine* command_line = CommandLine::ForCurrentProcess();
+  if (!command_line->HasSwitch(switches::kShillStub))
+    return;
+
+  std::string option_str =
+      command_line->GetSwitchValueASCII(switches::kShillStub);
+  VLOG(1) << "Parsing command line:" << option_str;
+  base::StringPairs string_pairs;
+  base::SplitStringIntoKeyValuePairs(option_str, '=', ',', &string_pairs);
+  for (base::StringPairs::iterator iter = string_pairs.begin();
+       iter != string_pairs.end(); ++iter) {
+    ParseOption((*iter).first, (*iter).second);
+  }
 }
 
 bool FakeShillManagerClient::ParseOption(const std::string& arg0,
                                          const std::string& arg1) {
-  if (arg0 == "interactive") {
+  VLOG(1) << "Parsing command line option: '" << arg0 << "=" << arg1 << "'";
+  if ((arg0 == "clear" || arg0 == "reset") && arg1 == "1") {
+    shill_initial_state_map_.clear();
+    return true;
+  } else if (arg0 == "interactive") {
     int seconds = 3;
     if (!arg1.empty())
       base::StringToInt(arg1, &seconds);
     interactive_delay_ = seconds;
     return true;
+  } else if (arg0 == "sim_lock") {
+    bool locked = (arg1 == "1") ? true : false;
+    base::DictionaryValue* simlock_dict = new base::DictionaryValue;
+    simlock_dict->Set(shill::kSIMLockEnabledProperty,
+                      new base::FundamentalValue(locked));
+  // TODO(stevenjb): Investigate why non-empty value breaks UI.
+  std::string lock_type = "";  // shill::kSIMLockPin
+    simlock_dict->SetString(shill::kSIMLockTypeProperty, lock_type);
+    simlock_dict->SetInteger(shill::kSIMLockRetriesLeftProperty, 5);
+
+    shill_device_property_map_
+        [shill::kTypeCellular][shill::kSIMLockStatusProperty] = simlock_dict;
+    shill_device_property_map_
+        [shill::kTypeCellular][shill::kTechnologyFamilyProperty] =
+            new base::StringValue(shill::kNetworkTechnologyGsm);
+    return true;
   }
   return SetInitialNetworkState(arg0, arg1);
 }
 
 bool FakeShillManagerClient::SetInitialNetworkState(std::string type_arg,
                                                     std::string state_arg) {
   std::string state;
   state_arg = StringToLowerASCII(state_arg);
   if (state_arg.empty() || state_arg == "1" || state_arg == "on" ||
       state_arg == "enabled" || state_arg == "connected" ||
@@ skipping 68 matching lines @@
   *enabled = true;
   if ((state == shill::kStatePortal && type != shill::kTypeWifi) ||
       (state == kNetworkActivated && type != shill::kTypeCellular)) {
     LOG(WARNING) << "Invalid state: " << state << " for " << type;
     return shill::kStateIdle;
   }
   return state;
 }
 
 }  // namespace chromeos