Rename GDataDirectoryService to DriveResourceMetadata

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"
@@ skipping 419 matching lines @@
       ui_weak_ptr_(ui_weak_ptr_factory_.GetWeakPtr()) {
   // Should be created from the file browser extension API on UI thread.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 }
 
 void GDataFileSystem::Initialize() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   drive_service_->Initialize(profile_);
 
-  directory_service_.reset(new GDataDirectoryService);
-  feed_loader_.reset(new GDataWapiFeedLoader(directory_service_.get(),
+  resource_metadata_.reset(new DriveResourceMetadata);
+  feed_loader_.reset(new GDataWapiFeedLoader(resource_metadata_.get(),
                                              drive_service_,
                                              webapps_registry_,
                                              cache_,
                                              blocking_task_runner_));
   feed_loader_->AddObserver(this);
 
   PrefService* pref_service = profile_->GetPrefs();
   hide_hosted_docs_ = pref_service->GetBoolean(prefs::kDisableGDataHostedFiles);
 
   InitializePreferenceObserver();
 }
 
 void GDataFileSystem::CheckForUpdates() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  ContentOrigin initial_origin = directory_service_->origin();
+  ContentOrigin initial_origin = resource_metadata_->origin();
   if (initial_origin == FROM_SERVER) {
-    directory_service_->set_origin(REFRESHING);
+    resource_metadata_->set_origin(REFRESHING);
     feed_loader_->ReloadFromServerIfNeeded(
         initial_origin,
-        directory_service_->largest_changestamp(),
+        resource_metadata_->largest_changestamp(),
         base::Bind(&GDataFileSystem::OnUpdateChecked,
                    ui_weak_ptr_,
                    initial_origin));
   }
 }
 
 void GDataFileSystem::OnUpdateChecked(ContentOrigin initial_origin,
                                       GDataFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK)
-    directory_service_->set_origin(initial_origin);
+    resource_metadata_->set_origin(initial_origin);
 }
 
 GDataFileSystem::~GDataFileSystem() {
   // This should be called from UI thread, from GDataSystemService shutdown.
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->RemoveObserver(this);
 
   // Cancel all the in-flight operations.
   // This asynchronously cancels the URL fetch operations.
@@ skipping 49 matching lines @@
                  resource_id,
                  CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::GetEntryInfoByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetEntryInfoWithFilePathCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  directory_service_->GetEntryByResourceIdAsync(resource_id,
+  resource_metadata_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::GetEntryInfoByEntryOnUIThread,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::GetEntryInfoByEntryOnUIThread(
     const GetEntryInfoWithFilePathCallback& callback,
     DriveEntry* entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (entry) {
     scoped_ptr<DriveEntryProto> entry_proto(new DriveEntryProto);
     entry->ToProtoFull(entry_proto.get());
     CheckLocalModificationAndRun(
         entry_proto.Pass(),
         base::Bind(&RunGetEntryInfoWithFilePathCallback,
                    callback, entry->GetFilePath()));
   } else {
     callback.Run(GDATA_FILE_ERROR_NOT_FOUND,
                  FilePath(),
                  scoped_ptr<DriveEntryProto>());
   }
 }
 
 void GDataFileSystem::LoadFeedIfNeeded(const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (directory_service_->origin() == INITIALIZING) {
+  if (resource_metadata_->origin() == INITIALIZING) {
     // If root feed is not initialized but the initialization process has
     // already started, add an observer to execute the remaining task after
     // the end of the initialization.
     AddObserver(new InitialLoadObserver(this,
                                         base::Bind(callback, GDATA_FILE_OK)));
     return;
-  } else if (directory_service_->origin() == UNINITIALIZED) {
+  } else if (resource_metadata_->origin() == UNINITIALIZED) {
     // Load root feed from this disk cache. Upon completion, kick off server
     // fetching.
-    directory_service_->set_origin(INITIALIZING);
+    resource_metadata_->set_origin(INITIALIZING);
     feed_loader_->LoadFromCache(
         true,  // should_load_from_server
         base::Bind(&GDataFileSystem::NotifyInitialLoadFinishedAndRun,
                    ui_weak_ptr_,
                    callback));
     return;
   }
 
   // The feed has already been loaded, so we have nothing to do, but post a
   // task to the same thread, rather than calling it here, as
@@ skipping 19 matching lines @@
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemote(
     const FilePath& local_src_file_path,
     const FilePath& remote_dest_file_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // Make sure the destination directory exists.
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       remote_dest_file_path.DirName(),
       base::Bind(
           &GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo,
           ui_weak_ptr_,
           local_src_file_path,
           remote_dest_file_path,
           callback));
 }
 
 void GDataFileSystem::TransferFileFromLocalToRemoteAfterGetEntryInfo(
@@ skipping 99 matching lines @@
   DCHECK(content_type);
 
   if (*error != GDATA_FILE_OK) {
     if (!params.callback.is_null())
       params.callback.Run(*error);
 
     return;
   }
 
   // Make sure the destination directory exists.
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       params.remote_file_path.DirName(),
       base::Bind(
           &GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           params,
           *file_size,
           *content_type));
 }
 
 void GDataFileSystem::StartFileUploadOnUIThreadAfterGetEntryInfo(
@@ skipping 67 matching lines @@
                                dest_file_path,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::CopyOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  directory_service_->GetEntryInfoPairByPaths(
+  resource_metadata_->GetEntryInfoPairByPaths(
       src_file_path,
       dest_file_path.DirName(),
       base::Bind(&GDataFileSystem::CopyOnUIThreadAfterGetEntryInfoPair,
                  ui_weak_ptr_,
                  dest_file_path,
                  callback));
 }
 
 void GDataFileSystem::CopyOnUIThreadAfterGetEntryInfoPair(
     const FilePath& dest_file_path,
@@ skipping 119 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // It is a no-op if the file is renamed to the same name.
   if (file_path.BaseName().value() == new_name) {
     callback.Run(GDATA_FILE_OK, file_path);
     return;
   }
 
   // Get the edit URL of an entry at |file_path|.
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(
           &GDataFileSystem::RenameAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path,
           new_name,
           callback));
 }
 
 void GDataFileSystem::RenameAfterGetEntryInfo(
@@ skipping 47 matching lines @@
                                dest_file_path,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::MoveOnUIThread(const FilePath& src_file_path,
                                      const FilePath& dest_file_path,
                                      const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  directory_service_->GetEntryInfoPairByPaths(
+  resource_metadata_->GetEntryInfoPairByPaths(
       src_file_path,
       dest_file_path.DirName(),
       base::Bind(&GDataFileSystem::MoveOnUIThreadAfterGetEntryInfoPair,
                  ui_weak_ptr_,
                  dest_file_path,
                  callback));
 }
 
 void GDataFileSystem::MoveOnUIThreadAfterGetEntryInfoPair(
     const FilePath& dest_file_path,
@@ skipping 55 matching lines @@
          remove_file_from_directory_callback);
 }
 
 void GDataFileSystem::MoveEntryFromRootDirectory(
     const FilePath& dir_path,
     const FileOperationCallback& callback,
     GDataFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
-  DCHECK_EQ(kGDataRootDirectory, file_path.DirName().value());
+  DCHECK_EQ(kDriveRootDirectory, file_path.DirName().value());
 
   // Return if there is an error or |dir_path| is the root directory.
-  if (error != GDATA_FILE_OK || dir_path == FilePath(kGDataRootDirectory)) {
+  if (error != GDATA_FILE_OK || dir_path == FilePath(kDriveRootDirectory)) {
     callback.Run(error);
     return;
   }
 
-  directory_service_->GetEntryInfoPairByPaths(
+  resource_metadata_->GetEntryInfoPairByPaths(
       file_path,
       dir_path,
       base::Bind(
           &GDataFileSystem::MoveEntryFromRootDirectoryAfterGetEntryInfoPair,
           ui_weak_ptr_,
           callback));
 }
 
 void GDataFileSystem::MoveEntryFromRootDirectoryAfterGetEntryInfoPair(
     const FileOperationCallback& callback,
@@ skipping 32 matching lines @@
 
 void GDataFileSystem::RemoveEntryFromNonRootDirectory(
     const FileMoveCallback& callback,
     GDataFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   const FilePath dir_path = file_path.DirName();
   // Return if there is an error or |dir_path| is the root directory.
-  if (error != GDATA_FILE_OK || dir_path == FilePath(kGDataRootDirectory)) {
+  if (error != GDATA_FILE_OK || dir_path == FilePath(kDriveRootDirectory)) {
     callback.Run(error, file_path);
     return;
   }
 
-  directory_service_->GetEntryInfoPairByPaths(
+  resource_metadata_->GetEntryInfoPairByPaths(
       file_path,
       dir_path,
       base::Bind(
           &GDataFileSystem::RemoveEntryFromNonRootDirectoryAfterEntryInfoPair,
           ui_weak_ptr_,
           callback));
 }
 
 void GDataFileSystem::RemoveEntryFromNonRootDirectoryAfterEntryInfoPair(
     const FileMoveCallback& callback,
@@ skipping 43 matching lines @@
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::RemoveOnUIThread(
     const FilePath& file_path,
     bool is_recursive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Get the edit URL of an entry at |file_path|.
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(
           &GDataFileSystem::RemoveOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path,
           is_recursive,
           callback));
 }
 
 void GDataFileSystem::RemoveOnUIThreadAfterGetEntryInfo(
@@ skipping 118 matching lines @@
 }
 
 void GDataFileSystem::CreateFileOnUIThread(
     const FilePath& file_path,
     bool is_exclusive,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // First, checks the existence of a file at |file_path|.
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoForCreateFile,
                  ui_weak_ptr_,
                  file_path,
                  is_exclusive,
                  callback));
 }
 
 void GDataFileSystem::OnGetEntryInfoForCreateFile(
     const FilePath& file_path,
@@ skipping 47 matching lines @@
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_content_callback)));
 }
 
 void GDataFileSystem::GetFileByPathOnUIThread(
     const FilePath& file_path,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath,
                  ui_weak_ptr_,
                  file_path,
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_content_callback)));
 }
 
 void GDataFileSystem::OnGetEntryInfoCompleteForGetFileByPath(
     const FilePath& file_path,
@@ skipping 104 matching lines @@
                  CreateRelayCallback(get_file_callback),
                  CreateRelayCallback(get_content_callback)));
 }
 
 void GDataFileSystem::GetFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  directory_service_->GetEntryByResourceIdAsync(resource_id,
+  resource_metadata_->GetEntryByResourceIdAsync(resource_id,
       base::Bind(&GDataFileSystem::GetFileByEntryOnUIThread,
                  ui_weak_ptr_,
                  get_file_callback,
                  get_content_callback));
 }
 
 void GDataFileSystem::GetFileByEntryOnUIThread(
     const GetFileCallback& get_file_callback,
     const GetContentCallback& get_content_callback,
     DriveEntry* entry) {
@@ skipping 73 matching lines @@
                                          GDataErrorCode status,
                                          scoped_ptr<base::Value> data) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   GDataFileError error = util::GDataToGDataFileError(status);
 
   scoped_ptr<DriveEntry> fresh_entry;
   if (error == GDATA_FILE_OK) {
     scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
     if (doc_entry.get())
-      fresh_entry.reset(directory_service_->FromDocumentEntry(*doc_entry));
+      fresh_entry.reset(resource_metadata_->FromDocumentEntry(*doc_entry));
     if (!fresh_entry.get() || !fresh_entry->AsDriveFile()) {
       LOG(ERROR) << "Got invalid entry from server for " << params.resource_id;
       error = GDATA_FILE_ERROR_FAILED;
     }
   }
 
   if (error != GDATA_FILE_OK) {
     if (!params.get_file_callback.is_null()) {
       params.get_file_callback.Run(error,
                                    cache_file_path,
                                    params.mime_type,
                                    REGULAR_FILE);
     }
     return;
   }
 
   GURL content_url = fresh_entry->content_url();
   int64 file_size = fresh_entry->file_info().size;
 
   DCHECK_EQ(params.resource_id, fresh_entry->resource_id());
   scoped_ptr<DriveFile> fresh_entry_as_file(
       fresh_entry.release()->AsDriveFile());
