Replace most of the occurrence of OperationRegistry with OperationRunner.

chrome/browser/google_apis/gdata_wapi_operations_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 <algorithm>
 #include <map>
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/stringprintf.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/gdata_wapi_operations.h"
 #include "chrome/browser/google_apis/gdata_wapi_parser.h"
 #include "chrome/browser/google_apis/gdata_wapi_url_generator.h"
-#include "chrome/browser/google_apis/operation_registry.h"
+#include "chrome/browser/google_apis/operation_runner.h"
 #include "chrome/browser/google_apis/task_util.h"
 #include "chrome/browser/google_apis/test_util.h"
-#include "chrome/browser/profiles/profile.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread.h"
 #include "net/base/escape.h"
 #include "net/test/embedded_test_server/embedded_test_server.h"
 #include "net/test/embedded_test_server/http_request.h"
 #include "net/test/embedded_test_server/http_response.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace google_apis {
@@ skipping 16 matching lines @@
 
   virtual void SetUp() OVERRIDE {
     file_thread_.Start();
     io_thread_.StartIOThread();
     profile_.reset(new TestingProfile);
 
     request_context_getter_ = new net::TestURLRequestContextGetter(
         content::BrowserThread::GetMessageLoopProxyForThread(
             content::BrowserThread::IO));
 
+    operation_runner_.reset(new OperationRunner(profile_.get(),
+                                                request_context_getter_,
+                                                std::vector<std::string>(),
+                                                kTestUserAgent));
+    operation_runner_->auth_service()->set_access_token_for_testing(
+        kTestGDataAuthToken);
+
     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 
     ASSERT_TRUE(test_server_.InitializeAndWaitUntilReady());
     test_server_.RegisterRequestHandler(
         base::Bind(&test_util::HandleDownloadRequest,
                    test_server_.base_url(),
                    base::Unretained(&http_request_)));
     test_server_.RegisterRequestHandler(
         base::Bind(&GDataWapiOperationsTest::HandleResourceFeedRequest,
                    base::Unretained(this)));
@@ skipping 224 matching lines @@
 
     return response.Pass();
   }
 
   MessageLoopForUI message_loop_;
   content::TestBrowserThread ui_thread_;
   content::TestBrowserThread file_thread_;
   content::TestBrowserThread io_thread_;
   net::test_server::EmbeddedTestServer test_server_;
   scoped_ptr<TestingProfile> profile_;
