chrome/browser: Update calls from RunAllPending() to RunUntilIdle().

chrome/browser/system_monitor/removable_device_notifications_window_win_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/system_monitor/removable_device_notifications_window_win.h"
 
 #include <dbt.h>
 
 #include <string>
 #include <vector>
@@ skipping 299 matching lines @@
 
  protected:
   // testing::Test:
   virtual void SetUp() OVERRIDE;
   virtual void TearDown() OVERRIDE;
 
   void AddMassStorageDeviceAttachExpectation(FilePath drive);
   void PreAttachDevices();
 
   // Runs all the pending tasks on UI thread, FILE thread and blocking thread.
-  void RunAllPending();
+  void RunUntilIdle();
 
   void DoMassStorageDeviceAttachedTest(const DeviceIndices& device_indices);
   void DoMassStorageDevicesDetachedTest(const DeviceIndices& device_indices);
 
   // Injects a device attach or detach change (depending on the value of
   // |test_attach|) and tests that the appropriate handler is called.
   void DoMTPDeviceTest(const string16& pnp_device_id, bool test_attach);
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
@@ skipping 14 matching lines @@
 RemovableDeviceNotificationsWindowWinTest::
     ~RemovableDeviceNotificationsWindowWinTest() {
 }
 
 void RemovableDeviceNotificationsWindowWinTest::SetUp() {
   ASSERT_TRUE(BrowserThread::CurrentlyOn(BrowserThread::UI));
   volume_mount_watcher_ = new TestVolumeMountWatcherWin;
   window_.reset(new TestRemovableDeviceNotificationsWindowWin(
       volume_mount_watcher_.get(), new TestPortableDeviceWatcherWin));
   window_->InitWithTestData(false);
-  RunAllPending();
+  RunUntilIdle();
   system_monitor_.AddDevicesChangedObserver(&observer_);
 }
 
 void RemovableDeviceNotificationsWindowWinTest::TearDown() {
-  RunAllPending();
+  RunUntilIdle();
   system_monitor_.RemoveDevicesChangedObserver(&observer_);
 }
 
 void RemovableDeviceNotificationsWindowWinTest::
     AddMassStorageDeviceAttachExpectation(FilePath drive) {
   std::string unique_id;
   string16 device_name;
   bool removable;
   ASSERT_TRUE(GetMassStorageDeviceDetails(drive, NULL, &unique_id,
                                           &device_name, &removable));
@@ skipping 13 matching lines @@
     testing::InSequence sequence;
     AttachedDevices initial_devices = GetTestAttachedDevices();
     for (AttachedDevices::const_iterator it = initial_devices.begin();
          it != initial_devices.end(); ++it) {
       AddMassStorageDeviceAttachExpectation(*it);
     }
   }
   window_.reset(new TestRemovableDeviceNotificationsWindowWin(
       volume_mount_watcher_.get(), new TestPortableDeviceWatcherWin));
   window_->InitWithTestData(true);
-  RunAllPending();
+  RunUntilIdle();
 }
 
