Database support for GDataDirectoryService.

chrome/browser/chromeos/gdata/gdata_file_system.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/chromeos/gdata/gdata_file_system.h"
 
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
+#include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_reader.h"
 #include "base/json/json_writer.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/platform_file.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/gdata/drive_webapps_registry.h"
 #include "chrome/browser/chromeos/gdata/gdata.pb.h"
 #include "chrome/browser/chromeos/gdata/gdata_documents_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_download_observer.h"
 #include "chrome/browser/chromeos/gdata/gdata_protocol_handler.h"
 #include "chrome/browser/chromeos/gdata/gdata_system_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_util.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/chrome_switches.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/notification_details.h"
 #include "net/base/mime_util.h"
 
 using content::BrowserThread;
 
 namespace gdata {
 namespace {
 
 const char kMimeTypeJson[] = "application/json";
 const char kMimeTypeOctetStream[] = "application/octet-stream";
 
 const FilePath::CharType kAccountMetadataFile[] =
     FILE_PATH_LITERAL("account_metadata.json");
 const FilePath::CharType kFilesystemProtoFile[] =
     FILE_PATH_LITERAL("file_system.pb");
+const FilePath::CharType kResourceMetadataDBFile[] =
+    FILE_PATH_LITERAL("resource_metadata.db");
 
 const char kEmptyFilePath[] = "/dev/null";
 
 // GData update check interval (in seconds).
 #ifndef NDEBUG
 const int kGDataUpdateCheckIntervalInSec = 5;
 #else
 const int kGDataUpdateCheckIntervalInSec = 60;
 #endif
 
@@ skipping 13 matching lines @@
     {-1,  1},    // Any size, dump if older than 1 minute.
 #else
     {0.5, 0},    // Less than 0.5MB, dump immediately.
     {1.0, 15},   // Less than 1.0MB, dump after 15 minutes.
     {2.0, 30},
     {4.0, 60},
     {-1,  120},  // Any size, dump if older than 120 minutes.
 #endif
 };
 
-// Defines set of parameters sent to callback OnProtoLoaded().
-struct LoadRootFeedParams {
-  LoadRootFeedParams(
-        FilePath search_file_path,
-        bool should_load_from_server,
-        const FindEntryCallback& callback)
-        : search_file_path(search_file_path),
-          should_load_from_server(should_load_from_server),
-          load_error(GDATA_FILE_OK),
-          callback(callback) {
-    }
-  ~LoadRootFeedParams() {
-  }
-
-  FilePath search_file_path;
-  bool should_load_from_server;
-  std::string proto;
-  GDataFileError load_error;
-  base::Time last_modified;
-  const FindEntryCallback callback;
-};
-
 // Returns true if file system is due to be serialized on disk based on it
 // |serialized_size| and |last_serialized| timestamp.
 bool ShouldSerializeFileSystemNow(size_t serialized_size,
                                   const base::Time& last_serialized) {
   const double size_in_mb = serialized_size / 1048576.0;
   const int last_proto_dump_in_min =
       (base::Time::Now() - last_serialized).InMinutes();
   for (size_t i = 0; i < arraysize(kSerializeTimetable); i++) {
     if ((size_in_mb < kSerializeTimetable[i].size ||
          kSerializeTimetable[i].size == -1) &&
@@ skipping 153 matching lines @@
     LOG(WARNING) << "GData metadata file can't be stored at "
                  << file_path.value();
     if (!file_util::Delete(file_path, true)) {
       LOG(WARNING) << "GData metadata file can't be deleted at "
                    << file_path.value();
       return;
     }
   }
 }
 
+bool UseLevelDB() {
+  return CommandLine::ForCurrentProcess()->HasSwitch(
+      switches::kUseLevelDBForGData);
+}
+
 // Gets the file size of |local_file|.
 void GetLocalFileSizeOnBlockingPool(const FilePath& local_file,
                                     GDataFileError* error,
                                     int64* file_size) {
   DCHECK(error);
   DCHECK(file_size);
 
   *file_size = 0;
   *error = file_util::GetFileSize(local_file, file_size) ?
       GDATA_FILE_OK :
@@ skipping 701 matching lines @@
   directory_service_->FindEntryByPathAndRunSync(search_file_path, callback);
 }
 
 void GDataWapiFeedLoader::ReloadFromServerIfNeeded(
     ContentOrigin initial_origin,
     int local_changestamp,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
+  DVLOG(1) << "ReloadFeedFromServerIfNeeded local_changestamp="
+           << local_changestamp << ", initial_origin=" << initial_origin;
+
   // First fetch the latest changestamp to see if there were any new changes
   // there at all.
   documents_service_->GetAccountMetadata(
       base::Bind(&GDataWapiFeedLoader::OnGetAccountMetadata,
                  weak_ptr_factory_.GetWeakPtr(),
                  initial_origin,
                  local_changestamp,
                  search_file_path,
                  callback));
 }
@@ skipping 143 matching lines @@
                          params->root_feed_changestamp);
 
   if (error != GDATA_FILE_OK) {
     if (!params->callback.is_null())
       params->callback.Run(error, NULL);
 
     return;
   }
 
   // Save file system metadata to disk.
-  SaveFileSystemAsProto();
+  SaveFileSystem();
 
   // If we had someone to report this too, then this retrieval was done in a
   // context of search... so continue search.
   if (!params->callback.is_null()) {
     directory_service_->FindEntryByPathAndRunSync(params->search_file_path,
                                                   params->callback);
   }
 
   FOR_EACH_OBSERVER(Observer, observers_, OnFeedFromServerLoaded());
 }
