chromeos/dbus/fake_cros_disks_client.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "chromeos/dbus/fake_cros_disks_client.h"
   6
   7 #include "base/bind.h"
   8 #include "base/message_loop/message_loop.h"
   9
  10 namespace chromeos {
  11
  12 FakeCrosDisksClient::FakeCrosDisksClient()
  13     : unmount_call_count_(0),
  14       unmount_success_(true),
  15       format_device_call_count_(0),
  16       format_device_success_(true) {
  17 }
  18
  19 FakeCrosDisksClient::~FakeCrosDisksClient() {
  20 }
  21
  22 void FakeCrosDisksClient::Init(dbus::Bus* bus) {
  23 }
  24
  25 void FakeCrosDisksClient::Mount(const std::string& source_path,
  26                                 const std::string& source_format,
  27                                 const std::string& mount_label,
  28                                 const base::Closure& callback,
  29                                 const base::Closure& error_callback) {
  30 }
  31
  32 void FakeCrosDisksClient::Unmount(const std::string& device_path,
  33                                   UnmountOptions options,
  34                                   const base::Closure& callback,
  35                                   const base::Closure& error_callback) {
  36   DCHECK(!callback.is_null());
  37   DCHECK(!error_callback.is_null());
  38
  39   unmount_call_count_++;
  40   last_unmount_device_path_ = device_path;
  41   last_unmount_options_ = options;
  42   base::MessageLoopProxy::current()->PostTask(
  43       FROM_HERE, unmount_success_ ? callback : error_callback);
  44   if (!unmount_listener_.is_null())
  45     unmount_listener_.Run();
  46 }
  47
  48 void FakeCrosDisksClient::EnumerateAutoMountableDevices(
  49     const EnumerateAutoMountableDevicesCallback& callback,
  50     const base::Closure& error_callback) {
  51 }
  52
  53 void FakeCrosDisksClient::FormatDevice(const std::string& device_path,
  54                                        const std::string& filesystem,
  55                                        const FormatDeviceCallback& callback,
  56                                        const base::Closure& error_callback) {
  57   DCHECK(!callback.is_null());
  58   DCHECK(!error_callback.is_null());
  59
  60   format_device_call_count_++;
  61   last_format_device_device_path_ = device_path;
  62   last_format_device_filesystem_ = filesystem;
  63   if (format_device_success_) {
  64     base::MessageLoopProxy::current()->PostTask(FROM_HERE,
  65                                                 base::Bind(callback, true));
  66   } else {
  67     base::MessageLoopProxy::current()->PostTask(FROM_HERE, error_callback);
  68   }
  69 }
  70
  71 void FakeCrosDisksClient::GetDeviceProperties(
  72     const std::string& device_path,
  73     const GetDevicePropertiesCallback& callback,
  74     const base::Closure& error_callback) {
  75 }
  76
  77 void FakeCrosDisksClient::SetUpConnections(
  78     const MountEventHandler& mount_event_handler,
  79     const MountCompletedHandler& mount_completed_handler) {
  80   mount_event_handler_ = mount_event_handler;
  81   mount_completed_handler_ = mount_completed_handler;
  82 }
  83
  84 bool FakeCrosDisksClient::SendMountEvent(MountEventType event,
  85                                          const std::string& path) {
  86   if (mount_event_handler_.is_null())
  87     return false;
  88   mount_event_handler_.Run(event, path);
  89   return true;
  90 }
  91
  92 bool FakeCrosDisksClient::SendMountCompletedEvent(
  93     MountError error_code,
  94     const std::string& source_path,
  95     MountType mount_type,
  96     const std::string& mount_path) {
  97   if (mount_completed_handler_.is_null())
  98     return false;
  99   mount_completed_handler_.Run(error_code, source_path, mount_type, mount_path);
 100   return true;
 101 }
 102
 103 }  // namespace chromeos