CrOS: Convert MediaTransferProtocolDaemonClient to use protobufs.

chrome/browser/chromeos/mtp/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 "chrome/browser/chromeos/mtp/media_transfer_protocol_manager.h"
 
 #include <map>
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/stl_util.h"
 #include "chromeos/dbus/dbus_thread_manager.h"
+#include "chromeos/dbus/mtp_file_entry.pb.h"
+#include "chromeos/dbus/mtp_storage_info.pb.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace chromeos {
 namespace mtp {
 
 namespace {
 
 MediaTransferProtocolManager* g_media_transfer_protocol_manager = NULL;
@@ skipping 34 matching lines @@
     std::vector<std::string> storages;
     for (StorageInfoMap::const_iterator it = storage_info_map_.begin();
          it != storage_info_map_.end();
          ++it) {
       storages.push_back(it->first);
     }
     return storages;
   }
 
   // MediaTransferProtocolManager override.
-  virtual const StorageInfo* GetStorageInfo(
+  virtual const MtpStorageInfo* GetStorageInfo(
       const std::string& storage_name) const OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     StorageInfoMap::const_iterator it = storage_info_map_.find(storage_name);
     if (it == storage_info_map_.end())
       return NULL;
     return &it->second;
   }
 
   // MediaTransferProtocolManager override.
   virtual void OpenStorage(const std::string& storage_name,
@@ skipping 31 matching lines @@
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   virtual void ReadDirectoryByPath(
       const std::string& storage_handle,
       const std::string& path,
       const ReadDirectoryCallback& callback) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!ContainsKey(handles_, storage_handle)) {
-      callback.Run(std::vector<FileEntry>(), true);
+      callback.Run(std::vector<MtpFileEntry>(), true);
       return;
     }
     read_directory_callbacks_.push(callback);
     mtp_client_->ReadDirectoryByPath(
         storage_handle,
         path,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectory,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   // MediaTransferProtocolManager override.
   virtual void ReadDirectoryById(
       const std::string& storage_handle,
       uint32 file_id,
       const ReadDirectoryCallback& callback) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!ContainsKey(handles_, storage_handle)) {
-      callback.Run(std::vector<FileEntry>(), true);
+      callback.Run(std::vector<MtpFileEntry>(), true);
       return;
     }
     read_directory_callbacks_.push(callback);
     mtp_client_->ReadDirectoryById(
         storage_handle,
         file_id,
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectory,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadDirectoryError,
                    weak_ptr_factory_.GetWeakPtr()));
@@ skipping 35 matching lines @@
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnReadFileError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual void GetFileInfoByPath(const std::string& storage_handle,
                                  const std::string& path,
                                  const GetFileInfoCallback& callback) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!ContainsKey(handles_, storage_handle)) {
-      callback.Run(FileEntry(), true);
+      callback.Run(MtpFileEntry(), true);
       return;
     }
     get_file_info_callbacks_.push(callback);
     mtp_client_->GetFileInfoByPath(
         storage_handle,
         path,
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
   virtual void GetFileInfoById(const std::string& storage_handle,
                                uint32 file_id,
                                const GetFileInfoCallback& callback) OVERRIDE {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     if (!ContainsKey(handles_, storage_handle)) {
-      callback.Run(FileEntry(), true);
+      callback.Run(MtpFileEntry(), true);
       return;
     }
     get_file_info_callbacks_.push(callback);
     mtp_client_->GetFileInfoById(
         storage_handle,
         file_id,
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfo,
                    weak_ptr_factory_.GetWeakPtr()),
         base::Bind(&MediaTransferProtocolManagerImpl::OnGetFileInfoError,
                    weak_ptr_factory_.GetWeakPtr()));
   }
 
  private:
   // Map of storage names to storage info.
-  typedef std::map<std::string, StorageInfo> StorageInfoMap;
+  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;
 
@@ skipping 24 matching lines @@
   void OnEnumerateStorage(const std::vector<std::string>& storage_names) {
     for (size_t i = 0; i < storage_names.size(); ++i) {
       mtp_client_->GetStorageInfo(
           storage_names[i],
           base::Bind(&MediaTransferProtocolManagerImpl::OnGetStorageInfo,
                      weak_ptr_factory_.GetWeakPtr()),
           base::Bind(&base::DoNothing));
     }
   }
 
-  void OnGetStorageInfo(const StorageInfo& storage_info) {
+  void OnGetStorageInfo(const MtpStorageInfo& storage_info) {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     const std::string& storage_name = storage_info.storage_name();
     if (ContainsKey(storage_info_map_, storage_name)) {
       // This should not happen, since MediaTransferProtocolManagerImpl should
       // only call EnumerateStorage() once, which populates |storage_info_map_|
       // with the already-attached devices.
       // After that, all incoming signals are either for new storage
       // attachments, which should not be in |storage_info_map_|, or for
       // storage detachements, which do not add to |storage_info_map_|.
       NOTREACHED();
@@ skipping 33 matching lines @@
       close_storage_callbacks_.front().first.Run(true);
     }
     close_storage_callbacks_.pop();
   }
 
   void OnCloseStorageError() {
     close_storage_callbacks_.front().first.Run(true);
     close_storage_callbacks_.pop();
   }
 
-  void OnReadDirectory(const std::vector<FileEntry>& file_entries) {
+  void OnReadDirectory(const std::vector<MtpFileEntry>& file_entries) {
     read_directory_callbacks_.front().Run(file_entries, false);
     read_directory_callbacks_.pop();
   }
 
   void OnReadDirectoryError() {
-    read_directory_callbacks_.front().Run(std::vector<FileEntry>(), true);
+    read_directory_callbacks_.front().Run(std::vector<MtpFileEntry>(), true);
     read_directory_callbacks_.pop();
   }
 
   void OnReadFile(const std::string& data) {
     read_file_callbacks_.front().Run(data, false);
     read_file_callbacks_.pop();
   }
 
   void OnReadFileError() {
     read_file_callbacks_.front().Run(std::string(), true);
     read_file_callbacks_.pop();
   }
 
-  void OnGetFileInfo(const FileEntry& entry) {
+  void OnGetFileInfo(const MtpFileEntry& entry) {
     get_file_info_callbacks_.front().Run(entry, false);
     get_file_info_callbacks_.pop();
   }
 
   void OnGetFileInfoError() {
-    get_file_info_callbacks_.front().Run(FileEntry(), true);
+    get_file_info_callbacks_.front().Run(MtpFileEntry(), true);
     get_file_info_callbacks_.pop();
   }
 
   // Mtpd DBus client.
   MediaTransferProtocolDaemonClient* mtp_client_;
 
   // Device attachment / detachment observers.
   ObserverList<Observer> observers_;
 
   base::WeakPtrFactory<MediaTransferProtocolManagerImpl> weak_ptr_factory_;
@@ skipping 40 matching lines @@
   VLOG(1) << "MediaTransferProtocolManager Shutdown completed";
 }
 
 // static
 MediaTransferProtocolManager* MediaTransferProtocolManager::GetInstance() {
   return g_media_transfer_protocol_manager;
 }
 
 }  // namespace mtp
 }  // namespace chromeos