Reimplement MonitorCellularDataPlan without Libcros

chrome/browser/chromeos/cros/cros_network_functions_unittest.cc

 // Copyright (c) 2012 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 "base/bind.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/cros/cros_network_functions.h"
 #include "chrome/browser/chromeos/cros/gvalue_util.h"
 #include "chrome/browser/chromeos/cros/mock_chromeos_network.h"
@@ skipping 951 matching lines @@
   CrosNetworkWatcher* watcher = CrosMonitorNetworkDeviceProperties(
       callback, path.value());
   // Call callback.
   handler.Run(key, value);
   // Stop monitoring.
   EXPECT_CALL(*mock_device_client_,
               ResetPropertyChangedHandler(path)).Times(1);
   delete watcher;
 }
 
+TEST_F(CrosNetworkFunctionsTest, CrosMonitorCellularDataPlan) {
+  const std::string modem_service_path = "/modem/path";
+  const int64 kUpdateTime = 123456;
+  const int64 kPlanStartTime = 234567;
+  const int64 kPlanEndTime = 345678;
+
+  CellularDataPlan* data_plan = new CellularDataPlan;
+  CellularDataPlanVector data_plans;
+  data_plan->plan_name = "plan name";
+  data_plan->plan_type = CELLULAR_DATA_PLAN_METERED_PAID;
+  data_plan->update_time = base::Time::FromInternalValue(kUpdateTime);
+  data_plan->plan_start_time = base::Time::FromInternalValue(kPlanStartTime);
+  data_plan->plan_end_time = base::Time::FromInternalValue(kPlanEndTime);
+  data_plan->plan_data_bytes = 1024*1024;
+  data_plan->data_bytes_used = 12345;
+  data_plans.push_back(data_plan);
+
+  base::DictionaryValue* data_plan_dictionary = new base::DictionaryValue;
+  data_plan_dictionary->SetWithoutPathExpansion(
+      cashew::kCellularPlanNameProperty,
+      base::Value::CreateStringValue(data_plan->plan_name));
+  data_plan_dictionary->SetWithoutPathExpansion(
+      cashew::kCellularPlanTypeProperty,
+      base::Value::CreateStringValue(cashew::kCellularDataPlanMeteredPaid));
+  data_plan_dictionary->SetWithoutPathExpansion(
+      cashew::kCellularPlanUpdateTimeProperty,
+      base::Value::CreateDoubleValue(kUpdateTime));
+  data_plan_dictionary->SetWithoutPathExpansion(
+      cashew::kCellularPlanStartProperty,
+      base::Value::CreateDoubleValue(kPlanStartTime));
+  data_plan_dictionary->SetWithoutPathExpansion(
+      cashew::kCellularPlanEndProperty,
+      base::Value::CreateDoubleValue(kPlanEndTime));
+  data_plan_dictionary->SetWithoutPathExpansion(
+      cashew::kCellularPlanDataBytesProperty,
+      base::Value::CreateDoubleValue(data_plan->plan_data_bytes));
+  data_plan_dictionary->SetWithoutPathExpansion(
+      cashew::kCellularDataBytesUsedProperty,
+      base::Value::CreateDoubleValue(data_plan->data_bytes_used));
+
+  base::ListValue data_plans_list;
+  data_plans_list.Append(data_plan_dictionary);
+
+  // Set expectations.
+  DataPlanUpdateWatcherCallback callback =
+      MockDataPlanUpdateWatcherCallback::CreateCallback(modem_service_path,
+                                                        data_plans);
+  CashewClient::DataPlansUpdateHandler arg_callback;
+  EXPECT_CALL(*mock_cashew_client_, SetDataPlansUpdateHandler(_))
+      .WillOnce(SaveArg<0>(&arg_callback));
+
+  // Start monitoring.
+  CrosNetworkWatcher* watcher = CrosMonitorCellularDataPlan(callback);
+
+  // Run callback.
+  arg_callback.Run(modem_service_path, data_plans_list);
+
+  // Stop monitoring.
+  EXPECT_CALL(*mock_cashew_client_, ResetDataPlansUpdateHandler()).Times(1);
+  delete watcher;
+}
+
 TEST_F(CrosNetworkFunctionsTest, CrosRequestNetworkManagerProperties) {
   const std::string key1 = "key1";
   const std::string value1 = "value1";
   const std::string key2 = "key.2.";
   const std::string value2 = "value2";
   // Create result value.
   base::DictionaryValue result;
   result.SetWithoutPathExpansion(key1, base::Value::CreateStringValue(value1));
   result.SetWithoutPathExpansion(key2, base::Value::CreateStringValue(value2));
   // Set expectations.
@@ skipping 250 matching lines @@
   const std::string string2 = "string2";
   base::DictionaryValue value;
   value.SetString(key1, string1);
   value.SetString(key2, string2);
   EXPECT_CALL(*mock_manager_client_, ConfigureService(IsEqualTo(&value), _))
       .Times(1);
   CrosConfigureService(value);
 }
 
 }  // namespace chromeos