chrome: Use base::MessageLoop. (Part 3)

chrome/browser/extensions/extension_icon_image_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 "chrome/browser/extensions/extension_icon_image.h"
 
 #include "base/json/json_file_value_serializer.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "chrome/browser/extensions/image_loader.h"
@@ skipping 64 matching lines @@
       : extension_(extension),
         waiting_(false),
         image_loaded_(false) {
   }
   virtual ~TestImageLoader() {}
 
   void OnImageLoaded(const gfx::Image& image) {
     image_ = image;
     image_loaded_ = true;
     if (waiting_)
-      MessageLoop::current()->Quit();
+      base::MessageLoop::current()->Quit();
   }
 
   SkBitmap LoadBitmap(const std::string& path,
                       int size) {
     image_loaded_ = false;
 
     image_loader_.LoadImageAsync(
         extension_, extension_->GetResource(path), gfx::Size(size, size),
         base::Bind(&TestImageLoader::OnImageLoaded,
                    base::Unretained(this)));
 
     // If |image_| still hasn't been loaded (i.e. it is being loaded
     // asynchronously), wait for it.
     if (!image_loaded_) {
       waiting_ = true;
-      MessageLoop::current()->Run();
+      base::MessageLoop::current()->Run();
       waiting_ = false;
     }
 
     EXPECT_TRUE(image_loaded_);
 
     return image_.IsEmpty() ? SkBitmap() : *image_.ToSkBitmap();
   }
 
  private:
   const Extension* extension_;
@@ skipping 13 matching lines @@
         quit_in_image_loaded_(false),
         ui_thread_(BrowserThread::UI, &ui_loop_),
         file_thread_(BrowserThread::FILE),
         io_thread_(BrowserThread::IO) {
   }
 
   virtual ~ExtensionIconImageTest() {}
 
   void WaitForImageLoad() {
     quit_in_image_loaded_ = true;
-    MessageLoop::current()->Run();
+    base::MessageLoop::current()->Run();
     quit_in_image_loaded_ = false;
   }
 
   int ImageLoadedCount() {
     int result = image_loaded_count_;
     image_loaded_count_ = 0;
     return result;
   }
 
   scoped_refptr<Extension> CreateExtension(const char* name,
@@ skipping 26 matching lines @@
   // testing::Test overrides:
   virtual void SetUp() OVERRIDE {
     file_thread_.Start();
     io_thread_.Start();
   }
 
   // IconImage::Delegate overrides:
   virtual void OnExtensionIconImageChanged(IconImage* image) OVERRIDE {
     image_loaded_count_++;
     if (quit_in_image_loaded_)
-      MessageLoop::current()->Quit();
+      base::MessageLoop::current()->Quit();
   }
 
   gfx::ImageSkia GetDefaultIcon() {
     return *ui::ResourceBundle::GetSharedInstance().GetImageSkiaNamed(
         IDR_EXTENSIONS_FAVICON);
   }
 
   // Loads an image to be used in test from the extension.
   // The image will be loaded from the relative path |path|.
   SkBitmap GetTestBitmap(const Extension* extension,
                          const std::string& path,
                          int size) {
     TestImageLoader image_loader(extension);
     return image_loader.LoadBitmap(path, size);
   }
 
  private:
   int image_loaded_count_;
   bool quit_in_image_loaded_;
-  MessageLoop ui_loop_;
+  base::MessageLoop ui_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(ExtensionIconImageTest);
 };
 
 }  // namespace
 
 TEST_F(ExtensionIconImageTest, Basic) {
@@ skipping 334 matching lines @@
   EXPECT_EQ(16, representation.pixel_width());
   EXPECT_TRUE(gfx::BitmapsAreEqual(representation.sk_bitmap(), bitmap_16));
 
   // When requesting another representation, we should get blank image.
   representation = image_skia.GetRepresentation(ui::SCALE_FACTOR_200P);
 
   EXPECT_TRUE(gfx::BitmapsAreEqual(
       representation.sk_bitmap(),
       CreateBlankBitmapForScale(16, ui::SCALE_FACTOR_200P)));
 }