Implement DeleteFile and DeleteDirectory.

device/media_transfer_protocol/media_transfer_protocol_manager.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 "device/media_transfer_protocol/media_transfer_protocol_manager.h"
 
 #include <algorithm>
 #include <map>
 #include <queue>
 #include <set>
@@ skipping 143 matching lines @@
     mtp_client_->CloseStorage(
         storage_handle,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorage,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCloseStorageError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   void ReadDirectory(const std::string& storage_handle,
-                     uint32 file_id,
+                     const uint32 file_id,
+                     const size_t max_size,
                      const ReadDirectoryCallback& callback) override {
     DCHECK(thread_checker_.CalledOnValidThread());
     if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
       callback.Run(std::vector<MtpFileEntry>(),
                    false /* no more entries */,
                    true /* error */);
       return;
     }
     read_directory_callbacks_.push(callback);
     mtp_client_->ReadDirectoryEntryIds(
-        storage_handle,
-        file_id,
-        base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryEntryIds,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   storage_handle),
+        storage_handle, file_id,
+        base::Bind(&MediaTransferProtocolManagerImpl::
+                       OnReadDirectoryEntryIdsToReadDirectory,
+                   weak_ptr_factory_.GetWeakPtr(), storage_handle, max_size),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   void ReadFileChunk(const std::string& storage_handle,
                      uint32 file_id,
                      uint32 offset,
                      uint32 count,
                      const ReadFileCallback& callback) override {
@@ skipping 45 matching lines @@
     }
     copy_file_from_local_callbacks_.push(callback);
     mtp_client_->CopyFileFromLocal(
         storage_handle, source_file_descriptor, parent_id, file_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocal,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnCopyFileFromLocalError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
+  void DeleteObject(const std::string& storage_handle,
+                    const uint32 object_id,
+                    const DeleteObjectCallback& callback) override {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    if (!ContainsKey(handles_, storage_handle) || !mtp_client_) {
+      callback.Run(true /* error */);
+      return;
+    }
+    delete_object_callbacks_.push(callback);
+    mtp_client_->DeleteObject(
+        storage_handle, object_id,
+        base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObject,
+                   weak_ptr_factory_.GetWeakPtr()),
+        base::Bind(&MediaTransferProtocolManagerImpl::OnDeleteObjectError,
+                   weak_ptr_factory_.GetWeakPtr()));
+  }
+
  private:
   // Map of storage names to storage info.
   typedef std::map<std::string, MtpStorageInfo> StorageInfoMap;
   // Callback queues - DBus communication is in-order, thus callbacks are
   // received in the same order as the requests.
   typedef std::queue<OpenStorageCallback> OpenStorageCallbackQueue;
   // (callback, handle)
   typedef std::queue<std::pair<CloseStorageCallback, std::string>
                     > CloseStorageCallbackQueue;
   typedef std::queue<ReadDirectoryCallback> ReadDirectoryCallbackQueue;
   typedef std::queue<ReadFileCallback> ReadFileCallbackQueue;
   typedef std::queue<GetFileInfoCallback> GetFileInfoCallbackQueue;
   typedef std::queue<CopyFileFromLocalCallback> CopyFileFromLocalCallbackQueue;
+  typedef std::queue<DeleteObjectCallback> DeleteObjectCallbackQueue;
 
   void OnStorageAttached(const std::string& storage_name) {
     DCHECK(thread_checker_.CalledOnValidThread());
     mtp_client_->GetStorageInfo(
         storage_name,
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetStorageInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&base::DoNothing));
   }
 
@@ skipping 82 matching lines @@
     }
     close_storage_callbacks_.pop();
   }
 
   void OnCloseStorageError() {
     DCHECK(thread_checker_.CalledOnValidThread());
     close_storage_callbacks_.front().first.Run(true);
     close_storage_callbacks_.pop();
   }
 
