Remove calls to deprecated MessageLoop methods in content.

content/browser/blob_storage/blob_reader_unittest.cc

 // Copyright 2015 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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <memory>
 #include <utility>
@@ skipping 319 matching lines @@
 }  // namespace
 
 class BlobReaderTest : public ::testing::Test {
  public:
   BlobReaderTest() {}
   ~BlobReaderTest() override {}
 
   void TearDown() override {
     reader_.reset();
     blob_handle_.reset();
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     base::RunLoop().RunUntilIdle();
   }
 
  protected:
   void InitializeReader(BlobDataBuilder* builder) {
     blob_handle_ = builder ? context_.AddFinishedBlob(builder) : nullptr;
     provider_ = new MockFileStreamReaderProvider();
     reader_.reset(new BlobReader(blob_handle_.get(),
                                  base::WrapUnique(provider_),
                                  message_loop_.task_runner().get()));
@@ skipping 366 matching lines @@
   reader->SetAsyncRunner(message_loop_.task_runner().get());
 
   ExpectLocalFileCall(kPath, kTime, 0, reader.release());
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   EXPECT_FALSE(reader_->IsInMemory());
   CheckSizeNotCalculatedYet(size_result);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   CheckSizeCalculatedAsynchronously(kData.size(), size_result);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kData.size()));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->Read(buffer.get(), kData.size(), &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(kData.size(), static_cast<size_t>(async_bytes_read));
   EXPECT_EQ(0, bytes_read);
   EXPECT_EQ(0, memcmp(buffer->data(), "FileData!!!", kData.size()));
 }
 
 TEST_F(BlobReaderTest, FileSystemAsync) {
   BlobDataBuilder b("uuid");
   const GURL kURL("file://test_file/here.txt");
   const std::string kData = "FileData!!!";
   const base::Time kTime = base::Time::Now();
   b.AppendFileSystemFile(kURL, 0, kData.size(), kTime);
   this->InitializeReader(&b);
 
   std::unique_ptr<FakeFileStreamReader> reader(new FakeFileStreamReader(kData));
   reader->SetAsyncRunner(message_loop_.task_runner().get());
 
   ExpectFileSystemCall(kURL, 0, kData.size(), kTime, reader.release());
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   CheckSizeNotCalculatedYet(size_result);
   EXPECT_FALSE(reader_->IsInMemory());
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   CheckSizeCalculatedAsynchronously(kData.size(), size_result);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kData.size()));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->Read(buffer.get(), kData.size(), &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(kData.size(), static_cast<size_t>(async_bytes_read));
   EXPECT_EQ(0, bytes_read);
   EXPECT_EQ(0, memcmp(buffer->data(), "FileData!!!", kData.size()));
 }
 
 TEST_F(BlobReaderTest, DiskCacheAsync) {
   std::unique_ptr<disk_cache::Backend> cache =
       CreateInMemoryDiskCache(message_loop_.task_runner());
   ASSERT_TRUE(cache);
@@ skipping 46 matching lines @@
   ExpectLocalFileCall(kPath, kTime, 0, reader.release());
 
   // We create the reader again with the offset after the seek.
   reader.reset(new FakeFileStreamReader(kRangeData));
   reader->SetAsyncRunner(message_loop_.task_runner().get());
   ExpectLocalFileCall(kPath, kTime, kOffset, reader.release());
 
   int size_result = -1;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
 
   scoped_refptr<net::IOBuffer> buffer = CreateBuffer(kReadLength);
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->SetReadRange(kOffset, kReadLength));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->Read(buffer.get(), kReadLength, &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(kReadLength, static_cast<size_t>(async_bytes_read));
   EXPECT_EQ(0, bytes_read);
   EXPECT_EQ(0, memcmp(buffer->data(), "leD", kReadLength));
 }
 
 TEST_F(BlobReaderTest, DiskCacheRange) {
   std::unique_ptr<disk_cache::Backend> cache =
       CreateInMemoryDiskCache(message_loop_.task_runner());
   ASSERT_TRUE(cache);
@@ skipping 72 matching lines @@
     FilePath path = kPathBase.Append(
         FilePath::FromUTF8Unsafe(base::StringPrintf("%d", current_value)));
     ExpectLocalFileCall(path, kTime, offset, reader.release());
   }
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   CheckSizeNotCalculatedYet(size_result);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   CheckSizeCalculatedAsynchronously(kTotalSize, size_result);
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   current_value = 0;
   for (size_t i = 0; i < kTotalSize / kBufferSize; i++) {
     int bytes_read = 0;
     int async_bytes_read = 0;
     EXPECT_EQ(BlobReader::Status::IO_PENDING,
               reader_->Read(buffer.get(), kBufferSize, &bytes_read,
                             base::Bind(&SetValue<int>, &async_bytes_read)));
-    message_loop_.RunUntilIdle();
+    base::RunLoop().RunUntilIdle();
     EXPECT_EQ(net::OK, reader_->net_error());
     EXPECT_EQ(0, bytes_read);
     EXPECT_EQ(kBufferSize, static_cast<size_t>(async_bytes_read));
     for (size_t j = 0; j < kBufferSize; j++) {
       EXPECT_EQ(current_value, buffer->data()[j]);
       current_value++;
     }
   }
 }
 
