Remove calls to deprecated MessageLoop methods in content.

content/browser/fileapi/file_writer_delegate_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 <stdint.h>
 #include <limits>
 #include <string>
 #include <utility>
 #include <vector>
 
@@ skipping 268 matching lines @@
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithoutQuotaLimit) {
   const GURL kBlobURL("blob:nolimit");
   content_ = kData;
 
   PrepareForWrite("test", kBlobURL, 0, std::numeric_limits<int64_t>::max());
 
   Result result;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
 
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kDataSize, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
   EXPECT_EQ(kDataSize, result.bytes_written());
   EXPECT_EQ(base::File::FILE_OK, result.status());
 }
 
 TEST_F(FileWriterDelegateTest, WriteSuccessWithJustQuota) {
   const GURL kBlobURL("blob:just");
   content_ = kData;
   const int64_t kAllowedGrowth = kDataSize;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
   EXPECT_EQ(base::File::FILE_OK, result.status());
 }
 
 TEST_F(FileWriterDelegateTest, DISABLED_WriteFailureByQuota) {
   const GURL kBlobURL("blob:failure");
   content_ = kData;
   const int64_t kAllowedGrowth = kDataSize - 1;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
   EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status());
   ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
 }
 
 TEST_F(FileWriterDelegateTest, WriteZeroBytesSuccessfullyWithZeroQuota) {
   const GURL kBlobURL("blob:zero");
   content_ = "";
   int64_t kAllowedGrowth = 0;
   PrepareForWrite("test", kBlobURL, 0, kAllowedGrowth);
 
   Result result;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   file_writer_delegate_.reset();
 
   ASSERT_EQ(kAllowedGrowth, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
 
   EXPECT_EQ(kAllowedGrowth, result.bytes_written());
   EXPECT_EQ(base::File::FILE_OK, result.status());
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
 }
@@ skipping 15 matching lines @@
   // Credate another FileWriterDelegate for concurrent write.
   file_writer_delegate2.reset(
       CreateWriterDelegate("test2", 0, std::numeric_limits<int64_t>::max()));
   request2 = empty_context_.CreateRequest(
       kBlobURL2, net::DEFAULT_PRIORITY, file_writer_delegate2.get());
 
   Result result, result2;
   ASSERT_EQ(0, usage());
   file_writer_delegate_->Start(std::move(request_), GetWriteCallback(&result));
   file_writer_delegate2->Start(std::move(request2), GetWriteCallback(&result2));
-  base::MessageLoop::current()->Run();
+  base::RunLoop().Run();
   if (result.write_status() == FileWriterDelegate::SUCCESS_IO_PENDING ||
       result2.write_status() == FileWriterDelegate::SUCCESS_IO_PENDING)
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
 
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result2.write_status());
   file_writer_delegate_.reset();
   file_writer_delegate2.reset();
 
   ASSERT_EQ(kDataSize * 2, usage());
   EXPECT_EQ(GetFileSizeOnDisk("test") + GetFileSizeOnDisk("test2"), usage());
 
   EXPECT_EQ(kDataSize, result.bytes_written());
@@ skipping 10 matching lines @@
   int64_t offset = 0;
   int64_t allowed_growth = 100;
   ASSERT_LT(kDataSize, allowed_growth);
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     ASSERT_EQ(0, usage());
     file_writer_delegate_->Start(std::move(request_),
                                  GetWriteCallback(&result));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     ASSERT_EQ(kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
     EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite kDataSize bytes data while allowed_growth is 20.
   offset = 0;
   allowed_growth = 20;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     file_writer_delegate_->Start(std::move(request_),
                                  GetWriteCallback(&result));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     EXPECT_EQ(kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
     EXPECT_EQ(base::File::FILE_OK, result.status());
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
   }
 
   // Trying to write kDataSize bytes data from offset 25 while
   // allowed_growth is 55.
   offset = 25;
   allowed_growth = 55;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     file_writer_delegate_->Start(std::move(request_),
                                  GetWriteCallback(&result));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(offset + kDataSize, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
     EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite 45 bytes data while allowed_growth is -20.
   offset = 0;
   allowed_growth = -20;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
   int64_t pre_write_usage = GetFileSizeOnDisk("test");
 
   {
     Result result;
     file_writer_delegate_->Start(std::move(request_),
                                  GetWriteCallback(&result));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     ASSERT_EQ(FileWriterDelegate::SUCCESS_COMPLETED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(pre_write_usage, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kDataSize, result.bytes_written());
     EXPECT_EQ(base::File::FILE_OK, result.status());
   }
 
   // Trying to overwrite 45 bytes data with offset pre_write_usage - 20,
   // while allowed_growth is 10.
   const int kOverlap = 20;
   offset = pre_write_usage - kOverlap;
   allowed_growth = 10;
   PrepareForWrite("test", kBlobURL, offset, allowed_growth);
 
   {
     Result result;
     file_writer_delegate_->Start(std::move(request_),
                                  GetWriteCallback(&result));
-    base::MessageLoop::current()->Run();
+    base::RunLoop().Run();
     ASSERT_EQ(FileWriterDelegate::ERROR_WRITE_STARTED, result.write_status());
     file_writer_delegate_.reset();
 
     EXPECT_EQ(pre_write_usage + allowed_growth, usage());
     EXPECT_EQ(GetFileSizeOnDisk("test"), usage());
     EXPECT_EQ(kOverlap + allowed_growth, result.bytes_written());
     EXPECT_EQ(base::File::FILE_ERROR_NO_SPACE, result.status());
   }
 }
 
 }  // namespace content