chromeos/dbus/cros_disks_client.cc

   1 // Copyright (c) 2012 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/cros_disks_client.h"
   6
   7 #include <map>
   8
   9 #include "base/bind.h"
  10 #include "base/files/file_path.h"
  11 #include "base/files/file_util.h"
  12 #include "base/location.h"
  13 #include "base/message_loop/message_loop_proxy.h"
  14 #include "base/stl_util.h"
  15 #include "base/strings/stringprintf.h"
  16 #include "base/sys_info.h"
  17 #include "base/task_runner_util.h"
  18 #include "base/threading/worker_pool.h"
  19 #include "base/values.h"
  20 #include "dbus/bus.h"
  21 #include "dbus/message.h"
  22 #include "dbus/object_path.h"
  23 #include "dbus/object_proxy.h"
  24 #include "dbus/values_util.h"
  25 #include "third_party/cros_system_api/dbus/service_constants.h"
  26
  27 namespace chromeos {
  28
  29 namespace {
  30
  31 const char* kDefaultMountOptions[] = {
  32   "rw",
  33   "nodev",
  34   "noexec",
  35   "nosuid",
  36 };
  37
  38 const char* kDefaultUnmountOptions[] = {
  39   "force",
  40 };
  41
  42 const char kLazyUnmountOption[] = "lazy";
  43
  44 const char kMountLabelOption[] = "mountlabel";
  45
  46 // Checks if retrieved media type is in boundaries of DeviceMediaType.
  47 bool IsValidMediaType(uint32 type) {
  48   return type < static_cast<uint32>(cros_disks::DEVICE_MEDIA_NUM_VALUES);
  49 }
  50
  51 // Translates enum used in cros-disks to enum used in Chrome.
  52 // Note that we could just do static_cast, but this is less sensitive to
  53 // changes in cros-disks.
  54 DeviceType DeviceMediaTypeToDeviceType(uint32 media_type_uint32) {
  55   if (!IsValidMediaType(media_type_uint32))
  56     return DEVICE_TYPE_UNKNOWN;
  57
  58   cros_disks::DeviceMediaType media_type =
  59       cros_disks::DeviceMediaType(media_type_uint32);
  60
  61   switch (media_type) {
  62     case(cros_disks::DEVICE_MEDIA_UNKNOWN):
  63       return DEVICE_TYPE_UNKNOWN;
  64     case(cros_disks::DEVICE_MEDIA_USB):
  65       return DEVICE_TYPE_USB;
  66     case(cros_disks::DEVICE_MEDIA_SD):
  67       return DEVICE_TYPE_SD;
  68     case(cros_disks::DEVICE_MEDIA_OPTICAL_DISC):
  69       return DEVICE_TYPE_OPTICAL_DISC;
  70     case(cros_disks::DEVICE_MEDIA_MOBILE):
  71       return DEVICE_TYPE_MOBILE;
  72     case(cros_disks::DEVICE_MEDIA_DVD):
  73       return DEVICE_TYPE_DVD;
  74     default:
  75       return DEVICE_TYPE_UNKNOWN;
  76   }
  77 }
  78
  79 bool ReadMountEntryFromDbus(dbus::MessageReader* reader, MountEntry* entry) {
  80   uint32 error_code = 0;
  81   std::string source_path;
  82   uint32 mount_type = 0;
  83   std::string mount_path;
  84   if (!reader->PopUint32(&error_code) ||
  85       !reader->PopString(&source_path) ||
  86       !reader->PopUint32(&mount_type) ||
  87       !reader->PopString(&mount_path)) {
  88     return false;
  89   }
  90   *entry = MountEntry(static_cast<MountError>(error_code), source_path,
  91                       static_cast<MountType>(mount_type), mount_path);
  92   return true;
  93 }
  94
  95 // The CrosDisksClient implementation.
  96 class CrosDisksClientImpl : public CrosDisksClient {
  97  public:
  98   CrosDisksClientImpl() : proxy_(NULL), weak_ptr_factory_(this) {}
  99
 100   // CrosDisksClient override.
 101   virtual void Mount(const std::string& source_path,
 102                      const std::string& source_format,
 103                      const std::string& mount_label,
 104                      const base::Closure& callback,
 105                      const base::Closure& error_callback) OVERRIDE {
 106     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
 107                                  cros_disks::kMount);
 108     dbus::MessageWriter writer(&method_call);
 109     writer.AppendString(source_path);
 110     writer.AppendString(source_format);
 111     std::vector<std::string> mount_options(kDefaultMountOptions,
 112                                            kDefaultMountOptions +
 113                                            arraysize(kDefaultMountOptions));
 114     if (!mount_label.empty()) {
 115       std::string mount_label_option = base::StringPrintf("%s=%s",
 116                                                           kMountLabelOption,
 117                                                           mount_label.c_str());
 118       mount_options.push_back(mount_label_option);
 119     }
 120     writer.AppendArrayOfStrings(mount_options);
 121     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 122                        base::Bind(&CrosDisksClientImpl::OnMount,
 123                                   weak_ptr_factory_.GetWeakPtr(),
 124                                   callback,
 125                                   error_callback));
 126   }
 127
 128   // CrosDisksClient override.
 129   virtual void Unmount(const std::string& device_path,
 130                        UnmountOptions options,
 131                        const base::Closure& callback,
 132                        const base::Closure& error_callback) OVERRIDE {
 133     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
 134                                  cros_disks::kUnmount);
 135     dbus::MessageWriter writer(&method_call);
 136     writer.AppendString(device_path);
 137
 138     std::vector<std::string> unmount_options(
 139         kDefaultUnmountOptions,
 140         kDefaultUnmountOptions + arraysize(kDefaultUnmountOptions));
 141     if (options == UNMOUNT_OPTIONS_LAZY)
 142       unmount_options.push_back(kLazyUnmountOption);
 143
 144     writer.AppendArrayOfStrings(unmount_options);
 145     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 146                        base::Bind(&CrosDisksClientImpl::OnUnmount,
 147                                   weak_ptr_factory_.GetWeakPtr(),
 148                                   callback,
 149                                   error_callback));
 150   }
 151
 152   // CrosDisksClient override.
 153   virtual void EnumerateAutoMountableDevices(
 154       const EnumerateAutoMountableDevicesCallback& callback,
 155       const base::Closure& error_callback) OVERRIDE {
 156     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
 157                                  cros_disks::kEnumerateAutoMountableDevices);
 158     proxy_->CallMethod(
 159         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 160         base::Bind(&CrosDisksClientImpl::OnEnumerateAutoMountableDevices,
 161                    weak_ptr_factory_.GetWeakPtr(),
 162                    callback,
 163                    error_callback));
 164   }
 165
 166   // CrosDisksClient override.
 167   virtual void EnumerateMountEntries(
 168       const EnumerateMountEntriesCallback& callback,
 169       const base::Closure& error_callback) OVERRIDE {
 170     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
 171                                  cros_disks::kEnumerateMountEntries);
 172     proxy_->CallMethod(
 173         &method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 174         base::Bind(&CrosDisksClientImpl::OnEnumerateMountEntries,
 175                    weak_ptr_factory_.GetWeakPtr(),
 176                    callback,
 177                    error_callback));
 178   }
 179
 180   // CrosDisksClient override.
 181   virtual void Format(const std::string& device_path,
 182                       const std::string& filesystem,
 183                       const base::Closure& callback,
 184                       const base::Closure& error_callback) OVERRIDE {
 185     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
 186                                  cros_disks::kFormat);
 187     dbus::MessageWriter writer(&method_call);
 188     writer.AppendString(device_path);
 189     writer.AppendString(filesystem);
 190     // No format option is currently specified, but we can later use this
 191     // argument to specify options for the format operation.
 192     std::vector<std::string> format_options;
 193     writer.AppendArrayOfStrings(format_options);
 194     proxy_->CallMethod(&method_call, dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 195                        base::Bind(&CrosDisksClientImpl::OnFormat,
 196                                   weak_ptr_factory_.GetWeakPtr(),
 197                                   callback,
 198                                   error_callback));
 199   }
 200
 201   // CrosDisksClient override.
 202   virtual void GetDeviceProperties(
 203       const std::string& device_path,
 204       const GetDevicePropertiesCallback& callback,
 205       const base::Closure& error_callback) OVERRIDE {
 206     dbus::MethodCall method_call(cros_disks::kCrosDisksInterface,
 207                                  cros_disks::kGetDeviceProperties);
 208     dbus::MessageWriter writer(&method_call);
 209     writer.AppendString(device_path);
 210     proxy_->CallMethod(&method_call,
 211                        dbus::ObjectProxy::TIMEOUT_USE_DEFAULT,
 212                        base::Bind(&CrosDisksClientImpl::OnGetDeviceProperties,
 213                                   weak_ptr_factory_.GetWeakPtr(),
 214                                   device_path,
 215                                   callback,
 216                                   error_callback));
 217   }
 218
 219   // CrosDisksClient override.
 220   virtual void SetMountEventHandler(
 221       const MountEventHandler& mount_event_handler) OVERRIDE {
 222     static const SignalEventTuple kSignalEventTuples[] = {
 223       { cros_disks::kDeviceAdded, CROS_DISKS_DEVICE_ADDED },
 224       { cros_disks::kDeviceScanned, CROS_DISKS_DEVICE_SCANNED },
 225       { cros_disks::kDeviceRemoved, CROS_DISKS_DEVICE_REMOVED },
 226       { cros_disks::kDiskAdded, CROS_DISKS_DISK_ADDED },
 227       { cros_disks::kDiskChanged, CROS_DISKS_DISK_CHANGED },
 228       { cros_disks::kDiskRemoved, CROS_DISKS_DISK_REMOVED },
 229     };
 230     const size_t kNumSignalEventTuples = arraysize(kSignalEventTuples);
 231
 232     for (size_t i = 0; i < kNumSignalEventTuples; ++i) {
 233       proxy_->ConnectToSignal(
 234           cros_disks::kCrosDisksInterface,
 235           kSignalEventTuples[i].signal_name,
 236           base::Bind(&CrosDisksClientImpl::OnMountEvent,
 237                      weak_ptr_factory_.GetWeakPtr(),
 238                      kSignalEventTuples[i].event_type,
 239                      mount_event_handler),
 240           base::Bind(&CrosDisksClientImpl::OnSignalConnected,
 241                      weak_ptr_factory_.GetWeakPtr()));
 242     }
 243   }
 244
 245   // CrosDisksClient override.
 246   virtual void SetMountCompletedHandler(
 247       const MountCompletedHandler& mount_completed_handler) OVERRIDE {
 248     proxy_->ConnectToSignal(
 249         cros_disks::kCrosDisksInterface,
 250         cros_disks::kMountCompleted,
 251         base::Bind(&CrosDisksClientImpl::OnMountCompleted,
 252                    weak_ptr_factory_.GetWeakPtr(),
 253                    mount_completed_handler),
 254         base::Bind(&CrosDisksClientImpl::OnSignalConnected,
 255                    weak_ptr_factory_.GetWeakPtr()));
 256   }
 257
 258   // CrosDisksClient override.
 259   virtual void SetFormatCompletedHandler(
 260       const FormatCompletedHandler& format_completed_handler) OVERRIDE {
 261     proxy_->ConnectToSignal(
 262         cros_disks::kCrosDisksInterface,
 263         cros_disks::kFormatCompleted,
 264         base::Bind(&CrosDisksClientImpl::OnFormatCompleted,
 265                    weak_ptr_factory_.GetWeakPtr(),
 266                    format_completed_handler),
 267         base::Bind(&CrosDisksClientImpl::OnSignalConnected,
 268                    weak_ptr_factory_.GetWeakPtr()));
 269   }
 270
 271  protected:
 272   virtual void Init(dbus::Bus* bus) OVERRIDE {
 273     proxy_ = bus->GetObjectProxy(
 274         cros_disks::kCrosDisksServiceName,
 275         dbus::ObjectPath(cros_disks::kCrosDisksServicePath));
 276   }
 277
 278  private:
 279   // A struct to contain a pair of signal name and mount event type.
 280   // Used by SetMountEventHandler.
 281   struct SignalEventTuple {
 282     const char *signal_name;
 283     MountEventType event_type;
 284   };
 285
 286   // Handles the result of Mount and calls |callback| or |error_callback|.
 287   void OnMount(const base::Closure& callback,
 288                const base::Closure& error_callback,
 289                dbus::Response* response) {
 290     if (!response) {
 291       error_callback.Run();
 292       return;
 293     }
 294     callback.Run();
 295   }
 296
 297   // Handles the result of Unmount and calls |callback| or |error_callback|.
 298   void OnUnmount(const base::Closure& callback,
 299                  const base::Closure& error_callback,
 300                  dbus::Response* response) {
 301     if (!response) {
 302       error_callback.Run();
 303       return;
 304     }
 305
 306     // Temporarly allow Unmount method to report failure both by setting dbus
 307     // error (in which case response is not set) and by returning mount error
 308     // different from MOUNT_ERROR_NONE. This is done so we can change Unmount
 309     // method to return mount error (http://crbug.com/288974) without breaking
 310     // Chrome.
 311     // TODO(tbarzic): When Unmount implementation is changed on cros disks side,
 312     // make this fail if reader is not able to read the error code value from
 313     // the response.
 314     dbus::MessageReader reader(response);
 315     uint32 error_code = 0;
 316     if (reader.PopUint32(&error_code) &&
 317         static_cast<MountError>(error_code) != MOUNT_ERROR_NONE) {
 318       error_callback.Run();
 319       return;
 320     }
 321
 322     callback.Run();
 323   }
 324
 325   // Handles the result of EnumerateAutoMountableDevices and calls |callback| or
 326   // |error_callback|.
 327   void OnEnumerateAutoMountableDevices(
 328       const EnumerateAutoMountableDevicesCallback& callback,
 329       const base::Closure& error_callback,
 330       dbus::Response* response) {
 331     if (!response) {
 332       error_callback.Run();
 333       return;
 334     }
 335     dbus::MessageReader reader(response);
 336     std::vector<std::string> device_paths;
 337     if (!reader.PopArrayOfStrings(&device_paths)) {
 338       LOG(ERROR) << "Invalid response: " << response->ToString();
 339       error_callback.Run();
 340       return;
 341     }
 342     callback.Run(device_paths);
 343   }
 344
 345   // Handles the result of EnumerateMountEntries and calls |callback| or
 346   // |error_callback|.
 347   void OnEnumerateMountEntries(
 348       const EnumerateMountEntriesCallback& callback,
 349       const base::Closure& error_callback,
 350       dbus::Response* response) {
 351     if (!response) {
 352       error_callback.Run();
 353       return;
 354     }
 355
 356     dbus::MessageReader reader(response);
 357     dbus::MessageReader array_reader(NULL);
 358     if (!reader.PopArray(&array_reader)) {
 359       LOG(ERROR) << "Invalid response: " << response->ToString();
 360       error_callback.Run();
 361       return;
 362     }
 363
 364     std::vector<MountEntry> entries;
 365     while (array_reader.HasMoreData()) {
 366       MountEntry entry;
 367       dbus::MessageReader sub_reader(NULL);
 368       if (!array_reader.PopStruct(&sub_reader) ||
 369           !ReadMountEntryFromDbus(&sub_reader, &entry)) {
 370         LOG(ERROR) << "Invalid response: " << response->ToString();
 371         error_callback.Run();
 372         return;
 373       }
 374       entries.push_back(entry);
 375     }
 376     callback.Run(entries);
 377   }
 378
 379   // Handles the result of Format and calls |callback| or |error_callback|.
 380   void OnFormat(const base::Closure& callback,
 381                 const base::Closure& error_callback,
 382                 dbus::Response* response) {
 383     if (!response) {
 384       error_callback.Run();
 385       return;
 386     }
 387     callback.Run();
 388   }
 389
 390   // Handles the result of GetDeviceProperties and calls |callback| or
 391   // |error_callback|.
 392   void OnGetDeviceProperties(const std::string& device_path,
 393                              const GetDevicePropertiesCallback& callback,
 394                              const base::Closure& error_callback,
 395                              dbus::Response* response) {
 396     if (!response) {
 397       error_callback.Run();
 398       return;
 399     }
 400     DiskInfo disk(device_path, response);
 401     callback.Run(disk);
 402   }
 403
 404   // Handles mount event signals and calls |handler|.
 405   void OnMountEvent(MountEventType event_type,
 406                     MountEventHandler handler,
 407                     dbus::Signal* signal) {
 408     dbus::MessageReader reader(signal);
 409     std::string device;
 410     if (!reader.PopString(&device)) {
 411       LOG(ERROR) << "Invalid signal: " << signal->ToString();
 412       return;
 413     }
 414     handler.Run(event_type, device);
 415   }
 416
 417   // Handles MountCompleted signal and calls |handler|.
 418   void OnMountCompleted(MountCompletedHandler handler, dbus::Signal* signal) {
 419     dbus::MessageReader reader(signal);
 420     MountEntry entry;
 421     if (!ReadMountEntryFromDbus(&reader, &entry)) {
 422       LOG(ERROR) << "Invalid signal: " << signal->ToString();
 423       return;
 424     }
 425     handler.Run(entry);
 426   }
 427
 428   // Handles FormatCompleted signal and calls |handler|.
 429   void OnFormatCompleted(FormatCompletedHandler handler, dbus::Signal* signal) {
 430     dbus::MessageReader reader(signal);
 431     uint32 error_code = 0;
 432     std::string device_path;
 433     if (!reader.PopUint32(&error_code) || !reader.PopString(&device_path)) {
 434       LOG(ERROR) << "Invalid signal: " << signal->ToString();
 435       return;
 436     }
 437     handler.Run(static_cast<FormatError>(error_code), device_path);
 438   }
 439
 440   // Handles the result of signal connection setup.
 441   void OnSignalConnected(const std::string& interface,
 442                          const std::string& signal,
 443                          bool succeeded) {
 444     LOG_IF(ERROR, !succeeded) << "Connect to " << interface << " " <<
 445         signal << " failed.";
 446   }
 447
 448   dbus::ObjectProxy* proxy_;
 449
 450   // Note: This should remain the last member so it'll be destroyed and
 451   // invalidate its weak pointers before any other members are destroyed.
 452   base::WeakPtrFactory<CrosDisksClientImpl> weak_ptr_factory_;
 453
 454   DISALLOW_COPY_AND_ASSIGN(CrosDisksClientImpl);
 455 };
 456
 457 // A stub implementaion of CrosDisksClient.
 458 class CrosDisksClientStubImpl : public CrosDisksClient {
 459  public:
 460   CrosDisksClientStubImpl()
 461       : weak_ptr_factory_(this) {}
 462
 463   virtual ~CrosDisksClientStubImpl() {}
 464
 465   // CrosDisksClient overrides:
 466   virtual void Init(dbus::Bus* bus) OVERRIDE {}
 467   virtual void Mount(const std::string& source_path,
 468                      const std::string& source_format,
 469                      const std::string& mount_label,
 470                      const base::Closure& callback,
 471                      const base::Closure& error_callback) OVERRIDE {
 472     // This stub implementation only accepts archive mount requests.
 473     const MountType type = MOUNT_TYPE_ARCHIVE;
 474
 475     const base::FilePath mounted_path = GetArchiveMountPoint().Append(
 476         base::FilePath::FromUTF8Unsafe(mount_label));
 477
 478     // Already mounted path.
 479     if (mounted_to_source_path_map_.count(mounted_path.value()) != 0) {
 480       FinishMount(MOUNT_ERROR_PATH_ALREADY_MOUNTED, source_path, type,
 481                   std::string(), callback);
 482       return;
 483     }
 484
 485     // Perform fake mount.
 486     base::PostTaskAndReplyWithResult(
 487         base::WorkerPool::GetTaskRunner(true /* task_is_slow */).get(),
 488         FROM_HERE,
 489         base::Bind(&PerformFakeMount, source_path, mounted_path),
 490         base::Bind(&CrosDisksClientStubImpl::ContinueMount,
 491                    weak_ptr_factory_.GetWeakPtr(),
 492                    source_path,
 493                    type,
 494                    callback,
 495                    mounted_path));
 496   }
 497
 498   virtual void Unmount(const std::string& device_path,
 499                        UnmountOptions options,
 500                        const base::Closure& callback,
 501                        const base::Closure& error_callback) OVERRIDE {
 502     // Not mounted.
 503     if (mounted_to_source_path_map_.count(device_path) == 0) {
 504       base::MessageLoopProxy::current()->PostTask(FROM_HERE, error_callback);
 505       return;
 506     }
 507
 508     mounted_to_source_path_map_.erase(device_path);
 509
 510     // Remove the directory created in Mount().
 511     base::WorkerPool::PostTaskAndReply(
 512         FROM_HERE,
 513         base::Bind(base::IgnoreResult(&base::DeleteFile),
 514                    base::FilePath::FromUTF8Unsafe(device_path),
 515                    true /* recursive */),
 516         callback,
 517         true /* task_is_slow */);
 518   }
 519
 520   virtual void EnumerateAutoMountableDevices(
 521       const EnumerateAutoMountableDevicesCallback& callback,
 522       const base::Closure& error_callback) OVERRIDE {
 523     std::vector<std::string> device_paths;
 524     base::MessageLoopProxy::current()->PostTask(
 525         FROM_HERE, base::Bind(callback, device_paths));
 526   }
 527
 528   virtual void EnumerateMountEntries(
 529       const EnumerateMountEntriesCallback& callback,
 530       const base::Closure& error_callback) OVERRIDE {
 531     std::vector<MountEntry> entries;
 532     base::MessageLoopProxy::current()->PostTask(
 533         FROM_HERE, base::Bind(callback, entries));
 534   }
 535
 536   virtual void Format(const std::string& device_path,
 537                       const std::string& filesystem,
 538                       const base::Closure& callback,
 539                       const base::Closure& error_callback) OVERRIDE {
 540     base::MessageLoopProxy::current()->PostTask(FROM_HERE, error_callback);
 541   }
 542
 543   virtual void GetDeviceProperties(
 544       const std::string& device_path,
 545       const GetDevicePropertiesCallback& callback,
 546       const base::Closure& error_callback) OVERRIDE {
 547     base::MessageLoopProxy::current()->PostTask(FROM_HERE, error_callback);
 548   }
 549
 550   virtual void SetMountEventHandler(
 551       const MountEventHandler& mount_event_handler) OVERRIDE {
 552     mount_event_handler_ = mount_event_handler;
 553   }
 554
 555   virtual void SetMountCompletedHandler(
 556       const MountCompletedHandler& mount_completed_handler) OVERRIDE {
 557     mount_completed_handler_ = mount_completed_handler;
 558   }
 559
 560   virtual void SetFormatCompletedHandler(
 561       const FormatCompletedHandler& format_completed_handler) OVERRIDE {
 562     format_completed_handler_ = format_completed_handler;
 563   }
 564
 565  private:
 566   // Performs file actions for Mount().
 567   static MountError PerformFakeMount(const std::string& source_path,
 568                                      const base::FilePath& mounted_path) {
 569     // Check the source path exists.
 570     if (!base::PathExists(base::FilePath::FromUTF8Unsafe(source_path))) {
 571       DLOG(ERROR) << "Source does not exist at " << source_path;
 572       return MOUNT_ERROR_INVALID_PATH;
 573     }
 574
 575     // Just create an empty directory and shows it as the mounted directory.
 576     if (!base::CreateDirectory(mounted_path)) {
 577       DLOG(ERROR) << "Failed to create directory at " << mounted_path.value();
 578       return MOUNT_ERROR_DIRECTORY_CREATION_FAILED;
 579     }
 580
 581     // Put a dummy file.
 582     const base::FilePath dummy_file_path =
 583         mounted_path.Append("SUCCESSFULLY_PERFORMED_FAKE_MOUNT.txt");
 584     const std::string dummy_file_content = "This is a dummy file.";
 585     const int write_result = base::WriteFile(
 586         dummy_file_path, dummy_file_content.data(), dummy_file_content.size());
 587     if (write_result != static_cast<int>(dummy_file_content.size())) {
 588       DLOG(ERROR) << "Failed to put a dummy file at "
 589                   << dummy_file_path.value();
 590       return MOUNT_ERROR_MOUNT_PROGRAM_FAILED;
 591     }
 592
 593     return MOUNT_ERROR_NONE;
 594   }
 595
 596   // Part of Mount() implementation.
 597   void ContinueMount(const std::string& source_path,
 598                      MountType type,
 599                      const base::Closure& callback,
 600                      const base::FilePath& mounted_path,
 601                      MountError mount_error) {
 602     if (mount_error != MOUNT_ERROR_NONE) {
 603       FinishMount(mount_error, source_path, type, std::string(), callback);
 604       return;
 605     }
 606     mounted_to_source_path_map_[mounted_path.value()] = source_path;
 607     FinishMount(MOUNT_ERROR_NONE, source_path, type,
 608                 mounted_path.AsUTF8Unsafe(), callback);
 609   }
 610
 611   // Runs |callback| and sends MountCompleted signal.
 612   // Part of Mount() implementation.
 613   void FinishMount(MountError error,
 614                    const std::string& source_path,
 615                    MountType type,
 616                    const std::string& mounted_path,
 617                    const base::Closure& callback) {
 618     base::MessageLoopProxy::current()->PostTask(FROM_HERE, callback);
 619     if (!mount_completed_handler_.is_null()) {
 620       base::MessageLoopProxy::current()->PostTask(
 621           FROM_HERE,
 622           base::Bind(mount_completed_handler_,
 623                      MountEntry(error, source_path, type, mounted_path)));
 624     }
 625   }
 626
 627   // Mounted path to source path map.
 628   std::map<std::string, std::string> mounted_to_source_path_map_;
 629
 630   MountEventHandler mount_event_handler_;
 631   MountCompletedHandler mount_completed_handler_;
 632   FormatCompletedHandler format_completed_handler_;
 633
 634   base::WeakPtrFactory<CrosDisksClientStubImpl> weak_ptr_factory_;
 635
 636   DISALLOW_COPY_AND_ASSIGN(CrosDisksClientStubImpl);
 637 };
 638
 639 }  // namespace
 640
 641 ////////////////////////////////////////////////////////////////////////////////
 642 // DiskInfo
 643
 644 DiskInfo::DiskInfo(const std::string& device_path, dbus::Response* response)
 645     : device_path_(device_path),
 646       is_drive_(false),
 647       has_media_(false),
 648       on_boot_device_(false),
 649       on_removable_device_(false),
 650       device_type_(DEVICE_TYPE_UNKNOWN),
 651       total_size_in_bytes_(0),
 652       is_read_only_(false),
 653       is_hidden_(true) {
 654   InitializeFromResponse(response);
 655 }
 656
 657 DiskInfo::~DiskInfo() {
 658 }
 659
 660 // Initializes |this| from |response| given by the cros-disks service.
 661 // Below is an example of |response|'s raw message (long string is ellipsized).
 662 //
 663 //
 664 // message_type: MESSAGE_METHOD_RETURN
 665 // destination: :1.8
 666 // sender: :1.16
 667 // signature: a{sv}
 668 // serial: 96
 669 // reply_serial: 267
 670 //
 671 // array [
 672 //   dict entry {
 673 //     string "DeviceFile"
 674 //     variant       string "/dev/sdb"
 675 //   }
 676 //   dict entry {
 677 //     string "DeviceIsDrive"
 678 //     variant       bool true
 679 //   }
 680 //   dict entry {
 681 //     string "DeviceIsMediaAvailable"
 682 //     variant       bool true
 683 //   }
 684 //   dict entry {
 685 //     string "DeviceIsMounted"
 686 //     variant       bool false
 687 //   }
 688 //   dict entry {
 689 //     string "DeviceIsOnBootDevice"
 690 //     variant       bool false
 691 //   }
 692 //   dict entry {
 693 //     string "DeviceIsOnRemovableDevice"
 694 //     variant       bool true
 695 //   }
 696 //   dict entry {
 697 //     string "DeviceIsReadOnly"
 698 //     variant       bool false
 699 //   }
 700 //   dict entry {
 701 //     string "DeviceIsVirtual"
 702 //     variant       bool false
 703 //   }
 704 //   dict entry {
 705 //     string "DeviceMediaType"
 706 //     variant       uint32 1
 707 //   }
 708 //   dict entry {
 709 //     string "DeviceMountPaths"
 710 //     variant       array [
 711 //       ]
 712 //   }
 713 //   dict entry {
 714 //     string "DevicePresentationHide"
 715 //     variant       bool true
 716 //   }
 717 //   dict entry {
 718 //     string "DeviceSize"
 719 //     variant       uint64 7998537728
 720 //   }
 721 //   dict entry {
 722 //     string "DriveIsRotational"
 723 //     variant       bool false
 724 //   }
 725 //   dict entry {
 726 //     string "VendorId"
 727 //     variant       string "18d1"
 728 //   }
 729 //   dict entry {
 730 //     string "VendorName"
 731 //     variant       string "Google Inc."
 732 //   }
 733 //   dict entry {
 734 //     string "ProductId"
 735 //     variant       string "4e11"
 736 //   }
 737 //   dict entry {
 738 //     string "ProductName"
 739 //     variant       string "Nexus One"
 740 //   }
 741 //   dict entry {
 742 //     string "DriveModel"
 743 //     variant       string "TransMemory"
 744 //   }
 745 //   dict entry {
 746 //     string "IdLabel"
 747 //     variant       string ""
 748 //   }
 749 //   dict entry {
 750 //     string "IdUuid"
 751 //     variant       string ""
 752 //   }
 753 //   dict entry {
 754 //     string "NativePath"
 755 //     variant       string "/sys/devices/pci0000:00/0000:00:1d.7/usb1/1-4/...
 756 //   }
 757 // ]
 758 void DiskInfo::InitializeFromResponse(dbus::Response* response) {
 759   dbus::MessageReader reader(response);
 760   scoped_ptr<base::Value> value(dbus::PopDataAsValue(&reader));
 761   base::DictionaryValue* properties = NULL;
 762   if (!value || !value->GetAsDictionary(&properties))
 763     return;
 764
 765   properties->GetBooleanWithoutPathExpansion(
 766       cros_disks::kDeviceIsDrive, &is_drive_);
 767   properties->GetBooleanWithoutPathExpansion(
 768       cros_disks::kDeviceIsReadOnly, &is_read_only_);
 769   properties->GetBooleanWithoutPathExpansion(
 770       cros_disks::kDevicePresentationHide, &is_hidden_);
 771   properties->GetBooleanWithoutPathExpansion(
 772       cros_disks::kDeviceIsMediaAvailable, &has_media_);
 773   properties->GetBooleanWithoutPathExpansion(
 774       cros_disks::kDeviceIsOnBootDevice, &on_boot_device_);
 775   properties->GetBooleanWithoutPathExpansion(
 776       cros_disks::kDeviceIsOnRemovableDevice, &on_removable_device_);
 777   properties->GetStringWithoutPathExpansion(
 778       cros_disks::kNativePath, &system_path_);
 779   properties->GetStringWithoutPathExpansion(
 780       cros_disks::kDeviceFile, &file_path_);
 781   properties->GetStringWithoutPathExpansion(cros_disks::kVendorId, &vendor_id_);
 782   properties->GetStringWithoutPathExpansion(
 783       cros_disks::kVendorName, &vendor_name_);
 784   properties->GetStringWithoutPathExpansion(
 785       cros_disks::kProductId, &product_id_);
 786   properties->GetStringWithoutPathExpansion(
 787       cros_disks::kProductName, &product_name_);
 788   properties->GetStringWithoutPathExpansion(
 789       cros_disks::kDriveModel, &drive_model_);
 790   properties->GetStringWithoutPathExpansion(cros_disks::kIdLabel, &label_);
 791   properties->GetStringWithoutPathExpansion(cros_disks::kIdUuid, &uuid_);
 792
 793   // dbus::PopDataAsValue() pops uint64 as double.
 794   // The top 11 bits of uint64 are dropped by the use of double. But, this works
 795   // unless the size exceeds 8 PB.
 796   double device_size_double = 0;
 797   if (properties->GetDoubleWithoutPathExpansion(cros_disks::kDeviceSize,
 798                                                 &device_size_double))
 799     total_size_in_bytes_ = device_size_double;
 800
 801   // dbus::PopDataAsValue() pops uint32 as double.
 802   double media_type_double = 0;
 803   if (properties->GetDoubleWithoutPathExpansion(cros_disks::kDeviceMediaType,
 804                                                 &media_type_double))
 805     device_type_ = DeviceMediaTypeToDeviceType(media_type_double);
 806
 807   base::ListValue* mount_paths = NULL;
 808   if (properties->GetListWithoutPathExpansion(cros_disks::kDeviceMountPaths,
 809                                               &mount_paths))
 810     mount_paths->GetString(0, &mount_path_);
 811 }
 812
 813 ////////////////////////////////////////////////////////////////////////////////
 814 // CrosDisksClient
 815
 816 CrosDisksClient::CrosDisksClient() {}
 817
 818 CrosDisksClient::~CrosDisksClient() {}
 819
 820 // static
 821 CrosDisksClient* CrosDisksClient::Create(DBusClientImplementationType type) {
 822   if (type == REAL_DBUS_CLIENT_IMPLEMENTATION)
 823     return new CrosDisksClientImpl();
 824   DCHECK_EQ(STUB_DBUS_CLIENT_IMPLEMENTATION, type);
 825   return new CrosDisksClientStubImpl();
 826 }
 827
 828 // static
 829 base::FilePath CrosDisksClient::GetArchiveMountPoint() {
 830   return base::FilePath(base::SysInfo::IsRunningOnChromeOS() ?
 831                         FILE_PATH_LITERAL("/media/archive") :
 832                         FILE_PATH_LITERAL("/tmp/chromeos/media/archive"));
 833 }
 834
 835 // static
 836 base::FilePath CrosDisksClient::GetRemovableDiskMountPoint() {
 837   return base::FilePath(base::SysInfo::IsRunningOnChromeOS() ?
 838                         FILE_PATH_LITERAL("/media/removable") :
 839                         FILE_PATH_LITERAL("/tmp/chromeos/media/removable"));
 840 }
 841
 842 }  // namespace chromeos