@@ skipping 1803 matching lines @@
     }
   }
 }
 
 void GDataWapiFeedLoader::LoadFromCache(
     bool should_load_from_server,
     const FilePath& search_file_path,
     const FindEntryCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  const FilePath path =
-      cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
-          kFilesystemProtoFile);
   LoadRootFeedParams* params = new LoadRootFeedParams(search_file_path,
                                                       should_load_from_server,
                                                       callback);
-  BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
-      base::Bind(&LoadProtoOnBlockingPool, path, params),
-      base::Bind(&GDataWapiFeedLoader::OnProtoLoaded,
-                 weak_ptr_factory_.GetWeakPtr(),
-                 base::Owned(params)));
+  FilePath path = cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META);
+  if (UseLevelDB()) {
+    path = path.Append(kResourceMetadataDBFile);
+    directory_service_->InitFromDB(path, blocking_task_runner_,
+        base::Bind(
+            &GDataWapiFeedLoader::ContinueWithInitializedDirectoryService,
+            weak_ptr_factory_.GetWeakPtr(),
+            base::Owned(params)));
+  } else {
+    path = path.Append(kFilesystemProtoFile);
+    BrowserThread::GetBlockingPool()->PostTaskAndReply(FROM_HERE,
+        base::Bind(&LoadProtoOnBlockingPool, path, params),
+        base::Bind(&GDataWapiFeedLoader::OnProtoLoaded,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   base::Owned(params)));
+  }
 }
 
 void GDataFileSystem::OnDirectoryChanged(const FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(directory_path));
 }
 
 void GDataFileSystem::OnDocumentFeedFetched(int num_accumulated_entries) {
@@ skipping 31 matching lines @@
                                       root_feed_changestamp);
 }
 
 void GDataWapiFeedLoader::OnProtoLoaded(LoadRootFeedParams* params) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // If we have already received updates from the server, bail out.
   if (directory_service_->origin() == FROM_SERVER)
     return;
 
-  int local_changestamp = 0;
   // Update directory structure only if everything is OK and we haven't yet
   // received the feed from the server yet.
   if (params->load_error == GDATA_FILE_OK) {
     DVLOG(1) << "ParseFromString";
     if (directory_service_->ParseFromString(params->proto)) {
       directory_service_->set_last_serialized(params->last_modified);
       directory_service_->set_serialized_size(params->proto.size());
-      local_changestamp = directory_service_->largest_changestamp();
     } else {
       params->load_error = GDATA_FILE_ERROR_FAILED;
       LOG(WARNING) << "Parse of cached proto file failed";
     }
   }
 
+  ContinueWithInitializedDirectoryService(params, params->load_error);
+}
+
+void GDataWapiFeedLoader::ContinueWithInitializedDirectoryService(
+    LoadRootFeedParams* params,
+    GDataFileError error) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DVLOG(1) << "Time elapsed to load directory service from disk="
+           << (base::Time::Now() - params->load_start_time).InMilliseconds()
+           << " milliseconds";
+
   FindEntryCallback callback = params->callback;
   // If we got feed content from cache, try search over it.
