Remove one thread hop while fetching matching rules

chrome/browser/android/data_usage/data_use_ui_tab_model_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_ui_tab_model.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/macros.h"
@@ skipping 15 matching lines @@
 
 namespace chrome {
 
 namespace android {
 
 namespace {
 
 const char kFooLabel[] = "foo_label";
 const char kFooPackage[] = "com.foo";
 
+}  // namespace
+
 class TestDataUseTabModel : public DataUseTabModel {
  public:
   TestDataUseTabModel() {}
   ~TestDataUseTabModel() override {}
 
   using DataUseTabModel::NotifyObserversOfTrackingStarting;
   using DataUseTabModel::NotifyObserversOfTrackingEnding;
 };
 
 class DataUseUITabModelTest : public testing::Test {
  public:
   DataUseUITabModelTest()
       : thread_bundle_(content::TestBrowserThreadBundle::IO_MAINLOOP) {}
   DataUseUITabModel* data_use_ui_tab_model() { return &data_use_ui_tab_model_; }
 
-  ExternalDataUseObserver* external_data_use_observer() const {
-    return external_data_use_observer_.get();
-  }
-
   TestDataUseTabModel* data_use_tab_model() const {
     return data_use_tab_model_.get();
   }
 
   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_tab_model_->RegisterURLRegexes(app_package_name, domain_path_regex,
                                             label);
   }
 
  protected:
   void SetUp() override {
     io_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
         content::BrowserThread::IO);
     ui_task_runner_ = content::BrowserThread::GetMessageLoopProxyForThread(
         content::BrowserThread::UI);
 
     data_use_aggregator_.reset(
         new data_usage::DataUseAggregator(nullptr, nullptr));
 
     external_data_use_observer_.reset(new ExternalDataUseObserver(
         data_use_aggregator_.get(), io_task_runner_, ui_task_runner_));
     // Wait for |external_data_use_observer_| to create the Java object.
     base::RunLoop().RunUntilIdle();
 
     data_use_tab_model_.reset(new TestDataUseTabModel());
     data_use_tab_model_->InitOnUIThread(
-        io_task_runner_, external_data_use_observer_->GetWeakPtr());
+        external_data_use_observer_->external_data_use_observer_bridge_);
     data_use_ui_tab_model_.SetDataUseTabModel(data_use_tab_model_.get());
     data_use_tab_model_->OnControlAppInstallStateChange(true);
   }
 
  private:
   content::TestBrowserThreadBundle thread_bundle_;
   DataUseUITabModel data_use_ui_tab_model_;
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
   scoped_refptr<base::SingleThreadTaskRunner> ui_task_runner_;
   scoped_ptr<data_usage::DataUseAggregator> data_use_aggregator_;
   scoped_ptr<ExternalDataUseObserver> external_data_use_observer_;
   scoped_ptr<TestDataUseTabModel> data_use_tab_model_;
 };
 
-}  // namespace
-
 // Tests that DataUseTabModel is notified of tab closure and navigation events,
 // and DataUseTabModel notifies DataUseUITabModel.
 TEST_F(DataUseUITabModelTest, ReportTabEventsTest) {
   std::vector<std::string> url_regexes;
   url_regexes.push_back(
       "http://www[.]foo[.]com/#q=.*|https://www[.]foo[.]com/#q=.*");
   RegisterURLRegexes(std::vector<std::string>(url_regexes.size(), kFooPackage),
                      url_regexes,
                      std::vector<std::string>(url_regexes.size(), kFooLabel));
 
@@ skipping 325 matching lines @@
   EXPECT_FALSE(data_use_ui_tab_model()->ConvertTransitionType(
       ui::PageTransition(ui::PAGE_TRANSITION_MANUAL_SUBFRAME),
       &transition_type));
   EXPECT_FALSE(data_use_ui_tab_model()->ConvertTransitionType(
       ui::PageTransition(ui::PAGE_TRANSITION_FORM_SUBMIT), &transition_type));
 }
 
 }  // namespace android
 
 }  // namespace chrome