Rename GDataDirectoryService to DriveResourceMetadata

chrome/browser/chromeos/gdata/gdata_wapi_feed_loader.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_wapi_feed_loader.h"
 
 #include <set>
 
 #include "base/command_line.h"
 #include "base/file_util.h"
@@ skipping 219 matching lines @@
   // When the UI update has started.
   base::TimeTicks start_time;
 
   // Time elapsed since the feed fetching was started.
   base::TimeDelta feed_fetching_elapsed_time;
 
   base::WeakPtrFactory<GetDocumentsUiState> weak_ptr_factory;
 };
 
 GDataWapiFeedLoader::GDataWapiFeedLoader(
-    GDataDirectoryService* directory_service,
+    DriveResourceMetadata* resource_metadata,
     DriveServiceInterface* drive_service,
     DriveWebAppsRegistryInterface* webapps_registry,
     GDataCache* cache,
     scoped_refptr<base::SequencedTaskRunner> blocking_task_runner)
-    : directory_service_(directory_service),
+    : resource_metadata_(resource_metadata),
       drive_service_(drive_service),
       webapps_registry_(webapps_registry),
       cache_(cache),
       blocking_task_runner_(blocking_task_runner),
       weak_ptr_factory_(ALLOW_THIS_IN_INITIALIZER_LIST(this)) {
 }
 
 GDataWapiFeedLoader::~GDataWapiFeedLoader() {
 }
 
@@ skipping 89 matching lines @@
   bool changes_detected = true;
   if (local_changestamp >= account_metadata->largest_changestamp()) {
     if (local_changestamp > account_metadata->largest_changestamp()) {
       LOG(WARNING) << "Cached client feed is fresher than server, client = "
                    << local_changestamp
                    << ", server = "
                    << account_metadata->largest_changestamp();
     }
     // If our cache holds the latest state from the server, change the
     // state to FROM_SERVER.
-    directory_service_->set_origin(
+    resource_metadata_->set_origin(
         initial_origin == FROM_CACHE ? FROM_SERVER : initial_origin);
     changes_detected = false;
   }
 
   // No changes detected, tell the client that the loading was successful.
   if (!changes_detected) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_OK);
     return;
   }
@@ skipping 28 matching lines @@
   if (feed_data.get())
     about_resource = AboutResource::CreateFrom(*feed_data);
 
   if (!about_resource.get()) {
     LoadFromServer(params);
     return;
   }
 
   bool changes_detected = true;
   int64 largest_changestamp = about_resource->largest_change_id();
-  directory_service_->InitializeRootEntry(about_resource->root_folder_id());
+  resource_metadata_->InitializeRootEntry(about_resource->root_folder_id());
 
   if (local_changestamp >= largest_changestamp) {
     if (local_changestamp > largest_changestamp) {
       LOG(WARNING) << "Cached client feed is fresher than server, client = "
                    << local_changestamp
                    << ", server = "
                    << largest_changestamp;
     }
     // If our cache holds the latest state from the server, change the
     // state to FROM_SERVER.
-    directory_service_->set_origin(
+    resource_metadata_->set_origin(
         initial_origin == FROM_CACHE ? FROM_SERVER : initial_origin);
     changes_detected = false;
   }
 
   // No changes detected, tell the client that the loading was successful.
   if (!changes_detected) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_OK);
     return;
   }
@@ skipping 140 matching lines @@
                         base::TimeTicks::Now() - start_time);
   }
 
   GDataFileError error = util::GDataToGDataFileError(status);
   if (error == GDATA_FILE_OK &&
       (!data.get() || data->GetType() != Value::TYPE_DICTIONARY)) {
     error = GDATA_FILE_ERROR_FAILED;
   }
 
   if (error != GDATA_FILE_OK) {
-    directory_service_->set_origin(initial_origin);
+    resource_metadata_->set_origin(initial_origin);
     callback.Run(params, error);
     return;
   }
 
   GURL next_feed_url;
   scoped_ptr<DocumentFeed> current_feed(DocumentFeed::ExtractAndParse(*data));
   if (!current_feed.get()) {
     callback.Run(params, GDATA_FILE_ERROR_FAILED);
     return;
   }
