Eliminate NOTIFICATION_HISTORY_LOADED notification

chrome/browser/predictors/resource_prefetch_predictor.cc

 // Copyright 2014 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/predictors/resource_prefetch_predictor.h"
 
 #include <map>
 #include <set>
 #include <utility>
 
@@ skipping 289 matching lines @@
 // ResourcePrefetchPredictor.
 
 ResourcePrefetchPredictor::ResourcePrefetchPredictor(
     const ResourcePrefetchPredictorConfig& config,
     Profile* profile)
     : profile_(profile),
       config_(config),
       initialization_state_(NOT_INITIALIZED),
       tables_(PredictorDatabaseFactory::GetForProfile(
           profile)->resource_prefetch_tables()),
-      results_map_deleter_(&results_map_) {
+      results_map_deleter_(&results_map_),
+      history_service_observer_(this) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   // Some form of learning has to be enabled.
   DCHECK(config_.IsLearningEnabled());
   if (config_.IsURLPrefetchingEnabled(profile_))
     DCHECK(config_.IsURLLearningEnabled());
   if (config_.IsHostPrefetchingEnabled(profile_))
     DCHECK(config_.IsHostLearningEnabled());
 }
 
 ResourcePrefetchPredictor::~ResourcePrefetchPredictor() {
 }
 
 void ResourcePrefetchPredictor::RecordURLRequest(
     const URLRequestSummary& request) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (initialization_state_ != INITIALIZED)
-    return;
+    if (!CheckForHistoryService())

[sdefresne, 2014/10/30 17:37:04]

Question: is it really required to insert all those calls to
CheckForHistoryService()? I'm afraid it may be introducing behaviour changes.
Isn't it enough to just call the method from
ResourcePrefetchPredictor::CreateCaches()?

[nshaik, 2014/10/30 21:48:36]

I was trying to be extra careful which I think is needless.
I just realized that StartInitialization is called every time
RecordMainFrameLoadComplete is done.
Changed the code.

