Implement a DRIVE_REQUEST_TOO_LARGE backoff.

google_apis/drive/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/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/json/json_reader.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 497 matching lines @@
   {
     base::RunLoop run_loop;
     drive::AboutGetRequest* request = new drive::AboutGetRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &about_resource)));
     request->set_fields("kind,quotaBytesTotal,quotaBytesUsedAggregate,"
                         "largestChangeId,rootFolderId");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/about?"
             "fields=kind%2CquotaBytesTotal%2CquotaBytesUsedAggregate%2C"
             "largestChangeId%2CrootFolderId",
             http_request_.relative_url);
 
@@ skipping 29 matching lines @@
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
     request->set_last_viewed_by_me_date(
         base::Time::FromUTCExploded(kLastViewedByMeDate));
     request->set_mime_type("application/vnd.google-apps.folder");
     request->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
     request->add_parent("root");
     request->set_title("new directory");
     request->set_properties(testing_properties_);
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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);
   EXPECT_EQ(
@@ skipping 44 matching lines @@
     request->set_set_modified_date(true);
     request->set_update_viewed_date(false);
 
     request->set_title("new title");
     request->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
     request->set_last_viewed_by_me_date(
         base::Time::FromUTCExploded(kLastViewedByMeDate));
     request->add_parent("parent_resource_id");
 
     request->set_properties(testing_properties_);
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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"]);
@@ skipping 19 matching lines @@
   scoped_ptr<AboutResource> about_resource;
 
   {
     base::RunLoop run_loop;
     drive::AboutGetRequest* request = new drive::AboutGetRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &about_resource)));
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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("drive/about.json")));
@@ skipping 14 matching lines @@
   scoped_ptr<AboutResource> about_resource;
 
   {
     base::RunLoop run_loop;
     drive::AboutGetRequest* request = new drive::AboutGetRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &about_resource)));
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   // "parse error" should be returned, and the about resource should be NULL.
   EXPECT_EQ(DRIVE_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);
 }
 
 TEST_F(DriveApiRequestsTest, AppsListRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/applist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<AppList> app_list;
 
   {
     base::RunLoop run_loop;
     drive::AppsListRequest* request = new drive::AppsListRequest(
         request_sender_.get(),
         *url_generator_,
         false,  // use_internal_endpoint
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &app_list)));
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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(app_list);
 }
 
 TEST_F(DriveApiRequestsTest, ChangesListRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/changelist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<ChangeList> result;
 
   {
     base::RunLoop run_loop;
     drive::ChangesListRequest* request = new drive::ChangesListRequest(
         request_sender_.get(), *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &result)));
     request->set_include_deleted(true);
     request->set_start_change_id(100);
     request->set_max_results(500);
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/drive/v2/changes?maxResults=500&startChangeId=100",
             http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, ChangesListNextPageRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/changelist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<ChangeList> result;
 
   {
     base::RunLoop run_loop;
     drive::ChangesListNextPageRequest* request =
         new drive::ChangesListNextPageRequest(
             request_sender_.get(),
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error, &result)));
     request->set_next_link(test_server_.GetURL("/continue/get/change/list"));
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_SUCCESS, error);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ("/continue/get/change/list", http_request_.relative_url);
   EXPECT_TRUE(result);
 }
 
 TEST_F(DriveApiRequestsTest, FilesCopyRequest) {
@@ skipping 13 matching lines @@
     drive::FilesCopyRequest* request = new drive::FilesCopyRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
     request->set_file_id("resource_id");
     request->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
     request->add_parent("parent_resource_id");
     request->set_title("new title");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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(
@@ skipping 16 matching lines @@
   {
     base::RunLoop run_loop;
     drive::FilesCopyRequest* request = new drive::FilesCopyRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
     request->set_file_id("resource_id");
     request->set_title("new title");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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 title\"}", http_request_.content);
@@ skipping 10 matching lines @@
 
   {
     base::RunLoop run_loop;
     drive::FilesListRequest* request = new drive::FilesListRequest(
         request_sender_.get(), *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &result)));
     request->set_max_results(50);
     request->set_q("\"abcde\" in parents");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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, FilesListNextPageRequest) {
   // Set an expected data file containing valid result.
   expected_data_file_path_ = test_util::GetTestFilePath(
       "drive/filelist.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileList> result;
 
   {
     base::RunLoop run_loop;
     drive::FilesListNextPageRequest* request =
         new drive::FilesListNextPageRequest(
             request_sender_.get(),
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error, &result)));
     request->set_next_link(test_server_.GetURL("/continue/get/file/list"));
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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, FilesDeleteRequest) {
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
 
   // Delete a resource with the given resource id.
   {
     base::RunLoop run_loop;
     drive::FilesDeleteRequest* request = new drive::FilesDeleteRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop, test_util::CreateCopyResultCallback(&error)));
     request->set_file_id("resource_id");
     request->set_etag(kTestETag);
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   EXPECT_EQ(HTTP_NO_CONTENT, error);
   EXPECT_EQ(net::test_server::METHOD_DELETE, http_request_.method);
   EXPECT_EQ(kTestETag, http_request_.headers["If-Match"]);
   EXPECT_EQ("/drive/v2/files/resource_id", http_request_.relative_url);
   EXPECT_FALSE(http_request_.has_content);
 }
 
 TEST_F(DriveApiRequestsTest, FilesTrashRequest) {
   // 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("drive/directory_entry.json");
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
   scoped_ptr<FileResource> file_resource;
 
   // Trash a resource with the given resource id.
   {
     base::RunLoop run_loop;
     drive::FilesTrashRequest* request = new drive::FilesTrashRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error, &file_resource)));
     request->set_file_id("resource_id");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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, ChildrenInsertRequest) {
   // Set an expected data file containing the children entry.
   expected_content_type_ = "application/json";
   expected_content_ = kTestChildrenResponse;
 
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
 
   // Add a resource with "resource_id" to a directory with
   // "parent_resource_id".
   {
     base::RunLoop run_loop;
     drive::ChildrenInsertRequest* request = new drive::ChildrenInsertRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error)));
     request->set_folder_id("parent_resource_id");
     request->set_id("resource_id");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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, ChildrenDeleteRequest) {
   DriveApiErrorCode error = DRIVE_OTHER_ERROR;
 
   // Remove a resource with "resource_id" from a directory with
   // "parent_resource_id".
   {
     base::RunLoop run_loop;
     drive::ChildrenDeleteRequest* request = new drive::ChildrenDeleteRequest(
         request_sender_.get(),
         *url_generator_,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&error)));
     request->set_child_id("resource_id");
     request->set_folder_id("parent_resource_id");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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);
 }
 
