Remove call to GetBlockingPool in RLZ

components/rlz/rlz_tracker_unittest.cc

 // Copyright (c) 2012 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 "components/rlz/rlz_tracker.h"
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/test/scoped_task_environment.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "components/rlz/rlz_tracker_delegate.h"
 #include "net/url_request/url_request_test_util.h"
 #include "rlz/test/rlz_test_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_IOS)
 #include "ui/base/device_form_factor.h"
 #endif
 
 using testing::AssertionResult;
 using testing::AssertionSuccess;
 using testing::AssertionFailure;
 
 namespace rlz {
 namespace {
 
 class TestRLZTrackerDelegate : public RLZTrackerDelegate {
  public:
   TestRLZTrackerDelegate()
-      : worker_pool_owner_(2, "TestRLZTracker"),
-        request_context_getter_(new net::TestURLRequestContextGetter(
+      : request_context_getter_(new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get())) {}
 
   void set_brand(const char* brand) { brand_override_ = brand; }
 
   void set_reactivation_brand(const char* reactivation_brand) {
     // TODO(thakis): Reactivation doesn't exist on Mac yet.
     reactivation_brand_override_ = reactivation_brand;
   }
 
   void SimulateOmniboxUsage() {
@@ skipping 13 matching lines @@
   }
 
   // RLZTrackerDelegate implementation.
   void Cleanup() override {
     on_omnibox_search_callback_.Reset();
     on_homepage_search_callback_.Reset();
   }
 
   bool IsOnUIThread() override { return true; }
 
-  base::SequencedWorkerPool* GetBlockingPool() override {
-    return worker_pool_owner_.pool().get();
-  }
-
   net::URLRequestContextGetter* GetRequestContext() override {
     return request_context_getter_.get();
   }
 
   bool GetBrand(std::string* brand) override {
     *brand = brand_override_;
     return true;
   }
 
   bool IsBrandOrganic(const std::string& brand) override {
@@ skipping 17 matching lines @@
     DCHECK(!callback.is_null());
     on_omnibox_search_callback_ = callback;
   }
 
   void SetHomepageSearchCallback(const base::Closure& callback) override {
     DCHECK(!callback.is_null());
     on_homepage_search_callback_ = callback;
   }
 
  private:
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
   scoped_refptr<net::URLRequestContextGetter> request_context_getter_;
 
   std::string brand_override_;
   std::string reactivation_brand_override_;
   base::Closure on_omnibox_search_callback_;
   base::Closure on_homepage_search_callback_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRLZTrackerDelegate);
 };
 
@@ skipping 126 matching lines @@
 
   void SimulateOmniboxUsage();
   void SimulateHomepageUsage();
   void SimulateAppListUsage();
   void InvokeDelayedInit();
 
   void ExpectEventRecorded(const char* event_name, bool expected);
   void ExpectRlzPingSent(bool expected);
   void ExpectReactivationRlzPingSent(bool expected);
 
-  base::MessageLoop message_loop_;
+  base::test::ScopedTaskEnvironment scoped_task_environment_;
   TestRLZTrackerDelegate* delegate_;
   std::unique_ptr<TestRLZTracker> tracker_;
   RlzLibTestNoMachineStateHelper m_rlz_test_helper_;
 };
 
 void RlzLibTest::SetUp() {
   testing::Test::SetUp();
   m_rlz_test_helper_.SetUp();
 
   delegate_ = new TestRLZTrackerDelegate;
@@ skipping 731 matching lines @@
 
   ExpectEventRecorded(OmniboxFirstSearch(), true);
 
   RLZTracker::ClearRlzState();
 
   ExpectEventRecorded(OmniboxFirstSearch(), false);
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace rlz