Preload the visited link db on the file thread.

chrome/browser/profile.cc

 // Copyright (c) 2009 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/profile.h"
 
 #include "app/theme_provider.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
@@ skipping 107 matching lines @@
   return base.Append(chrome::kMediaCacheDirname);
 }
 
 bool HasACacheSubdir(const FilePath &dir) {
   return file_util::PathExists(GetCachePath(dir)) ||
          file_util::PathExists(GetMediaCachePath(dir));
 }
 
 }  // namespace
 
+// This helper class owns the VisitedLinkMaster and exposes a way to load it
+// from on the file thread.
+class VisitedLinkCreator
+    : public base::RefCountedThreadSafe<VisitedLinkCreator> {
+ public:
+  enum LoadState {
+    NOT_LOADED,
+    FILE_LOAD_FAILED,
+    LOAD_FINISHED
+  };
+
+  explicit VisitedLinkCreator(Profile* profile)
+      : listener_(new VisitedLinkEventListener()),
+        profile_(profile),
+        load_state_(NOT_LOADED) {
+    visited_link_master_.reset(new VisitedLinkMaster(listener_.get(),
+                                                     profile_));
+  }
+
+  // Preload the visited link master on the file thread.
+  void Preload() {
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+    ChromeThread::PostTask(ChromeThread::FILE, FROM_HERE, NewRunnableMethod(
+        this, &VisitedLinkCreator::LoadBackground));
+  }
+
+  // This method can return NULL if for some reason we can't initialize the
+  // visited link master.
+  VisitedLinkMaster* GetMaster() {
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::UI));
+    // Go ahead and try to load the VisitedLink table.  If the data was
+    // preloaded, Load() does nothing.
+    AutoLock l(lock_);
+    if (LOAD_FINISHED != load_state_) {
+      bool success = false;
+      if (FILE_LOAD_FAILED == load_state_) {
+        success = visited_link_master_->InitFromScratch();
+      } else if (NOT_LOADED == load_state_) {
+        // We haven't tried to load from file yet, so go ahead and do that.
+        success = visited_link_master_->Init();
+      }
+
+      if (!success) {
+        NOTREACHED() << "Failed to init visited link master.";
+        visited_link_master_.reset();
+      }
+      load_state_ = LOAD_FINISHED;
+    }
+
+    // We don't need to lock here because after Load() has been called, we
+    // never change vistied_link_master_.
+    return visited_link_master_.get();
+  }
+
+ private:
+  // Tries to load the visited link database from the UI thread.
+  void LoadBackground() {
+    DCHECK(ChromeThread::CurrentlyOn(ChromeThread::FILE));
+    AutoLock l(lock_);
+    if (NOT_LOADED != load_state_)
+      return;
+
+    // We only want to try to load the data from a file (it's not thread safe
+    // to InitFromScratch on the file thread).
+    load_state_ = visited_link_master_->InitFromFile() ? LOAD_FINISHED
+                                                       : FILE_LOAD_FAILED;
+  }
+
+  scoped_ptr<VisitedLinkMaster::Listener> listener_;
+  Profile* profile_;
+
+  // This lock protects visited_link_master_ and load_state_.
+  Lock lock_;
+  scoped_ptr<VisitedLinkMaster> visited_link_master_;
+  // Once created_ is true, we can stop trying to create and init the
+  // VisitedLinkMaster.
+  LoadState load_state_;
+
+  DISALLOW_COPY_AND_ASSIGN(VisitedLinkCreator);
+};
+
 // A pointer to the request context for the default profile.  See comments on
 // Profile::GetDefaultRequestContext.
 URLRequestContextGetter* Profile::default_request_context_;
 
 static void CleanupRequestContext(ChromeURLRequestContextGetter* context) {
   if (context)
     context->CleanupOnUIThread();
 }
 
 // static
@@ skipping 69 matching lines @@
 
   virtual ~OffTheRecordProfileImpl() {
     CleanupRequestContext(request_context_);
     CleanupRequestContext(extensions_request_context_);
   }
 
   virtual ProfileId GetRuntimeId() {
     return reinterpret_cast<ProfileId>(this);
   }
 
-  virtual FilePath GetPath() { return profile_->GetPath(); }
+  virtual FilePath GetPath() {
+    return profile_->GetPath();
+  }
 
   virtual bool IsOffTheRecord() {
     return true;
   }
 
   virtual Profile* GetOffTheRecordProfile() {
     return this;
   }
 
   virtual void DestroyOffTheRecordProfile() {
@@ skipping 10 matching lines @@
       db_tracker_ = new webkit_database::DatabaseTracker(FilePath());
     return db_tracker_;
   }
 
   virtual VisitedLinkMaster* GetVisitedLinkMaster() {
     // We don't provide access to the VisitedLinkMaster when we're OffTheRecord
     // because we don't want to leak the sites that the user has visited before.
     return NULL;
   }
 
+  virtual void PreloadVisitedLinkMaster() {}
+
   virtual ExtensionsService* GetExtensionsService() {
     return NULL;
   }
 
   virtual UserScriptMaster* GetUserScriptMaster() {
     return profile_->GetUserScriptMaster();
   }
 
   virtual ExtensionDevToolsManager* GetExtensionDevToolsManager() {
     return NULL;
@@ skipping 302 matching lines @@
 
   // The main database tracker for this profile.
   // Should be used only on the file thread.
   scoped_refptr<webkit_database::DatabaseTracker> db_tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(OffTheRecordProfileImpl);
 };
 
 ProfileImpl::ProfileImpl(const FilePath& path)
     : path_(path),
-      visited_link_event_listener_(new VisitedLinkEventListener()),
       extension_devtools_manager_(NULL),
       request_context_(NULL),
       media_request_context_(NULL),
       extensions_request_context_(NULL),
       host_zoom_map_(NULL),
       blacklist_manager_(NULL),
       blacklist_manager_created_(false),
       history_service_created_(false),
       favicon_service_created_(false),
       created_web_data_service_(false),
@@ skipping 226 matching lines @@
   return this;
 }
 
 webkit_database::DatabaseTracker* ProfileImpl::GetDatabaseTracker() {
   if (!db_tracker_)
     db_tracker_ = new webkit_database::DatabaseTracker(GetPath());
   return db_tracker_;
 }
 
 VisitedLinkMaster* ProfileImpl::GetVisitedLinkMaster() {
-  if (!visited_link_master_.get()) {
-    scoped_ptr<VisitedLinkMaster> visited_links(
-      new VisitedLinkMaster(visited_link_event_listener_.get(), this));
-    if (!visited_links->Init())
-      return NULL;
-    visited_link_master_.swap(visited_links);
+  if (!visited_link_creator_.get())
+    visited_link_creator_ = new VisitedLinkCreator(this);
+  return visited_link_creator_->GetMaster();
+}
+
+void ProfileImpl::PreloadVisitedLinkMaster() {
+  if (!visited_link_creator_.get()) {
+    visited_link_creator_ = new VisitedLinkCreator(this);
+    visited_link_creator_->Preload();
   }
-
-  return visited_link_master_.get();
 }
 
 ExtensionsService* ProfileImpl::GetExtensionsService() {
   return extensions_service_.get();
 }
 
 UserScriptMaster* ProfileImpl::GetUserScriptMaster() {
   return user_script_master_.get();
 }
 
@@ skipping 484 matching lines @@
   }
   if (!sync_service_.get())
     InitSyncService();
   return sync_service_.get();
 }
 
 void ProfileImpl::InitSyncService() {
   sync_service_.reset(new ProfileSyncService(this));
   sync_service_->Initialize();
 }