@@ skipping 19 matching lines @@
             request_sender_.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->set_properties(testing_properties_);
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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);
@@ skipping 24 matching lines @@
             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);
+    request_sender_->StartRequestWithAuthRetry(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) + "/" +
@@ skipping 30 matching lines @@
         new drive::InitiateUploadNewFileRequest(
             request_sender_.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);
+    request_sender_->StartRequestWithAuthRetry(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",
@@ skipping 19 matching lines @@
             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);
+    request_sender_->StartRequestWithAuthRetry(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.
@@ skipping 28 matching lines @@
         new drive::InitiateUploadNewFileRequest(
             request_sender_.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);
+    request_sender_->StartRequestWithAuthRetry(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);
@@ skipping 18 matching lines @@
     {
       base::RunLoop run_loop;
       drive::GetUploadStatusRequest* get_upload_status_request =
           new drive::GetUploadStatusRequest(
               request_sender_.get(),
               upload_url,
               kTestContent.size(),
               test_util::CreateQuitCallback(
                   &run_loop,
                   test_util::CreateCopyResultCallback(&response, &new_entry)));
-      request_sender_->StartRequestWithRetry(get_upload_status_request);
+      request_sender_->StartRequestWithAuthRetry(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"]);
@@ skipping 25 matching lines @@
               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);
+      request_sender_->StartRequestWithAuthRetry(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) + "-" +
@@ skipping 23 matching lines @@
     {
       base::RunLoop run_loop;
       drive::GetUploadStatusRequest* get_upload_status_request =
           new drive::GetUploadStatusRequest(
               request_sender_.get(),
               upload_url,
               kTestContent.size(),
               test_util::CreateQuitCallback(
                   &run_loop,
                   test_util::CreateCopyResultCallback(&response, &new_entry)));
-      request_sender_->StartRequestWithRetry(get_upload_status_request);
+      request_sender_->StartRequestWithAuthRetry(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"]);
@@ skipping 32 matching lines @@
             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->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
     request->set_last_viewed_by_me_date(
         base::Time::FromUTCExploded(kLastViewedByMeDate));
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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);
@@ skipping 30 matching lines @@
             request_sender_.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->set_properties(testing_properties_);
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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"]);
 
@@ skipping 19 matching lines @@
             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);
+    request_sender_->StartRequestWithAuthRetry(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) + "/" +
@@ skipping 30 matching lines @@
         new drive::InitiateUploadExistingFileRequest(
             request_sender_.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);
+    request_sender_->StartRequestWithAuthRetry(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"]);
 
@@ skipping 15 matching lines @@
             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);
+    request_sender_->StartRequestWithAuthRetry(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) + "/" +
@@ skipping 32 matching lines @@
         new drive::InitiateUploadExistingFileRequest(
             request_sender_.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);
+    request_sender_->StartRequestWithAuthRetry(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);
@@ skipping 24 matching lines @@
         new drive::InitiateUploadExistingFileRequest(
             request_sender_.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);
+    request_sender_->StartRequestWithAuthRetry(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"]);
 
@@ skipping 20 matching lines @@
             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);
+    request_sender_->StartRequestWithAuthRetry(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) + "/" +
@@ skipping 40 matching lines @@
             kTestETag,
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error, &upload_url)));
     request->set_parent_resource_id("new_parent_resource_id");
     request->set_title("new file title");
     request->set_modified_date(base::Time::FromUTCExploded(kModifiedDate));
     request->set_last_viewed_by_me_date(
         base::Time::FromUTCExploded(kLastViewedByMeDate));
 
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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"]);
 
