Activation process improvements

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 66 matching lines @@
 static const char* kNetworkTechnologyHspa = "HSPA";
 static const char* kNetworkTechnologyHspaPlus = "HSPA+";
 static const char* kNetworkTechnologyLte = "LTE";
 static const char* kNetworkTechnologyLteAdvanced = "LTE Advanced";
 
 // Connman roaming state options
 static const char* kRoamingStateHome = "home";
 static const char* kRoamingStateRoaming = "roaming";
 static const char* kRoamingStateUnknown = "unknown";
 
+// How long we should remember that cellular plan payment was received.
+const int kRecentPlanPaymentHours = 6;
+
 static ConnectionState ParseState(const std::string& state) {
   if (state == kStateIdle)
     return STATE_IDLE;
   if (state == kStateCarrier)
     return STATE_CARRIER;
   if (state == kStateAssociation)
     return STATE_ASSOCIATION;
   if (state == kStateConfiguration)
     return STATE_CONFIGURATION;
   if (state == kStateReady)
@@ skipping 1031 matching lines @@
     }
   }
 
   virtual void RefreshCellularDataPlans(const CellularNetwork* network) {
     DCHECK(network);
     if (!EnsureCrosLoaded() || !network)
       return;
     RequestCellularDataPlanUpdate(network->service_path().c_str());
   }
 
+  // Records information that cellular play payment had happened.
+  virtual void SignalCellularPlanPayment() {
+    DCHECK(!HasRecentCellularPlanPayment());
+    cellular_plan_payment_time_ = base::Time::Now();
+  }
+
+  // Returns true if cellular plan payment had been recorded recently.
+  virtual bool HasRecentCellularPlanPayment() {
+    return (base::Time::Now() -
+              cellular_plan_payment_time_).InHours() < kRecentPlanPaymentHours;
+  }
+
   virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {
     DCHECK(network);
     if (!EnsureCrosLoaded() || !network)
       return;
     // TODO(ers) restore default service type priority ordering?
     if (DisconnectFromNetwork(network->service_path().c_str())) {
       // Update local cache and notify listeners.
       if (network->type() == TYPE_WIFI) {
         WifiNetwork* wifi = GetWirelessNetworkByPath(
             wifi_networks_, network->service_path());
@@ skipping 466 matching lines @@
 
     wifi_ = wifi2;
 
     STLDeleteElements(&cellular_networks_);
     cellular_networks_.clear();
 
     CellularNetwork* cellular1 = new CellularNetwork();
     cellular1->set_service_path("fc1");
     cellular1->set_name("Fake Cellular 1");
     cellular1->set_strength(70);
-    cellular1->set_connected(true);
+    cellular1->set_connected(false);
     cellular1->set_activation_state(ACTIVATION_STATE_ACTIVATED);
     cellular1->set_payment_url(std::string("http://www.google.com"));
     cellular1->set_network_technology(NETWORK_TECHNOLOGY_EVDO);
 
     CellularDataPlan* base_plan = new CellularDataPlan();
     base_plan->plan_name = "Base plan";
     base_plan->plan_type = CELLULAR_DATA_PLAN_METERED_BASE;
     base_plan->plan_data_bytes = 100ll * 1024 * 1024;
     base_plan->data_bytes_used = 75ll * 1024 * 1024;
     cellular1->data_plans_.push_back(base_plan);
@@ skipping 126 matching lines @@
           BrowserThread::UI, FROM_HERE,
           NewRunnableMethod(this,
                             &NetworkLibraryImpl::UpdateNetworkStatus,
                             path, key, value));
       return;
     }
 
     bool boolval = false;
     int intval = 0;
     std::string stringval;
-    Network* network;
+    Network* network = NULL;
     if (ethernet_->service_path() == path) {
       network = ethernet_;
     } else {
       CellularNetwork* cellular =
           GetWirelessNetworkByPath(cellular_networks_, path);
       WifiNetwork* wifi =
           GetWirelessNetworkByPath(wifi_networks_, path);
       if (cellular == NULL && wifi == NULL)
         return;
 
-      WirelessNetwork* wireless;
+      WirelessNetwork* wireless = NULL;
       if (wifi != NULL)
         wireless = static_cast<WirelessNetwork*>(wifi);
       else
         wireless = static_cast<WirelessNetwork*>(cellular);
 
       if (strcmp(key, kSignalStrengthProperty) == 0) {
         if (value->GetAsInteger(&intval))
           wireless->set_strength(intval);
       } else if (cellular != NULL) {
         if (strcmp(key, kConnectivityStateProperty) == 0) {
@@ skipping 22 matching lines @@
     } else if (strcmp(key, kIsActiveProperty) == 0) {
       if (value->GetAsBoolean(&boolval))
         network->set_active(boolval);
     } else if (strcmp(key, kStateProperty) == 0) {
       if (value->GetAsString(&stringval)) {
         network->set_state(ParseState(stringval));
         // State changed, so refresh IP address.
         network->InitIPAddress();
       }
     }
-    NotifyNetworkChanged(network);
+    if (network)
+      NotifyNetworkChanged(network);
   }
 
   void UpdateCellularDataPlan(const CellularDataPlanList* data_plans) {
     DCHECK(cellular_);
     cellular_->SetDataPlans(data_plans);
     NotifyCellularDataPlanChanged();
   }
 
   void ClearNetworks() {
     if (ethernet_)
@@ skipping 53 matching lines @@
 
   // True if we are currently scanning for wifi networks.
   bool wifi_scanning_;
 
   // Currently not implemented. TODO: implement or eliminate.
   bool offline_mode_;
 
   // 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) {
@@ skipping 63 matching lines @@
                                     const std::string& password,
                                     const std::string& identity,
                                     const std::string& certpath,
                                     bool auto_connect) {
     return true;
   }
   virtual bool ConnectToCellularNetwork(const CellularNetwork* network) {
     return true;
   }
   virtual void RefreshCellularDataPlans(const CellularNetwork* network) {}
+  virtual void SignalCellularPlanPayment() {}
+  virtual bool HasRecentCellularPlanPayment() { return false; }
   virtual void DisconnectFromWirelessNetwork(const WirelessNetwork* network) {}
   virtual void SaveCellularNetwork(const CellularNetwork* network) {}
   virtual void SaveWifiNetwork(const WifiNetwork* network) {}
   virtual void ForgetWifiNetwork(const std::string& service_path) {}
   virtual bool ethernet_available() const { return true; }
   virtual bool wifi_available() const { return false; }
   virtual bool cellular_available() const { return false; }
   virtual bool ethernet_enabled() const { return true; }
   virtual bool wifi_enabled() const { return false; }
   virtual bool cellular_enabled() const { return false; }
@@ skipping 26 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);