Make DriveFeedProcessor asynchronous.

chrome/browser/chromeos/drive/drive_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/drive/document_entry_conversion.h"
 #include "chrome/browser/chromeos/drive/drive_feed_processor.h"
 #include "chrome/browser/chromeos/drive/drive_files.h"
@@ skipping 83 matching lines @@
   // Go through all entries generated by the feed and apply them to the local
   // snapshot of the file system.
   ApplyNextEntryProtoAsync();
 }
 
 void DriveFeedProcessor::ApplyNextEntryProtoAsync() {
   base::MessageLoopProxy::current()->PostTask(
       FROM_HERE,
       base::Bind(&DriveFeedProcessor::ApplyNextEntryProto,
                  weak_ptr_factory_.GetWeakPtr()));
-
 }
 
 void DriveFeedProcessor::ApplyNextEntryProto() {
   DCHECK(!on_complete_callback_.is_null());
 
   if (entry_proto_map_.empty()) {
     // All entries have been processed.
     on_complete_callback_.Run();
     return;
   }
@@ skipping 17 matching lines @@
                    weak_ptr_factory_.GetWeakPtr(),
                    parent_it));
   } else {
     // Erase the entry so the deleted entry won't be referenced.
     entry_proto_map_.erase(it);
     ApplyEntryProto(entry_proto);
   }
 }
 
 void DriveFeedProcessor::ApplyEntryProto(const DriveEntryProto& entry_proto) {
-  scoped_ptr<DriveEntry> entry =
-      resource_metadata_->CreateDriveEntryFromProto(entry_proto);
-  DCHECK(entry.get());
-  DriveEntry* old_entry =
-      resource_metadata_->GetEntryByResourceId(entry->resource_id());
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  if (entry->is_deleted()) {
-    // Deleted file/directory.
-    DVLOG(1) << "Removing file " << entry->base_name();
-    if (old_entry)
-      RemoveEntryFromParent(old_entry);
-  } 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();
+  // Lookup the entry.
+  resource_metadata_->GetEntryInfoByResourceId(
+      entry_proto.resource_id(),
+      base::Bind(&DriveFeedProcessor::ContinueApplyEntryProto,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 entry_proto));
+}
 
-    // Move children files over if we are dealing with directories.
-    if (old_entry->AsDriveDirectory() && entry->AsDriveDirectory()) {
-      entry->AsDriveDirectory()->TakeOverEntries(
-          old_entry->AsDriveDirectory());
+void DriveFeedProcessor::ContinueApplyEntryProto(
+    const DriveEntryProto& entry_proto,
+    DriveFileError error,
+    const FilePath& file_path,
+    scoped_ptr<DriveEntryProto> old_entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (error == DRIVE_FILE_OK) {
+    if (entry_proto.deleted()) {
+      // Deleted file/directory.
+      RemoveEntryFromParent(entry_proto, file_path);
+    } else {
+      // Entry exists and needs to be refreshed.
+      RefreshEntryProto(entry_proto, file_path);
     }
+  } else if (error == DRIVE_FILE_ERROR_NOT_FOUND && !entry_proto.deleted()) {
+    // Adding a new entry.
+    AddEntryToParent(entry_proto);
+  } else {
+    // Continue.
+    ApplyNextEntryProtoAsync();
+  }
+}
 
-    // Remove the old instance of this entry.
-    RemoveEntryFromParent(old_entry);
+void DriveFeedProcessor::RefreshEntryProto(const DriveEntryProto& entry_proto,
+                                           const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-    // Add to parent.
-    AddEntryToParent(entry.release());
-  } else {
-    // Adding a new file.
-    AddEntryToParent(entry.release());
+  resource_metadata_->RefreshEntryProto(
+      entry_proto,
+      base::Bind(&DriveFeedProcessor::NotifyForRefreshEntryProto,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 file_path));
+}
+
+void DriveFeedProcessor::NotifyForRefreshEntryProto(
+    const FilePath& old_file_path,
+    DriveFileError error,
+    const FilePath& file_path,
+    scoped_ptr<DriveEntryProto> entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DVLOG(1) << "NotifyForRefreshEntryProto " << file_path.value();
+  if (error == DRIVE_FILE_OK) {
+    // Notify old parent.
+    changed_dirs_.insert(old_file_path.DirName());
+
+    // Notify new parent.
+    changed_dirs_.insert(file_path.DirName());
+
+    // Notify self if entry is a directory.
+    if (entry_proto->file_info().is_directory()) {
+      // Notify new self.
+      changed_dirs_.insert(file_path);
+      // Notify old self.
+      changed_dirs_.insert(old_file_path);
+    }
   }
 
-  // Process the next DriveEntryProto from the map.
   ApplyNextEntryProtoAsync();
 }
 
-void DriveFeedProcessor::AddEntryToParent(
-    DriveEntry* entry) {
+void DriveFeedProcessor::AddEntryToParent(const DriveEntryProto& entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  resource_metadata_->AddEntryToParent(entry_proto,
+      base::Bind(&DriveFeedProcessor::NotifyForAddEntryToParent,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 entry_proto.file_info().is_directory()));
+}
+
+void DriveFeedProcessor::NotifyForAddEntryToParent(bool is_directory,
+                                                   DriveFileError error,
+                                                   const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DVLOG(1) << "NotifyForAddEntryToParent " << file_path.value();
+  if (error == DRIVE_FILE_OK) {
+    // Notify if a directory has been created.
+    if (is_directory)
+      changed_dirs_.insert(file_path);
+
+    // Notify parent.
+    changed_dirs_.insert(file_path.DirName());
+  }
+
+  ApplyNextEntryProtoAsync();
+}
+
+
+void DriveFeedProcessor::RemoveEntryFromParent(
+    const DriveEntryProto& entry_proto,
+    const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!file_path.empty());
+
+  if (!entry_proto.file_info().is_directory()) {
+    // No children if entry is a file.
+    OnGetChildrenForRemove(entry_proto,
+                           file_path,
+                           std::set<FilePath>());
+  } else {
+    // If entry is a directory, notify its children.
+    resource_metadata_->GetChildDirectories(
+        entry_proto.resource_id(),
+        base::Bind(&DriveFeedProcessor::OnGetChildrenForRemove,
+                   weak_ptr_factory_.GetWeakPtr(),
+                   entry_proto,
+                   file_path));
+  }
+}
+
+void DriveFeedProcessor::OnGetChildrenForRemove(
+    const DriveEntryProto& entry_proto,
+    const FilePath& file_path,
+    const std::set<FilePath>& changed_directories) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  DCHECK(!file_path.empty());
+
+  resource_metadata_->RemoveEntryFromParent(
+      entry_proto.resource_id(),
+      base::Bind(&DriveFeedProcessor::NotifyForRemoveEntryFromParent,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 entry_proto.file_info().is_directory(),
+                 file_path,
+                 changed_directories));
+}
+
+void DriveFeedProcessor::NotifyForRemoveEntryFromParent(
+    bool is_directory,
+    const FilePath& file_path,
+    const std::set<FilePath>& changed_directories,
+    DriveFileError error,
+    const FilePath& parent_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  DVLOG(1) << "NotifyForRemoveEntryFromParent " << file_path.value();
+  if (error == DRIVE_FILE_OK) {
+    // Notify parent.
+    changed_dirs_.insert(parent_path);
+
+    // Notify children, if any.
+    changed_dirs_.insert(changed_directories.begin(),
+                         changed_directories.end());
+
+    // If entry is a directory, notify self.
+    if (is_directory)
+      changed_dirs_.insert(file_path);
+  }
+
+  // Continue.
+  ApplyNextEntryProtoAsync();
+}
+
+void DriveFeedProcessor::AddEntryToParentDeprecated(DriveEntry* entry) {
   DriveDirectory* parent = ResolveParent(entry);
 
   if (!parent) {  // Orphan.
     delete entry;
     return;
   }
   parent->AddEntry(entry);
 
   // Notify this directory that has been created.
   if (entry->AsDriveDirectory())
     changed_dirs_.insert(entry->GetFilePath());
 
   // Notify |parent| only if it already exists by checking if it is attached to
   // the tree (has parent) or if it is root. The parent of |parent| may not
   // exist here if it is about to be created later in the same feed.
   if (parent->parent() || parent == resource_metadata_->root())
     changed_dirs_.insert(parent->GetFilePath());
 }
 
