cashew: add local byte counters

src/data_plan.cc

 // 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.
 
 #include "src/data_plan.h"
 
 #include <time.h>
 
 #include <glog/logging.h>
 
@@ skipping 30 matching lines @@
 static const char *kCrosUsageDataPlanTypeUnlimited = "UNLIMITED";
 static const char *kCrosUsageDataPlanTypeMeteredFree = "METERED_FREE";
 static const char *kCrosUsageDataPlanTypeMeteredPaid = "METERED_PAID";
 
 DataPlan::DataPlan(const std::string& name, DataPlan::Type type,
                    base::Time update_time, base::Time start_time,
                    base::Time end_time, Bytes data_bytes_max,
                    Bytes data_bytes_used)
     : name_(name), type_(type), update_time_(update_time),
       start_time_(start_time), end_time_(end_time),
-      data_bytes_max_(data_bytes_max), data_bytes_used_(data_bytes_used) {
+      data_bytes_max_(data_bytes_max), data_bytes_used_(data_bytes_used),
+      local_bytes_used_(0) {
 }
 
 DataPlan::~DataPlan() {
 }
 
 const std::string& DataPlan::GetName() const {
   return name_;
 }
 
 DataPlan::Type DataPlan::GetType() const {
@@ skipping 13 matching lines @@
 }
 
 Bytes DataPlan::GetDataBytesMax() const {
   return data_bytes_max_;
 }
 
 Bytes DataPlan::GetDataBytesUsed() const {
   return data_bytes_used_;
 }
 
+Bytes DataPlan::GetLocalBytesUsed() const {
+  return local_bytes_used_;
+}
+
+void DataPlan::SetLocalBytesUsed(Bytes local_bytes_used) {
+  CHECK_GE(local_bytes_used, 0);
+  local_bytes_used_ = local_bytes_used;
+}
+
+bool DataPlan::IsActive() const {
+  // is the plan current?
+  base::Time now = base::Time::Now();
+  if (now < start_time_ || now >= end_time_) {
+    return false;
+  }
+  // is the plan exhausted?
+  if (type_ != kTypeUnlimited && data_bytes_used_ >= data_bytes_max_) {
+    return false;
+  }
+  return true;
+}
+
 DBusDataPlan DataPlan::ToDBusFormat() const {
   DBusDataPlan plan;
   // Indexing into map w/ nonexistent key causes empty DBus::Variant to be
   // created and inserted. We then fill in the desired value via its writer
   // DBus::MessageIter.
   plan[kCellularDataPlanName].writer().append_string(name_.c_str());
   plan[kCellularDataPlanType].writer().append_string(
       TypeToLibcrosString(type_));
   plan[kCellularDataPlanUpdateTime].writer().append_int64(
       update_time_.ToInternalValue());
   plan[kCellularDataPlanStartTime].writer().append_int64(
       start_time_.ToInternalValue());
   plan[kCellularDataPlanEndTime].writer().append_int64(
       end_time_.ToInternalValue());
   // omit max bytes field for unlimited plans
   if (type_ != kTypeUnlimited) {
     plan[kCellularDataPlanDataBytesMax].writer().append_int64(data_bytes_max_);
   }
-  // always send used bytes field, even if we had to assume a value of 0
-  // because this is an unlimited plan and the property was absent in the
-  // usage API replies that we received
-  // TODO(vlaviano): we'll be able to do better when we have local counters
-  plan[kCellularDataPlanDataBytesUsed].writer().append_int64(data_bytes_used_);
+  // send our best estimate of data bytes used
+  // this is the baseline, if any, that we received from the carrier usage API
+  // plus any local traffic that we've measured since then
+  Bytes total_bytes_used = data_bytes_used_ + local_bytes_used_;
+  plan[kCellularDataPlanDataBytesUsed].writer().append_int64(total_bytes_used);
   return plan;
 }
 
 // static
 DataPlan* DataPlan::FromDictionaryValue(const DictionaryValue *value,
                                         const Policy *policy) {
   CHECK_NOTNULL(value);
   CHECK_NOTNULL(policy);
   std::string last_update_iso8601;
   if (!value->GetString(kCrosUsageDataPlanLastUpdateProperty,
@@ skipping 143 matching lines @@
       DLOG(WARNING) << "TimeFromIso8601: mktime failed";
       return false;
     }
   }
 
   // convert from time_t to base::Time
   *time_out = base::Time::FromTimeT(tt);
   return true;
 }
 
+// static
+DataPlan* DataPlan::GetActivePlan(const DataPlanList& data_plans) {
+  DataPlanList::const_iterator it;
+  for (it = data_plans.begin(); it != data_plans.end(); ++it) {
+    DataPlan *plan = *it;
+    DCHECK(plan != NULL);
+    if (plan->IsActive()) {
+      return plan;
+    }
+  }
+  return NULL;
+}
+
 // private methods
 
 const char* DataPlan::TypeToLibcrosString(DataPlan::Type type) const {
   switch (type) {
     case kTypeUnlimited:
       return kCellularDataPlanTypeUnlimited;
     case kTypeMeteredFree:
       return kCellularDataPlanTypeMeteredFree;
     case kTypeMeteredPaid:
       return kCellularDataPlanTypeMeteredPaid;
@@ skipping 28 matching lines @@
     *out_value = generic_int_out;
     return true;
   }
   if (dict.GetInteger64(key, out_value)) {
     return true;
   }
   return false;
 }
 
 }  // namespace cashew