Retry uploading in UploadJobImpl when error occurs

chrome/browser/chromeos/policy/system_log_uploader.cc

 // Copyright (c) 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.
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner_util.h"
+#include "base/thread_task_runner_handle.h"

[Andrew T Wilson (Slow), 2016/05/10 22:00:42]

Is this include necessary still?

[Marton Hunyady, 2016/05/11 12:55:30]

Done.

 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/policy/upload_job_impl.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service.h"
 #include "chrome/browser/chromeos/settings/device_oauth2_token_service_factory.h"
 #include "chrome/common/chrome_switches.h"
 #include "components/feedback/anonymizer_tool.h"
 #include "components/policy/core/browser/browser_policy_connector.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/http/http_request_headers.h"
 #include "system_log_uploader.h"
@@ skipping 32 matching lines @@
         file_path,
         policy::SystemLogUploader::RemoveSensitiveData(&anonymizer, data)));
   }
   return system_logs;
 }
 
 // An implementation of the |SystemLogUploader::Delegate|, that is used to
 // create an upload job and load system logs from the disk.
 class SystemLogDelegate : public policy::SystemLogUploader::Delegate {
  public:
-  SystemLogDelegate();
+  explicit SystemLogDelegate(
+      scoped_refptr<base::SequencedTaskRunner> task_runner);
   ~SystemLogDelegate() override;
 
   // SystemLogUploader::Delegate:
   void LoadSystemLogs(const LogUploadCallback& upload_callback) override;
 
   std::unique_ptr<policy::UploadJob> CreateUploadJob(
       const GURL& upload_url,
       policy::UploadJob::Delegate* delegate) override;
 
  private:
+  // TaskRunner used for scheduling upload the upload task.
+  const scoped_refptr<base::SequencedTaskRunner> task_runner_;
+
   DISALLOW_COPY_AND_ASSIGN(SystemLogDelegate);
 };
 
-SystemLogDelegate::SystemLogDelegate() {}
+SystemLogDelegate::SystemLogDelegate(
+    scoped_refptr<base::SequencedTaskRunner> task_runner)
+    : task_runner_(task_runner) {}
 
 SystemLogDelegate::~SystemLogDelegate() {}
 
 void SystemLogDelegate::LoadSystemLogs(
     const LogUploadCallback& upload_callback) {
   // Run ReadFiles() in the thread that interacts with the file system and
   // return system logs to |upload_callback| on the current thread.
   base::PostTaskAndReplyWithResult(content::BrowserThread::GetBlockingPool(),
                                    FROM_HERE, base::Bind(&ReadFiles),
                                    upload_callback);
 }
 
 std::unique_ptr<policy::UploadJob> SystemLogDelegate::CreateUploadJob(
     const GURL& upload_url,
     policy::UploadJob::Delegate* delegate) {
   chromeos::DeviceOAuth2TokenService* device_oauth2_token_service =
       chromeos::DeviceOAuth2TokenServiceFactory::Get();
 
   scoped_refptr<net::URLRequestContextGetter> system_request_context =
       g_browser_process->system_request_context();
   std::string robot_account_id =
       device_oauth2_token_service->GetRobotAccountId();
   return std::unique_ptr<policy::UploadJob>(new policy::UploadJobImpl(
       upload_url, robot_account_id, device_oauth2_token_service,
       system_request_context, delegate,
-      base::WrapUnique(
-          new policy::UploadJobImpl::RandomMimeBoundaryGenerator)));
+      base::WrapUnique(new policy::UploadJobImpl::RandomMimeBoundaryGenerator),
+      task_runner_));
 }
 
 // Returns the system log upload frequency.
 base::TimeDelta GetUploadFrequency() {
   base::TimeDelta upload_frequency(base::TimeDelta::FromMilliseconds(
       policy::SystemLogUploader::kDefaultUploadDelayMs));
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kSystemLogUploadFrequency)) {
     std::string string_value =
         base::CommandLine::ForCurrentProcess()->GetSwitchValueASCII(
@@ skipping 39 matching lines @@
 SystemLogUploader::SystemLogUploader(
     std::unique_ptr<Delegate> syslog_delegate,
     const scoped_refptr<base::SequencedTaskRunner>& task_runner)
     : retry_count_(0),
       upload_frequency_(GetUploadFrequency()),
       task_runner_(task_runner),
       syslog_delegate_(std::move(syslog_delegate)),
       upload_enabled_(false),
       weak_factory_(this) {
   if (!syslog_delegate_)
-    syslog_delegate_.reset(new SystemLogDelegate());
+    syslog_delegate_.reset(new SystemLogDelegate(task_runner));
   DCHECK(syslog_delegate_);
 
   // Watch for policy changes.
   upload_enabled_observer_ = chromeos::CrosSettings::Get()->AddSettingsObserver(
       chromeos::kSystemLogUploadEnabled,
       base::Bind(&SystemLogUploader::RefreshUploadSettings,
                  base::Unretained(this)));
 
   // Fetch the current value of the policy.
   RefreshUploadSettings();
@@ skipping 107 matching lines @@
       base::TimeDelta());
   // Ensure that we never have more than one pending delayed task.
   weak_factory_.InvalidateWeakPtrs();
   task_runner_->PostDelayedTask(FROM_HERE,
                                 base::Bind(&SystemLogUploader::StartLogUpload,
                                            weak_factory_.GetWeakPtr()),
                                 delay);
 }
 
 }  // namespace policy