Add histograms for ExternalDataUseObserver

chrome/browser/android/data_usage/external_data_use_observer_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 "chrome/browser/android/data_usage/external_data_use_observer.h"
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/test/histogram_tester.h"
 #include "base/thread_task_runner_handle.h"
 #include "chrome/browser/android/data_usage/data_use_tab_model_test_utils.h"
 #include "components/data_usage/core/data_use.h"
 #include "components/data_usage/core/data_use_aggregator.h"
 #include "components/data_usage/core/data_use_amortizer.h"
 #include "components/data_usage/core/data_use_annotator.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"
@@ skipping 18 matching lines @@
     external_data_use_observer_.reset(new ExternalDataUseObserver(
         data_use_aggregator_.get(), io_task_runner_.get(),
         ui_task_runner_.get()));
     test_data_use_tab_model_ = new TestDataUseTabModel(
         external_data_use_observer_.get(), ui_task_runner_.get());
     external_data_use_observer_->data_use_tab_model_.reset(
         test_data_use_tab_model_);
   }
 
   scoped_ptr<ExternalDataUseObserver> Create() const {
-    return scoped_ptr<ExternalDataUseObserver>(new ExternalDataUseObserver(
+    scoped_ptr<ExternalDataUseObserver> observer(new ExternalDataUseObserver(
         data_use_aggregator_.get(), io_task_runner_.get(),
         ui_task_runner_.get()));
+    // |test_data_use_tab_model| is owned by |observer|.
+    TestDataUseTabModel* test_data_use_tab_model(
+        new TestDataUseTabModel(observer.get(), ui_task_runner_.get()));
+    observer->data_use_tab_model_.reset(test_data_use_tab_model);
+    return observer.Pass();
   }
 
   ExternalDataUseObserver* external_data_use_observer() const {
     return external_data_use_observer_.get();
   }
 
   TestDataUseTabModel* test_data_use_tab_model() const {
     return test_data_use_tab_model_;
   }
 
@@ skipping 226 matching lines @@
   labels.push_back("label_1");
   labels.push_back("label_4");
   labels.push_back("label_5");
   external_data_use_observer()->RegisterURLRegexes(
       std::vector<std::string>(labels.size(), std::string()),
       std::vector<std::string>(labels.size(), "http://foobar.com"), labels);
 }
 
 // Verifies that buffer size does not exceed the specified limit.
 TEST_F(ExternalDataUseObserverTest, BufferSize) {
+  base::HistogramTester histogram_tester;
   const char kLabel[] = "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()->FetchMatchingRulesDoneOnIOThread(
       std::vector<std::string>(url_regexes.size(), std::string()), url_regexes,
       std::vector<std::string>(url_regexes.size(), kLabel));
 
@@ skipping 15 matching lines @@
   // Verify that total buffered bytes is computed correctly.
   EXPECT_EQ(static_cast<int64_t>(ExternalDataUseObserver::kMaxBufferSize *
                                  (bytes_downloaded + bytes_uploaded)),
             external_data_use_observer()->total_bytes_buffered_);
   EXPECT_EQ(ExternalDataUseObserver::kMaxBufferSize,
             buffered_data_reports().size());
 
   // Verify the label of the data use report.
   for (const auto& it : buffered_data_reports())
     EXPECT_EQ(kLabel, it.first.label);
+
+  // Verify that metrics were updated correctly for the lost reports.
+  histogram_tester.ExpectTotalCount(
+      "DataUsage.ReportSubmissionResult",
+      ExternalDataUseObserver::kMaxBufferSize - 1);

[sclittle, 2015/12/02 19:07:55]

nit: If these are all the same sample (e.g. the same number of bytes), you could
just use ExpectUniqueSample(histogram_name, bytes_sample, kMaxBufferSize - 1)

[tbansal1, 2015/12/03 03:19:45]

Done.

+  histogram_tester.ExpectBucketCount(
+      "DataUsage.ReportSubmissionResult", 3,
+      ExternalDataUseObserver::kMaxBufferSize - 1);
+  histogram_tester.ExpectTotalCount(
+      "DataUsage.ReportSubmission.Lost.Bytes",
+      ExternalDataUseObserver::kMaxBufferSize - 1);

[sclittle, 2015/12/02 19:07:54]

Can you also test the samples in this histogram?

[tbansal1, 2015/12/03 03:19:45]

Done.

 }
 
 // Tests that buffered data use reports are merged correctly.
 TEST_F(ExternalDataUseObserverTest, ReportsMergedCorrectly) {
   const char kLabel[] = "label";
 
   std::vector<std::string> url_regexes;
   url_regexes.push_back(
       "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*");
 
@@ skipping 101 matching lines @@
 
   std::vector<std::string> app_package_names;
   const char kAppFoo[] = "com.example.foo";
   const char kAppBar[] = "com.example.bar";
   app_package_names.push_back(kAppFoo);
   app_package_names.push_back(kAppBar);
 
   external_data_use_observer()->FetchMatchingRulesDoneOnIOThread(
       app_package_names, url_regexes, labels);
   EXPECT_EQ(0U, external_data_use_observer()->buffered_data_reports_.size());
-  EXPECT_FALSE(external_data_use_observer()->submit_data_report_pending_);
+  EXPECT_TRUE(
+      external_data_use_observer()->last_data_report_submitted_.is_null());
   EXPECT_FALSE(external_data_use_observer()->matching_rules_fetch_pending_);
 
   // Check |kLabelFoo| matching rule.
   data_usage::DataUse data_foo_1(
       GURL("http://www.foo.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
       net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_1",
       external_data_use_observer()->data_use_report_min_bytes_, 0);
   external_data_use_observer()->OnDataUse(data_foo_1);
   data_usage::DataUse data_foo_2(
       GURL("http://www.foo.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
       net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_2",
       external_data_use_observer()->data_use_report_min_bytes_, 0);
   external_data_use_observer()->OnDataUse(data_foo_2);
 
   // The foo1 report should have been submitted.
-  EXPECT_TRUE(external_data_use_observer()->submit_data_report_pending_);
+  EXPECT_FALSE(
+      external_data_use_observer()->last_data_report_submitted_.is_null());
 
   // Only the foo2 report should be present.
   EXPECT_EQ(1U, buffered_data_reports().size());
   const ExternalDataUseObserver::DataUseReportKey key_foo_2(
       kLabelFoo, net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_2");
   EXPECT_NE(buffered_data_reports().end(),
             buffered_data_reports().find(key_foo_2));
 
   // Check |kLabelBar| matching rule.
   data_usage::DataUse data_bar(
@@ skipping 115 matching lines @@
 
   for (size_t i = 0; i < num_iterations; ++i) {
     data_usage::DataUse data_use_foo(
         GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
         net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1024, 0);
     external_data_use_observer()->OnDataUse(data_use_foo);
 
     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_TRUE(
+          external_data_use_observer()->last_data_report_submitted_.is_null());
       EXPECT_EQ(static_cast<int64_t>(i + 1),
                 external_data_use_observer()->total_bytes_buffered_ / 1024);
+      EXPECT_EQ(0, external_data_use_observer()->pending_report_bytes_);
 
     } 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_FALSE(
+          external_data_use_observer()->last_data_report_submitted_.is_null());
       EXPECT_EQ(0, external_data_use_observer()->total_bytes_buffered_);
     }
   }
   EXPECT_EQ(0, external_data_use_observer()->total_bytes_buffered_);
+  EXPECT_EQ(static_cast<int64_t>(num_iterations),
+            external_data_use_observer()->pending_report_bytes_ / 1024);
+
+  base::HistogramTester histogram_tester;
+  external_data_use_observer()->OnReportDataUseDoneOnIOThread(true);
+
+  // Verify that metrics were updated correctly for the report that was
+  // successfully submitted.
+  histogram_tester.ExpectTotalCount("DataUsage.ReportSubmissionResult", 1);
+  histogram_tester.ExpectBucketCount("DataUsage.ReportSubmissionResult", 0, 1);
+  histogram_tester.ExpectTotalCount(
+      "DataUsage.ReportSubmission.Successful.Bytes", 1);

[sclittle, 2015/12/02 19:07:55]

nit: Can you check the sample for this histogram as well? You can just replace
this with a call to ExpectUniqueSample. Same thing everywhere else that you
ExpectTotalCount(name, 1) in tests.

[tbansal1, 2015/12/03 03:19:45]

Done.

+
+  // Verify that metrics were updated correctly for the report that was not
+  // successfully submitted.
+  external_data_use_observer()->OnDataUse(data_usage::DataUse(
+      GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
+      net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1024 * 1024,
+      0));
+  external_data_use_observer()->OnReportDataUseDoneOnIOThread(false);
+  histogram_tester.ExpectTotalCount("DataUsage.ReportSubmissionResult", 2);
+  histogram_tester.ExpectBucketCount("DataUsage.ReportSubmissionResult", 1, 1);
+  histogram_tester.ExpectTotalCount("DataUsage.ReportSubmission.Failed.Bytes",
+                                    1);
 }
 
 // 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 * 1024,
             external_data_use_observer()->data_use_report_min_bytes_);
 
   variations::testing::ClearAllVariationParams();
   std::map<std::string, std::string> variation_params;
 
   const int kFetchMatchingRulesDurationSeconds = 10000;
+  const int kDefaultMaxDataReportSubmitWaitSeconds = 20000;
   const int64_t kDataUseReportMinBytes = 5000;
   variation_params["fetch_matching_rules_duration_seconds"] =
       base::Int64ToString(kFetchMatchingRulesDurationSeconds);
+  variation_params["data_report_submit_timeout_seconds"] =
+      base::Int64ToString(kDefaultMaxDataReportSubmitWaitSeconds);
   variation_params["data_use_report_min_bytes"] =
       base::Int64ToString(kDataUseReportMinBytes);
 
   ASSERT_TRUE(variations::AssociateVariationParams(
       ExternalDataUseObserver::kExternalDataUseObserverFieldTrial, "Enabled",
       variation_params));
 
   base::FieldTrialList field_trial_list(nullptr);
 
   base::FieldTrialList::CreateFieldTrial(
       ExternalDataUseObserver::kExternalDataUseObserverFieldTrial, "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(kFetchMatchingRulesDurationSeconds),
             external_data_use_obsever_with_variations
                 ->fetch_matching_rules_duration_);
   EXPECT_EQ(
+      base::TimeDelta::FromSeconds(kDefaultMaxDataReportSubmitWaitSeconds),
+      external_data_use_obsever_with_variations->data_report_submit_timeout_);
+  EXPECT_EQ(
       kDataUseReportMinBytes,
       external_data_use_obsever_with_variations->data_use_report_min_bytes_);
 }
 