@@ skipping 28 matching lines @@
   std::unique_ptr<FakeFileStreamReader> reader(
       new FakeFileStreamReader(kData1));
   reader->SetAsyncRunner(message_loop_.task_runner().get());
   ExpectLocalFileCall(kData1Path, kTime, 0, reader.release());
 
   int size_result = -1;
   EXPECT_FALSE(IsReaderTotalSizeCalculated());
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   CheckSizeNotCalculatedYet(size_result);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   CheckSizeCalculatedAsynchronously(kDataSize, size_result);
 
   scoped_refptr<net::IOBuffer> buffer = CreateBuffer(kDataSize);
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->Read(buffer.get(), kDataSize, &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
   EXPECT_EQ(0, async_bytes_read);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(0, bytes_read);
   EXPECT_EQ(kDataSize, static_cast<size_t>(async_bytes_read));
   EXPECT_EQ(0, memcmp(buffer->data(), "Hello there. This is multi-content.",
                       kDataSize));
 }
 
 TEST_F(BlobReaderTest, StateErrors) {
   // Test common variables
   int bytes_read = -1;
@@ skipping 81 matching lines @@
   builder1.AppendFile(kPath, 0, kData.size(), kTime);
   this->InitializeReader(&builder1);
   FakeFileStreamReader* reader = new FakeFileStreamReader(kData);
   reader->SetAsyncRunner(message_loop_.task_runner().get());
   reader->SetReturnError(net::ERR_FILE_NOT_FOUND);
   ExpectLocalFileCall(kPath, kTime, 0, reader);
 
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   EXPECT_EQ(net::OK, reader_->net_error());
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, size_result);
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, reader_->net_error());
 
   // Case: Error on read.
   BlobDataBuilder builder2("uuid2");
   builder2.AppendFile(kPath, 0, kData.size(), kTime);
   this->InitializeReader(&builder2);
   reader = new FakeFileStreamReader(kData);
   ExpectLocalFileCall(kPath, kTime, 0, reader);
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   reader->SetReturnError(net::ERR_FILE_NOT_FOUND);
   reader->SetAsyncRunner(message_loop_.task_runner().get());
 
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kData.size()));
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->Read(buffer.get(), kData.size(), &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
   EXPECT_EQ(net::OK, reader_->net_error());
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, async_bytes_read);
   EXPECT_EQ(net::ERR_FILE_NOT_FOUND, reader_->net_error());
 }
 
 TEST_F(BlobReaderTest, RangeError) {
   const std::string kData("Hello!!!");
   const size_t kDataSize = 8ul;
   const uint64_t kReadLength = 4ull;
 
   // Case: offset too high.
@@ skipping 27 matching lines @@
   context_.CreatePendingBlob(kUuid, "", "");
   blob_handle_ = context_.GetBlobDataFromUUID(kUuid);
   provider_ = new MockFileStreamReaderProvider();
   reader_.reset(new BlobReader(blob_handle_.get(), base::WrapUnique(provider_),
                                message_loop_.task_runner().get()));
   int size_result = -1;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   EXPECT_FALSE(reader_->IsInMemory());
   context_.CancelPendingBlob(kUuid, IPCBlobCreationCancelCode::UNKNOWN);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   EXPECT_EQ(net::ERR_FAILED, size_result);
 }
 
 TEST_F(BlobReaderTest, ReadFromIncompleteBlob) {
   const std::string kUuid("uuid1");
   const std::string kData("Hello!!!");
   const size_t kDataSize = 8ul;
 
   BlobDataBuilder b(kUuid);
   b.AppendData(kData);
   context_.CreatePendingBlob(kUuid, "", "");
   blob_handle_ = context_.GetBlobDataFromUUID(kUuid);
   provider_ = new MockFileStreamReaderProvider();
   reader_.reset(new BlobReader(blob_handle_.get(), base::WrapUnique(provider_),
                                message_loop_.task_runner().get()));
   int size_result = -1;
   EXPECT_EQ(BlobReader::Status::IO_PENDING,
             reader_->CalculateSize(base::Bind(&SetValue<int>, &size_result)));
   EXPECT_FALSE(reader_->IsInMemory());
   context_.CompletePendingBlob(b);
-  message_loop_.RunUntilIdle();
+  base::RunLoop().RunUntilIdle();
   CheckSizeCalculatedAsynchronously(kDataSize, size_result);
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kDataSize));
 
   int bytes_read = 0;
   int async_bytes_read = 0;
   EXPECT_EQ(BlobReader::Status::DONE,
             reader_->Read(buffer.get(), kDataSize, &bytes_read,
                           base::Bind(&SetValue<int>, &async_bytes_read)));
   EXPECT_EQ(net::OK, reader_->net_error());
   EXPECT_EQ(kDataSize, static_cast<size_t>(bytes_read));
   EXPECT_EQ(0, async_bytes_read);
   EXPECT_EQ(kData, std::string(buffer->data(), kDataSize));
   EXPECT_EQ(net::OK, size_result);
 }
 
 }  // namespace storage