-  if (params->load_error == GDATA_FILE_OK && !callback.is_null()) {
+  if (error == GDATA_FILE_OK && !callback.is_null()) {
     // Continue file content search operation if the delegate hasn't terminated
     // this search branch already.
     directory_service_->FindEntryByPathAndRunSync(params->search_file_path,
                                                   callback);
     callback.Reset();
   }
 
   if (!params->should_load_from_server)
     return;
 
   // Decide the |initial_origin| to pass to ReloadFromServerIfNeeded().
   // This is used to restore directory content origin to its initial value when
   // we fail to retrieve the feed from server.
   // By default, if directory content is not yet initialized, restore content
   // origin to UNINITIALIZED in case of failure.
   ContentOrigin initial_origin = UNINITIALIZED;
   if (directory_service_->origin() != INITIALIZING) {
     // If directory content is already initialized, restore content origin
     // to FROM_CACHE in case of failure.
     initial_origin = FROM_CACHE;
     directory_service_->set_origin(REFRESHING);
   }
 
   // Kick of the retrieval of the feed from server. If we have previously
   // |reported| to the original callback, then we just need to refresh the
   // content without continuing search upon operation completion.
   ReloadFromServerIfNeeded(initial_origin,
-                           local_changestamp,
+                           directory_service_->largest_changestamp(),
                            params->search_file_path,
                            callback);
 }
 
-void GDataWapiFeedLoader::SaveFileSystemAsProto() {
+void GDataWapiFeedLoader::SaveFileSystem() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  DVLOG(1) << "SaveFileSystemAsProto";
-
   if (!ShouldSerializeFileSystemNow(directory_service_->serialized_size(),
                                     directory_service_->last_serialized())) {
     return;
   }
 
-  const FilePath path =
-      cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
-          kFilesystemProtoFile);
-  scoped_ptr<std::string> serialized_proto(new std::string());
-  directory_service_->SerializeToString(serialized_proto.get());
-  directory_service_->set_last_serialized(base::Time::Now());
-  directory_service_->set_serialized_size(serialized_proto->size());
-  PostBlockingPoolSequencedTask(
-      FROM_HERE,
-      blocking_task_runner_,
-      base::Bind(&SaveProtoOnBlockingPool, path,
-                 base::Passed(serialized_proto.Pass())));
+  if (UseLevelDB()) {
+    directory_service_->SaveToDB();
+  } else {
+    const FilePath path =
+        cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META).Append(
+            kFilesystemProtoFile);
+    scoped_ptr<std::string> serialized_proto(new std::string());
+    directory_service_->SerializeToString(serialized_proto.get());
+    directory_service_->set_last_serialized(base::Time::Now());
+    directory_service_->set_serialized_size(serialized_proto->size());
+    PostBlockingPoolSequencedTask(
+        FROM_HERE,
+        blocking_task_runner_,
+        base::Bind(&SaveProtoOnBlockingPool, path,
+                   base::Passed(serialized_proto.Pass())));
+  }
 }
 
 void GDataFileSystem::OnFilePathUpdated(const FileOperationCallback& callback,
                                         GDataFileError error,
                                         const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!callback.is_null())
     callback.Run(error);
 }
 
@@ skipping 374 matching lines @@
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnFileSystemBeingUnmounted());
 }
 
 void GDataFileSystem::RunAndNotifyInitialLoadFinished(
     const FindEntryCallback& callback,
     GDataFileError error,
     GDataEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  DVLOG(1) << "Initial load finished";
   if (!callback.is_null())
     callback.Run(error, entry);
 
+  DVLOG(1) << "RunAndNotifyInitialLoadFinished";
+
   // Notify the observers that root directory has been initialized.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnInitialLoadFinished());
 }
 
 GDataFileError GDataFileSystem::AddNewDirectory(
     const FilePath& directory_path, base::Value* entry_value) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (!entry_value)
@@ skipping 642 matching lines @@
   }
 
   PlatformFileInfoProto entry_file_info;
   GDataEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   if (!callback.is_null())
     callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata