Eliminate use of sim unlock UI notifications

chrome/browser/ui/webui/options/chromeos/internet_options_handler.cc

 // Copyright (c) 2012 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 "chrome/browser/ui/webui/options/chromeos/internet_options_handler.h"
 
 #include <ctype.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "ash/system/chromeos/network/network_connect.h"
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/mobile_config.h"
 #include "chrome/browser/chromeos/net/onc_utils.h"
 #include "chrome/browser/chromeos/options/network_config_view.h"
 #include "chrome/browser/chromeos/options/network_property_ui_data.h"
 #include "chrome/browser/chromeos/settings/cros_settings.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/chromeos/ui/choose_mobile_network_dialog.h"
 #include "chrome/browser/chromeos/ui/mobile_config_ui.h"
 #include "chrome/browser/chromeos/ui_proxy_config_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/options/chromeos/internet_options_handler_strings.h"
 #include "chromeos/chromeos_switches.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/managed_network_configuration_handler.h"
 #include "chromeos/network/network_configuration_handler.h"
 #include "chromeos/network/network_connection_handler.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_ip_config.h"
 #include "chromeos/network/network_profile.h"
 #include "chromeos/network/network_profile_handler.h"
 #include "chromeos/network/network_state.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_util.h"
 #include "chromeos/network/onc/onc_signature.h"
 #include "chromeos/network/onc/onc_translator.h"
 #include "components/onc/onc_constants.h"
-#include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "grit/ash_resources.h"
 #include "grit/ui_chromeos_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/web_ui_util.h"
 #include "ui/chromeos/network/network_icon.h"
 #include "ui/gfx/image/image_skia.h"
@@ skipping 35 matching lines @@
 const char kRefreshNetworkDataFunction[] =
     "options.network.NetworkList.refreshNetworkData";
 const char kSetDefaultNetworkIconsFunction[] =
     "options.network.NetworkList.setDefaultNetworkIcons";
 const char kShowDetailedInfoFunction[] =
     "options.internet.DetailsInternetPage.showDetailedInfo";
 const char kUpdateConnectionDataFunction[] =
     "options.internet.DetailsInternetPage.updateConnectionData";
 const char kUpdateCarrierFunction[] =
     "options.internet.DetailsInternetPage.updateCarrier";
-const char kUpdateSecurityTabFunction[] =
-    "options.internet.DetailsInternetPage.updateSecurityTab";
 
 // These are used to register message handlers with JavaScript.
 const char kBuyDataPlanMessage[] = "buyDataPlan";
 const char kChangePinMessage[] = "changePin";
 const char kDisableCellularMessage[] = "disableCellular";
 const char kDisableWifiMessage[] = "disableWifi";
 const char kDisableWimaxMessage[] = "disableWimax";
 const char kEnableCellularMessage[] = "enableCellular";
 const char kEnableWifiMessage[] = "enableWifi";
 const char kEnableWimaxMessage[] = "enableWimax";
@@ skipping 388 matching lines @@
   const DeviceState* device =
       NetworkHandler::Get()->network_state_handler()->GetDeviceState(
           cellular->device_path());
   if (device) {
     const base::DictionaryValue& device_properties = device->properties();
     ::onc::ONCSource onc_source;
     NetworkHandler::Get()->managed_network_configuration_handler()->
         FindPolicyByGUID(LoginState::Get()->primary_user_hash(),
                          cellular->guid(), &onc_source);
     const NetworkPropertyUIData cellular_property_ui_data(onc_source);
+    LOG(ERROR) << "SIM_LOCK_ENABLED: " << device->sim_lock_enabled();

[stevenjb, 2014/07/18 00:29:40]

Oops. Removed locally, will update with any other review feedback.

     SetValueDictionary(dictionary,
                        kTagSimCardLockEnabled,
                        new base::FundamentalValue(device->sim_lock_enabled()),
                        cellular_property_ui_data);
 
     carrier_id = device->home_provider_id();
     device_properties.GetStringWithoutPathExpansion(shill::kMdnProperty, &mdn);
 
     MobileConfig* config = MobileConfig::GetInstance();
     if (config->IsReady()) {
@@ skipping 176 matching lines @@
       service_path,
       base::Bind(&ash::network_connect::ConnectToNetwork,
                  service_path, owning_window),
       base::Bind(&ShillError, "RequestReconnect"));
 }
 
 }  // namespace
 
 InternetOptionsHandler::InternetOptionsHandler()
     : weak_factory_(this) {
-  registrar_.Add(this, chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED,
-                 content::NotificationService::AllSources());
-  registrar_.Add(this, chrome::NOTIFICATION_ENTER_PIN_ENDED,
-                 content::NotificationService::AllSources());
   NetworkHandler::Get()->network_state_handler()->AddObserver(this, FROM_HERE);
 }
 
 InternetOptionsHandler::~InternetOptionsHandler() {
   if (NetworkHandler::IsInitialized()) {
     NetworkHandler::Get()->network_state_handler()->RemoveObserver(
         this, FROM_HERE);
   }
 }
 
