Use base::RunLoop instead of directly using MessageLoop in Drive related code.

chrome/browser/google_apis/drive_api_requests_unittest.cc

 // Copyright (c) 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 "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/google_apis/auth_service.h"
 #include "chrome/browser/google_apis/drive_api_parser.h"
 #include "chrome/browser/google_apis/drive_api_requests.h"
 #include "chrome/browser/google_apis/drive_api_url_generator.h"
 #include "chrome/browser/google_apis/request_sender.h"
 #include "chrome/browser/google_apis/task_util.h"
 #include "chrome/browser/google_apis/test_util.h"
 #include "chrome/test/base/testing_profile.h"
@@ skipping 292 matching lines @@
 };
 
 TEST_F(DriveApiRequestsTest, GetAboutRequest_ValidJson) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "chromeos/drive/about.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<AboutResource> about_resource;
 
-  GetAboutRequest* request = new GetAboutRequest(
-      request_sender_.get(),
-      request_context_getter_.get(),
-      *url_generator_,
-      CreateComposedCallback(
-          base::Bind(&test_util::RunAndQuit),
-          test_util::CreateCopyResultCallback(&error, &about_resource)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    GetAboutRequest* request = new GetAboutRequest(
+        request_sender_.get(),
+        request_context_getter_.get(),
+        *url_generator_,
+        test_util::CreateQuitCallback(
+            &run_loop,
+            test_util::CreateCopyResultCallback(&error, &about_resource)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/about", http_request_.relative_url);
 
   scoped_ptr<AboutResource> expected(
       AboutResource::CreateFrom(
           *test_util::LoadJSONFile("chromeos/drive/about.json")));
   ASSERT_TRUE(about_resource.get());
   EXPECT_EQ(expected->largest_change_id(), about_resource->largest_change_id());
   EXPECT_EQ(expected->quota_bytes_total(), about_resource->quota_bytes_total());
   EXPECT_EQ(expected->quota_bytes_used(), about_resource->quota_bytes_used());
   EXPECT_EQ(expected->root_folder_id(), about_resource->root_folder_id());
 }
 
 TEST_F(DriveApiRequestsTest, GetAboutRequest_InvalidJson) {
   // Set an expected data file containing invalid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "chromeos/gdata/testfile.txt");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<AboutResource> about_resource;
 
-  GetAboutRequest* request = new GetAboutRequest(
-      request_sender_.get(),
-      request_context_getter_.get(),
-      *url_generator_,
-      CreateComposedCallback(
-          base::Bind(&test_util::RunAndQuit),
-          test_util::CreateCopyResultCallback(&error, &about_resource)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    GetAboutRequest* request = new GetAboutRequest(
+        request_sender_.get(),
+        request_context_getter_.get(),
+        *url_generator_,
+        test_util::CreateQuitCallback(
+            &run_loop,
+            test_util::CreateCopyResultCallback(&error, &about_resource)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   // "parse error" should be returned, and the about resource should be NULL.
   EXPECT_EQ(GDATA_PARSE_ERROR, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/about", http_request_.relative_url);
   EXPECT_FALSE(about_resource.get());
 }
 
 TEST_F(DriveApiRequestsTest, GetApplistRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "chromeos/drive/applist.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result;
 
-  GetApplistRequest* request = new GetApplistRequest(
-      request_sender_.get(),
-      request_context_getter_.get(),
-      *url_generator_,
-      CreateComposedCallback(
-          base::Bind(&test_util::RunAndQuit),
-          test_util::CreateCopyResultCallback(&error, &result)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    GetApplistRequest* request = new GetApplistRequest(
+        request_sender_.get(),
+        request_context_getter_.get(),
+        *url_generator_,
+        test_util::CreateQuitCallback(
+            &run_loop,
+            test_util::CreateCopyResultCallback(&error, &result)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/apps", http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, GetChangelistRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "chromeos/drive/changelist.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result;
 
-  GetChangelistRequest* request = new GetChangelistRequest(
-      request_sender_.get(),
-      request_context_getter_.get(),
-      *url_generator_,
-      true,  // include deleted
-      100,  // start changestamp
-      500,  // max results
-      CreateComposedCallback(
-          base::Bind(&test_util::RunAndQuit),
-          test_util::CreateCopyResultCallback(&error, &result)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    GetChangelistRequest* request = new GetChangelistRequest(
+        request_sender_.get(),
+        request_context_getter_.get(),
+        *url_generator_,
+        true,  // include deleted
+        100,  // start changestamp
+        500,  // max results
+        test_util::CreateQuitCallback(
+            &run_loop,
+            test_util::CreateCopyResultCallback(&error, &result)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/changes?startChangeId=100&maxResults=500",
             http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, GetFilelistRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "chromeos/drive/filelist.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result;
 
-  GetFilelistRequest* request = new GetFilelistRequest(
-      request_sender_.get(),
-      request_context_getter_.get(),
-      *url_generator_,
-      "\"abcde\" in parents",
-      50,  // max results
-      CreateComposedCallback(
-          base::Bind(&test_util::RunAndQuit),
-          test_util::CreateCopyResultCallback(&error, &result)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    GetFilelistRequest* request = new GetFilelistRequest(
+        request_sender_.get(),
+        request_context_getter_.get(),
+        *url_generator_,
+        "\"abcde\" in parents",
+        50,  // max results
+        test_util::CreateQuitCallback(
+            &run_loop,
+            test_util::CreateCopyResultCallback(&error, &result)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/files?maxResults=50&q=%22abcde%22+in+parents",
             http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, ContinueGetFileListRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "chromeos/drive/filelist.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result;
 
-  drive::ContinueGetFileListRequest* request =
-      new drive::ContinueGetFileListRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          test_server_.GetURL("/continue/get/file/list"),
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &result)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::ContinueGetFileListRequest* request =
+        new drive::ContinueGetFileListRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            test_server_.GetURL("/continue/get/file/list"),
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &result)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/continue/get/file/list", http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, CreateDirectoryRequest) {
   // Set an expected data file containing the directory's entry data.
   expected_data_file_path_ =
       test_util::GetTestFilePath("chromeos/drive/directory_entry.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> file_resource;
 
   // Create "new directory" in the root directory.
-  drive::CreateDirectoryRequest* request =
-      new drive::CreateDirectoryRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          "root",
-          "new directory",
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &file_resource)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::CreateDirectoryRequest* request =
+        new drive::CreateDirectoryRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            "root",
+            "new directory",
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &file_resource)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/drive/v2/files", http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
 
   scoped_ptr<FileResource> expected(
       FileResource::CreateFrom(
@@ skipping 10 matching lines @@
 
 TEST_F(DriveApiRequestsTest, RenameResourceRequest) {
   // Set an expected data file containing the directory's entry data.
   // It'd be returned if we rename a directory.
   expected_data_file_path_ =
       test_util::GetTestFilePath("chromeos/drive/directory_entry.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
 
   // Create "new directory" in the root directory.
-  drive::RenameResourceRequest* request =
-      new drive::RenameResourceRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          "resource_id",
-          "new name",
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::RenameResourceRequest* request =
+        new drive::RenameResourceRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            "resource_id",
+            "new name",
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_PATCH, http_request_.method);
   EXPECT_EQ("/drive/v2/files/resource_id", http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("{\"title\":\"new name\"}", http_request_.content);
 }
 
 TEST_F(DriveApiRequestsTest, TouchResourceRequest) {
   // Set an expected data file containing the directory's entry data.
   // It'd be returned if we rename a directory.
   expected_data_file_path_ =
       test_util::GetTestFilePath("chromeos/drive/directory_entry.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> file_resource;
   const base::Time::Exploded kModifiedDate = {2012, 7, 0, 19, 15, 59, 13, 123};
   const base::Time::Exploded kLastViewedByMeDate =
       {2013, 7, 0, 19, 15, 59, 13, 123};
 
   // Touch a file with |resource_id|.
-  drive::TouchResourceRequest* request = new drive::TouchResourceRequest(
-      request_sender_.get(),
-      request_context_getter_.get(),
-      *url_generator_,
-      "resource_id",
-      base::Time::FromUTCExploded(kModifiedDate),
-      base::Time::FromUTCExploded(kLastViewedByMeDate),
-      CreateComposedCallback(
-          base::Bind(&test_util::RunAndQuit),
-          test_util::CreateCopyResultCallback(&error, &file_resource)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::TouchResourceRequest* request = new drive::TouchResourceRequest(
+        request_sender_.get(),
+        request_context_getter_.get(),
+        *url_generator_,
+        "resource_id",
+        base::Time::FromUTCExploded(kModifiedDate),
+        base::Time::FromUTCExploded(kLastViewedByMeDate),
+        test_util::CreateQuitCallback(
+            &run_loop,
+            test_util::CreateCopyResultCallback(&error, &file_resource)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_PATCH, http_request_.method);
   EXPECT_EQ("/drive/v2/files/resource_id"
             "?setModifiedDate=true&updateViewedDate=false",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("{\"lastViewedByMeDate\":\"2013-07-19T15:59:13.123Z\","
             "\"modifiedDate\":\"2012-07-19T15:59:13.123Z\"}",
             http_request_.content);
 }
 
 TEST_F(DriveApiRequestsTest, CopyResourceRequest) {
   // Set an expected data file containing the dummy file entry data.
   // It'd be returned if we copy a file.
   expected_data_file_path_ =
       test_util::GetTestFilePath("chromeos/drive/file_entry.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> file_resource;
 
   // Copy the file to a new file named "new name".
-  drive::CopyResourceRequest* request =
-      new drive::CopyResourceRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          "resource_id",
-          "parent_resource_id",
-          "new name",
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &file_resource)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::CopyResourceRequest* request =
+        new drive::CopyResourceRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            "resource_id",
+            "parent_resource_id",
+            "new name",
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &file_resource)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/drive/v2/files/resource_id/copy", http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ(
       "{\"parents\":[{\"id\":\"parent_resource_id\"}],\"title\":\"new name\"}",
       http_request_.content);
   EXPECT_TRUE(file_resource);
 }
 
 TEST_F(DriveApiRequestsTest, CopyResourceRequest_EmptyParentResourceId) {
   // Set an expected data file containing the dummy file entry data.
   // It'd be returned if we copy a file.
   expected_data_file_path_ =
       test_util::GetTestFilePath("chromeos/drive/file_entry.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   scoped_ptr<FileResource> file_resource;
 
   // Copy the file to a new file named "new name".
-  drive::CopyResourceRequest* request =
-      new drive::CopyResourceRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          "resource_id",
-          std::string(),  // parent resource id.
-          "new name",
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &file_resource)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::CopyResourceRequest* request =
+        new drive::CopyResourceRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            "resource_id",
+            std::string(),  // parent resource id.
+            "new name",
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &file_resource)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/drive/v2/files/resource_id/copy", http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("{\"title\":\"new name\"}", http_request_.content);
   EXPECT_TRUE(file_resource);
 }
 
 TEST_F(DriveApiRequestsTest, TrashResourceRequest) {
   // Set data for the expected result. Directory entry should be returned
   // if the trashing entry is a directory, so using it here should be fine.
   expected_data_file_path_ =
       test_util::GetTestFilePath("chromeos/drive/directory_entry.json");
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
 
   // Trash a resource with the given resource id.
-  drive::TrashResourceRequest* request =
-      new drive::TrashResourceRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          "resource_id",
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::TrashResourceRequest* request =
+        new drive::TrashResourceRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            "resource_id",
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/drive/v2/files/resource_id/trash", http_request_.relative_url);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(http_request_.content.empty());
 }
 
 TEST_F(DriveApiRequestsTest, InsertResourceRequest) {
   // Set an expected data file containing the children entry.
   expected_content_type_ = "application/json";
   expected_content_ = kTestChildrenResponse;
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
 
   // Add a resource with "resource_id" to a directory with
   // "parent_resource_id".
-  drive::InsertResourceRequest* request =
-      new drive::InsertResourceRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          "parent_resource_id",
-          "resource_id",
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::InsertResourceRequest* request =
+        new drive::InsertResourceRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            "parent_resource_id",
+            "resource_id",
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/drive/v2/files/parent_resource_id/children",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("{\"id\":\"resource_id\"}", http_request_.content);
 }
 
 TEST_F(DriveApiRequestsTest, DeleteResourceRequest) {
   GDataErrorCode error = GDATA_OTHER_ERROR;
 
   // Remove a resource with "resource_id" from a directory with
   // "parent_resource_id".
-  drive::DeleteResourceRequest* request =
-      new drive::DeleteResourceRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          "parent_resource_id",
-          "resource_id",
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::DeleteResourceRequest* request =
+        new drive::DeleteResourceRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            "parent_resource_id",
+            "resource_id",
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_NO_CONTENT, error);
   EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
   EXPECT_EQ("/drive/v2/files/parent_resource_id/children/resource_id",
             http_request_.relative_url);
   EXPECT_FALSE(http_request_.has_content);
 }
 
 TEST_F(DriveApiRequestsTest, UploadNewFileRequest) {
   // Set an expected url for uploading.
   expected_upload_path_ = kTestUploadNewFilePath;
 
   const char kTestContentType[] = "text/plain";
   const std::string kTestContent(100, 'a');
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // Initiate uploading a new file to the directory with
   // "parent_resource_id".
-  drive::InitiateUploadNewFileRequest* request =
-      new drive::InitiateUploadNewFileRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          kTestContentType,
-          kTestContent.size(),
-          "parent_resource_id",  // The resource id of the parent directory.
-          "new file title",  // The title of the file being uploaded.
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &upload_url)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::InitiateUploadNewFileRequest* request =
+        new drive::InitiateUploadNewFileRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            kTestContentType,
+            kTestContent.size(),
+            "parent_resource_id",  // The resource id of the parent directory.
+            "new file title",  // The title of the file being uploaded.
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &upload_url)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(kTestUploadNewFilePath, upload_url.path());
   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("{\"parents\":[{"
             "\"id\":\"parent_resource_id\","
             "\"kind\":\"drive#fileLink\""
             "}],"
             "\"title\":\"new file title\"}",
             http_request_.content);
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<FileResource> new_entry;
 
-  drive::ResumeUploadRequest* resume_request =
-      new drive::ResumeUploadRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          upload_url,
-          0,  // start_position
-          kTestContent.size(),  // end_position (exclusive)
-          kTestContent.size(),  // content_length,
-          kTestContentType,
-          kTestFilePath,
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&response, &new_entry)),
-          ProgressCallback());
-  request_sender_->StartRequestWithRetry(resume_request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::ResumeUploadRequest* resume_request =
+        new drive::ResumeUploadRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            upload_url,
+            0,  // start_position
+            kTestContent.size(),  // end_position (exclusive)
+            kTestContent.size(),  // content_length,
+            kTestContentType,
+            kTestFilePath,
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&response, &new_entry)),
+            ProgressCallback());
+    request_sender_->StartRequestWithRetry(resume_request);
+    run_loop.Run();
+  }
 
   // METHOD_PUT should be used to upload data.
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // Request should go to the upload URL.
   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
   // Content-Range header should be added.
   EXPECT_EQ("bytes 0-" +
             base::Int64ToString(kTestContent.size() - 1) + "/" +
             base::Int64ToString(kTestContent.size()),
             http_request_.headers["Content-Range"]);
@@ skipping 15 matching lines @@
   const char kTestContentType[] = "text/plain";
   const char kTestContent[] = "";
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("empty_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // Initiate uploading a new file to the directory with "parent_resource_id".
-  drive::InitiateUploadNewFileRequest* request =
-      new drive::InitiateUploadNewFileRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          kTestContentType,
-          0,
-          "parent_resource_id",  // The resource id of the parent directory.
-          "new file title",  // The title of the file being uploaded.
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &upload_url)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::InitiateUploadNewFileRequest* request =
+        new drive::InitiateUploadNewFileRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            kTestContentType,
+            0,
+            "parent_resource_id",  // The resource id of the parent directory.
+            "new file title",  // The title of the file being uploaded.
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &upload_url)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(kTestUploadNewFilePath, upload_url.path());
   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ("0", http_request_.headers["X-Upload-Content-Length"]);
 
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("{\"parents\":[{"
             "\"id\":\"parent_resource_id\","
             "\"kind\":\"drive#fileLink\""
             "}],"
             "\"title\":\"new file title\"}",
             http_request_.content);
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<FileResource> new_entry;
 
-  drive::ResumeUploadRequest* resume_request =
-      new drive::ResumeUploadRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          upload_url,
-          0,  // start_position
-          0,  // end_position (exclusive)
-          0,  // content_length,
-          kTestContentType,
-          kTestFilePath,
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&response, &new_entry)),
-          ProgressCallback());
-  request_sender_->StartRequestWithRetry(resume_request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::ResumeUploadRequest* resume_request =
+        new drive::ResumeUploadRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            upload_url,
+            0,  // start_position
+            0,  // end_position (exclusive)
+            0,  // content_length,
+            kTestContentType,
+            kTestFilePath,
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&response, &new_entry)),
+            ProgressCallback());
+    request_sender_->StartRequestWithRetry(resume_request);
+    run_loop.Run();
+  }
 
   // METHOD_PUT should be used to upload data.
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // Request should go to the upload URL.
   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
   // Content-Range header should NOT be added.
   EXPECT_EQ(0U, http_request_.headers.count("Content-Range"));
   // The upload content should be set in the HTTP request.
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ(kTestContent, http_request_.content);
@@ skipping 13 matching lines @@
   const size_t kNumChunkBytes = 10;  // Num bytes in a chunk.
   const std::string kTestContent(100, 'a');
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // Initiate uploading a new file to the directory with "parent_resource_id".
-  drive::InitiateUploadNewFileRequest* request =
-      new drive::InitiateUploadNewFileRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          kTestContentType,
-          kTestContent.size(),
-          "parent_resource_id",  // The resource id of the parent directory.
-          "new file title",  // The title of the file being uploaded.
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &upload_url)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::InitiateUploadNewFileRequest* request =
+        new drive::InitiateUploadNewFileRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            kTestContentType,
+            kTestContent.size(),
+            "parent_resource_id",  // The resource id of the parent directory.
+            "new file title",  // The title of the file being uploaded.
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &upload_url)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(kTestUploadNewFilePath, upload_url.path());
   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("{\"parents\":[{"
             "\"id\":\"parent_resource_id\","
             "\"kind\":\"drive#fileLink\""
             "}],"
             "\"title\":\"new file title\"}",
             http_request_.content);
 
   // Before sending any data, check the current status.
   // This is an edge case test for GetUploadStatusRequest.
   {
     UploadRangeResponse response;
     scoped_ptr<FileResource> new_entry;
 
     // Check the response by GetUploadStatusRequest.
-    drive::GetUploadStatusRequest* get_upload_status_request =
-        new drive::GetUploadStatusRequest(
-            request_sender_.get(),
-            request_context_getter_.get(),
-            upload_url,
-            kTestContent.size(),
-            CreateComposedCallback(
-                base::Bind(&test_util::RunAndQuit),
-                test_util::CreateCopyResultCallback(&response, &new_entry)));
-    request_sender_->StartRequestWithRetry(get_upload_status_request);
-    base::MessageLoop::current()->Run();
+    {
+      base::RunLoop run_loop;
+      drive::GetUploadStatusRequest* get_upload_status_request =
+          new drive::GetUploadStatusRequest(
+              request_sender_.get(),
+              request_context_getter_.get(),
+              upload_url,
+              kTestContent.size(),
+              test_util::CreateQuitCallback(
+                  &run_loop,
+                  test_util::CreateCopyResultCallback(&response, &new_entry)));
+      request_sender_->StartRequestWithRetry(get_upload_status_request);
+      run_loop.Run();
+    }
 
     // METHOD_PUT should be used to upload data.
     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes */" + base::Int64ToString(kTestContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
     EXPECT_TRUE(http_request_.content.empty());
 
     // Check the response.
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
     EXPECT_EQ(0, response.start_position_received);
     EXPECT_EQ(0, response.end_position_received);
   }
 
   // Upload the content to the upload URL.
   for (size_t start_position = 0; start_position < kTestContent.size();
        start_position += kNumChunkBytes) {
     const std::string payload = kTestContent.substr(
         start_position,
         std::min(kNumChunkBytes, kTestContent.size() - start_position));
     const size_t end_position = start_position + payload.size();
 
     UploadRangeResponse response;
     scoped_ptr<FileResource> new_entry;
 
-    drive::ResumeUploadRequest* resume_request =
-        new drive::ResumeUploadRequest(
-            request_sender_.get(),
-            request_context_getter_.get(),
-            upload_url,
-            start_position,
-            end_position,
-            kTestContent.size(),  // content_length,
-            kTestContentType,
-            kTestFilePath,
-            CreateComposedCallback(
-                base::Bind(&test_util::RunAndQuit),
-                test_util::CreateCopyResultCallback(&response, &new_entry)),
-            ProgressCallback());
-    request_sender_->StartRequestWithRetry(resume_request);
-    base::MessageLoop::current()->Run();
+    {
+      base::RunLoop run_loop;
+      drive::ResumeUploadRequest* resume_request =
+          new drive::ResumeUploadRequest(
+              request_sender_.get(),
+              request_context_getter_.get(),
+              upload_url,
+              start_position,
+              end_position,
+              kTestContent.size(),  // content_length,
+              kTestContentType,
+              kTestFilePath,
+              test_util::CreateQuitCallback(
+                  &run_loop,
+                  test_util::CreateCopyResultCallback(&response, &new_entry)),
+              ProgressCallback());
+      request_sender_->StartRequestWithRetry(resume_request);
+      run_loop.Run();
+    }
 
     // METHOD_PUT should be used to upload data.
     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes " +
               base::Int64ToString(start_position) + "-" +
               base::Int64ToString(end_position - 1) + "/" +
               base::Int64ToString(kTestContent.size()),
@@ skipping 11 matching lines @@
       EXPECT_EQ(-1, response.end_position_received);
       break;
     }
 
     // Check the response.
     EXPECT_EQ(HTTP_RESUME_INCOMPLETE, response.code);
     EXPECT_EQ(0, response.start_position_received);
     EXPECT_EQ(static_cast<int64>(end_position), response.end_position_received);
 
     // Check the response by GetUploadStatusRequest.
-    drive::GetUploadStatusRequest* get_upload_status_request =
-        new drive::GetUploadStatusRequest(
-            request_sender_.get(),
-            request_context_getter_.get(),
-            upload_url,
-            kTestContent.size(),
-            CreateComposedCallback(
-                base::Bind(&test_util::RunAndQuit),
-                test_util::CreateCopyResultCallback(&response, &new_entry)));
-    request_sender_->StartRequestWithRetry(get_upload_status_request);
-    base::MessageLoop::current()->Run();
+    {
+      base::RunLoop run_loop;
+      drive::GetUploadStatusRequest* get_upload_status_request =
+          new drive::GetUploadStatusRequest(
+              request_sender_.get(),
+              request_context_getter_.get(),
+              upload_url,
+              kTestContent.size(),
+              test_util::CreateQuitCallback(
+                  &run_loop,
+                  test_util::CreateCopyResultCallback(&response, &new_entry)));
+      request_sender_->StartRequestWithRetry(get_upload_status_request);
+      run_loop.Run();
+    }
 
     // METHOD_PUT should be used to upload data.
     EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
     // Request should go to the upload URL.
     EXPECT_EQ(upload_url.path(), http_request_.relative_url);
     // Content-Range header should be added.
     EXPECT_EQ("bytes */" + base::Int64ToString(kTestContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
     EXPECT_TRUE(http_request_.content.empty());
@@ skipping 13 matching lines @@
   const char kTestContentType[] = "text/plain";
   const std::string kTestContent(100, 'a');
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // Initiate uploading a new file to the directory with "parent_resource_id".
-  drive::InitiateUploadExistingFileRequest* request =
-      new drive::InitiateUploadExistingFileRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          kTestContentType,
-          kTestContent.size(),
-          "resource_id",  // The resource id of the file to be overwritten.
-          std::string(),  // No etag.
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &upload_url)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::InitiateUploadExistingFileRequest* request =
+        new drive::InitiateUploadExistingFileRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            kTestContentType,
+            kTestContent.size(),
+            "resource_id",  // The resource id of the file to be overwritten.
+            std::string(),  // No etag.
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &upload_url)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(kTestUploadExistingFilePath, upload_url.path());
   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(http_request_.content.empty());
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<FileResource> new_entry;
 
-  drive::ResumeUploadRequest* resume_request =
-      new drive::ResumeUploadRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          upload_url,
-          0,  // start_position
-          kTestContent.size(),  // end_position (exclusive)
-          kTestContent.size(),  // content_length,
-          kTestContentType,
-          kTestFilePath,
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&response, &new_entry)),
-          ProgressCallback());
-  request_sender_->StartRequestWithRetry(resume_request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::ResumeUploadRequest* resume_request =
+        new drive::ResumeUploadRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            upload_url,
+            0,  // start_position
+            kTestContent.size(),  // end_position (exclusive)
+            kTestContent.size(),  // content_length,
+            kTestContentType,
+            kTestFilePath,
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&response, &new_entry)),
+            ProgressCallback());
+    request_sender_->StartRequestWithRetry(resume_request);
+    run_loop.Run();
+  }
 
   // METHOD_PUT should be used to upload data.
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // Request should go to the upload URL.
   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
   // Content-Range header should be added.
   EXPECT_EQ("bytes 0-" +
             base::Int64ToString(kTestContent.size() - 1) + "/" +
             base::Int64ToString(kTestContent.size()),
             http_request_.headers["Content-Range"]);
