Replace deprecated base::NonThreadSafe in chrome/browser/win in favor of SequenceChecker.

chrome/browser/win/jumplist.cc

 // Copyright 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/win/jumplist.h"
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
@@ skipping 226 matching lines @@
   }
   tab_restore_service->AddObserver(this);
   pref_change_registrar_.reset(new PrefChangeRegistrar);
   pref_change_registrar_->Init(profile_->GetPrefs());
   pref_change_registrar_->Add(
       prefs::kIncognitoModeAvailability,
       base::Bind(&JumpList::OnIncognitoAvailabilityChanged, this));
 }
 
 JumpList::~JumpList() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   Terminate();
 }
 
 // static
 bool JumpList::Enabled() {
   return JumpListUpdater::IsEnabled();
 }
 
 void JumpList::CancelPendingUpdate() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   if (task_id_ != base::CancelableTaskTracker::kBadTaskId) {
     cancelable_task_tracker_.TryCancel(task_id_);
     task_id_ = base::CancelableTaskTracker::kBadTaskId;
   }
 }
 
 void JumpList::Terminate() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   timer_most_visited_.Stop();
   timer_recently_closed_.Stop();
   CancelPendingUpdate();
   if (profile_) {
     sessions::TabRestoreService* tab_restore_service =
         TabRestoreServiceFactory::GetForProfile(profile_);
     if (tab_restore_service)
       tab_restore_service->RemoveObserver(this);
     scoped_refptr<history::TopSites> top_sites =
         TopSitesFactory::GetForProfile(profile_);
     if (top_sites)
       top_sites->RemoveObserver(this);
     pref_change_registrar_.reset();
   }
   profile_ = NULL;
 }
 
 void JumpList::ShutdownOnUIThread() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   Terminate();
 }
 
 void JumpList::OnMostVisitedURLsAvailable(
     const history::MostVisitedURLList& urls) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   {
     JumpListData* data = &jumplist_data_->data;
     base::AutoLock auto_lock(data->list_lock_);
     data->most_visited_pages_.clear();
 
     for (size_t i = 0; i < urls.size() && i < kMostVisitedItems; i++) {
       const history::MostVisitedURL& url = urls[i];
       scoped_refptr<ShellLinkItem> link = CreateShellLink();
       std::string url_string = url.url.spec();
       base::string16 url_string_wide = base::UTF8ToUTF16(url_string);
       link->GetCommandLine()->AppendArgNative(url_string_wide);
       link->GetCommandLine()->AppendSwitchASCII(
           switches::kWinJumplistAction, jumplist::kMostVisitedCategory);
       link->set_title(!url.title.empty() ? url.title : url_string_wide);
       link->set_url(url_string);
       data->most_visited_pages_.push_back(link);
       data->icon_urls_.push_back(std::make_pair(url_string, link));
     }
     data->most_visited_pages_have_updates_ = true;
   }
 
   // Send a query that retrieves the first favicon.
   StartLoadingFavicon();
 }
 
 void JumpList::TabRestoreServiceChanged(sessions::TabRestoreService* service) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   // if we have a pending favicon request, cancel it here (it is out of date).
   CancelPendingUpdate();
 
   // Initialize the one-shot timer to update the the "Recently Closed" category
   // in a while. If there is already a request queued then cancel it and post
   // the new request. This ensures that JumpList update of the "Recently Closed"
   // category won't happen until there has been a brief quiet period, thus
   // avoiding update storms.
   if (timer_recently_closed_.IsRunning()) {
     timer_recently_closed_.Reset();
   } else {
     timer_recently_closed_.Start(
         FROM_HERE, kDelayForJumplistUpdate,
         base::Bind(&JumpList::DeferredTabRestoreServiceChanged,
                    base::Unretained(this)));
   }
 }
 
 void JumpList::TabRestoreServiceDestroyed(
     sessions::TabRestoreService* service) {}
 
 bool JumpList::AddTab(const sessions::TabRestoreService::Tab& tab,
                       size_t max_items,
                       JumpListData* data) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   data->list_lock_.AssertAcquired();
 
   // This code adds the URL and the title strings of the given tab to |data|.
   if (data->recently_closed_pages_.size() >= max_items)
     return false;
 
   scoped_refptr<ShellLinkItem> link = CreateShellLink();
   const sessions::SerializedNavigationEntry& current_navigation =
       tab.navigations.at(tab.current_navigation_index);
   std::string url = current_navigation.virtual_url().spec();
   link->GetCommandLine()->AppendArgNative(base::UTF8ToUTF16(url));
   link->GetCommandLine()->AppendSwitchASCII(switches::kWinJumplistAction,
                                             jumplist::kRecentlyClosedCategory);
   link->set_title(current_navigation.title());
   link->set_url(url);
   data->recently_closed_pages_.push_back(link);
   data->icon_urls_.push_back(std::make_pair(std::move(url), std::move(link)));
 
   return true;
 }
 
 void JumpList::AddWindow(const sessions::TabRestoreService::Window& window,
                          size_t max_items,
                          JumpListData* data) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   data->list_lock_.AssertAcquired();
 
   // This code enumerates all the tabs in the given window object and add their
   // URLs and titles to |data|.
   DCHECK(!window.tabs.empty());
 
   for (const auto& tab : window.tabs) {
     if (!AddTab(*tab, max_items, data))
       return;
   }
 }
 
 void JumpList::StartLoadingFavicon() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::ElapsedTimer timer;
 
   GURL url;
   bool waiting_for_icons = true;
   {
     JumpListData* data = &jumplist_data_->data;
     base::AutoLock auto_lock(data->list_lock_);
     waiting_for_icons = !data->icon_urls_.empty();
     if (waiting_for_icons) {
@@ skipping 18 matching lines @@
       base::Bind(&JumpList::OnFaviconDataAvailable, base::Unretained(this)),
       &cancelable_task_tracker_);
 
   // TODO(chengx): Remove the UMA histogram after fixing http://crbug.com/717236
   UMA_HISTOGRAM_TIMES("WinJumplist.StartLoadingFaviconDuration",
                       timer.Elapsed());
 }
 
 void JumpList::OnFaviconDataAvailable(
     const favicon_base::FaviconImageResult& image_result) {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   base::ElapsedTimer timer;
 
   // If there is currently a favicon request in progress, it is now outdated,
   // as we have received another, so nullify the handle from the old request.
   task_id_ = base::CancelableTaskTracker::kBadTaskId;
   // Lock the list to set icon data and pop the url.
   {
     JumpListData* data = &jumplist_data_->data;
     base::AutoLock auto_lock(data->list_lock_);
@@ skipping 14 matching lines @@
 
   // TODO(chengx): Remove the UMA histogram after fixing http://crbug.com/717236
   UMA_HISTOGRAM_TIMES("WinJumplist.OnFaviconDataAvailableDuration",
                       timer.Elapsed());
 
   // Check whether we need to load more favicons.
   StartLoadingFavicon();
 }
 
 void JumpList::OnIncognitoAvailabilityChanged() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   bool waiting_for_icons = true;
   {
     JumpListData* data = &jumplist_data_->data;
     base::AutoLock auto_lock(data->list_lock_);
     waiting_for_icons = !data->icon_urls_.empty();
   }
 
   // Since neither the "Most Visited" category nor the "Recently Closed"
   // category changes, mark the flags so that icon files for those categories
   // won't be updated later on.
   if (!waiting_for_icons)
     PostRunUpdate();
 }
 
 void JumpList::PostRunUpdate() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   TRACE_EVENT0("browser", "JumpList::PostRunUpdate");
   if (!profile_)
     return;
 
   base::FilePath profile_dir = profile_->GetPath();
 
   // Check if incognito windows (or normal windows) are disabled by policy.
   IncognitoModePrefs::Availability incognito_availability =
       IncognitoModePrefs::GetAvailability(profile_->GetPrefs());
