Delay predictor DB access until after the first main frame load complete.

chrome/browser/predictors/autocomplete_action_predictor.cc

 // Copyright (c) 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/predictors/autocomplete_action_predictor.h"
 
 #include <math.h>
 
 #include <vector>
 
@@ skipping 76 matching lines @@
   if (profile_->IsOffTheRecord()) {
     main_profile_predictor_ = AutocompleteActionPredictorFactory::GetForProfile(
         profile_->GetOriginalProfile());
     DCHECK(main_profile_predictor_);
     main_profile_predictor_->incognito_predictor_ = this;
     if (main_profile_predictor_->initialized_)
       CopyFromMainProfile();
   } else {
     // Request the in-memory database from the history to force it to load so
     // it's available as soon as possible.
     HistoryService* history_service = HistoryServiceFactory::GetForProfile(

[Shishir, 2012/08/30 18:51:08]

Does it make sense to move this to onload too?

[dominich, 2012/08/30 18:53:57]

In most cases that I've seen, it's already loaded at this point so it's not the
bottleneck. It's certainly something that could be done but it would complicate
the startup of this object significantly.

If the change in this CL doesn't significantly reduce the startup time (which I
believe it will) then I can revisit this.

         profile_, Profile::EXPLICIT_ACCESS);
     if (history_service)
       history_service->InMemoryDatabase();
 
     table_ =
         PredictorDatabaseFactory::GetForProfile(profile_)->autocomplete_table();
 
-    // Create local caches using the database as loaded. We will garbage collect
-    // rows from the caches and the database once the history service is
-    // available.
-    std::vector<AutocompleteActionPredictorTable::Row>* rows =
-        new std::vector<AutocompleteActionPredictorTable::Row>();
-    content::BrowserThread::PostTaskAndReply(content::BrowserThread::DB,
-        FROM_HERE,
-        base::Bind(&AutocompleteActionPredictorTable::GetAllRows, table_, rows),
-        base::Bind(&AutocompleteActionPredictor::CreateCaches, AsWeakPtr(),
-                   base::Owned(rows)));
+    // Observe all main frame loads so we can wait for the first to complete
+    // before accessing DB and IO threads to build the local cache.
+    notification_registrar_.Add(this,
+                                content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
+                                content::NotificationService::AllSources());
   }
 }
 
 AutocompleteActionPredictor::~AutocompleteActionPredictor() {
   if (main_profile_predictor_)
     main_profile_predictor_->incognito_predictor_ = NULL;
   else if (incognito_predictor_)
     incognito_predictor_->main_profile_predictor_ = NULL;
   if (prerender_handle_.get())
     prerender_handle_->OnCancel();
@@ skipping 101 matching lines @@
 bool AutocompleteActionPredictor::IsPreconnectable(
     const AutocompleteMatch& match) {
   return IsAutocompleteMatchSearchType(match);
 }
 
 void AutocompleteActionPredictor::Observe(
     int type,
     const content::NotificationSource& source,
     const content::NotificationDetails& details) {
   switch (type) {
+    case content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME:
+      CreateLocalCachesFromDatabase();
+      notification_registrar_.Remove(
+          this,
+          content::NOTIFICATION_LOAD_COMPLETED_MAIN_FRAME,
+          content::NotificationService::AllSources());
+      break;
+
     case chrome::NOTIFICATION_HISTORY_URLS_DELETED: {
       DCHECK(initialized_);
       const content::Details<const history::URLsDeletedDetails>
           urls_deleted_details =
               content::Details<const history::URLsDeletedDetails>(details);
       if (urls_deleted_details->all_history)
         DeleteAllRows();
       else
         DeleteRowsWithURLs(urls_deleted_details->rows);
       break;
@@ skipping 19 matching lines @@
                                      content::Source<Profile>(profile_));
       break;
     }
 
     default:
       NOTREACHED() << "Unexpected notification observed.";
       break;
   }
 }
 
+void AutocompleteActionPredictor::CreateLocalCachesFromDatabase() {
+  // Create local caches using the database as loaded. We will garbage collect
+  // rows from the caches and the database once the history service is
+  // available.
+  std::vector<AutocompleteActionPredictorTable::Row>* rows =
+      new std::vector<AutocompleteActionPredictorTable::Row>();
+  content::BrowserThread::PostTaskAndReply(content::BrowserThread::DB,
+      FROM_HERE,
+      base::Bind(&AutocompleteActionPredictorTable::GetAllRows, table_, rows),
+      base::Bind(&AutocompleteActionPredictor::CreateCaches, AsWeakPtr(),
+                 base::Owned(rows)));
+}
+
 void AutocompleteActionPredictor::DeleteAllRows() {
   if (!initialized_)
     return;
 
   db_cache_.clear();
   db_id_cache_.clear();
 
   if (table_.get()) {
     content::BrowserThread::PostTask(content::BrowserThread::DB, FROM_HERE,
         base::Bind(&AutocompleteActionPredictorTable::DeleteAllRows,
@@ skipping 289 matching lines @@
   return number_of_hits / (number_of_hits + value.number_of_misses);
 }
 
 AutocompleteActionPredictor::TransitionalMatch::TransitionalMatch() {
 }
 
 AutocompleteActionPredictor::TransitionalMatch::~TransitionalMatch() {
 }
 
 }  // namespace predictors