Remove one thread hop while fetching matching rules

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/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.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 scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner,
-    const base::WeakPtr<ExternalDataUseObserver>& external_data_use_observer,
+    const ExternalDataUseObserverBridge* external_data_use_observer_bridge,

[Raj, 2016/03/08 06:33:07]

ExternalDataUseObserverBridge lives in UI thread, and avoids one UI-IO thread
hop while fetching rules. I measured that the thread hop for the initial rule
fetch accounted for ~50ms.

[tbansal1, 2016/03/08 18:15:00]

I am confused. Is this related to the buffering of navigation events? For my own
convenience :), I would suggest splitting into 3 CLs:
1) Buffering + Processing of UI events.
2) Fetching the matching rules when the control app is installed.
3) Removing one thread-hop by passing Bridge instead of EDUO. Also, can you not
skip this thread hop by unconditionally fetching the matching rules in
Bridge::Init() method.

[Raj, 2016/03/09 02:27:35]

Sorry. Will split into 3 CLs.

     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),
       tick_clock_(new base::DefaultTickClock()),
-      io_task_runner_(io_task_runner),
-      external_data_use_observer_(external_data_use_observer) {
-  DCHECK(io_task_runner_);
+      external_data_use_observer_bridge_(external_data_use_observer_bridge) {
+  DCHECK(external_data_use_observer_bridge_);
 }
 
 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 37 matching lines @@
 
   for (const std::string& label : removed_matching_rule_labels) {
     if (data_use_tab_model_)
       data_use_tab_model_->OnTrackingLabelRemoved(label);
   }
   UMA_HISTOGRAM_COUNTS_100("DataUsage.MatchingRulesCount.Valid",
                            matching_rules_.size());
   UMA_HISTOGRAM_COUNTS_100("DataUsage.MatchingRulesCount.Invalid",
                            invalid_rules);
 
-  DCHECK(io_task_runner_);
-
-  // Notify |external_data_use_observer_| if it should register as a data use
-  // observer.
-  io_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&ExternalDataUseObserver::ShouldRegisterAsDataUseObserver,
-                 external_data_use_observer_, !matching_rules_.empty()));
+  DCHECK(external_data_use_observer_bridge_);
+  external_data_use_observer_bridge_->ShouldRegisterAsDataUseObserver(
+      !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 29 matching lines @@
       *label = matching_rule->label();
       return true;
     }
   }
 
   return false;
 }
 
 void DataUseMatcher::FetchMatchingRules() {
   DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK(io_task_runner_);
-
-  // Notify |external_data_use_observer_| to fetch the rules.
-  io_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&ExternalDataUseObserver::FetchMatchingRules,
-                            external_data_use_observer_));
+  DCHECK(external_data_use_observer_bridge_);
+  external_data_use_observer_bridge_->FetchMatchingRules();
 }
 
 bool DataUseMatcher::HasValidRules() const {
   return !matching_rules_.empty();
 }
 
 void DataUseMatcher::ParsePackageField(const std::string& app_package_name,
                                        std::string* new_app_package_name,
                                        base::TimeTicks* expiration) const {
   const char separator = '|';
@@ skipping 36 matching lines @@
   return label_;
 }
 
 const base::TimeTicks& DataUseMatcher::MatchingRule::expiration() const {
   return expiration_;
 }
 
 }  // namespace android
 
 }  // namespace chrome