Retry: Prepopulate primary origin's directory database if possible.

Before (with primary origin patch)
140~170 ms

After (excluding 1st launch for a new profile)
30~90 ms

The very first launch for a fresh profile is still slow as
it needs to go through full initialization.

BUG=306030
TEST=manual
TEST=valgrind

Review URL: https://codereview.chromium.org/44463002

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@231294 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 67 insertions, 10 deletions

diff --git a/webkit/browser/fileapi/obfuscated_file_util.cc b/webkit/browser/fileapi/obfuscated_file_util.cc
index 642d278..46d733d 100644
--- a/webkit/browser/fileapi/obfuscated_file_util.cc
+++ b/webkit/browser/fileapi/obfuscated_file_util.cc
@@ -948,6 +948,37 @@ int64 ObfuscatedFileUtil::ComputeFilePathCost(const base::FilePath& path) {
   return UsageForPath(VirtualPath::BaseName(path).value().size());
 }
 
+void ObfuscatedFileUtil::MaybePrepopulateDatabase(
+    const std::vector<std::string>& type_strings_to_prepopulate) {
+  SandboxPrioritizedOriginDatabase database(file_system_directory_);
+  std::string origin_string = database.GetPrimaryOrigin();
+  if (origin_string.empty() || !database.HasOriginPath(origin_string))
+    return;
+  const GURL origin = webkit_database::GetOriginFromIdentifier(origin_string);
+
+  // Prepopulate the directory database(s) if and only if this instance
+  // has primary origin and the directory database is already there.
+  for (size_t i = 0; i < type_strings_to_prepopulate.size(); ++i) {
+    const std::string type_string = type_strings_to_prepopulate[i];
+    // Only handles known types.
+    if (!ContainsKey(known_type_strings_, type_string))
+      continue;
+    PlatformFileError error = base::PLATFORM_FILE_ERROR_FAILED;
+    base::FilePath path = GetDirectoryForOriginAndType(
+        origin, type_string, false, &error);
+    if (error != base::PLATFORM_FILE_OK)
+      continue;
+    scoped_ptr<SandboxDirectoryDatabase> db(new SandboxDirectoryDatabase(path));
+    if (db->Init(SandboxDirectoryDatabase::FAIL_ON_CORRUPTION)) {
+      directories_[GetDirectoryDatabaseKey(origin, type_string)] = db.release();
+      MarkUsed();
+      // Don't populate more than one database, as it may rather hurt
+      // performance.
+      break;
+    }
+  }
+}
+
 base::FilePath ObfuscatedFileUtil::GetDirectoryForURL(
     const FileSystemURL& url,
     bool create,
diff --git a/webkit/browser/fileapi/obfuscated_file_util.h b/webkit/browser/fileapi/obfuscated_file_util.h
index 94bbb6c..e25a99e 100644
--- a/webkit/browser/fileapi/obfuscated_file_util.h
+++ b/webkit/browser/fileapi/obfuscated_file_util.h
@@ -8,6 +8,7 @@
 #include <map>
 #include <set>
 #include <string>
+#include <vector>
 
 #include "base/callback_forward.h"
 #include "base/files/file_path.h"
@@ -216,6 +217,13 @@ class WEBKIT_STORAGE_BROWSER_EXPORT_PRIVATE ObfuscatedFileUtil
   // on each path segment and add the results.
   static int64 ComputeFilePathCost(const base::FilePath& path);
 
+  // Tries to prepopulate directory database for the given type strings.
+  // This tries from the first one in the given type_strings and stops
+  // once it succeeds to do so for one database (i.e. it prepopulates
+  // at most one database).
+  void MaybePrepopulateDatabase(
+      const std::vector<std::string>& type_strings_to_prepopulate);
+
  private:
   typedef SandboxDirectoryDatabase::FileId FileId;
   typedef SandboxDirectoryDatabase::FileInfo FileInfo;
diff --git a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
index 6f1ff0e7..593e1a0 100644
--- a/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
+++ b/webkit/browser/fileapi/sandbox_file_system_backend_delegate.cc
@@ -43,6 +43,11 @@ const char kTemporaryDirectoryName[] = "t";
 const char kPersistentDirectoryName[] = "p";
 const char kSyncableDirectoryName[] = "s";
 
+const char* kPrepopulateTypes[] = {
+  kPersistentDirectoryName,
+  kTemporaryDirectoryName
+};
+
 enum FileSystemError {
   kOK = 0,
   kIncognito,
@@ -129,6 +134,12 @@ void DidOpenFileSystem(
   callback.Run(*error);
 }
 
+template <typename T>
+void DeleteSoon(base::SequencedTaskRunner* runner, T* ptr) {
+  if (!runner->DeleteSoon(FROM_HERE, ptr))
+    delete ptr;
+}
+
 }  // namespace
 
 const base::FilePath::CharType
@@ -178,21 +189,28 @@ SandboxFileSystemBackendDelegate::SandboxFileSystemBackendDelegate(
       file_system_options_(file_system_options),
       is_filesystem_opened_(false),
       weak_factory_(this) {
+  // Prepopulate database only if it can run asynchronously (i.e. the current
+  // thread is not file_task_runner). Usually this is the case but may not
+  // in test code.
+  if (!file_task_runner_->RunsTasksOnCurrentThread()) {
+    std::vector<std::string> types_to_prepopulate(
+        &kPrepopulateTypes[0],
+        &kPrepopulateTypes[arraysize(kPrepopulateTypes)]);
+    file_task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&ObfuscatedFileUtil::MaybePrepopulateDatabase,
+                  base::Unretained(obfuscated_file_util()),
+                  types_to_prepopulate));
+  }
 }
 
 SandboxFileSystemBackendDelegate::~SandboxFileSystemBackendDelegate() {
   io_thread_checker_.DetachFromThread();
+
   if (!file_task_runner_->RunsTasksOnCurrentThread()) {
-    AsyncFileUtil* sandbox_file_util = sandbox_file_util_.release();
-    SandboxQuotaObserver* quota_observer = quota_observer_.release();
-    FileSystemUsageCache* file_system_usage_cache =
-        file_system_usage_cache_.release();
-    if (!file_task_runner_->DeleteSoon(FROM_HERE, sandbox_file_util))
-      delete sandbox_file_util;
-    if (!file_task_runner_->DeleteSoon(FROM_HERE, quota_observer))
-      delete quota_observer;
-    if (!file_task_runner_->DeleteSoon(FROM_HERE, file_system_usage_cache))
-      delete file_system_usage_cache;
+    DeleteSoon(file_task_runner_.get(), sandbox_file_util_.release());
+    DeleteSoon(file_task_runner_.get(), quota_observer_.release());
+    DeleteSoon(file_task_runner_.get(), file_system_usage_cache_.release());
   }
 }