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 78 matching lines @@
 // Time from startup to first HistoryService query.
 static const int64 kUpdateIntervalSecs = 15;
 // Intervals between requests to HistoryService.
 static const int64 kMinUpdateIntervalMinutes = 1;
 static const int64 kMaxUpdateIntervalMinutes = 60;
 
 // Use 100 quality (highest quality) because we're very sensitive to
 // artifacts for these small sized, highly detailed images.
 static const int kTopSitesImageQuality = 100;
 
+// Initially, histogram is not recorded.
+bool TopSitesImpl::histogram_recorded_ = false;
+
 TopSitesImpl::TopSitesImpl(Profile* profile,
                            const PrepopulatedPageList& prepopulated_pages)
     : backend_(NULL),
       cache_(new TopSitesCache()),
       thread_safe_cache_(new TopSitesCache()),
       profile_(profile),
       last_num_urls_changed_(0),
       prepopulated_pages_(prepopulated_pages),
       loaded_(false),
       history_service_observer_(this) {
@@ skipping 509 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, CALL_LOCATION_FROM_OTHER_PLACES);
   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,
+                               const CallLocation location) {
   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);
+
+  TopSitesBackend::RecordHistogram record_or_not =
+      TopSitesBackend::RECORD_HISTOGRAM_NO;
+
+  // Record the delta size into a histogram if this function is called from
+  // function OnGotMostVisitedThumbnails and no histogram value has been
+  // recorded before.
+  if (location == CALL_LOCATION_FROM_ON_GOT_MOST_VISITED_THUMBNAILS &&
+      !histogram_recorded_) {
+    size_t delta_size =
+        delta.deleted.size() + delta.added.size() + delta.moved.size();
+    UMA_HISTOGRAM_COUNTS_100("History.FirstSetTopSitesDeltaSize", delta_size);
+    // Will be passed to TopSitesBackend to let it record the histogram too.
+    record_or_not = TopSitesBackend::RECORD_HISTOGRAM_YES;
+    // Change it to true so that the histogram will not be recorded any more.
+    histogram_recorded_ = true;
+  }
+
   if (!delta.deleted.empty() || !delta.added.empty() || !delta.moved.empty()) {
-    backend_->UpdateTopSites(delta);
+    backend_->UpdateTopSites(delta, record_or_not);
   }
 
   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 96 matching lines @@
   timer_.Start(FROM_HERE, delta, this, &TopSitesImpl::TimerFired);
 }
 
 void TopSitesImpl::OnGotMostVisitedThumbnails(
     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,
+              CALL_LOCATION_FROM_ON_GOT_MOST_VISITED_THUMBNAILS);
   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, CALL_LOCATION_FROM_OTHER_PLACES);
 }
 
 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(), CALL_LOCATION_FROM_OTHER_PLACES);
     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, CALL_LOCATION_FROM_OTHER_PLACES);
   }
   StartQueryForMostVisited();
 }
 
 void TopSitesImpl::HistoryServiceBeingDeleted(HistoryService* history_service) {
   history_service_observer_.Remove(history_service);
 }
 
 }  // namespace history