-  OperationRegistry operation_registry_;
+  scoped_ptr<OperationRunner> operation_runner_;
   scoped_ptr<GDataWapiUrlGenerator> url_generator_;
   scoped_refptr<net::TestURLRequestContextGetter> request_context_getter_;
   base::ScopedTempDir temp_dir_;
 
   // These fields are used to keep the current upload state during a
   // test case. These values are updated by the request from
   // ResumeUploadOperation, and used to construct the response for
   // both ResumeUploadOperation and GetUploadStatusOperation, to emulate
   // the WAPI server.
   int64 received_bytes_;
   int64 content_length_;
 
   // The incoming HTTP request is saved so tests can verify the request
   // parameters like HTTP method (ex. some operations should use DELETE
   // instead of GET).
   net::test_server::HttpRequest http_request_;
 };
 
 }  // namespace
 
 TEST_F(GDataWapiOperationsTest, GetResourceListOperation_DefaultFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceList> result_data;
 
   GetResourceListOperation* operation = new GetResourceListOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       GURL(),         // Pass an empty URL to use the default feed
       0,              // start changestamp
       std::string(),  // search string
       std::string(),  // directory resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full?v=3&alt=json&showroot=true&"
             "showfolders=true&include-shared=true&max-results=500",
             http_request_.relative_url);
 
   // Sanity check of the result.
   scoped_ptr<ResourceList> expected(
       ResourceList::ExtractAndParse(
           *test_util::LoadJSONFile("chromeos/gdata/root_feed.json")));
   ASSERT_TRUE(result_data);
   EXPECT_EQ(expected->title(), result_data->title());
 }
 
 TEST_F(GDataWapiOperationsTest, GetResourceListOperation_ValidFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceList> result_data;
 
   GetResourceListOperation* operation = new GetResourceListOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       test_server_.GetURL("/files/chromeos/gdata/root_feed.json"),
       0,              // start changestamp
       std::string(),  // search string
       std::string(),  // directory resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/files/chromeos/gdata/root_feed.json?v=3&alt=json&showroot=true&"
             "showfolders=true&include-shared=true&max-results=500",
             http_request_.relative_url);
 
   scoped_ptr<ResourceList> expected(
       ResourceList::ExtractAndParse(
           *test_util::LoadJSONFile("chromeos/gdata/root_feed.json")));
   ASSERT_TRUE(result_data);
   EXPECT_EQ(expected->title(), result_data->title());
 }
 
 TEST_F(GDataWapiOperationsTest, GetResourceListOperation_InvalidFeed) {
   // testfile.txt exists but the response is not JSON, so it should
   // emit a parse error instead.
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceList> result_data;
 
   GetResourceListOperation* operation = new GetResourceListOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       test_server_.GetURL("/files/chromeos/gdata/testfile.txt"),
       0,              // start changestamp
       std::string(),  // search string
       std::string(),  // directory resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(GDATA_PARSE_ERROR, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/files/chromeos/gdata/testfile.txt?v=3&alt=json&showroot=true&"
             "showfolders=true&include-shared=true&max-results=500",
             http_request_.relative_url);
   EXPECT_FALSE(result_data);
 }
 
 TEST_F(GDataWapiOperationsTest, SearchByTitleOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<ResourceList> result_data;
 
   SearchByTitleOperation* operation = new SearchByTitleOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       "search-title",
       std::string(),  // directory resource id
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full?v=3&alt=json&showroot=true&"
             "showfolders=true&include-shared=true&max-results=500"
             "&title=search-title&title-exact=true",
             http_request_.relative_url);
   EXPECT_TRUE(result_data);
 }
 
 TEST_F(GDataWapiOperationsTest, GetResourceEntryOperation_ValidResourceId) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   GetResourceEntryOperation* operation = new GetResourceEntryOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       "file:2_file_resource_id",  // resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/file%3A2_file_resource_id"
             "?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_TRUE(test_util::VerifyJsonData(
       test_util::GetTestFilePath("chromeos/gdata/file_entry.json"),
       result_data.get()));
 }
 
 TEST_F(GDataWapiOperationsTest, GetResourceEntryOperation_InvalidResourceId) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   GetResourceEntryOperation* operation = new GetResourceEntryOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       "<invalid>",  // resource ID
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)));
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_NOT_FOUND, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/%3Cinvalid%3E?v=3&alt=json"
             "&showroot=true",
             http_request_.relative_url);
   ASSERT_FALSE(result_data);
 }
 
 TEST_F(GDataWapiOperationsTest, GetAccountMetadataOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<AccountMetadata> result_data;
 
   GetAccountMetadataOperation* operation = new GetAccountMetadataOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       true);  // Include installed apps.
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/metadata/default?v=3&alt=json&showroot=true"
             "&include-installed-apps=true",
             http_request_.relative_url);
 
   scoped_ptr<AccountMetadata> expected(
       AccountMetadata::CreateFrom(
@@ skipping 11 matching lines @@
   EXPECT_EQ(expected->installed_apps().size(),
             result_data->installed_apps().size());
 }
 
 TEST_F(GDataWapiOperationsTest,
        GetAccountMetadataOperationWithoutInstalledApps) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<AccountMetadata> result_data;
 
   GetAccountMetadataOperation* operation = new GetAccountMetadataOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       false);  // Exclude installed apps.
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/feeds/metadata/default?v=3&alt=json&showroot=true",
             http_request_.relative_url);
 
   scoped_ptr<AccountMetadata> expected(
       AccountMetadata::CreateFrom(
           *test_util::LoadJSONFile("chromeos/gdata/account_metadata.json")));
 
   ASSERT_TRUE(result_data.get());
   EXPECT_EQ(expected->largest_changestamp(),
             result_data->largest_changestamp());
   EXPECT_EQ(expected->quota_bytes_total(),
             result_data->quota_bytes_total());
   EXPECT_EQ(expected->quota_bytes_used(),
             result_data->quota_bytes_used());
 
   // Installed apps shouldn't be included.
   EXPECT_EQ(0U, result_data->installed_apps().size());
 }
 
 TEST_F(GDataWapiOperationsTest, DeleteResourceOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
 
   DeleteResourceOperation* operation = new DeleteResourceOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(base::Bind(&test_util::RunAndQuit),
                              test_util::CreateCopyResultCallback(&result_code)),
       "file:2_file_resource_id",
       std::string());
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
   EXPECT_EQ(
       "/feeds/default/private/full/file%3A2_file_resource_id?v=3&alt=json"
       "&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 }
 
 TEST_F(GDataWapiOperationsTest, DeleteResourceOperationWithETag) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
 
   DeleteResourceOperation* operation = new DeleteResourceOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code)),
       "file:2_file_resource_id",
       "etag");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
   EXPECT_EQ(
       "/feeds/default/private/full/file%3A2_file_resource_id?v=3&alt=json"
       "&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("etag", http_request_.headers["If-Match"]);
 }
 
 TEST_F(GDataWapiOperationsTest, CreateDirectoryOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   // Create "new directory" in the root directory.
   CreateDirectoryOperation* operation = new CreateDirectoryOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "folder:root",
       "new directory");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/folder%3Aroot/contents?v=3&alt=json"
             "&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\">\n"
             " <category scheme=\"http://schemas.google.com/g/2005#kind\" "
             "term=\"http://schemas.google.com/docs/2007#folder\"/>\n"
             " <title>new directory</title>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, CopyHostedDocumentOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   scoped_ptr<base::Value> result_data;
 
   // Copy a document with a new name "New Document".
   CopyHostedDocumentOperation* operation = new CopyHostedDocumentOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "document:5_document_resource_id",  // source resource ID
       "New Document");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\">\n"
             " <id>document:5_document_resource_id</id>\n"
             " <title>New Document</title>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, RenameResourceOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
 
   // Rename a file with a new name "New File".
   RenameResourceOperation* operation = new RenameResourceOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code)),
       "file:2_file_resource_id",
       "New File");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ(
       "/feeds/default/private/full/file%3A2_file_resource_id?v=3&alt=json"
       "&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\">\n"
             " <title>New File</title>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, AuthorizeAppOperation_ValidFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL result_data;
 
   // Authorize an app with APP_ID to access to a document.
   AuthorizeAppOperation* operation = new AuthorizeAppOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "file:2_file_resource_id",
       "the_app_id");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(GURL("https://entry1_open_with_link/"), result_data);
 
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/file%3A2_file_resource_id"
             "?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
             " <docs:authorizedApp>the_app_id</docs:authorizedApp>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, AuthorizeAppOperation_NotFound) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL result_data;
 
   // Authorize an app with APP_ID to access to a document.
   AuthorizeAppOperation* operation = new AuthorizeAppOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "file:2_file_resource_id",
       "unauthorized_app_id");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(GDATA_OTHER_ERROR, result_code);
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/file%3A2_file_resource_id"
             "?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
             " <docs:authorizedApp>unauthorized_app_id</docs:authorizedApp>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, AuthorizeAppOperation_InvalidFeed) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL result_data;
 
   // Authorize an app with APP_ID to access to a document but an invalid feed.
   AuthorizeAppOperation* operation = new AuthorizeAppOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       *url_generator_,
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&result_code, &result_data)),
       "invalid_resource_id",
       "APP_ID");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(GDATA_PARSE_ERROR, result_code);
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/invalid_resource_id"
             "?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
             " <docs:authorizedApp>APP_ID</docs:authorizedApp>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, AddResourceToDirectoryOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
 
   // Add a file to the root directory.
   AddResourceToDirectoryOperation* operation =
       new AddResourceToDirectoryOperation(
-          &operation_registry_,
+          operation_runner_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code)),
           "folder:root",
           "file:2_file_resource_id");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/folder%3Aroot/contents?v=3&alt=json"
             "&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\">\n"
             " <id>http://127.0.0.1:8040/feeds/default/private/full/"
             "file%3A2_file_resource_id</id>\n"
             "</entry>\n",
             http_request_.content);
 }
 
 TEST_F(GDataWapiOperationsTest, RemoveResourceFromDirectoryOperation) {
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
 
   // Remove a file from the root directory.
   RemoveResourceFromDirectoryOperation* operation =
       new RemoveResourceFromDirectoryOperation(
-          &operation_registry_,
+          operation_runner_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code)),
           "folder:root",
           "file:2_file_resource_id");
 
