Landing change for ers@chromium.org: http://codereview.chromium.org/4134012/s...

chrome/browser/chromeos/dom_ui/mobile_setup_ui.cc

 // Copyright (c) 2006-2010 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/chromeos/dom_ui/mobile_setup_ui.h"
 
+#include <algorithm>
 #include <map>
 #include <string>
 
 #include "app/l10n_util.h"
 #include "app/resource_bundle.h"
 #include "base/callback.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 100 matching lines @@
   }
 
  private:
   virtual ~MobileSetupUIHTMLSource() {}
 
   std::string service_path_;
   DISALLOW_COPY_AND_ASSIGN(MobileSetupUIHTMLSource);
 };
 
 // The handler for Javascript messages related to the "register" view.
-class MobileSetupHandler : public DOMMessageHandler,
-                           public chromeos::NetworkLibrary::Observer,
-                           public chromeos::NetworkLibrary::PropertyObserver,
-                           public base::SupportsWeakPtr<MobileSetupHandler> {
+class MobileSetupHandler
+  : public DOMMessageHandler,
+    public chromeos::NetworkLibrary::NetworkManagerObserver,
+    public chromeos::NetworkLibrary::NetworkObserver,
+    public base::SupportsWeakPtr<MobileSetupHandler> {
  public:
   explicit MobileSetupHandler(const std::string& service_path);
   virtual ~MobileSetupHandler();
 
   // Init work after Attach.
   void Init(TabContents* contents);
 
   // DOMMessageHandler implementation.
   virtual DOMMessageHandler* Attach(DOMUI* dom_ui);
   virtual void RegisterMessages();
 
-  // NetworkLibrary::Observer implementation.
-  virtual void NetworkChanged(chromeos::NetworkLibrary* obj);
-  // NetworkLibrary::PropertyObserver implementation.
-  virtual void PropertyChanged(const char* service_path,
-                               const char* key,
-                               const Value* value);
+  // NetworkLibrary::NetworkManagerObserver implementation.
+  virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* obj);
+  // NetworkLibrary::NetworkObserver implementation.
+  virtual void OnNetworkChanged(chromeos::NetworkLibrary* obj,
+                                const chromeos::Network* network);
 
  private:
   typedef enum PlanActivationState {
     PLAN_ACTIVATION_PAGE_LOADING = -1,
     PLAN_ACTIVATION_START = 0,
     PLAN_ACTIVATION_INITIATING_ACTIVATION = 1,
     PLAN_ACTIVATION_RECONNECTING = 2,
     PLAN_ACTIVATION_SHOWING_PAYMENT = 3,
     PLAN_ACTIVATION_DONE = 4,
     PLAN_ACTIVATION_ERROR = 5,
@@ skipping 190 matching lines @@
       service_path_(service_path),
       reenable_wifi_(false),
       reenable_ethernet_(false),
       reenable_cert_check_(false),
       transaction_complete_signalled_(false) {
 }
 
 MobileSetupHandler::~MobileSetupHandler() {
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
-  lib->RemoveObserver(this);
-  lib->RemoveProperyObserver(this);
+  lib->RemoveNetworkManagerObserver(this);
+  lib->RemoveObserverForAllNetworks(this);
   ReEnableOtherConnections();
 }
 
 DOMMessageHandler* MobileSetupHandler::Attach(DOMUI* dom_ui) {
   return DOMMessageHandler::Attach(dom_ui);
 }
 
 void MobileSetupHandler::Init(TabContents* contents) {
   tab_contents_ = contents;
   LoadCellularConfig();
   SetupActivationProcess(GetCellularNetwork(service_path_));
 }
 
 void MobileSetupHandler::RegisterMessages() {
   dom_ui_->RegisterMessageCallback(kJsApiStartActivation,
       NewCallback(this, &MobileSetupHandler::HandleStartActivation));
   dom_ui_->RegisterMessageCallback(kJsApiCloseTab,
       NewCallback(this, &MobileSetupHandler::HandleCloseTab));
   dom_ui_->RegisterMessageCallback(kJsApiSetTransactionStatus,
       NewCallback(this, &MobileSetupHandler::HandleSetTransactionStatus));
 }
 
-void MobileSetupHandler::NetworkChanged(chromeos::NetworkLibrary* lib) {
+void MobileSetupHandler::OnNetworkManagerChanged(
+    chromeos::NetworkLibrary* cros) {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
+  // Note that even though we get here when the service has
+  // reappeared after disappearing earlier in the activation
+  // process, there's no need to re-establish the NetworkObserver,
+  // because the service path remains the same.
   EvaluateCellularNetwork(GetCellularNetwork(service_path_));
 }
 
-void MobileSetupHandler::PropertyChanged(const char* service_path,
-                                         const char* key,
-                                         const Value* value) {
-
+void MobileSetupHandler::OnNetworkChanged(chromeos::NetworkLibrary* cros,
+                                          const chromeos::Network* network) {
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
-  // TODO(zelidrag, ers): Remove this once we flip the notification machanism.
-  chromeos::CrosLibrary::Get()->GetNetworkLibrary()->UpdateSystemInfo();
-
-  chromeos::CellularNetwork* network = GetCellularNetwork(service_path_);
-  if (!network) {
-    EvaluateCellularNetwork(NULL);
-    return;
-  }
-  if (network->service_path() != service_path) {
-    NOTREACHED();
-    return;
-  }
-  std::string value_string;
-  LOG(INFO) << "Cellular property change: " << key << " = " <<
-      value_string.c_str();
-
-  EvaluateCellularNetwork(network);
+  DCHECK(network && network->type() == chromeos::TYPE_CELLULAR);
+  EvaluateCellularNetwork(
+      static_cast<chromeos::CellularNetwork*>(
+          const_cast<chromeos::Network*>(network)));
 }
 
 void MobileSetupHandler::HandleCloseTab(const ListValue* args) {
   if (!dom_ui_)
     return;
   Browser* browser = BrowserList::FindBrowserWithFeature(
       dom_ui_->GetProfile(), Browser::FEATURE_TABSTRIP);
   if (browser)
     browser->CloseTabContents(tab_contents_);
 }
@@ skipping 17 matching lines @@
       NewRunnableMethod(task.get(), &TaskProxy::HandleSetTransactionStatus));
 }
 
 void MobileSetupHandler::StartActivation() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   chromeos::CellularNetwork* network = GetCellularNetwork(service_path_);
   if (!network) {
     ChangeState(NULL, PLAN_ACTIVATION_ERROR, std::string());
     return;
   }
-  chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
-      GetNetworkLibrary();
-  lib->RemoveObserver(this);
-  lib->RemoveProperyObserver(this);
-  // Start monitoring network and service property changes.
-  lib->AddObserver(this);
-  lib->AddProperyObserver(network->service_path().c_str(),
-                          this);
+  // Start monitoring network property changes.
+  chromeos::NetworkLibrary* lib =
+      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
+  lib->AddNetworkManagerObserver(this);
+  lib->RemoveObserverForAllNetworks(this);
+  lib->AddNetworkObserver(network->service_path(), this);
   state_ = PLAN_ACTIVATION_START;
   EvaluateCellularNetwork(network);
 }
 
 void MobileSetupHandler::SetTransactionStatus(const std::string& status) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // The payment is received, try to reconnect and check the status all over
   // again.
   if (LowerCaseEqualsASCII(status, "ok") &&
       state_ == PLAN_ACTIVATION_SHOWING_PAYMENT) {
@@ skipping 156 matching lines @@
 void MobileSetupHandler::CompleteActivation(
     chromeos::CellularNetwork* network) {
   // Remove observers, we are done with this page.
   chromeos::NetworkLibrary* lib = chromeos::CrosLibrary::Get()->
       GetNetworkLibrary();
   // If we have successfully activated the connection, set autoconnect flag.
   if (network) {
     network->set_auto_connect(true);
     lib->SaveCellularNetwork(network);
   }
-  lib->RemoveObserver(this);
-  lib->RemoveProperyObserver(this);
+  lib->RemoveNetworkManagerObserver(this);
+  lib->RemoveObserverForAllNetworks(this);
   // Reactivate other types of connections if we have
   // shut them down previously.
   ReEnableOtherConnections();
 }
 
 
 void MobileSetupHandler::ChangeState(chromeos::CellularNetwork* network,
                                      PlanActivationState new_state,
                                      const std::string& error_description) {
   static bool first_time = true;
@@ skipping 188 matching lines @@
   }
 }
 
 
 ////////////////////////////////////////////////////////////////////////////////
 //
 // MobileSetupUI
 //
 ////////////////////////////////////////////////////////////////////////////////
 
-MobileSetupUI::MobileSetupUI(TabContents* contents) : DOMUI(contents){
+MobileSetupUI::MobileSetupUI(TabContents* contents) : DOMUI(contents) {
   const chromeos::CellularNetwork* network = GetCellularNetwork();
   std::string service_path = network ? network->service_path() : std::string();
   MobileSetupHandler* handler = new MobileSetupHandler(service_path);
   AddMessageHandler((handler)->Attach(this));
   handler->Init(contents);
   MobileSetupUIHTMLSource* html_source =
       new MobileSetupUIHTMLSource(service_path);
 
   // Set up the chrome://mobilesetup/ source.
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       NewRunnableMethod(
           Singleton<ChromeURLDataManager>::get(),
           &ChromeURLDataManager::AddDataSource,
           make_scoped_refptr(html_source)));
 }