-  void OnReadDirectoryEntryIds(const std::string& storage_handle,
-                               const std::vector<uint32>& file_ids) {
+  void OnReadDirectoryEntryIdsToReadDirectory(
+      const std::string& storage_handle,
+      const size_t max_size,
+      const std::vector<uint32>& file_ids) {
     DCHECK(thread_checker_.CalledOnValidThread());
 
     if (file_ids.empty()) {
-      OnGotDirectoryEntries(storage_handle,
-                            file_ids,
-                            kInitialOffset,
-                            file_ids,
-                            std::vector<MtpFileEntry>());
+      OnGotDirectoryEntries(storage_handle, file_ids, kInitialOffset, max_size,
+                            file_ids, std::vector<MtpFileEntry>());
       return;
     }
 
     std::vector<uint32> sorted_file_ids = file_ids;
     std::sort(sorted_file_ids.begin(), sorted_file_ids.end());
 
+    const size_t chunk_size =
+        max_size == 0 ? kFileInfoToFetchChunkSize
+                      : std::min(max_size, kFileInfoToFetchChunkSize);
+
     mtp_client_->GetFileInfo(
-        storage_handle,
-        file_ids,
-        kInitialOffset,
-        kFileInfoToFetchChunkSize,
+        storage_handle, file_ids, kInitialOffset, chunk_size,
         base::Bind(&MediaTransferProtocolManagerImpl::OnGotDirectoryEntries,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   storage_handle,
-                   file_ids,
-                   kInitialOffset,
-                   sorted_file_ids),
+                   weak_ptr_factory_.GetWeakPtr(), storage_handle, file_ids,
+                   kInitialOffset, max_size, sorted_file_ids),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   void OnGotDirectoryEntries(const std::string& storage_handle,
                              const std::vector<uint32>& file_ids,
-                             size_t offset,
+                             const size_t offset,
+                             const size_t max_size,
                              const std::vector<uint32>& sorted_file_ids,
                              const std::vector<MtpFileEntry>& file_entries) {
     DCHECK(thread_checker_.CalledOnValidThread());
     DCHECK_EQ(file_ids.size(), sorted_file_ids.size());
 
     // Use |sorted_file_ids| to sanity check and make sure the results are a
     // subset of the requested file ids.
     for (size_t i = 0; i < file_entries.size(); ++i) {
       std::vector<uint32>::const_iterator it =
           std::lower_bound(sorted_file_ids.begin(),
                            sorted_file_ids.end(),
                            file_entries[i].item_id());
       if (it == sorted_file_ids.end()) {
         OnReadDirectoryError();
         return;
       }
     }
 
-    size_t next_offset = file_ids.size();
+    const size_t directory_size =
+        max_size == 0 ? file_ids.size() : std::min(file_ids.size(), max_size);
+    size_t next_offset = directory_size;
     if (offset < SIZE_MAX - kFileInfoToFetchChunkSize)
       next_offset = std::min(next_offset, offset + kFileInfoToFetchChunkSize);
-    bool has_more = next_offset < file_ids.size();
+    bool has_more = next_offset < directory_size;
     read_directory_callbacks_.front().Run(file_entries,
                                           has_more,
                                           false /* no error */);
+
     if (has_more) {
+      const size_t chunk_size =
+          next_offset + kFileInfoToFetchChunkSize > directory_size

[Lei Zhang, 2015/03/10 08:12:05]

This is just std::min(directory_size - next_offset, kFileInfoToFetchChunkSize);

[yawano, 2015/03/10 08:20:36]

Done.

+              ? directory_size - next_offset
+              : kFileInfoToFetchChunkSize;
+
       mtp_client_->GetFileInfo(
-          storage_handle,
-          file_ids,
-          next_offset,
-          kFileInfoToFetchChunkSize,
+          storage_handle, file_ids, next_offset, chunk_size,
           base::Bind(&MediaTransferProtocolManagerImpl::OnGotDirectoryEntries,
-                     weak_ptr_factory_.GetWeakPtr(),
-                     storage_handle,
-                     file_ids,
-                     next_offset,
-                     sorted_file_ids),
+                     weak_ptr_factory_.GetWeakPtr(), storage_handle, file_ids,
+                     next_offset, max_size, sorted_file_ids),
           base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                      weak_ptr_factory_.GetWeakPtr()));
       return;
     }
     read_directory_callbacks_.pop();
   }
 
   void OnReadDirectoryError() {
     DCHECK(thread_checker_.CalledOnValidThread());
     read_directory_callbacks_.front().Run(std::vector<MtpFileEntry>(),
@@ skipping 35 matching lines @@
     copy_file_from_local_callbacks_.front().Run(false /* no error */);
     copy_file_from_local_callbacks_.pop();
   }
 
   void OnCopyFileFromLocalError() {
     DCHECK(thread_checker_.CalledOnValidThread());
     copy_file_from_local_callbacks_.front().Run(true /* error */);
     copy_file_from_local_callbacks_.pop();
   }
 
+  void OnDeleteObject() {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    delete_object_callbacks_.front().Run(false /* no error */);
+    delete_object_callbacks_.pop();
+  }
+
+  void OnDeleteObjectError() {
+    DCHECK(thread_checker_.CalledOnValidThread());
+    delete_object_callbacks_.front().Run(true /* error */);
+    delete_object_callbacks_.pop();
+  }
+
   // Get the Bus object used to communicate with mtpd.
   dbus::Bus* GetBus() {
     DCHECK(thread_checker_.CalledOnValidThread());
 #if defined(OS_CHROMEOS)
     return chromeos::DBusThreadManager::Get()->GetSystemBus();
 #else
     return session_bus_.get();
 #endif
   }
 
@@ skipping 62 matching lines @@
 
   std::string current_mtpd_owner_;
 
   // Queued callbacks.
   OpenStorageCallbackQueue open_storage_callbacks_;
   CloseStorageCallbackQueue close_storage_callbacks_;
   ReadDirectoryCallbackQueue read_directory_callbacks_;
   ReadFileCallbackQueue read_file_callbacks_;
   GetFileInfoCallbackQueue get_file_info_callbacks_;
   CopyFileFromLocalCallbackQueue copy_file_from_local_callbacks_;
+  DeleteObjectCallbackQueue delete_object_callbacks_;
 
   base::ThreadChecker thread_checker_;
 
   base::WeakPtrFactory<MediaTransferProtocolManagerImpl> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(MediaTransferProtocolManagerImpl);
 };
 
 }  // namespace
 
 // static
 MediaTransferProtocolManager* MediaTransferProtocolManager::Initialize(
     scoped_refptr<base::SequencedTaskRunner> task_runner) {
   DCHECK(!g_media_transfer_protocol_manager);
 
   g_media_transfer_protocol_manager =
       new MediaTransferProtocolManagerImpl(task_runner);
   VLOG(1) << "MediaTransferProtocolManager initialized";
 
   return g_media_transfer_protocol_manager;
 }
 
 }  // namespace device