webkit: Update the calls from RunAllPending() to RunUntilIdle().

webkit/fileapi/local_file_system_quota_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.
 
 // This test checks the entire behavior of FileSystem usage and quota, such as:
 // 1) the actual size of files on disk,
 // 2) the described size in .usage, and
 // 3) the result of QuotaManager::GetUsageAndQuota.
 
 #include "base/bind.h"
@@ skipping 78 matching lines @@
 
   int64 SizeByQuotaUtil() {
     return test_helper_.GetCachedOriginUsage();
   }
 
   void GetUsageAndQuotaFromQuotaManager() {
     quota_manager_->GetUsageAndQuota(
         test_helper_.origin(), test_helper_.storage_type(),
         base::Bind(&LocalFileSystemQuotaTest::OnGetUsageAndQuota,
                    weak_factory_.GetWeakPtr()));
-    MessageLoop::current()->RunAllPending();
+    MessageLoop::current()->RunUntilIdle();
   }
 
   bool FileExists(const FilePath& virtual_path) {
     FileSystemURL path = test_helper_.CreateURL(virtual_path);
     scoped_ptr<FileSystemOperationContext> context(NewContext());
     return FileUtilHelper::PathExists(context.get(), file_util(), path);
   }
 
   bool DirectoryExists(const FilePath& virtual_path) {
     FileSystemURL path = test_helper_.CreateURL(virtual_path);
@@ skipping 126 matching lines @@
   int total_path_cost = SizeByQuotaUtil();
 
   operation()->Truncate(URLForPath(child_file1_path_), 5000,
                         base::Bind(&AssertFileErrorEq, base::PLATFORM_FILE_OK));
   operation()->Truncate(URLForPath(child_file2_path_), 400,
                         base::Bind(&AssertFileErrorEq, base::PLATFORM_FILE_OK));
   operation()->Truncate(URLForPath(grandchild_file1_path_), 30,
                         base::Bind(&AssertFileErrorEq, base::PLATFORM_FILE_OK));
   operation()->Truncate(URLForPath(grandchild_file2_path_), 2,
                         base::Bind(&AssertFileErrorEq, base::PLATFORM_FILE_OK));
-  MessageLoop::current()->RunAllPending();
+  MessageLoop::current()->RunUntilIdle();
 
   const int64 all_file_size = 5000 + 400 + 30 + 2;
 
   EXPECT_EQ(all_file_size, ActualFileSize());
   EXPECT_EQ(all_file_size + total_path_cost, SizeByQuotaUtil());
   GetUsageAndQuotaFromQuotaManager();
   EXPECT_EQ(quota::kQuotaStatusOk, quota_status());
   EXPECT_EQ(all_file_size + total_path_cost, usage());
   ASSERT_LT(all_file_size + total_path_cost, quota());
 
   operation()->Move(URLForPath(src_dir_path), URLForPath(dest_dir_path),
                     RecordStatusCallback());
-  MessageLoop::current()->RunAllPending();
+  MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(DirectoryExists(dest_dir_path.Append(
       VirtualPath::BaseName(child_dir_path_))));
   EXPECT_TRUE(FileExists(dest_dir_path.Append(
       VirtualPath::BaseName(child_dir_path_)).Append(
       VirtualPath::BaseName(grandchild_file1_path_))));
 
   EXPECT_EQ(all_file_size, ActualFileSize());
   EXPECT_EQ(all_file_size + total_path_cost - src_path_cost,
@@ skipping 14 matching lines @@
   int total_path_cost = SizeByQuotaUtil();
 
   operation()->Truncate(URLForPath(child_file1_path_), 8000,
                         base::Bind(&AssertFileErrorEq, base::PLATFORM_FILE_OK));
   operation()->Truncate(URLForPath(child_file2_path_), 700,
                         base::Bind(&AssertFileErrorEq, base::PLATFORM_FILE_OK));
   operation()->Truncate(URLForPath(grandchild_file1_path_), 60,
                         base::Bind(&AssertFileErrorEq, base::PLATFORM_FILE_OK));
   operation()->Truncate(URLForPath(grandchild_file2_path_), 5,
                         base::Bind(&AssertFileErrorEq, base::PLATFORM_FILE_OK));
-  MessageLoop::current()->RunAllPending();
+  MessageLoop::current()->RunUntilIdle();
 
   const int64 child_file_size = 8000 + 700;
   const int64 grandchild_file_size = 60 + 5;
   const int64 all_file_size = child_file_size + grandchild_file_size;
   int64 expected_usage = all_file_size + total_path_cost;
 
   EXPECT_EQ(all_file_size, ActualFileSize());
   EXPECT_EQ(expected_usage, SizeByQuotaUtil());
   GetUsageAndQuotaFromQuotaManager();
   EXPECT_EQ(quota::kQuotaStatusOk, quota_status());
   EXPECT_EQ(expected_usage, usage());
   ASSERT_LT(expected_usage, quota());
 
   operation()->Copy(URLForPath(src_dir_path), URLForPath(dest_dir1_path),
                     RecordStatusCallback());
-  MessageLoop::current()->RunAllPending();
+  MessageLoop::current()->RunUntilIdle();
   expected_usage += all_file_size +
       child_path_cost_ + grandchild_path_cost_;
 
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(DirectoryExists(src_dir_path.Append(
       VirtualPath::BaseName(child_dir_path_))));
   EXPECT_TRUE(FileExists(src_dir_path.Append(
       VirtualPath::BaseName(child_dir_path_)).Append(
       VirtualPath::BaseName(grandchild_file1_path_))));
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   EXPECT_TRUE(DirectoryExists(dest_dir1_path.Append(
       VirtualPath::BaseName(child_dir_path_))));
   EXPECT_TRUE(FileExists(dest_dir1_path.Append(
       VirtualPath::BaseName(child_dir_path_)).Append(
       VirtualPath::BaseName(grandchild_file1_path_))));
 
   EXPECT_EQ(2 * all_file_size, ActualFileSize());
   EXPECT_EQ(expected_usage, SizeByQuotaUtil());
   GetUsageAndQuotaFromQuotaManager();
   EXPECT_EQ(quota::kQuotaStatusOk, quota_status());
   EXPECT_EQ(expected_usage, usage());
   ASSERT_LT(expected_usage, quota());
 
   operation()->Copy(URLForPath(child_dir_path_), URLForPath(dest_dir2_path),
                     RecordStatusCallback());
-  MessageLoop::current()->RunAllPending();
+  MessageLoop::current()->RunUntilIdle();
 
   EXPECT_EQ(base::PLATFORM_FILE_OK, status());
   expected_usage += grandchild_file_size + grandchild_path_cost_;
 
   EXPECT_EQ(2 * child_file_size + 3 * grandchild_file_size, ActualFileSize());
   EXPECT_EQ(expected_usage, SizeByQuotaUtil());
   GetUsageAndQuotaFromQuotaManager();
   EXPECT_EQ(quota::kQuotaStatusOk, quota_status());
   EXPECT_EQ(expected_usage, usage());
   ASSERT_LT(expected_usage, quota());
 }
 
 }  // namespace fileapi