Revert r207560 and r207566 to reland r207511.

ash/desktop_background/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 "ash/desktop_background/wallpaper_resizer.h"
 
 #include "ash/desktop_background/wallpaper_resizer_observer.h"
-#include "ash/test/ash_test_base.h"
+#include "base/message_loop/message_loop.h"
+#include "content/public/test/test_browser_thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
 #include "ui/gfx/image/image_skia_rep.h"
 
 using aura::RootWindow;
 using aura::Window;
 
 namespace {
 
 const int kTestImageWidth = 5;
 const int kTestImageHeight = 2;
 const int kTargetWidth = 1;
@@ skipping 29 matching lines @@
   const SkBitmap* image_bitmap = image.bitmap();
   SkAutoLockPixels image_lock(*image_bitmap);
   return *image_bitmap->getAddr32(0, 0) == expect;
 }
 
 }  // namespace
 
 namespace ash {
 namespace internal {
 
-class WallpaperResizerTest : public test::AshTestBase,
+class WallpaperResizerTest : public testing::Test,
                              public WallpaperResizerObserver {
  public:
-  WallpaperResizerTest() {}
+  WallpaperResizerTest()
+      : ui_thread_(content::BrowserThread::UI, &message_loop_) {
+  }
   virtual ~WallpaperResizerTest() {}
 
-  gfx::ImageSkia Resize(const WallpaperInfo& info,
+  gfx::ImageSkia Resize(const gfx::ImageSkia& image,
                         const gfx::Size& target_size,
-                        const gfx::ImageSkia& image) {
+                        WallpaperLayout layout) {
     scoped_ptr<WallpaperResizer> resizer;
-    resizer.reset(new WallpaperResizer(info, target_size, image));
+    resizer.reset(new WallpaperResizer(image, target_size, layout));
     resizer->AddObserver(this);
     resizer->StartResize();
     WaitForResize();
     resizer->RemoveObserver(this);
     return resizer->wallpaper_image();
   }
 
   void WaitForResize() {
-    base::MessageLoop::current()->Run();
+    message_loop_.Run();
   }
 
   virtual void OnWallpaperResized() OVERRIDE {
-    base::MessageLoop::current()->Quit();
+    message_loop_.Quit();
   }
 
  private:
+  base::MessageLoop message_loop_;
+  content::TestBrowserThread ui_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,
       WALLPAPER_LAYOUT_TILE,
   };
   const int length = arraysize(layouts);
 
   for (int i = 0; i < length; i++) {
     WallpaperLayout layout = layouts[i];
-    WallpaperInfo info = { 0, layout };
     gfx::ImageSkia small_image(gfx::ImageSkiaRep(gfx::Size(10, 20),
                                                  ui::SCALE_FACTOR_100P));
 
-    gfx::ImageSkia resized_small = Resize(info, gfx::Size(800, 600),
-                                          small_image);
+    gfx::ImageSkia resized_small = Resize(small_image, gfx::Size(800, 600),
+                                          layout);
     EXPECT_EQ(10, resized_small.width());
     EXPECT_EQ(20, resized_small.height());
 
     gfx::ImageSkia large_image(gfx::ImageSkiaRep(gfx::Size(1000, 1000),
                                                  ui::SCALE_FACTOR_100P));
-    gfx::ImageSkia resized_large = Resize(info, gfx::Size(800, 600),
-                                          large_image);
+    gfx::ImageSkia resized_large = Resize(large_image, gfx::Size(800, 600),
+                                          layout);
     EXPECT_EQ(800, resized_large.width());
     EXPECT_EQ(600, resized_large.height());
   }
 }
 
 // Test for crbug.com/244629. "CENTER_CROPPED generates the same image as
 // STRETCH layout"
 TEST_F(WallpaperResizerTest, AllLayoutDifferent) {
   gfx::ImageSkia image = CreateTestImage(
       gfx::Size(kTestImageWidth, kTestImageHeight));
 
   gfx::Size target_size = gfx::Size(kTargetWidth, kTargetHeight);
-  WallpaperInfo info_center = { 0, WALLPAPER_LAYOUT_CENTER };
-  gfx::ImageSkia center = Resize(info_center, target_size, image);
+  gfx::ImageSkia center = Resize(image, target_size, WALLPAPER_LAYOUT_CENTER);
 
-  WallpaperInfo info_center_cropped = { 0, WALLPAPER_LAYOUT_CENTER_CROPPED };
-  gfx::ImageSkia center_cropped = Resize(info_center_cropped, target_size,
-                                         image);
+  gfx::ImageSkia center_cropped = Resize(image, target_size,
+                                         WALLPAPER_LAYOUT_CENTER_CROPPED);
 
-  WallpaperInfo info_stretch = { 0, WALLPAPER_LAYOUT_STRETCH };
-  gfx::ImageSkia stretch = Resize(info_stretch, target_size, image);
+  gfx::ImageSkia stretch = Resize(image, target_size, WALLPAPER_LAYOUT_STRETCH);
 
-  WallpaperInfo info_tile = { 0, WALLPAPER_LAYOUT_TILE };
-  gfx::ImageSkia tile = Resize(info_tile, target_size, image);
+  gfx::ImageSkia tile = Resize(image, target_size, WALLPAPER_LAYOUT_TILE);
 
   EXPECT_TRUE(IsColor(center, kExpectedCenter));
   EXPECT_TRUE(IsColor(center_cropped, kExpectedCenterCropped));
   EXPECT_TRUE(IsColor(stretch, kExpectedStretch));
   EXPECT_TRUE(IsColor(tile, kExpectedTile));
 }
 
 }  // namespace internal
 }  // namespace ash