Fix a threading issue and modernize the use of scoped_refptr in the on-demand update checker.

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 <stdint.h>
 #include <string.h>
 
+#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.h"
 #include "base/metrics/sparse_histogram.h"
 #include "base/path_service.h"
@@ skipping 182 matching lines @@
 
 // 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.
   static void RunUpdateCheck(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      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(
-      const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+      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.
+  void AddDelegate(const base::WeakPtr<UpdateCheckDelegate>& delegate);
+
+  // Notifies delegates of an update's progress. |progress|, a number between 0
+  // and 100 (inclusive), is an estimation as to what percentage of the upgrade
+  // has completed. |new_version| indicates the version that is being download
+  // and installed.
+  void NotifyUpgradeProgress(int progress, const base::string16& new_version);
+
   // Starts an update check.
   void BeginUpdateCheck();
 
   // Returns the result of initiating an update check. Sets |error_code| if the
   // result is any kind of failure. On failure, the instance is left in a
   // consistent state so that this method can be invoked later to retry the
   // steps that failed.
   HRESULT BeginUpdateCheckInternal(GoogleUpdateErrorCode* error_code);
 
   // Sets status_ to UPGRADE_ERROR, error_code_ to |error_code|, hresult_ to
@@ skipping 55 matching lines @@
       base::string16* new_version,
       int* progress) const;
 
   // Polls Google Update to determine the state of the ongoing check or
   // 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();
 
-  // If an UpdateCheckDriver is already running, the delegate is added to the
-  // existing one instead of creating a new one.
-  void AddDelegate(const base::WeakPtr<UpdateCheckDelegate>& delegate);
-
+  // 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_;
 
   // The caller's task runner, on which methods of the |delegates_| will be
   // invoked.
   scoped_refptr<base::SingleThreadTaskRunner> 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_;
 
-  // Contains all delegates by which feedback is conveyed.
+  // Contains all delegates by which feedback is conveyed. Accessed only on the
+  // caller's thread.
   std::vector<base::WeakPtr<UpdateCheckDelegate>> delegates_;
 
   // Number of remaining retries allowed when errors occur.
   int allowed_retries_;
 
   // True if operating on a per-machine installation rather than a per-user one.
   bool system_level_install_;
 
   // The on-demand updater that is doing the work.
   base::win::ScopedComPtr<IGoogleUpdate3Web> google_update_;
@@ skipping 16 matching lines @@
   HRESULT hresult_;
   int installer_exit_code_;
 
   DISALLOW_COPY_AND_ASSIGN(UpdateCheckDriver);
 };
 
 UpdateCheckDriver* UpdateCheckDriver::driver_ = nullptr;
 
 // static
 void UpdateCheckDriver::RunUpdateCheck(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    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_)));
   } else {
     DCHECK_EQ(driver_->task_runner_, task_runner);
     driver_->AddDelegate(delegate);
   }
 }
 
 // Runs on the caller's thread.
 UpdateCheckDriver::UpdateCheckDriver(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    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_(task_runner),
+    : task_runner_(std::move(task_runner)),
       result_runner_(base::ThreadTaskRunnerHandle::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) {
-  delegates_.push_back(delegate);
-}
+      installer_exit_code_(-1) {}
 
 UpdateCheckDriver::~UpdateCheckDriver() {
   DCHECK(result_runner_->BelongsToCurrentThread());
   // 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) {
       UMA_HISTOGRAM_SPARSE_SLOWLY("GoogleUpdate.InstallerExitCode",
                                   installer_exit_code_);
     }
   }
 
   // Clear the driver before calling the delegates because they might call
   // BeginUpdateCheck() and they must not add themselves to the current
-  // instance of UpdateCheckDriver, which is currently being destroyed.
+  // instance of UpdateCheckDriver, which is being destroyed.
   driver_ = nullptr;
 
   for (const auto& delegate : delegates_) {
     if (delegate) {
       if (status_ == UPGRADE_ERROR)
         delegate->OnError(error_code_, html_error_message_, new_version_);
       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);
   if (SUCCEEDED(hresult)) {
     // Start polling.
     task_runner_->PostTask(FROM_HERE,
                            base::Bind(&UpdateCheckDriver::PollGoogleUpdate,
                                       base::Unretained(this)));
     return;
   }
@@ skipping 321 matching lines @@
   } else if (IsIntermediateState(state, state_value, &new_version, &progress)) {
     bool got_new_version = new_version_.empty() && !new_version.empty();
     if (got_new_version)
       new_version_ = new_version;
     // Give the caller this status update if it differs from the last one given.
     if (got_new_version || progress != last_reported_progress_) {
       last_reported_progress_ = progress;
 
       // It is safe to post this task with an unretained pointer since the task
       // is guaranteed to run before a subsequent DeleteSoon is handled.
-      for (const auto& delegate : delegates_) {
-        result_runner_->PostTask(
-            FROM_HERE,
-            base::Bind(&UpdateCheckDelegate::OnUpgradeProgress, delegate,
-                       last_reported_progress_, new_version_));
-      }
+      result_runner_->PostTask(
+          FROM_HERE, base::Bind(&UpdateCheckDriver::NotifyUpgradeProgress,
+                                base::Unretained(this), last_reported_progress_,
+                                new_version_));
     }
 
     // Schedule the next check.
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(&UpdateCheckDriver::PollGoogleUpdate,
                               base::Unretained(this)),
         base::TimeDelta::FromMilliseconds(kGoogleUpdatePollIntervalMs));
     // Early return for this non-terminal state.
     return;
   }
 
   // Release the reference on the COM objects before bouncing back to the
   // caller's thread.
   state.Release();
   app_.Release();
   app_bundle_.Release();
   google_update_.Release();
 
   result_runner_->DeleteSoon(FROM_HERE, this);
 }
 
-void UpdateCheckDriver::AddDelegate(
-    const base::WeakPtr<UpdateCheckDelegate>& delegate) {
-  delegates_.push_back(delegate);
-}
-
 void UpdateCheckDriver::OnUpgradeError(GoogleUpdateErrorCode error_code,
                                        HRESULT hresult,
                                        int installer_exit_code,
                                        const base::string16& error_string) {
   status_ = UPGRADE_ERROR;
   error_code_ = error_code;
   hresult_ = hresult;
   installer_exit_code_ = installer_exit_code;
 
   // Some specific result codes have dedicated messages.
@@ skipping 20 matching lines @@
         IDS_ABOUT_BOX_GOOGLE_UPDATE_ERROR, error_string, html_error_msg);
   }
 }
 
 }  // namespace
 
 
 // Globals ---------------------------------------------------------------------
 
 void BeginUpdateCheck(
-    const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
+    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(task_runner, locale,
+  UpdateCheckDriver::RunUpdateCheck(std::move(task_runner), 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);
   }
 }