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 <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "components/data_usage/core/data_use.h"
+#include "components/data_usage/core/data_use_amortizer.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 {
 
@@ skipping 75 matching lines @@
     return observed_data_use_;
   }
 
  private:
   DataUseAggregator* data_use_aggregator_;
   std::vector<DataUse> observed_data_use_;
 
   DISALLOW_COPY_AND_ASSIGN(TestObserver);
 };
 
+// An amortizer that doubles all byte counts it sees.
+class DoublingAmortizer : public DataUseAmortizer {
+ public:
+  DoublingAmortizer() {}
+  ~DoublingAmortizer() override {}
+
+  void Amortize(std::vector<DataUse>* data_use_sequence,
+                int64_t extra_tx_bytes,
+                int64_t extra_rx_bytes) override {
+    for (DataUse& data_use : *data_use_sequence) {
+      data_use.tx_bytes *= 2;
+      data_use.rx_bytes *= 2;
+    }
+  }
+};
+
 class DataUseAggregatorTest : public testing::Test {
  public:
-  DataUseAggregatorTest()
-      : reporting_network_delegate_(&data_use_aggregator_),
-        context_(true),
-        test_observer_(&data_use_aggregator_) {
-    context_.set_client_socket_factory(&mock_socket_factory_);
-    context_.set_network_delegate(&reporting_network_delegate_);
-    context_.Init();
+  DataUseAggregatorTest() {}
+  ~DataUseAggregatorTest() override {}
+
+  void Initialize(scoped_ptr<DataUseAmortizer> data_use_amortizer) {
+    // Ensure that nothing outlives the |data_use_aggregator_|.
+    test_observer_.reset();
+    context_.reset();
+    reporting_network_delegate_.reset();
+    mock_socket_factory_.reset();
+
+    data_use_aggregator_.reset(
+        new DataUseAggregator(data_use_amortizer.Pass()));
+    test_observer_.reset(new TestObserver(data_use_aggregator_.get()));
+
+    context_.reset(new net::TestURLRequestContext(true));
+    mock_socket_factory_.reset(new net::MockClientSocketFactory());
+    context_->set_client_socket_factory(mock_socket_factory_.get());
+    reporting_network_delegate_.reset(
+        new ReportingNetworkDelegate(data_use_aggregator_.get()));
+    context_->set_network_delegate(reporting_network_delegate_.get());
+    context_->Init();
   }
 
-  ~DataUseAggregatorTest() override {}
-
   scoped_ptr<net::URLRequest> ExecuteRequest(
       const GURL& url,
       const GURL& first_party_for_cookies) {
     net::MockRead reads[] = {
         net::MockRead("HTTP/1.1 200 OK\r\n\r\n"), net::MockRead("hello world"),
         net::MockRead(net::SYNCHRONOUS, net::OK),
     };
     net::StaticSocketDataProvider socket(reads, arraysize(reads), nullptr, 0);
-    mock_socket_factory_.AddSocketDataProvider(&socket);
+    mock_socket_factory_->AddSocketDataProvider(&socket);
 
     net::TestDelegate delegate;
     scoped_ptr<net::URLRequest> request =
-        context_.CreateRequest(url, net::IDLE, &delegate);
+        context_->CreateRequest(url, net::IDLE, &delegate);
     request->set_first_party_for_cookies(first_party_for_cookies);
     request->Start();
     loop_.RunUntilIdle();
 
     return request.Pass();
   }
 
   void SimulateNetworkConnectionChange(
       net::NetworkChangeNotifier::ConnectionType connection_type) {
     test_network_change_notifier_.SimulateNetworkConnectionChange(
         connection_type);
   }
 
   void set_tab_id_for_requests(int32_t tab_id_for_requests) {
-    reporting_network_delegate_.set_tab_id_for_requests(tab_id_for_requests);
+    reporting_network_delegate_->set_tab_id_for_requests(tab_id_for_requests);
   }
 
-  DataUseAggregator* data_use_aggregator() { return &data_use_aggregator_; }
+  DataUseAggregator* data_use_aggregator() {
+    return data_use_aggregator_.get();
+  }
 
   const std::vector<DataUse>& observed_data_use() const {
-    return test_observer_.observed_data_use();
+    return test_observer_->observed_data_use();
   }
 
  private:
   base::MessageLoopForIO loop_;
   TestNetworkChangeNotifier test_network_change_notifier_;
 
-  DataUseAggregator data_use_aggregator_;
-  net::MockClientSocketFactory mock_socket_factory_;
-  ReportingNetworkDelegate reporting_network_delegate_;
-  net::TestURLRequestContext context_;
-  TestObserver test_observer_;
+  scoped_ptr<DataUseAggregator> data_use_aggregator_;
+  scoped_ptr<net::MockClientSocketFactory> mock_socket_factory_;
+  scoped_ptr<ReportingNetworkDelegate> reporting_network_delegate_;
+  scoped_ptr<net::TestURLRequestContext> context_;
+  scoped_ptr<TestObserver> test_observer_;
 
   DISALLOW_COPY_AND_ASSIGN(DataUseAggregatorTest);
 };
 
 TEST_F(DataUseAggregatorTest, ReportDataUse) {
-  const net::NetworkChangeNotifier::ConnectionType kFooConnectionType =
-      net::NetworkChangeNotifier::CONNECTION_2G;
-  SimulateNetworkConnectionChange(kFooConnectionType);
-  const int32_t kFooTabId = 10;
-  set_tab_id_for_requests(kFooTabId);
-  const scoped_ptr<net::URLRequest> foo_request =
-      ExecuteRequest(GURL("http://foo.com"), GURL("http://foofirstparty.com"));
+  const bool kBooleans[] = {false, true};
+  for (bool use_doubling_amortizer : kBooleans) {
+    Initialize(use_doubling_amortizer
+                   ? scoped_ptr<DataUseAmortizer>(new DoublingAmortizer())
+                   : scoped_ptr<DataUseAmortizer>());
 
-  const net::NetworkChangeNotifier::ConnectionType kBarConnectionType =
-      net::NetworkChangeNotifier::CONNECTION_WIFI;
-  SimulateNetworkConnectionChange(kBarConnectionType);
-  const int32_t kBarTabId = 20;
-  set_tab_id_for_requests(kBarTabId);
-  scoped_ptr<net::URLRequest> bar_request =
-      ExecuteRequest(GURL("http://bar.com"), GURL("http://barfirstparty.com"));
+    const net::NetworkChangeNotifier::ConnectionType kFooConnectionType =
+        net::NetworkChangeNotifier::CONNECTION_2G;
+    SimulateNetworkConnectionChange(kFooConnectionType);
+    const int32_t kFooTabId = 10;
+    set_tab_id_for_requests(kFooTabId);
+    const scoped_ptr<net::URLRequest> foo_request = ExecuteRequest(
+        GURL("http://foo.com"), GURL("http://foofirstparty.com"));
 
-  auto data_use_it = observed_data_use().begin();
+    const net::NetworkChangeNotifier::ConnectionType kBarConnectionType =
+        net::NetworkChangeNotifier::CONNECTION_WIFI;
+    SimulateNetworkConnectionChange(kBarConnectionType);
+    const int32_t kBarTabId = 20;
+    set_tab_id_for_requests(kBarTabId);
+    scoped_ptr<net::URLRequest> bar_request = ExecuteRequest(
+        GURL("http://bar.com"), GURL("http://barfirstparty.com"));
 
-  // First, the |foo_request| data use should have happened.
-  int64_t observed_foo_tx_bytes = 0, observed_foo_rx_bytes = 0;
-  while (data_use_it != observed_data_use().end() &&
-         data_use_it->url == GURL("http://foo.com")) {
-    EXPECT_EQ(foo_request->request_time(), data_use_it->request_time);
-    EXPECT_EQ(GURL("http://foofirstparty.com"),
-              data_use_it->first_party_for_cookies);
-    EXPECT_EQ(kFooTabId, data_use_it->tab_id);
-    EXPECT_EQ(kFooConnectionType, data_use_it->connection_type);
+    auto data_use_it = observed_data_use().begin();
 
-    observed_foo_tx_bytes += data_use_it->tx_bytes;
-    observed_foo_rx_bytes += data_use_it->rx_bytes;
-    ++data_use_it;
+    // First, the |foo_request| data use should have happened.
+    int64_t observed_foo_tx_bytes = 0, observed_foo_rx_bytes = 0;
+    while (data_use_it != observed_data_use().end() &&
+           data_use_it->url == GURL("http://foo.com")) {
+      EXPECT_EQ(foo_request->request_time(), data_use_it->request_time);
+      EXPECT_EQ(GURL("http://foofirstparty.com"),
+                data_use_it->first_party_for_cookies);
+      EXPECT_EQ(kFooTabId, data_use_it->tab_id);
+      EXPECT_EQ(kFooConnectionType, data_use_it->connection_type);
+
+      observed_foo_tx_bytes += data_use_it->tx_bytes;
+      observed_foo_rx_bytes += data_use_it->rx_bytes;
+      ++data_use_it;
+    }
+    if (use_doubling_amortizer) {
+      EXPECT_EQ(2 * foo_request->GetTotalSentBytes(), observed_foo_tx_bytes);
+      EXPECT_EQ(2 * foo_request->GetTotalReceivedBytes(),
+                observed_foo_rx_bytes);
+    } else {
+      EXPECT_EQ(foo_request->GetTotalSentBytes(), observed_foo_tx_bytes);
+      EXPECT_EQ(foo_request->GetTotalReceivedBytes(), observed_foo_rx_bytes);
+    }
+
+    // Then, the |bar_request| data use should have happened.
+    int64_t observed_bar_tx_bytes = 0, observed_bar_rx_bytes = 0;
+    while (data_use_it != observed_data_use().end()) {
+      EXPECT_EQ(GURL("http://bar.com"), data_use_it->url);
+      EXPECT_EQ(bar_request->request_time(), data_use_it->request_time);
+      EXPECT_EQ(GURL("http://barfirstparty.com"),
+                data_use_it->first_party_for_cookies);
+      EXPECT_EQ(kBarTabId, data_use_it->tab_id);
+      EXPECT_EQ(kBarConnectionType, data_use_it->connection_type);
+
+      observed_bar_tx_bytes += data_use_it->tx_bytes;
+      observed_bar_rx_bytes += data_use_it->rx_bytes;
+      ++data_use_it;
+    }
+    if (use_doubling_amortizer) {
+      EXPECT_EQ(2 * bar_request->GetTotalSentBytes(), observed_bar_tx_bytes);
+      EXPECT_EQ(2 * bar_request->GetTotalReceivedBytes(),
+                observed_bar_rx_bytes);
+    } else {
+      EXPECT_EQ(bar_request->GetTotalSentBytes(), observed_bar_tx_bytes);
+      EXPECT_EQ(bar_request->GetTotalReceivedBytes(), observed_bar_rx_bytes);
+    }
   }
-  EXPECT_EQ(foo_request->GetTotalSentBytes(), observed_foo_tx_bytes);
-  EXPECT_EQ(foo_request->GetTotalReceivedBytes(), observed_foo_rx_bytes);
-
-  // Then, the |bar_request| data use should have happened.
-  int64_t observed_bar_tx_bytes = 0, observed_bar_rx_bytes = 0;
-  while (data_use_it != observed_data_use().end()) {
-    EXPECT_EQ(GURL("http://bar.com"), data_use_it->url);
-    EXPECT_EQ(bar_request->request_time(), data_use_it->request_time);
-    EXPECT_EQ(GURL("http://barfirstparty.com"),
-              data_use_it->first_party_for_cookies);
-    EXPECT_EQ(kBarTabId, data_use_it->tab_id);
-    EXPECT_EQ(kBarConnectionType, data_use_it->connection_type);
-
-    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, ReportOffTheRecordDataUse) {
+  Initialize(scoped_ptr<DataUseAmortizer>(new DoublingAmortizer()));
+
   // 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), observed_data_use().size());
 }
 
 }  // namespace
 
 }  // namespace data_usage