Eliminate use of sim unlock UI notifications

chrome/browser/ui/webui/chromeos/sim_unlock_ui.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/chromeos/sim_unlock_ui.h"
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted_memory.h"
 #include "base/memory/weak_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/string_piece.h"
 #include "base/values.h"
-#include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/chromeos/sim_dialog_delegate.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/url_constants.h"
 #include "chromeos/network/device_state.h"
 #include "chromeos/network/network_device_handler.h"
 #include "chromeos/network/network_event_log.h"
 #include "chromeos/network/network_state_handler.h"
 #include "chromeos/network/network_state_handler_observer.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/notification_service.h"
 #include "content/public/browser/url_data_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui.h"
 #include "content/public/browser/web_ui_message_handler.h"
 #include "grit/browser_resources.h"
 #include "grit/generated_resources.h"
 #include "third_party/cros_system_api/dbus/service_constants.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/webui/jstemplate_builder.h"
 #include "ui/base/webui/web_ui_util.h"
 
 using content::BrowserThread;
 using content::WebContents;
 using content::WebUIMessageHandler;
 
 namespace {
 
 // JS API callbacks names.
-const char kJsApiCancel[] = "cancel";
 const char kJsApiChangePinCode[] = "changePinCode";
 const char kJsApiEnterPinCode[] = "enterPinCode";
 const char kJsApiEnterPukCode[] = "enterPukCode";
 const char kJsApiProceedToPukInput[] = "proceedToPukInput";
 const char kJsApiSimStatusInitialize[] = "simStatusInitialize";
 
 // Page JS API function names.
 const char kJsApiSimStatusChanged[] = "mobile.SimUnlock.simStateChanged";
 
 // SIM state variables which are passed to the page.
@@ skipping 95 matching lines @@
     }
 
     TaskProxy(const base::WeakPtr<SimUnlockHandler>& handler,
               const std::string& code,
               SimUnlockCode code_type)
         : handler_(handler),
           code_(code),
           code_type_(code_type) {
     }
 
-    void HandleCancel() {
-      if (handler_)
-        handler_->CancelDialog();
-    }
-
     void HandleEnterCode() {
       if (handler_)
         handler_->EnterCode(code_, code_type_);
     }
 
     void HandleInitialize() {
       if (handler_)
         handler_->InitializeSimStatus();
     }
 
@@ skipping 14 matching lines @@
 
     // Pending code type.
     SimUnlockCode code_type_;
 
     DISALLOW_COPY_AND_ASSIGN(TaskProxy);
   };
 
   // Returns the cellular device that this dialog currently corresponds to.
   const DeviceState* GetCellularDevice();
 
-  // Processing for the cases when dialog was cancelled.
-  void CancelDialog();
-
   // Pass PIN/PUK code to shill and check status.
   void EnterCode(const std::string& code, SimUnlockCode code_type);
 
   // Methods to invoke shill PIN/PUK D-Bus operations.
   void ChangeRequirePin(bool require_pin, const std::string& pin);
   void EnterPin(const std::string& pin);
   void ChangePin(const std::string& old_pin, const std::string& new_pin);
   void UnblockPin(const std::string& puk, const std::string& new_pin);
   void PinOperationSuccessCallback(const std::string& operation_name);
   void PinOperationErrorCallback(const std::string& operation_name,
                                  const std::string& error_name,
                                  scoped_ptr<base::DictionaryValue> error_data);
 
   // Called when an asynchronous PIN operation has completed.
   void OnPinOperationCompleted(PinOperationError error);
 
   // Single handler for PIN/PUK code operations.
   void HandleEnterCode(SimUnlockCode code_type, const std::string& code);
 
   // Handlers for JS WebUI messages.
-  void HandleCancel(const base::ListValue* args);
   void HandleChangePinCode(const base::ListValue* args);
   void HandleEnterPinCode(const base::ListValue* args);
   void HandleEnterPukCode(const base::ListValue* args);
   void HandleProceedToPukInput(const base::ListValue* args);
   void HandleSimStatusInitialize(const base::ListValue* args);
 
   // Initialize current SIM card status, passes that to page.
   void InitializeSimStatus();
 
