Files.app: Provide detailed change information on onDirectoryChanged event

chrome/browser/chromeos/drive/file_system/copy_operation.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/drive/file_system/copy_operation.h"
 
 #include <string>
 
 #include "base/file_util.h"
 #include "base/task_runner_util.h"
 #include "chrome/browser/chromeos/drive/drive.pb.h"
 #include "chrome/browser/chromeos/drive/file_cache.h"
+#include "chrome/browser/chromeos/drive/file_change.h"
 #include "chrome/browser/chromeos/drive/file_system/create_file_operation.h"
 #include "chrome/browser/chromeos/drive/file_system/operation_observer.h"
 #include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/drive/job_scheduler.h"
 #include "chrome/browser/chromeos/drive/resource_entry_conversion.h"
 #include "chrome/browser/chromeos/drive/resource_metadata.h"
 #include "chrome/browser/drive/drive_api_util.h"
 #include "content/public/browser/browser_thread.h"
 #include "google_apis/drive/drive_api_parser.h"
 
@@ skipping 133 matching lines @@
     return error;
 
   return cache->Store(local_id, std::string(), cache_file_path,
                       internal::FileCache::FILE_OPERATION_COPY);
 }
 
 // Stores the entry returned from the server and returns its path.
 FileError UpdateLocalStateForServerSideOperation(
     internal::ResourceMetadata* metadata,
     scoped_ptr<google_apis::FileResource> file_resource,
+    ResourceEntry* resource_entry,

[kinaba, 2014/06/23 05:37:43]

ResourceEntry* entry

should be ok.

[yoshiki, 2014/06/24 02:02:22]

Done.

     base::FilePath* file_path) {
   DCHECK(file_resource);
 
-  ResourceEntry entry;
   std::string parent_resource_id;
-  if (!ConvertFileResourceToResourceEntry(*file_resource, &entry,
-                                          &parent_resource_id) ||
+  if (!ConvertFileResourceToResourceEntry(
+          *file_resource, resource_entry, &parent_resource_id) ||
       parent_resource_id.empty())
     return FILE_ERROR_NOT_A_FILE;
 
   std::string parent_local_id;
   FileError error = metadata->GetIdByResourceId(parent_resource_id,
                                                 &parent_local_id);
   if (error != FILE_ERROR_OK)
     return error;
-  entry.set_parent_local_id(parent_local_id);
+  resource_entry->set_parent_local_id(parent_local_id);
 
   std::string local_id;
-  error = metadata->AddEntry(entry, &local_id);
+  error = metadata->AddEntry(*resource_entry, &local_id);
   // Depending on timing, the metadata may have inserted via change list
   // already. So, FILE_ERROR_EXISTS is not an error.
   if (error == FILE_ERROR_EXISTS)
-    error = metadata->GetIdByResourceId(entry.resource_id(), &local_id);
+    error =
+        metadata->GetIdByResourceId(resource_entry->resource_id(), &local_id);
 
   if (error != FILE_ERROR_OK)
     return error;
 
   return metadata->GetFilePath(local_id, file_path);
 }
 
 // Stores the file at |local_file_path| to the cache as a content of entry at
 // |remote_dest_path|, and marks it dirty.
 FileError UpdateLocalStateForScheduleTransfer(
     internal::ResourceMetadata* metadata,
     internal::FileCache* cache,
     const base::FilePath& local_src_path,
     const base::FilePath& remote_dest_path,
+    ResourceEntry* entry,
     std::string* local_id) {
   FileError error = metadata->GetIdByPath(remote_dest_path, local_id);
   if (error != FILE_ERROR_OK)
     return error;
 
-  ResourceEntry entry;
-  error = metadata->GetResourceEntryById(*local_id, &entry);
+  error = metadata->GetResourceEntryById(*local_id, entry);
   if (error != FILE_ERROR_OK)
     return error;
 
   return cache->Store(*local_id, std::string(), local_src_path,
                       internal::FileCache::FILE_OPERATION_COPY);
 }
 
 // Gets the file size of the |local_path|, and the ResourceEntry for the parent
 // of |remote_path| to prepare the necessary information for transfer.
 FileError PrepareTransferFileFromLocalToRemote(
@@ skipping 109 matching lines @@
     const std::vector<std::string>* updated_local_ids,
     const bool* directory_changed,
     const bool* should_copy_on_server,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!params->callback.is_null());
 
   for (size_t i = 0; i < updated_local_ids->size(); ++i)
     observer_->OnEntryUpdatedByOperation((*updated_local_ids)[i]);
 
-  if (*directory_changed)
-    observer_->OnDirectoryChangedByOperation(params->dest_file_path.DirName());
+  if (*directory_changed) {
+    FileChange changed_file;
+    DCHECK(params->src_entry.file_info().is_directory());
+    changed_file.Update(params->dest_file_path,
+                        FileChange::FILE_TYPE_FILE,
+                        FileChange::ADD_OR_UPDATE);
+    observer_->OnDirectoryChangedByOperation(changed_file);
+  }
 
   if (error != FILE_ERROR_OK || !*should_copy_on_server) {
     params->callback.Run(error);
     return;
   }
 
   base::FilePath new_title = params->dest_file_path.BaseName();
   if (params->src_entry.file_specific_info().is_hosted_document()) {
     // Drop the document extension, which should not be in the title.
     // TODO(yoshiki): Remove this code with crbug.com/223304.
@@ skipping 91 matching lines @@
     case HAS_PARENT:
       CopyResourceOnServer(params->resource_id,
                            params->parent_resource_id,
                            params->new_title,
                            base::Time(),
                            params->callback);
       break;
     // When |resource_id| has no parent, we just set the new destination folder
     // as the parent, for sharing the document between the original source.
     // This reparenting is already done in LocalWorkForTransferJsonGdocFile().
-    case IS_ORPHAN:
+    case IS_ORPHAN: {
       DCHECK(!params->changed_path.empty());
       observer_->OnEntryUpdatedByOperation(params->local_id);
-      observer_->OnDirectoryChangedByOperation(params->changed_path.DirName());
+
+      FileChange changed_file;
+      changed_file.Update(
+          params->changed_path,
+          FileChange::FILE_TYPE_FILE,  // This must be a hosted document.
+          FileChange::ADD_OR_UPDATE);
+      observer_->OnDirectoryChangedByOperation(changed_file);
       params->callback.Run(error);
       break;
+    }
     // When the |resource_id| is not in the local metadata, assume it to be a
     // document just now shared on the server but not synced locally.
     // Same as the IS_ORPHAN case, we want to deal the case by setting parent,
     // but this time we need to resort to server side operation.
     case NOT_IN_METADATA:
       scheduler_->UpdateResource(
           params->resource_id,
           params->parent_resource_id,
           params->new_title,
           base::Time(),
@@ skipping 28 matching lines @@
     scoped_ptr<google_apis::FileResource> entry) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   FileError error = GDataToFileError(status);
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
 
+  ResourceEntry* resource_entry = new ResourceEntry;
+
   // The copy on the server side is completed successfully. Update the local
   // metadata.
   base::FilePath* file_path = new base::FilePath;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
       base::Bind(&UpdateLocalStateForServerSideOperation,
-                 metadata_, base::Passed(&entry), file_path),
+                 metadata_,
+                 base::Passed(&entry),
+                 resource_entry,
+                 file_path),
       base::Bind(&CopyOperation::UpdateAfterLocalStateUpdate,
                  weak_ptr_factory_.GetWeakPtr(),
-                 callback, base::Owned(file_path)));
+                 callback,
+                 base::Owned(file_path),
+                 base::Owned(resource_entry)));
 }
 
 void CopyOperation::UpdateAfterLocalStateUpdate(
     const FileOperationCallback& callback,
     base::FilePath* file_path,
+    const ResourceEntry* entry,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
-  if (error == FILE_ERROR_OK)
-    observer_->OnDirectoryChangedByOperation(file_path->DirName());
+  if (error == FILE_ERROR_OK) {
+    FileChange changed_file;
+    changed_file.Update(*file_path, *entry, FileChange::ADD_OR_UPDATE);
+    observer_->OnDirectoryChangedByOperation(changed_file);
+  }
   callback.Run(error);
 }
 
 void CopyOperation::ScheduleTransferRegularFile(
     const base::FilePath& local_src_path,
     const base::FilePath& remote_dest_path,
     const FileOperationCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
@@ skipping 13 matching lines @@
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error != FILE_ERROR_OK) {
     callback.Run(error);
     return;
   }
 
   std::string* local_id = new std::string;