-  operation->Start(kTestGDataAuthToken, kTestUserAgent,
-                   base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   // DELETE method should be used, without the body content.
   EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
   EXPECT_EQ("/feeds/default/private/full/folder%3Aroot/contents/"
             "file%3A2_file_resource_id?v=3&alt=json&showroot=true",
             http_request_.relative_url);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
   EXPECT_FALSE(http_request_.has_content);
 }
 
 // This test exercises InitiateUploadNewFileOperation and
 // ResumeUploadOperation for a scenario of uploading a new file.
 TEST_F(GDataWapiOperationsTest, UploadNewFile) {
   const std::string kUploadContent = "hello";
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kUploadContent));
 
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading a new file.
   InitiateUploadNewFileOperation* initiate_operation =
       new InitiateUploadNewFileOperation(
-          &operation_registry_,
+          operation_runner_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
           base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "folder:id",
           "New file");
 
-  initiate_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(initiate_operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ(
       "/feeds/upload/create-session/default/private/full/folder%3Aid/contents"
       "?convert=false&v=3&alt=json&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
             " <title>New file</title>\n"
             "</entry>\n",
             http_request_.content);
 
   // 2) Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&response, &new_entry)),
       ProgressCallback(),
       base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
       upload_url,
       0,  // start_position
       kUploadContent.size(),  // end_position (exclusive)
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       kTestFilePath);
 
