Always enable roaming for cellular operators that don't work without it

chrome/browser/chromeos/cros/network_library.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/chromeos/cros/network_library.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 
@@ skipping 85 matching lines @@
 const int kNetworkNotifyDelayMs = 50;
 
 // How long we should remember that cellular plan payment was received.
 const int kRecentPlanPaymentHours = 6;
 
 // Default value of the SIM unlock retries count. It is updated to the real
 // retries count once cellular device with SIM card is initialized.
 // If cellular device doesn't have SIM card, then retries are never used.
 const int kDefaultSimUnlockRetriesCount = 999;
 
+// List of cellular operators names that should have data roaming always enabled
+// to be able to connect to any network.
+const char* kAlwaysInRoamingOperators[] = {
+  "CUBIC"
+};
+
 ////////////////////////////////////////////////////////////////////////////////
 // Misc.
 
 // Safe string constructor since we can't rely on non NULL pointers
 // for string values from libcros.
 static std::string SafeString(const char* s) {
   return s ? std::string(s) : std::string();
 }
 
 // Erase the memory used by a string, then clear it.
@@ skipping 1251 matching lines @@
   virtual std::string GetCellularHomeCarrierId() const OVERRIDE;
 
   // virtual ChangePin implemented in derived classes.
   // virtual ChangeRequiredPin implemented in derived classes.
   // virtual EnterPin implemented in derived classes.
   // virtual UnblockPin implemented in derived classes.
 
   // virtual RequestCellularScan implemented in derived classes.
   // virtual RequestCellularRegister implemented in derived classes.
   // virtual SetCellularDataRoamingAllowed implemented in derived classes.
+  // virtual IsCellularAlwaysInRoaming implemented in derived classes.
   // virtual RequestNetworkScan implemented in derived classes.
   // virtual GetWifiAccessPoints implemented in derived classes.
 
   virtual bool HasProfileType(NetworkProfileType type) const OVERRIDE;
   virtual void SetNetworkProfile(const std::string& service_path,
                                  NetworkProfileType type) OVERRIDE;
   virtual bool CanConnectToNetwork(const Network* network) const OVERRIDE;
 
   // Connect to an existing network.
   virtual void ConnectToWifiNetwork(WifiNetwork* wifi) OVERRIDE;
@@ skipping 1561 matching lines @@
   virtual void ChangePin(const std::string& old_pin,
                          const std::string& new_pin) OVERRIDE;
   virtual void ChangeRequirePin(bool require_pin,
                                 const std::string& pin) OVERRIDE;
   virtual void EnterPin(const std::string& pin) OVERRIDE;
   virtual void UnblockPin(const std::string& puk,
                           const std::string& new_pin) OVERRIDE;
   virtual void RequestCellularScan() OVERRIDE;
   virtual void RequestCellularRegister(const std::string& network_id) OVERRIDE;
   virtual void SetCellularDataRoamingAllowed(bool new_value) OVERRIDE;