+  ResourceEntry* entry = new ResourceEntry;
   base::PostTaskAndReplyWithResult(
       blocking_task_runner_.get(),
       FROM_HERE,
-      base::Bind(
-          &UpdateLocalStateForScheduleTransfer,
-          metadata_, cache_, local_src_path, remote_dest_path, local_id),
+      base::Bind(&UpdateLocalStateForScheduleTransfer,
+                 metadata_,
+                 cache_,
+                 local_src_path,
+                 remote_dest_path,
+                 entry,
+                 local_id),
       base::Bind(
           &CopyOperation::ScheduleTransferRegularFileAfterUpdateLocalState,
-          weak_ptr_factory_.GetWeakPtr(), callback, remote_dest_path,
+          weak_ptr_factory_.GetWeakPtr(),
+          callback,
+          remote_dest_path,
+          base::Owned(entry),
           base::Owned(local_id)));
 }
 
 void CopyOperation::ScheduleTransferRegularFileAfterUpdateLocalState(
     const FileOperationCallback& callback,
     const base::FilePath& remote_dest_path,
+    const ResourceEntry* entry,
     std::string* local_id,
     FileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   DCHECK(!callback.is_null());
 
   if (error == FILE_ERROR_OK) {
-    observer_->OnDirectoryChangedByOperation(remote_dest_path.DirName());
+    FileChange changed_file;
+    changed_file.Update(remote_dest_path, *entry, FileChange::ADD_OR_UPDATE);
+    observer_->OnDirectoryChangedByOperation(changed_file);
     observer_->OnEntryUpdatedByOperation(*local_id);
   }
   callback.Run(error);
 }
 
 }  // namespace file_system
 }  // namespace drive