Skip to content

GitLab

T
tangled
Commit 85b95a20 authored by thestig@chromium.org's avatar thestig@chromium.org
Browse files
Options

chromeos: Add dbus MTPDClient. 

BUG=chromium-os:29557
TEST=none
Review URL: https://chromiumcodereview.appspot.com/10825170

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@150382 0039d316-1c4b-4281-b951-d872f2087c98
parent 7c578773
Hide whitespace changes
Inline Side-by-side
Showing with 997 additions and 20 deletions
chromeos/chromeos.gyp
View file @ 85b95a20
...@@ -95,6 +95,8 @@ ...@@ -95,6 +95,8 @@
'dbus/image_burner_client.h', 'dbus/image_burner_client.h',
'dbus/introspectable_client.cc', 'dbus/introspectable_client.cc',
'dbus/introspectable_client.h', 'dbus/introspectable_client.h',
'dbus/media_transfer_protocol_daemon_client.cc',
'dbus/media_transfer_protocol_daemon_client.h',
'dbus/modem_messaging_client.cc', 'dbus/modem_messaging_client.cc',
'dbus/modem_messaging_client.h', 'dbus/modem_messaging_client.h',
'dbus/power_manager_client.cc', 'dbus/power_manager_client.cc',
...@@ -142,10 +144,10 @@ ...@@ -142,10 +144,10 @@
'dbus/mock_bluetooth_node_client.h', 'dbus/mock_bluetooth_node_client.h',
'dbus/mock_bluetooth_out_of_band_client.cc', 'dbus/mock_bluetooth_out_of_band_client.cc',
'dbus/mock_bluetooth_out_of_band_client.h', 'dbus/mock_bluetooth_out_of_band_client.h',
'dbus/mock_cros_disks_client.cc',
'dbus/mock_cros_disks_client.h',
'dbus/mock_cashew_client.cc', 'dbus/mock_cashew_client.cc',
'dbus/mock_cashew_client.h', 'dbus/mock_cashew_client.h',
'dbus/mock_cros_disks_client.cc',
'dbus/mock_cros_disks_client.h',
'dbus/mock_cryptohome_client.cc', 'dbus/mock_cryptohome_client.cc',
'dbus/mock_cryptohome_client.h', 'dbus/mock_cryptohome_client.h',
'dbus/mock_dbus_thread_manager.cc', 'dbus/mock_dbus_thread_manager.cc',
...@@ -170,6 +172,8 @@ ...@@ -170,6 +172,8 @@
'dbus/mock_image_burner_client.h', 'dbus/mock_image_burner_client.h',
'dbus/mock_introspectable_client.cc', 'dbus/mock_introspectable_client.cc',
'dbus/mock_introspectable_client.h', 'dbus/mock_introspectable_client.h',
'dbus/mock_media_transfer_protocol_daemon_client.cc',
'dbus/mock_media_transfer_protocol_daemon_client.h',
'dbus/mock_modem_messaging_client.cc', 'dbus/mock_modem_messaging_client.cc',
'dbus/mock_modem_messaging_client.h', 'dbus/mock_modem_messaging_client.h',
'dbus/mock_power_manager_client.cc', 'dbus/mock_power_manager_client.cc',
......
chromeos/dbus/cros_disks_client.cc
View file @ 85b95a20
...@@ -4,6 +4,8 @@ ...@@ -4,6 +4,8 @@
#include "chromeos/dbus/cros_disks_client.h" #include "chromeos/dbus/cros_disks_client.h"
#include <map>
#include "base/bind.h" #include "base/bind.h"
#include "base/stl_util.h" #include "base/stl_util.h"
#include "base/stringprintf.h" #include "base/stringprintf.h"
...@@ -246,7 +248,7 @@ class CrosDisksClientImpl : public CrosDisksClient { ...@@ -246,7 +248,7 @@ class CrosDisksClientImpl : public CrosDisksClient {
cros_disks::kMountCompleted, cros_disks::kMountCompleted,
base::Bind(&CrosDisksClientImpl::OnMountCompleted, base::Bind(&CrosDisksClientImpl::OnMountCompleted,
weak_ptr_factory_.GetWeakPtr(), weak_ptr_factory_.GetWeakPtr(),
mount_completed_handler ), mount_completed_handler),
base::Bind(&CrosDisksClientImpl::OnSignalConnected, base::Bind(&CrosDisksClientImpl::OnSignalConnected,
weak_ptr_factory_.GetWeakPtr())); weak_ptr_factory_.GetWeakPtr()));
} }
...@@ -415,7 +417,7 @@ class CrosDisksClientStubImpl : public CrosDisksClient { ...@@ -415,7 +417,7 @@ class CrosDisksClientStubImpl : public CrosDisksClient {
DISALLOW_COPY_AND_ASSIGN(CrosDisksClientStubImpl); DISALLOW_COPY_AND_ASSIGN(CrosDisksClientStubImpl);
}; };
} // namespace } // namespace
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
// DiskInfo // DiskInfo
...@@ -435,7 +437,7 @@ DiskInfo::DiskInfo(const std::string& device_path, dbus::Response* response) ...@@ -435,7 +437,7 @@ DiskInfo::DiskInfo(const std::string& device_path, dbus::Response* response)
DiskInfo::~DiskInfo() { DiskInfo::~DiskInfo() {
} }
// Initialize |this| from |response| given by the cros-disks service. // Initializes |this| from |response| given by the cros-disks service.
// Below is an example of |response|'s raw message (long string is ellipsized). // Below is an example of |response|'s raw message (long string is ellipsized).
// //
// //
......
chromeos/dbus/cros_disks_client.h
View file @ 85b95a20
...@@ -71,14 +71,14 @@ class DiskInfo { ...@@ -71,14 +71,14 @@ class DiskInfo {
~DiskInfo(); ~DiskInfo();
// Device path. (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1) // Device path. (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1)
std::string device_path() const { return device_path_; } const std::string& device_path() const { return device_path_; }
// Disk mount path. (e.g. /media/removable/VOLUME) // Disk mount path. (e.g. /media/removable/VOLUME)
std::string mount_path() const { return mount_path_; } const std::string& mount_path() const { return mount_path_; }
// Disk system path given by udev. // Disk system path given by udev.
// (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1) // (e.g. /sys/devices/pci0000:00/.../8:0:0:0/block/sdb/sdb1)
std::string system_path() const { return system_path_; } const std::string& system_path() const { return system_path_; }
// Is a drive or not. (i.e. true with /dev/sdb, false with /dev/sdb1) // Is a drive or not. (i.e. true with /dev/sdb, false with /dev/sdb1)
bool is_drive() const { return is_drive_; } bool is_drive() const { return is_drive_; }
...@@ -90,13 +90,13 @@ class DiskInfo { ...@@ -90,13 +90,13 @@ class DiskInfo {
bool on_boot_device() const { return on_boot_device_; } bool on_boot_device() const { return on_boot_device_; }
// Disk file path (e.g. /dev/sdb). // Disk file path (e.g. /dev/sdb).
std::string file_path() const { return file_path_; } const std::string& file_path() const { return file_path_; }
// Disk label. // Disk label.
std::string label() const { return label_; } const std::string& label() const { return label_; }
// Disk model. (e.g. "TransMemory") // Disk model. (e.g. "TransMemory")
std::string drive_label() const { return drive_model_; } const std::string& drive_label() const { return drive_model_; }
// Device type. Not working well, yet. // Device type. Not working well, yet.
DeviceType device_type() const { return device_type_; } DeviceType device_type() const { return device_type_; }
...@@ -111,7 +111,7 @@ class DiskInfo { ...@@ -111,7 +111,7 @@ class DiskInfo {
bool is_hidden() const { return is_hidden_; } bool is_hidden() const { return is_hidden_; }
// Returns file system uuid. // Returns file system uuid.
std::string uuid() const { return uuid_; } const std::string& uuid() const { return uuid_; }
private: private:
void InitializeFromResponse(dbus::Response* response); void InitializeFromResponse(dbus::Response* response);
...@@ -146,34 +146,40 @@ class CHROMEOS_EXPORT CrosDisksClient { ...@@ -146,34 +146,40 @@ class CHROMEOS_EXPORT CrosDisksClient {
// A callback to handle the result of Unmount. // A callback to handle the result of Unmount.
// The argument is the device path. // The argument is the device path.
typedef base::Callback<void(const std::string&)> UnmountCallback; typedef base::Callback<void(const std::string& device_path)> UnmountCallback;
// A callback to handle the result of EnumerateAutoMountableDevices. // A callback to handle the result of EnumerateAutoMountableDevices.
// The argument is the enumerated device paths. // The argument is the enumerated device paths.
typedef base::Callback<void(const std::vector<std::string>&) typedef base::Callback<void(const std::vector<std::string>& device_paths)
> EnumerateAutoMountableDevicesCallback; > EnumerateAutoMountableDevicesCallback;
// A callback to handle the result of FormatDevice. // A callback to handle the result of FormatDevice.
// The first argument is the device path. // The first argument is the device path.
// The second argument is true when formatting succeeded, false otherwise. // The second argument is true when formatting succeeded, false otherwise.
typedef base::Callback<void(const std::string&, bool)> FormatDeviceCallback; typedef base::Callback<void(const std::string& device_path,
bool format_succeeded)> FormatDeviceCallback;
// A callback to handle the result of GetDeviceProperties. // A callback to handle the result of GetDeviceProperties.
// The argument is the information about the specified device. // The argument is the information about the specified device.
typedef base::Callback<void(const DiskInfo&)> GetDevicePropertiesCallback; typedef base::Callback<void(const DiskInfo& disk_info)
> GetDevicePropertiesCallback;
// A callback to handle MountCompleted signal. // A callback to handle MountCompleted signal.
// The first argument is the error code. // The first argument is the error code.
// The second argument is the source path. // The second argument is the source path.
// The third argument is the mount type. // The third argument is the mount type.
// The fourth argument is the mount path. // The fourth argument is the mount path.
typedef base::Callback<void(MountError, const std::string&, MountType, typedef base::Callback<void(MountError error_code,
const std::string&)> MountCompletedHandler; const std::string& source_path,
MountType mount_type,
const std::string& mount_path)
> MountCompletedHandler;
// A callback to handle mount events. // A callback to handle mount events.
// The first argument is the event type. // The first argument is the event type.
// The second argument is the device path. // The second argument is the device path.
typedef base::Callback<void(MountEventType, const std::string&) typedef base::Callback<void(MountEventType event_type,
const std::string& device_path)
> MountEventHandler; > MountEventHandler;
virtual ~CrosDisksClient(); virtual ~CrosDisksClient();
......
chromeos/dbus/dbus_thread_manager.cc
View file @ 85b95a20
...@@ -4,6 +4,8 @@ ...@@ -4,6 +4,8 @@
#include "chromeos/dbus/dbus_thread_manager.h" #include "chromeos/dbus/dbus_thread_manager.h"
#include <map>
#include "base/chromeos/chromeos_version.h" #include "base/chromeos/chromeos_version.h"
#include "base/command_line.h" #include "base/command_line.h"
#include "base/threading/thread.h" #include "base/threading/thread.h"
...@@ -32,6 +34,7 @@ ...@@ -32,6 +34,7 @@
#include "chromeos/dbus/ibus/ibus_input_context_client.h" #include "chromeos/dbus/ibus/ibus_input_context_client.h"
#include "chromeos/dbus/image_burner_client.h" #include "chromeos/dbus/image_burner_client.h"
#include "chromeos/dbus/introspectable_client.h" #include "chromeos/dbus/introspectable_client.h"
#include "chromeos/dbus/media_transfer_protocol_daemon_client.h"
#include "chromeos/dbus/modem_messaging_client.h" #include "chromeos/dbus/modem_messaging_client.h"
#include "chromeos/dbus/power_manager_client.h" #include "chromeos/dbus/power_manager_client.h"
#include "chromeos/dbus/session_manager_client.h" #include "chromeos/dbus/session_manager_client.h"
...@@ -120,6 +123,10 @@ class DBusThreadManagerImpl : public DBusThreadManager { ...@@ -120,6 +123,10 @@ class DBusThreadManagerImpl : public DBusThreadManager {
// Create the introspectable object client. // Create the introspectable object client.
introspectable_client_.reset( introspectable_client_.reset(
IntrospectableClient::Create(client_type, system_bus_.get())); IntrospectableClient::Create(client_type, system_bus_.get()));
// Create the media transfer protocol daemon client.
media_transfer_protocol_daemon_client_.reset(
MediaTransferProtocolDaemonClient::Create(client_type,
system_bus_.get()));
// Create the ModemMessaging client. // Create the ModemMessaging client.
modem_messaging_client_.reset( modem_messaging_client_.reset(
ModemMessagingClient::Create(client_type, system_bus_.get())); ModemMessagingClient::Create(client_type, system_bus_.get()));
...@@ -295,6 +302,12 @@ class DBusThreadManagerImpl : public DBusThreadManager { ...@@ -295,6 +302,12 @@ class DBusThreadManagerImpl : public DBusThreadManager {
return introspectable_client_.get(); return introspectable_client_.get();
} }
// DBusThreadManager override.
virtual MediaTransferProtocolDaemonClient*
GetMediaTransferProtocolDaemonClient() OVERRIDE {
return media_transfer_protocol_daemon_client_.get();
}
// DBusThreadManager override. // DBusThreadManager override.
virtual ModemMessagingClient* GetModemMessagingClient() OVERRIDE { virtual ModemMessagingClient* GetModemMessagingClient() OVERRIDE {
return modem_messaging_client_.get(); return modem_messaging_client_.get();
...@@ -343,7 +356,6 @@ class DBusThreadManagerImpl : public DBusThreadManager { ...@@ -343,7 +356,6 @@ class DBusThreadManagerImpl : public DBusThreadManager {
// DBusThreadManager override. // DBusThreadManager override.
virtual IBusEngineService* GetIBusEngineService( virtual IBusEngineService* GetIBusEngineService(
const dbus::ObjectPath& object_path) OVERRIDE { const dbus::ObjectPath& object_path) OVERRIDE {
const DBusClientImplementationType client_type = const DBusClientImplementationType client_type =
base::chromeos::IsRunningOnChromeOS() ? REAL_DBUS_CLIENT_IMPLEMENTATION base::chromeos::IsRunningOnChromeOS() ? REAL_DBUS_CLIENT_IMPLEMENTATION
: STUB_DBUS_CLIENT_IMPLEMENTATION; : STUB_DBUS_CLIENT_IMPLEMENTATION;
...@@ -389,6 +401,8 @@ class DBusThreadManagerImpl : public DBusThreadManager { ...@@ -389,6 +401,8 @@ class DBusThreadManagerImpl : public DBusThreadManager {
scoped_ptr<GsmSMSClient> gsm_sms_client_; scoped_ptr<GsmSMSClient> gsm_sms_client_;
scoped_ptr<ImageBurnerClient> image_burner_client_; scoped_ptr<ImageBurnerClient> image_burner_client_;
scoped_ptr<IntrospectableClient> introspectable_client_; scoped_ptr<IntrospectableClient> introspectable_client_;
scoped_ptr<MediaTransferProtocolDaemonClient>
media_transfer_protocol_daemon_client_;
scoped_ptr<ModemMessagingClient> modem_messaging_client_; scoped_ptr<ModemMessagingClient> modem_messaging_client_;
scoped_ptr<PowerManagerClient> power_manager_client_; scoped_ptr<PowerManagerClient> power_manager_client_;
scoped_ptr<SessionManagerClient> session_manager_client_; scoped_ptr<SessionManagerClient> session_manager_client_;
......
chromeos/dbus/dbus_thread_manager.h
View file @ 85b95a20
...@@ -46,6 +46,7 @@ class IBusEngineFactoryService; ...@@ -46,6 +46,7 @@ class IBusEngineFactoryService;
class IBusInputContextClient; class IBusInputContextClient;
class ImageBurnerClient; class ImageBurnerClient;
class IntrospectableClient; class IntrospectableClient;
class MediaTransferProtocolDaemonClient;
class ModemMessagingClient; class ModemMessagingClient;
class PowerManagerClient; class PowerManagerClient;
class SessionManagerClient; class SessionManagerClient;
...@@ -199,6 +200,12 @@ class CHROMEOS_EXPORT DBusThreadManager { ...@@ -199,6 +200,12 @@ class CHROMEOS_EXPORT DBusThreadManager {
// down. // down.
virtual IntrospectableClient* GetIntrospectableClient() = 0; virtual IntrospectableClient* GetIntrospectableClient() = 0;
// Returns the media transfer protocol client, owned by DBusThreadManager.
// Do not cache this pointer and use it after DBusThreadManager is shut
// down.
virtual MediaTransferProtocolDaemonClient*
GetMediaTransferProtocolDaemonClient() = 0;
// Returns the Modem Messaging client, owned by DBusThreadManager. // Returns the Modem Messaging client, owned by DBusThreadManager.
// Do not cache this pointer and use it after DBusThreadManager is shut // Do not cache this pointer and use it after DBusThreadManager is shut
// down. // down.
......
chromeos/dbus/media_transfer_protocol_daemon_client.cc 0 → 100644
View file @ 85b95a20
// 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 "chromeos/dbus/media_transfer_protocol_daemon_client.h"
#include <map>
#include "base/bind.h"
#include "base/stl_util.h"
#include "base/stringprintf.h"
#include "dbus/bus.h"
#include "dbus/message.h"
#include "dbus/object_path.h"
#include "dbus/object_proxy.h"
#include "third_party/cros_system_api/dbus/service_constants.h"
namespace chromeos {
namespace {
// Pops a string value when |reader| is not NULL.
// Returns true when a value is popped, false otherwise.
bool MaybePopString(dbus::MessageReader* reader, std::string* value) {
if (!reader)
return false;
return reader->PopString(value);
}
// Pops a uint16 value when |reader| is not NULL.
// Returns true when a value is popped, false otherwise.
bool MaybePopUint16(dbus::MessageReader* reader, uint16* value) {
if (!reader)
return false;
return reader->PopUint16(value);
}
// Pops a uint32 value when |reader| is not NULL.
// Returns true when a value is popped, false otherwise.
bool MaybePopUint32(dbus::MessageReader* reader, uint32* value) {
if (!reader)
return false;
return reader->PopUint32(value);
}
// Pops a uint64 value when |reader| is not NULL.
// Returns true when a value is popped, false otherwise.
bool MaybePopUint64(dbus::MessageReader* reader, uint64* value) {
if (!reader)
return false;
return reader->PopUint64(value);
}
// Pops a int64 value when |reader| is not NULL.
// Returns true when a value is popped, false otherwise.
bool MaybePopInt64(dbus::MessageReader* reader, int64* value) {
if (!reader)
return false;
return reader->PopInt64(value);
}
// The MediaTransferProtocolDaemonClient implementation.
class MediaTransferProtocolDaemonClientImpl
: public MediaTransferProtocolDaemonClient {
public:
explicit MediaTransferProtocolDaemonClientImpl(dbus::Bus* bus)
: proxy_(bus->GetObjectProxy(
mtpd::kMtpdServiceName,
dbus::ObjectPath(mtpd::kMtpdServicePath))),
weak_ptr_factory_(this) {
}
// MediaTransferProtocolDaemonClient override.
virtual void EnumerateStorage(const EnumerateStorageCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {
dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kEnumerateStorage);
proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&MediaTransferProtocolDaemonClientImpl::OnEnumerateStorage,
weak_ptr_factory_.GetWeakPtr(),
callback,
error_callback));
}
// MediaTransferProtocolDaemonClient override.
virtual void GetStorageInfo(const std::string& storage_name,
const GetStorageInfoCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {
dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kGetStorageInfo);
dbus::MessageWriter writer(&method_call);
writer.AppendString(storage_name);
proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&MediaTransferProtocolDaemonClientImpl::OnGetStorageInfo,
weak_ptr_factory_.GetWeakPtr(),
storage_name,
callback,
error_callback));
}
// MediaTransferProtocolDaemonClient override.
virtual void OpenStorage(const std::string& storage_name,
OpenStorageMode mode,
const OpenStorageCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {
dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kOpenStorage);
dbus::MessageWriter writer(&method_call);
writer.AppendString(storage_name);
DCHECK_EQ(OPEN_STORAGE_MODE_READ_ONLY, mode);
writer.AppendString(mtpd::kReadOnlyMode);
proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&MediaTransferProtocolDaemonClientImpl::OnOpenStorage,
weak_ptr_factory_.GetWeakPtr(),
callback,
error_callback));
}
// MediaTransferProtocolDaemonClient override.
virtual void CloseStorage(const std::string& handle,
const CloseStorageCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {
dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kCloseStorage);
dbus::MessageWriter writer(&method_call);
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 ReadFileByPath(const std::string& handle,
const std::string& path,
const ReadFileCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {
dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kReadFileByPath);
dbus::MessageWriter writer(&method_call);
writer.AppendString(handle);
writer.AppendString(path);
proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadFile,
weak_ptr_factory_.GetWeakPtr(),
callback,
error_callback));
}
// MediaTransferProtocolDaemonClient override.
virtual void ReadFileById(const std::string& handle,
uint32 file_id,
const ReadFileCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {
dbus::MethodCall method_call(mtpd::kMtpdInterface, mtpd::kReadFileById);
dbus::MessageWriter writer(&method_call);
writer.AppendString(handle);
writer.AppendUint32(file_id);
proxy_->CallMethod(
&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
base::Bind(&MediaTransferProtocolDaemonClientImpl::OnReadFile,
weak_ptr_factory_.GetWeakPtr(),
callback,
error_callback));
}
// MediaTransferProtocolDaemonClient override.
virtual void SetUpConnections(
const MTPStorageEventHandler& handler) OVERRIDE {
static const SignalEventTuple kSignalEventTuples[] = {
{ mtpd::kMTPStorageAttached, true },
{ mtpd::kMTPStorageDetached, false },
};
const size_t kNumSignalEventTuples = arraysize(kSignalEventTuples);
for (size_t i = 0; i < kNumSignalEventTuples; ++i) {
proxy_->ConnectToSignal(
mtpd::kMtpdInterface,
kSignalEventTuples[i].signal_name,
base::Bind(&MediaTransferProtocolDaemonClientImpl::OnMTPStorageSignal,
weak_ptr_factory_.GetWeakPtr(),
handler,
kSignalEventTuples[i].is_attach),
base::Bind(&MediaTransferProtocolDaemonClientImpl::OnSignalConnected,
weak_ptr_factory_.GetWeakPtr()));
}
}
private:
// A struct to contain a pair of signal name and attachment event type.
// Used by SetUpConnections.
struct SignalEventTuple {
const char *signal_name;
bool is_attach;
};
// Handles the result of EnumerateStorage and calls |callback| or
// |error_callback|.
void OnEnumerateStorage(const EnumerateStorageCallback& callback,
const ErrorCallback& error_callback,
dbus::Response* response) {
if (!response) {
error_callback.Run();
return;
}
dbus::MessageReader reader(response);
std::vector<std::string> storage_names;
if (!reader.PopArrayOfStrings(&storage_names)) {
LOG(ERROR) << "Invalid response: " << response->ToString();
error_callback.Run();
return;
}
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) {
if (!response) {
error_callback.Run();
return;
}
StorageInfo storage_info(storage_name, response);
callback.Run(storage_info);
}
// Handles the result of OpenStorage and calls |callback| or |error_callback|.
void OnOpenStorage(const OpenStorageCallback& callback,
const ErrorCallback& error_callback,
dbus::Response* response) {
if (!response) {
error_callback.Run();
return;
}
dbus::MessageReader reader(response);
std::string handle;
if (!reader.PopString(&handle)) {
LOG(ERROR) << "Invalid response: " << response->ToString();
error_callback.Run();
return;
}
callback.Run(handle);
}
// Handles the result of CloseStorage and calls |callback| or
// |error_callback|.
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
// |error_callback|.
void OnReadDirectory(const ReadDirectoryCallback& callback,
const ErrorCallback& error_callback,
dbus::Response* response) {
if (!response) {
error_callback.Run();
return;
}
std::vector<FileEntry> file_entries;
dbus::MessageReader response_reader(response);
dbus::MessageReader array_reader(response);
if (!response_reader.PopArray(&array_reader)) {
LOG(ERROR) << "Invalid response: " << response->ToString();
error_callback.Run();
return;
}
while (array_reader.HasMoreData()) {
FileEntry entry(response);
file_entries.push_back(entry);
}
callback.Run(file_entries);
}
// Handles the result of ReadFileByPath/Id and calls |callback| or
// |error_callback|.
void OnReadFile(const ReadFileCallback& callback,
const ErrorCallback& error_callback,
dbus::Response* response) {
if (!response) {
error_callback.Run();
return;
}
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 MTPStorageAttached/Dettached signals and calls |handler|.
void OnMTPStorageSignal(MTPStorageEventHandler handler,
bool is_attach,
dbus::Signal* signal) {
dbus::MessageReader reader(signal);
std::string storage_name;
if (!reader.PopString(&storage_name)) {
LOG(ERROR) << "Invalid signal: " << signal->ToString();
return;
}
DCHECK(!storage_name.empty());
handler.Run(is_attach, storage_name);
}
// Handles the result of signal connection setup.
void OnSignalConnected(const std::string& interface,
const std::string& signal,
bool successed) {
LOG_IF(ERROR, !successed) << "Connect to " << interface << " "
<< signal << " failed.";
}
dbus::ObjectProxy* proxy_;
base::WeakPtrFactory<MediaTransferProtocolDaemonClientImpl> weak_ptr_factory_;
DISALLOW_COPY_AND_ASSIGN(MediaTransferProtocolDaemonClientImpl);
};
// A stub implementaion of MediaTransferProtocolDaemonClient.
class MediaTransferProtocolDaemonClientStubImpl
: public MediaTransferProtocolDaemonClient {
public:
MediaTransferProtocolDaemonClientStubImpl() {}
virtual ~MediaTransferProtocolDaemonClientStubImpl() {}
virtual void EnumerateStorage(
const EnumerateStorageCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {}
virtual void GetStorageInfo(
const std::string& storage_name,
const GetStorageInfoCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {}
virtual void OpenStorage(const std::string& storage_name,
OpenStorageMode mode,
const OpenStorageCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {}
virtual void CloseStorage(const std::string& handle,
const CloseStorageCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {}
virtual void ReadDirectoryByPath(
const std::string& handle,
const std::string& path,
const ReadDirectoryCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {}
virtual void ReadDirectoryById(
const std::string& handle,
uint32 file_id,
const ReadDirectoryCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {}
virtual void ReadFileByPath(const std::string& handle,
const std::string& path,
const ReadFileCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {}
virtual void ReadFileById(const std::string& handle,
uint32 file_id,
const ReadFileCallback& callback,
const ErrorCallback& error_callback) OVERRIDE {}
virtual void SetUpConnections(
const MTPStorageEventHandler& handler) OVERRIDE {}
private:
DISALLOW_COPY_AND_ASSIGN(MediaTransferProtocolDaemonClientStubImpl);
};
} // namespace
////////////////////////////////////////////////////////////////////////////////
// StorageInfo
StorageInfo::StorageInfo(const std::string& storage_name,
dbus::Response* response)
: vendor_id_(0),
product_id_(0),
device_flags_(0),
storage_name_(storage_name),
storage_type_(0),
filesystem_type_(0),
access_capability_(0),
max_capacity_(0),
free_space_in_bytes_(0),
free_space_in_objects_(0) {
InitializeFromResponse(response);
}
StorageInfo::~StorageInfo() {
}
// Initializes |this| from |response| given by the mtpd service.
void StorageInfo::InitializeFromResponse(dbus::Response* response) {
dbus::MessageReader response_reader(response);
dbus::MessageReader array_reader(response);
if (!response_reader.PopArray(&array_reader)) {
LOG(ERROR) << "Invalid response: " << response->ToString();
return;
}
// TODO(thestig): Rework this code using Protocol Buffers. crosbug.com/22626
typedef std::map<std::string, dbus::MessageReader*> PropertiesMap;
PropertiesMap properties;
STLValueDeleter<PropertiesMap> properties_value_deleter(&properties);
while (array_reader.HasMoreData()) {
dbus::MessageReader* value_reader = new dbus::MessageReader(response);
dbus::MessageReader dict_entry_reader(response);
std::string key;
if (!array_reader.PopDictEntry(&dict_entry_reader) ||
!dict_entry_reader.PopString(&key) ||
!dict_entry_reader.PopVariant(value_reader)) {
LOG(ERROR) << "Invalid response: " << response->ToString();
return;
}
properties[key] = value_reader;
}
// TODO(thestig) Add enums for fields below as appropriate.
MaybePopString(properties[mtpd::kVendor], &vendor_);
MaybePopString(properties[mtpd::kProduct], &product_);
MaybePopString(properties[mtpd::kStorageDescription], &storage_description_);
MaybePopString(properties[mtpd::kVolumeIdentifier], &volume_identifier_);
MaybePopUint16(properties[mtpd::kVendorId], &vendor_id_);
MaybePopUint16(properties[mtpd::kProductId], &product_id_);
MaybePopUint16(properties[mtpd::kStorageType], &storage_type_);
MaybePopUint16(properties[mtpd::kFilesystemType], &filesystem_type_);
MaybePopUint16(properties[mtpd::kAccessCapability], &access_capability_);
MaybePopUint32(properties[mtpd::kDeviceFlags], &device_flags_);
MaybePopUint64(properties[mtpd::kMaxCapacity], &max_capacity_);
MaybePopUint64(properties[mtpd::kFreeSpaceInBytes], &free_space_in_bytes_);
MaybePopUint64(properties[mtpd::kFreeSpaceInObjects],
&free_space_in_objects_);
}
////////////////////////////////////////////////////////////////////////////////
// FileEntry
FileEntry::FileEntry(dbus::Response* response)
: item_id_(0),
parent_id_(0),
file_size_(0),
file_type_(FILE_TYPE_UNKNOWN) {
InitializeFromResponse(response);
}
FileEntry::~FileEntry() {
}
// Initializes |this| from |response| given by the mtpd service.
void FileEntry::InitializeFromResponse(dbus::Response* response) {
dbus::MessageReader response_reader(response);
dbus::MessageReader array_reader(response);
if (!response_reader.PopArray(&array_reader)) {
LOG(ERROR) << "Invalid response: " << response->ToString();
return;
}
// TODO(thestig): Rework this code using Protocol Buffers. crosbug.com/22626
typedef std::map<std::string, dbus::MessageReader*> PropertiesMap;
PropertiesMap properties;
STLValueDeleter<PropertiesMap> properties_value_deleter(&properties);
while (array_reader.HasMoreData()) {
dbus::MessageReader* value_reader = new dbus::MessageReader(response);
dbus::MessageReader dict_entry_reader(response);
std::string key;
if (!array_reader.PopDictEntry(&dict_entry_reader) ||
!dict_entry_reader.PopString(&key) ||
!dict_entry_reader.PopVariant(value_reader)) {
LOG(ERROR) << "Invalid response: " << response->ToString();
return;
}
properties[key] = value_reader;
}
MaybePopString(properties[mtpd::kFileName], &file_name_);
MaybePopUint32(properties[mtpd::kItemId], &item_id_);
MaybePopUint32(properties[mtpd::kParentId], &parent_id_);
MaybePopUint64(properties[mtpd::kFileSize], &file_size_);
int64 modification_date = -1;
if (MaybePopInt64(properties[mtpd::kModificationDate], &modification_date))
modification_date_ = base::Time::FromTimeT(modification_date);
uint16 file_type = FILE_TYPE_OTHER;
if (MaybePopUint16(properties[mtpd::kFileType], &file_type)) {
switch (file_type) {
case FILE_TYPE_FOLDER:
case FILE_TYPE_JPEG:
case FILE_TYPE_JFIF:
case FILE_TYPE_TIFF:
case FILE_TYPE_BMP:
case FILE_TYPE_GIF:
case FILE_TYPE_PICT:
case FILE_TYPE_PNG:
case FILE_TYPE_WINDOWSIMAGEFORMAT:
case FILE_TYPE_JP2:
case FILE_TYPE_JPX:
case FILE_TYPE_UNKNOWN:
file_type_ = static_cast<FileType>(file_type);
default:
file_type_ = FILE_TYPE_OTHER;
break;
}
}
}
////////////////////////////////////////////////////////////////////////////////
// MediaTransferProtocolDaemonClient
MediaTransferProtocolDaemonClient::MediaTransferProtocolDaemonClient() {}
MediaTransferProtocolDaemonClient::~MediaTransferProtocolDaemonClient() {}
// static
MediaTransferProtocolDaemonClient*
MediaTransferProtocolDaemonClient::Create(DBusClientImplementationType type,
dbus::Bus* bus) {
if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
return new MediaTransferProtocolDaemonClientImpl(bus);
DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
return new MediaTransferProtocolDaemonClientStubImpl();
}
} // namespace chromeos
chromeos/dbus/media_transfer_protocol_daemon_client.h 0 → 100644
View file @ 85b95a20
// 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.
// Client code to talk to the Media Transfer Protocol daemon. The MTP daemon is
// responsible for communicating with PTP / MTP capable devices like cameras
// and smartphones.
#ifndef CHROMEOS_DBUS_MEDIA_TRANSFER_PROTOCOL_DAEMON_CLIENT_H_
#define CHROMEOS_DBUS_MEDIA_TRANSFER_PROTOCOL_DAEMON_CLIENT_H_
#include <string>
#include <vector>
#include "base/basictypes.h"
#include "base/callback.h"
#include "base/time.h"
#include "chromeos/chromeos_export.h"
#include "chromeos/dbus/dbus_client_implementation_type.h"
namespace dbus {
class Bus;
class Response;
}
namespace chromeos {
// Mode to open a storage in.
enum OpenStorageMode {
OPEN_STORAGE_MODE_READ_ONLY,
};
// Values match libmtp values unless noted below.
// TODO(thestig) See if we can do better than this.
enum FileType {
FILE_TYPE_FOLDER = 0,
FILE_TYPE_JPEG = 14,
FILE_TYPE_JFIF = 15,
FILE_TYPE_TIFF = 16,
FILE_TYPE_BMP = 17,
FILE_TYPE_GIF = 18,
FILE_TYPE_PICT = 19,
FILE_TYPE_PNG = 20,
FILE_TYPE_WINDOWSIMAGEFORMAT = 25,
FILE_TYPE_JP2 = 40,
FILE_TYPE_JPX = 41,
// Truly unknown file type.
FILE_TYPE_UNKNOWN = 44,
// There's more file types to map to, but right now they are not interesting.
// Just assign a dummy value for now.
FILE_TYPE_OTHER = 9999
};
// A class to represent information about a storage sent from mtpd.
class StorageInfo {
public:
StorageInfo(const std::string& storage_name, dbus::Response* response);
~StorageInfo();
// Storage name. (e.g. usb:1,5:65537)
const std::string& storage_name() const { return storage_name_; }
// Vendor. (e.g. Kodak)
const std::string& vendor() const { return vendor_; }
// Vendor ID. (e.g. 0x040a)
uint16 vendor_id() const { return vendor_id_; }
// Product. (e.g. DC4800)
const std::string& product() const { return product_; }
// Vendor ID. (e.g. 0x0160)
uint16 product_id() const { return product_id_; }
// Device flags as defined by libmtp.
uint32 device_flags() const { return device_flags_; }
// Storage type as defined in libmtp. (e.g. PTP_ST_FixedROM)
uint16 storage_type() const { return storage_type_; }
// File system type as defined in libmtp. (e.g. PTP_FST_DCF)
uint16 filesystem_type() const { return filesystem_type_; }
// Access capability as defined in libmtp. (e.g. PTP_AC_ReadWrite)
uint16 access_capability() const { return access_capability_; }
// Max capacity in bytes.
uint64 max_capacity() const { return max_capacity_; }
// Free space in byte.
uint64 free_space_in_bytes() const { return free_space_in_bytes_; }
// Free space in number of objects.
uint64 free_space_in_objects() const { return free_space_in_objects_; }
// Storage description. (e.g. internal memory)
const std::string& storage_description() const {
return storage_description_;
}
// Volume identifier. (e.g. the serial number, should be unique)
const std::string& volume_identifier() const { return volume_identifier_; }
private:
void InitializeFromResponse(dbus::Response* response);
// Device info. (A device can have multiple storages)
std::string vendor_;
uint16 vendor_id_;
std::string product_;
uint16 product_id_;
uint32 device_flags_;
// Storage info.
std::string storage_name_;
uint16 storage_type_;
uint16 filesystem_type_;
uint16 access_capability_;
uint64 max_capacity_;
uint64 free_space_in_bytes_;
uint64 free_space_in_objects_;
std::string storage_description_;
std::string volume_identifier_;
};
// A class to represent information about a file entry sent from mtpd.
class FileEntry {
public:
explicit FileEntry(dbus::Response* response);
~FileEntry();
// ID for the file.
uint32 item_id() const { return item_id_; }
// ID for the file's parent.
uint32 parent_id() const { return parent_id_; }
// Name of the file.
const std::string& file_name() const { return file_name_; }
// Size of the file.
uint64 file_size() const { return file_size_; }
// Modification time of the file.
base::Time modification_date() const { return modification_date_; }
// File type.
FileType file_type() const { return file_type_; }
private:
void InitializeFromResponse(dbus::Response* response);
// Storage info.
uint32 item_id_;
uint32 parent_id_;
std::string file_name_;
uint64 file_size_;
base::Time modification_date_;
FileType file_type_;
};
// A class to make the actual DBus calls for mtpd service.
// This class only makes calls, result/error handling should be done
// by callbacks.
class CHROMEOS_EXPORT MediaTransferProtocolDaemonClient {
public:
// A callback to be called when DBus method call fails.
typedef base::Callback<void()> ErrorCallback;
// A callback to handle the result of EnumerateAutoMountableDevices.
// The argument is the enumerated storage names.
typedef base::Callback<void(const std::vector<std::string>& storage_names)
> EnumerateStorageCallback;
// A callback to handle the result of GetStorageInfo.
// The argument is the information about the specified storage.
typedef base::Callback<void(const StorageInfo& storage_info)
> GetStorageInfoCallback;
// A callback to handle the result of OpenStorage.
// The argument is the returned handle.
typedef base::Callback<void(const std::string& handle)> OpenStorageCallback;
// A callback to handle the result of CloseStorage.
typedef base::Callback<void()> CloseStorageCallback;
// A callback to handle the result of ReadDirectoryByPath/Id.
// The argument is a vector of file entries.
typedef base::Callback<void(const std::vector<FileEntry>& file_entries)
> ReadDirectoryCallback;
// A callback to handle the result of ReadFileByPath/Id.
// The argument is a string containing the file data.
// TODO(thestig) Consider using a file descriptor instead of the data.
typedef base::Callback<void(const std::string& data)> ReadFileCallback;
// A callback to handle storage attach/detach events.
// The first argument is true for attach, false for detach.
// The second argument is the storage name.
typedef base::Callback<void(bool is_attach,
const std::string& storage_name)
> MTPStorageEventHandler;
virtual ~MediaTransferProtocolDaemonClient();
// Calls EnumerateStorage method. |callback| is called after the
// method call succeeds, otherwise, |error_callback| is called.
virtual void EnumerateStorage(
const EnumerateStorageCallback& callback,
const ErrorCallback& error_callback) = 0;
// Calls GetStorageInfo method. |callback| is called after the method call
// succeeds, otherwise, |error_callback| is called.
virtual void GetStorageInfo(const std::string& storage_name,
const GetStorageInfoCallback& callback,
const ErrorCallback& error_callback) = 0;
// Calls OpenStorage method. |callback| is called after the method call
// succeeds, otherwise, |error_callback| is called.
// OpenStorage returns a handle in |callback|.
virtual void OpenStorage(const std::string& storage_name,
OpenStorageMode mode,
const OpenStorageCallback& callback,
const ErrorCallback& error_callback) = 0;
// Calls CloseStorage method. |callback| is called after the method call
// succeeds, otherwise, |error_callback| is called.
// |handle| comes from a OpenStorageCallback.
virtual void CloseStorage(const std::string& handle,
const CloseStorageCallback& callback,
const ErrorCallback& error_callback) = 0;
// Calls ReadDirectoryByPath method. |callback| is called after the method
// call succeeds, otherwise, |error_callback| is called.
virtual void ReadDirectoryByPath(const std::string& handle,
const std::string& path,
const ReadDirectoryCallback& callback,
const ErrorCallback& error_callback) = 0;
// Calls ReadDirectoryById method. |callback| is called after the method
// call succeeds, otherwise, |error_callback| is called.
// |file_id| is a MTP-device specific id for a file.
virtual void ReadDirectoryById(const std::string& handle,
uint32 file_id,
const ReadDirectoryCallback& callback,
const ErrorCallback& error_callback) = 0;
// Calls ReadFileByPath method. |callback| is called after the method call
// succeeds, otherwise, |error_callback| is called.
virtual void ReadFileByPath(const std::string& handle,
const std::string& path,
const ReadFileCallback& callback,
const ErrorCallback& error_callback) = 0;
// Calls ReadFileById method. |callback| is called after the method call
// succeeds, otherwise, |error_callback| is called.
// |file_id| is a MTP-device specific id for a file.
virtual void ReadFileById(const std::string& handle,
uint32 file_id,
const ReadFileCallback& callback,
const ErrorCallback& error_callback) = 0;
// Registers given callback for events.
// |storage_event_handler| is called when a mtp storage attach or detach
// signal is received.
virtual void SetUpConnections(const MTPStorageEventHandler& handler) = 0;
// Factory function, creates a new instance and returns ownership.
// For normal usage, access the singleton via DBusThreadManager::Get().
static MediaTransferProtocolDaemonClient*
Create(DBusClientImplementationType type, dbus::Bus* bus);
protected:
// Create() should be used instead.
MediaTransferProtocolDaemonClient();
private:
DISALLOW_COPY_AND_ASSIGN(MediaTransferProtocolDaemonClient);
};
} // namespace chromeos
#endif // CHROMEOS_DBUS_MEDIA_TRANSFER_PROTOCOL_DAEMON_CLIENT_H_
chromeos/dbus/mock_dbus_thread_manager.cc
View file @ 85b95a20
...@@ -23,6 +23,7 @@ ...@@ -23,6 +23,7 @@
#include "chromeos/dbus/mock_gsm_sms_client.h" #include "chromeos/dbus/mock_gsm_sms_client.h"
#include "chromeos/dbus/mock_image_burner_client.h" #include "chromeos/dbus/mock_image_burner_client.h"
#include "chromeos/dbus/mock_introspectable_client.h" #include "chromeos/dbus/mock_introspectable_client.h"
#include "chromeos/dbus/mock_media_transfer_protocol_daemon_client.h"
#include "chromeos/dbus/mock_modem_messaging_client.h" #include "chromeos/dbus/mock_modem_messaging_client.h"
#include "chromeos/dbus/mock_power_manager_client.h" #include "chromeos/dbus/mock_power_manager_client.h"
#include "chromeos/dbus/mock_session_manager_client.h" #include "chromeos/dbus/mock_session_manager_client.h"
...@@ -57,6 +58,8 @@ MockDBusThreadManager::MockDBusThreadManager() ...@@ -57,6 +58,8 @@ MockDBusThreadManager::MockDBusThreadManager()
mock_gsm_sms_client_(new MockGsmSMSClient), mock_gsm_sms_client_(new MockGsmSMSClient),
mock_image_burner_client_(new MockImageBurnerClient), mock_image_burner_client_(new MockImageBurnerClient),
mock_introspectable_client_(new MockIntrospectableClient), mock_introspectable_client_(new MockIntrospectableClient),
mock_media_transfer_protocol_daemon_client_(
new MockMediaTransferProtocolDaemonClient),
mock_modem_messaging_client_(new MockModemMessagingClient), mock_modem_messaging_client_(new MockModemMessagingClient),
mock_power_manager_client_(new MockPowerManagerClient), mock_power_manager_client_(new MockPowerManagerClient),
mock_session_manager_client_(new MockSessionManagerClient), mock_session_manager_client_(new MockSessionManagerClient),
...@@ -101,6 +104,8 @@ MockDBusThreadManager::MockDBusThreadManager() ...@@ -101,6 +104,8 @@ MockDBusThreadManager::MockDBusThreadManager()
.WillRepeatedly(Return(mock_image_burner_client())); .WillRepeatedly(Return(mock_image_burner_client()));
EXPECT_CALL(*this, GetIntrospectableClient()) EXPECT_CALL(*this, GetIntrospectableClient())
.WillRepeatedly(Return(mock_introspectable_client())); .WillRepeatedly(Return(mock_introspectable_client()));
EXPECT_CALL(*this, GetMediaTransferProtocolDaemonClient())
.WillRepeatedly(Return(mock_media_transfer_protocol_daemon_client()));
EXPECT_CALL(*this, GetModemMessagingClient()) EXPECT_CALL(*this, GetModemMessagingClient())
.WillRepeatedly(Return(mock_modem_messaging_client())); .WillRepeatedly(Return(mock_modem_messaging_client()));
EXPECT_CALL(*this, GetPowerManagerClient()) EXPECT_CALL(*this, GetPowerManagerClient())
......
chromeos/dbus/mock_dbus_thread_manager.h
View file @ 85b95a20
...@@ -37,6 +37,7 @@ class MockFlimflamServiceClient; ...@@ -37,6 +37,7 @@ class MockFlimflamServiceClient;
class MockGsmSMSClient; class MockGsmSMSClient;
class MockImageBurnerClient; class MockImageBurnerClient;
class MockIntrospectableClient; class MockIntrospectableClient;
class MockMediaTransferProtocolDaemonClient;
class MockModemMessagingClient; class MockModemMessagingClient;
class MockPowerManagerClient; class MockPowerManagerClient;
class MockSessionManagerClient; class MockSessionManagerClient;
...@@ -74,6 +75,8 @@ class MockDBusThreadManager : public DBusThreadManager { ...@@ -74,6 +75,8 @@ class MockDBusThreadManager : public DBusThreadManager {
MOCK_METHOD0(GetGsmSMSClient, GsmSMSClient*(void)); MOCK_METHOD0(GetGsmSMSClient, GsmSMSClient*(void));
MOCK_METHOD0(GetImageBurnerClient, ImageBurnerClient*(void)); MOCK_METHOD0(GetImageBurnerClient, ImageBurnerClient*(void));
MOCK_METHOD0(GetIntrospectableClient, IntrospectableClient*(void)); MOCK_METHOD0(GetIntrospectableClient, IntrospectableClient*(void));
MOCK_METHOD0(GetMediaTransferProtocolDaemonClient,
MediaTransferProtocolDaemonClient*(void));
MOCK_METHOD0(GetModemMessagingClient, ModemMessagingClient*(void)); MOCK_METHOD0(GetModemMessagingClient, ModemMessagingClient*(void));
MOCK_METHOD0(GetPowerManagerClient, PowerManagerClient*(void)); MOCK_METHOD0(GetPowerManagerClient, PowerManagerClient*(void));
MOCK_METHOD0(GetSessionManagerClient, SessionManagerClient*(void)); MOCK_METHOD0(GetSessionManagerClient, SessionManagerClient*(void));
...@@ -145,6 +148,10 @@ class MockDBusThreadManager : public DBusThreadManager { ...@@ -145,6 +148,10 @@ class MockDBusThreadManager : public DBusThreadManager {
MockIntrospectableClient* mock_introspectable_client() { MockIntrospectableClient* mock_introspectable_client() {
return mock_introspectable_client_.get(); return mock_introspectable_client_.get();
} }
MockMediaTransferProtocolDaemonClient*
mock_media_transfer_protocol_daemon_client() {
return mock_media_transfer_protocol_daemon_client_.get();
}
MockModemMessagingClient* mock_modem_messaging_client() { MockModemMessagingClient* mock_modem_messaging_client() {
return mock_modem_messaging_client_.get(); return mock_modem_messaging_client_.get();
} }
...@@ -184,6 +191,8 @@ class MockDBusThreadManager : public DBusThreadManager { ...@@ -184,6 +191,8 @@ class MockDBusThreadManager : public DBusThreadManager {
scoped_ptr<MockGsmSMSClient> mock_gsm_sms_client_; scoped_ptr<MockGsmSMSClient> mock_gsm_sms_client_;
scoped_ptr<MockImageBurnerClient> mock_image_burner_client_; scoped_ptr<MockImageBurnerClient> mock_image_burner_client_;
scoped_ptr<MockIntrospectableClient> mock_introspectable_client_; scoped_ptr<MockIntrospectableClient> mock_introspectable_client_;
scoped_ptr<MockMediaTransferProtocolDaemonClient>
mock_media_transfer_protocol_daemon_client_;
scoped_ptr<MockModemMessagingClient> mock_modem_messaging_client_; scoped_ptr<MockModemMessagingClient> mock_modem_messaging_client_;
scoped_ptr<MockPowerManagerClient> mock_power_manager_client_; scoped_ptr<MockPowerManagerClient> mock_power_manager_client_;
scoped_ptr<MockSessionManagerClient> mock_session_manager_client_; scoped_ptr<MockSessionManagerClient> mock_session_manager_client_;
......
chromeos/dbus/mock_dbus_thread_manager_without_gmock.cc
View file @ 85b95a20
...@@ -135,6 +135,12 @@ IntrospectableClient* ...@@ -135,6 +135,12 @@ IntrospectableClient*
return NULL; return NULL;
} }
MediaTransferProtocolDaemonClient*
MockDBusThreadManagerWithoutGMock::GetMediaTransferProtocolDaemonClient() {
NOTIMPLEMENTED();
return NULL;
}
ModemMessagingClient* ModemMessagingClient*
MockDBusThreadManagerWithoutGMock::GetModemMessagingClient() { MockDBusThreadManagerWithoutGMock::GetModemMessagingClient() {
NOTIMPLEMENTED(); NOTIMPLEMENTED();
......
chromeos/dbus/mock_dbus_thread_manager_without_gmock.h
View file @ 85b95a20
...@@ -52,6 +52,8 @@ class MockDBusThreadManagerWithoutGMock : public DBusThreadManager { ...@@ -52,6 +52,8 @@ class MockDBusThreadManagerWithoutGMock : public DBusThreadManager {
virtual GsmSMSClient* GetGsmSMSClient() OVERRIDE; virtual GsmSMSClient* GetGsmSMSClient() OVERRIDE;
virtual ImageBurnerClient* GetImageBurnerClient() OVERRIDE; virtual ImageBurnerClient* GetImageBurnerClient() OVERRIDE;
virtual IntrospectableClient* GetIntrospectableClient() OVERRIDE; virtual IntrospectableClient* GetIntrospectableClient() OVERRIDE;
virtual MediaTransferProtocolDaemonClient*
GetMediaTransferProtocolDaemonClient() OVERRIDE;
virtual ModemMessagingClient* GetModemMessagingClient() OVERRIDE; virtual ModemMessagingClient* GetModemMessagingClient() OVERRIDE;
virtual PowerManagerClient* GetPowerManagerClient() OVERRIDE; virtual PowerManagerClient* GetPowerManagerClient() OVERRIDE;
virtual SessionManagerClient* GetSessionManagerClient() OVERRIDE; virtual SessionManagerClient* GetSessionManagerClient() OVERRIDE;
......
chromeos/dbus/mock_media_transfer_protocol_daemon_client.cc 0 → 100644
View file @ 85b95a20
// 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 "chromeos/dbus/mock_media_transfer_protocol_daemon_client.h"
namespace chromeos {
MockMediaTransferProtocolDaemonClient::MockMediaTransferProtocolDaemonClient() {} // NOLINT
MockMediaTransferProtocolDaemonClient::~MockMediaTransferProtocolDaemonClient() {} // NOLINT
} // namespace chromeos
chromeos/dbus/mock_media_transfer_protocol_daemon_client.h 0 → 100644
View file @ 85b95a20
// 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.
#ifndef CHROMEOS_DBUS_MOCK_MEDIA_TRANSFER_PROTOCOL_DAEMON_CLIENT_H_
#define CHROMEOS_DBUS_MOCK_MEDIA_TRANSFER_PROTOCOL_DAEMON_CLIENT_H_
#include <string>
#include "chromeos/dbus/media_transfer_protocol_daemon_client.h"
#include "testing/gmock/include/gmock/gmock.h"
namespace chromeos {
class MockMediaTransferProtocolDaemonClient
: public MediaTransferProtocolDaemonClient {
public:
MockMediaTransferProtocolDaemonClient();
virtual ~MockMediaTransferProtocolDaemonClient();
MOCK_METHOD2(EnumerateStorage, void(const EnumerateStorageCallback&,
const ErrorCallback&));
MOCK_METHOD3(GetStorageInfo, void(const std::string&,
const GetStorageInfoCallback&,
const ErrorCallback&));
MOCK_METHOD4(OpenStorage, void(const std::string&,
OpenStorageMode mode,
const OpenStorageCallback&,
const ErrorCallback&));
MOCK_METHOD3(CloseStorage, void(const std::string&,
const CloseStorageCallback&,
const ErrorCallback&));
MOCK_METHOD4(ReadDirectoryByPath, void(const std::string&,
const std::string&,
const ReadDirectoryCallback&,
const ErrorCallback&));
MOCK_METHOD4(ReadDirectoryById, void(const std::string&,
uint32,
const ReadDirectoryCallback&,
const ErrorCallback&));
MOCK_METHOD4(ReadFileByPath, void(const std::string&,
const std::string&,
const ReadFileCallback&,
const ErrorCallback&));
MOCK_METHOD4(ReadFileById, void(const std::string&,
uint32,
const ReadFileCallback&,
const ErrorCallback&));
MOCK_METHOD1(SetUpConnections, void(const MTPStorageEventHandler&));
};
} // namespace chromeos
#endif // CHROMEOS_DBUS_MOCK_MEDIA_TRANSFER_PROTOCOL_DAEMON_CLIENT_H_
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment