Replace deprecated base::NonThreadSafe in chrome/browser/profile_resetter in favor of SequenceCheck…

chrome/browser/profile_resetter/profile_resetter.cc

 // Copyright (c) 2013 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/profile_resetter/profile_resetter.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <vector>
@@ skipping 61 matching lines @@
 
 }  // namespace
 #endif  // defined(OS_WIN)
 
 ProfileResetter::ProfileResetter(Profile* profile)
     : profile_(profile),
       template_url_service_(TemplateURLServiceFactory::GetForProfile(profile_)),
       pending_reset_flags_(0),
       cookies_remover_(nullptr),
       weak_ptr_factory_(this) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(profile_);
 }
 
 ProfileResetter::~ProfileResetter() {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (cookies_remover_)
     cookies_remover_->RemoveObserver(this);
 }
 
 void ProfileResetter::Reset(
     ProfileResetter::ResettableFlags resettable_flags,
     std::unique_ptr<BrandcodedDefaultSettings> master_settings,
     const base::Closure& callback) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(master_settings);
 
   // We should never be called with unknown flags.
   CHECK_EQ(static_cast<ResettableFlags>(0), resettable_flags & ~ALL);
 
   // We should never be called when a previous reset has not finished.
   CHECK_EQ(static_cast<ResettableFlags>(0), pending_reset_flags_);
 
   if (!resettable_flags) {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
@@ skipping 31 matching lines @@
 
   DCHECK_EQ(resettable_flags, reset_triggered_for_flags);
 }
 
 bool ProfileResetter::IsActive() const {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   return pending_reset_flags_ != 0;
 }
 
 void ProfileResetter::MarkAsDone(Resettable resettable) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // Check that we are never called twice or unexpectedly.
   CHECK(pending_reset_flags_ & resettable);
 
   pending_reset_flags_ &= ~resettable;
 
   if (!pending_reset_flags_) {
     content::BrowserThread::PostTask(content::BrowserThread::UI, FROM_HERE,
                                      callback_);
     callback_.Reset();
     master_settings_.reset();
     template_url_service_sub_.reset();
   }
 }
 
 void ProfileResetter::ResetDefaultSearchEngine() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(template_url_service_);
   // If TemplateURLServiceFactory is ready we can clean it right now.
   // Otherwise, load it and continue from ProfileResetter::Observe.
   if (template_url_service_->loaded()) {
     PrefService* prefs = profile_->GetPrefs();
     DCHECK(prefs);
     TemplateURLPrepopulateData::ClearPrepopulatedEnginesInPrefs(
         profile_->GetPrefs());
     std::unique_ptr<base::ListValue> search_engines(
         master_settings_->GetSearchProviderOverrides());
@@ skipping 10 matching lines @@
   } else {
     template_url_service_sub_ =
         template_url_service_->RegisterOnLoadedCallback(
             base::Bind(&ProfileResetter::OnTemplateURLServiceLoaded,
                        weak_ptr_factory_.GetWeakPtr()));
     template_url_service_->Load();
   }
 }
 
 void ProfileResetter::ResetHomepage() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   PrefService* prefs = profile_->GetPrefs();
   DCHECK(prefs);
   std::string homepage;
   bool homepage_is_ntp, show_home_button;
 
   if (master_settings_->GetHomepage(&homepage))
     prefs->SetString(prefs::kHomePage, homepage);
 
   if (master_settings_->GetHomepageIsNewTab(&homepage_is_ntp))
     prefs->SetBoolean(prefs::kHomePageIsNewTabPage, homepage_is_ntp);
   else
     prefs->ClearPref(prefs::kHomePageIsNewTabPage);
 
   if (master_settings_->GetShowHomeButton(&show_home_button))
     prefs->SetBoolean(prefs::kShowHomeButton, show_home_button);
   else
     prefs->ClearPref(prefs::kShowHomeButton);
   MarkAsDone(HOMEPAGE);
 }
 
 void ProfileResetter::ResetContentSettings() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   HostContentSettingsMap* map =
       HostContentSettingsMapFactory::GetForProfile(profile_);
 
   for (const content_settings::WebsiteSettingsInfo* info :
        *content_settings::WebsiteSettingsRegistry::GetInstance()) {
     map->ClearSettingsForOneType(info->type());
   }
 
   // TODO(raymes): The default value isn't really used for website settings
   // right now, but if it were we should probably reset that here too.
   for (const content_settings::ContentSettingsInfo* info :
        *content_settings::ContentSettingsRegistry::GetInstance()) {
     map->SetDefaultContentSetting(info->website_settings_info()->type(),
                                   CONTENT_SETTING_DEFAULT);
   }
   MarkAsDone(CONTENT_SETTINGS);
 }
 
 void ProfileResetter::ResetCookiesAndSiteData() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(!cookies_remover_);
 
   cookies_remover_ = content::BrowserContext::GetBrowsingDataRemover(profile_);
   cookies_remover_->AddObserver(this);
   int remove_mask = ChromeBrowsingDataRemoverDelegate::DATA_TYPE_SITE_DATA |
                     content::BrowsingDataRemover::DATA_TYPE_CACHE;
   PrefService* prefs = profile_->GetPrefs();
   DCHECK(prefs);
 
   // Don't try to clear LSO data if it's not supported.
   if (!prefs->GetBoolean(prefs::kClearPluginLSODataEnabled))
     remove_mask &= ~ChromeBrowsingDataRemoverDelegate::DATA_TYPE_PLUGIN_DATA;
   cookies_remover_->RemoveAndReply(
       base::Time(), base::Time::Max(), remove_mask,
       content::BrowsingDataRemover::ORIGIN_TYPE_UNPROTECTED_WEB, this);
 }
 
 void ProfileResetter::ResetExtensions() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   std::vector<std::string> brandcode_extensions;
   master_settings_->GetExtensions(&brandcode_extensions);
 
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   DCHECK(extension_service);
   extension_service->DisableUserExtensionsExcept(brandcode_extensions);
 
   // Reenable all disabled external component extensions.