-  resume_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(resume_operation);
   MessageLoop::current()->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(kUploadContent.size() -1) + "/" +
             base::Int64ToString(kUploadContent.size()),
@@ skipping 26 matching lines @@
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kUploadContent));
 
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading a new file.
   InitiateUploadNewFileOperation* initiate_operation =
       new InitiateUploadNewFileOperation(
-          &operation_registry_,
+          operation_runner_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
           base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "folder:id",
           "New file");
 
-  initiate_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(initiate_operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ(
       "/feeds/upload/create-session/default/private/full/folder%3Aid/contents"
       "?convert=false&v=3&alt=json&showroot=true",
       http_request_.relative_url);
@@ skipping 14 matching lines @@
   // 2) Before sending any data, check the current status.
   // This is an edge case test for GetUploadStatusOperation
   // (UploadRangeOperationBase).
   {
     UploadRangeResponse response;
     scoped_ptr<ResourceEntry> new_entry;
 
     // Check the response by GetUploadStatusOperation.
     GetUploadStatusOperation* get_upload_status_operation =
         new GetUploadStatusOperation(
-            &operation_registry_,
+            operation_runner_.get(),
             request_context_getter_.get(),
             CreateComposedCallback(
                 base::Bind(&test_util::RunAndQuit),
                 test_util::CreateCopyResultCallback(&response, &new_entry)),
             base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
             upload_url,
             kUploadContent.size());
-    get_upload_status_operation->Start(
-        kTestGDataAuthToken, kTestUserAgent,
-        base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+    operation_runner_->StartOperationWithRetry(get_upload_status_operation);
     MessageLoop::current()->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(kUploadContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
@@ skipping 17 matching lines @@
     const std::string payload = kUploadContent.substr(
         start_position, std::min(kMaxNumBytes, remaining_size));
     num_bytes_consumed += payload.size();
     // The end position is exclusive.
     const size_t end_position = start_position + payload.size();
 
     UploadRangeResponse response;
     scoped_ptr<ResourceEntry> new_entry;
 
     ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
-        &operation_registry_,
+        operation_runner_.get(),
         request_context_getter_.get(),
         CreateComposedCallback(
             base::Bind(&test_util::RunAndQuit),
             test_util::CreateCopyResultCallback(&response, &new_entry)),
         ProgressCallback(),
         base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
         upload_url,
         start_position,
         end_position,
         kUploadContent.size(),  // content_length,
         "text/plain",  // content_type
         kTestFilePath);
 
-    resume_operation->Start(
-        kTestGDataAuthToken, kTestUserAgent,
-        base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+    operation_runner_->StartOperationWithRetry(resume_operation);
     MessageLoop::current()->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) + "/" +
@@ skipping 16 matching lines @@
 
     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);
 
 #if !defined(NO_GET_UPLOAD_STATUS_TEST)
     // Check the response by GetUploadStatusOperation.
     GetUploadStatusOperation* get_upload_status_operation =
         new GetUploadStatusOperation(
-            &operation_registry_,
+            operation_runner_.get(),
             request_context_getter_.get(),
             CreateComposedCallback(
                 base::Bind(&test_util::RunAndQuit),
                 test_util::CreateCopyResultCallback(&response, &new_entry)),
             base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
             upload_url,
             kUploadContent.size());
-    get_upload_status_operation->Start(
-        kTestGDataAuthToken, kTestUserAgent,
-        base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+    operation_runner_->StartOperationWithRetry(get_upload_operation);
     MessageLoop::current()->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(kUploadContent.size()),
               http_request_.headers["Content-Range"]);
     EXPECT_TRUE(http_request_.has_content);
@@ skipping 20 matching lines @@
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("empty_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kUploadContent));
 
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading a new file.
   InitiateUploadNewFileOperation* initiate_operation =
       new InitiateUploadNewFileOperation(
-          &operation_registry_,
+          operation_runner_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
           base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "folder:id",
           "New file");
 
-  initiate_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(initiate_operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_new_file"), upload_url);
   EXPECT_EQ(net::test_server::METHOD_POST, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ(
       "/feeds/upload/create-session/default/private/full/folder%3Aid/contents"
       "?convert=false&v=3&alt=json&showroot=true",
       http_request_.relative_url);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ("application/atom+xml", http_request_.headers["Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
 
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("<?xml version=\"1.0\"?>\n"
             "<entry xmlns=\"http://www.w3.org/2005/Atom\" "
             "xmlns:docs=\"http://schemas.google.com/docs/2007\">\n"
             " <title>New file</title>\n"
             "</entry>\n",
             http_request_.content);
 
   // 2) Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&response, &new_entry)),
       ProgressCallback(),
       base::FilePath::FromUTF8Unsafe("drive/newfile.txt"),
       upload_url,
       0,  // start_position
       kUploadContent.size(),  // end_position (exclusive)
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       kTestFilePath);
 
-  resume_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(resume_operation);
   MessageLoop::current()->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 exit if the content is empty.
   // We should not generate the header with an invalid value "bytes 0--1/0".
   EXPECT_EQ(0U, http_request_.headers.count("Content-Range"));
   // The upload content should be set in the HTTP request.
@@ skipping 14 matching lines @@
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kUploadContent));
 
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading an existing file.
   InitiateUploadExistingFileOperation* initiate_operation =
       new InitiateUploadExistingFileOperation(
-          &operation_registry_,
+          operation_runner_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
           base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "file:foo",
           std::string() /* etag */);
 
-  initiate_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(initiate_operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_existing_file"), upload_url);
   // For updating an existing file, METHOD_PUT should be used.
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file%3Afoo"
             "?convert=false&v=3&alt=json&showroot=true",
             http_request_.relative_url);
   // Even though the body is empty, the content type should be set to
   // "text/plain".
   EXPECT_EQ("text/plain", http_request_.headers["Content-Type"]);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   // For updating an existing file, an empty body should be attached (PUT
   // requires a body)
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("", http_request_.content);
   EXPECT_EQ("*", http_request_.headers["If-Match"]);
 
   // 2) Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&response, &new_entry)),
       ProgressCallback(),
       base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
       upload_url,
       0,  // start_position
       kUploadContent.size(),  // end_position (exclusive)
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       kTestFilePath);
 
-  resume_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(resume_operation);
   MessageLoop::current()->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(kUploadContent.size() -1) + "/" +
             base::Int64ToString(kUploadContent.size()),
@@ skipping 16 matching lines @@
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kUploadContent));
 
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   // 1) Get the upload URL for uploading an existing file.
   InitiateUploadExistingFileOperation* initiate_operation =
       new InitiateUploadExistingFileOperation(
-          &operation_registry_,
+          operation_runner_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
           base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "file:foo",
           kTestETag);
 
-  initiate_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(initiate_operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(test_server_.GetURL("/upload_existing_file"), upload_url);
   // For updating an existing file, METHOD_PUT should be used.
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file%3Afoo"
             "?convert=false&v=3&alt=json&showroot=true",
             http_request_.relative_url);
   // Even though the body is empty, the content type should be set to
   // "text/plain".
   EXPECT_EQ("text/plain", http_request_.headers["Content-Type"]);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   // For updating an existing file, an empty body should be attached (PUT
   // requires a body)
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("", http_request_.content);
   EXPECT_EQ(kTestETag, http_request_.headers["If-Match"]);
 
   // 2) Upload the content to the upload URL.
   UploadRangeResponse response;
   scoped_ptr<ResourceEntry> new_entry;
 
   ResumeUploadOperation* resume_operation = new ResumeUploadOperation(
-      &operation_registry_,
+      operation_runner_.get(),
       request_context_getter_.get(),
       CreateComposedCallback(
           base::Bind(&test_util::RunAndQuit),
           test_util::CreateCopyResultCallback(&response, &new_entry)),
       ProgressCallback(),
       base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
       upload_url,
       0,  // start_position
       kUploadContent.size(),  // end_position (exclusive)
       kUploadContent.size(),  // content_length,
       "text/plain",  // content_type
       kTestFilePath);
 
-  resume_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(resume_operation);
   MessageLoop::current()->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(kUploadContent.size() -1) + "/" +
             base::Int64ToString(kUploadContent.size()),
@@ skipping 12 matching lines @@
 // This test exercises InitiateUploadExistingFileOperation for a scenario of
 // confliction on updating an existing file.
 TEST_F(GDataWapiOperationsTest, UploadExistingFileWithETagConflict) {
   const std::string kUploadContent = "hello";
   const std::string kWrongETag = "wrong_etag";
   GDataErrorCode result_code = GDATA_OTHER_ERROR;
   GURL upload_url;
 
   InitiateUploadExistingFileOperation* initiate_operation =
       new InitiateUploadExistingFileOperation(
-          &operation_registry_,
+          operation_runner_.get(),
           request_context_getter_.get(),
           *url_generator_,
           CreateComposedCallback(
               base::Bind(&test_util::RunAndQuit),
               test_util::CreateCopyResultCallback(&result_code, &upload_url)),
           base::FilePath::FromUTF8Unsafe("drive/existingfile.txt"),
           "text/plain",
           kUploadContent.size(),
           "file:foo",
           kWrongETag);
 
-  initiate_operation->Start(
-      kTestGDataAuthToken, kTestUserAgent,
-      base::Bind(&test_util::DoNothingForReAuthenticateCallback));
+  operation_runner_->StartOperationWithRetry(initiate_operation);
   MessageLoop::current()->Run();
 
   EXPECT_EQ(HTTP_PRECONDITION, result_code);
   // For updating an existing file, METHOD_PUT should be used.
   EXPECT_EQ(net::test_server::METHOD_PUT, http_request_.method);
   // convert=false should be passed as files should be uploaded as-is.
   EXPECT_EQ("/feeds/upload/create-session/default/private/full/file%3Afoo"
             "?convert=false&v=3&alt=json&showroot=true",
             http_request_.relative_url);
   // Even though the body is empty, the content type should be set to
   // "text/plain".
   EXPECT_EQ("text/plain", http_request_.headers["Content-Type"]);
   EXPECT_EQ("text/plain", http_request_.headers["X-Upload-Content-Type"]);
   EXPECT_EQ(base::Int64ToString(kUploadContent.size()),
             http_request_.headers["X-Upload-Content-Length"]);
   // For updating an existing file, an empty body should be attached (PUT
   // requires a body)
   EXPECT_TRUE(http_request_.has_content);
   EXPECT_EQ("", http_request_.content);
   EXPECT_EQ(kWrongETag, http_request_.headers["If-Match"]);
 }
 
 }  // namespace google_apis