Rename GDataDirectoryService to DriveResourceMetadata

chrome/browser/chromeos/gdata/gdata_wapi_feed_processor.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 <utility>
 
 #include "base/metrics/histogram.h"
+#include "chrome/browser/chromeos/gdata/drive_resource_metadata.h"
 #include "chrome/browser/chromeos/gdata/drive_files.h"
-#include "chrome/browser/chromeos/gdata/gdata_directory_service.h"
 #include "chrome/browser/chromeos/gdata/gdata_wapi_feed_processor.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace gdata {
 
 FeedToFileResourceMapUmaStats::FeedToFileResourceMapUmaStats()
     : num_regular_files(0),
       num_hosted_documents(0) {
 }
 
 FeedToFileResourceMapUmaStats::~FeedToFileResourceMapUmaStats() {
 }
 
 GDataWapiFeedProcessor::GDataWapiFeedProcessor(
-    GDataDirectoryService* directory_service)
-  : directory_service_(directory_service) {
+    DriveResourceMetadata* resource_metadata)
+  : resource_metadata_(resource_metadata) {
 }
 
 GDataWapiFeedProcessor::~GDataWapiFeedProcessor() {
 }
 
 GDataFileError GDataWapiFeedProcessor::ApplyFeeds(
     const std::vector<DocumentFeed*>& feed_list,
     int64 start_changestamp,
     int64 root_feed_changestamp,
     std::set<FilePath>* changed_dirs) {
   bool is_delta_feed = start_changestamp != 0;
 
-  directory_service_->set_origin(FROM_SERVER);
+  resource_metadata_->set_origin(FROM_SERVER);
 
   int64 delta_feed_changestamp = 0;
   FeedToFileResourceMapUmaStats uma_stats;
   FileResourceIdMap file_map;
   GDataFileError error = FeedToFileResourceMap(feed_list,
                                                &file_map,
                                                &delta_feed_changestamp,
                                                &uma_stats);
   if (error != GDATA_FILE_OK)
     return error;
@@ skipping 36 matching lines @@
 
 void GDataWapiFeedProcessor::ApplyFeedFromFileUrlMap(
     bool is_delta_feed,
     int64 feed_changestamp,
     FileResourceIdMap* file_map,
   std::set<FilePath>* changed_dirs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(changed_dirs);
 
   if (!is_delta_feed) {  // Full update.
-    directory_service_->root()->RemoveChildren();
-    changed_dirs->insert(directory_service_->root()->GetFilePath());
+    resource_metadata_->root()->RemoveChildren();
+    changed_dirs->insert(resource_metadata_->root()->GetFilePath());
   }
-  directory_service_->set_largest_changestamp(feed_changestamp);
+  resource_metadata_->set_largest_changestamp(feed_changestamp);
 
-  scoped_ptr<GDataDirectoryService> orphaned_dir_service(
-      new GDataDirectoryService);
+  scoped_ptr<DriveResourceMetadata> orphaned_resources(
+      new DriveResourceMetadata);
   // Go through all entries generated by the feed and apply them to the local
   // snapshot of the file system.
   for (FileResourceIdMap::iterator it = file_map->begin();
        it != file_map->end();) {
     // Ensure that the entry is deleted, unless the ownership is explicitly
     // transferred by entry.release().
     scoped_ptr<DriveEntry> entry(it->second);
     DCHECK_EQ(it->first, entry->resource_id());
     // Erase the entry so the deleted entry won't be referenced.
     file_map->erase(it++);
 
     DriveEntry* old_entry =
-        directory_service_->GetEntryByResourceId(entry->resource_id());
+        resource_metadata_->GetEntryByResourceId(entry->resource_id());
     DriveDirectory* dest_dir = NULL;
     if (entry->is_deleted()) {  // Deleted file/directory.
       DVLOG(1) << "Removing file " << entry->base_name();
       if (!old_entry)
         continue;
 
       dest_dir = old_entry->parent();
       if (!dest_dir) {
         NOTREACHED();
         continue;
@@ skipping 15 matching lines @@
             old_entry->AsDriveDirectory());
       }
       // Remove the old instance of this entry.
       RemoveEntryFromDirectoryAndCollectChangedDirectories(
           dest_dir, old_entry, changed_dirs);
       // Did we actually move the new file to another directory?
       if (dest_dir->resource_id() != entry->parent_resource_id()) {
         changed_dirs->insert(dest_dir->GetFilePath());
         dest_dir = FindDirectoryForNewEntry(entry.get(),
                                             *file_map,
-                                            orphaned_dir_service.get());
+                                            orphaned_resources.get());
       }
       DCHECK(dest_dir);
       AddEntryToDirectoryAndCollectChangedDirectories(
           entry.release(),
           dest_dir,
-          orphaned_dir_service.get(),
+          orphaned_resources.get(),
           changed_dirs);
     } else {  // Adding a new file.
       dest_dir = FindDirectoryForNewEntry(entry.get(),
                                           *file_map,
-                                          orphaned_dir_service.get());
+                                          orphaned_resources.get());
       DCHECK(dest_dir);
       AddEntryToDirectoryAndCollectChangedDirectories(
           entry.release(),
           dest_dir,
-          orphaned_dir_service.get(),
+          orphaned_resources.get(),
           changed_dirs);
     }
 
     // Record changed directory if this was a delta feed and the parent
     // directory is already properly rooted within its parent.
     if (dest_dir && (dest_dir->parent() ||
-        dest_dir == directory_service_->root()) &&
-        dest_dir != orphaned_dir_service->root() && is_delta_feed) {
+        dest_dir == resource_metadata_->root()) &&
+        dest_dir != orphaned_resources->root() && is_delta_feed) {
       changed_dirs->insert(dest_dir->GetFilePath());
     }
   }
   // All entry must be erased from the map.
   DCHECK(file_map->empty());
 }
 
 // static
 void GDataWapiFeedProcessor::AddEntryToDirectoryAndCollectChangedDirectories(
     DriveEntry* entry,
     DriveDirectory* directory,
-    GDataDirectoryService* orphaned_dir_service,
+    DriveResourceMetadata* orphaned_resources,
     std::set<FilePath>* changed_dirs) {
   directory->AddEntry(entry);
-  if (entry->AsDriveDirectory() && directory != orphaned_dir_service->root())
+  if (entry->AsDriveDirectory() && directory != orphaned_resources->root())
     changed_dirs->insert(entry->GetFilePath());
 }
 
 // static
 void GDataWapiFeedProcessor::
 RemoveEntryFromDirectoryAndCollectChangedDirectories(
     DriveDirectory* directory,
     DriveEntry* entry,
     std::set<FilePath>* changed_dirs) {
   // Get the list of all sub-directory paths, so we can notify their listeners
   // that they are smoked.
   DriveDirectory* dir = entry->AsDriveDirectory();
   if (dir)
     dir->GetChildDirectoryPaths(changed_dirs);
   directory->RemoveEntry(entry);
 }
 
 DriveDirectory* GDataWapiFeedProcessor::FindDirectoryForNewEntry(
     DriveEntry* new_entry,
     const FileResourceIdMap& file_map,
-    GDataDirectoryService* orphaned_dir_service) {
+    DriveResourceMetadata* orphaned_resources) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DriveDirectory* dir = NULL;
   // Added file.
   const std::string& parent_id = new_entry->parent_resource_id();
   if (parent_id.empty()) {
-    dir = directory_service_->root();
+    dir = resource_metadata_->root();
     DVLOG(1) << "Root parent for " << new_entry->base_name();
   } else {
-    DriveEntry* entry = directory_service_->GetEntryByResourceId(parent_id);
+    DriveEntry* entry = resource_metadata_->GetEntryByResourceId(parent_id);
     dir = entry ? entry->AsDriveDirectory() : NULL;
     if (!dir) {
       // The parent directory was also added with this set of feeds.
       FileResourceIdMap::const_iterator find_iter =
           file_map.find(parent_id);
       dir = (find_iter != file_map.end() &&
              find_iter->second) ?
                 find_iter->second->AsDriveDirectory() : NULL;
       if (dir) {
         DVLOG(1) << "Found parent for " << new_entry->base_name()
                  << " in file_map " << parent_id;
       } else {
         DVLOG(1) << "Adding orphan " << new_entry->GetFilePath().value();
-        dir = orphaned_dir_service->root();
+        dir = orphaned_resources->root();
       }
     }
   }
   return dir;
 }
 
 GDataFileError GDataWapiFeedProcessor::FeedToFileResourceMap(
     const std::vector<DocumentFeed*>& feed_list,
     FileResourceIdMap* file_map,
     int64* feed_changestamp,
     FeedToFileResourceMapUmaStats* uma_stats) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(uma_stats);
 
   GDataFileError error = GDATA_FILE_OK;
   uma_stats->num_regular_files = 0;
   uma_stats->num_hosted_documents = 0;
   uma_stats->num_files_with_entry_kind.clear();
   for (size_t i = 0; i < feed_list.size(); ++i) {
     const DocumentFeed* feed = feed_list[i];
 
     // Get upload url from the root feed. Links for all other collections will
     // be handled in GDatadirectory::FromDocumentEntry();
     if (i == 0) {
       const Link* root_feed_upload_link =
           feed->GetLinkByType(Link::RESUMABLE_CREATE_MEDIA);
       if (root_feed_upload_link)
-        directory_service_->root()->set_upload_url(
+        resource_metadata_->root()->set_upload_url(
             root_feed_upload_link->href());
       *feed_changestamp = feed->largest_changestamp();
       DCHECK_GE(*feed_changestamp, 0);
     }
 
     for (ScopedVector<DocumentEntry>::const_iterator iter =
              feed->entries().begin();
          iter != feed->entries().end(); ++iter) {
       DocumentEntry* doc = *iter;
-      DriveEntry* entry = directory_service_->FromDocumentEntry(*doc);
+      DriveEntry* entry = resource_metadata_->FromDocumentEntry(*doc);
       // Some document entries don't map into files (i.e. sites).
       if (!entry)
         continue;
       // Count the number of files.
       DriveFile* as_file = entry->AsDriveFile();
       if (as_file) {
         if (as_file->is_hosted_document())
           ++uma_stats->num_hosted_documents;
         else
           ++uma_stats->num_regular_files;
@@ skipping 22 matching lines @@
     // If the code above fails to parse a feed, any DriveEntry instance
     // added to |file_by_url| is not managed by a DriveDirectory instance,
     // so we need to explicitly release them here.
     STLDeleteValues(file_map);
   }
 
   return error;
 }
 
 }  // namespace gdata