Amortize data usage using TrafficStats on Android.

components/data_usage/android/traffic_stats_amortizer_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/android/traffic_stats_amortizer.h"
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/macros.h"
+#include "base/memory/scoped_ptr.h"
+#include "base/message_loop/message_loop.h"
+#include "base/run_loop.h"
+#include "base/test/simple_test_tick_clock.h"
+#include "base/time/tick_clock.h"
+#include "base/time/time.h"
+#include "base/timer/mock_timer.h"
+#include "base/timer/timer.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 "testing/gtest/include/gtest/gtest.h"
+#include "url/gurl.h"
+
+namespace data_usage {
+namespace android {
+
+namespace {
+
+// The delay between receiving DataUse and querying TrafficStats byte counts for
+// amortization.
+const base::TimeDelta kTrafficStatsQueryDelay =
+    base::TimeDelta::FromMilliseconds(50);
+
+// The longest amount of time that an amortization run can be delayed for.
+const base::TimeDelta kMaxAmortizationDelay =
+    base::TimeDelta::FromMilliseconds(200);
+
+// The maximum allowed size of the DataUse buffer.
+const size_t kMaxDataUseBufferSize = 8;
+
+// Synthesizes a fake scoped_ptr<DataUse> with the given |tx_bytes| and
+// |rx_bytes|, using arbitrary values for all other fields.
+scoped_ptr<DataUse> CreateDataUse(int64_t tx_bytes, int64_t rx_bytes) {
+  return scoped_ptr<DataUse>(new DataUse(
+      GURL("http://example.com"), base::TimeTicks() /* request_start */,
+      GURL("http://examplefirstparty.com"), 10 /* tab_id */,
+      net::NetworkChangeNotifier::CONNECTION_2G, "example_mcc_mnc", tx_bytes,
+      rx_bytes));
+}
+
+class MockTimerWithTickClock : public base::MockTimer {
+ public:
+  MockTimerWithTickClock(bool retain_user_task,
+                         bool is_repeating,
+                         base::TickClock* tick_clock)
+      : base::MockTimer(retain_user_task, is_repeating),
+        tick_clock_(tick_clock) {}
+
+  ~MockTimerWithTickClock() override {}
+
+  void Reset() override {
+    start_time_ = tick_clock_->NowTicks();
+    base::MockTimer::Reset();
+  }
+
+  const base::TimeTicks& start_time() const { return start_time_; }
+
+ private:
+  base::TickClock* tick_clock_;
+  base::TimeTicks start_time_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockTimerWithTickClock);
+};
+
+class TestTrafficStatsAmortizer : public TrafficStatsAmortizer {
+ public:
+  TestTrafficStatsAmortizer(scoped_ptr<base::TickClock> tick_clock,
+                            scoped_ptr<base::Timer> traffic_stats_query_timer)
+      : TrafficStatsAmortizer(tick_clock.Pass(),
+                              traffic_stats_query_timer.Pass(),
+                              kTrafficStatsQueryDelay,
+                              kMaxAmortizationDelay,
+                              kMaxDataUseBufferSize),
+        next_traffic_stats_available_(false),
+        next_traffic_stats_tx_bytes_(-1),
+        next_traffic_stats_rx_bytes_(-1) {}
+
+  ~TestTrafficStatsAmortizer() override {}
+
+  void SetNextTrafficStats(bool available, int64_t tx_bytes, int64_t rx_bytes) {
+    next_traffic_stats_available_ = available;
+    next_traffic_stats_tx_bytes_ = tx_bytes;
+    next_traffic_stats_rx_bytes_ = rx_bytes;
+  }
+
+  void AddTrafficStats(int64_t tx_bytes, int64_t rx_bytes) {
+    next_traffic_stats_tx_bytes_ += tx_bytes;
+    next_traffic_stats_rx_bytes_ += rx_bytes;
+  }
+
+ protected:
+  bool QueryTrafficStats(int64_t* tx_bytes, int64_t* rx_bytes) const override {
+    *tx_bytes = next_traffic_stats_tx_bytes_;
+    *rx_bytes = next_traffic_stats_rx_bytes_;
+    return next_traffic_stats_available_;
+  }
+
+ private:
+  bool next_traffic_stats_available_;
+  int64_t next_traffic_stats_tx_bytes_;
+  int64_t next_traffic_stats_rx_bytes_;
+
+  DISALLOW_COPY_AND_ASSIGN(TestTrafficStatsAmortizer);
+};
+
+class TrafficStatsAmortizerTest : public testing::Test {
+ public:
+  TrafficStatsAmortizerTest()
+      : test_tick_clock_(new base::SimpleTestTickClock()),
+        mock_timer_(new MockTimerWithTickClock(false, false, test_tick_clock_)),
+        amortizer_(scoped_ptr<base::TickClock>(test_tick_clock_),
+                   scoped_ptr<base::Timer>(mock_timer_)),
+        data_use_callback_call_count_(0) {}
+
+  ~TrafficStatsAmortizerTest() override {
+    EXPECT_FALSE(mock_timer_->IsRunning());
+  }
+
+  // Simulate the passage of time, firing timers if appropriate.
+  void AdvanceTime(const base::TimeDelta& delta) {
+    run_loop_.RunUntilIdle();
+    test_tick_clock_->Advance(delta);
+
+    // Fire the |mock_timer_| if necessary.
+    if (mock_timer_->IsRunning() &&
+        mock_timer_->start_time() + mock_timer_->GetCurrentDelay() >=
+            test_tick_clock_->NowTicks()) {
+      mock_timer_->Fire();
+    }
+    run_loop_.RunUntilIdle();
+  }
+
+  // Expects that |expected| and |actual| are equivalent.
+  void ExpectDataUse(scoped_ptr<DataUse> expected, scoped_ptr<DataUse> actual) {
+    ++data_use_callback_call_count_;
+
+    // Have separate checks for the |tx_bytes| and |rx_bytes| for better error
+    // messages.
+    EXPECT_EQ(expected->tx_bytes, actual->tx_bytes);
+    EXPECT_EQ(expected->rx_bytes, actual->rx_bytes);
+    EXPECT_EQ(*expected, *actual);
+  }
+
+  // Convenience function for creating an ExpectDataUse callback.

[bengr, 2015/11/10 18:12:50]

// Creates an ExpectDataUse callback, as a convenience.

[sclittle, 2015/11/11 02:10:08]

Done.

+  DataUseAmortizer::DataUseConsumerCallback ExpectDataUseCallback(
+      scoped_ptr<DataUse> expected) {
+    return base::Bind(&TrafficStatsAmortizerTest::ExpectDataUse,
+                      base::Unretained(this), base::Passed(&expected));
+  }
+
+  base::TimeTicks NowTicks() const { return test_tick_clock_->NowTicks(); }
+
+  TestTrafficStatsAmortizer* amortizer() { return &amortizer_; }
+
+  int data_use_callback_call_count() const {
+    return data_use_callback_call_count_;
+  }
+
+ private:
+  base::MessageLoop message_loop_;
+  base::RunLoop run_loop_;
+  // Weak, owned by |amortizer_|.

[bengr, 2015/11/10 18:12:50]

Add blank line above.

[sclittle, 2015/11/11 02:10:08]

Done.

+  base::SimpleTestTickClock* test_tick_clock_;
+  // Weak, owned by |amortizer_|.

[bengr, 2015/11/10 18:12:50]

Add blank line above.

[sclittle, 2015/11/11 02:10:08]

Done.

+  MockTimerWithTickClock* mock_timer_;

[bengr, 2015/11/10 18:12:50]

Add blank line below.

[sclittle, 2015/11/11 02:10:08]

Done.

+  TestTrafficStatsAmortizer amortizer_;
+
+  // The number of times ExpectDataUse has been called.
+  int data_use_callback_call_count_;
+
+  DISALLOW_COPY_AND_ASSIGN(TrafficStatsAmortizerTest);
+};
+
+TEST_F(TrafficStatsAmortizerTest, AmortizeWithTrafficStatsAlwaysUnavailable) {
+  amortizer()->SetNextTrafficStats(false, -1, -1);
+  // Do it three times for good measure.
+  for (int i = 0; i < 3; ++i) {
+    // Extra bytes should be ignored since TrafficStats are unavailable.
+    amortizer()->OnExtraBytes(1337, 9001);
+    // The original DataUse should be unchanged.
+    amortizer()->AmortizeDataUse(
+        CreateDataUse(100, 1000),
+        ExpectDataUseCallback(CreateDataUse(100, 1000)));
+
+    AdvanceTime(kTrafficStatsQueryDelay);
+    EXPECT_EQ(i + 1, data_use_callback_call_count());
+  }
+}
+
+TEST_F(TrafficStatsAmortizerTest, AmortizeDataUse) {
+  // The initial values of TrafficStats shouldn't matter.
+  amortizer()->SetNextTrafficStats(true, 1337, 9001);
+
+  // The first amortization run should not change any byte counts because
+  // there's no TrafficStats delta to work with.
+  amortizer()->AmortizeDataUse(CreateDataUse(50, 500),
+                               ExpectDataUseCallback(CreateDataUse(50, 500)));
+  amortizer()->AmortizeDataUse(CreateDataUse(100, 1000),
+                               ExpectDataUseCallback(CreateDataUse(100, 1000)));
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(2, data_use_callback_call_count());
+
+  // This amortization run, tx_bytes and rx_bytes should be doubled.
+  amortizer()->AmortizeDataUse(CreateDataUse(50, 500),
+                               ExpectDataUseCallback(CreateDataUse(100, 1000)));
+  AdvanceTime(kTrafficStatsQueryDelay / 2);
+
+  // Another DataUse is reported before the amortizer queries TrafficStats.
+  amortizer()->AmortizeDataUse(CreateDataUse(100, 1000),
+                               ExpectDataUseCallback(CreateDataUse(200, 2000)));
+  AdvanceTime(kTrafficStatsQueryDelay / 2);
+
+  // Then, the TrafficStats values update with the new bytes. The second run
+  // callbacks should not have been called yet.
+  amortizer()->AddTrafficStats(300, 3000);
+  EXPECT_EQ(2, data_use_callback_call_count());
+
+  // The callbacks should fire once kTrafficStatsQueryDelay has passed since the
+  // DataUse was passed to the amortizer.
+  AdvanceTime(kTrafficStatsQueryDelay / 2);
+  EXPECT_EQ(4, data_use_callback_call_count());
+}
+
+TEST_F(TrafficStatsAmortizerTest, AmortizeWithExtraBytes) {
+  // The initial values of TrafficStats shouldn't matter.
+  amortizer()->SetNextTrafficStats(true, 1337, 9001);
+
+  // Do the first amortization run with TrafficStats unavailable.
+  amortizer()->OnExtraBytes(100, 1000);
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(0, data_use_callback_call_count());
+
+  // On the second amortization run, byte counts should double.
+  amortizer()->AmortizeDataUse(CreateDataUse(50, 500),
+                               ExpectDataUseCallback(CreateDataUse(100, 1000)));
+  amortizer()->OnExtraBytes(500, 5000);
+  amortizer()->AddTrafficStats(1100, 11000);
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(1, data_use_callback_call_count());
+}
+
+TEST_F(TrafficStatsAmortizerTest, AmortizeWithNegativeOverhead) {
+  // The initial values of TrafficStats shouldn't matter.
+  amortizer()->SetNextTrafficStats(true, 1337, 9001);
+
+  // Do the first amortization run with TrafficStats unavailable.
+  amortizer()->OnExtraBytes(100, 1000);
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(0, data_use_callback_call_count());
+
+  // On the second amortization run, byte counts should halve.
+  amortizer()->AmortizeDataUse(CreateDataUse(50, 500),

[bengr, 2015/11/10 18:12:50]

Also add cases where sent or received bytes is at the int64_t max, and where
ratio is the int64_t max (e.g., with sent/received = 1).

[sclittle, 2015/11/11 02:10:08]

Done. Note that these are weird since floating point error figures in at these
magnitudes.

+                               ExpectDataUseCallback(CreateDataUse(25, 250)));
+  amortizer()->AddTrafficStats(25, 250);
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(1, data_use_callback_call_count());
+}
+
+TEST_F(TrafficStatsAmortizerTest, AmortizeWithZeroPreAmortizationBytes) {
+  // The initial values of TrafficStats shouldn't matter.
+  amortizer()->SetNextTrafficStats(true, 1337, 9001);
+
+  // Do the first amortization run with TrafficStats unavailable.
+  amortizer()->OnExtraBytes(100, 1000);
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(0, data_use_callback_call_count());
+
+  // On the second amortization run, byte counts should stay 0.
+  amortizer()->AmortizeDataUse(CreateDataUse(0, 0),

[bengr, 2015/11/10 18:12:50]

Add cases where sent or received bytes is 0.

[sclittle, 2015/11/11 02:10:08]

Done.

+                               ExpectDataUseCallback(CreateDataUse(0, 0)));
+  amortizer()->AddTrafficStats(100, 1000);
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(1, data_use_callback_call_count());
+}
+
+TEST_F(TrafficStatsAmortizerTest, AmortizeAtMaxDelay) {
+  // The initial values of TrafficStats shouldn't matter.
+  amortizer()->SetNextTrafficStats(true, 1337, 9001);
+
+  // Do the first amortization run with TrafficStats unavailable.
+  amortizer()->OnExtraBytes(100, 1000);
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(0, data_use_callback_call_count());
+
+  // On the second amortization run, byte counts should double.
+  amortizer()->AddTrafficStats(1000, 10000);
+  amortizer()->AmortizeDataUse(CreateDataUse(50, 500),
+                               ExpectDataUseCallback(CreateDataUse(100, 1000)));
+
+  // Simulate 9 cases of extra bytes being reported, each before TrafficStats

[bengr, 2015/11/10 18:12:50]

Why 9? Do you mean kMaxBufferSize + 1?

[sclittle, 2015/11/11 02:10:08]

Reworded comment. I meant that we'll keep reporting extra bytes until the
kMaxAmortizationDelay is hit.

+  // would be queried.
+  const base::TimeDelta kSmallDelay = kMaxAmortizationDelay / 10;

[bengr, 2015/11/10 18:12:50]

Why / 10?

[sclittle, 2015/11/11 02:10:08]

Added comments.

+  EXPECT_LT(kSmallDelay, kMaxAmortizationDelay);
+
+  AdvanceTime(kSmallDelay);
+  for (int i = 0; i < 9; ++i) {
+    EXPECT_EQ(0, data_use_callback_call_count());
+    amortizer()->OnExtraBytes(50, 500);
+    AdvanceTime(kSmallDelay);
+  }
+
+  // The final time, the amortizer should have given up on waiting to query
+  // TrafficStats and just have amortized as soon as it hit the deadline of
+  // 200ms.
+  EXPECT_EQ(1, data_use_callback_call_count());
+}
+
+TEST_F(TrafficStatsAmortizerTest, AmortizeAtMaxBufferSize) {
+  // The initial values of TrafficStats shouldn't matter.
+  amortizer()->SetNextTrafficStats(true, 1337, 9001);
+
+  // Do the first amortization run with TrafficStats unavailable.
+  amortizer()->OnExtraBytes(100, 1000);
+  AdvanceTime(kTrafficStatsQueryDelay);
+  EXPECT_EQ(0, data_use_callback_call_count());
+
+  // The second run will fill up with 9 consecutive DataUse objects, which will
+  // be amortized immediately once the buffer exceeds maximum size.
+  amortizer()->AddTrafficStats(900, 9000);
+  for (int i = 0; i < 9; ++i) {
+    EXPECT_EQ(0, data_use_callback_call_count());
+    amortizer()->AmortizeDataUse(
+        CreateDataUse(50, 500),
+        ExpectDataUseCallback(CreateDataUse(100, 1000)));
+  }
+
+  EXPECT_EQ(9, data_use_callback_call_count());
+}
+
+}  // namespace
+
+}  // namespace android
+}  // namespace data_usage