[chrome/browser/drive] Avoid use of MessageLoopProxy by TTRH

chrome/browser/drive/drive_uploader_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/drive/drive_uploader.h"
 
 #include <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/drive/dummy_drive_service.h"
 #include "google_apis/drive/drive_api_parser.h"
 #include "google_apis/drive/test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using google_apis::CancelCallback;
 using google_apis::FileResource;
 using google_apis::DriveApiErrorCode;
 using google_apis::DRIVE_NO_CONNECTION;
@@ skipping 60 matching lines @@
       const std::string& title,
       const UploadNewFileOptions& options,
       const InitiateUploadCallback& callback) override {
     EXPECT_EQ(kTestDocumentTitle, title);
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadParentResourceId, parent_resource_id);
 
     // Calls back the upload URL for subsequent ResumeUpload requests.
     // InitiateUpload is an asynchronous function, so don't callback directly.
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadNewFileURL)));
     return CancelCallback();
   }
 
   CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const UploadExistingFileOptions& options,
       const InitiateUploadCallback& callback) override {
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadResourceId, resource_id);
 
     if (!options.etag.empty() && options.etag != kTestETag) {
-      base::MessageLoop::current()->PostTask(FROM_HERE,
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
           base::Bind(callback, HTTP_PRECONDITION, GURL()));
       return CancelCallback();
     }
 
     // Calls back the upload URL for subsequent ResumeUpload requests.
     // InitiateUpload is an asynchronous function, so don't callback directly.
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadExistingFileURL)));
     return CancelCallback();
   }
 
   // Handles a request for uploading a chunk of bytes.
   CancelCallback ResumeUpload(
       const GURL& upload_location,
       int64 start_position,
       int64 end_position,
       int64 content_length,
@@ skipping 20 matching lines @@
 
     // Update the internal status of the current upload session.
     resume_upload_call_count_++;
     received_bytes_ = end_position;
 
     // Callback progress
     if (!progress_callback.is_null()) {
       // For the testing purpose, it always notifies the progress at the end of
       // each chunk uploading.
       int64 chunk_size = end_position - start_position;
-      base::MessageLoop::current()->PostTask(FROM_HERE,
+      base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
           base::Bind(progress_callback, chunk_size, chunk_size));
     }
 
     SendUploadRangeResponse(upload_location, callback);
     return CancelCallback();
   }
 
   // Handles a request to fetch the current upload status.
   CancelCallback GetUploadStatus(const GURL& upload_location,
                                  int64 content_length,
@@ skipping 19 matching lines @@
           HTTP_CREATED : HTTP_SUCCESS;
       response = UploadRangeResponse(response_code, -1, -1);
 
       entry.reset(new FileResource);
       entry->set_md5_checksum(kTestDummyMd5);
     } else {
       response = UploadRangeResponse(
           HTTP_RESUME_INCOMPLETE, 0, received_bytes_);
     }
     // ResumeUpload is an asynchronous function, so don't callback directly.
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, response, base::Passed(&entry)));
   }
 
   CancelCallback MultipartUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const base::FilePath& local_file_path,
       const UploadNewFileOptions& options,
