Use task runner in version_updater_win.cc.

chrome/browser/google/google_update_win.cc

 // Copyright (c) 2012 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 "chrome/browser/google/google_update_win.h"
 
 #include <atlbase.h>
 #include <atlcom.h>
 #include <objbase.h>
 #include <stdint.h>
 #include <string.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
+#include "base/sequenced_task_runner.h"
 #include "base/sequenced_task_runner_helpers.h"
-#include "base/single_thread_task_runner.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/threading/thread_task_runner_handle.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_traits.h"
+#include "base/threading/sequenced_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/version.h"
 #include "base/win/scoped_bstr.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/install_static/install_util.h"
 #include "chrome/installer/util/google_update_settings.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/install_util.h"
 #include "ui/base/l10n/l10n_util.h"
@@ skipping 14 matching lines @@
   // The upgrade happened successfully.
   UPGRADE_SUCCESSFUL = 3,
   // No need to upgrade, Chrome is up to date.
   UPGRADE_ALREADY_UP_TO_DATE = 4,
   // An error occurred.
   UPGRADE_ERROR = 5,
   NUM_UPGRADE_STATUS
 };
 
 GoogleUpdate3ClassFactory* g_google_update_factory = nullptr;
+scoped_refptr<base::SequencedTaskRunner> g_update_driver_task_runner = nullptr;

[gab, 2017/07/19 15:15:24]

I think this needs to be a raw pointer to avoid a static initializer.

[calamity, 2017/07/20 03:56:20]

Done.

 
 // The time interval, in milliseconds, between polls to Google Update. This
 // value was chosen unscientificaly during an informal discussion.
 const int64_t kGoogleUpdatePollIntervalMs = 250;
 
 const int kGoogleAllowedRetries = 1;
 const int kGoogleRetryIntervalSeconds = 5;
 
 // Constants from Google Update.
 const HRESULT GOOPDATE_E_APP_UPDATE_DISABLED_BY_POLICY = 0x80040813;
@@ skipping 115 matching lines @@
   return class_factory->CreateInstance(
       nullptr, IID_PPV_ARGS(google_update->GetAddressOf()));
 }
 
 // UpdateCheckDriver -----------------------------------------------------------
 
 // A driver that is created and destroyed on the caller's thread and drives
 // Google Update on another.
 class UpdateCheckDriver {
  public:
-  // Runs an update check on |task_runner|, invoking methods of |delegate| on
-  // the caller's thread to report progress and final results.
+  // Runs an update check, invoking methods of |delegate| on the caller's thread
+  // to report progress and final results.
   static void RunUpdateCheck(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       const std::string& locale,
       bool install_update_if_possible,
       gfx::AcceleratedWidget elevation_window,
       const base::WeakPtr<UpdateCheckDelegate>& delegate);
 
  private:
   friend class base::DeleteHelper<UpdateCheckDriver>;
 
   UpdateCheckDriver(
-      scoped_refptr<base::SingleThreadTaskRunner> task_runner,
       const std::string& locale,
       bool install_update_if_possible,
       gfx::AcceleratedWidget elevation_window,
       const base::WeakPtr<UpdateCheckDelegate>& delegate);
 
   // Invokes a completion or error method on all delegates, as appropriate.
   ~UpdateCheckDriver();
 
   // If an UpdateCheckDriver is already running, the delegate is added to the
   // existing one instead of creating a new one.
@@ skipping 77 matching lines @@
   // update. If the process has reached a terminal state, this instance will be
   // deleted and the caller will be notified of the final status. Otherwise, the
   // caller will be notified of the intermediate state (iff it differs from a
   // previous notification) and another future poll will be scheduled.
   void PollGoogleUpdate();
 
   // The global driver instance. Accessed only on the caller's thread.
   static UpdateCheckDriver* driver_;
 
   // The task runner on which the update checks runs.
-  scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+  scoped_refptr<base::SequencedTaskRunner> task_runner_;
 
   // The caller's task runner, on which methods of the |delegates_| will be
   // invoked.
-  scoped_refptr<base::SingleThreadTaskRunner> result_runner_;
+  scoped_refptr<base::SequencedTaskRunner> result_runner_;
 
   // The UI locale.
   std::string locale_;
 
   // False to only check for an update; true to also install one if available.
   bool install_update_if_possible_;
 
   // A parent window in case any UX is required (e.g., an elevation prompt).
   gfx::AcceleratedWidget elevation_window_;
 
@@ skipping 28 matching lines @@
   HRESULT hresult_;
   int installer_exit_code_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckDriver);
 };
 
 UpdateCheckDriver* UpdateCheckDriver::driver_ = nullptr;
 
 // static
 void UpdateCheckDriver::RunUpdateCheck(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const std::string& locale,
     bool install_update_if_possible,
     gfx::AcceleratedWidget elevation_window,
     const base::WeakPtr<UpdateCheckDelegate>& delegate) {
   // Create the driver if it doesn't exist, or add the delegate to the existing
   // one.
   if (!driver_) {
     // The driver is owned by itself, and will self-destruct when its work is
     // done.
-    driver_ =
-        new UpdateCheckDriver(task_runner, locale, install_update_if_possible,
-                              elevation_window, delegate);
-    task_runner->PostTask(FROM_HERE,
-                          base::Bind(&UpdateCheckDriver::BeginUpdateCheck,
-                                     base::Unretained(driver_)));
+    driver_ = new UpdateCheckDriver(locale, install_update_if_possible,
+                                    elevation_window, delegate);
+    driver_->task_runner_->PostTask(
+        FROM_HERE, base::Bind(&UpdateCheckDriver::BeginUpdateCheck,
+                              base::Unretained(driver_)));
   } else {
-    DCHECK_EQ(driver_->task_runner_, task_runner);
     driver_->AddDelegate(delegate);
   }
 }
 
 // Runs on the caller's thread.
 UpdateCheckDriver::UpdateCheckDriver(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const std::string& locale,
     bool install_update_if_possible,
     gfx::AcceleratedWidget elevation_window,
     const base::WeakPtr<UpdateCheckDelegate>& delegate)
