Replace single-threaded SequencedWorkerPool with base::Thread in WallpaperResizerTest.

components/wallpaper/wallpaper_resizer_unittest.cc

 // Copyright 2013 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/wallpaper/wallpaper_resizer.h"
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
-#include "base/test/sequenced_worker_pool_owner.h"
+#include "base/threading/thread.h"
 #include "components/wallpaper/wallpaper_resizer_observer.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/image/image_skia_rep.h"
 
 namespace {
 
 const int kTestImageWidth = 5;
 const int kTestImageHeight = 2;
 const int kTargetWidth = 1;
 const int kTargetHeight = 1;
@@ skipping 30 matching lines @@
   return *image_bitmap->getAddr32(0, 0) == expect;
 }
 
 }  // namespace
 
 namespace wallpaper {
 
 class WallpaperResizerTest : public testing::Test,
                              public WallpaperResizerObserver {
  public:
-  WallpaperResizerTest() : worker_pool_owner_(1, "WallpaperResizerTest") {}
+  WallpaperResizerTest() : worker_thread_("WallpaperResizerTest") {}
   ~WallpaperResizerTest() override {}
 
+  void SetUp() override {
+    ASSERT_TRUE(worker_thread_.Start());
+  }
+
   gfx::ImageSkia Resize(const gfx::ImageSkia& image,
                         const gfx::Size& target_size,
                         WallpaperLayout layout) {
     std::unique_ptr<WallpaperResizer> resizer;
     resizer.reset(
-        new WallpaperResizer(image, target_size, layout, worker_pool()));
+        new WallpaperResizer(image, target_size, layout, task_runner()));
     resizer->AddObserver(this);
     resizer->StartResize();
     WaitForResize();
     resizer->RemoveObserver(this);
     return resizer->image();
   }
 
-  base::SequencedWorkerPool* worker_pool() {
-    return worker_pool_owner_.pool().get();
+  scoped_refptr<base::TaskRunner> task_runner() {
+    return worker_thread_.task_runner();
   }
 
   void WaitForResize() { base::RunLoop().Run(); }
 
   void OnWallpaperResized() override { message_loop_.QuitWhenIdle(); }
 
  private:
   base::MessageLoop message_loop_;
-  base::SequencedWorkerPoolOwner worker_pool_owner_;
+  base::Thread worker_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(WallpaperResizerTest);
 };
 
 TEST_F(WallpaperResizerTest, BasicResize) {
   // Keeps in sync with WallpaperLayout enum.
   WallpaperLayout layouts[4] = {
       WALLPAPER_LAYOUT_CENTER,
       WALLPAPER_LAYOUT_CENTER_CROPPED,
       WALLPAPER_LAYOUT_STRETCH,
@@ skipping 40 matching lines @@
   EXPECT_TRUE(IsColor(tile, kExpectedTile));
 }
 
 TEST_F(WallpaperResizerTest, ImageId) {
   gfx::ImageSkia image =
       CreateTestImage(gfx::Size(kTestImageWidth, kTestImageHeight));
 
   // Create a WallpaperResizer and check that it reports an original image ID
   // both pre- and post-resize that matches the ID returned by GetImageId().
   WallpaperResizer resizer(image, gfx::Size(10, 20), WALLPAPER_LAYOUT_STRETCH,
-                           worker_pool());
+                           task_runner());
   EXPECT_EQ(WallpaperResizer::GetImageId(image), resizer.original_image_id());
   resizer.AddObserver(this);
   resizer.StartResize();
   WaitForResize();
   resizer.RemoveObserver(this);
   EXPECT_EQ(WallpaperResizer::GetImageId(image), resizer.original_image_id());
 }
 
 }  // namespace ash