-  // Notifies SIM Security tab handler that RequirePin preference change
-  // has been ended (either updated or cancelled).
-  void NotifyOnRequirePinChangeEnded(bool new_value);
-
-  // Notifies observers that the EnterPin or EnterPuk dialog has been
-  // completed (either cancelled or with entry of PIN/PUK).
-  void NotifyOnEnterPinEnded(bool cancelled);
-
   // Checks whether SIM card is in PUK locked state and proceeds to PUK input.
   void ProceedToPukInput();
 
   // Processes current SIM card state and update internal state/page.
   void ProcessSimCardState(const DeviceState* cellular);
 
   // Updates page with the current state/SIM card info/error.
   void UpdatePage(const DeviceState* cellular, const std::string& error_msg);
 
   // Dialog internal state.
@@ skipping 33 matching lines @@
 
 void SimUnlockUIHTMLSource::StartDataRequest(
     const std::string& path,
     int render_process_id,
     int render_frame_id,
     const content::URLDataSource::GotDataCallback& callback) {
   base::DictionaryValue strings;
   strings.SetString("title",
       l10n_util::GetStringUTF16(IDS_SIM_UNLOCK_ENTER_PIN_TITLE));
   strings.SetString("ok", l10n_util::GetStringUTF16(IDS_OK));
-  strings.SetString("cancel", l10n_util::GetStringUTF16(IDS_CANCEL));
   strings.SetString("enterPinTitle",
       l10n_util::GetStringUTF16(IDS_SIM_UNLOCK_ENTER_PIN_TITLE));
   strings.SetString("enterPinMessage",
       l10n_util::GetStringUTF16(IDS_SIM_ENTER_PIN_MESSAGE));
   strings.SetString("enterPinTriesMessage",
       l10n_util::GetStringUTF16(IDS_SIM_UNLOCK_ENTER_PIN_TRIES_MESSAGE));
   strings.SetString("incorrectPinTriesMessage",
       l10n_util::GetStringUTF16(IDS_SIM_UNLOCK_INCORRECT_PIN_TRIES_MESSAGE));
   strings.SetString("incorrectPinTitle",
       l10n_util::GetStringUTF16(IDS_SIM_UNLOCK_INCORRECT_PIN_TITLE));
@@ skipping 57 matching lines @@
           ->GetTechnologyState(NetworkTypePattern::Cellular()) !=
       NetworkStateHandler::TECHNOLOGY_UNAVAILABLE)
     GetNetworkStateHandler()->AddObserver(this, FROM_HERE);
 }
 
 SimUnlockHandler::~SimUnlockHandler() {
   GetNetworkStateHandler()->RemoveObserver(this, FROM_HERE);
 }
 
 void SimUnlockHandler::RegisterMessages() {
-  web_ui()->RegisterMessageCallback(kJsApiCancel,
-      base::Bind(&SimUnlockHandler::HandleCancel,
-                 base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kJsApiChangePinCode,
       base::Bind(&SimUnlockHandler::HandleChangePinCode,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kJsApiEnterPinCode,
       base::Bind(&SimUnlockHandler::HandleEnterPinCode,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kJsApiEnterPukCode,
       base::Bind(&SimUnlockHandler::HandleEnterPukCode,
                  base::Unretained(this)));
   web_ui()->RegisterMessageCallback(kJsApiProceedToPukInput,
@@ skipping 32 matching lines @@
   VLOG(1) << "OnPinOperationCompleted, error: " << error;
   const DeviceState* cellular = GetCellularDevice();
   if (!cellular) {
     VLOG(1) << "Cellular device disappeared. Dismissing dialog.";
     ProcessSimCardState(NULL);
     return;
   }
   if (state_ == SIM_NOT_LOCKED_ASK_PIN && error == PIN_ERROR_NONE) {
     CHECK(dialog_mode_ == SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON ||
           dialog_mode_ == SimDialogDelegate::SIM_DIALOG_SET_LOCK_OFF);
-    // Async change RequirePin operation has finished OK.
-    NotifyOnRequirePinChangeEnded(
-        dialog_mode_ == SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON);
     // Dialog will close itself.
     state_ = SIM_ABSENT_NOT_LOCKED;
   } else if (state_ == SIM_NOT_LOCKED_CHANGE_PIN && error == PIN_ERROR_NONE) {
     CHECK(dialog_mode_ == SimDialogDelegate::SIM_DIALOG_CHANGE_PIN);
     // Dialog will close itself.
     state_ = SIM_ABSENT_NOT_LOCKED;
   }
   // If previous EnterPIN was last PIN attempt and SIMLock state was already
   // processed by OnNetworkDeviceChanged, let dialog stay on
   // NO_PIN_RETRIES_LEFT step.
   if (!(state_ == SIM_LOCKED_NO_PIN_TRIES_LEFT && error == PIN_ERROR_BLOCKED))
     ProcessSimCardState(cellular);
-  if (dialog_mode_ == SimDialogDelegate::SIM_DIALOG_UNLOCK &&
-      state_ == SIM_ABSENT_NOT_LOCKED)
-    NotifyOnEnterPinEnded(false);
 }
 
 const DeviceState* SimUnlockHandler::GetCellularDevice() {
   return GetNetworkStateHandler()->GetDeviceState(cellular_device_path_);
 }
 
-void SimUnlockHandler::CancelDialog() {
-  if (dialog_mode_ == SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON ||
-      dialog_mode_ == SimDialogDelegate::SIM_DIALOG_SET_LOCK_OFF) {
-    // When async change RequirePin operation is performed,
-    // dialog UI controls such as Cancel button are disabled.
-    // If dialog was cancelled that means RequirePin preference hasn't been
-    // changed and is not in process of changing at the moment.
-    NotifyOnRequirePinChangeEnded(
-        !(dialog_mode_ == SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON));
-  } else if (dialog_mode_ == SimDialogDelegate::SIM_DIALOG_UNLOCK) {
-    NotifyOnEnterPinEnded(true);
-  }
-}
-
 void SimUnlockHandler::EnterCode(const std::string& code,
                                  SimUnlockCode code_type) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   pending_pin_operation_ = true;
 
   switch (code_type) {
     case CODE_PIN:
       if (dialog_mode_ == SimDialogDelegate::SIM_DIALOG_SET_LOCK_ON ||
           dialog_mode_ == SimDialogDelegate::SIM_DIALOG_SET_LOCK_OFF) {
@@ skipping 119 matching lines @@
   if (error_name == NetworkDeviceHandler::kErrorIncorrectPin ||
       error_name == NetworkDeviceHandler::kErrorPinRequired)
     pin_error = PIN_ERROR_INCORRECT_CODE;
   else if (error_name == NetworkDeviceHandler::kErrorPinBlocked)
     pin_error = PIN_ERROR_BLOCKED;
   else
     pin_error = PIN_ERROR_UNKNOWN;
   OnPinOperationCompleted(pin_error);
 }
 
-void SimUnlockHandler::NotifyOnEnterPinEnded(bool cancelled) {
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_ENTER_PIN_ENDED,
-      content::NotificationService::AllSources(),
-      content::Details<bool>(&cancelled));
-}
-
-void SimUnlockHandler::NotifyOnRequirePinChangeEnded(bool new_value) {
-  content::NotificationService::current()->Notify(
-      chrome::NOTIFICATION_REQUIRE_PIN_SETTING_CHANGE_ENDED,
-      content::NotificationService::AllSources(),
-      content::Details<bool>(&new_value));
-}
-
-void SimUnlockHandler::HandleCancel(const base::ListValue* args) {
-  const size_t kEnterCodeParamCount = 0;
-  if (args->GetSize() != kEnterCodeParamCount) {
-    NOTREACHED();
-    return;
-  }
-  scoped_refptr<TaskProxy> task = new TaskProxy(AsWeakPtr());
-  BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-      base::Bind(&TaskProxy::HandleCancel, task.get()));
-}
-
 void SimUnlockHandler::HandleChangePinCode(const base::ListValue* args) {
   const size_t kChangePinParamCount = 2;
   std::string pin;
   std::string new_pin;
   if (args->GetSize() != kChangePinParamCount ||
       !args->GetString(0, &pin) ||
       !args->GetString(1, &new_pin)) {
     NOTREACHED();
     return;
   }
@@ skipping 185 matching lines @@
   SimUnlockHandler* handler = new SimUnlockHandler();
   web_ui->AddMessageHandler(handler);
   SimUnlockUIHTMLSource* html_source = new SimUnlockUIHTMLSource();
 
   // Set up the chrome://sim-unlock/ source.
   Profile* profile = Profile::FromWebUI(web_ui);
   content::URLDataSource::Add(profile, html_source);
 }
 
 }  // namespace chromeos