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

chrome/browser/chromeos/drive/drive_file_stream_reader_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 "chrome/browser/chromeos/drive/drive_file_stream_reader.h"
 
 #include <string>
 
 #include "base/bind.h"
 #include "base/file_util.h"
@@ skipping 27 matching lines @@
 }  // namespace
 
 TEST(LocalReaderProxyTest, Read) {
   // Prepare the test content.
   const base::FilePath kTestFile(
       google_apis::test_util::GetTestFilePath("chromeos/drive/applist.json"));
   std::string expected_content;
   ASSERT_TRUE(file_util::ReadFileToString(kTestFile, &expected_content));
 
   // The LocalReaderProxy should live on IO thread.
-  MessageLoopForIO io_loop;
+  base::MessageLoopForIO io_loop;
   content::TestBrowserThread io_thread(BrowserThread::IO, &io_loop);
 
   {
     // Open the file first.
     scoped_ptr<net::FileStream> file_stream(new net::FileStream(NULL));
     net::TestCompletionCallback callback;
     int result = file_stream->Open(
         google_apis::test_util::GetTestFilePath("chromeos/drive/applist.json"),
         base::PLATFORM_FILE_OPEN | base::PLATFORM_FILE_READ |
         base::PLATFORM_FILE_ASYNC,
@@ skipping 24 matching lines @@
     EXPECT_EQ(expected_content, concatenated_content);
   }
 
   // For graceful shutdown, we wait for that the FileStream used above is
   // actually closed.
   test_util::WaitForFileStreamClosed();
 }
 
 TEST(NetworkReaderProxyTest, EmptyFile) {
   // The NetworkReaderProxy should live on IO thread.
-  MessageLoopForIO io_loop;
+  base::MessageLoopForIO io_loop;
   content::TestBrowserThread io_thread(BrowserThread::IO, &io_loop);
 
   NetworkReaderProxy proxy(0, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 10;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
 
   // For empty file, Read() should return 0 immediately.
   EXPECT_EQ(0, result);
 }
 
 TEST(NetworkReaderProxyTest, Read) {
   // The NetworkReaderProxy should live on IO thread.
-  MessageLoopForIO io_loop;
+  base::MessageLoopForIO io_loop;
   content::TestBrowserThread io_thread(BrowserThread::IO, &io_loop);
 
   NetworkReaderProxy proxy(10, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   // If no data is available yet, ERR_IO_PENDING should be returned.
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
@@ skipping 28 matching lines @@
   EXPECT_EQ(2, result);
   EXPECT_EQ("ij", std::string(buffer->data(), result));
 
   // The whole data is read, so Read() should return 0 immediately by then.
   result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
   EXPECT_EQ(0, result);
 }
 
 TEST(NetworkReaderProxyTest, ErrorWithPendingCallback) {
   // The NetworkReaderProxy should live on IO thread.
-  MessageLoopForIO io_loop;
+  base::MessageLoopForIO io_loop;
   content::TestBrowserThread io_thread(BrowserThread::IO, &io_loop);
 
   NetworkReaderProxy proxy(10, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   // Set pending callback.
   int result = proxy.Read(buffer.get(), kBufferSize, callback.callback());
   EXPECT_EQ(net::ERR_IO_PENDING, result);
 
   // Emulate that an error is found. The callback should be called internally.
   proxy.OnCompleted(FILE_ERROR_FAILED);
   result = callback.GetResult(result);
   EXPECT_EQ(net::ERR_FAILED, result);
 
   // The next Read call should also return the same error code.
   EXPECT_EQ(net::ERR_FAILED,
             proxy.Read(buffer.get(), kBufferSize, callback.callback()));
 }
 
 TEST(NetworkReaderProxyTest, ErrorWithPendingData) {
   // The NetworkReaderProxy should live on IO thread.
-  MessageLoopForIO io_loop;
+  base::MessageLoopForIO io_loop;
   content::TestBrowserThread io_thread(BrowserThread::IO, &io_loop);
 
   NetworkReaderProxy proxy(10, base::Bind(&base::DoNothing));
 
   net::TestCompletionCallback callback;
   const int kBufferSize = 3;
   scoped_refptr<net::IOBuffer> buffer(new net::IOBuffer(kBufferSize));
 
   // Supply the data before an error.
   scoped_ptr<std::string> data(new std::string("abcde"));
   proxy.OnGetContent(data.Pass());
 
   // Emulate that an error is found.
   proxy.OnCompleted(FILE_ERROR_FAILED);
 
   // The next Read call should return the error code, even if there is
   // pending data (the pending data should be released in OnCompleted.
   EXPECT_EQ(net::ERR_FAILED,
             proxy.Read(buffer.get(), kBufferSize, callback.callback()));
 }
 
 TEST(NetworkReaderProxyTest, CancelJob) {
   // The NetworkReaderProxy should live on IO thread.
-  MessageLoopForIO io_loop;
+  base::MessageLoopForIO io_loop;
   content::TestBrowserThread io_thread(BrowserThread::IO, &io_loop);
 
   int num_called = 0;
   {
     NetworkReaderProxy proxy(0, base::Bind(&IncrementCallback, &num_called));
     proxy.OnCompleted(FILE_ERROR_OK);
     // Destroy the instance after the network operation is completed.
     // The cancelling callback shouldn't be called.
   }
   EXPECT_EQ(0, num_called);
@@ skipping 60 matching lines @@
 
   DriveFileSystemInterface* GetDriveFileSystem() {
     return fake_drive_file_system_.get();
   }
 
   DriveFileStreamReader::DriveFileSystemGetter GetDriveFileSystemGetter() {
     return base::Bind(&DriveFileStreamReaderTest::GetDriveFileSystem,
                       base::Unretained(this));
   }
 
-  MessageLoopForIO message_loop_;
+  base::MessageLoopForIO message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread io_thread_;
 
   scoped_ptr<google_apis::FakeDriveService> fake_drive_service_;
   scoped_ptr<test_util::FakeDriveFileSystem> fake_drive_file_system_;
 };
 
 TEST_F(DriveFileStreamReaderTest, Read) {
   const base::FilePath kDriveFile =
       util::GetDriveMyDriveRootPath().AppendASCII("File 1.txt");
@@ skipping 63 matching lines @@
     result = callback.GetResult(result);
     ASSERT_GT(result, 0);
     second_content.append(buffer->data(), result);
   }
 
   // The same content is expected.
   EXPECT_EQ(first_content, second_content);
 }
 
 }  // namespace drive