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 10 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 660 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 142 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 1745 matching lines @@
   if (!callback.is_null())
     callback.Run(params, error);
 }
 
 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_,
+        &params->load_error, base::Bind(

[satorux1, 2012/08/03 22:17:26]

I think I was confused about this |load_error| parameter.

Can you check params->load_error before calling InitFromDB? If this is not OK
here, we don't have to call InitFromDB, right?

Then, I think we can get rid of the error parameter from InitFromDB, because 

[achuithb, 2012/08/03 22:25:58]

because? The suspense is killing me ;)

We need to set the error in the case where the db is not found because we use
this as a signal to let the user know we are refreshing drive for the first
time.

error is definitely OK over here since we just created the param. I'll replace
the runtime check with a DCHECK instead.

[satorux1, 2012/08/03 22:33:30]

oops, here's what I was thinking:

Instead of passing GDataFileError* to InitFromDB(), I think the callback should
get the error as a parameter, then modify params->load_error as needed in the
callbck function

[achuithb, 2012/08/03 23:27:35]

Done.

+            &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);
+}
+
+void GDataWapiFeedLoader::ContinueWithInitializedDirectoryService(
+    LoadRootFeedParams* params) {
+  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()) {
     // 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();
   }
 
@@ skipping 10 matching lines @@
     // 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 356 matching lines @@
     LOG(ERROR) << "Entry for the existing file not found: " << resource_id;
   }
 }
 
 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