@@ skipping 16 matching lines @@
       const base::FilePath& local_file_path,
       const UploadExistingFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
     EXPECT_EQ(kTestMimeType, content_type);
     EXPECT_EQ(expected_content_length_, content_length);
     EXPECT_EQ(kTestInitiateUploadResourceId, resource_id);
     EXPECT_EQ(expected_upload_file_, local_file_path);
 
     if (!options.etag.empty() && options.etag != kTestETag) {
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(callback, HTTP_PRECONDITION,
                      base::Passed(make_scoped_ptr<FileResource>(NULL))));
       return CancelCallback();
     }
 
     return SendMultipartUploadResult(HTTP_SUCCESS, content_length, callback,
                                      progress_callback);
   }
 
   CancelCallback SendMultipartUploadResult(
       DriveApiErrorCode response_code,
       int64 content_length,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) {
     received_bytes_ = content_length;
     multipart_upload_call_count_++;
 
     // Callback progress
     if (!progress_callback.is_null()) {
       // For the testing purpose, it always notifies the progress at the end of
       // whole file uploading.
-      base::MessageLoop::current()->PostTask(
+      base::ThreadTaskRunnerHandle::Get()->PostTask(
           FROM_HERE,
           base::Bind(progress_callback, content_length, content_length));
     }
 
     // MultipartUploadXXXFile is an asynchronous function, so don't callback
     // directly.
     scoped_ptr<FileResource> entry;
     entry.reset(new FileResource);
     entry->set_md5_checksum(kTestDummyMd5);
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE, base::Bind(callback, response_code, base::Passed(&entry)));
     return CancelCallback();
   }
 
   const base::FilePath expected_upload_file_;
   const int64 expected_content_length_;
   int64 received_bytes_;
   int64 resume_upload_call_count_;
   int64 multipart_upload_call_count_;
 };
 
 // Mock DriveService that returns a failure at InitiateUpload().
 class MockDriveServiceNoConnectionAtInitiate : public DummyDriveService {
   // Returns error.
   CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const UploadNewFileOptions& options,
       const InitiateUploadCallback& callback) override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const UploadExistingFileOptions& options,
       const InitiateUploadCallback& callback) override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION, GURL()));
     return CancelCallback();
   }
 
   // Should not be used.
   CancelCallback ResumeUpload(
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) override {
     NOTREACHED();
     return CancelCallback();
   }
 
   CancelCallback MultipartUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const base::FilePath& local_file_path,
       const UploadNewFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION,
                    base::Passed(make_scoped_ptr<FileResource>(NULL))));
     return CancelCallback();
   }
 
   CancelCallback MultipartUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const base::FilePath& local_file_path,
       const UploadExistingFileOptions& options,
       const google_apis::FileResourceCallback& callback,
       const google_apis::ProgressCallback& progress_callback) override {
-    base::MessageLoop::current()->PostTask(
+    base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::Bind(callback, DRIVE_NO_CONNECTION,
                    base::Passed(make_scoped_ptr<FileResource>(NULL))));
     return CancelCallback();
   }
 };
 
 // Mock DriveService that returns a failure at ResumeUpload().
 class MockDriveServiceNoConnectionAtResume : public DummyDriveService {
   // Succeeds and returns an upload location URL.
   CancelCallback InitiateUploadNewFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& parent_resource_id,
       const std::string& title,
       const UploadNewFileOptions& options,
       const InitiateUploadCallback& callback) override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadNewFileURL)));
     return CancelCallback();
   }
 
   CancelCallback InitiateUploadExistingFile(
       const std::string& content_type,
       int64 content_length,
       const std::string& resource_id,
       const UploadExistingFileOptions& options,
       const InitiateUploadCallback& callback) override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback, HTTP_SUCCESS, GURL(kTestUploadExistingFileURL)));
     return CancelCallback();
   }
 
   // Returns error.
   CancelCallback ResumeUpload(
       const GURL& upload_url,
       int64 start_position,
       int64 end_position,
       int64 content_length,
       const std::string& content_type,
       const base::FilePath& local_file_path,
       const UploadRangeCallback& callback,
       const ProgressCallback& progress_callback) override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(DRIVE_NO_CONNECTION, -1, -1),
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 };
 
 // Mock DriveService that returns a failure at GetUploadStatus().
 class MockDriveServiceNoConnectionAtGetUploadStatus : public DummyDriveService {
   // Returns error.
   CancelCallback GetUploadStatus(const GURL& upload_url,
                                  int64 content_length,
                                  const UploadRangeCallback& callback) override {
-    base::MessageLoop::current()->PostTask(FROM_HERE,
+    base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE,
         base::Bind(callback,
                    UploadRangeResponse(DRIVE_NO_CONNECTION, -1, -1),
                    base::Passed(scoped_ptr<FileResource>())));
     return CancelCallback();
   }
 };
 
 class DriveUploaderTest : public testing::Test {
  public:
   void SetUp() override { ASSERT_TRUE(temp_dir_.CreateUniqueTempDir()); }
@@ skipping 10 matching lines @@
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 0, &local_path, &data));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType,
       UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(0, mock_service.resume_upload_call_count());
@@ skipping 12 matching lines @@
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType,
       UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   // 512KB upload should be uploaded as multipart body.
@@ skipping 14 matching lines @@
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 2 * 1024 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType,
       UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   // 2MB upload should not be split into multiple chunks.
