Update icons to show lowdata and very lowdata for 3G data....

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 "app/l10n_util.h"
 #include "base/string_number_conversions.h"
@@ skipping 246 matching lines @@
     prl_version_ = service.device_info->PRL_version;
   }
 }
 
 bool CellularNetwork::is_gsm() const {
   return network_technology_ != NETWORK_TECHNOLOGY_EVDO &&
       network_technology_ != NETWORK_TECHNOLOGY_1XRTT &&
       network_technology_ != NETWORK_TECHNOLOGY_UNKNOWN;
 }
 
+CellularNetwork::DataLeft CellularNetwork::data_left() const {
+  if (data_plans_.empty())
+    return DATA_NORMAL;
+  CellularDataPlan plan = data_plans_[0];
+  if (plan.plan_type == CELLULAR_DATA_PLAN_UNLIMITED) {
+    int64 remaining = plan.plan_end_time - plan.update_time;
+    if (remaining <= 0)
+      return DATA_NONE;
+    else if (remaining <= kCellularDataVeryLowSecs)
+      return DATA_VERY_LOW;
+    else if (remaining <= kCellularDataLowSecs)
+      return DATA_LOW;
+    else
+      return DATA_NORMAL;
+  } else if (plan.plan_type == CELLULAR_DATA_PLAN_METERED_PAID ||
+             plan.plan_type == CELLULAR_DATA_PLAN_METERED_BASE) {
+    int64 remaining = plan.plan_data_bytes - plan.data_bytes_used;
+    if (remaining <= 0)
+      return DATA_NONE;
+    else if (remaining <= kCellularDataVeryLowBytes)
+      return DATA_VERY_LOW;
+    else if (remaining <= kCellularDataLowBytes)
+      return DATA_LOW;
+    else
+      return DATA_NORMAL;
+  }
+  return DATA_NORMAL;
+}
+
 std::string CellularNetwork::GetNetworkTechnologyString() const {
   // No need to localize these cellular technology abbreviations.
   switch (network_technology_) {
     case NETWORK_TECHNOLOGY_1XRTT:
       return "1xRTT";
       break;
     case NETWORK_TECHNOLOGY_EVDO:
       return "EVDO";
       break;
     case NETWORK_TECHNOLOGY_GPRS:
@@ skipping 712 matching lines @@
     test_plan.plan_start_time =
         (base::Time::Now() - base::TimeDelta::FromDays(15)).ToInternalValue() /
             base::Time::kMicrosecondsPerSecond;
     test_plan.plan_end_time =
         (base::Time::Now() + base::TimeDelta::FromDays(12)).ToInternalValue() /
             base::Time::kMicrosecondsPerSecond;
     test_plan.plan_data_bytes = 20LL * 1024LL * 1024LL * 1024LL;
     test_plan.plan_type = CELLULAR_DATA_PLAN_METERED_PAID;
     test_plan.update_time = base::Time::Now().ToInternalValue() /
         base::Time::kMicrosecondsPerSecond;
-    cellular_data_plans_.push_back(test_plan);
+    chromeos::CellularDataPlanList test_plans;
+    test_plans.push_back(test_plan);
+    cellular_.SetDataPlans(test_plans);
   }
 
   void UpdateSystemInfo() {
     if (CrosLibrary::Get()->EnsureLoaded()) {
       UpdateNetworkStatus();
     }
   }
 
   WifiNetwork* GetWifiNetworkByName(const std::string& name) {
     for (size_t i = 0; i < wifi_networks_.size(); ++i) {
@@ skipping 38 matching lines @@
     }
 
     EnableNetworkDevice(device, enable);
   }
 
   void NotifyNetworkChanged() {
     FOR_EACH_OBSERVER(Observer, observers_, NetworkChanged(this));
   }
 
   void NotifyCellularDataPlanChanged() {
-    FOR_EACH_OBSERVER(Observer, observers_,
-        CellularDataPlanChanged(cellular_.service_path(),
-                                cellular_data_plans_));
+    FOR_EACH_OBSERVER(Observer, observers_, CellularDataPlanChanged(this));
   }
 
   void UpdateNetworkStatus() {
     // Make sure we run on UI thread.
     if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
       BrowserThread::PostTask(
           BrowserThread::UI, FROM_HERE,
           NewRunnableMethod(this,
                             &NetworkLibraryImpl::UpdateNetworkStatus));
       return;
@@ skipping 35 matching lines @@
     available_devices_ = system->available_technologies;
     enabled_devices_ = system->enabled_technologies;
     connected_devices_ = system->connected_technologies;
     offline_mode_ = system->offline_mode;
 
     NotifyNetworkChanged();
     FreeSystemInfo(system);
   }
 
   void UpdateCellularDataPlan(const CellularDataPlanList& data_plans) {
-    cellular_data_plans_ = data_plans;
+    cellular_.SetDataPlans(data_plans);
     NotifyCellularDataPlanChanged();
   }
 
   ObserverList<Observer> observers_;
 
   // The network status connection for monitoring network status changes.
   MonitorNetworkConnection network_status_connection_;
 
   // For monitoring data plan changes to the connected cellular network.
   DataPlanUpdateMonitor data_plan_monitor_;
 
   // The ethernet network.
   EthernetNetwork ethernet_;
 
   // The list of available wifi networks.
   WifiNetworkVector wifi_networks_;
 
   // The current connected (or connecting) wifi network.
   WifiNetwork wifi_;
 
   // The remembered wifi networks.
   WifiNetworkVector remembered_wifi_networks_;
 
   // The list of available cellular networks.
   CellularNetworkVector cellular_networks_;
 
   // The current connected (or connecting) cellular network.
   CellularNetwork cellular_;
 
-  // The data plan for the current cellular network.
-  CellularDataPlanList cellular_data_plans_;
-
   // The remembered cellular networks.
   CellularNetworkVector remembered_cellular_networks_;
 
   // The current available network devices. Bitwise flag of ConnectionTypes.
   int available_devices_;
 
   // The current enabled network devices. Bitwise flag of ConnectionTypes.
   int enabled_devices_;
 
   // The current connected network devices. Bitwise flag of ConnectionTypes.
@@ skipping 100 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);