Devices: Remove MTP functions that use file paths.

device/media_transfer_protocol/media_transfer_protocol_daemon_client.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_daemon_client.h"
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "dbus/bus.h"
 #include "dbus/message.h"
@@ skipping 78 matching lines @@
     writer.AppendString(handle);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnCloseStorage,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
-  virtual void ReadDirectoryByPath(
-      const std::string& handle,
-      const std::string& path,
-      const ReadDirectoryCallback& callback,
-      const ErrorCallback& error_callback) OVERRIDE {
-    dbus::MethodCall method_call(mtpd::kMtpdInterface,
-                                 mtpd::kReadDirectoryByPath);
-    dbus::MessageWriter writer(&method_call);
-    writer.AppendString(handle);
-    writer.AppendString(path);
-    proxy_->CallMethod(
-        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadDirectory,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback,
-                   error_callback));
-  }
-
-  // MediaTransferProtocolDaemonClient override.
   virtual void ReadDirectoryById(
       const std::string& handle,
       uint32 file_id,
       const ReadDirectoryCallback& callback,
       const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(mtpd::kMtpdInterface,
                                  mtpd::kReadDirectoryById);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(file_id);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadDirectory,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
-  virtual void ReadFileChunkByPath(
-      const std::string& handle,
-      const std::string& path,
-      uint32 offset,
-      uint32 bytes_to_read,
-      const ReadFileCallback& callback,
-      const ErrorCallback& error_callback) OVERRIDE {
-    DCHECK_LE(bytes_to_read, kMaxChunkSize);
-    dbus::MethodCall method_call(mtpd::kMtpdInterface,
-                                 mtpd::kReadFileChunkByPath);
-    dbus::MessageWriter writer(&method_call);
-    writer.AppendString(handle);
-    writer.AppendString(path);
-    writer.AppendUint32(offset);
-    writer.AppendUint32(bytes_to_read);
-    proxy_->CallMethod(
-        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadFile,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback,
-                   error_callback));
-  }
-
-  // MediaTransferProtocolDaemonClient override.
   virtual void ReadFileChunkById(const std::string& handle,
                                  uint32 file_id,
                                  uint32 offset,
                                  uint32 bytes_to_read,
                                  const ReadFileCallback& callback,
                                  const ErrorCallback& error_callback) OVERRIDE {
     DCHECK_LE(bytes_to_read, kMaxChunkSize);
     dbus::MethodCall method_call(mtpd::kMtpdInterface,
                                  mtpd::kReadFileChunkById);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(file_id);
     writer.AppendUint32(offset);
     writer.AppendUint32(bytes_to_read);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
         base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadFile,
                    weak_ptr_factory_.GetWeakPtr(),
                    callback,
                    error_callback));
   }
 
   // MediaTransferProtocolDaemonClient override.
-  virtual void GetFileInfoByPath(const std::string& handle,
-                                 const std::string& path,
-                                 const GetFileInfoCallback& callback,
-                                 const ErrorCallback& error_callback) OVERRIDE {
-    dbus::MethodCall method_call(mtpd::kMtpdInterface,
-                                 mtpd::kGetFileInfoByPath);
-    dbus::MessageWriter writer(&method_call);
-    writer.AppendString(handle);
-    writer.AppendString(path);
-    proxy_->CallMethod(
-        &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
-        base::Bind(&MediaTransferProtocolDaemonClientImpl::OnGetFileInfo,
-                   weak_ptr_factory_.GetWeakPtr(),
-                   callback,
-                   error_callback));
-  }
-
-  // MediaTransferProtocolDaemonClient override.
   virtual void GetFileInfoById(const std::string& handle,
                                uint32 file_id,
                                const GetFileInfoCallback& callback,
                                const ErrorCallback& error_callback) OVERRIDE {
     dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kGetFileInfoById);
     dbus::MessageWriter writer(&method_call);
     writer.AppendString(handle);
     writer.AppendUint32(file_id);
     proxy_->CallMethod(
         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
@@ skipping 54 matching lines @@
     }
     callback.Run(storage_names);
   }
 
   // Handles the result of GetStorageInfo and calls |callback| or
   // |error_callback|.
   void OnGetStorageInfo(const std::string& storage_name,
                         const GetStorageInfoCallback& callback,
                         const ErrorCallback& error_callback,
                         dbus::Response* response) {
+    LOG(ERROR) << "Client OnGetStorageInfo " << storage_name;
     if (!response) {
       error_callback.Run();
       return;
     }
 
     dbus::MessageReader reader(response);
     MtpStorageInfo protobuf;
     if (!reader.PopArrayOfBytesAsProto(&protobuf)) {
       LOG(ERROR) << kInvalidResponseMsg << response->ToString();
       error_callback.Run();
@@ skipping 25 matching lines @@
   void OnCloseStorage(const CloseStorageCallback& callback,
                       const ErrorCallback& error_callback,
                       dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
     callback.Run();
   }
 
-  // Handles the result of ReadDirectoryByPath/Id and calls |callback| or
+  // Handles the result of ReadDirectoryById and calls |callback| or
   // |error_callback|.
   void OnReadDirectory(const ReadDirectoryCallback& callback,
                        const ErrorCallback& error_callback,
                        dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
 
     std::vector<MtpFileEntry> file_entries;
     dbus::MessageReader reader(response);
     MtpFileEntries entries_protobuf;
     if (!reader.PopArrayOfBytesAsProto(&entries_protobuf)) {
       LOG(ERROR) << kInvalidResponseMsg << response->ToString();
       error_callback.Run();
       return;
     }
 
     for (int i = 0; i < entries_protobuf.file_entries_size(); ++i)
       file_entries.push_back(entries_protobuf.file_entries(i));
     callback.Run(file_entries);
   }
 
-  // Handles the result of ReadFileChunkByPath/Id and calls |callback| or
+  // Handles the result of ReadFileChunkById and calls |callback| or
   // |error_callback|.
   void OnReadFile(const ReadFileCallback& callback,
                   const ErrorCallback& error_callback,
                   dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
 
     const uint8* data_bytes = NULL;
     size_t data_length = 0;
     dbus::MessageReader reader(response);
     if (!reader.PopArrayOfBytes(&data_bytes, &data_length)) {
       error_callback.Run();
       return;
     }
     std::string data(reinterpret_cast<const char*>(data_bytes), data_length);
     callback.Run(data);
   }
 
-  // Handles the result of GetFileInfoByPath/Id and calls |callback| or
+  // Handles the result of GetFileInfoById and calls |callback| or
   // |error_callback|.
   void OnGetFileInfo(const GetFileInfoCallback& callback,
                      const ErrorCallback& error_callback,
                      dbus::Response* response) {
     if (!response) {
       error_callback.Run();
       return;
     }
 
     dbus::MessageReader reader(response);
@@ skipping 49 matching lines @@
 
 MediaTransferProtocolDaemonClient::~MediaTransferProtocolDaemonClient() {}
 
 // static
 MediaTransferProtocolDaemonClient* MediaTransferProtocolDaemonClient::Create(
     dbus::Bus* bus) {
   return new MediaTransferProtocolDaemonClientImpl(bus);
 }
 
 }  // namespace device