-void RemovableDeviceNotificationsWindowWinTest::RunAllPending() {
-  message_loop_.RunAllPending();
+void RemovableDeviceNotificationsWindowWinTest::RunUntilIdle() {
+  message_loop_.RunUntilIdle();
 }
 
 void RemovableDeviceNotificationsWindowWinTest::
     DoMassStorageDeviceAttachedTest(const DeviceIndices& device_indices) {
   DEV_BROADCAST_VOLUME volume_broadcast;
   volume_broadcast.dbcv_size = sizeof(volume_broadcast);
   volume_broadcast.dbcv_devicetype = DBT_DEVTYP_VOLUME;
   volume_broadcast.dbcv_unitmask = 0x0;
   volume_broadcast.dbcv_flags = 0x0;
   {
     testing::InSequence sequence;
     for (DeviceIndices::const_iterator it = device_indices.begin();
          it != device_indices.end(); ++it) {
       volume_broadcast.dbcv_unitmask |= 0x1 << *it;
       AddMassStorageDeviceAttachExpectation(DriveNumberToFilePath(*it));
     }
   }
   window_->InjectDeviceChange(DBT_DEVICEARRIVAL,
                               reinterpret_cast<DWORD>(&volume_broadcast));
-  RunAllPending();
+  RunUntilIdle();
 }
 
 void RemovableDeviceNotificationsWindowWinTest::
     DoMassStorageDevicesDetachedTest(const DeviceIndices& device_indices) {
   DEV_BROADCAST_VOLUME volume_broadcast;
   volume_broadcast.dbcv_size = sizeof(volume_broadcast);
   volume_broadcast.dbcv_devicetype = DBT_DEVTYP_VOLUME;
   volume_broadcast.dbcv_unitmask = 0x0;
   volume_broadcast.dbcv_flags = 0x0;
   {
     testing::InSequence sequence;
     for (DeviceIndices::const_iterator it = device_indices.begin();
          it != device_indices.end(); ++it) {
       volume_broadcast.dbcv_unitmask |= 0x1 << *it;
       std::string unique_id;
       bool removable;
       ASSERT_TRUE(GetMassStorageDeviceDetails(DriveNumberToFilePath(*it), NULL,
                                               &unique_id, NULL, &removable));
       if (removable) {
         MediaStorageUtil::Type type =
             MediaStorageUtil::REMOVABLE_MASS_STORAGE_NO_DCIM;
         std::string device_id = MediaStorageUtil::MakeDeviceId(type, unique_id);
         EXPECT_CALL(observer_, OnRemovableStorageDetached(device_id)).Times(1);
       }
     }
   }
   window_->InjectDeviceChange(DBT_DEVICEREMOVECOMPLETE,
                               reinterpret_cast<DWORD>(&volume_broadcast));
-  RunAllPending();
+  RunUntilIdle();
 }
 
 void RemovableDeviceNotificationsWindowWinTest::DoMTPDeviceTest(
     const string16& pnp_device_id, bool test_attach) {
   GUID guidDevInterface = GUID_NULL;
   HRESULT hr = CLSIDFromString(kWPDDevInterfaceGUID, &guidDevInterface);
   if (FAILED(hr))
     return;
 
   size_t device_id_size = pnp_device_id.size() * sizeof(char16);
@@ skipping 23 matching lines @@
             .Times((name.empty() || unique_id.empty()) ? 0 : 1);
       } else {
         EXPECT_CALL(observer_, OnRemovableStorageDetached(unique_id))
             .Times((name.empty() || unique_id.empty()) ? 0 : 1);
       }
     }
   }
   window_->InjectDeviceChange(
       test_attach ? DBT_DEVICEARRIVAL : DBT_DEVICEREMOVECOMPLETE,
       reinterpret_cast<DWORD>(dev_interface_broadcast.get()));
-  RunAllPending();
+  RunUntilIdle();
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, RandomMessage) {
   window_->InjectDeviceChange(DBT_DEVICEQUERYREMOVE, NULL);
-  RunAllPending();
+  RunUntilIdle();
 }
 
 TEST_F(RemovableDeviceNotificationsWindowWinTest, DevicesAttached) {
   DeviceIndices device_indices;
   device_indices.push_back(1);
   device_indices.push_back(5);
   device_indices.push_back(7);
   device_indices.push_back(13);
 
   DoMassStorageDeviceAttachedTest(device_indices);
@@ skipping 129 matching lines @@
 
 // Attach a device with two data partitions. Verify that attach/detach
 // notifications are sent out for each removable storage.
 TEST_F(RemovableDeviceNotificationsWindowWinTest,
        MTPDeviceWithMultipleStorageObjects) {
   DoMTPDeviceTest(kMTPDeviceWithMultipleStorageObjects, true);
   DoMTPDeviceTest(kMTPDeviceWithMultipleStorageObjects, false);
 }
 
 }  // namespace chrome