cashew: reset local counter on plan transition

src/data_plan.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.
 
 // TODO(vlaviano): update accessor style (GetFoo/SetFoo -> foo)
 
 #ifndef SRC_DATA_PLAN_H_
 #define SRC_DATA_PLAN_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include <base/basictypes.h>  // NOLINT
 #include <base/time.h>  // NOLINT
 #include <dbus-c++/dbus.h>  // NOLINT
 
 #include "src/values.h"
 
 namespace cashew {
 
 class DataPlan;
+class Device;
 class Policy;
+class Service;
+class ServiceManager;
 
 // byte count
 // TODO(vlaviano): this should be a uint64, but libcros/Chrome expects this
 typedef int64 Bytes;

[Eric Shienbrood, 2011/02/10 18:47:00]

Would "ByteCount" be a better name for this? "Bytes" sounds like something you'd
use to refer to an array of bytes.

[Vince Laviano, 2011/02/10 22:29:19]

Done.

 
 // List of DataPlan objects
 // TODO(vlaviano): consider promoting this from a typedef to a class
 typedef std::vector<DataPlan*> DataPlanList;
 
 // DataPlan object formatted for D-Bus (using DBus::Variants to wrap fields)
 typedef std::map<std::string, DBus::Variant> DBusDataPlan;
 
 // List of DataPlan objects formatted for D-Bus
 typedef std::vector<DBusDataPlan> DBusDataPlanList;
@@ skipping 60 matching lines @@
     // returns true on success and false on failure
     // |time_out| must not be NULL and is set on a successful return
     static bool TimeFromIso8601(const std::string& time_8601,
                                 base::Time *time_out,
                                 bool zoneless_strings_are_local);
 
     // returns first active plan in |data_plans|
     // returns NULL if list is empty or contains no active plans
     static DataPlan* GetActivePlan(const DataPlanList& data_plans);
 
+    // event handler for |service's| local byte counter on |device|
+    // updates active plans in |data_plans| based on the |rx_bytes| and
+    //   |tx_bytes| values gathered during the most recent sample interval
+    // notifies |service_manager| if an active plan is completely consumed
+    // returns true if any plans were updated and false otherwise
+    // |data_plans|, |service|, |service_manager| and |device| must not be NULL
+    static bool OnByteCounterUpdate(DataPlanList *data_plans, Service *service,
+                                    ServiceManager *service_manager,
+                                    Device *device, uint64 rx_bytes,
+                                    uint64 tx_bytes);
+
   private:
     // human-readable plan name
     const std::string name_;
 
     // plan type
     const Type type_;
 
     // last update time (i.e., how fresh is plan data)
     // this refers to carrier API data, not local measurements
     base::Time update_time_;
@@ skipping 36 matching lines @@
     static bool GetInt64FromDictionary(const DictionaryValue& dict,
                                        const std::string& key,
                                        int64* out_value);
 
     DISALLOW_COPY_AND_ASSIGN(DataPlan);
 };
 
 }  // namespace cashew
 
 #endif  // SRC_DATA_PLAN_H_