Make DataUseTabModel and DataUseMatcher more independent

chrome/browser/android/data_usage/data_use_matcher.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_matcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_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/external_data_use_observer_bridge.h"
 #include "third_party/re2/src/re2/re2.h"
 #include "url/gurl.h"
 
 namespace chrome {
 
 namespace android {
 
 DataUseMatcher::DataUseMatcher(
-    const base::WeakPtr<DataUseTabModel>& data_use_tab_model,
-    const ExternalDataUseObserverBridge* external_data_use_observer_bridge,
+    const base::Callback<void(const std::string&)>&
+        on_tracking_label_removed_callback,
+    const base::Callback<void(bool)>& on_matching_rules_fetched_callback,
     const base::TimeDelta& default_matching_rule_expiration_duration)
-    : data_use_tab_model_(data_use_tab_model),
-      default_matching_rule_expiration_duration_(
+    : default_matching_rule_expiration_duration_(
           default_matching_rule_expiration_duration),
       tick_clock_(new base::DefaultTickClock()),
-      external_data_use_observer_bridge_(external_data_use_observer_bridge) {
-  DCHECK(external_data_use_observer_bridge_);
+      on_tracking_label_removed_callback_(on_tracking_label_removed_callback),
+      on_matching_rules_fetched_callback_(on_matching_rules_fetched_callback) {
+  DCHECK(on_tracking_label_removed_callback_);
+  DCHECK(on_matching_rules_fetched_callback_);
+  // Detach from current thread since rest of DataUseMatcher lives on the UI
+  // thread and the current thread may not be UI thread..
+  thread_checker_.DetachFromThread();
 }
 
 DataUseMatcher::~DataUseMatcher() {}
 
 void DataUseMatcher::RegisterURLRegexes(
     const std::vector<std::string>& app_package_names,
     const std::vector<std::string>& domain_path_regexes,
     const std::vector<std::string>& labels) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(app_package_names.size(), domain_path_regexes.size());
@@ skipping 28 matching lines @@
 
     if (expiration <= now_ticks)
       continue;  // skip expired matching rules.
     DCHECK(!labels.at(i).empty());
     matching_rules_.push_back(base::WrapUnique(new MatchingRule(
         app_package_name, std::move(pattern), labels.at(i), expiration)));
 
     removed_matching_rule_labels.erase(labels.at(i));
   }
 
-  for (const std::string& label : removed_matching_rule_labels) {
-    if (data_use_tab_model_)
-      data_use_tab_model_->OnTrackingLabelRemoved(label);
-  }
+  for (const std::string& label : removed_matching_rule_labels)
+    on_tracking_label_removed_callback_.Run(label);
+
   UMA_HISTOGRAM_COUNTS_100("DataUsage.MatchingRulesCount.Valid",
                            matching_rules_.size());
   UMA_HISTOGRAM_COUNTS_100("DataUsage.MatchingRulesCount.Invalid",
                            invalid_rules);
 
-  external_data_use_observer_bridge_->ShouldRegisterAsDataUseObserver(
-      !matching_rules_.empty());
+  on_matching_rules_fetched_callback_.Run(!matching_rules_.empty());
 }
 
 bool DataUseMatcher::MatchesURL(const GURL& url, std::string* label) const {
   const base::TimeTicks now_ticks = tick_clock_->NowTicks();
   DCHECK(thread_checker_.CalledOnValidThread());
   *label = "";
 
   if (!url.is_valid() || url.is_empty())
     return false;
 
@@ skipping 27 matching lines @@
       continue;  // skip expired matching rules.
     if (app_package_name == matching_rule->app_package_name()) {
       *label = matching_rule->label();
       return true;
     }
   }
 
   return false;
 }
 
-void DataUseMatcher::FetchMatchingRules() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  external_data_use_observer_bridge_->FetchMatchingRules();
-}
-
 bool DataUseMatcher::HasRules() const {
   return !matching_rules_.empty();
 }
 
 bool DataUseMatcher::HasValidRuleWithLabel(const std::string& label) const {
   for (const auto& matching_rule : matching_rules_) {
     if (matching_rule->expiration() > tick_clock_->NowTicks() &&
         label == matching_rule->label()) {
       return true;
     }
@@ skipping 44 matching lines @@
   return label_;
 }
 
 const base::TimeTicks& DataUseMatcher::MatchingRule::expiration() const {
   return expiration_;
 }
 
 }  // namespace android
 
 }  // namespace chrome