cashew: support "usage requests allowed OTA only" policy

src/service.h

 // Copyright (c) 2010 The Chromium OS 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 SRC_SERVICE_H_
 #define SRC_SERVICE_H_
 
 #include <glib.h>
 
 #include <map>
@@ skipping 52 matching lines @@
       kTypeWifi,
       kTypeWimax,
       kTypeBluetooth,
       kTypeCellular,
     } Type;
 
     // get type for this service
     // NOTE: for now, should always be kTypeCellular
     virtual Type GetType() const;
 
+    // convert type string to Type enum value
+    static Type TypeFromString(const std::string& type);
+
     // get Device object for this service
     // this can return NULL if we don't yet have Device info
     virtual Device* GetDevice() const;
 
     // get data plan info, formatted for D-Bus
     virtual DBusDataPlanList GetDBusDataPlans() const;
 
+    // do we think that we're the default service at this time?
+    virtual bool IsDefaultService() const;
+
     // Flimflam Service D-Bus Proxy methods
 
     // receive incoming PropertyChanged D-Bus signal from Flimflam service
     virtual void PropertyChanged(const std::string& property_name,
                                  const DBus::Variant& new_value);
 
     // Device methods
 
     // we've received updated Cellular.Carrier info from our child Device
     virtual void OnCarrierUpdate(const std::string& carrier);
 
     // DataPlanProviderDelegate methods
 
     // a request to our carrier usage API proxy has completed
     virtual void OnRequestComplete(const DataPlanProvider *provider,
                                    bool successful,
                                    const Value *parsed_usage_update);
 
+    // Service Manager methods
+
+    // we've received an update from our parent about whether or not we're the
+    // default service
+    virtual void OnDefaultServiceUpdate(bool is_default_service);
+
+    // we've received an update from our parent that Flimflam has come online
+    virtual void OnFlimflamOnline();
+
+    // we've received an update from our parent that Flimflam has gone offline
+    virtual void OnFlimflamOffline();
+
   private:
     // back pointer to our parent ServiceManager
     ServiceManager * const parent_;
 
     // D-Bus connection, owned by our creator
     // shared with Device obj that we create
     DBus::Connection& connection_;
 
     // D-Bus path for Flimflam service that we represent
     // this is our unique identifier
@@ skipping 20 matching lines @@
 
     // do we have an outstanding usage API request
     bool request_in_progress_;
 
     // periodic update timeout
     GSource *update_timeout_source_;
 
     // carrier policy
     Policy *policy_;
 
+    // do we think that we're the default service?
+    bool is_default_service_;
+
     // convert state string to State enum value
     State StateFromString(const std::string& state) const;
 
-    // convert type string to Type enum value
-    Type TypeFromString(const std::string& type) const;
-
     // we've received updated Device info from Flimflam
     void OnDeviceUpdate(const DBus::Path& device_path);
 
     // we've received updated State info from Flimflam
     void OnStateUpdate(const std::string& state);
 
     // we've received updated Type info from Flimflam
     void OnTypeUpdate(const std::string& type);
 
     // we've received updated Cellular.UsageUrl info from Flimflam
@@ skipping 35 matching lines @@
     // this also destroys the update timer and cancels pending requests
     // NOTE: this does not delete usage url (it's considered service state)
     void DeleteCarrierState();
 
     // does |status| contain a valid usage API status result string?
     bool IsValidCrosUsageStatus(const std::string& status) const;
 
     // usage API request returned an error result
     void OnCrosUsageErrorResult(const std::string& status);
 
+    // do we think that we're connected at this time?
+    bool IsConnected() const;
+
+    // we've just become connected
+    void OnConnected();
+
+    // we've just become disconnected
+    // NOTE: this means we've entered a state other than kStateReady, not
+    // that we're necessarily in kStateDisconnect
+    void OnDisconnected();
+
+    // are we currently sending periodic usage API requests?
+    bool IsSendingUsageRequests() const;
+
+    // based on our best current knowledge and our policy, should we be
+    // sending periodic usage API requests?
+    bool ShouldSendUsageRequests() const;
+
+    // stop sending periodic usage API requests
+    void StopSendingUsageRequests();
+
+    // start sending periodic usage API requests
+    void StartSendingUsageRequests();
+
+    // something has changed, so reevaluate whether or not we should be sending
+    // periodic usage API requests and adjust our behavior if necessary
+    void ReconsiderSendingUsageRequests();
+
     DISALLOW_COPY_AND_ASSIGN(Service);
 };
 
 }  // namespace cashew
 
 #endif  // SRC_SERVICE_H_