-  directory_service_->RefreshFile(fresh_entry_as_file.Pass());
+  resource_metadata_->RefreshFile(fresh_entry_as_file.Pass());
 
   bool* has_enough_space = new bool(false);
   util::PostBlockingPoolSequencedTaskAndReply(
       FROM_HERE,
       blocking_task_runner_,
       base::Bind(&GDataCache::FreeDiskSpaceIfNeededFor,
                  base::Unretained(cache_),
                  file_size,
                  has_enough_space),
       base::Bind(&GDataFileSystem::StartDownloadFileIfEnoughSpace,
@@ skipping 64 matching lines @@
     const GetEntryInfoCallback& callback,
     GDataFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
     callback.Run(error, scoped_ptr<DriveEntryProto>());
     return;
   }
 
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::GetEntryInfoByPathOnUIThreadAfterGetEntry(
     const GetEntryInfoCallback& callback,
     GDataFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
@@ skipping 43 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != GDATA_FILE_OK) {
     callback.Run(error,
                  hide_hosted_docs_,
                  scoped_ptr<DriveEntryProtoVector>());
     return;
   }
 
-  directory_service_->ReadDirectoryByPath(
+  resource_metadata_->ReadDirectoryByPath(
       file_path,
       base::Bind(&GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterRead,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::ReadDirectoryByPathOnUIThreadAfterRead(
     const ReadDirectoryWithSettingCallback& callback,
     GDataFileError error,
     scoped_ptr<DriveEntryProtoVector> entries) {
@@ skipping 18 matching lines @@
       base::Bind(&GDataFileSystem::RequestDirectoryRefreshOnUIThread,
                  ui_weak_ptr_,
                  file_path));
 }
 
 void GDataFileSystem::RequestDirectoryRefreshOnUIThread(
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Make sure the destination directory exists.
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(
           &GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo,
           ui_weak_ptr_,
           file_path));
 }
 
 void GDataFileSystem::RequestDirectoryRefreshOnUIThreadAfterGetEntryInfo(
     const FilePath& file_path,
     GDataFileError error,
     scoped_ptr<DriveEntryProto> entry_proto) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK ||
       !entry_proto->file_info().is_directory()) {
     LOG(ERROR) << "Directory entry not found: " << file_path.value();
     return;
   }
 
   feed_loader_->LoadDirectoryFromServer(
-      directory_service_->origin(),
+      resource_metadata_->origin(),
       entry_proto->resource_id(),
       base::Bind(&GDataFileSystem::OnRequestDirectoryRefresh,
                  ui_weak_ptr_,
                  file_path));
 }
 
 void GDataFileSystem::OnRequestDirectoryRefresh(
     const FilePath& directory_path,
     GetDocumentsParams* params,
     GDataFileError error) {
   DCHECK(params);
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error != GDATA_FILE_OK) {
     LOG(ERROR) << "Failed to refresh directory: " << directory_path.value()
                << ": " << error;
     return;
   }
 
   int64 unused_delta_feed_changestamp = 0;
   FeedToFileResourceMapUmaStats unused_uma_stats;
   FileResourceIdMap file_map;
