MD Settings: Internet: Enable SIM unlock with no cellular network

extensions/browser/api/networking_private/networking_private_chromeos.cc

 // Copyright 2014 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 "extensions/browser/api/networking_private/networking_private_chromeos.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/logging.h"
@@ skipping 18 matching lines @@
 #include "content/public/browser/browser_context.h"
 #include "extensions/browser/api/networking_private/networking_private_api.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extensions_browser_client.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/extension_set.h"
 #include "extensions/common/permissions/api_permission.h"
 #include "extensions/common/permissions/permissions_data.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 
-using chromeos::DeviceState;
 using chromeos::NetworkHandler;
 using chromeos::NetworkStateHandler;
 using chromeos::NetworkTypePattern;
 using chromeos::ShillManagerClient;
 using extensions::NetworkingPrivateDelegate;
 
 namespace private_api = extensions::api::networking_private;
 
 namespace {
 
@@ skipping 36 matching lines @@
       *error = "Error.NonPrimaryUser";
     return false;
   }
   if (user_hash)
     *user_hash = context_user_hash;
   return true;
 }
 
 void AppendDeviceState(
     const std::string& type,
-    const DeviceState* device,
+    const chromeos::DeviceState* device,
     NetworkingPrivateDelegate::DeviceStateList* device_state_list) {
   DCHECK(!type.empty());
   NetworkTypePattern pattern =
       chromeos::onc::NetworkTypePatternFromOncType(type);
   NetworkStateHandler::TechnologyState technology_state =
       GetStateHandler()->GetTechnologyState(pattern);
   private_api::DeviceStateType state = private_api::DEVICE_STATE_TYPE_NONE;
   switch (technology_state) {
     case NetworkStateHandler::TECHNOLOGY_UNAVAILABLE:
       if (!device)
@@ skipping 85 matching lines @@
     return nullptr;
   if (GetStringFromDictionary(*vpn_dict, ::onc::vpn::kType) !=
       ::onc::vpn::kThirdPartyVpn) {
     return nullptr;
   }
   base::DictionaryValue* third_party_vpn = nullptr;
   vpn_dict->GetDictionary(::onc::vpn::kThirdPartyVpn, &third_party_vpn);
   return third_party_vpn;
 }
 
+const chromeos::DeviceState* GetCellularDeviceState(const std::string& guid) {
+  const chromeos::NetworkState* network_state = nullptr;
+  if (!guid.empty())
+    network_state = GetStateHandler()->GetNetworkStateFromGuid(guid);
+  const chromeos::DeviceState* device_state = nullptr;
+  if (network_state) {
+    device_state =
+        GetStateHandler()->GetDeviceState(network_state->device_path());
+  }
+  if (!device_state) {
+    device_state =
+        GetStateHandler()->GetDeviceStateByType(NetworkTypePattern::Cellular());
+  }
+  return device_state;
+}
+
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 namespace extensions {
 
 NetworkingPrivateChromeOS::NetworkingPrivateChromeOS(
     content::BrowserContext* browser_context,
     std::unique_ptr<VerifyDelegate> verify_delegate)
     : NetworkingPrivateDelegate(std::move(verify_delegate)),
@@ skipping 265 matching lines @@
               ->GetCaptivePortalState(guid)
               .status));
 }
 
 void NetworkingPrivateChromeOS::UnlockCellularSim(
     const std::string& guid,
     const std::string& pin,
     const std::string& puk,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
-  const chromeos::NetworkState* network_state =
-      GetStateHandler()->GetNetworkStateFromGuid(guid);
-  if (!network_state) {
-    failure_callback.Run(networking_private::kErrorNetworkUnavailable);
-    return;
-  }
-  const chromeos::DeviceState* device_state =
-      GetStateHandler()->GetDeviceState(network_state->device_path());
+  const chromeos::DeviceState* device_state = GetCellularDeviceState(guid);
   if (!device_state) {
     failure_callback.Run(networking_private::kErrorNetworkUnavailable);
     return;
   }
   std::string lock_type = device_state->sim_lock_type();
   if (lock_type.empty()) {
     // Sim is already unlocked.
     failure_callback.Run(networking_private::kErrorInvalidNetworkOperation);
     return;
   }
@@ skipping 10 matching lines @@
   }
 }
 
 void NetworkingPrivateChromeOS::SetCellularSimState(
     const std::string& guid,
     bool require_pin,
     const std::string& current_pin,
     const std::string& new_pin,
     const VoidCallback& success_callback,
     const FailureCallback& failure_callback) {
-  const chromeos::NetworkState* network_state =
-      GetStateHandler()->GetNetworkStateFromGuid(guid);
-  if (!network_state) {
-    failure_callback.Run(networking_private::kErrorNetworkUnavailable);
-    return;
-  }
-  const chromeos::DeviceState* device_state =
-      GetStateHandler()->GetDeviceState(network_state->device_path());
+  const chromeos::DeviceState* device_state = GetCellularDeviceState(guid);
   if (!device_state) {
     failure_callback.Run(networking_private::kErrorNetworkUnavailable);
     return;
   }
   if (!device_state->sim_lock_type().empty()) {
     // The SIM needs to be unlocked before the state can be changed.
     failure_callback.Run(networking_private::kErrorSimLocked);
     return;
   }
 
@@ skipping 24 matching lines @@
   return network_list;
 }
 
 std::unique_ptr<NetworkingPrivateDelegate::DeviceStateList>
 NetworkingPrivateChromeOS::GetDeviceStateList() {
   std::set<std::string> technologies_found;
   NetworkStateHandler::DeviceStateList devices;
   NetworkHandler::Get()->network_state_handler()->GetDeviceList(&devices);
 
   std::unique_ptr<DeviceStateList> device_state_list(new DeviceStateList);
-  for (const DeviceState* device : devices) {
+  for (const chromeos::DeviceState* device : devices) {
     std::string onc_type =
         chromeos::network_util::TranslateShillTypeToONC(device->type());
     AppendDeviceState(onc_type, device, device_state_list.get());
     technologies_found.insert(onc_type);
   }
 
   // For any technologies that we do not have a DeviceState entry for, append
   // an entry if the technolog is available.
   const char* technology_types[] = {::onc::network_type::kEthernet,
                                     ::onc::network_type::kWiFi,
@@ skipping 77 matching lines @@
   // Eventually the caller (e.g. Settings) should handle any failures and
   // show its own configuration UI. crbug.com/380937.
   if (ui_delegate()->HandleConnectFailed(guid, error_name)) {
     success_callback.Run();
     return;
   }
   failure_callback.Run(error_name);
 }
 
 }  // namespace extensions