Chrome Cleaner: Fix issue where a tagged profile could be reset multiple times

chrome/browser/safe_browsing/chrome_cleaner/settings_resetter_win.cc

 // Copyright 2017 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/safe_browsing/chrome_cleaner/settings_resetter_win.h"
 
 #include <algorithm>
 #include <iterator>
 #include <memory>
 #include <utility>
 #include <vector>
 
 #include "base/barrier_closure.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/sequence_checker.h"
 #include "base/synchronization/lock.h"
 #include "base/win/registry.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/profile_resetter/profile_resetter.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/srt_field_trial_win.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/common/pref_names.h"
@@ skipping 61 matching lines @@
       Profile* profile,
       std::unique_ptr<BrandcodedDefaultSettings> master_settings);
 
   // Removes the settings reset tag for |profile|. If there are no more
   // profiles to reset, invokes |done_callback_| and deletes this object.
   void OnResetCompleted(Profile* profile);
 
   // The profiles to be reset.
   std::vector<Profile*> profiles_to_reset_;
 
+  // The ProfileResetter objects that are used to reset each profile. We need to
+  // hold on to these until each reset operation has been completed.
+  std::vector<std::unique_ptr<ProfileResetter>> profile_resetters_;
+
+  // Used to check that modifications to |profile_resetters_| are sequenced
+  // correctly.
+  SEQUENCE_CHECKER(sequence_checker_);
+
   // The number of profiles that need to be reset.
   int num_pending_resets_;
 
   // The callback to be invoked once settings reset completes.
   base::OnceClosure done_callback_;
 
   std::unique_ptr<PostCleanupSettingsResetter::Delegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(SettingsResetter);
 };
 
 SettingsResetter::SettingsResetter(
     std::vector<Profile*> profiles_to_reset,
     std::unique_ptr<PostCleanupSettingsResetter::Delegate> delegate,
     base::OnceClosure done_callback)
     : profiles_to_reset_(std::move(profiles_to_reset)),
       num_pending_resets_(profiles_to_reset_.size()),
       done_callback_(std::move(done_callback)),
       delegate_(std::move(delegate)) {
   DCHECK_LT(0, num_pending_resets_);
   DCHECK(done_callback_);
   DCHECK(delegate_);
+
+  DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
 SettingsResetter::~SettingsResetter() {
   DCHECK(!done_callback_);
   DCHECK(!num_pending_resets_);
 }
 
 void SettingsResetter::Run() {
   for (Profile* profile : profiles_to_reset_) {
     delegate_->FetchDefaultSettings(
         base::Bind(&SettingsResetter::OnFetchCompleted, this, profile));
   }
 }
 
 void SettingsResetter::OnFetchCompleted(
     Profile* profile,
     std::unique_ptr<BrandcodedDefaultSettings> master_settings) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
   static const ProfileResetter::ResettableFlags kSettingsToReset =
       ProfileResetter::DEFAULT_SEARCH_ENGINE | ProfileResetter::HOMEPAGE |
       ProfileResetter::EXTENSIONS | ProfileResetter::STARTUP_PAGES |
       ProfileResetter::SHORTCUTS;
 
-  delegate_->GetProfileResetter(profile)->Reset(
+  profile_resetters_.push_back(delegate_->GetProfileResetter(profile));
+  profile_resetters_.back()->Reset(
       kSettingsToReset, std::move(master_settings),
       base::Bind(&SettingsResetter::OnResetCompleted, this, profile));
 }
 
 void SettingsResetter::OnResetCompleted(Profile* profile) {
   DCHECK_LT(0, num_pending_resets_);
 
   RecordResetPending(false, profile);
 
   --num_pending_resets_;
@@ skipping 78 matching lines @@
 }
 
 // static
 void PostCleanupSettingsResetter::RegisterProfilePrefs(
     user_prefs::PrefRegistrySyncable* registry) {
   DCHECK(registry);
   registry->RegisterBooleanPref(prefs::kChromeCleanerResetPending, false);
 }
 
 }  // namespace safe_browsing