Amortize data usage using TrafficStats on Android.

components/data_usage/core/data_use_aggregator_unittest.cc

 // Copyright 2015 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 "components/data_usage/core/data_use_aggregator.h"
 
 #include <stdint.h>
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/time/time.h"
 #include "components/data_usage/core/data_use.h"
+#include "components/data_usage/core/data_use_amortizer.h"
 #include "components/data_usage/core/data_use_annotator.h"
 #include "net/base/load_timing_info.h"
 #include "net/base/network_change_notifier.h"
 #include "net/base/network_delegate_impl.h"
 #include "net/socket/socket_test_util.h"
 #include "net/url_request/url_request.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace data_usage {
 
 namespace {
 
 base::TimeTicks GetRequestStart(const net::URLRequest& request) {
   net::LoadTimingInfo load_timing_info;
   request.GetLoadTimingInfo(&load_timing_info);
   return load_timing_info.request_start;
 }
 
 // Test class that can set the network operator's MCCMNC.
 class TestDataUseAggregator : public DataUseAggregator {
  public:
-  TestDataUseAggregator(scoped_ptr<DataUseAnnotator> annotator)
-      : DataUseAggregator(annotator.Pass()) {}
+  TestDataUseAggregator(scoped_ptr<DataUseAnnotator> annotator,
+                        scoped_ptr<DataUseAmortizer> amortizer)
+      : DataUseAggregator(annotator.Pass(), amortizer.Pass()) {}
 
   ~TestDataUseAggregator() override {}
 
  private:
   friend class TestNetworkChangeNotifier;
   using DataUseAggregator::OnConnectionTypeChanged;
   using DataUseAggregator::SetMccMncForTests;
 };
 
 // Override NetworkChangeNotifier to simulate connection type changes for tests.
@@ skipping 154 matching lines @@
   int on_data_use_called_count_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
 class DataUseAggregatorTest : public testing::Test {
  public:
   DataUseAggregatorTest()
       : fake_data_use_annotator_(new FakeDataUseAnnotator()),
         data_use_aggregator_(
-            scoped_ptr<DataUseAnnotator>(fake_data_use_annotator_)),
+            scoped_ptr<DataUseAnnotator>(fake_data_use_annotator_),
+            // TODO(sclittle): Add a test for a non-NULL DataUseAmortizer.
+            scoped_ptr<DataUseAmortizer>()),
         test_network_change_notifier_(&data_use_aggregator_),
         reporting_network_delegate_(&data_use_aggregator_,
                                     fake_data_use_annotator_,
                                     &test_network_change_notifier_),
         context_(true),
         test_observer_(&data_use_aggregator_) {
     context_.set_client_socket_factory(&mock_socket_factory_);
     context_.set_network_delegate(&reporting_network_delegate_);
     context_.Init();
   }
@@ skipping 107 matching lines @@
     EXPECT_EQ(kBarMccMnc, data_use_it->mcc_mnc);
 
     observed_bar_tx_bytes += data_use_it->tx_bytes;
     observed_bar_rx_bytes += data_use_it->rx_bytes;
     ++data_use_it;
   }
   EXPECT_EQ(bar_request->GetTotalSentBytes(), observed_bar_tx_bytes);
   EXPECT_EQ(bar_request->GetTotalReceivedBytes(), observed_bar_rx_bytes);
 }
 
