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

chrome/browser/storage_monitor/storage_monitor_linux_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.
 
 // StorageMonitorLinux unit tests.
 
 #include "chrome/browser/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
@@ skipping 104 matching lines @@
   }
   if (device == kInvalidDevice) {
     return StorageInfo::MakeDeviceId(StorageInfo::FIXED_MASS_STORAGE,
                                           kInvalidDevice);
   }
   return std::string();
 }
 
 class TestStorageMonitorLinux : public StorageMonitorLinux {
  public:
-  TestStorageMonitorLinux(const base::FilePath& path, MessageLoop* message_loop)
+  TestStorageMonitorLinux(const base::FilePath& path,
+                          base::MessageLoop* message_loop)
       : StorageMonitorLinux(path),
         message_loop_(message_loop) {
     SetMediaTransferProtocolManagerForTest(
         new TestMediaTransferProtocolManagerLinux());
     SetGetDeviceInfoCallbackForTest(base::Bind(&GetDeviceInfo));
   }
   virtual ~TestStorageMonitorLinux() {}
 
  private:
   virtual void UpdateMtab(
       const MtabWatcherLinux::MountPointDeviceMap& new_mtab) OVERRIDE {
     StorageMonitorLinux::UpdateMtab(new_mtab);
-    message_loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
+    message_loop_->PostTask(FROM_HERE, base::MessageLoop::QuitClosure());
   }
 
-  MessageLoop* message_loop_;
+  base::MessageLoop* message_loop_;
 
   DISALLOW_COPY_AND_ASSIGN(TestStorageMonitorLinux);
 };
 
 class StorageMonitorLinuxTest : public testing::Test {
  public:
   struct MtabTestData {
     MtabTestData(const std::string& mount_device,
                  const std::string& mount_point,
                  const std::string& mount_type)
         : mount_device(mount_device),
           mount_point(mount_point),
           mount_type(mount_type) {
     }
 
     const std::string mount_device;
     const std::string mount_point;
     const std::string mount_type;
   };
 
   StorageMonitorLinuxTest()
-      : message_loop_(MessageLoop::TYPE_IO),
+      : message_loop_(base::MessageLoop::TYPE_IO),
         ui_thread_(content::BrowserThread::UI, &message_loop_),
         file_thread_(content::BrowserThread::FILE, &message_loop_) {
   }
   virtual ~StorageMonitorLinuxTest() {}
 
  protected:
   virtual void SetUp() OVERRIDE {
     // Create and set up a temp dir with files for the test.
     ASSERT_TRUE(scoped_temp_dir_.CreateUniqueTempDir());
     base::FilePath test_dir = scoped_temp_dir_.path().AppendASCII("test_etc");
@@ skipping 123 matching lines @@
     for (size_t i = 0; i < data_size; ++i) {
       entry.mnt_fsname = const_cast<char*>(data[i].mount_device.c_str());
       entry.mnt_dir = const_cast<char*>(data[i].mount_point.c_str());
       entry.mnt_type = const_cast<char*>(data[i].mount_type.c_str());
       ASSERT_EQ(0, addmntent(file, &entry));
     }
     ASSERT_EQ(1, endmntent(file));
   }
 
   // The message loop and file thread to run tests on.
-  MessageLoop message_loop_;
+  base::MessageLoop message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
 
   scoped_ptr<MockRemovableStorageObserver> mock_storage_observer_;
 
   // Temporary directory for created test data.
   base::ScopedTempDir scoped_temp_dir_;
   // Path to the test mtab file.
   base::FilePath mtab_file_;
 
@@ skipping 365 matching lines @@
             GetStorageSize(test_path_a));
   EXPECT_EQ(GetDevicePartitionSize(kDeviceNoDCIM),
             GetStorageSize(test_path_b));
   EXPECT_EQ(GetDevicePartitionSize(kInvalidPath),
             GetStorageSize(base::FilePath(kInvalidPath)));
 }
 
 }  // namespace
 
 }  // namespace chrome