Tests: Simplify SequencedWorkerPoolOwner, call Shutdown on destructor.

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 "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.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/thread_task_runner_handle.h"
-#include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.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_(new base::SequencedWorkerPool(1, "TestRLZTracker")),
+      : worker_pool_owner_(1, "TestRLZTracker"),
         request_context_getter_(new net::TestURLRequestContextGetter(
             base::ThreadTaskRunnerHandle::Get())) {}
 
-  ~TestRLZTrackerDelegate() override { worker_pool_->Shutdown(); }
-
   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() {
     using std::swap;
     base::Closure callback;
@@ skipping 12 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_.get();
+    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;
   }
@@ skipping 19 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:
-  scoped_refptr<base::SequencedWorkerPool> worker_pool_;
+  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 878 matching lines @@
 
   ExpectEventRecorded(OmniboxFirstSearch(), true);
 
   RLZTracker::ClearRlzState();
 
   ExpectEventRecorded(OmniboxFirstSearch(), false);
 }
 #endif  // defined(OS_CHROMEOS)
 
 }  // namespace rlz