[cros] Process proper notification in SIM dialog.

chrome/browser/ui/webui/chromeos/sim_unlock_ui.cc

 // Copyright (c) 2011 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/logging.h"
 #include "base/memory/weak_ptr.h"
@@ skipping 79 matching lines @@
   virtual ~SimUnlockHandler();
 
   // Init work after Attach.
   void Init(TabContents* contents);
 
   // WebUIMessageHandler implementation.
   virtual WebUIMessageHandler* Attach(WebUI* web_ui) OVERRIDE;
   virtual void RegisterMessages() OVERRIDE;
 
   // NetworkLibrary::NetworkDeviceObserver implementation.
-  virtual void OnNetworkDeviceChanged(NetworkLibrary* cros,
-                                      const NetworkDevice* device) OVERRIDE;
+  virtual void OnNetworkDeviceSimLockChanged(
+      NetworkLibrary* cros, const NetworkDevice* device) OVERRIDE;
 
   // NetworkLibrary::PinOperationObserver implementation.
   virtual void OnPinOperationCompleted(NetworkLibrary* cros,
                                        PinOperationError error) OVERRIDE;
 
  private:
   // Should keep this state enum in sync with similar one in JS code.
   // SIM_NOT_LOCKED_ASK_PIN - SIM card is not locked but we ask user
   // for PIN input because PinRequired preference change was requested.
   // SIM_NOT_LOCKED_CHANGE_PIN - SIM card is not locked, ask user for old PIN
@@ skipping 94 matching lines @@
   void ProceedToPukInput();
 
   // Processes current SIM card state and update internal state/page.
   void ProcessSimCardState(const chromeos::NetworkDevice* cellular);
 
   // Updates page with the current state/SIM card info/error.
   void UpdatePage(const chromeos::NetworkDevice* cellular,
                   const std::string& error_msg);
 
   TabContents* tab_contents_;
+
+  // Dialog internal state.
   SimUnlockState state_;
 
   // Path of the Cellular device that we monitor property updates from.
   std::string cellular_device_path_;
 
   // Type of the dialog: generic unlock/change pin/change PinRequire.
   SimDialogDelegate::SimDialogMode dialog_mode_;
 
   // New PIN value for the case when we unblock SIM card or change PIN.
   std::string new_pin_;
 
+  // True if there's a pending PIN operation.
+  // That means that SIM lock state change will be received 2 times:
+  // OnNetworkDeviceSimLockChanged and OnPinOperationCompleted.
+  // First one should be ignored.
+  bool pending_pin_operation_;
+
   DISALLOW_COPY_AND_ASSIGN(SimUnlockHandler);
 };
 
 // SimUnlockUIHTMLSource -------------------------------------------------------
 
 SimUnlockUIHTMLSource::SimUnlockUIHTMLSource()
     : DataSource(chrome::kChromeUISimUnlockHost, MessageLoop::current()) {
 }
 
 void SimUnlockUIHTMLSource::StartDataRequest(const std::string& path,
@@ skipping 62 matching lines @@
                                                                   &strings);
 
   SendResponse(request_id, base::RefCountedString::TakeString(&full_html));
 }
 
 // SimUnlockHandler ------------------------------------------------------------
 
 SimUnlockHandler::SimUnlockHandler()
     : tab_contents_(NULL),
       state_(SIM_UNLOCK_LOADING),
-      dialog_mode_(SimDialogDelegate::SIM_DIALOG_UNLOCK) {
+      dialog_mode_(SimDialogDelegate::SIM_DIALOG_UNLOCK),
+      pending_pin_operation_(false) {
   const chromeos::NetworkDevice* cellular = GetCellularDevice();
   // One could just call us directly via chrome://sim-unlock.
   if (cellular) {
     cellular_device_path_ = cellular->device_path();
     CrosLibrary::Get()->GetNetworkLibrary()->AddNetworkDeviceObserver(
         cellular_device_path_, this);
     CrosLibrary::Get()->GetNetworkLibrary()->AddPinOperationObserver(this);
   }
 }
 
@@ skipping 21 matching lines @@
   web_ui_->RegisterMessageCallback(kJsApiEnterPinCode,
       NewCallback(this, &SimUnlockHandler::HandleEnterPinCode));
   web_ui_->RegisterMessageCallback(kJsApiEnterPukCode,
       NewCallback(this, &SimUnlockHandler::HandleEnterPukCode));
   web_ui_->RegisterMessageCallback(kJsApiProceedToPukInput,
       NewCallback(this, &SimUnlockHandler::HandleProceedToPukInput));
   web_ui_->RegisterMessageCallback(kJsApiSimStatusInitialize,
       NewCallback(this, &SimUnlockHandler::HandleSimStatusInitialize));
 }
 
-void SimUnlockHandler::OnNetworkDeviceChanged(NetworkLibrary* cros,
-                                              const NetworkDevice* device) {
+void SimUnlockHandler::OnNetworkDeviceSimLockChanged(
+    NetworkLibrary* cros, const NetworkDevice* device) {
   chromeos::SimLockState lock_state = device->sim_lock_state();
   int retries_left = device->sim_retries_left();
-  VLOG(1) << "OnNetworkDeviceChanged, lock: " << lock_state
+  VLOG(1) << "OnNetworkDeviceSimLockChanged, lock: " << lock_state
           << ", retries: " << retries_left;
-  ProcessSimCardState(GetCellularDevice());
+  // There's a pending PIN operation.
+  // Wait for it to finish and refresh state then.
+  if (!pending_pin_operation_)
+    ProcessSimCardState(GetCellularDevice());
 }
 
 void SimUnlockHandler::OnPinOperationCompleted(NetworkLibrary* cros,
                                                PinOperationError error) {
+  pending_pin_operation_ = false;
   DCHECK(cros);
   const NetworkDevice* cellular = cros->FindCellularDevice();
   DCHECK(cellular);
   VLOG(1) << "OnPinOperationCompleted, error: " << error;
   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);
@@ skipping 29 matching lines @@
 }
 
 void SimUnlockHandler::EnterCode(const std::string& code,
                                  SimUnlockCode code_type) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   NetworkLibrary* lib = chromeos::CrosLibrary::Get()->GetNetworkLibrary();
   CHECK(lib);
 
   const NetworkDevice* cellular = GetCellularDevice();
   chromeos::SimLockState lock_state = cellular->sim_lock_state();
+  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) {
         if (lock_state != chromeos::SIM_UNLOCKED) {
           // If SIM is locked/absent, change RequirePin UI is not accessible.
           NOTREACHED() <<
               "Changing RequirePin pref on locked / uninitialized SIM.";
         }
@@ skipping 233 matching lines @@
   AddMessageHandler((handler)->Attach(this));
   handler->Init(contents);
   SimUnlockUIHTMLSource* html_source = new SimUnlockUIHTMLSource();
 
   // Set up the chrome://sim-unlock/ source.
   Profile* profile = Profile::FromBrowserContext(contents->browser_context());
   profile->GetChromeURLDataManager()->AddDataSource(html_source);
 }
 
 }  // namespace chromeos