Make ExternalDataUseReporter independent of other data use classes

chrome/browser/android/data_usage/external_data_use_reporter.h

 // 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.
 
 #ifndef CHROME_BROWSER_ANDROID_DATA_USAGE_EXTERNAL_DATA_USE_REPORTER_H_
 #define CHROME_BROWSER_ANDROID_DATA_USAGE_EXTERNAL_DATA_USE_REPORTER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <deque>
 #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)
 #include "base/android/application_status_listener.h"
 #endif
 
 namespace data_usage {
 struct DataUse;
 }
 
 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
 // data usage bytes is reached, or when Chromium goes into background, or when
 // the previous report submission times out. This class is not thread safe, and
 // 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 {
     // Submission of data use report to the external observer was successful.
     DATAUSAGE_REPORT_SUBMISSION_SUCCESSFUL = 0,
     // Submission of data use report to the external observer returned error.
     DATAUSAGE_REPORT_SUBMISSION_FAILED = 1,
     // Submission of data use report to the external observer timed out.
     DATAUSAGE_REPORT_SUBMISSION_TIMED_OUT = 2,
     // Data use report was lost before an attempt was made to submit it.
     DATAUSAGE_REPORT_SUBMISSION_LOST = 3,
     DATAUSAGE_REPORT_SUBMISSION_MAX = 4
   };
 
   // The caller should guarantee that |data_use_tab_model| and
   // |external_data_use_observer_bridge| to be non-null during the lifetime of
   // |this|. |field_trial| is the field trial name to get the various
   // 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();
 
   // Notifies the ExternalDataUseReporter of data usage. The data use is labeled
   // using |data_use_tab_model_|, buffered and then reported to
   // |external_data_use_observer_bridge_| later.
   void OnDataUse(std::unique_ptr<const std::deque<const data_usage::DataUse>>
                      data_use_list);
 
@@ skipping 107 matching lines @@
   // submit the report immediately or to wait until |data_use_report_min_bytes_|
   // unreported bytes are buffered.
   void SubmitBufferedDataUseReport(bool immediate);
 
 #if defined(OS_ANDROID)
   // Called whenever the application transitions from foreground to background
   // or vice versa.
   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
   // reports.
   std::unique_ptr<base::android::ApplicationStatusListener> app_state_listener_;
 #endif
 
   // Time when the currently pending data use report was submitted.
   // |last_data_report_submitted_ticks_| is null if no data use report is
   // currently pending.
@@ skipping 25 matching lines @@
   base::ThreadChecker thread_checker_;
 
   DISALLOW_COPY_AND_ASSIGN(ExternalDataUseReporter);
 };
 
 }  // namespace android
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_ANDROID_DATA_USAGE_EXTERNAL_DATA_USE_REPORTER_H_