@@ skipping 40 matching lines @@
   if (timer_most_visited_.IsRunning()) {
     timer_most_visited_.Reset();
   } else {
     timer_most_visited_.Start(
         FROM_HERE, kDelayForJumplistUpdate,
         base::Bind(&JumpList::DeferredTopSitesChanged, base::Unretained(this)));
   }
 }
 
 void JumpList::DeferredTopSitesChanged() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (updates_to_skip_ > 0) {
     --updates_to_skip_;
     return;
   }
 
   // Opening the first tab in one session triggers a TopSite history sync.
   // Delay this sync till the first tab is closed to allow the "recently closed"
   // category from last session to stay longer.
   if (!has_tab_closed_)
     return;
 
   scoped_refptr<history::TopSites> top_sites =
       TopSitesFactory::GetForProfile(profile_);
   if (top_sites) {
     top_sites->GetMostVisitedURLs(
         base::Bind(&JumpList::OnMostVisitedURLsAvailable,
                    weak_ptr_factory_.GetWeakPtr()),
         false);
   }
 }
 
 void JumpList::DeferredTabRestoreServiceChanged() {
-  DCHECK(CalledOnValidThread());
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 
   if (updates_to_skip_ > 0) {
     --updates_to_skip_;
     return;
   }
 
   // Force a TopSite history sync when closing a first tab in one session.
   if (!has_tab_closed_) {
     has_tab_closed_ = true;
     scoped_refptr<history::TopSites> top_sites =
@@ skipping 289 matching lines @@
           app_id, profile_dir, local_most_visited_pages,
           local_recently_closed_pages, most_visited_pages_have_updates,
           recently_closed_pages_have_updates, incognito_availability)) {
     base::AutoLock auto_lock(data->list_lock_);
     if (most_visited_pages_have_updates)
       data->most_visited_pages_have_updates_ = true;
     if (recently_closed_pages_have_updates)
       data->recently_closed_pages_have_updates_ = true;
   }
 }