Make DataUseTabModel and DataUseMatcher more independent

chrome/browser/android/data_usage/data_use_tab_model.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/data_use_tab_model.h"
 
 #include <stdint.h>
 
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/default_tick_clock.h"
 #include "base/time/tick_clock.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/data_usage/data_use_matcher.h"
 #include "chrome/browser/android/data_usage/external_data_use_observer.h"
+#include "chrome/browser/android/data_usage/external_data_use_observer_bridge.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_entry.h"
 #include "url/gurl.h"
 
 namespace {
 
 // Default maximum number of tabs to maintain session information about. May be
 // overridden by the field trial.
 const size_t kDefaultMaxTabEntries = 200;
@@ skipping 101 matching lines @@
 }  // namespace
 
 namespace chrome {
 
 namespace android {
 
 // static
 const char DataUseTabModel::kDefaultTag[] = "ChromeTab";
 const char DataUseTabModel::kCustomTabTag[] = "ChromeCustomTab";
 
-DataUseTabModel::DataUseTabModel()
+DataUseTabModel::DataUseTabModel(
+    const base::Closure& fetch_matching_rules_callback,
+    const base::Callback<void(bool)>& on_matching_rules_fetched_callback)
     : max_tab_entries_(GetMaxTabEntries()),
       max_sessions_per_tab_(GetMaxSessionsPerTab()),
       closed_tab_expiration_duration_(GetClosedTabExpirationDuration()),
       open_tab_expiration_duration_(GetOpenTabExpirationDuration()),
+      tick_clock_(new base::DefaultTickClock()),
+      data_use_matcher_(new DataUseMatcher(
+          base::Bind(&DataUseTabModel::OnTrackingLabelRemoved, GetWeakPtr()),
+          on_matching_rules_fetched_callback,
+          GetDefaultMatchingRuleExpirationDuration())),
+      fetch_matching_rules_callback_(fetch_matching_rules_callback),
       is_ready_for_navigation_event_(false),
       is_control_app_installed_(false),
       weak_factory_(this) {
   // Detach from current thread since rest of DataUseTabModel lives on the UI
   // thread and the current thread may not be UI thread..
   thread_checker_.DetachFromThread();
 }
 
 DataUseTabModel::~DataUseTabModel() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 base::WeakPtr<DataUseTabModel> DataUseTabModel::GetWeakPtr() {
   DCHECK(thread_checker_.CalledOnValidThread());
   return weak_factory_.GetWeakPtr();
 }
 
-void DataUseTabModel::InitOnUIThread(
-    const ExternalDataUseObserverBridge* external_data_use_observer_bridge) {
+void DataUseTabModel::InitOnUIThread() {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(external_data_use_observer_bridge);
-
-  tick_clock_.reset(new base::DefaultTickClock());
-  data_use_matcher_.reset(
-      new DataUseMatcher(GetWeakPtr(), external_data_use_observer_bridge,
-                         GetDefaultMatchingRuleExpirationDuration()));
 }
 
 void DataUseTabModel::OnNavigationEvent(
     SessionID::id_type tab_id,
     TransitionType transition,
     const GURL& url,
     const std::string& package,
     content::NavigationEntry* navigation_entry) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(IsValidTabID(tab_id));
   DCHECK(!navigation_entry || (navigation_entry->GetURL() == url));
 
   std::string current_label, new_label;
   bool is_package_match;
 
   if (is_control_app_installed_ && !data_use_matcher_->HasRules())
-    data_use_matcher_->FetchMatchingRules();
+    fetch_matching_rules_callback_.Run();
 
   GetCurrentAndNewLabelForNavigationEvent(tab_id, transition, url, package,
                                           navigation_entry, &current_label,
                                           &new_label, &is_package_match);
   if (!current_label.empty() && new_label.empty()) {
     EndTrackingDataUse(tab_id);
   } else if (current_label.empty() && !new_label.empty()) {
     StartTrackingDataUse(
         tab_id, new_label,
         ((transition == TRANSITION_CUSTOM_TAB) && is_package_match));
@@ skipping 12 matching lines @@
   TabEntryMap::iterator tab_entry_iterator = active_tabs_.find(tab_id);
   if (tab_entry_iterator == active_tabs_.end())
     return;
 
   TabDataUseEntry& tab_entry = tab_entry_iterator->second;
   if (tab_entry.IsTrackingDataUse())
     tab_entry.EndTracking();
   tab_entry.OnTabCloseEvent();
 }
 
-void DataUseTabModel::OnTrackingLabelRemoved(std::string label) {
+void DataUseTabModel::OnTrackingLabelRemoved(const std::string& label) {
   for (auto& tab_entry : active_tabs_)
     tab_entry.second.EndTrackingWithLabel(label);
 }
 
 bool DataUseTabModel::GetTrackingInfoForTabAtTime(
     SessionID::id_type tab_id,
     base::TimeTicks timestamp,
     TrackingInfo* output_tracking_info) const {
   DCHECK(thread_checker_.CalledOnValidThread());
 
@@ skipping 72 matching lines @@
   std::vector<std::string> empty;
   if (!is_control_app_installed_) {
     // Clear rules.
     data_use_matcher_->RegisterURLRegexes(empty, empty, empty);
     if (!is_ready_for_navigation_event_) {
       is_ready_for_navigation_event_ = true;
       NotifyObserversOfDataUseTabModelReady();
     }
   } else {
     // Fetch the matching rules when the app is installed.
-    data_use_matcher_->FetchMatchingRules();
+    fetch_matching_rules_callback_.Run();
   }
 }
 
 base::TimeTicks DataUseTabModel::NowTicks() const {
   DCHECK(thread_checker_.CalledOnValidThread());
   return tick_clock_->NowTicks();
 }
 
 bool DataUseTabModel::IsCustomTabPackageMatch(SessionID::id_type tab_id) const {
   DCHECK(thread_checker_.CalledOnValidThread());
@@ skipping 192 matching lines @@
         NowTicks() -
             oldest_tab_entry_iterator->second.GetLatestStartOrEndTime(),
         base::TimeDelta::FromMinutes(1), base::TimeDelta::FromHours(1), 50);
     active_tabs_.erase(oldest_tab_entry_iterator);
   }
 }
 
 }  // namespace android
 
 }  // namespace chrome