@@ skipping 14 matching lines @@
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 2 * 1024 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtInitiate mock_service;
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType,
       UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
   EXPECT_FALSE(entry);
 }
 
 TEST_F(DriveUploaderTest, MultipartUploadFail) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(temp_dir_.path(), 512 * 1024,
                                                    &local_path, &data));
 
   DriveApiErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtInitiate mock_service;
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType,
       UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
   EXPECT_FALSE(entry);
 }
 
 TEST_F(DriveUploaderTest, InitiateUploadNoConflict) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   UploadExistingFileOptions options;
   options.etag = kTestETag;
   uploader.UploadExistingFile(kTestInitiateUploadResourceId,
                               local_path,
                               kTestMimeType,
                               options,
                               test_util::CreateCopyResultCallback(
                                   &error, &upload_location, &entry),
                               google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, MultipartUploadConflict) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 512 * 1024, &local_path, &data));
   const std::string kDestinationETag("destination_etag");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   UploadExistingFileOptions options;
   options.etag = kDestinationETag;
   uploader.UploadExistingFile(kTestInitiateUploadResourceId,
                               local_path,
                               kTestMimeType,
                               options,
                               test_util::CreateCopyResultCallback(
                                   &error, &upload_location, &entry),
                               google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CONFLICT, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, InitiateUploadConflict) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 2 * 1024 * 1024, &local_path, &data));
   const std::string kDestinationETag("destination_etag");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   UploadExistingFileOptions options;
   options.etag = kDestinationETag;
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType, options,
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(HTTP_CONFLICT, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, ResumeUploadFail) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 2 * 1024 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtResume mock_service;
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId, local_path, kTestMimeType,
       UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_EQ(GURL(kTestUploadExistingFileURL), upload_location);
 }
 
 TEST_F(DriveUploaderTest, GetUploadStatusFail) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 2 * 1024 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = HTTP_SUCCESS;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceNoConnectionAtGetUploadStatus mock_service;
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   uploader.ResumeUploadFile(GURL(kTestUploadExistingFileURL),
                             local_path,
                             kTestMimeType,
                             test_util::CreateCopyResultCallback(
                                 &error, &upload_location, &entry),
                             google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(DRIVE_NO_CONNECTION, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, NonExistingSourceFile) {
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   DriveUploader uploader(NULL,  // NULL, the service won't be used.
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   uploader.UploadExistingFile(
       kTestInitiateUploadResourceId,
       temp_dir_.path().AppendASCII("_this_path_should_not_exist_"),
       kTestMimeType, UploadExistingFileOptions(),
       test_util::CreateCopyResultCallback(&error, &upload_location, &entry),
       google_apis::ProgressCallback());
   base::RunLoop().RunUntilIdle();
 
   // Should return failure without doing any attempt to connect to the server.
   EXPECT_EQ(HTTP_NOT_FOUND, error);
   EXPECT_TRUE(upload_location.is_empty());
 }
 
 TEST_F(DriveUploaderTest, ResumeUpload) {
   base::FilePath local_path;
   std::string data;
   ASSERT_TRUE(test_util::CreateFileOfSpecifiedSize(
       temp_dir_.path(), 1024 * 1024, &local_path, &data));
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   GURL upload_location;
   scoped_ptr<FileResource> entry;
 
   MockDriveServiceWithUploadExpectation mock_service(local_path, data.size());
   DriveUploader uploader(&mock_service,
-                         base::MessageLoopProxy::current().get());
+                         base::ThreadTaskRunnerHandle::Get().get());
   // Emulate the situation that the only first part is successfully uploaded,
   // but not the latter half.
   mock_service.set_received_bytes(512 * 1024);
 
   std::vector<test_util::ProgressInfo> upload_progress_values;
   uploader.ResumeUploadFile(
       GURL(kTestUploadExistingFileURL),
       local_path,
       kTestMimeType,
       test_util::CreateCopyResultCallback(
           &error, &upload_location, &entry),
       base::Bind(&test_util::AppendProgressCallbackResult,
                  &upload_progress_values));
   base::RunLoop().RunUntilIdle();
 
   EXPECT_EQ(1, mock_service.resume_upload_call_count());
   EXPECT_EQ(1024 * 1024, mock_service.received_bytes());
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_TRUE(upload_location.is_empty());
   ASSERT_TRUE(entry);
   EXPECT_EQ(kTestDummyMd5, entry->md5_checksum());
   ASSERT_EQ(1U, upload_progress_values.size());
   EXPECT_EQ(test_util::ProgressInfo(1024 * 1024, 1024 * 1024),
             upload_progress_values[0]);
 }
 
 }  // namespace drive