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>
@@ skipping 36 matching lines @@
     ~RandomMimeBoundaryGenerator() override;
 
     std::string GenerateBoundary() const override;  // MimeBoundaryGenerator
   };
 
   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);

[Andrew T Wilson (Slow), 2016/05/02 09:15:49]

Do you make any assumptions about this task_runner (for example, is it OK for
tasks posted to that runner to be run from a different thread than the one the
constructor is called on)? It's important to document this and also to add some
DCHECKs to the code to make sure that assumption is maintained.

[Marton Hunyady, 2016/05/04 11:26:41]

Done.

   ~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;
 
  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_;
+
+  // 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_