-  GDataWapiFeedProcessor feed_processor(directory_service_.get());
+  GDataWapiFeedProcessor feed_processor(resource_metadata_.get());
   error = feed_processor.FeedToFileResourceMap(
       *params->feed_list,
       &file_map,
       &unused_delta_feed_changestamp,
       &unused_uma_stats);
   if (error != GDATA_FILE_OK) {
     LOG(ERROR) << "Failed to convert feed: " << directory_path.value()
                << ": " << error;
     return;
   }
 
-  directory_service_->RefreshDirectory(
+  resource_metadata_->RefreshDirectory(
       params->directory_resource_id,
       file_map,
       base::Bind(&GDataFileSystem::OnDirectoryChangeFileMoveCallback,
                  ui_weak_ptr_));
 }
 
 void GDataFileSystem::UpdateFileByResourceId(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   DCHECK(!callback.is_null());
 
   RunTaskOnUIThread(
       base::Bind(&GDataFileSystem::UpdateFileByResourceIdOnUIThread,
                  ui_weak_ptr_,
                  resource_id,
                  CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::UpdateFileByResourceIdOnUIThread(
     const std::string& resource_id,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   // TODO(satorux): GetEntryInfoByResourceId() is called twice for
   // UpdateFileByResourceIdOnUIThread(). crbug.com/143873
-  directory_service_->GetEntryInfoByResourceId(
+  resource_metadata_->GetEntryInfoByResourceId(
       resource_id,
       base::Bind(&GDataFileSystem::UpdateFileByEntryInfo,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::UpdateFileByEntryInfo(
     const FileOperationCallback& callback,
     GDataFileError error,
     const FilePath& /* dive_file_path */,
@@ skipping 63 matching lines @@
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (*error != GDATA_FILE_OK) {
     callback.Run(*error);
     return;
   }
 
   // TODO(satorux): GetEntryInfoByResourceId() is called twice for
   // UpdateFileByResourceIdOnUIThread(). crbug.com/143873
-  directory_service_->GetEntryInfoByResourceId(
+  resource_metadata_->GetEntryInfoByResourceId(
       resource_id,
       base::Bind(&GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry,
           ui_weak_ptr_,
           callback,
           *file_size,
           cache_file_path));
 }
 
 void GDataFileSystem::OnGetFileCompleteForUpdateFileByEntry(
     const FileOperationCallback& callback,
@@ skipping 196 matching lines @@
     scoped_ptr<std::vector<SearchResultInfo> > result_vec(results);
     if (!callback.is_null())
       callback.Run(error, next_feed, result_vec.Pass());
     return;
   }
 
   // Go through all entires generated by the feed and add them to the search
   // result directory.
   for (size_t i = 0; i < feed->entries().size(); ++i) {
     DocumentEntry* doc = const_cast<DocumentEntry*>(feed->entries()[i]);
-    scoped_ptr<DriveEntry> entry(directory_service_->FromDocumentEntry(*doc));
+    scoped_ptr<DriveEntry> entry(resource_metadata_->FromDocumentEntry(*doc));
 
     if (!entry.get())
       continue;
 
     DCHECK_EQ(doc->resource_id(), entry->resource_id());
     DCHECK(!entry->is_deleted());
 
     std::string entry_resource_id = entry->resource_id();
 
     // This will do nothing if the entry is not already present in file system.
     if (entry->AsDriveFile()) {
       scoped_ptr<DriveFile> entry_as_file(entry.release()->AsDriveFile());
-      directory_service_->RefreshFile(entry_as_file.Pass());
+      resource_metadata_->RefreshFile(entry_as_file.Pass());
       // We shouldn't use entry object after this point.
       DCHECK(!entry.get());
     }
 
     // We will need information about result entry to create info for callback.
     // We can't use |entry| anymore, so we have to refetch entry from file
     // system. Also, |entry| doesn't have file path set before |RefreshFile|
     // call, so we can't get file path from there.
-    directory_service_->GetEntryByResourceIdAsync(entry_resource_id,
+    resource_metadata_->GetEntryByResourceIdAsync(entry_resource_id,
         base::Bind(&AddEntryToSearchResults,
                    results,
                    callback,
                    base::Bind(&GDataFileSystem::CheckForUpdates, ui_weak_ptr_),
                    error,
                    i+1 == feed->entries().size(),
                    next_feed));
   }
 }
 
 void GDataFileSystem::Search(const std::string& search_query,
                              const GURL& next_feed,
                              const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI) ||
          BrowserThread::CurrentlyOn(BrowserThread::IO));
   RunTaskOnUIThread(base::Bind(&GDataFileSystem::SearchAsyncOnUIThread,
                                ui_weak_ptr_,
                                search_query,
                                next_feed,
                                CreateRelayCallback(callback)));
 }
 
 void GDataFileSystem::SearchAsyncOnUIThread(
     const std::string& search_query,
     const GURL& next_feed,
     const SearchCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   feed_loader_->SearchFromServer(
-      directory_service_->origin(),
+      resource_metadata_->origin(),
       search_query,
       next_feed,
       base::Bind(&GDataFileSystem::OnSearch, ui_weak_ptr_, callback));
 }
 
 void GDataFileSystem::OnDirectoryChanged(const FilePath& directory_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(directory_path));
@@ skipping 53 matching lines @@
     callback.Run(error);
     return;
   }
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::ExtractAndParse(*data));
   if (!doc_entry.get()) {
     callback.Run(GDATA_FILE_ERROR_FAILED);
     return;
   }
 
-  DriveEntry* entry = directory_service_->FromDocumentEntry(*doc_entry);
+  DriveEntry* entry = resource_metadata_->FromDocumentEntry(*doc_entry);
   if (!entry) {
     callback.Run(GDATA_FILE_ERROR_FAILED);
     return;
   }
 
   // |entry| was added in the root directory on the server, so we should
   // first add it to |root_| to mirror the state and then move it to the
   // destination directory by MoveEntryFromRootDirectory().
-  directory_service_->AddEntryToDirectory(
-      directory_service_->root(),
+  resource_metadata_->AddEntryToDirectory(
+      resource_metadata_->root(),
       entry,
       base::Bind(&GDataFileSystem::MoveEntryFromRootDirectory,
                  ui_weak_ptr_,
                  dir_path,
                  callback));
 }
 
 void GDataFileSystem::OnMoveEntryFromRootDirectoryCompleted(
     const FileOperationCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   GDataFileError error = util::GDataToGDataFileError(status);
   if (error == GDATA_FILE_OK) {
-    DriveEntry* entry = directory_service_->FindEntryByPathSync(file_path);
+    DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
     if (entry) {
-      DCHECK_EQ(directory_service_->root(), entry->parent());
-      directory_service_->MoveEntryToDirectory(
+      DCHECK_EQ(resource_metadata_->root(), entry->parent());
+      resource_metadata_->MoveEntryToDirectory(
           dir_path,
           entry,
           base::Bind(
               &GDataFileSystem::NotifyAndRunFileOperationCallback,
               ui_weak_ptr_,
               callback));
       return;
     } else {
       error = GDATA_FILE_ERROR_NOT_FOUND;
     }
@@ skipping 133 matching lines @@
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     if (!callback.is_null())
       callback.Run(error, FilePath());
     return;
   }
 
-  DriveEntry* entry = directory_service_->FindEntryByPathSync(file_path);
+  DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
   if (!entry) {
     if (!callback.is_null())
       callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
     return;
   }
 
   DCHECK(entry->parent());
   entry->set_title(new_name);
   // After changing the title of the entry, call MoveEntryToDirectory() to
   // remove the entry from its parent directory and then add it back in order to
   // go through the file name de-duplication.
   // TODO(achuith/satorux/zel): This code is fragile. The title has been
   // changed, but not the file_name. MoveEntryToDirectory calls RemoveChild to
   // remove the child based on the old file_name, and then re-adds the child by
   // first assigning the new title to file_name. http://crbug.com/30157
-  directory_service_->MoveEntryToDirectory(
+  resource_metadata_->MoveEntryToDirectory(
       entry->parent()->GetFilePath(),
       entry,
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::MoveEntryToRootDirectoryLocally(
     const FileMoveCallback& callback,
     const FilePath& file_path,
     const FilePath& dir_path,
     GDataErrorCode status,
     const GURL& document_url) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   const GDataFileError error = util::GDataToGDataFileError(status);
   if (error != GDATA_FILE_OK) {
     callback.Run(error, FilePath());
     return;
   }
 
-  DriveEntry* entry = directory_service_->FindEntryByPathSync(file_path);
+  DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
   if (!entry) {
     callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
     return;
   }
 
-  directory_service_->MoveEntryToDirectory(
-      directory_service_->root()->GetFilePath(),
+  resource_metadata_->MoveEntryToDirectory(
+      resource_metadata_->root()->GetFilePath(),
       entry,
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  callback));
 }
 
 void GDataFileSystem::NotifyAndRunFileMoveCallback(
     const FileMoveCallback& callback,
     GDataFileError error,
     const FilePath& moved_file_path) {
@@ skipping 43 matching lines @@
 }
 
 void GDataFileSystem::RemoveStaleEntryOnUpload(
     const std::string& resource_id,
     DriveDirectory* parent_dir,
     const FileMoveCallback& callback,
     DriveEntry* existing_entry) {
   if (existing_entry &&
       // This should always match, but just in case.
       existing_entry->parent() == parent_dir) {
-    directory_service_->RemoveEntryFromParent(existing_entry, callback);
+    resource_metadata_->RemoveEntryFromParent(existing_entry, callback);
   } else {
     callback.Run(GDATA_FILE_ERROR_NOT_FOUND, FilePath());
     LOG(ERROR) << "Entry for the existing file not found: " << resource_id;
   }
 }
 
 void GDataFileSystem::NotifyFileSystemMounted() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   DVLOG(1) << "File System is mounted";
@@ skipping 30 matching lines @@
 
   if (!entry_value)
     return GDATA_FILE_ERROR_FAILED;
 
   scoped_ptr<DocumentEntry> doc_entry(DocumentEntry::CreateFrom(*entry_value));
 
   if (!doc_entry.get())
     return GDATA_FILE_ERROR_FAILED;
 
   // Find parent directory element within the cached file system snapshot.
-  DriveEntry* entry = directory_service_->FindEntryByPathSync(directory_path);
+  DriveEntry* entry = resource_metadata_->FindEntryByPathSync(directory_path);
   if (!entry)
     return GDATA_FILE_ERROR_FAILED;
 
   // Check if parent is a directory since in theory since this is a callback
   // something could in the meantime have nuked the parent dir and created a
   // file with the exact same name.
   DriveDirectory* parent_dir = entry->AsDriveDirectory();
   if (!parent_dir)
     return GDATA_FILE_ERROR_FAILED;
 
   DriveEntry* new_entry =
-      directory_service_->FromDocumentEntry(*doc_entry);
+      resource_metadata_->FromDocumentEntry(*doc_entry);
   if (!new_entry)
     return GDATA_FILE_ERROR_FAILED;
 
-  directory_service_->AddEntryToDirectory(
+  resource_metadata_->AddEntryToDirectory(
       parent_dir,
       new_entry,
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  FileMoveCallback()));
   return GDATA_FILE_OK;
 }
 
 GDataFileSystem::FindMissingDirectoryResult
 GDataFileSystem::FindFirstMissingParentDirectory(
     const FilePath& directory_path,
     GURL* last_dir_content_url,
     FilePath* first_missing_parent_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // Let's find which how deep is the existing directory structure and
   // get the first element that's missing.
   std::vector<FilePath::StringType> path_parts;
   directory_path.GetComponents(&path_parts);
   FilePath current_path;
 
   for (std::vector<FilePath::StringType>::const_iterator iter =
           path_parts.begin();
        iter != path_parts.end(); ++iter) {
     current_path = current_path.Append(*iter);
-    DriveEntry* entry = directory_service_->FindEntryByPathSync(current_path);
+    DriveEntry* entry = resource_metadata_->FindEntryByPathSync(current_path);
     if (entry) {
       if (entry->file_info().is_directory) {
         *last_dir_content_url = entry->content_url();
       } else {
         // Huh, the segment found is a file not a directory?
         return FOUND_INVALID;
       }
     } else {
       *first_missing_parent_path = current_path;
       return FOUND_MISSING;
     }
   }
   return DIRECTORY_ALREADY_PRESENT;
 }
 
 GDataFileError GDataFileSystem::RemoveEntryLocally(
     const FilePath& file_path, std::string* resource_id) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   resource_id->clear();
 
   // Find directory element within the cached file system snapshot.
-  DriveEntry* entry = directory_service_->FindEntryByPathSync(file_path);
+  DriveEntry* entry = resource_metadata_->FindEntryByPathSync(file_path);
 
   if (!entry)
     return GDATA_FILE_ERROR_NOT_FOUND;
 
   // You can't remove root element.
   if (!entry->parent())
     return GDATA_FILE_ERROR_ACCESS_DENIED;
 
   // If it's a file (only files have resource id), get its resource id so that
   // we can remove it after releasing the auto lock.
   if (entry->AsDriveFile())
     *resource_id = entry->AsDriveFile()->resource_id();
 
-  directory_service_->RemoveEntryFromParent(
+  resource_metadata_->RemoveEntryFromParent(
       entry,
       base::Bind(&GDataFileSystem::OnDirectoryChangeFileMoveCallback,
                  ui_weak_ptr_));
   return GDATA_FILE_OK;
 }
 
 void GDataFileSystem::AddUploadedFile(
     UploadMode upload_mode,
     const FilePath& virtual_dir_path,
     scoped_ptr<DocumentEntry> entry,
@@ skipping 27 matching lines @@
 
   // ScopedClosureRunner ensures that the specified callback is always invoked
   // upon return or passed on.
   base::ScopedClosureRunner callback_runner(callback);
 
   if (!entry.get()) {
     NOTREACHED();
     return;
   }
 
-  DriveEntry* dir_entry = directory_service_->FindEntryByPathSync(
+  DriveEntry* dir_entry = resource_metadata_->FindEntryByPathSync(
       virtual_dir_path);
   if (!dir_entry)
     return;
 
   DriveDirectory* parent_dir  = dir_entry->AsDriveDirectory();
   if (!parent_dir)
     return;
 
   scoped_ptr<DriveEntry> new_entry(
-      directory_service_->FromDocumentEntry(*entry));
+      resource_metadata_->FromDocumentEntry(*entry));
   if (!new_entry.get())
     return;
 
   const std::string& resource_id = new_entry->resource_id();
   AddUploadedFileParams* params =
       new AddUploadedFileParams(upload_mode,
                                 parent_dir,
                                 new_entry.Pass(),
                                 file_content_path,
                                 cache_operation,
                                 callback_runner.Release());
 
   const FileMoveCallback file_move_callback =
       base::Bind(&GDataFileSystem::ContinueAddUploadedFile,
                  ui_weak_ptr_, params);
 
   if (upload_mode == UPLOAD_EXISTING_FILE) {
     // Remove an existing entry, which should be present.
-    directory_service_->GetEntryByResourceIdAsync(
+    resource_metadata_->GetEntryByResourceIdAsync(
         resource_id,
         base::Bind(&GDataFileSystem::RemoveStaleEntryOnUpload,
                    ui_weak_ptr_,
                    resource_id,
                    parent_dir,
                    file_move_callback));
   } else {
     file_move_callback.Run(GDATA_FILE_OK, FilePath());
   }
 }
 
 void GDataFileSystem::ContinueAddUploadedFile(
     AddUploadedFileParams* params,
     GDataFileError error,
     const FilePath& file_path) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK_EQ(GDATA_FILE_OK, error);
   DCHECK(params->new_entry.get());
   DriveFile* file = params->new_entry->AsDriveFile();
   DCHECK(file);
 
   params->resource_id = file->resource_id();
   params->md5 = file->file_md5();
-  directory_service_->AddEntryToDirectory(
+  resource_metadata_->AddEntryToDirectory(
       params->parent_dir,
       params->new_entry.release(),
       base::Bind(&GDataFileSystem::NotifyAndRunFileMoveCallback,
                  ui_weak_ptr_,
                  base::Bind(&GDataFileSystem::AddUploadedFileToCache,
                             ui_weak_ptr_,
                             base::Owned(params))));
 }
 
 void GDataFileSystem::AddUploadedFileToCache(
@@ skipping 47 matching lines @@
 
 void GDataFileSystem::UpdateEntryDataOnUIThread(
     const std::string& resource_id,
     const std::string& md5,
     scoped_ptr<DocumentEntry> entry,
     const FilePath& file_content_path,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<DriveFile> new_entry(
-      directory_service_->FromDocumentEntry(*entry)->AsDriveFile());
+      resource_metadata_->FromDocumentEntry(*entry)->AsDriveFile());
   if (!new_entry.get()) {
     return;
   }
 
-  directory_service_->RefreshFile(new_entry.Pass());
+  resource_metadata_->RefreshFile(new_entry.Pass());
 
   // Add the file to the cache if we have uploaded a new file.
   cache_->StoreOnUIThread(resource_id,
                           md5,
                           file_content_path,
                           GDataCache::FILE_OPERATION_MOVE,
                           base::Bind(&OnCacheUpdatedForAddUploadedFile,
                                      callback));
 }
 
@@ skipping 15 matching lines @@
   }
 }
 
 void GDataFileSystem::SetHideHostedDocuments(bool hide) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (hide == hide_hosted_docs_)
     return;
 
   hide_hosted_docs_ = hide;
-  const FilePath root_path = directory_service_->root()->GetFilePath();
+  const FilePath root_path = resource_metadata_->root()->GetFilePath();
 
   // Kick off directory refresh when this setting changes.
   FOR_EACH_OBSERVER(GDataFileSystemInterface::Observer, observers_,
                     OnDirectoryChanged(root_path));
 }
 
 //============= GDataFileSystem: internal helper functions =====================
 
 void GDataFileSystem::InitializePreferenceObserver() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
@@ skipping 23 matching lines @@
   // Open->Open->modify->Close->modify->Close; the second modify may not be
   // synchronized to the server since it is already Closed on the cache).
   if (open_files_.find(file_path) != open_files_.end()) {
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_FILE_ERROR_IN_USE, FilePath()));
     return;
   }
   open_files_.insert(file_path);
 
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::OnGetEntryInfoCompleteForOpenFile,
                  ui_weak_ptr_,
                  file_path,
                  base::Bind(&GDataFileSystem::OnOpenFileFinished,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
@@ skipping 109 matching lines @@
 
   if (open_files_.find(file_path) == open_files_.end()) {
     // The file is not being opened.
     MessageLoop::current()->PostTask(
         FROM_HERE,
         base::Bind(callback, GDATA_FILE_ERROR_NOT_FOUND));
     return;
   }
 
   // Step 1 of CloseFile: Get resource_id and md5 for |file_path|.
-  directory_service_->GetEntryInfoByPath(
+  resource_metadata_->GetEntryInfoByPath(
       file_path,
       base::Bind(&GDataFileSystem::CloseFileOnUIThreadAfterGetEntryInfo,
                  ui_weak_ptr_,
                  file_path,
                  base::Bind(&GDataFileSystem::CloseFileOnUIThreadFinalize,
                             ui_weak_ptr_,
                             file_path,
                             callback)));
 }
 
@@ skipping 152 matching lines @@
     return;
   }
 
   PlatformFileInfoProto entry_file_info;
   DriveEntry::ConvertPlatformFileInfoToProto(*file_info, &entry_file_info);
   *entry_proto->mutable_file_info() = entry_file_info;
   callback.Run(GDATA_FILE_OK, entry_proto.Pass());
 }
 
 }  // namespace gdata