Remove one thread hop while fetching matching rules

chrome/browser/android/data_usage/data_use_matcher.h

 // 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.
 
 #ifndef CHROME_BROWSER_ANDROID_DATA_USAGE_DATA_USE_MATCHER_H_
 #define CHROME_BROWSER_ANDROID_DATA_USAGE_DATA_USE_MATCHER_H_
 
 #include <string>
 #include <vector>
 
 #include "base/compiler_specific.h"
 #include "base/containers/hash_tables.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/thread_checker.h"
 #include "base/time/time.h"
 #include "chrome/browser/android/data_usage/data_use_tab_model.h"
 
 namespace base {
-class SingleThreadTaskRunner;
 class TickClock;
 }
 
 namespace re2 {
 class RE2;
 }
 
 class GURL;
 
 namespace chrome {
 
 namespace android {
 
-class ExternalDataUseObserver;
+class ExternalDataUseObserverBridge;
 
 // DataUseMatcher stores the matching URL patterns and package names along with
 // the labels. It also provides functionality to get the matching label for a
 // given URL or package. DataUseMatcher is not thread safe.
 class DataUseMatcher {
  public:
   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,
       const base::TimeDelta& default_matching_rule_expiration_duration);
 
   ~DataUseMatcher();
 
   // Called by FetchMatchingRulesDoneOnIOThread to register multiple
   // case-insensitive regular expressions. If the url of the data use request
   // matches any of the regular expression, the observation is passed to the
   // Java listener.
   void RegisterURLRegexes(const std::vector<std::string>& app_package_names,
                           const std::vector<std::string>& domain_path_regexes,
                           const std::vector<std::string>& labels);
 
   // Returns true if the |url| matches the registered regular expressions.
   // |label| must not be null. If a match is found, the |label| is set to the
   // matching rule's label.
   bool MatchesURL(const GURL& url, std::string* label) const WARN_UNUSED_RESULT;
 
   // Returns true if the |app_package_name| matches the registered package
   // names. |label| must not be null. If a match is found, the |label| is set
   // to the matching rule's label.
   bool MatchesAppPackageName(const std::string& app_package_name,
                              std::string* label) const WARN_UNUSED_RESULT;
 
   // Fetches the matching rules asynchronously from
-  // |external_data_use_observer_|.
+  // |external_data_use_observer_bridge_|.
   void FetchMatchingRules();
 
   // Returns true if there is any valid matching rule.
   bool HasValidRules() const;
 
  private:
   friend class DataUseMatcherTest;
   FRIEND_TEST_ALL_PREFIXES(DataUseMatcherTest,
                            EncodeExpirationTimeInPackageName);
   FRIEND_TEST_ALL_PREFIXES(DataUseMatcherTest,
@@ skipping 49 matching lines @@
   // |data_use_tab_model_| is notified if a label is removed from the set of
   // matching labels.
   base::WeakPtr<DataUseTabModel> data_use_tab_model_;
 
   // Default expiration duration of a matching rule, if expiration is not
   // specified in the rule.
   const base::TimeDelta default_matching_rule_expiration_duration_;
 
   // TickClock used for obtaining the current time.
   scoped_ptr<base::TickClock> tick_clock_;
-  // |io_task_runner_| is used to call ExternalDataUseObserver methods on
-  // IO thread.
-  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
-  // |external_data_use_observer_| is notified when matching rules are fetched.
-  base::WeakPtr<ExternalDataUseObserver> external_data_use_observer_;
+  // Pointer to the ExternalDataUseObserverBridge owned by
+  // ExternalDataUseObserver. DataUseTabModel (owner of |this|) and
+  // ExternalDataUseObserverBridge are owned by ExternalDataUseObserver, and are
+  // destroyed in that order. So |external_data_use_observer_bridge_| is
+  // guaranteed to be non-null.
+  const ExternalDataUseObserverBridge* external_data_use_observer_bridge_;
 
   DISALLOW_COPY_AND_ASSIGN(DataUseMatcher);
 };
 
 }  // namespace android
 
 }  // namespace chrome
 
 #endif  // CHROME_BROWSER_ANDROID_DATA_USAGE_DATA_USE_MATCHER_H_