+// Tests if the metrics are recorded correctly.
+TEST_F(ExternalDataUseObserverTest, DataUseReportTimedOut) {
+  variations::testing::ClearAllVariationParams();
+  std::map<std::string, std::string> variation_params;
+  variation_params["data_report_submit_timeout_seconds"] = "0";
+  variation_params["data_use_report_min_bytes"] = "0";
+
+  ASSERT_TRUE(variations::AssociateVariationParams(
+      ExternalDataUseObserver::kExternalDataUseObserverFieldTrial, "Enabled",
+      variation_params));
+
+  base::FieldTrialList field_trial_list(nullptr);
+
+  base::FieldTrialList::CreateFieldTrial(
+      ExternalDataUseObserver::kExternalDataUseObserverFieldTrial, "Enabled");
+
+  // Create another ExternalDataUseObserver object. This would fetch variation
+  // params.
+  scoped_ptr<ExternalDataUseObserver>
+      external_data_use_obsever_with_variations = Create();
+
+  std::vector<std::string> url_regexes;
+  url_regexes.push_back(
+      "http://www[.]google[.]com/#q=.*|https://www[.]google[.]com/#q=.*");
+  external_data_use_obsever_with_variations->FetchMatchingRulesDoneOnIOThread(
+      std::vector<std::string>(url_regexes.size(), std::string()), url_regexes,
+      std::vector<std::string>(url_regexes.size(), "label"));
+
+  base::HistogramTester histogram_tester;
+  external_data_use_obsever_with_variations->data_use_tab_model()
+      ->OnNavigationEvent(0, DataUseTabModel::TRANSITION_OMNIBOX_SEARCH,
+                          GURL("http://www.google.com/#q=abc"), std::string());
+  external_data_use_obsever_with_variations->OnDataUse(data_usage::DataUse(
+      GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
+      net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_foo", 1024 * 1024,
+      0));
+  external_data_use_obsever_with_variations->OnDataUse(data_usage::DataUse(
+      GURL("http://www.google.com/#q=abc"), base::TimeTicks::Now(), GURL(), 0,
+      net::NetworkChangeNotifier::CONNECTION_UNKNOWN, "mccmnc_bar", 1024 * 1024,
+      0));
+  histogram_tester.ExpectTotalCount("DataUsage.ReportSubmissionResult", 1);

[sclittle, 2015/12/02 19:07:55]

nit: you could get rid of the ExpectTotalCount here and just use
ExpectUniqueSample below.

[tbansal1, 2015/12/03 03:19:45]

Done.

+  // First data use report should be marked as timed out.
+  histogram_tester.ExpectBucketCount("DataUsage.ReportSubmissionResult", 2, 1);
+}
+
 }  // namespace android
 
 }  // namespace chrome