+  virtual bool IsCellularAlwaysInRoaming() OVERRIDE;
   virtual void RequestNetworkScan() OVERRIDE;
   virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) OVERRIDE;
 
   virtual void DisconnectFromNetwork(const Network* network) OVERRIDE;
   virtual void CallEnableNetworkDeviceType(
       ConnectionType device, bool enable) OVERRIDE;
   virtual void EnableOfflineMode(bool enable) OVERRIDE;
 
   virtual NetworkIPConfigVector GetIPConfigs(
       const std::string& device_path,
@@ skipping 236 matching lines @@
 
 void NetworkLibraryImplCros::UpdateNetworkDeviceStatus(
     const std::string& path, const std::string& key, const Value& value) {
   CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   NetworkDevice* device = FindNetworkDeviceByPath(path);
   if (device) {
     VLOG(2) << "UpdateNetworkDeviceStatus: " << device->name() << "." << key;
     PropertyIndex index = PROPERTY_INDEX_UNKNOWN;
     if (device->UpdateStatus(key, value, &index)) {
       if (index == PROPERTY_INDEX_CELLULAR_ALLOW_ROAMING) {
-        bool settings_value =
-            UserCrosSettingsProvider::cached_data_roaming_enabled();
-        if (device->data_roaming_allowed() != settings_value) {
-          // Switch back to signed settings value.
-          SetCellularDataRoamingAllowed(settings_value);
-          return;
+        if (!device->data_roaming_allowed() && IsCellularAlwaysInRoaming()) {
+          SetCellularDataRoamingAllowed(true);
+        } else {
+          bool settings_value =
+              UserCrosSettingsProvider::cached_data_roaming_enabled();
+          if (device->data_roaming_allowed() != settings_value) {
+            // Switch back to signed settings value.
+            SetCellularDataRoamingAllowed(settings_value);
+            return;
+          }
         }
       }
     } else {
       VLOG(1) << "UpdateNetworkDeviceStatus: Failed to update: "
               << path << "." << key;
     }
     // Notify only observers on device property change.
     NotifyNetworkDeviceChanged(device, index);
     // If a device's power state changes, new properties may become defined.
     if (index == PROPERTY_INDEX_POWERED)
@@ skipping 239 matching lines @@
     NOTREACHED() << "Calling SetCellularDataRoamingAllowed method "
         "w/o cellular device.";
     return;
   }
   scoped_ptr<Value> value(Value::CreateBooleanValue(new_value));
   chromeos::SetNetworkDeviceProperty(cellular->device_path().c_str(),
                                      kCellularAllowRoamingProperty,
                                      value.get());
 }
 
+bool NetworkLibraryImplCros::IsCellularAlwaysInRoaming() {
+  const NetworkDevice* cellular = FindCellularDevice();
+  if (!cellular) {
+    NOTREACHED() << "Calling IsCellularAlwaysInRoaming method "
+        "w/o cellular device.";
+    return false;
+  }
+  const std::string& home_provider_name = cellular->home_provider_name();
+  for (size_t i = 0; i < arraysize(kAlwaysInRoamingOperators); i++) {
+    if (home_provider_name == kAlwaysInRoamingOperators[i])
+      return true;
+  }
+  return false;
+}
+
 void NetworkLibraryImplCros::RequestNetworkScan() {
   if (wifi_enabled()) {
     wifi_scanning_ = true;  // Cleared when updates are received.
     chromeos::RequestNetworkScan(kTypeWifi);
   }
   if (cellular_network())
     cellular_network()->RefreshDataPlansIfNeeded();
   // Make sure all Manager info is up to date. This will also update
   // remembered networks and visible services.
   chromeos::RequestNetworkManagerInfo(&NetworkManagerUpdate, this);
@@ skipping 755 matching lines @@
   } else {
     NativeNetworkDeviceParser parser;
     device = parser.CreateDeviceFromInfo(device_path, info);
     VLOG(2) << " Adding device: " << device_path;
     if (device) {
       device_map_[device_path] = device;
     }
     CHECK(device) << "Attempted to add NULL device for path: " << device_path;
   }
   VLOG(1) << "ParseNetworkDevice:" << device->name();
+  if (device && device->type() == TYPE_CELLULAR) {
+    if (!device->data_roaming_allowed() && IsCellularAlwaysInRoaming()) {
+      SetCellularDataRoamingAllowed(true);
+    } else {
+      bool settings_value =
+          UserCrosSettingsProvider::cached_data_roaming_enabled();
+      if (device->data_roaming_allowed() != settings_value) {
+        // Switch back to signed settings value.
+        SetCellularDataRoamingAllowed(settings_value);
+      }
+    }
+  }
   NotifyNetworkManagerChanged(false);  // Not forced.
   AddNetworkDeviceObserver(device_path, network_device_observer_.get());
 }
 
 ////////////////////////////////////////////////////////////////////////////
 
 class NetworkLibraryImplStub : public NetworkLibraryImplBase {
  public:
   NetworkLibraryImplStub();
   virtual ~NetworkLibraryImplStub();
@@ skipping 29 matching lines @@
   virtual void ChangeRequirePin(bool require_pin,
                                 const std::string& pin) OVERRIDE;
   virtual void EnterPin(const std::string& pin) OVERRIDE;
   virtual void UnblockPin(const std::string& puk,
                           const std::string& new_pin) OVERRIDE;
 
   virtual void RequestCellularScan() OVERRIDE {}
   virtual void RequestCellularRegister(
       const std::string& network_id) OVERRIDE {}
   virtual void SetCellularDataRoamingAllowed(bool new_value) OVERRIDE {}
+  virtual bool IsCellularAlwaysInRoaming() OVERRIDE { return false; }
   virtual void RequestNetworkScan() OVERRIDE {}
 
   virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) OVERRIDE;
 
   virtual void DisconnectFromNetwork(const Network* network) OVERRIDE;
 
   virtual void CallEnableNetworkDeviceType(
       ConnectionType device, bool enable) OVERRIDE {}
   virtual void EnableOfflineMode(bool enable) OVERRIDE {
     offline_mode_ = enable;
@@ skipping 299 matching lines @@
   return network_library;
 }
 
 /////////////////////////////////////////////////////////////////////////////
 
 }  // namespace chromeos
 
 // Allows InvokeLater without adding refcounting. This class is a Singleton and
 // won't be deleted until its last InvokeLater is run.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(chromeos::NetworkLibraryImplBase);