Implement a DRIVE_REQUEST_TOO_LARGE backoff.

google_apis/drive/request_sender_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "google_apis/drive/request_sender.h"
 
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "google_apis/drive/base_requests.h"
 #include "google_apis/drive/dummy_auth_service.h"
@@ skipping 121 matching lines @@
 }  // namespace
 
 TEST_F(RequestSenderTest, StartAndFinishRequest) {
   bool start_called  = false;
   FinishReason finish_reason = NONE;
   TestRequest* request = new TestRequest(&request_sender_,
                                          &start_called,
                                          &finish_reason);
   base::WeakPtr<AuthenticatedRequestInterface> weak_ptr = request->GetWeakPtr();
 
-  base::Closure cancel_closure = request_sender_.StartRequestWithRetry(request);
+  base::Closure cancel_closure =
+      request_sender_.StartRequestWithAuthRetry(request);
   EXPECT_TRUE(!cancel_closure.is_null());
 
   // Start is called with the specified access token. Let it succeed.
   EXPECT_TRUE(start_called);
   EXPECT_EQ(kTestAccessToken, request->passed_access_token());
   request->FinishRequestWithSuccess();
   EXPECT_FALSE(weak_ptr);  // The request object is deleted.
 
   // It is safe to run the cancel closure even after the request is finished.
   // It is just no-op. The TestRequest::Cancel method is not called.
   cancel_closure.Run();
   EXPECT_EQ(SUCCESS, finish_reason);
 }
 
 TEST_F(RequestSenderTest, StartAndCancelRequest) {
   bool start_called  = false;
   FinishReason finish_reason = NONE;
   TestRequest* request = new TestRequest(&request_sender_,
                                          &start_called,
                                          &finish_reason);
   base::WeakPtr<AuthenticatedRequestInterface> weak_ptr = request->GetWeakPtr();
 
-  base::Closure cancel_closure = request_sender_.StartRequestWithRetry(request);
+  base::Closure cancel_closure =
+      request_sender_.StartRequestWithAuthRetry(request);
   EXPECT_TRUE(!cancel_closure.is_null());
   EXPECT_TRUE(start_called);
 
   cancel_closure.Run();
   EXPECT_EQ(CANCEL, finish_reason);
   EXPECT_FALSE(weak_ptr);  // The request object is deleted.
 }
 
 TEST_F(RequestSenderTest, NoRefreshToken) {
   auth_service_->ClearRefreshToken();
   auth_service_->ClearAccessToken();
 
   bool start_called  = false;
   FinishReason finish_reason = NONE;
   TestRequest* request = new TestRequest(&request_sender_,
                                          &start_called,
                                          &finish_reason);
   base::WeakPtr<AuthenticatedRequestInterface> weak_ptr = request->GetWeakPtr();
 
-  base::Closure cancel_closure = request_sender_.StartRequestWithRetry(request);
+  base::Closure cancel_closure =
+      request_sender_.StartRequestWithAuthRetry(request);
   EXPECT_TRUE(!cancel_closure.is_null());
 
   // The request is not started at all because no access token is obtained.
   EXPECT_FALSE(start_called);
   EXPECT_EQ(AUTH_FAILURE, finish_reason);
   EXPECT_FALSE(weak_ptr);  // The request object is deleted.
 }
 
 TEST_F(RequestSenderTest, ValidRefreshTokenAndNoAccessToken) {
   auth_service_->ClearAccessToken();
 
   bool start_called  = false;
   FinishReason finish_reason = NONE;
   TestRequest* request = new TestRequest(&request_sender_,
                                          &start_called,
                                          &finish_reason);
   base::WeakPtr<AuthenticatedRequestInterface> weak_ptr = request->GetWeakPtr();
 
-  base::Closure cancel_closure = request_sender_.StartRequestWithRetry(request);
+  base::Closure cancel_closure =
+      request_sender_.StartRequestWithAuthRetry(request);
   EXPECT_TRUE(!cancel_closure.is_null());
 
   // Access token should indicate that this is the first retry.
   EXPECT_TRUE(start_called);
   EXPECT_EQ(kTestAccessToken + std::string("1"),
             request->passed_access_token());
   request->FinishRequestWithSuccess();
   EXPECT_EQ(SUCCESS, finish_reason);
   EXPECT_FALSE(weak_ptr);  // The request object is deleted.
 }
 
 TEST_F(RequestSenderTest, AccessTokenRejectedSeveralTimes) {
   bool start_called  = false;
   FinishReason finish_reason = NONE;
   TestRequest* request = new TestRequest(&request_sender_,
                                          &start_called,
                                          &finish_reason);
   base::WeakPtr<AuthenticatedRequestInterface> weak_ptr = request->GetWeakPtr();
 
-  base::Closure cancel_closure = request_sender_.StartRequestWithRetry(request);
+  base::Closure cancel_closure =
+      request_sender_.StartRequestWithAuthRetry(request);
   EXPECT_TRUE(!cancel_closure.is_null());
 
   EXPECT_TRUE(start_called);
   EXPECT_EQ(kTestAccessToken, request->passed_access_token());
   // Emulate the case that the access token was rejected by the remote service.
   request->passed_reauth_callback().Run(request);
   // New access token is fetched. Let it fail once again.
   EXPECT_EQ(kTestAccessToken + std::string("1"),
             request->passed_access_token());
   request->passed_reauth_callback().Run(request);
   // Once more.
   EXPECT_EQ(kTestAccessToken + std::string("2"),
             request->passed_access_token());
   request->passed_reauth_callback().Run(request);
 
   // Currently, limit for the retry is controlled in each request object, not
   // by the RequestSender. So with this TestRequest, RequestSender retries
   // infinitely. Let it succeed/
   EXPECT_EQ(kTestAccessToken + std::string("3"),
             request->passed_access_token());
   request->FinishRequestWithSuccess();
   EXPECT_EQ(SUCCESS, finish_reason);
   EXPECT_FALSE(weak_ptr);
 }
 
 }  // namespace google_apis