Only record the execution time during startup.

chrome/browser/history/top_sites_impl.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/history/top_sites_impl.h"
 
 #include <algorithm>
 #include <set>
 
 #include "base/bind.h"
@@ skipping 607 matching lines @@
     new_url.redirects.push_back(url);
   }
   new_url.last_forced_time = time;
   // Add forced URLs and sort. Added to the end of the list of forced URLs
   // since this is almost always where it needs to go, unless the user's local
   // clock is fiddled with.
   MostVisitedURLList::iterator mid = new_list.begin() + num_forced;
   new_list.insert(mid, new_url);
   mid = new_list.begin() + num_forced;  // Mid was invalidated.
   std::inplace_merge(new_list.begin(), mid, mid + 1, ForcedURLComparator);
-  SetTopSites(new_list);
+  SetTopSites(new_list, false);
   return true;
 }
 
 bool TopSitesImpl::AddPrepopulatedPages(MostVisitedURLList* urls,
                                         size_t num_forced_urls) {
   bool added = false;
   for (const auto& prepopulated_page : prepopulated_pages_) {
     if (urls->size() - num_forced_urls < kNonForcedTopSitesNumber &&
         IndexOf(*urls, prepopulated_page.most_visited.url) == -1) {
       urls->push_back(prepopulated_page.most_visited);
@@ skipping 106 matching lines @@
         return;
       const GURL& url = load_details->entry->GetURL();
       if (!cache_->IsKnownURL(url) && CanAddURLToHistory(url)) {
         // To avoid slamming history we throttle requests when the url updates.
         // To do otherwise negatively impacts perf tests.
         RestartQueryForTopSitesTimer(GetUpdateDelay());
       }
     }
 }
 
-void TopSitesImpl::SetTopSites(const MostVisitedURLList& new_top_sites) {
+void TopSitesImpl::SetTopSites(
+    const MostVisitedURLList& new_top_sites, bool startup) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   MostVisitedURLList top_sites(new_top_sites);
   size_t num_forced_urls = MergeCachedForcedURLs(&top_sites);
   AddPrepopulatedPages(&top_sites, num_forced_urls);
 
   TopSitesDelta delta;
   DiffMostVisited(cache_->top_sites(), top_sites, &delta);
   if (!delta.deleted.empty() || !delta.added.empty() || !delta.moved.empty()) {
-    backend_->UpdateTopSites(delta);
+    backend_->UpdateTopSites(delta, startup);
+  }
+
+  // Record the delta size into a histogram for startup.
+  if (startup) {
+    size_t delta_size =
+        delta.deleted.size() + delta.added.size() + delta.moved.size();
+    UMA_HISTOGRAM_COUNTS_100(
+        "History.UpdateTopSitesOnDBThread_Startup_DeltaSize", delta_size);
   }
 
   last_num_urls_changed_ = delta.added.size() + delta.moved.size();
 
   // We always do the following steps (setting top sites in cache, and resetting
   // thread safe cache ...) as this method is invoked during startup at which
   // point the caches haven't been updated yet.
   cache_->SetTopSites(top_sites);
 
   // See if we have any tmp thumbnails for the new sites.
@@ skipping 89 matching lines @@
   if (timer_.IsRunning() && ((timer_start_time_ + timer_.GetCurrentDelay()) <
                              (base::TimeTicks::Now() + delta))) {
     return;
   }
 
   timer_start_time_ = base::TimeTicks::Now();
   timer_.Stop();
   timer_.Start(FROM_HERE, delta, this, &TopSitesImpl::TimerFired);
 }
 
 void TopSitesImpl::OnGotMostVisitedThumbnails(

[jwd, 2015/03/30 16:06:47]

I'm a bit concerned that this *could* be called during a non-startup scenario.
Would it make sense to plumb that boolean out even further? So that it gets set
in the bind in TopSitesImpl::Init(..)?

[yao, 2015/03/30 22:16:18]

But OnGotMostVisitedThumbnails is only called from TopSitesImpl::Init. 

[yao, 2015/03/30 22:18:35]

Ah, ic what you are saying, but OnGotMostVisitedThumbnails is 30 functions deep
from BrowserMainRunnerImpl::Run, that would be a overkill I feel. 

[jwd, 2015/03/31 19:26:16]

As per offline conversation, I'd be comfortable with just pushing it up one
level into Init.

     const scoped_refptr<MostVisitedThumbnails>& thumbnails) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Set the top sites directly in the cache so that SetTopSites diffs
   // correctly.
   cache_->SetTopSites(thumbnails->most_visited);
-  SetTopSites(thumbnails->most_visited);
+  SetTopSites(thumbnails->most_visited, true);
   cache_->SetThumbnails(thumbnails->url_to_images_map);
 
   ResetThreadSafeImageCache();
 
   MoveStateToLoaded();
 
   // Start a timer that refreshes top sites from history.
   RestartQueryForTopSitesTimer(
       base::TimeDelta::FromSeconds(kUpdateIntervalSecs));
 }
 
 void TopSitesImpl::OnTopSitesAvailableFromHistory(
     const MostVisitedURLList* pages) {
   DCHECK(pages);
-  SetTopSites(*pages);
+  SetTopSites(*pages, false);
 }
 
 void TopSitesImpl::OnURLsDeleted(HistoryService* history_service,
                                  bool all_history,
                                  bool expired,
                                  const URLRows& deleted_rows,
                                  const std::set<GURL>& favicon_urls) {
   if (!loaded_)
     return;
 
   if (all_history) {
-    SetTopSites(MostVisitedURLList());
+    SetTopSites(MostVisitedURLList(), false);
     backend_->ResetDatabase();
   } else {
     std::set<size_t> indices_to_delete;  // Indices into top_sites_.
     for (const auto& row : deleted_rows) {
       if (cache_->IsKnownURL(row.url()))
         indices_to_delete.insert(cache_->GetURLIndex(row.url()));
     }
 
     if (indices_to_delete.empty())
       return;
 
     MostVisitedURLList new_top_sites(cache_->top_sites());
     for (std::set<size_t>::reverse_iterator i = indices_to_delete.rbegin();
          i != indices_to_delete.rend(); i++) {
       new_top_sites.erase(new_top_sites.begin() + *i);
     }
-    SetTopSites(new_top_sites);
+    SetTopSites(new_top_sites, false);
   }
   StartQueryForMostVisited();
 }
 
 void TopSitesImpl::HistoryServiceBeingDeleted(HistoryService* history_service) {
   history_service_observer_.Remove(history_service);
 }
 
 }  // namespace history