chromeos/disks/disk_mount_manager.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/disks/disk_mount_manager.h"
   6
   7 #include <map>
   8 #include <set>
   9
  10 #include "base/bind.h"
  11 #include "base/memory/weak_ptr.h"
  12 #include "base/observer_list.h"
  13 #include "base/stl_util.h"
  14 #include "base/string_util.h"
  15 #include "chromeos/dbus/dbus_thread_manager.h"
  16
  17 namespace chromeos {
  18 namespace disks {
  19
  20 namespace {
  21
  22 const char kDeviceNotFound[] = "Device could not be found";
  23
  24 DiskMountManager* g_disk_mount_manager = NULL;
  25
  26 // The DiskMountManager implementation.
  27 class DiskMountManagerImpl : public DiskMountManager {
  28  public:
  29   DiskMountManagerImpl() : weak_ptr_factory_(this) {
  30     DBusThreadManager* dbus_thread_manager = DBusThreadManager::Get();
  31     DCHECK(dbus_thread_manager);
  32     cros_disks_client_ = dbus_thread_manager->GetCrosDisksClient();
  33     DCHECK(cros_disks_client_);
  34     cros_disks_client_->SetUpConnections(
  35         base::Bind(&DiskMountManagerImpl::OnMountEvent,
  36                    weak_ptr_factory_.GetWeakPtr()),
  37         base::Bind(&DiskMountManagerImpl::OnMountCompleted,
  38                    weak_ptr_factory_.GetWeakPtr()));
  39   }
  40
  41   virtual ~DiskMountManagerImpl() {
  42     STLDeleteContainerPairSecondPointers(disks_.begin(), disks_.end());
  43   }
  44
  45   // DiskMountManager override.
  46   virtual void AddObserver(Observer* observer) OVERRIDE {
  47     observers_.AddObserver(observer);
  48   }
  49
  50   // DiskMountManager override.
  51   virtual void RemoveObserver(Observer* observer) OVERRIDE {
  52     observers_.RemoveObserver(observer);
  53   }
  54
  55   // DiskMountManager override.
  56   virtual void MountPath(const std::string& source_path,
  57                          const std::string& source_format,
  58                          const std::string& mount_label,
  59                          MountType type) OVERRIDE {
  60     // Hidden and non-existent devices should not be mounted.
  61     if (type == MOUNT_TYPE_DEVICE) {
  62       DiskMap::const_iterator it = disks_.find(source_path);
  63       if (it == disks_.end() || it->second->is_hidden()) {
  64         OnMountCompleted(MOUNT_ERROR_INTERNAL, source_path, type, "");
  65         return;
  66       }
  67     }
  68     cros_disks_client_->Mount(
  69         source_path,
  70         source_format,
  71         mount_label,
  72         type,
  73         // When succeeds, OnMountCompleted will be called by
  74         // "MountCompleted" signal instead.
  75         base::Bind(&base::DoNothing),
  76         base::Bind(&DiskMountManagerImpl::OnMountCompleted,
  77                    weak_ptr_factory_.GetWeakPtr(),
  78                    MOUNT_ERROR_INTERNAL,
  79                    source_path,
  80                    type,
  81                    ""));
  82   }
  83
  84   // DiskMountManager override.
  85   virtual void UnmountPath(const std::string& mount_path,
  86                            UnmountOptions options,
  87                            const UnmountPathCallback& callback) OVERRIDE {
  88     UnmountChildMounts(mount_path);
  89     cros_disks_client_->Unmount(mount_path, options,
  90                                 base::Bind(&DiskMountManagerImpl::OnUnmountPath,
  91                                            weak_ptr_factory_.GetWeakPtr(),
  92                                            callback,
  93                                            true),
  94                                 base::Bind(&DiskMountManagerImpl::OnUnmountPath,
  95                                            weak_ptr_factory_.GetWeakPtr(),
  96                                            callback,
  97                                            false));
  98   }
  99
 100   // DiskMountManager override.
 101   virtual void FormatMountedDevice(const std::string& mount_path) OVERRIDE {
 102     MountPointMap::const_iterator mount_point = mount_points_.find(mount_path);
 103     if (mount_point == mount_points_.end()) {
 104       LOG(ERROR) << "Mount point with path \"" << mount_path << "\" not found.";
 105       OnFormatDevice(mount_path, false);
 106       return;
 107     }
 108
 109     std::string device_path = mount_point->second.source_path;
 110     DiskMap::const_iterator disk = disks_.find(device_path);
 111     if (disk == disks_.end()) {
 112       LOG(ERROR) << "Device with path \"" << device_path << "\" not found.";
 113       OnFormatDevice(device_path, false);
 114       return;
 115     }
 116
 117     UnmountPath(disk->second->mount_path(),
 118                 UNMOUNT_OPTIONS_NONE,
 119                 base::Bind(&DiskMountManagerImpl::OnUnmountPathForFormat,
 120                            weak_ptr_factory_.GetWeakPtr(),
 121                            device_path));
 122   }
 123
 124   // DiskMountManager override.
 125   virtual void UnmountDeviceRecursively(
 126       const std::string& device_path,
 127       const UnmountDeviceRecursivelyCallbackType& callback) OVERRIDE {
 128     std::vector<std::string> devices_to_unmount;
 129
 130     // Get list of all devices to unmount.
 131     int device_path_len = device_path.length();
 132     for (DiskMap::iterator it = disks_.begin(); it != disks_.end(); ++it) {
 133       if (!it->second->mount_path().empty() &&
 134           strncmp(device_path.c_str(), it->second->device_path().c_str(),
 135                   device_path_len) == 0) {
 136         devices_to_unmount.push_back(it->second->mount_path());
 137       }
 138     }
 139
 140     // We should detect at least original device.
 141     if (devices_to_unmount.empty()) {
 142       if (disks_.find(device_path) == disks_.end()) {
 143         LOG(WARNING) << "Unmount recursive request failed for device "
 144                      << device_path << ", with error: " << kDeviceNotFound;
 145         callback.Run(false);
 146         return;
 147       }
 148
 149       // Nothing to unmount.
 150       callback.Run(true);
 151       return;
 152     }
 153
 154     // We will send the same callback data object to all Unmount calls and use
 155     // it to syncronize callbacks.
 156     // Note: this implementation has a potential memory leak issue. For
 157     // example if this instance is destructed before all the callbacks for
 158     // Unmount are invoked, the memory pointed by |cb_data| will be leaked.
 159     // It is because the UnmountDeviceRecursivelyCallbackData keeps how
 160     // many times OnUnmountDeviceRecursively callback is called and when
 161     // all the callbacks are called, |cb_data| will be deleted in the method.
 162     // However destructing the instance before all callback invocations will
 163     // cancel all pending callbacks, so that the |cb_data| would never be
 164     // deleted.
 165     // Fortunately, in the real scenario, the instance will be destructed
 166     // only for ShutDown. So, probably the memory would rarely be leaked.
 167     // TODO(hidehiko): Fix the issue.
 168     UnmountDeviceRecursivelyCallbackData* cb_data =
 169         new UnmountDeviceRecursivelyCallbackData(
 170             callback, devices_to_unmount.size());
 171     for (size_t i = 0; i < devices_to_unmount.size(); ++i) {
 172       cros_disks_client_->Unmount(
 173           devices_to_unmount[i],
 174           UNMOUNT_OPTIONS_NONE,
 175           base::Bind(&DiskMountManagerImpl::OnUnmountDeviceRecursively,
 176                      weak_ptr_factory_.GetWeakPtr(), cb_data, true),
 177           base::Bind(&DiskMountManagerImpl::OnUnmountDeviceRecursively,
 178                      weak_ptr_factory_.GetWeakPtr(), cb_data, false));
 179     }
 180   }
 181
 182   // DiskMountManager override.
 183   virtual void RequestMountInfoRefresh() OVERRIDE {
 184     cros_disks_client_->EnumerateAutoMountableDevices(
 185         base::Bind(&DiskMountManagerImpl::OnRequestMountInfo,
 186                    weak_ptr_factory_.GetWeakPtr()),
 187         base::Bind(&base::DoNothing));
 188   }
 189
 190   // DiskMountManager override.
 191   virtual const DiskMap& disks() const OVERRIDE { return disks_; }
 192
 193   // DiskMountManager override.
 194   virtual const Disk* FindDiskBySourcePath(const std::string& source_path)
 195       const OVERRIDE {
 196     DiskMap::const_iterator disk_it = disks_.find(source_path);
 197     return disk_it == disks_.end() ? NULL : disk_it->second;
 198   }
 199
 200   // DiskMountManager override.
 201   virtual const MountPointMap& mount_points() const OVERRIDE {
 202     return mount_points_;
 203   }
 204
 205   // DiskMountManager override.
 206   virtual bool AddDiskForTest(Disk* disk) OVERRIDE {
 207     if (disks_.find(disk->device_path()) != disks_.end()) {
 208       LOG(ERROR) << "Attempt to add a duplicate disk";
 209       return false;
 210     }
 211
 212     disks_.insert(std::make_pair(disk->device_path(), disk));
 213     return true;
 214   }
 215
 216   // DiskMountManager override.
 217   // Corresponding disk should be added to the manager before this is called.
 218   virtual bool AddMountPointForTest(
 219       const MountPointInfo& mount_point) OVERRIDE {
 220     if (mount_points_.find(mount_point.mount_path) != mount_points_.end()) {
 221       LOG(ERROR) << "Attempt to add a duplicate mount point";
 222       return false;
 223     }
 224     if (mount_point.mount_type == chromeos::MOUNT_TYPE_DEVICE &&
 225         disks_.find(mount_point.source_path) == disks_.end()) {
 226       LOG(ERROR) << "Device mount points must have a disk entry.";
 227       return false;
 228     }
 229
 230     mount_points_.insert(std::make_pair(mount_point.mount_path, mount_point));
 231     return true;
 232   }
 233
 234  private:
 235   struct UnmountDeviceRecursivelyCallbackData {
 236     UnmountDeviceRecursivelyCallbackData(
 237         const UnmountDeviceRecursivelyCallbackType& in_callback,
 238         int in_num_pending_callbacks)
 239         : callback(in_callback),
 240           num_pending_callbacks(in_num_pending_callbacks) {
 241     }
 242
 243     const UnmountDeviceRecursivelyCallbackType callback;
 244     size_t num_pending_callbacks;
 245   };
 246
 247   // Unmounts all mount points whose source path is transitively parented by
 248   // |mount_path|.
 249   void UnmountChildMounts(const std::string& mount_path_in) {
 250     std::string mount_path = mount_path_in;
 251     // Let's make sure mount path has trailing slash.
 252     if (mount_path[mount_path.length() - 1] != '/')
 253       mount_path += '/';
 254
 255     for (MountPointMap::iterator it = mount_points_.begin();
 256          it != mount_points_.end();
 257          ++it) {
 258       if (StartsWithASCII(it->second.source_path, mount_path,
 259                           true /*case sensitive*/)) {
 260         // TODO(tbarzic): Handle the case where this fails.
 261         UnmountPath(it->second.mount_path,
 262                     UNMOUNT_OPTIONS_NONE,
 263                     UnmountPathCallback());
 264       }
 265     }
 266   }
 267
 268   // Callback for UnmountDeviceRecursively.
 269   void OnUnmountDeviceRecursively(
 270       UnmountDeviceRecursivelyCallbackData* cb_data,
 271       bool success,
 272       const std::string& mount_path) {
 273     if (success) {
 274       // Do standard processing for Unmount event.
 275       OnUnmountPath(UnmountPathCallback(), true, mount_path);
 276       LOG(INFO) << mount_path <<  " unmounted.";
 277     }
 278     // This is safe as long as all callbacks are called on the same thread as
 279     // UnmountDeviceRecursively.
 280     cb_data->num_pending_callbacks--;
 281
 282     if (cb_data->num_pending_callbacks == 0) {
 283       // This code has a problem that the |success| status used here is for the
 284       // last "unmount" callback, but not whether all unmounting is succeeded.
 285       // TODO(hidehiko): Fix the issue.
 286       cb_data->callback.Run(success);
 287       delete cb_data;
 288     }
 289   }
 290
 291   // Callback to handle MountCompleted signal and Mount method call failure.
 292   void OnMountCompleted(MountError error_code,
 293                         const std::string& source_path,
 294                         MountType mount_type,
 295                         const std::string& mount_path) {
 296     MountCondition mount_condition = MOUNT_CONDITION_NONE;
 297     if (mount_type == MOUNT_TYPE_DEVICE) {
 298       if (error_code == MOUNT_ERROR_UNKNOWN_FILESYSTEM) {
 299         mount_condition = MOUNT_CONDITION_UNKNOWN_FILESYSTEM;
 300       }
 301       if (error_code == MOUNT_ERROR_UNSUPPORTED_FILESYSTEM) {
 302         mount_condition = MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM;
 303       }
 304     }
 305     const MountPointInfo mount_info(source_path, mount_path, mount_type,
 306                                     mount_condition);
 307
 308     NotifyMountStatusUpdate(MOUNTING, error_code, mount_info);
 309
 310     // If the device is corrupted but it's still possible to format it, it will
 311     // be fake mounted.
 312     if ((error_code == MOUNT_ERROR_NONE || mount_info.mount_condition) &&
 313         mount_points_.find(mount_info.mount_path) == mount_points_.end()) {
 314       mount_points_.insert(MountPointMap::value_type(mount_info.mount_path,
 315                                                      mount_info));
 316     }
 317     if ((error_code == MOUNT_ERROR_NONE || mount_info.mount_condition) &&
 318         mount_info.mount_type == MOUNT_TYPE_DEVICE &&
 319         !mount_info.source_path.empty() &&
 320         !mount_info.mount_path.empty()) {
 321       DiskMap::iterator iter = disks_.find(mount_info.source_path);
 322       if (iter == disks_.end()) {
 323         // disk might have been removed by now?
 324         return;
 325       }
 326       Disk* disk = iter->second;
 327       DCHECK(disk);
 328       disk->set_mount_path(mount_info.mount_path);
 329     }
 330   }
 331
 332   // Callback for UnmountPath.
 333   void OnUnmountPath(const UnmountPathCallback& callback,
 334                      bool success,
 335                      const std::string& mount_path) {
 336     MountPointMap::iterator mount_points_it = mount_points_.find(mount_path);
 337     if (mount_points_it == mount_points_.end()) {
 338       // The path was unmounted, but not as a result of this unmount request,
 339       // so return error.
 340       if (!callback.is_null())
 341         callback.Run(MOUNT_ERROR_INTERNAL);
 342       return;
 343     }
 344
 345     NotifyMountStatusUpdate(
 346         UNMOUNTING,
 347         success ? MOUNT_ERROR_NONE : MOUNT_ERROR_INTERNAL,
 348         MountPointInfo(mount_points_it->second.source_path,
 349                        mount_points_it->second.mount_path,
 350                        mount_points_it->second.mount_type,
 351                        mount_points_it->second.mount_condition));
 352
 353     std::string path(mount_points_it->second.source_path);
 354     if (success)
 355       mount_points_.erase(mount_points_it);
 356
 357     DiskMap::iterator disk_iter = disks_.find(path);
 358     if (disk_iter != disks_.end()) {
 359       DCHECK(disk_iter->second);
 360       if (success)
 361         disk_iter->second->clear_mount_path();
 362     }
 363
 364     if (!callback.is_null())
 365       callback.Run(success ? MOUNT_ERROR_NONE : MOUNT_ERROR_INTERNAL);
 366   }
 367
 368   void OnUnmountPathForFormat(const std::string& device_path,
 369                               MountError error_code) {
 370     if (error_code == MOUNT_ERROR_NONE &&
 371         disks_.find(device_path) != disks_.end()) {
 372       FormatUnmountedDevice(device_path);
 373     } else {
 374       OnFormatDevice(device_path, false);
 375     }
 376   }
 377
 378   // Starts device formatting.
 379   void FormatUnmountedDevice(const std::string& device_path) {
 380     DiskMap::const_iterator disk = disks_.find(device_path);
 381     DCHECK(disk != disks_.end() && disk->second->mount_path().empty());
 382
 383     const char kFormatVFAT[] = "vfat";
 384     cros_disks_client_->FormatDevice(
 385         device_path,
 386         kFormatVFAT,
 387         base::Bind(&DiskMountManagerImpl::OnFormatDevice,
 388                    weak_ptr_factory_.GetWeakPtr()),
 389         base::Bind(&DiskMountManagerImpl::OnFormatDevice,
 390                    weak_ptr_factory_.GetWeakPtr(),
 391                    device_path,
 392                    false));
 393   }
 394
 395   // Callback for FormatDevice.
 396   // TODO(tbarzic): Pass FormatError instead of bool.
 397   void OnFormatDevice(const std::string& device_path, bool success) {
 398     FormatError error_code =
 399         success ? FORMAT_ERROR_NONE : FORMAT_ERROR_UNKNOWN;
 400     NotifyFormatStatusUpdate(FORMAT_STARTED, error_code, device_path);
 401   }
 402
 403   // Callbcak for GetDeviceProperties.
 404   void OnGetDeviceProperties(const DiskInfo& disk_info) {
 405     // TODO(zelidrag): Find a better way to filter these out before we
 406     // fetch the properties:
 407     // Ignore disks coming from the device we booted the system from.
 408     if (disk_info.on_boot_device())
 409       return;
 410
 411     LOG(WARNING) << "Found disk " << disk_info.device_path();
 412     // Delete previous disk info for this path:
 413     bool is_new = true;
 414     DiskMap::iterator iter = disks_.find(disk_info.device_path());
 415     if (iter != disks_.end()) {
 416       delete iter->second;
 417       disks_.erase(iter);
 418       is_new = false;
 419     }
 420     Disk* disk = new Disk(disk_info.device_path(),
 421                           disk_info.mount_path(),
 422                           disk_info.system_path(),
 423                           disk_info.file_path(),
 424                           disk_info.label(),
 425                           disk_info.drive_label(),
 426                           disk_info.vendor_id(),
 427                           disk_info.vendor_name(),
 428                           disk_info.product_id(),
 429                           disk_info.product_name(),
 430                           disk_info.uuid(),
 431                           FindSystemPathPrefix(disk_info.system_path()),
 432                           disk_info.device_type(),
 433                           disk_info.total_size_in_bytes(),
 434                           disk_info.is_drive(),
 435                           disk_info.is_read_only(),
 436                           disk_info.has_media(),
 437                           disk_info.on_boot_device(),
 438                           disk_info.is_hidden());
 439     disks_.insert(std::make_pair(disk_info.device_path(), disk));
 440     NotifyDiskStatusUpdate(is_new ? DISK_ADDED : DISK_CHANGED, disk);
 441   }
 442
 443   // Callbcak for RequestMountInfo.
 444   void OnRequestMountInfo(const std::vector<std::string>& devices) {
 445     std::set<std::string> current_device_set;
 446     if (!devices.empty()) {
 447       // Initiate properties fetch for all removable disks,
 448       for (size_t i = 0; i < devices.size(); i++) {
 449         current_device_set.insert(devices[i]);
 450         // Initiate disk property retrieval for each relevant device path.
 451         cros_disks_client_->GetDeviceProperties(
 452             devices[i],
 453             base::Bind(&DiskMountManagerImpl::OnGetDeviceProperties,
 454                        weak_ptr_factory_.GetWeakPtr()),
 455             base::Bind(&base::DoNothing));
 456       }
 457     }
 458     // Search and remove disks that are no longer present.
 459     for (DiskMap::iterator iter = disks_.begin(); iter != disks_.end(); ) {
 460       if (current_device_set.find(iter->first) == current_device_set.end()) {
 461         Disk* disk = iter->second;
 462         NotifyDiskStatusUpdate(DISK_REMOVED, disk);
 463         delete iter->second;
 464         disks_.erase(iter++);
 465       } else {
 466         ++iter;
 467       }
 468     }
 469   }
 470
 471   // Callback to handle mount event signals.
 472   void OnMountEvent(MountEventType event, const std::string& device_path_arg) {
 473     // Take a copy of the argument so we can modify it below.
 474     std::string device_path = device_path_arg;
 475     switch (event) {
 476       case CROS_DISKS_DISK_ADDED: {
 477         cros_disks_client_->GetDeviceProperties(
 478             device_path,
 479             base::Bind(&DiskMountManagerImpl::OnGetDeviceProperties,
 480                        weak_ptr_factory_.GetWeakPtr()),
 481             base::Bind(&base::DoNothing));
 482         break;
 483       }
 484       case CROS_DISKS_DISK_REMOVED: {
 485         // Search and remove disks that are no longer present.
 486         DiskMountManager::DiskMap::iterator iter = disks_.find(device_path);
 487         if (iter != disks_.end()) {
 488           Disk* disk = iter->second;
 489           NotifyDiskStatusUpdate(DISK_REMOVED, disk);
 490           delete iter->second;
 491           disks_.erase(iter);
 492         }
 493         break;
 494       }
 495       case CROS_DISKS_DEVICE_ADDED: {
 496         system_path_prefixes_.insert(device_path);
 497         NotifyDeviceStatusUpdate(DEVICE_ADDED, device_path);
 498         break;
 499       }
 500       case CROS_DISKS_DEVICE_REMOVED: {
 501         system_path_prefixes_.erase(device_path);
 502         NotifyDeviceStatusUpdate(DEVICE_REMOVED, device_path);
 503         break;
 504       }
 505       case CROS_DISKS_DEVICE_SCANNED: {
 506         NotifyDeviceStatusUpdate(DEVICE_SCANNED, device_path);
 507         break;
 508       }
 509       case CROS_DISKS_FORMATTING_FINISHED: {
 510         std::string path;
 511         FormatError error_code;
 512         ParseFormatFinishedPath(device_path, &path, &error_code);
 513
 514         if (!path.empty()) {
 515           NotifyFormatStatusUpdate(FORMAT_COMPLETED, error_code, path);
 516           break;
 517         }
 518
 519         LOG(ERROR) << "Error while handling disks metadata. Cannot find "
 520                    << "device that is being formatted.";
 521         break;
 522       }
 523       default: {
 524         LOG(ERROR) << "Unknown event: " << event;
 525       }
 526     }
 527   }
 528
 529   // Notifies all observers about disk status update.
 530   void NotifyDiskStatusUpdate(DiskEvent event,
 531                               const Disk* disk) {
 532     FOR_EACH_OBSERVER(Observer, observers_, OnDiskEvent(event, disk));
 533   }
 534
 535   // Notifies all observers about device status update.
 536   void NotifyDeviceStatusUpdate(DeviceEvent event,
 537                                 const std::string& device_path) {
 538     FOR_EACH_OBSERVER(Observer, observers_, OnDeviceEvent(event, device_path));
 539   }
 540
 541   // Notifies all observers about mount completion.
 542   void NotifyMountStatusUpdate(MountEvent event,
 543                                MountError error_code,
 544                                const MountPointInfo& mount_info) {
 545     FOR_EACH_OBSERVER(Observer, observers_,
 546                       OnMountEvent(event, error_code, mount_info));
 547   }
 548
 549   void NotifyFormatStatusUpdate(FormatEvent event,
 550                                 FormatError error_code,
 551                                 const std::string& device_path) {
 552     FOR_EACH_OBSERVER(Observer, observers_,
 553                       OnFormatEvent(event, error_code, device_path));
 554   }
 555
 556   // Converts file path to device path.
 557   void ParseFormatFinishedPath(const std::string& received_path,
 558                                std::string* device_path,
 559                                FormatError* error_code) {
 560     // TODO(tbarzic): Refactor error handling code like here.
 561     // Appending "!" is not the best way to indicate error.  This kind of trick
 562     // also makes it difficult to simplify the code paths.
 563     bool success = !StartsWithASCII(received_path, "!", true);
 564     *error_code = success ? FORMAT_ERROR_NONE : FORMAT_ERROR_UNKNOWN;
 565
 566     std::string path = received_path.substr(success ? 0 : 1);
 567
 568     // Depending on cros disks implementation the event may return either file
 569     // path or device path. We want to use device path.
 570     for (DiskMountManager::DiskMap::iterator it = disks_.begin();
 571          it != disks_.end(); ++it) {
 572       // Skip the leading '!' on the failure case.
 573       if (it->second->file_path() == path ||
 574           it->second->device_path() == path) {
 575         *device_path = it->second->device_path();
 576         return;
 577       }
 578     }
 579   }
 580
 581   // Finds system path prefix from |system_path|.
 582   const std::string& FindSystemPathPrefix(const std::string& system_path) {
 583     if (system_path.empty())
 584       return EmptyString();
 585     for (SystemPathPrefixSet::const_iterator it = system_path_prefixes_.begin();
 586          it != system_path_prefixes_.end();
 587          ++it) {
 588       const std::string& prefix = *it;
 589       if (StartsWithASCII(system_path, prefix, true))
 590         return prefix;
 591     }
 592     return EmptyString();
 593   }
 594
 595   // Mount event change observers.
 596   ObserverList<Observer> observers_;
 597
 598   CrosDisksClient* cros_disks_client_;
 599
 600   // The list of disks found.
 601   DiskMountManager::DiskMap disks_;
 602
 603   DiskMountManager::MountPointMap mount_points_;
 604
 605   typedef std::set<std::string> SystemPathPrefixSet;
 606   SystemPathPrefixSet system_path_prefixes_;
 607
 608   base::WeakPtrFactory<DiskMountManagerImpl> weak_ptr_factory_;
 609
 610   DISALLOW_COPY_AND_ASSIGN(DiskMountManagerImpl);
 611 };
 612
 613 }  // namespace
 614
 615 DiskMountManager::Disk::Disk(const std::string& device_path,
 616                              const std::string& mount_path,
 617                              const std::string& system_path,
 618                              const std::string& file_path,
 619                              const std::string& device_label,
 620                              const std::string& drive_label,
 621                              const std::string& vendor_id,
 622                              const std::string& vendor_name,
 623                              const std::string& product_id,
 624                              const std::string& product_name,
 625                              const std::string& fs_uuid,
 626                              const std::string& system_path_prefix,
 627                              DeviceType device_type,
 628                              uint64 total_size_in_bytes,
 629                              bool is_parent,
 630                              bool is_read_only,
 631                              bool has_media,
 632                              bool on_boot_device,
 633                              bool is_hidden)
 634     : device_path_(device_path),
 635       mount_path_(mount_path),
 636       system_path_(system_path),
 637       file_path_(file_path),
 638       device_label_(device_label),
 639       drive_label_(drive_label),
 640       vendor_id_(vendor_id),
 641       vendor_name_(vendor_name),
 642       product_id_(product_id),
 643       product_name_(product_name),
 644       fs_uuid_(fs_uuid),
 645       system_path_prefix_(system_path_prefix),
 646       device_type_(device_type),
 647       total_size_in_bytes_(total_size_in_bytes),
 648       is_parent_(is_parent),
 649       is_read_only_(is_read_only),
 650       has_media_(has_media),
 651       on_boot_device_(on_boot_device),
 652       is_hidden_(is_hidden) {
 653 }
 654
 655 DiskMountManager::Disk::~Disk() {}
 656
 657 bool DiskMountManager::AddDiskForTest(Disk* disk) {
 658   return false;
 659 }
 660
 661 bool DiskMountManager::AddMountPointForTest(const MountPointInfo& mount_point) {
 662   return false;
 663 }
 664
 665 // static
 666 std::string DiskMountManager::MountTypeToString(MountType type) {
 667   switch (type) {
 668     case MOUNT_TYPE_DEVICE:
 669       return "device";
 670     case MOUNT_TYPE_ARCHIVE:
 671       return "file";
 672     case MOUNT_TYPE_NETWORK_STORAGE:
 673       return "network";
 674     case MOUNT_TYPE_GOOGLE_DRIVE:
 675       return "drive";
 676     case MOUNT_TYPE_INVALID:
 677       return "invalid";
 678     default:
 679       NOTREACHED();
 680   }
 681   return "";
 682 }
 683
 684 // static
 685 std::string DiskMountManager::MountConditionToString(MountCondition condition) {
 686   switch (condition) {
 687     case MOUNT_CONDITION_NONE:
 688       return "";
 689     case MOUNT_CONDITION_UNKNOWN_FILESYSTEM:
 690       return "unknown_filesystem";
 691     case MOUNT_CONDITION_UNSUPPORTED_FILESYSTEM:
 692       return "unsupported_filesystem";
 693     default:
 694       NOTREACHED();
 695   }
 696   return "";
 697 }
 698
 699 // static
 700 MountType DiskMountManager::MountTypeFromString(const std::string& type_str) {
 701   if (type_str == "device")
 702     return MOUNT_TYPE_DEVICE;
 703   else if (type_str == "network")
 704     return MOUNT_TYPE_NETWORK_STORAGE;
 705   else if (type_str == "file")
 706     return MOUNT_TYPE_ARCHIVE;
 707   else if (type_str == "drive")
 708     return MOUNT_TYPE_GOOGLE_DRIVE;
 709   else
 710     return MOUNT_TYPE_INVALID;
 711 }
 712
 713 // static
 714 std::string DiskMountManager::DeviceTypeToString(DeviceType type) {
 715   switch (type) {
 716     case DEVICE_TYPE_USB:
 717       return "usb";
 718     case DEVICE_TYPE_SD:
 719       return "sd";
 720     case DEVICE_TYPE_OPTICAL_DISC:
 721       return "optical";
 722     case DEVICE_TYPE_MOBILE:
 723       return "mobile";
 724     default:
 725       return "unknown";
 726   }
 727 }
 728
 729 // static
 730 void DiskMountManager::Initialize() {
 731   if (g_disk_mount_manager) {
 732     LOG(WARNING) << "DiskMountManager was already initialized";
 733     return;
 734   }
 735   g_disk_mount_manager = new DiskMountManagerImpl();
 736   VLOG(1) << "DiskMountManager initialized";
 737 }
 738
 739 // static
 740 void DiskMountManager::InitializeForTesting(
 741     DiskMountManager* disk_mount_manager) {
 742   if (g_disk_mount_manager) {
 743     LOG(WARNING) << "DiskMountManager was already initialized";
 744     return;
 745   }
 746   g_disk_mount_manager = disk_mount_manager;
 747   VLOG(1) << "DiskMountManager initialized";
 748 }
 749
 750 // static
 751 void DiskMountManager::Shutdown() {
 752   if (!g_disk_mount_manager) {
 753     LOG(WARNING) << "DiskMountManager::Shutdown() called with NULL manager";
 754     return;
 755   }
 756   delete g_disk_mount_manager;
 757   g_disk_mount_manager = NULL;
 758   VLOG(1) << "DiskMountManager Shutdown completed";
 759 }
 760
 761 // static
 762 DiskMountManager* DiskMountManager::GetInstance() {
 763   return g_disk_mount_manager;
 764 }
 765
 766 }  // namespace disks
 767 }  // namespace chromeos