@@ skipping 23 matching lines @@
     drive::DownloadFileRequest* request = new drive::DownloadFileRequest(
         request_sender_.get(),
         *url_generator_,
         kTestId,
         kDownloadedFilePath,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&result_code, &temp_file)),
         GetContentCallback(),
         ProgressCallback());
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   std::string contents;
   base::ReadFileToString(temp_file, &contents);
   base::DeleteFile(temp_file, false);
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ(kTestDownloadPathPrefix + kTestId, http_request_.relative_url);
@@ skipping 16 matching lines @@
     drive::DownloadFileRequest* request = new drive::DownloadFileRequest(
         request_sender_.get(),
         *url_generator_,
         kTestId,
         kDownloadedFilePath,
         test_util::CreateQuitCallback(
             &run_loop,
             test_util::CreateCopyResultCallback(&result_code, &temp_file)),
         base::Bind(&AppendContent, &contents),
         ProgressCallback());
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(request);
     run_loop.Run();
   }
 
   base::DeleteFile(temp_file, false);
 
   EXPECT_EQ(HTTP_SUCCESS, result_code);
   EXPECT_EQ(net::test_server::METHOD_GET, http_request_.method);
   EXPECT_EQ(kTestDownloadPathPrefix + kTestId, http_request_.relative_url);
   EXPECT_EQ(kDownloadedFilePath, temp_file);
 
@@ skipping 14 matching lines @@
         new drive::PermissionsInsertRequest(
             request_sender_.get(),
             *url_generator_,
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error)));
     request->set_id("resource_id");
     request->set_role(drive::PERMISSION_ROLE_COMMENTER);
     request->set_type(drive::PERMISSION_TYPE_USER);
     request->set_value("user@example.com");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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/permissions",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   scoped_ptr<base::Value> expected(base::JSONReader::DeprecatedRead(
@@ skipping 14 matching lines @@
         new drive::PermissionsInsertRequest(
             request_sender_.get(),
             *url_generator_,
             test_util::CreateQuitCallback(
                 &run_loop,
                 test_util::CreateCopyResultCallback(&error)));
     request->set_id("resource_id2");
     request->set_role(drive::PERMISSION_ROLE_WRITER);
     request->set_type(drive::PERMISSION_TYPE_DOMAIN);
     request->set_value("example.com");
-    request_sender_->StartRequestWithRetry(request);
+    request_sender_->StartRequestWithAuthRetry(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_id2/permissions",
             http_request_.relative_url);
   EXPECT_EQ("application/json", http_request_.headers["Content-Type"]);
 
   expected.reset(base::JSONReader::DeprecatedRead(
@@ skipping 10 matching lines @@
   const char kTestContentType[] = "text/plain";
   const std::string kTestContent(10, 'a');
   const base::FilePath kTestFilePath =
       temp_dir_.path().AppendASCII("upload_file.txt");
   ASSERT_TRUE(test_util::WriteStringToFile(kTestFilePath, kTestContent));
 
   // Create batch request.
   drive::BatchUploadRequest* const request =
       new drive::BatchUploadRequest(request_sender_.get(), *url_generator_);
   request->SetBoundaryForTesting("OUTERBOUNDARY");
-  request_sender_->StartRequestWithRetry(request);
+  request_sender_->StartRequestWithAuthRetry(request);
 
   // Create child request.
   DriveApiErrorCode errors[] = {DRIVE_OTHER_ERROR, DRIVE_OTHER_ERROR};
   scoped_ptr<FileResource> file_resources[2];
   base::RunLoop run_loop[2];
   for (int i = 0; i < 2; ++i) {
     const FileResourceCallback callback = test_util::CreateQuitCallback(
         &run_loop[i],
         test_util::CreateCopyResultCallback(&errors[i], &file_resources[i]));
     drive::MultipartUploadNewFileDelegate* const child_request =
@@ skipping 67 matching lines @@
       request->GetWeakPtrAsBatchUploadRequest();
   request->Commit();
   ASSERT_FALSE(weak_ptr.get());
 }
 
 TEST_F(DriveApiRequestsTest, BatchUploadRequestWithBodyIncludingZero) {
   // Create batch request.
   drive::BatchUploadRequest* const request =
       new drive::BatchUploadRequest(request_sender_.get(), *url_generator_);
   request->SetBoundaryForTesting("OUTERBOUNDARY");
-  request_sender_->StartRequestWithRetry(request);
+  request_sender_->StartRequestWithAuthRetry(request);
 
   // Create child request.
   {
     base::RunLoop loop;
     TestBatchableDelegate* const child_request = new TestBatchableDelegate(
         GURL("http://example.com/test"), "application/binary",
         std::string("Apple\0Orange\0", 13), loop.QuitClosure());
     request->AddRequest(child_request);
     request->Commit();
     loop.Run();
@@ skipping 181 matching lines @@
                                     "Header: value\r\n"
                                     "\r\n"
                                     "BODY\r\n"
                                     "--BOUNDARY-- \t",
                                     &parts));
   ASSERT_EQ(1u, parts.size());
   EXPECT_EQ(HTTP_SUCCESS, parts[0].code);
   EXPECT_EQ("BODY", parts[0].body);
 }
 }  // namespace google_apis