Revert 64888 - Push for ers:...

chrome/browser/chromeos/dom_ui/mobile_setup_ui.cc

 // Copyright (c) 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 <map>
 #include <string>
 
 #include "app/l10n_util.h"
@@ skipping 106 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::NetworkManagerObserver,
-      public chromeos::NetworkLibrary::NetworkObserver,
-      public base::SupportsWeakPtr<MobileSetupHandler> {
-
+class MobileSetupHandler : public DOMMessageHandler,
+                           public chromeos::NetworkLibrary::Observer,
+                           public chromeos::NetworkLibrary::PropertyObserver,
+                           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::NetworkManagerObserver implementation.
-  virtual void OnNetworkManagerChanged(chromeos::NetworkLibrary* obj);
-  // NetworkLibrary::NetworkObserver implementation.
-  virtual void OnNetworkChanged(chromeos::NetworkLibrary* obj,
-                                const chromeos::Network* network);
+  // 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);
 
  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 163 matching lines @@
       state_(PLAN_ACTIVATION_PAGE_LOADING),
       service_path_(service_path),
       reenable_wifi_(false),
       reenable_ethernet_(false),
       reenable_cert_check_(false) {
 }
 
 MobileSetupHandler::~MobileSetupHandler() {
   chromeos::NetworkLibrary* lib =
       chromeos::CrosLibrary::Get()->GetNetworkLibrary();
-  lib->RemoveNetworkManagerObserver(this);
-  lib->RemoveObserverForAllNetworks(this);
+  lib->RemoveObserver(this);
+  lib->RemoveProperyObserver(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::OnNetworkManagerChanged(
-    chromeos::NetworkLibrary* cros) {
+void MobileSetupHandler::NetworkChanged(chromeos::NetworkLibrary* lib) {
   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::OnNetworkChanged(chromeos::NetworkLibrary* cros,
-                                          const chromeos::Network* network) {
+void MobileSetupHandler::PropertyChanged(const char* service_path,
+                                         const char* key,
+                                         const Value* value) {
+
   if (state_ == PLAN_ACTIVATION_PAGE_LOADING)
     return;
-  DCHECK(network && network->type() == chromeos::TYPE_CELLULAR);
-  EvaluateCellularNetwork(
-      static_cast<chromeos::CellularNetwork*>(
-          const_cast<chromeos::Network*>(network)));
+  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();
+
+  // TODO(zelidrag, ers): Remove this once we flip the notification machanism.
+  chromeos::CrosLibrary::Get()->GetNetworkLibrary()->UpdateSystemInfo();
+  EvaluateCellularNetwork(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_);
 }
 
 void MobileSetupHandler::HandleStartActivation(const ListValue* args) {
   chromeos::CellularNetwork* network = GetCellularNetwork(service_path_);
   if (!network) {
     ChangeState(NULL, PLAN_ACTIVATION_ERROR, std::string());
     return;
   }
-  // Start monitoring network property changes.
-  chromeos::NetworkLibrary* lib =
-      chromeos::CrosLibrary::Get()->GetNetworkLibrary();
-  lib->AddNetworkManagerObserver(this);
-  lib->RemoveObserverForAllNetworks(this);
-  lib->AddNetworkObserver(network->service_path(), this);
+  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);
   ChangeState(network, PLAN_ACTIVATION_START, std::string());
   EvaluateCellularNetwork(network);
 }
 
 void MobileSetupHandler::HandleSetTransactionStatus(const ListValue* args) {
   const size_t kSetTransactionStatusParamCount = 1;
   if (args->GetSize() != kSetTransactionStatusParamCount)
     return;
 
   // Get change callback function name.
@@ 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->RemoveNetworkManagerObserver(this);
-  lib->RemoveObserverForAllNetworks(this);
+  lib->RemoveObserver(this);
+  lib->RemoveProperyObserver(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 201 matching lines @@
       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)));
 }