Make ExternalDataUseReporter independent of other data use classes

Removes DataUseTabModel and ExternalDataUseObserverBridge dependency on
ExternalDataUseReporter by passing necessary callbacks.

BUG=570884

Review-Url: https://codereview.chromium.org/2165123002
Cr-Commit-Position: refs/heads/master@{#406926}

chrome/browser/android/data_usage/data_use_tab_model.cc

@@ -222,7 +222,7 @@ void DataUseTabModel::OnTrackingLabelRemoved(const std::string& label) {
 
 bool DataUseTabModel::GetTrackingInfoForTabAtTime(
     SessionID::id_type tab_id,
-    base::TimeTicks timestamp,
+    const base::TimeTicks timestamp,
     TrackingInfo* output_tracking_info) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 

chrome/browser/android/data_usage/external_data_use_observer.cc

@@ -63,10 +63,16 @@ ExternalDataUseObserver::ExternalDataUseObserver(
           base::Bind(
               &ExternalDataUseObserverBridge::ShouldRegisterAsDataUseObserver,
               base::Unretained(external_data_use_observer_bridge_)))),
-      external_data_use_reporter_(
-          new ExternalDataUseReporter(kExternalDataUseObserverFieldTrial,
-                                      data_use_tab_model_,
-                                      external_data_use_observer_bridge_)),
+      // It is okay to use  base::Unretained for the callbacks, since
+      // |external_data_use_observer_bridge_| and |data_use_tab_model_| are
+      // owned by |this|, and are destroyed on UI thread after |this| and
+      // |external_data_use_reporter_| are destroyed.
+      external_data_use_reporter_(new ExternalDataUseReporter(
+          kExternalDataUseObserverFieldTrial,
+          base::Bind(&DataUseTabModel::GetTrackingInfoForTabAtTime,
+                     base::Unretained(data_use_tab_model_)),
+          base::Bind(&ExternalDataUseObserverBridge::ReportDataUse,
+                     base::Unretained(external_data_use_observer_bridge_)))),
       io_task_runner_(io_task_runner),
       ui_task_runner_(ui_task_runner),
       last_matching_rules_fetch_time_(base::TimeTicks::Now()),

chrome/browser/android/data_usage/external_data_use_observer_bridge.cc

@@ -135,8 +135,8 @@ void ExternalDataUseObserverBridge::ReportDataUse(
     const std::string& tag,
     net::NetworkChangeNotifier::ConnectionType connection_type,
     const std::string& mcc_mnc,
-    const base::Time& start_time,
-    const base::Time& end_time,
+    base::Time start_time,
+    base::Time end_time,
     int64_t bytes_downloaded,
     int64_t bytes_uploaded) const {
   DCHECK(thread_checker_.CalledOnValidThread());

chrome/browser/android/data_usage/external_data_use_observer_bridge.h

@@ -75,8 +75,8 @@ class ExternalDataUseObserverBridge {
                      const std::string& tag,
                      net::NetworkChangeNotifier::ConnectionType connection_type,
                      const std::string& mcc_mnc,
-                     const base::Time& start_time,
-                     const base::Time& end_time,
+                     base::Time start_time,
+                     base::Time end_time,
                      int64_t bytes_downloaded,
                      int64_t bytes_uploaded) const;
 

chrome/browser/android/data_usage/external_data_use_reporter.cc

@@ -10,8 +10,6 @@
 #include "base/metrics/histogram_base.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
-#include "chrome/browser/android/data_usage/data_use_tab_model.h"
-#include "chrome/browser/android/data_usage/external_data_use_observer_bridge.h"
 #include "components/data_usage/core/data_use.h"
 #include "components/variations/variations_associated_data.h"
 
@@ -100,10 +98,10 @@ const size_t ExternalDataUseReporter::kMaxBufferSize = 100;
 
 ExternalDataUseReporter::ExternalDataUseReporter(
     const char* field_trial,
-    DataUseTabModel* data_use_tab_model,
-    ExternalDataUseObserverBridge* external_data_use_observer_bridge)
-    : external_data_use_observer_bridge_(external_data_use_observer_bridge),
-      data_use_tab_model_(data_use_tab_model),
+    const GetTrackingInfoCallback& get_tracking_info_callback,
+    const ReportDataUseCallback& report_data_use_callback)
+    : get_tracking_info_callback_(get_tracking_info_callback),
+      report_data_use_callback_(report_data_use_callback),
       last_data_report_submitted_ticks_(base::TimeTicks()),
       pending_report_bytes_(0),
       previous_report_time_(base::Time::Now()),
@@ -111,6 +109,8 @@ ExternalDataUseReporter::ExternalDataUseReporter(
       data_use_report_min_bytes_(GetMinBytes(field_trial)),
       data_report_submit_timeout_(base::TimeDelta::FromMilliseconds(
           GetDataReportSubmitTimeoutMsec(field_trial))) {
+  DCHECK(get_tracking_info_callback_);
+  DCHECK(report_data_use_callback_);
   DCHECK(last_data_report_submitted_ticks_.is_null());
   // Detach from current thread since rest of ExternalDataUseReporter lives on
   // the UI thread and the current thread may not be UI thread..
@@ -140,7 +140,7 @@ void ExternalDataUseReporter::OnDataUse(
   DataUseTabModel::TrackingInfo tracking_info;
 
   for (const auto& data_use : *data_use_list) {
-    if (!data_use_tab_model_->GetTrackingInfoForTabAtTime(
+    if (!get_tracking_info_callback_.Run(
             data_use.tab_id, data_use.request_start, &tracking_info)) {
       continue;
     }
@@ -278,9 +278,9 @@ void ExternalDataUseReporter::SubmitBufferedDataUseReport(bool immediate) {
   buffered_data_reports_.erase(it);
   total_bytes_buffered_ -= (report.bytes_downloaded + report.bytes_uploaded);
 
-  external_data_use_observer_bridge_->ReportDataUse(
-      key.label, key.tag, key.connection_type, key.mcc_mnc, report.start_time,
-      report.end_time, report.bytes_downloaded, report.bytes_uploaded);
+  report_data_use_callback_.Run(key.label, key.tag, key.connection_type,
+                                key.mcc_mnc, report.start_time, report.end_time,
+                                report.bytes_downloaded, report.bytes_uploaded);
 }
 
 ExternalDataUseReporter::DataUseReportKey::DataUseReportKey(

chrome/browser/android/data_usage/external_data_use_reporter.h

@@ -12,11 +12,13 @@
 #include <memory>
 #include <string>
 
+#include "base/callback.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
+#include "chrome/browser/android/data_usage/data_use_tab_model.h"
 #include "net/base/network_change_notifier.h"
 
 #if defined(OS_ANDROID)
@@ -31,9 +33,6 @@ namespace chrome {
 
 namespace android {
 
-class DataUseTabModel;
-class ExternalDataUseObserverBridge;
-
 // This class receives data use observations from ExternalDataUseObserver,
 // labels the data use using DataUseTabModel, and buffers the data use report.
 // The buffered reports are submitted to the platform when a minimum number of
@@ -42,6 +41,21 @@ class ExternalDataUseObserverBridge;
 // must only be accessed on UI thread.
 class ExternalDataUseReporter {
  public:
+  typedef base::Callback<bool(SessionID::id_type,
+                              const base::TimeTicks,
+                              DataUseTabModel::TrackingInfo*)>
+      GetTrackingInfoCallback;
+
+  typedef base::Callback<void(const std::string&,
+                              const std::string&,
+                              net::NetworkChangeNotifier::ConnectionType,
+                              const std::string&,
+                              const base::Time,
+                              const base::Time,
+                              int64_t,
+                              int64_t)>
+      ReportDataUseCallback;
+
   // Result of data usage report submission.  This enum must remain synchronized
   // with the enum of the same name in metrics/histograms/histograms.xml.
   enum DataUsageReportSubmissionResult {
@@ -62,8 +76,9 @@ class ExternalDataUseReporter {
   // paramenters from.
   ExternalDataUseReporter(
       const char* field_trial,
-      DataUseTabModel* data_use_tab_model,
-      ExternalDataUseObserverBridge* external_data_use_observer_bridge);
+      const GetTrackingInfoCallback& get_tracking_info_callback,
+      const ReportDataUseCallback& report_data_use_callback);
+
   virtual ~ExternalDataUseReporter();
 
   void InitOnUIThread();
@@ -191,12 +206,11 @@ class ExternalDataUseReporter {
   void OnApplicationStateChange(base::android::ApplicationState new_state);
 #endif
 
-  // Pointer to the ExternalDataUseObserverBridge in UI thread. Not owned by
-  // |this|.
-  ExternalDataUseObserverBridge* external_data_use_observer_bridge_;
+  // Callback to be run to get the tracking info for a tab at a particular time.
+  const GetTrackingInfoCallback get_tracking_info_callback_;
 
-  // Pointer to the DataUseTabModel in UI thread, Not owned by |this|.
-  DataUseTabModel* data_use_tab_model_;
+  // Callback to be run to report the data usage to the underlying platform.
+  const ReportDataUseCallback report_data_use_callback_;
 
 #if defined(OS_ANDROID)
   // Listens to when Chromium gets backgrounded and submits buffered data use

chrome/browser/android/data_usage/external_data_use_reporter_unittest.cc

@@ -142,7 +142,7 @@ class ExternalDataUseReporterTest : public testing::Test {
   }
 
   DataUseTabModel* data_use_tab_model() const {
-    return external_data_use_reporter()->data_use_tab_model_;
+    return external_data_use_observer()->GetDataUseTabModel();
   }
 
   const ExternalDataUseReporter::DataUseReports& buffered_data_reports() const {