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

chrome/browser/chromeos/cros/network_library.h

 // 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #define CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 371 matching lines @@
   SimLockState sim_lock_state() const { return sim_lock_state_; }
   bool is_sim_locked() const {
     return sim_lock_state_ == SIM_LOCKED_PIN ||
         sim_lock_state_ == SIM_LOCKED_PUK;
   }
   const int sim_retries_left() const { return sim_retries_left_; }
   SimPinRequire sim_pin_required() const { return sim_pin_required_; }
   const std::string& firmware_revision() const { return firmware_revision_; }
   const std::string& hardware_revision() const { return hardware_revision_; }
   const unsigned int prl_version() const { return prl_version_; }
-  const std::string& home_provider() const { return home_provider_; }
   const std::string& home_provider_code() const { return home_provider_code_; }
   const std::string& home_provider_country() const {
     return home_provider_country_;
   }
   const std::string& home_provider_id() const { return home_provider_id_; }
   const std::string& home_provider_name() const { return home_provider_name_; }
   const std::string& selected_cellular_network() const {
     return selected_cellular_network_;
   }
   const CellularNetworkList& found_cellular_networks() const {
@@ skipping 42 matching lines @@
   void set_meid(const std::string& meid) { meid_ = meid; }
   void set_imei(const std::string& imei) { imei_ = imei; }
   void set_imsi(const std::string& imsi) { imsi_ = imsi; }
   void set_esn(const std::string& esn) { esn_ = esn; }
   void set_mdn(const std::string& mdn) { mdn_ = mdn; }
   void set_min(const std::string& min) { min_ = min; }
   void set_technology_family(TechnologyFamily technology_family) {
     technology_family_ = technology_family;
   }
   void set_carrier(const std::string& carrier) { carrier_ = carrier; }
-  void set_home_provider(const std::string& home_provider) {
-    home_provider_ = home_provider;
-  }
   void set_home_provider_code(const std::string& home_provider_code) {
     home_provider_code_ = home_provider_code;
   }
   void set_home_provider_country(const std::string& home_provider_country) {
     home_provider_country_ = home_provider_country;
   }
   void set_home_provider_id(const std::string& home_provider_id) {
     home_provider_id_ = home_provider_id;
   }
   void set_home_provider_name(const std::string& home_provider_name) {
@@ skipping 43 matching lines @@
 
   // General device info.
   std::string device_path_;
   std::string name_;
   std::string unique_id_;
   ConnectionType type_;
   bool scanning_;
   // Cellular specific device info.
   TechnologyFamily technology_family_;
   std::string carrier_;
-  std::string home_provider_;
   std::string home_provider_code_;
   std::string home_provider_country_;
   std::string home_provider_id_;
   std::string home_provider_name_;
   std::string meid_;
   std::string imei_;
   std::string imsi_;
   std::string esn_;
   std::string mdn_;
   std::string min_;
@@ skipping 970 matching lines @@
 
   // Request a scan for available cellular networks.
   virtual void RequestCellularScan() = 0;
 
   // Request a register in cellular network with |network_id|.
   virtual void RequestCellularRegister(const std::string& network_id) = 0;
 
   // Change data roaming restriction for current cellular device.
   virtual void SetCellularDataRoamingAllowed(bool new_value) = 0;
 
+  // Return true if GSM SIM card can work only with enabled roaming.
+  virtual bool IsCellularAlwaysInRoaming() = 0;
+
   // Request a scan for new wifi networks.
   virtual void RequestNetworkScan() = 0;
 
   // Reads out the results of the last wifi scan. These results are not
   // pre-cached in the library, so the call may block whilst the results are
   // read over IPC.
   // Returns false if an error occurred in reading the results. Note that
   // a true return code only indicates the result set was successfully read,
   // it does not imply a scan has successfully completed yet.
   virtual bool GetWifiAccessPoints(WifiAccessPointVector* result) = 0;
@@ skipping 107 matching lines @@
   virtual void SwitchToPreferredNetwork() = 0;
 
   // Factory function, creates a new instance and returns ownership.
   // For normal usage, access the singleton via CrosLibrary::Get().
   static NetworkLibrary* GetImpl(bool stub);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_CROS_NETWORK_LIBRARY_H_