| // 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_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( |
| DriveResourceMetadata* resource_metadata) |
| : resource_metadata_(resource_metadata) { |
| } |
| |
| GDataWapiFeedProcessor::~GDataWapiFeedProcessor() { |
| } |
| |
| DriveFileError GDataWapiFeedProcessor::ApplyFeeds( |
| const ScopedVector<DocumentFeed>& feed_list, |
| int64 start_changestamp, |
| int64 root_feed_changestamp, |
| std::set<FilePath>* changed_dirs) { |
| bool is_delta_feed = start_changestamp != 0; |
| |
| resource_metadata_->set_origin(FROM_SERVER); |
| |
| int64 delta_feed_changestamp = 0; |
| FeedToFileResourceMapUmaStats uma_stats; |
| FileResourceIdMap file_map; |
| DriveFileError error = FeedToFileResourceMap(feed_list, |
| &file_map, |
| &delta_feed_changestamp, |
| &uma_stats); |
| if (error != DRIVE_FILE_OK) |
| return error; |
| |
| ApplyFeedFromFileUrlMap( |
| is_delta_feed, |
| is_delta_feed ? delta_feed_changestamp : root_feed_changestamp, |
| &file_map, |
| changed_dirs); |
| |
| // Shouldn't record histograms when processing delta feeds. |
| if (!is_delta_feed) |
| UpdateFileCountUmaHistograms(uma_stats); |
| |
| return DRIVE_FILE_OK; |
| } |
| |
| 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("Drive.NumberOfRegularFiles", |
| uma_stats.num_regular_files); |
| UMA_HISTOGRAM_COUNTS("Drive.NumberOfHostedDocuments", |
| uma_stats.num_hosted_documents); |
| UMA_HISTOGRAM_COUNTS("Drive.NumberOfTotalFiles", num_total_files); |
| 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 DriveEntryKind kind = iter->first; |
| const int count = iter->second; |
| for (int i = 0; i < count; ++i) { |
| UMA_HISTOGRAM_ENUMERATION( |
| "Drive.EntryKind", kind, ENTRY_KIND_MAX_VALUE); |
| } |
| } |
| for (FeedToFileResourceMapUmaStats::FileFormatToCountMap::const_iterator |
| iter = uma_stats.num_files_with_file_format.begin(); |
| iter != uma_stats.num_files_with_file_format.end(); |
| ++iter) { |
| const DriveFileFormat format = iter->first; |
| const int count = iter->second; |
| for (int i = 0; i < count; ++i) { |
| UMA_HISTOGRAM_ENUMERATION( |
| "Drive.FileFormat", format, FILE_FORMAT_MAX_VALUE); |
| } |
| } |
| } |
| |
| 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. |
| resource_metadata_->root()->RemoveChildren(); |
| changed_dirs->insert(resource_metadata_->root()->GetFilePath()); |
| } |
| resource_metadata_->set_largest_changestamp(feed_changestamp); |
| |
| 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 = |
| 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; |
| } |
| RemoveEntryFromDirectoryAndCollectChangedDirectories( |
| 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->AsDriveDirectory() && entry->AsDriveDirectory()) { |
| entry->AsDriveDirectory()->TakeOverEntries( |
| 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_resources.get()); |
| } |
| DCHECK(dest_dir); |
| AddEntryToDirectoryAndCollectChangedDirectories( |
| entry.release(), |
| dest_dir, |
| orphaned_resources.get(), |
| changed_dirs); |
| } else { // Adding a new file. |
| dest_dir = FindDirectoryForNewEntry(entry.get(), |
| *file_map, |
| orphaned_resources.get()); |
| DCHECK(dest_dir); |
| AddEntryToDirectoryAndCollectChangedDirectories( |
| entry.release(), |
| dest_dir, |
| 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 == 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, |
| DriveResourceMetadata* orphaned_resources, |
| std::set<FilePath>* changed_dirs) { |
| directory->AddEntry(entry); |
| 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, |
| 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 = resource_metadata_->root(); |
| DVLOG(1) << "Root parent for " << new_entry->base_name(); |
| } else { |
| 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_resources->root(); |
| } |
| } |
| } |
| return dir; |
| } |
| |
| DriveFileError GDataWapiFeedProcessor::FeedToFileResourceMap( |
| const ScopedVector<DocumentFeed>& feed_list, |
| FileResourceIdMap* file_map, |
| int64* feed_changestamp, |
| FeedToFileResourceMapUmaStats* uma_stats) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| DCHECK(uma_stats); |
| |
| DriveFileError error = DRIVE_FILE_OK; |
| uma_stats->num_regular_files = 0; |
| uma_stats->num_hosted_documents = 0; |
| uma_stats->num_files_with_entry_kind.clear(); |
| uma_stats->num_files_with_file_format.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::LINK_RESUMABLE_CREATE_MEDIA); |
| if (root_feed_upload_link) |
| 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; |
| scoped_ptr<DriveEntry> entry = |
| resource_metadata_->FromDocumentEntry(*doc); |
| // Some document entries don't map into files (i.e. sites). |
| if (!entry.get()) |
| 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; |
| const FilePath::StringType extension = |
| FilePath(as_file->base_name()).Extension(); |
| const DriveFileFormat format = GetDriveFileFormat(extension); |
| ++uma_stats->num_files_with_file_format[format]; |
| } |
| ++uma_stats->num_files_with_entry_kind[as_file->kind()]; |
| } |
| |
| FileResourceIdMap::iterator map_entry = |
| file_map->find(entry->resource_id()); |
| |
| // An entry with the same self link may already exist, so we need to |
| // release the existing DriveEntry instance before overwriting the |
| // entry with another DriveEntry instance. |
| if (map_entry != file_map->end()) { |
| LOG(WARNING) << "Found duplicate file " |
| << map_entry->second->base_name(); |
| |
| delete map_entry->second; |
| file_map->erase(map_entry); |
| } |
| // Must use this temporary because entry.release() may be evaluated |
| // first in make_pair. |
| const std::string& resource_id = entry->resource_id(); |
| file_map->insert(std::make_pair(resource_id, entry.release())); |
| } |
| } |
| |
| if (error != DRIVE_FILE_OK) { |
| // 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 |
