gdata: Introduce GDataWapiFeedProcessor class

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 550 matching lines @@
     const GetEntryInfoWithFilePathCallback& callback,
     const FilePath& path,
     GDataFileError error,
     scoped_ptr<GDataEntryProto> entry_proto) {
   if (!callback.is_null())
     callback.Run(error, path, entry_proto.Pass());
 }
 
 }  // namespace
 
+// Struct used to record UMA stats with FeedToFileResourceMap().
+//
+// TODO(satorux): Move this to a new file. crbug.com/130669
+struct FeedToFileResourceMapUmaStats {
+  FeedToFileResourceMapUmaStats()
+      : num_regular_files(0),
+        num_hosted_documents(0) {}
+
+  typedef std::map<DocumentEntry::EntryKind, int> EntryKindToCountMap;
+  int num_regular_files;
+  int num_hosted_documents;
+  EntryKindToCountMap num_files_with_entry_kind;
+};
+
+// GDataWapiFeedProcessor is used to process feeds from WAPI (codename for
+// Documents List API).
+//
+// TODO(satorux): Move this into a new file. crbug.com/130669
+class GDataWapiFeedProcessor {
+ public:
+  explicit GDataWapiFeedProcessor(GDataDirectoryService* directory_service)
+      : directory_service_(directory_service) {
+  }
+
+  // Applies the documents feeds to the file system using |directory_service_|.
+  //
+  // |start_changestamp| determines the type of feed to process. The value is
+  // set to zero for the root feeds, every other value is for the delta feeds.
+  //
+  // In the case of processing the root feeds |root_feed_changestamp| is used
+  // as its initial changestamp value. The value comes from
+  // AccountMetadataFeed.
+  GDataFileError ApplyFeeds(const std::vector<DocumentFeed*>& feed_list,
+                            int start_changestamp,
+                            int root_feed_changestamp,
+                            std::set<FilePath>* changed_dirs);
+

[achuithb, 2012/08/01 00:00:14]

nit: unnecessary newline

[satorux1, 2012/08/01 00:56:52]

Done.

+
+  // Converts list of document feeds from collected feeds into
+  // FileResourceIdMap.
+  GDataFileError FeedToFileResourceMap(
+    const std::vector<DocumentFeed*>& feed_list,
+    FileResourceIdMap* file_map,
+    int* feed_changestamp,
+    FeedToFileResourceMapUmaStats* uma_stats);
+
+ private:
+  // Updates UMA histograms about file counts.
+  void UpdateFileCountUmaHistograms(
+      const FeedToFileResourceMapUmaStats& uma_stats) const;
+
+  // Applies the pre-processed feed from |file_map| map onto the file system.
+  // All entries in |file_map| will be erased (i.e. the map becomes empty),
+  // and values are deleted.
+  void ApplyFeedFromFileUrlMap(bool is_delta_feed,
+                               int feed_changestamp,
+                               FileResourceIdMap* file_map,
+                               std::set<FilePath>* changed_dirs);
+
+  // Helper function for adding new |file| from the feed into |directory|. It
+  // checks the type of file and updates |changed_dirs| if this file adding
+  // operation needs to raise directory notification update. If file is being
+  // added to |orphaned_dir_service| such notifications are not raised since
+  // we ignore such files and don't add them to the file system now.
+  static void AddEntryToDirectoryAndCollectChangedDirectories(
+      GDataEntry* entry,
+      GDataDirectory* directory,
+      GDataDirectoryService* orphaned_dir_service,
+      std::set<FilePath>* changed_dirs);
+
+  // Helper function for removing |entry| from |directory|. If |entry| is a
+  // directory too, it will collect all its children file paths into
+  // |changed_dirs| as well.
+  static void RemoveEntryFromDirectoryAndCollectChangedDirectories(
+      GDataDirectory* directory,
+      GDataEntry* entry,
+      std::set<FilePath>* changed_dirs);
+
+  // Finds directory where new |file| should be added to during feed processing.
+  // |orphaned_entries_dir| collects files/dirs that don't have a parent in
+  // either locally cached file system or in this new feed.
+  GDataDirectory* FindDirectoryForNewEntry(
+      GDataEntry* new_entry,
+      const FileResourceIdMap& file_map,
+      GDataDirectoryService* orphaned_dir_service);
+
+  GDataDirectoryService* directory_service_;
+  DISALLOW_COPY_AND_ASSIGN(GDataWapiFeedProcessor);
+};
+
 // GDataFileSystem::GetDocumentsParams struct implementation.
 struct GDataFileSystem::GetDocumentsParams {
   GetDocumentsParams(int start_changestamp,
                      int root_feed_changestamp,
                      std::vector<DocumentFeed*>* feed_list,
                      bool should_fetch_multiple_feeds,
                      const FilePath& search_file_path,
                      const std::string& search_query,
                      const std::string& directory_resource_id,
                      const FindEntryCallback& callback);
@@ skipping 127 matching lines @@
       resource_id(resource_id),
       md5(md5),
       mime_type(mime_type),
       get_file_callback(get_file_callback),
       get_download_data_callback(get_download_data_callback) {
 }
 
 GDataFileSystem::GetFileFromCacheParams::~GetFileFromCacheParams() {
 }
 
-// GDataFileSystem::FeedToFileResourceMapUmaStats implementation.
-struct GDataFileSystem::FeedToFileResourceMapUmaStats {
-  FeedToFileResourceMapUmaStats()
-      : num_regular_files(0),
-        num_hosted_documents(0) {}
-
-  typedef std::map<DocumentEntry::EntryKind, int> EntryKindToCountMap;
-  int num_regular_files;
-  int num_hosted_documents;
-  EntryKindToCountMap num_files_with_entry_kind;
-};
-
 // GDataFileSystem::StartFileUploadParams implementation.
 struct GDataFileSystem::StartFileUploadParams {
   StartFileUploadParams(const FilePath& in_local_file_path,
                         const FilePath& in_remote_file_path,
                         const FileOperationCallback& in_callback)
       : local_file_path(in_local_file_path),
         remote_file_path(in_remote_file_path),
         callback(in_callback) {}
 
   const FilePath local_file_path;
@@ skipping 1615 matching lines @@
   const FilePath& directory_path = params->search_file_path;
   if (error != GDATA_FILE_OK) {
     LOG(ERROR) << "Failed to refresh directory: " << directory_path.value()
                << ": " << error;
     return;
   }
 
   int unused_delta_feed_changestamp = 0;
   FeedToFileResourceMapUmaStats unused_uma_stats;
   FileResourceIdMap file_map;
-  error = FeedToFileResourceMap(*params->feed_list,
-                                &file_map,
-                                &unused_delta_feed_changestamp,
-                                &unused_uma_stats);
+  GDataWapiFeedProcessor feed_processor(directory_service_.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_->GetEntryByResourceIdAsync(params->directory_resource_id,
       base::Bind(&GDataFileSystem::RequestDirectoryRefreshByEntry,
                  ui_weak_ptr_,
                  directory_path,
@@ skipping 893 matching lines @@
   return GDATA_FILE_OK;
 }
 
 GDataFileError GDataFileSystem::UpdateFromFeed(
     const std::vector<DocumentFeed*>& feed_list,
     int start_changestamp,
     int 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_.get());
+  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) {
+      NotifyDirectoryChanged(*dir_iter);
+    }
+  }
+
+  return error;
+}
+
+GDataFileError GDataWapiFeedProcessor::ApplyFeeds(
+    const std::vector<DocumentFeed*>& feed_list,
+    int start_changestamp,
+    int root_feed_changestamp,
+    std::set<FilePath>* changed_dirs) {
   bool is_delta_feed = start_changestamp != 0;
 
   directory_service_->set_origin(FROM_SERVER);
 
   int delta_feed_changestamp = 0;
   FeedToFileResourceMapUmaStats uma_stats;
   FileResourceIdMap file_map;
   GDataFileError error = FeedToFileResourceMap(feed_list,
-                                                        &file_map,
-                                                        &delta_feed_changestamp,
-                                                        &uma_stats);
+                                               &file_map,
+                                               &delta_feed_changestamp,
+                                               &uma_stats);
   if (error != GDATA_FILE_OK)
     return error;
 
   ApplyFeedFromFileUrlMap(
       is_delta_feed,
       is_delta_feed ? delta_feed_changestamp : root_feed_changestamp,
-      &file_map);
+      &file_map,
+      changed_dirs);
 
   // Shouldn't record histograms when processing delta feeds.
   if (!is_delta_feed)
     UpdateFileCountUmaHistograms(uma_stats);
 
   return GDATA_FILE_OK;
 }
 
