Added flags to prevent messing with network connections while 3G device is be...

chrome/browser/chromeos/cros/network_library.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/cros/network_library.h"
 
 #include <algorithm>
 #include <map>
 
 #include "app/l10n_util.h"
@@ skipping 824 matching lines @@
       : network_manager_monitor_(NULL),
         data_plan_monitor_(NULL),
         ethernet_(NULL),
         wifi_(NULL),
         cellular_(NULL),
         available_devices_(0),
         enabled_devices_(0),
         connected_devices_(0),
         wifi_scanning_(false),
         offline_mode_(false),
+        is_locked_(false),
         update_task_(NULL) {
     if (EnsureCrosLoaded()) {
       Init();
       network_manager_monitor_ =
           MonitorNetworkManager(&NetworkManagerStatusChangedHandler,
                                 this);
       data_plan_monitor_ = MonitorCellularDataPlan(&DataPlanUpdateHandler,
                                                    this);
       network_login_observer_.reset(new NetworkLoginObserver(this));
     } else {
@@ skipping 78 matching lines @@
       map_iter->second->RemoveObserver(observer);
       if (!map_iter->second->size()) {
         delete map_iter->second;
         network_observers_.erase(map_iter++);
       } else {
         ++map_iter;
       }
     }
   }
 
+  virtual void Lock() {
+    if (is_locked_)
+      return;
+    is_locked_ = true;
+    NotifyNetworkManagerChanged();
+ }
+
+  virtual void Unlock() {
+    DCHECK(is_locked_);
+    if (!is_locked_)
+      return;
+    is_locked_ = false;
+    NotifyNetworkManagerChanged();
+    is_locked_ = false;

[Charlie Lee, 2011/01/20 20:05:43]

What's the reason for setting this twice?

[zel, 2011/01/20 22:06:14]

Done.

+  }
+
+  virtual bool IsLocked() {
+    return is_locked_;
+  }
+
   virtual void AddCellularDataPlanObserver(CellularDataPlanObserver* observer) {
     if (!data_plan_observers_.HasObserver(observer))
       data_plan_observers_.AddObserver(observer);
   }
 
   virtual void RemoveCellularDataPlanObserver(
       CellularDataPlanObserver* observer) {
     data_plan_observers_.RemoveObserver(observer);
   }
 
@@ skipping 340 matching lines @@
     }
     if (cellular_ && cellular_->connected()) {
       cellular_->set_active(true);
       return cellular_;
     }
     // END BUG 9310 WORKAROUND
     return NULL;
   }
 
   virtual void EnableEthernetNetworkDevice(bool enable) {
+    if (is_locked_)
+      return;
     EnableNetworkDeviceType(TYPE_ETHERNET, enable);
   }
 
   virtual void EnableWifiNetworkDevice(bool enable) {
+    if (is_locked_)
+      return;
     EnableNetworkDeviceType(TYPE_WIFI, enable);
   }
 
   virtual void EnableCellularNetworkDevice(bool enable) {
+    if (is_locked_)
+      return;
     EnableNetworkDeviceType(TYPE_CELLULAR, enable);
   }
 
   virtual void EnableOfflineMode(bool enable) {
     if (!EnsureCrosLoaded())
       return;
 
     // If network device is already enabled/disabled, then don't do anything.
     if (enable && offline_mode_) {
       VLOG(1) << "Trying to enable offline mode when it's already enabled.";
@@ skipping 269 matching lines @@
   }
 
   void Init() {
     // First, get the currently available networks. This data is cached
     // on the connman side, so the call should be quick.
     VLOG(1) << "Getting initial CrOS network info.";
     UpdateSystemInfo();
   }
 
   void InitTestData() {
+    is_locked_ = true;
     ethernet_ = new EthernetNetwork();
     ethernet_->set_connected(true);
     ethernet_->set_service_path("eth1");
 
     STLDeleteElements(&wifi_networks_);
     wifi_networks_.clear();
     WifiNetwork* wifi1 = new WifiNetwork();
     wifi1->set_service_path("fw1");
     wifi1->set_name("Fake Wifi 1");
     wifi1->set_strength(90);
@@ skipping 297 matching lines @@
 
   // The current connected network devices. Bitwise flag of ConnectionTypes.
   int connected_devices_;
 
   // True if we are currently scanning for wifi networks.
   bool wifi_scanning_;
 
   // Currently not implemented. TODO: implement or eliminate.
   bool offline_mode_;
 
+  // True if access network library is locked.
+  bool is_locked_;
+
   // Delayed task to retrieve the network information.
   CancelableTask* update_task_;
 
   // Cellular plan payment time.
   base::Time cellular_plan_payment_time_;
 
   DISALLOW_COPY_AND_ASSIGN(NetworkLibraryImpl);
 };
 
 class NetworkLibraryStubImpl : public NetworkLibrary {
  public:
   NetworkLibraryStubImpl()
       : ip_address_("1.1.1.1"),
         ethernet_(new EthernetNetwork()),
         wifi_(NULL),
         cellular_(NULL) {
   }
   ~NetworkLibraryStubImpl() { if (ethernet_) delete ethernet_; }
   virtual void AddNetworkManagerObserver(NetworkManagerObserver* observer) {}
   virtual void RemoveNetworkManagerObserver(NetworkManagerObserver* observer) {}
   virtual void AddNetworkObserver(const std::string& service_path,
                                   NetworkObserver* observer) {}
   virtual void RemoveNetworkObserver(const std::string& service_path,
                                      NetworkObserver* observer) {}
   virtual void RemoveObserverForAllNetworks(NetworkObserver* observer) {}
+  virtual void Lock() {}
+  virtual void Unlock() {}
+  virtual bool IsLocked() { return true; }
   virtual void AddCellularDataPlanObserver(
       CellularDataPlanObserver* observer) {}
   virtual void RemoveCellularDataPlanObserver(
       CellularDataPlanObserver* observer) {}
   virtual const EthernetNetwork* ethernet_network() const {
     return ethernet_;
   }
   virtual bool ethernet_connecting() const { return false; }
   virtual bool ethernet_connected() const { return true; }
   virtual const WifiNetwork* wifi_network() const {
@@ skipping 92 matching lines @@
     return new NetworkLibraryStubImpl();
   else
     return new NetworkLibraryImpl();
 }
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until it's last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImpl);