Retry uploading in UploadJobImpl when error occurs

chrome/browser/chromeos/policy/upload_job_impl.h

 // Copyright 2015 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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_POLICY_UPLOAD_JOB_IMPL_H_
 #define CHROME_BROWSER_CHROMEOS_POLICY_UPLOAD_JOB_IMPL_H_
 
 #include <map>
 #include <memory>
 #include <string>
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
+#include "base/threading/thread_checker.h"
 #include "chrome/browser/chromeos/policy/upload_job.h"
 #include "google_apis/gaia/oauth2_token_service.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 #include "url/gurl.h"
 
 namespace policy {
 
 // This implementation of UploadJob uses the OAuth2TokenService to acquire
@@ skipping 17 matching lines @@
 
   // An implemenation of the MimeBoundaryGenerator which uses random
   // alpha-numeric characters to construct MIME boundaries.
   class RandomMimeBoundaryGenerator : public MimeBoundaryGenerator {
    public:
     ~RandomMimeBoundaryGenerator() override;
 
     std::string GenerateBoundary() const override;  // MimeBoundaryGenerator
   };
 
+  // |task_runner| must belong to the same thread from which the constructor and
+  // all the public methods are called.
   UploadJobImpl(const GURL& upload_url,
                 const std::string& account_id,
                 OAuth2TokenService* token_service,
                 scoped_refptr<net::URLRequestContextGetter> url_context_getter,
                 Delegate* delegate,
-                std::unique_ptr<MimeBoundaryGenerator> boundary_generator);
+                std::unique_ptr<MimeBoundaryGenerator> boundary_generator,
+                const scoped_refptr<base::SequencedTaskRunner> task_runner);
   ~UploadJobImpl() override;
 
   // UploadJob:
   void AddDataSegment(const std::string& name,
                       const std::string& filename,
                       const std::map<std::string, std::string>& header_entries,
                       std::unique_ptr<std::string> data) override;
   void Start() override;
 
+  // Sets the retry delay to a shorter time to prevent browser tests from
+  // timing out.
+  static void SetRetryDelayForTesting(long retryDelayMs);
+
  private:
   // Indicates the current state of the UploadJobImpl.
+  // State transitions for successful upload:
+  //   IDLE -> ACQUIRING_TOKEN -> PREPARING_CONTENT -> UPLOADING -> SUCCESS
+  // If error happens, state goes back to ACQUIRING_TOKEN.
+  // State transitions when error occurs once:
+  //   IDLE -> ACQUIRING_TOKEN -> PREPARING_CONTENT -> UPLOADING ->
+  //     -> ACQUIRING_TOKEN -> PREPARING_CONTENT -> UPLOADING -> SUCCESS
+  // State transitions when tried unsuccessfully kMaxRetries times:
+  //   ... -> PREPARING_CONTENT -> UPLOADING -> ERROR
   enum State {
     IDLE,               // Start() has not been called.
     ACQUIRING_TOKEN,    // Trying to acquire the access token.
     PREPARING_CONTENT,  // Currently encoding the content.
     UPLOADING,          // Upload started.
     SUCCESS,            // Upload successfully completed.
     ERROR               // Upload failed.
   };
 
   // OAuth2TokenService::Consumer:
   void OnGetTokenSuccess(const OAuth2TokenService::Request* request,
                          const std::string& access_token,
                          const base::Time& expiration_time) override;
   void OnGetTokenFailure(const OAuth2TokenService::Request* request,
                          const GoogleServiceAuthError& error) override;
 
   // net::URLFetcherDelegate:
   void OnURLFetchComplete(const net::URLFetcher* source) override;
 
+  void HandleError(ErrorCode errorCode);
+
   // Requests an access token for the upload scope.
   void RequestAccessToken();
 
   // Dispatches POST request to URLFetcher.
-  void StartUpload(const std::string& access_token);
+  void StartUpload();
 
   // Constructs the body of the POST request by concatenating the
   // |data_segments_|, separated by appropriate content-disposition headers and
   // a MIME boundary. Places the request body in |post_data_| and a copy of the
   // MIME boundary in |mime_boundary_|. Returns true on success. If |post_data_|
   // and |mime_boundary_| were set already, returns true immediately. In case of
   // an error, clears |post_data_| and |mime_boundary_| and returns false.
   bool SetUpMultipart();
 
   // Assembles the request and starts the URLFetcher. Fails if another upload
@@ skipping 37 matching lines @@
 
   // The OAuth access token.
   std::string access_token_;
 
   // Helper to upload the data.
   std::unique_ptr<net::URLFetcher> upload_fetcher_;
 
   // The data chunks to be uploaded.
   ScopedVector<DataSegment> data_segments_;
 
+  // TaskRunner used for scheduling retry attempts.
+  const scoped_refptr<base::SequencedTaskRunner> task_runner_;
+
+  base::ThreadChecker thread_checker_;
+
+  // Should remain the last member so it will be destroyed first and
+  // invalidate all weak pointers.
+  base::WeakPtrFactory<UploadJobImpl> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(UploadJobImpl);
 };
 
 }  // namespace policy
 
 #endif  // CHROME_BROWSER_CHROMEOS_POLICY_UPLOAD_JOB_IMPL_H_