-void GDataFileSystem::UpdateFileCountUmaHistograms(
+void GDataWapiFeedProcessor::UpdateFileCountUmaHistograms(
     const FeedToFileResourceMapUmaStats& uma_stats) const {
   const int num_total_files =
       uma_stats.num_hosted_documents + uma_stats.num_regular_files;
   UMA_HISTOGRAM_COUNTS("GData.NumberOfRegularFiles",
                        uma_stats.num_regular_files);
   UMA_HISTOGRAM_COUNTS("GData.NumberOfHostedDocuments",
                        uma_stats.num_hosted_documents);
   UMA_HISTOGRAM_COUNTS("GData.NumberOfTotalFiles", num_total_files);
   const std::vector<int> all_entry_kinds = DocumentEntry::GetAllEntryKinds();
   for (FeedToFileResourceMapUmaStats::EntryKindToCountMap::const_iterator iter =
            uma_stats.num_files_with_entry_kind.begin();
        iter != uma_stats.num_files_with_entry_kind.end();
        ++iter) {
     const DocumentEntry::EntryKind kind = iter->first;
     const int count = iter->second;
     for (int i = 0; i < count; ++i) {
       UMA_HISTOGRAM_CUSTOM_ENUMERATION(
           "GData.EntryKind", kind, all_entry_kinds);
     }
   }
 }
 
-void GDataFileSystem::ApplyFeedFromFileUrlMap(
+void GDataWapiFeedProcessor::ApplyFeedFromFileUrlMap(
     bool is_delta_feed,
     int feed_changestamp,
-    FileResourceIdMap* file_map) {
+    FileResourceIdMap* file_map,
+  std::set<FilePath>* changed_dirs) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  // Don't send directory content change notification while performing
-  // the initial content retrieval.
-  const bool should_notify_directory_changed = is_delta_feed;
-
-  std::set<FilePath> changed_dirs;
+  DCHECK(changed_dirs);
 
   if (!is_delta_feed) {  // Full update.
     directory_service_->root()->RemoveChildren();
-    changed_dirs.insert(directory_service_->root()->GetFilePath());
+    changed_dirs->insert(directory_service_->root()->GetFilePath());
   }
   directory_service_->set_largest_changestamp(feed_changestamp);
 
   scoped_ptr<GDataDirectoryService> orphaned_dir_service(
       new GDataDirectoryService);
   // 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
@@ skipping 10 matching lines @@
       DVLOG(1) << "Removing file " << entry->base_name();
       if (!old_entry)
         continue;
 
       dest_dir = old_entry->parent();
       if (!dest_dir) {
         NOTREACHED();
         continue;
       }
       RemoveEntryFromDirectoryAndCollectChangedDirectories(
-          dest_dir, old_entry, &changed_dirs);
+          dest_dir, old_entry, changed_dirs);
     } else if (old_entry) {  // Change or move of existing entry.
       // Please note that entry rename is just a special case of change here
       // since name is just one of the properties that can change.
       DVLOG(1) << "Changed file " << entry->base_name();
       dest_dir = old_entry->parent();
       if (!dest_dir) {
         NOTREACHED();
         continue;
       }
       // Move children files over if we are dealing with directories.
       if (old_entry->AsGDataDirectory() && entry->AsGDataDirectory()) {
         entry->AsGDataDirectory()->TakeOverEntries(
             old_entry->AsGDataDirectory());
       }
       // Remove the old instance of this entry.
       RemoveEntryFromDirectoryAndCollectChangedDirectories(
-          dest_dir, old_entry, &changed_dirs);
+          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());
+        changed_dirs->insert(dest_dir->GetFilePath());
         dest_dir = FindDirectoryForNewEntry(entry.get(),
                                             *file_map,
                                             orphaned_dir_service.get());
       }
       DCHECK(dest_dir);
       AddEntryToDirectoryAndCollectChangedDirectories(
           entry.release(),
           dest_dir,
           orphaned_dir_service.get(),
-          &changed_dirs);
+          changed_dirs);
     } else {  // Adding a new file.
       dest_dir = FindDirectoryForNewEntry(entry.get(),
                                           *file_map,
                                           orphaned_dir_service.get());
       DCHECK(dest_dir);
       AddEntryToDirectoryAndCollectChangedDirectories(
           entry.release(),
           dest_dir,
           orphaned_dir_service.get(),
-          &changed_dirs);
+          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) {
-      changed_dirs.insert(dest_dir->GetFilePath());
+      changed_dirs->insert(dest_dir->GetFilePath());
     }
   }
   // All entry must be erased from the map.
   DCHECK(file_map->empty());