-void DriveFeedProcessor::RemoveEntryFromParent(
-    DriveEntry* entry) {
+void DriveFeedProcessor::RemoveEntryFromParent(DriveEntry* entry) {
   DriveDirectory* parent = entry->parent();
   if (!parent) {
     NOTREACHED();
     return;
   }
 
   DriveDirectory* dir = entry->AsDriveDirectory();
-  if (dir) {
-    // We need to notify all children of entry if entry is a directory.
+  // Notify all children of entry, if entry is a directory.
+  if (dir)
     dir->GetChildDirectoryPaths(&changed_dirs_);
-    // Besides children, notify this removed directory too.
-    changed_dirs_.insert(dir->GetFilePath());
-  }
 
   parent->RemoveEntry(entry);
 
   // Notify parent.
   changed_dirs_.insert(parent->GetFilePath());
 }
 
-DriveDirectory* DriveFeedProcessor::ResolveParent(
-    DriveEntry* new_entry) {
+DriveDirectory* DriveFeedProcessor::ResolveParent(DriveEntry* new_entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const std::string& parent_resource_id = new_entry->parent_resource_id();
   if (parent_resource_id.empty()) {
     DVLOG(1) << "Root parent for " << new_entry->base_name();
     return resource_metadata_->root();
   }
 
   DriveEntry* parent =
       resource_metadata_->GetEntryByResourceId(parent_resource_id);
@@ skipping 26 matching lines @@
     }
 
     for (size_t j = 0; j < feed->entries().size(); ++j) {
       const google_apis::DocumentEntry* doc = feed->entries()[j];
       DriveEntryProto entry_proto = ConvertDocumentEntryToDriveEntryProto(*doc);
       // Some document entries don't map into files (i.e. sites).
       if (entry_proto.resource_id().empty())
         continue;
 
       // Count the number of files.
-      if (uma_stats && entry_proto.has_file_specific_info()) {
+      if (uma_stats && !entry_proto.file_info().is_directory()) {
         uma_stats->IncrementNumFiles(
             entry_proto.file_specific_info().is_hosted_document());
       }
 
       std::pair<DriveEntryProtoMap::iterator, bool> ret = entry_proto_map_.
           insert(std::make_pair(entry_proto.resource_id(), entry_proto));
       DCHECK(ret.second);
       if (!ret.second)
         LOG(WARNING) << "Found duplicate file " << entry_proto.base_name();
     }
   }
 }
 
 void DriveFeedProcessor::Clear() {
   entry_proto_map_.clear();
   changed_dirs_.clear();
   on_complete_callback_.Reset();
 }
 
 }  // namespace drive