-TEST_F(DataUseAggregatorTest, ReportCombinedDataUse) {
-  // Set up the |foo_request|.
-  net::MockRead foo_reads[] = {
-      net::MockRead(net::SYNCHRONOUS, "HTTP/1.1 200 OK\r\n\r\n"),
-      net::MockRead(net::SYNCHRONOUS, "hello world"),
-      net::MockRead(net::SYNCHRONOUS, net::OK),
-  };
-  net::StaticSocketDataProvider foo_socket(foo_reads, arraysize(foo_reads),
-                                           nullptr, 0);
-  mock_socket_factory()->AddSocketDataProvider(&foo_socket);
-
-  net::TestDelegate foo_delegate;
-  scoped_ptr<net::URLRequest> foo_request = context()->CreateRequest(
-      GURL("http://foo.com"), net::IDLE, &foo_delegate);
-  foo_request->set_first_party_for_cookies(GURL("http://foofirstparty.com"));
-
-  // Set up the |bar_request|.
-  net::MockRead bar_reads[] = {
-      net::MockRead(net::SYNCHRONOUS, "HTTP/1.1 200 OK\r\n\r\n"),
-      net::MockRead(net::SYNCHRONOUS, "hello world"),
-      net::MockRead(net::SYNCHRONOUS, net::OK),
-  };
-  net::StaticSocketDataProvider bar_socket(bar_reads, arraysize(bar_reads),
-                                           nullptr, 0);
-  mock_socket_factory()->AddSocketDataProvider(&bar_socket);
-
-  net::TestDelegate bar_delegate;
-  scoped_ptr<net::URLRequest> bar_request = context()->CreateRequest(
-      GURL("http://bar.com"), net::IDLE, &bar_delegate);
-  bar_request->set_first_party_for_cookies(GURL("http://barfirstparty.com"));
-
-  // Set up the network delegate to assign tab IDs and connection types for each
-  // request.
-  const int32_t kFooTabId = 10;
-  const net::NetworkChangeNotifier::ConnectionType kFooConnectionType =
-      net::NetworkChangeNotifier::CONNECTION_2G;
-  const std::string kFooMccMnc = "foo_mcc_mnc";
-  const int32_t kBarTabId = 20;
-  const net::NetworkChangeNotifier::ConnectionType kBarConnectionType =
-      net::NetworkChangeNotifier::CONNECTION_WIFI;
-  const std::string kBarMccMnc = "bar_mcc_mnc";
-
-  ReportingNetworkDelegate::DataUseContextMap data_use_context_map;
-  data_use_context_map[foo_request.get()] =
-      ReportingNetworkDelegate::DataUseContext(kFooTabId, kFooConnectionType,
-                                               kFooMccMnc);
-  data_use_context_map[bar_request.get()] =
-      ReportingNetworkDelegate::DataUseContext(kBarTabId, kBarConnectionType,
-                                               kBarMccMnc);
-  reporting_network_delegate()->set_data_use_context_map(data_use_context_map);
-
-  // Run the requests.
-  foo_request->Start();
-  bar_request->Start();
-  base::MessageLoop::current()->RunUntilIdle();
-
-  // The observer should have been notified once with a DataUse element for each
-  // request.
-  EXPECT_EQ(1, test_observer()->on_data_use_called_count());
-  EXPECT_EQ(static_cast<size_t>(2),
-            test_observer()->observed_data_use().size());
-
-  // All of the |foo_request| DataUse should have been combined into a single
-  // DataUse element.
-  const DataUse& foo_data_use = test_observer()->observed_data_use().front();
-  EXPECT_EQ(GURL("http://foo.com"), foo_data_use.url);
-  EXPECT_EQ(GetRequestStart(*foo_request), foo_data_use.request_start);
-  EXPECT_EQ(GURL("http://foofirstparty.com"),
-            foo_data_use.first_party_for_cookies);
-  EXPECT_EQ(kFooTabId, foo_data_use.tab_id);
-  EXPECT_EQ(kFooConnectionType, foo_data_use.connection_type);
-  EXPECT_EQ(kFooMccMnc, foo_data_use.mcc_mnc);
-  EXPECT_EQ(foo_request->GetTotalSentBytes(), foo_data_use.tx_bytes);
-  EXPECT_EQ(foo_request->GetTotalReceivedBytes(), foo_data_use.rx_bytes);
-
-  // All of the |bar_request| DataUse should have been combined into a single
-  // DataUse element.
-  const DataUse& bar_data_use = test_observer()->observed_data_use().back();
-  EXPECT_EQ(GURL("http://bar.com"), bar_data_use.url);
-  EXPECT_EQ(GetRequestStart(*bar_request), bar_data_use.request_start);
-  EXPECT_EQ(GURL("http://barfirstparty.com"),
-            bar_data_use.first_party_for_cookies);
-  EXPECT_EQ(kBarTabId, bar_data_use.tab_id);
-  EXPECT_EQ(kBarConnectionType, bar_data_use.connection_type);
-  EXPECT_EQ(kBarMccMnc, bar_data_use.mcc_mnc);
-  EXPECT_EQ(bar_request->GetTotalSentBytes(), bar_data_use.tx_bytes);
-  EXPECT_EQ(bar_request->GetTotalReceivedBytes(), bar_data_use.rx_bytes);
-}
-
 TEST_F(DataUseAggregatorTest, ReportOffTheRecordDataUse) {
   // Off the record data use should not be reported to observers.
   data_use_aggregator()->ReportOffTheRecordDataUse(1000, 1000);
   base::MessageLoop::current()->RunUntilIdle();
   EXPECT_EQ(static_cast<size_t>(0),
             test_observer()->observed_data_use().size());
 }
 
 }  // namespace
 
 }  // namespace data_usage