Remove one thread hop while fetching matching rules

chrome/browser/android/data_usage/data_use_matcher_unittest.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 <string>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/test/histogram_tester.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 "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
 namespace {
 
 const char kUMAMatchingRulesCountValidHistogram[] =
     "DataUsage.MatchingRulesCount.Valid";
 const char kUMAMatchingRulesCountInvalidHistogram[] =
@@ skipping 19 matching lines @@
   void set_now_ticks(const base::TimeTicks& now_ticks) {
     now_ticks_ = now_ticks;
   }
 
  private:
   base::TimeTicks now_ticks_;
 
   DISALLOW_COPY_AND_ASSIGN(NowTestTickClock);
 };
 
+class TestExternalDataUseObserverBridge
+    : public chrome::android::ExternalDataUseObserverBridge {
+ public:
+  TestExternalDataUseObserverBridge() {}
+  void FetchMatchingRules() const override {}
+  void ShouldRegisterAsDataUseObserver(bool should_register) const override{};
+};
+
 }  // namespace
 
 namespace chrome {
 
 namespace android {
 
 class ExternalDataUseObserver;
 
 class DataUseMatcherTest : public testing::Test {
  public:
   DataUseMatcherTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP),
+        external_data_use_observer_bridge_(
+            new TestExternalDataUseObserverBridge()),
         data_use_matcher_(base::WeakPtr<DataUseTabModel>(),
-                          content::BrowserThread::GetMessageLoopProxyForThread(
-                              content::BrowserThread::IO),
-                          base::WeakPtr<ExternalDataUseObserver>(),
+                          external_data_use_observer_bridge_.get(),
                           base::TimeDelta::FromSeconds(
                               kDefaultMatchingRuleExpirationDurationSeconds)) {}
 
   DataUseMatcher* data_use_matcher() { return &data_use_matcher_; }
 
   void RegisterURLRegexes(const std::vector<std::string>& app_package_name,
                           const std::vector<std::string>& domain_path_regex,
                           const std::vector<std::string>& label) {
     data_use_matcher_.RegisterURLRegexes(app_package_name, domain_path_regex,
                                          label);
   }
 
   // Returns true if the matching rule at |index| is expired.
   bool IsExpired(size_t index) {
     DCHECK_LT(index, data_use_matcher_.matching_rules_.size());
     return data_use_matcher_.matching_rules_[index]->expiration() <
            data_use_matcher_.tick_clock_->NowTicks();
   }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
+  scoped_ptr<ExternalDataUseObserverBridge> external_data_use_observer_bridge_;
   DataUseMatcher data_use_matcher_;
   DISALLOW_COPY_AND_ASSIGN(DataUseMatcherTest);
 };
 
 TEST_F(DataUseMatcherTest, SingleRegex) {
   const struct {
     std::string url;
     std::string regex;
     bool expect_match;
     int expect_count_valid_rules;
@@ skipping 426 matching lines @@
                             base::TimeDelta::FromMilliseconds(10001));
 
   EXPECT_TRUE(IsExpired(0));
   EXPECT_FALSE(data_use_matcher()->MatchesURL(GURL(kRegexFoo), &got_label));
   EXPECT_FALSE(data_use_matcher()->MatchesAppPackageName(kAppFoo, &got_label));
 }
 
 }  // namespace android
 
 }  // namespace chrome