+      return;
 
   CHECK_EQ(request.resource_type, content::RESOURCE_TYPE_MAIN_FRAME);
   OnMainFrameRequest(request);
 }
 
 void ResourcePrefetchPredictor::RecordURLResponse(
     const URLRequestSummary& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (initialization_state_ != INITIALIZED)
-    return;
+    if (!CheckForHistoryService())
+      return;
 
   if (response.resource_type == content::RESOURCE_TYPE_MAIN_FRAME)
     OnMainFrameResponse(response);
   else
     OnSubresourceResponse(response);
 }
 
 void ResourcePrefetchPredictor::RecordURLRedirect(
     const URLRequestSummary& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (initialization_state_ != INITIALIZED)
-    return;
+    if (!CheckForHistoryService())
+      return;
 
   CHECK_EQ(response.resource_type, content::RESOURCE_TYPE_MAIN_FRAME);
   OnMainFrameRedirect(response);
 }
 
 void ResourcePrefetchPredictor::RecordMainFrameLoadComplete(
     const NavigationID& navigation_id) {
   switch (initialization_state_) {
     case NOT_INITIALIZED:
       StartInitialization();
@@ skipping 30 matching lines @@
   }
 }
 
 void ResourcePrefetchPredictor::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
   switch (type) {
-    case chrome::NOTIFICATION_HISTORY_LOADED: {
-      DCHECK_EQ(initialization_state_, INITIALIZING);
-      notification_registrar_.Remove(this,
-                                     chrome::NOTIFICATION_HISTORY_LOADED,
-                                     content::Source<Profile>(profile_));
-      OnHistoryAndCacheLoaded();
-      break;
-    }
-
     case chrome::NOTIFICATION_HISTORY_URLS_DELETED: {
       DCHECK_EQ(initialization_state_, INITIALIZED);
       const content::Details<const history::URLsDeletedDetails>
           urls_deleted_details =
               content::Details<const history::URLsDeletedDetails>(details);
       if (urls_deleted_details->all_history) {
         DeleteAllUrls();
         UMA_HISTOGRAM_ENUMERATION("ResourcePrefetchPredictor.ReportingEvent",
                                   REPORTING_EVENT_ALL_HISTORY_CLEARED,
                                   REPORTING_EVENT_COUNT);
@@ skipping 34 matching lines @@
   // New empty navigation entry.
   inflight_navigations_.insert(std::make_pair(
       request.navigation_id,
       make_linked_ptr(new std::vector<URLRequestSummary>())));
 }
 
 void ResourcePrefetchPredictor::OnMainFrameResponse(
     const URLRequestSummary& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   if (initialization_state_ != INITIALIZED)
-    return;
+    if (!CheckForHistoryService())
+      return;
 
   RecordNavigationEvent(NAVIGATION_EVENT_RESPONSE_STARTED);
 
   StopPrefetching(response.navigation_id);
 }
 
 void ResourcePrefetchPredictor::OnMainFrameRedirect(
     const URLRequestSummary& response) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
@@ skipping 212 matching lines @@
   DCHECK(inflight_navigations_.empty());
 
   url_table_cache_.reset(url_data_map.release());
   host_table_cache_.reset(host_data_map.release());
 
   UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.UrlTableMainFrameUrlCount",
                        url_table_cache_->size());
   UMA_HISTOGRAM_COUNTS("ResourcePrefetchPredictor.HostTableHostCount",
                        host_table_cache_->size());
 
-  // Add notifications for history loading if it is not ready.
-  HistoryService* history_service = HistoryServiceFactory::GetForProfile(
-    profile_, Profile::EXPLICIT_ACCESS);
-  if (!history_service) {
-    notification_registrar_.Add(this, chrome::NOTIFICATION_HISTORY_LOADED,
-                                content::Source<Profile>(profile_));
-  } else {
-    OnHistoryAndCacheLoaded();
-  }
+  CheckForHistoryService();
 }
 
 void ResourcePrefetchPredictor::OnHistoryAndCacheLoaded() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_EQ(initialization_state_, INITIALIZING);
 
   notification_registrar_.Add(this,
                               chrome::NOTIFICATION_HISTORY_URLS_DELETED,
                               content::Source<Profile>(profile_));
 
   // Initialize the prefetch manager only if prefetching is enabled.
   if (config_.IsPrefetchingEnabled(profile_)) {
     prefetch_manager_ = new ResourcePrefetcherManager(
         this, config_, profile_->GetRequestContext());
   }
 
+  history_service_observer_.RemoveAll();
   initialization_state_ = INITIALIZED;
 }
 
 void ResourcePrefetchPredictor::CleanupAbandonedNavigations(
     const NavigationID& navigation_id) {
   static const base::TimeDelta max_navigation_age =
       base::TimeDelta::FromSeconds(config_.max_navigation_lifetime_seconds);
 
   base::TimeTicks time_now = base::TimeTicks::Now();
   for (NavigationMap::iterator it = inflight_navigations_.begin();
@@ skipping 482 matching lines @@
   if (total_resources_fetched_from_network > 0) {
     RPP_PREDICTED_HISTOGRAM_PERCENTAGE(
         "PrefetchFromNetworkPercentOfTotalFromNetwork",
         prefetch_network * 100.0 / total_resources_fetched_from_network);
   }
 
 #undef RPP_PREDICTED_HISTOGRAM_PERCENTAGE
 #undef RPP_PREDICTED_HISTOGRAM_COUNTS
 }
 
+bool ResourcePrefetchPredictor::CheckForHistoryService() {
+  if (initialization_state_ == INITIALIZED)
+    return true;
+
+  // Register for HistoryServiceLoading if it is not ready.
+  HistoryService* history_service = HistoryServiceFactory::GetForProfile(
+    profile_, Profile::EXPLICIT_ACCESS);
+  if (history_service && history_service->BackendLoaded()) {
+    // HistoryService is already loaded. Continue with Initialization.
+    OnHistoryAndCacheLoaded();
+    return true;
+  } else if (history_service &&
+      !history_service_observer_.IsObserving(history_service)) {
+    history_service_observer_.Add(history_service);
+  }
+  return false;
+}
+
+void ResourcePrefetchPredictor::OnHistoryServiceLoaded(
+    HistoryService* history_service) {
+  OnHistoryAndCacheLoaded();
+  history_service_observer_.Remove(history_service);
+}
+
 }  // namespace predictors