Make ExternalDataUseReporter independent of other data use classes

chrome/browser/android/data_usage/external_data_use_reporter.cc

 // Copyright 2016 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_reporter.h"
 
 #include <utility>
 
 #include "base/metrics/field_trial.h"
 #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"
 
 namespace chrome {
 
 namespace android {
 
 namespace {
 
 // Default duration after which a pending data use report is considered timed
@@ skipping 68 matching lines @@
   return kDefaultDataUseReportMinBytes;
 }
 
 }  // namespace
 
 // static
 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 base::Callback<bool(SessionID::id_type,

[tbansal1, 2016/07/21 00:19:30]

You can use typedef here too.

[Raj, 2016/07/21 04:09:16]

Done.

+                              const base::TimeTicks&,
+                              DataUseTabModel::TrackingInfo*)>&
+        get_tracking_info_callback,
+    const 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)>& 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()),
       total_bytes_buffered_(0),
       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..
   thread_checker_.DetachFromThread();
 }
 
 void ExternalDataUseReporter::InitOnUIThread() {
   DCHECK(thread_checker_.CalledOnValidThread());
 #if defined(OS_ANDROID)
   app_state_listener_.reset(new base::android::ApplicationStatusListener(
       base::Bind(&ExternalDataUseReporter::OnApplicationStateChange,
                  base::Unretained(this))));
 #endif
 }
 
 ExternalDataUseReporter::~ExternalDataUseReporter() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 void ExternalDataUseReporter::OnDataUse(const data_usage::DataUse& data_use) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   const base::Time now_time = base::Time::Now();
   DataUseTabModel::TrackingInfo tracking_info;
 
-  if (!data_use_tab_model_->GetTrackingInfoForTabAtTime(
-          data_use.tab_id, data_use.request_start, &tracking_info)) {
+  if (!get_tracking_info_callback_.Run(data_use.tab_id, data_use.request_start,
+                                       &tracking_info)) {
     return;
   }
 
   BufferDataUseReport(data_use, tracking_info.label, tracking_info.tag,
                       previous_report_time_, now_time);
   SubmitBufferedDataUseReport(false);
   previous_report_time_ = now_time;
 }
 
 void ExternalDataUseReporter::OnReportDataUseDone(bool success) {
@@ skipping 115 matching lines @@
 
   DCHECK_EQ(0, pending_report_bytes_);
   DCHECK(last_data_report_submitted_ticks_.is_null());
   pending_report_bytes_ = report.bytes_downloaded + report.bytes_uploaded;
   last_data_report_submitted_ticks_ = ticks_now;
 
   // Remove the entry from the map.
   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(
     const std::string& label,
     const std::string& tag,
     net::NetworkChangeNotifier::ConnectionType connection_type,
     const std::string& mcc_mnc)
     : label(label),
       tag(tag),
       connection_type(connection_type),
@@ skipping 32 matching lines @@
   hash = hash * 23 + hash_function(k.label);
   hash = hash * 31 + hash_function(k.tag);
   hash = hash * 43 + k.connection_type;
   hash = hash * 83 + hash_function(k.mcc_mnc);
   return hash;
 }
 
 }  // namespace android
 
 }  // namespace chrome