@@ skipping 92 matching lines @@
                         base::TimeTicks::Now() - start_time);
   }
 
   GDataFileError error = util::GDataToGDataFileError(status);
   if (error == GDATA_FILE_OK &&
       (!data.get() || data->GetType() != Value::TYPE_DICTIONARY)) {
     error = GDATA_FILE_ERROR_FAILED;
   }
 
   if (error != GDATA_FILE_OK) {
-    directory_service_->set_origin(initial_origin);
+    resource_metadata_->set_origin(initial_origin);
     callback.Run(params, error);
     return;
   }
 
   GURL next_feed_url;
   scoped_ptr<ChangeList> current_feed(ChangeList::CreateFrom(*data));
   if (!current_feed.get()) {
     callback.Run(params, GDATA_FILE_ERROR_FAILED);
     return;
   }
@@ skipping 119 matching lines @@
 void GDataWapiFeedLoader::LoadFromCache(
     bool should_load_from_server,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   LoadRootFeedParams* params = new LoadRootFeedParams(should_load_from_server,
                                                       callback);
   FilePath path = cache_->GetCacheDirectoryPath(GDataCache::CACHE_TYPE_META);
   if (UseLevelDB()) {
     path = path.Append(kResourceMetadataDBFile);
-    directory_service_->InitFromDB(path, blocking_task_runner_,
+    resource_metadata_->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 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)
+  if (resource_metadata_->origin() == FROM_SERVER)
     return;
 
   // 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());
+    if (resource_metadata_->ParseFromString(params->proto)) {
+      resource_metadata_->set_last_serialized(params->last_modified);
+      resource_metadata_->set_serialized_size(params->proto.size());
     } else {
       params->load_error = GDATA_FILE_ERROR_FAILED;
       LOG(WARNING) << "Parse of cached proto file failed";
     }
   }
 
   ContinueWithInitializedDirectoryService(params, params->load_error);
 }
 
 void GDataWapiFeedLoader::ContinueWithInitializedDirectoryService(
@@ skipping 18 matching lines @@
 
   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 (resource_metadata_->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);
+    resource_metadata_->set_origin(REFRESHING);
   }
 
   // Kick off 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,
-                           directory_service_->largest_changestamp(),
+                           resource_metadata_->largest_changestamp(),
                            callback);
 }
 
 void GDataWapiFeedLoader::SaveFileSystem() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (!ShouldSerializeFileSystemNow(directory_service_->serialized_size(),
-                                    directory_service_->last_serialized())) {
+  if (!ShouldSerializeFileSystemNow(resource_metadata_->serialized_size(),
+                                    resource_metadata_->last_serialized())) {
     return;
   }
 
   if (UseLevelDB()) {
-    directory_service_->SaveToDB();
+    resource_metadata_->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());
+    resource_metadata_->SerializeToString(serialized_proto.get());
+    resource_metadata_->set_last_serialized(base::Time::Now());
+    resource_metadata_->set_serialized_size(serialized_proto->size());
     util::PostBlockingPoolSequencedTask(
         FROM_HERE,
         blocking_task_runner_,
         base::Bind(&SaveProtoOnBlockingPool, path,
                    base::Passed(serialized_proto.Pass())));
   }
 }
 
 GDataFileError GDataWapiFeedLoader::UpdateFromFeed(
     const std::vector<DocumentFeed*>& feed_list,
     int64 start_changestamp,
     int64 root_feed_changestamp) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DVLOG(1) << "Updating directory with a feed";
 
   std::set<FilePath> changed_dirs;
 
-  GDataWapiFeedProcessor feed_processor(directory_service_);
+  GDataWapiFeedProcessor feed_processor(resource_metadata_);
   const GDataFileError error = feed_processor.ApplyFeeds(
       feed_list,
       start_changestamp,
       root_feed_changestamp,
       &changed_dirs);
 
   // Don't send directory content change notification while performing
   // the initial content retrieval.
   const bool should_notify_directory_changed = (start_changestamp != 0);
   if (should_notify_directory_changed) {
     for (std::set<FilePath>::iterator dir_iter = changed_dirs.begin();
         dir_iter != changed_dirs.end(); ++dir_iter) {
       FOR_EACH_OBSERVER(Observer, observers_,
                         OnDirectoryChanged(*dir_iter));
     }
   }
 
   return error;
 }
 
 }  // namespace gdata