ExternalDataUseObserver JNI integration

chrome/browser/android/data_usage/external_data_use_observer_unittest.cc

Index: chrome/browser/android/data_usage/external_data_use_observer_unittest.cc
diff --git a/chrome/browser/android/data_usage/external_data_use_observer_unittest.cc b/chrome/browser/android/data_usage/external_data_use_observer_unittest.cc
index 18a6985b00cc37fef33b6c3a0d13897f19a9bcc5..c122927e7d5546e1076d63821a5d76f02c56e0bd 100644
--- a/chrome/browser/android/data_usage/external_data_use_observer_unittest.cc
+++ b/chrome/browser/android/data_usage/external_data_use_observer_unittest.cc
@@ -9,11 +9,13 @@
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
+#include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/thread_task_runner_handle.h"
 #include "components/data_usage/core/data_use.h"
 #include "components/data_usage/core/data_use_aggregator.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "net/base/network_change_notifier.h"
@@ -39,6 +41,12 @@ class ExternalDataUseObserverTest : public testing::Test {
         ui_task_runner_.get()));
   }
 
+  scoped_ptr<ExternalDataUseObserver> Create() const {
+    return scoped_ptr<ExternalDataUseObserver>(new ExternalDataUseObserver(
+        data_use_aggregator_.get(), io_task_runner_.get(),
+        ui_task_runner_.get()));
+  }
+
   ExternalDataUseObserver* external_data_use_observer() const {
     return external_data_use_observer_.get();
   }
@@ -231,6 +239,7 @@ TEST_F(ExternalDataUseObserverTest, ChangeRegex) {
 
 // Tests that at most one data use request is submitted.
 TEST_F(ExternalDataUseObserverTest, AtMostOneDataUseSubmitRequest) {
+  external_data_use_observer()->data_use_report_min_bytes_ = 0;
   const std::string label("label");
 
   std::vector<std::string> url_regexes;
@@ -261,6 +270,7 @@ TEST_F(ExternalDataUseObserverTest, AtMostOneDataUseSubmitRequest) {
 
 // Verifies that buffer size does not exceed the specified limit.
 TEST_F(ExternalDataUseObserverTest, BufferSize) {
+  external_data_use_observer()->data_use_report_min_bytes_ = 0;
   const std::string label("label");
 
   std::vector<std::string> url_regexes;
@@ -272,6 +282,8 @@ TEST_F(ExternalDataUseObserverTest, BufferSize) {
       std::vector<std::string>(url_regexes.size(), label));
 
   const size_t max_buffer_size = ExternalDataUseObserver::kMaxBufferSize;
+  const int bytes_downloaded = 1000;
+  const int bytes_uploaded = 100;
 
   ScopedVector<data_usage::DataUse> data_use_vector;
   // Push more entries than the buffer size. Buffer size should not be exceeded.
@@ -279,7 +291,7 @@ TEST_F(ExternalDataUseObserverTest, BufferSize) {
     scoped_ptr<data_usage::DataUse> data_use(new data_usage::DataUse(
         GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
         net::NetworkChangeNotifier::CONNECTION_UNKNOWN,
-        "mccmnc" + base::Int64ToString(i), 0, 0));
+        "mccmnc" + base::Int64ToString(i), bytes_downloaded, bytes_uploaded));
     data_use_vector.push_back(data_use.Pass());
   }
 
@@ -287,7 +299,12 @@ TEST_F(ExternalDataUseObserverTest, BufferSize) {
       data_use_vector.begin(), data_use_vector.end());
 
   external_data_use_observer()->OnDataUse(const_sequence);
-  // One report will be consumed.
+  EXPECT_LE(0, external_data_use_observer()->total_bytes_buffered_);
+
+  // One report will be consumed. Verify that total buffered bytes is computed
+  // correctly.
+  EXPECT_EQ((max_buffer_size - 1) * (bytes_downloaded + bytes_uploaded),
+            external_data_use_observer()->total_bytes_buffered_);
   EXPECT_EQ(max_buffer_size - 1,
             external_data_use_observer()->buffered_data_reports_.size());
 
@@ -298,6 +315,7 @@ TEST_F(ExternalDataUseObserverTest, BufferSize) {
 
 // Tests that buffered data use reports are merged correctly.
 TEST_F(ExternalDataUseObserverTest, ReportsMergedCorrectly) {
+  external_data_use_observer()->data_use_report_min_bytes_ = 0;
   const std::string label("label");
 
   std::vector<std::string> url_regexes;
@@ -403,6 +421,7 @@ TEST_F(ExternalDataUseObserverTest, TimestampsMergedCorrectly) {
 
 // Tests the behavior when multiple matching rules are available.
 TEST_F(ExternalDataUseObserverTest, MultipleMatchingRules) {
+  external_data_use_observer()->data_use_report_min_bytes_ = 0;
   std::vector<std::string> url_regexes;
   url_regexes.push_back(
       "http://www[.]foo[.]com/#q=.*|https://www[.]foo[.]com/#q=.*");
@@ -484,6 +503,133 @@ TEST_F(ExternalDataUseObserverTest, HashFunction) {
   EXPECT_NE(hash(foo), hash(bar_mcc_mnc));
 }
 
+// Tests if matching rules are fetched periodically.
+TEST_F(ExternalDataUseObserverTest, PeriodicFetchMatchingRules) {
+  external_data_use_observer()->data_use_report_min_bytes_ = 0;
+  const std::string label("label");
+
+  std::vector<std::string> url_regexes;
+  url_regexes.push_back(
+      "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*");
+
+  external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread(
+      std::vector<std::string>(url_regexes.size(), std::string()), url_regexes,
+      std::vector<std::string>(url_regexes.size(), label));
+
+  EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_);
+  EXPECT_FALSE(
+      external_data_use_observer()->last_matching_rules_fetch_time_.is_null());
+
+  std::vector<const data_usage::DataUse*> data_use_sequence;
+  data_usage::DataUse data_use_foo(
+      GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
+      net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1, 2);
+  data_use_sequence.push_back(&data_use_foo);
+
+  // Change the time when the fetching rules were fetched.
+  external_data_use_observer()->last_matching_rules_fetch_time_ =
+      base::TimeTicks::Now() -
+      external_data_use_observer()->fetch_matching_rules_duration_;
+  // Matching rules should be expired.
+  EXPECT_GE(base::TimeTicks::Now() -
+                external_data_use_observer()->last_matching_rules_fetch_time_,
+            external_data_use_observer()->fetch_matching_rules_duration_);
+  // OnDataUse should trigger fetching of matching rules.
+  external_data_use_observer()->OnDataUse(data_use_sequence);
+
+  // Matching rules should not be expired.
+  EXPECT_LT(base::TimeTicks::Now() -
+                external_data_use_observer()->last_matching_rules_fetch_time_,
+            external_data_use_observer()->fetch_matching_rules_duration_);
+}
+
+// Tests if data use reports are sent only after the total bytes send/received
+// across all buffered reports have reached the specified threshold.
+TEST_F(ExternalDataUseObserverTest, BufferDataUseReports) {
+  const std::string label("label");
+
+  std::vector<std::string> url_regexes;
+  url_regexes.push_back(
+      "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*");
+
+  external_data_use_observer()->FetchMatchingRulesCallbackOnIOThread(
+      std::vector<std::string>(url_regexes.size(), std::string()), url_regexes,
+      std::vector<std::string>(url_regexes.size(), label));
+
+  // This tests reports 1000 bytes in each loop iteration. For the test to work
+  // properly, |data_use_report_min_bytes_| should be a multiple of 1000.
+  ASSERT_EQ(0, external_data_use_observer()->data_use_report_min_bytes_ % 1000);
+
+  const size_t num_iterations =
+      external_data_use_observer()->data_use_report_min_bytes_ / 1000;
+
+  for (size_t i = 0; i < num_iterations; ++i) {
+    ScopedVector<data_usage::DataUse> data_use_vector;
+
+    scoped_ptr<data_usage::DataUse> data_use_foo(new data_usage::DataUse(
+        GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
+        net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1000, 0));
+    data_use_vector.push_back(data_use_foo.Pass());
+
+    std::vector<const data_usage::DataUse*> const_sequence(
+        data_use_vector.begin(), data_use_vector.end());
+
+    external_data_use_observer()->OnDataUse(const_sequence);
+    if (i != num_iterations - 1) {
+      // Total buffered bytes is less than the minimum threshold. Data use
+      // report should not be send.
+      EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_);
+      EXPECT_EQ(i + 1,
+                external_data_use_observer()->total_bytes_buffered_ / 1000);
+
+    } else {
+      // Total bytes is at least the minimum threshold. This should trigger
+      // submitting of the buffered data use report.
+      EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_);
+      EXPECT_EQ(0, external_data_use_observer()->total_bytes_buffered_);
+    }
+  }
+  EXPECT_EQ(0, external_data_use_observer()->total_bytes_buffered_);
+}
+
+// Tests if the parameters from the field trial are populated correctly.
+TEST_F(ExternalDataUseObserverTest, Variations) {
+  EXPECT_EQ(base::TimeDelta::FromSeconds(60 * 15),
+            external_data_use_observer()->fetch_matching_rules_duration_);
+  EXPECT_EQ(100 * 1000,
+            external_data_use_observer()->data_use_report_min_bytes_);
+
+  variations::testing::ClearAllVariationParams();
+  std::map<std::string, std::string> variation_params;
+
+  const int fetch_matching_rules_duration_seconds = 10000;
+  const int data_use_report_min_bytes = 5000;
+  variation_params["fetch_matching_rules_duration_seconds"] =
+      base::Int64ToString(fetch_matching_rules_duration_seconds);
+  variation_params["data_use_report_min_bytes"] =
+      base::Int64ToString(data_use_report_min_bytes);
+
+  ASSERT_TRUE(variations::AssociateVariationParams(
+      external_data_use_observer()->GetExternalDataUseObserverFieldTrialName(),
+      "Enabled", variation_params));
+
+  base::FieldTrialList field_trial_list(nullptr);
+  base::FieldTrialList::CreateFieldTrial(
+      external_data_use_observer()->GetExternalDataUseObserverFieldTrialName(),
+      "Enabled");
+
+  // Create another ExternalDataUseObserver object. This would fetch variation
+  // params.
+  scoped_ptr<ExternalDataUseObserver>
+      external_data_use_obsever_with_variations = Create();
+  EXPECT_EQ(base::TimeDelta::FromSeconds(fetch_matching_rules_duration_seconds),
+            external_data_use_obsever_with_variations
+                ->fetch_matching_rules_duration_);
+  EXPECT_EQ(
+      data_use_report_min_bytes,
+      external_data_use_obsever_with_variations->data_use_report_min_bytes_);
+}
+
 }  // namespace android
 
 }  // namespace chrome