@@ skipping 272 matching lines @@
     const base::ListValue* args) {
   bool require_pin_new_value;
   if (!args->GetBoolean(0, &require_pin_new_value)) {
     NOTREACHED();
     return;
   }
   // 1. Bring up SIM unlock dialog, pass new RequirePin setting in URL.
   // 2. Dialog will ask for current PIN in any case.
   // 3. If card is locked it will first call PIN unlock operation
   // 4. Then it will call Set RequirePin, passing the same PIN.
-  // 5. We'll get notified by REQUIRE_PIN_SETTING_CHANGE_ENDED notification.
+  // 5. The dialog may change device properties, in which case
+  //    DevicePropertiesUpdated() will get called which will update the UI.
   SimDialogDelegate::SimDialogMode mode;
   if (require_pin_new_value)
     mode = SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON;
   else
     mode = SimDialogDelegate::SIM_DIALOG_SET_LOCK_OFF;
   SimDialogDelegate::ShowDialog(GetNativeWindow(), mode);
 }
 
 void InternetOptionsHandler::ChangePinCallback(const base::ListValue* args) {
   SimDialogDelegate::ShowDialog(GetNativeWindow(),
@@ skipping 66 matching lines @@
 }
 
 void InternetOptionsHandler::NetworkPropertiesUpdated(
     const NetworkState* network) {
   if (!web_ui())
     return;
   RefreshNetworkData();
   UpdateConnectionData(network->path());
 }
 
-void InternetOptionsHandler::Observe(
-    int type,
-    const content::NotificationSource& source,
-    const content::NotificationDetails& details) {
-  if (type == chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED) {
-    base::FundamentalValue require_pin(*content::Details<bool>(details).ptr());
-    web_ui()->CallJavascriptFunction(
-        kUpdateSecurityTabFunction, require_pin);
-  } else if (type == chrome::NOTIFICATION_ENTER_PIN_ENDED) {
-    // We make an assumption (which is valid for now) that the SIM
-    // unlock dialog is put up only when the user is trying to enable
-    // mobile data.
-    bool cancelled = *content::Details<bool>(details).ptr();
-    if (cancelled)
-      RefreshNetworkData();
-    // The case in which the correct PIN was entered and the SIM is
-    // now unlocked is handled in NetworkMenuButton.
-  }
+void InternetOptionsHandler::DevicePropertiesUpdated(
+    const DeviceState* device) {
+  if (!web_ui())
+    return;
+  if (device->type() != shill::kTypeCellular)
+    return;
+  const NetworkState* network =
+      NetworkHandler::Get()->network_state_handler()->FirstNetworkByType(
+          NetworkTypePattern::Cellular());
+  if (network)
+    UpdateConnectionData(network->path());  // Update sim lock status.
 }
 
 void InternetOptionsHandler::SetServerHostnameCallback(
     const base::ListValue* args) {
   std::string service_path, server_hostname;
   if (args->GetSize() < 2 ||
       !args->GetString(0, &service_path) ||
       !args->GetString(1, &server_hostname)) {
     NOTREACHED();
     return;
@@ skipping 445 matching lines @@
   dictionary->SetBoolean(
       kTagWimaxAvailable,
       handler->IsTechnologyAvailable(NetworkTypePattern::Wimax()));
   dictionary->SetBoolean(
       kTagWimaxEnabled,
       handler->IsTechnologyEnabled(NetworkTypePattern::Wimax()));
 }
 
 }  // namespace options
 }  // namespace chromeos