@@ skipping 11 matching lines @@
       extension_ids_to_reenable.push_back(extension->id());
   }
   for (const auto& extension_id : extension_ids_to_reenable) {
     extension_service->EnableExtension(extension_id);
   }
 
   MarkAsDone(EXTENSIONS);
 }
 
 void ProfileResetter::ResetStartupPages() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   PrefService* prefs = profile_->GetPrefs();
   DCHECK(prefs);
   std::unique_ptr<base::ListValue> url_list(
       master_settings_->GetUrlsToRestoreOnStartup());
   if (url_list)
     ListPrefUpdate(prefs, prefs::kURLsToRestoreOnStartup)->Swap(url_list.get());
 
   int restore_on_startup;
   if (master_settings_->GetRestoreOnStartup(&restore_on_startup))
     prefs->SetInteger(prefs::kRestoreOnStartup, restore_on_startup);
@@ skipping 30 matching lines @@
                  weak_ptr_factory_.GetWeakPtr(),
                  SHORTCUTS));
 #else
   MarkAsDone(SHORTCUTS);
 #endif
 }
 
 void ProfileResetter::OnTemplateURLServiceLoaded() {
   // TemplateURLService has loaded. If we need to clean search engines, it's
   // time to go on.
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   template_url_service_sub_.reset();
   if (pending_reset_flags_ & DEFAULT_SEARCH_ENGINE)
     ResetDefaultSearchEngine();
 }
 
 void ProfileResetter::OnBrowsingDataRemoverDone() {
   cookies_remover_->RemoveObserver(this);
   cookies_remover_ = nullptr;
   MarkAsDone(COOKIES_AND_SITE_DATA);
 }
@@ skipping 19 matching lines @@
         chrome_exe,
         false,
         cancel,
         &shortcuts);
   }
   return shortcuts;
 #else
   return std::vector<ShortcutCommand>();
 #endif
 }