-    : task_runner_(std::move(task_runner)),
-      result_runner_(base::ThreadTaskRunnerHandle::Get()),
+    : task_runner_(
+          g_update_driver_task_runner
+              ? std::move(g_update_driver_task_runner)
+              : base::CreateSequencedTaskRunnerWithTraits(
+                    {base::MayBlock(), base::TaskPriority::USER_VISIBLE})),
+      result_runner_(base::SequencedTaskRunnerHandle::Get()),
       locale_(locale),
       install_update_if_possible_(install_update_if_possible),
       elevation_window_(elevation_window),
       delegates_(1, delegate),
       allowed_retries_(kGoogleAllowedRetries),
       system_level_install_(false),
       last_reported_progress_(0),
       status_(UPGRADE_ERROR),
       error_code_(GOOGLE_UPDATE_NO_ERROR),
       hresult_(S_OK),
       installer_exit_code_(-1) {}
 
 UpdateCheckDriver::~UpdateCheckDriver() {
-  DCHECK(result_runner_->BelongsToCurrentThread());

[gab, 2017/07/19 15:15:24]

Why remove these checks? With SequencedTaskRunner you can do
result_runner_->RunsTasksInCurrentSequence();

[calamity, 2017/07/20 03:56:20]

Done.

   // If there is an error, then error_code must not be blank, and vice versa.
   DCHECK_NE(status_ == UPGRADE_ERROR, error_code_ == GOOGLE_UPDATE_NO_ERROR);
   UMA_HISTOGRAM_ENUMERATION("GoogleUpdate.UpgradeResult", status_,
                             NUM_UPGRADE_STATUS);
   if (status_ == UPGRADE_ERROR) {
     UMA_HISTOGRAM_ENUMERATION("GoogleUpdate.UpdateErrorCode", error_code_,
                               NUM_ERROR_CODES);
     if (FAILED(hresult_))
       UMA_HISTOGRAM_SPARSE_SLOWLY("GoogleUpdate.ErrorHresult", hresult_);
     if (installer_exit_code_ != -1) {
@@ skipping 14 matching lines @@
       else if (install_update_if_possible_)
         delegate->OnUpgradeComplete(new_version_);
       else
         delegate->OnUpdateCheckComplete(new_version_);
     }
   }
 }
 
 void UpdateCheckDriver::AddDelegate(
     const base::WeakPtr<UpdateCheckDelegate>& delegate) {
-  DCHECK(result_runner_->BelongsToCurrentThread());
   delegates_.push_back(delegate);
 }
 
 void UpdateCheckDriver::NotifyUpgradeProgress(
     int progress,
     const base::string16& new_version) {
-  DCHECK(result_runner_->BelongsToCurrentThread());
 
   for (const auto& delegate : delegates_) {
     if (delegate)
       delegate->OnUpgradeProgress(progress, new_version);
   }
 }
 
 void UpdateCheckDriver::BeginUpdateCheck() {
   GoogleUpdateErrorCode error_code = GOOGLE_UPDATE_NO_ERROR;
   HRESULT hresult = BeginUpdateCheckInternal(&error_code);
@@ skipping 391 matching lines @@
         IDS_ABOUT_BOX_GOOGLE_UPDATE_ERROR, error_string, html_error_msg);
   }
 }
 
 }  // namespace
 
 
 // Globals ---------------------------------------------------------------------
 
 void BeginUpdateCheck(
-    scoped_refptr<base::SingleThreadTaskRunner> task_runner,
     const std::string& locale,
     bool install_update_if_possible,
     gfx::AcceleratedWidget elevation_window,
     const base::WeakPtr<UpdateCheckDelegate>& delegate) {
-  UpdateCheckDriver::RunUpdateCheck(std::move(task_runner), locale,
-                                    install_update_if_possible,
+  UpdateCheckDriver::RunUpdateCheck(locale, install_update_if_possible,
                                     elevation_window, delegate);
 }
 
 
 // Private API exposed for testing. --------------------------------------------
 
 void SetGoogleUpdateFactoryForTesting(
     const GoogleUpdate3ClassFactory& google_update_factory) {
   if (g_google_update_factory) {
     delete g_google_update_factory;
     g_google_update_factory = nullptr;
   }
   if (!google_update_factory.is_null()) {
     g_google_update_factory =
         new GoogleUpdate3ClassFactory(google_update_factory);
   }
 }
+
+// TODO(calamity): Remove once a MockTimer is implemented in
+// ScopedTaskEnvironment. See https://crbug.com/708584.
+void SetUpdateDriverTaskRunnerForTesting(
+    scoped_refptr<base::SequencedTaskRunner> task_runner) {
+  g_update_driver_task_runner = std::move(task_runner);
+}