-
-  if (should_notify_directory_changed) {
-    for (std::set<FilePath>::iterator dir_iter = changed_dirs.begin();
-        dir_iter != changed_dirs.end(); ++dir_iter) {
-      NotifyDirectoryChanged(*dir_iter);
-    }
-  }
 }
 
 // static
-void GDataFileSystem::AddEntryToDirectoryAndCollectChangedDirectories(
+void GDataWapiFeedProcessor::AddEntryToDirectoryAndCollectChangedDirectories(
     GDataEntry* entry,
     GDataDirectory* directory,
     GDataDirectoryService* orphaned_dir_service,
     std::set<FilePath>* changed_dirs) {
   directory->AddEntry(entry);
   if (entry->AsGDataDirectory() && directory != orphaned_dir_service->root())
     changed_dirs->insert(entry->GetFilePath());
 }
 
 // static
-void GDataFileSystem::RemoveEntryFromDirectoryAndCollectChangedDirectories(
+void GDataWapiFeedProcessor::
+RemoveEntryFromDirectoryAndCollectChangedDirectories(
     GDataDirectory* directory,
     GDataEntry* entry,
     std::set<FilePath>* changed_dirs) {
   // Get the list of all sub-directory paths, so we can notify their listeners
   // that they are smoked.
   GetChildDirectoryPaths(entry, changed_dirs);
   directory->RemoveEntry(entry);
 }
 
 // static
 void GDataFileSystem::RemoveStaleEntryOnUpload(const std::string& resource_id,
                                                GDataDirectory* parent_dir,
                                                GDataEntry* existing_entry) {
   if (existing_entry &&
       // This should always match, but just in case.
       existing_entry->parent() == parent_dir) {
     parent_dir->RemoveEntry(existing_entry);
   } else {
     LOG(ERROR) << "Entry for the existing file not found: " << resource_id;
   }
 }
 
-GDataDirectory* GDataFileSystem::FindDirectoryForNewEntry(
+GDataDirectory* GDataWapiFeedProcessor::FindDirectoryForNewEntry(
     GDataEntry* new_entry,
     const FileResourceIdMap& file_map,
     GDataDirectoryService* orphaned_dir_service) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   GDataDirectory* dir = NULL;
   // Added file.
   const std::string& parent_id = new_entry->parent_resource_id();
   if (parent_id.empty()) {
     dir = directory_service_->root();
     DVLOG(1) << "Root parent for " << new_entry->base_name();
@@ skipping 12 matching lines @@
                  << " in file_map " << parent_id;
       } else {
         DVLOG(1) << "Adding orphan " << new_entry->GetFilePath().value();
         dir = orphaned_dir_service->root();
       }
     }
   }
   return dir;
 }
 
-GDataFileError GDataFileSystem::FeedToFileResourceMap(
+GDataFileError GDataWapiFeedProcessor::FeedToFileResourceMap(
     const std::vector<DocumentFeed*>& feed_list,
     FileResourceIdMap* file_map,
     int* 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;
@@ skipping 11 matching lines @@
             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;
       GDataEntry* entry = GDataEntry::FromDocumentEntry(
-          NULL, doc, directory_service_.get());
+          NULL, doc, directory_service_);
       // Some document entries don't map into files (i.e. sites).
       if (!entry)
         continue;
       // Count the number of files.
       GDataFile* as_file = entry->AsGDataFile();
       if (as_file) {
         if (as_file->is_hosted_document())
           ++uma_stats->num_hosted_documents;
         else
           ++uma_stats->num_regular_files;
@@ skipping 709 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