@@ skipping 15 matching lines @@
   const char kTestContentType[] = "text/plain";
   const std::string kTestContent(100, 'a');
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // Initiate uploading a new file to the directory with "parent_resource_id".
-  drive::InitiateUploadExistingFileRequest* request =
-      new drive::InitiateUploadExistingFileRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          kTestContentType,
-          kTestContent.size(),
-          "resource_id",  // The resource id of the file to be overwritten.
-          kTestETag,
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &upload_url)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::InitiateUploadExistingFileRequest* request =
+        new drive::InitiateUploadExistingFileRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            kTestContentType,
+            kTestContent.size(),
+            "resource_id",  // The resource id of the file to be overwritten.
+            kTestETag,
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &upload_url)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(kTestUploadExistingFilePath, upload_url.path());
   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   EXPECT_EQ(kTestETag, http_request_.headers["If-Match"]);
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(http_request_.content.empty());
 
   // Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<FileResource> new_entry;
 
-  drive::ResumeUploadRequest* resume_request =
-      new drive::ResumeUploadRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          upload_url,
-          0,  // start_position
-          kTestContent.size(),  // end_position (exclusive)
-          kTestContent.size(),  // content_length,
-          kTestContentType,
-          kTestFilePath,
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&response, &new_entry)),
-          ProgressCallback());
-  request_sender_->StartRequestWithRetry(resume_request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::ResumeUploadRequest* resume_request =
+        new drive::ResumeUploadRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            upload_url,
+            0,  // start_position
+            kTestContent.size(),  // end_position (exclusive)
+            kTestContent.size(),  // content_length,
+            kTestContentType,
+            kTestFilePath,
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&response, &new_entry)),
+            ProgressCallback());
+    request_sender_->StartRequestWithRetry(resume_request);
+    run_loop.Run();
+  }
 
   // METHOD_PUT should be used to upload data.
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // Request should go to the upload URL.
   EXPECT_EQ(upload_url.path(), http_request_.relative_url);
   // Content-Range header should be added.
   EXPECT_EQ("bytes 0-" +
             base::Int64ToString(kTestContent.size() - 1) + "/" +
             base::Int64ToString(kTestContent.size()),
             http_request_.headers["Content-Range"]);
