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();
-
-    // 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.
-    RemoveEntryFromParent(old_entry);
-
-    // Add to parent.
-    AddEntryToParent(entry.release());
-  } else {
-    // Adding a new file.
-    AddEntryToParent(entry.release());
+  // Deleted file/directory.
+  if (entry_proto.deleted()) {
+    DVLOG(1) << "RemoveEntryFromParent " << entry_proto.base_name();
+    RemoveEntryFromParent(entry_proto.resource_id());
+    return;
   }
 
-  // Process the next DriveEntryProto from the map.
+  resource_metadata_->GetEntryInfoByResourceId(entry_proto.resource_id(),
+      base::Bind(&DriveFeedProcessor::ContinueApplyEntryProto,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 entry_proto));
+}
+
+void DriveFeedProcessor::ContinueApplyEntryProto(
+    const DriveEntryProto& entry_proto,
+    DriveFileError error,
+    const FilePath& drive_file_path,
+    scoped_ptr<DriveEntryProto> old_entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (error == DRIVE_FILE_OK) {
+    // Entry exists and needs to be refreshed.
+    RefreshEntryProto(entry_proto);
+  } else {
+    // Adding a new entry.
+    AddEntryToParent(entry_proto);
+  }
+}
+
+void DriveFeedProcessor::RefreshEntryProto(const DriveEntryProto& entry_proto) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // Get all directories to be notified.
+  resource_metadata_->GetChangedDirectories(
+      entry_proto.resource_id(),
+      base::Bind(&DriveFeedProcessor::ContinueRefreshEntryProto,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 entry_proto));
+}
+
+void DriveFeedProcessor::ContinueRefreshEntryProto(
+    const DriveEntryProto& entry_proto,
+    const std::set<FilePath>& changed_directories) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  resource_metadata_->RefreshEntryProto(
+      entry_proto,
+      base::Bind(&DriveFeedProcessor::NotifyForRefreshEntryProto,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 changed_directories));
+}
+
+void DriveFeedProcessor::NotifyForRefreshEntryProto(
+    const std::set<FilePath>& changed_directories,
+    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 children, old self and parent of old self.
+    changed_dirs_.insert(changed_directories.begin(),
+                         changed_directories.end());
+
+    // Notify new parent.
+    changed_dirs_.insert(file_path.DirName());
+
+    // Notify new self.
+    if (!entry_proto->has_file_specific_info())
+      changed_dirs_.insert(file_path);
+  }
+
   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.has_file_specific_info()));
+}
+
+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 std::string& resource_id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  // We need to notify all children of entry if entry is a directory.
+  resource_metadata_->GetChangedDirectories(
+      resource_id,
+      base::Bind(&DriveFeedProcessor::ContinueRemoveEntryFromParent,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 resource_id));
+}
+
+void DriveFeedProcessor::ContinueRemoveEntryFromParent(
+    const std::string& resource_id,
+    const std::set<FilePath>& changed_directories) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  resource_metadata_->RemoveEntryFromParent(
+      resource_id,
+      base::Bind(&DriveFeedProcessor::NotifyForRemoveEntryFromParent,
+                 weak_ptr_factory_.GetWeakPtr(),
+                 changed_directories));
+}
+
+void DriveFeedProcessor::NotifyForRemoveEntryFromParent(
+    const std::set<FilePath>& changed_directories,
+    DriveFileError error,
+    const FilePath& file_path) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  if (error == DRIVE_FILE_OK) {
+    changed_dirs_.insert(changed_directories.begin(),
+                         changed_directories.end());
+  }
+  ApplyNextEntryProtoAsync();
+}
+
+void DriveFeedProcessor::AddEntryToParent(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) {
+  if (dir)
     // We need to notify all children of entry if entry is a directory.
     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 47 matching lines @@
   }
 }
 
 void DriveFeedProcessor::Clear() {
   entry_proto_map_.clear();
   changed_dirs_.clear();
   on_complete_callback_.Reset();
 }
 
 }  // namespace drive