@@ skipping 12 matching lines @@
   // Set an expected url for uploading.
   expected_upload_path_ = kTestUploadExistingFilePath;
 
   const char kTestContentType[] = "text/plain";
   const std::string kTestContent(100, 'a');
 
   GDataErrorCode error = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // Initiate uploading a new file to the directory with "parent_resource_id".
-  drive::InitiateUploadExistingFileRequest* request =
-      new drive::InitiateUploadExistingFileRequest(
-          request_sender_.get(),
-          request_context_getter_.get(),
-          *url_generator_,
-          kTestContentType,
-          kTestContent.size(),
-          "resource_id",  // The resource id of the file to be overwritten.
-          "Conflicting-etag",
-          CreateComposedCallback(
-              base::Bind(&test_util::RunAndQuit),
-              test_util::CreateCopyResultCallback(&error, &upload_url)));
-  request_sender_->StartRequestWithRetry(request);
-  base::MessageLoop::current()->Run();
+  {
+    base::RunLoop run_loop;
+    drive::InitiateUploadExistingFileRequest* request =
+        new drive::InitiateUploadExistingFileRequest(
+            request_sender_.get(),
+            request_context_getter_.get(),
+            *url_generator_,
+            kTestContentType,
+            kTestContent.size(),
+            "resource_id",  // The resource id of the file to be overwritten.
+            "Conflicting-etag",
+            test_util::CreateQuitCallback(
+                &run_loop,
+                test_util::CreateCopyResultCallback(&error, &upload_url)));
+    request_sender_->StartRequestWithRetry(request);
+    run_loop.Run();
+  }
 
   EXPECT_EQ(HTTP_PRECONDITION, error);
   EXPECT_EQ(kTestContentType, http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kTestContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   EXPECT_EQ("Conflicting-etag", http_request_.headers["If-Match"]);
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/upload/drive/v2/files/resource_id?uploadType=resumable",
             http_request_.relative_url);
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_TRUE(http_request_.content.empty());
 }
 
 }  // namespace google_apis