Don't show hidden devices in UI (exept from imageburner).

chrome/browser/chromeos/cros/mount_library.cc

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/chromeos/cros/mount_library.h"
 
 #include <set>
 #include <sys/statvfs.h>
 #include <vector>
 
@@ skipping 58 matching lines @@
     const std::string& file_path,
     const std::string& device_label,
     const std::string& drive_label,
     const std::string& parent_path,
     const std::string& system_path_prefix,
     DeviceType device_type,
     uint64 total_size,
     bool is_parent,
     bool is_read_only,
     bool has_media,
-    bool on_boot_device)
+    bool on_boot_device,
+    bool is_hidden)
     : device_path_(device_path),
       mount_path_(mount_path),
       system_path_(system_path),
       file_path_(file_path),
       device_label_(device_label),
       drive_label_(drive_label),
       parent_path_(parent_path),
       system_path_prefix_(system_path_prefix),
       device_type_(device_type),
       total_size_(total_size),
       is_parent_(is_parent),
       is_read_only_(is_read_only),
       has_media_(has_media),
-      on_boot_device_(on_boot_device) {
+      on_boot_device_(on_boot_device),
+      is_hidden_(is_hidden) {
 }
 
 MountLibrary::Disk::~Disk() {}
 
 class MountLibcrosProxyImpl : public MountLibcrosProxy {
  public:
   virtual void CallMountPath(const char* source_path,
                              MountType type,
                              const MountPathOptions& options,
                              MountCompletedMonitor callback,
@@ skipping 81 matching lines @@
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(Observer* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
   virtual void MountPath(const char* source_path,
                          MountType type,
                          const MountPathOptions& options) OVERRIDE {
+    // Hidden and non-existent devices should not be mounted.
+    if (type == MOUNT_TYPE_DEVICE) {
+      DiskMap::const_iterator it = disks_.find(source_path);
+      if (it == disks_.end() || it->second->is_hidden()) {
+        MountCompletedHandler(this, MOUNT_ERROR_INTERNAL, source_path, type,
+            NULL);
+        return;
+      }
+    }
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     libcros_proxy_->CallMountPath(source_path, type, options,
                                   &MountCompletedHandler, this);
   }
 
   virtual void UnmountPath(const char* mount_path) OVERRIDE {
     CHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
     libcros_proxy_->CallUnmountPath(mount_path, &UnmountMountPointCallback,
                                     this);
   }
@@ skipping 325 matching lines @@
       FireDeviceStatusUpdate(MOUNT_FORMATTING_STARTED, device_path);
     } else {
       FireDeviceStatusUpdate(MOUNT_FORMATTING_STARTED,
                              std::string("!") + device_path);
       LOG(WARNING) << "Format request failed for device "
                    << device_path << ", with error: "
                    << (error_message ? error_message : "Unknown");
     }
   }
 
-
   void OnGetDiskProperties(const char* device_path,
-                           const DiskInfo* disk1,
+                           const DiskInfo* disk,
                            MountMethodErrorType error,
                            const char* error_message) {
     DCHECK(device_path);
     if (error == MOUNT_METHOD_ERROR_NONE && device_path) {
       // TODO(zelidrag): Find a better way to filter these out before we
       // fetch the properties:
       // Ignore disks coming from the device we booted the system from.
 
       // This cast is temporal solution, until we merge DiskInfo and
       // DiskInfoAdvanced into single interface.
-      const DiskInfoAdvanced* disk =
-          reinterpret_cast<const DiskInfoAdvanced*>(disk1);
       if (disk->on_boot_device())
         return;
 
       LOG(WARNING) << "Found disk " << device_path;
       // Delete previous disk info for this path:
       bool is_new = true;
       std::string device_path_string(device_path);
       DiskMap::iterator iter = disks_.find(device_path_string);
       if (iter != disks_.end()) {
         delete iter->second;
@@ skipping 36 matching lines @@
                                 filepath,
                                 devicelabel,
                                 drivelabel,
                                 parentpath,
                                 FindSystemPathPrefix(systempath),
                                 disk->device_type(),
                                 disk->size(),
                                 disk->is_drive(),
                                 disk->is_read_only(),
                                 disk->has_media(),
-                                disk->on_boot_device());
+                                disk->on_boot_device(),
+                                disk->is_hidden());
       disks_.insert(
           std::pair<std::string, Disk*>(device_path_string, new_disk));
       FireDiskStatusUpdate(is_new ? MOUNT_DISK_ADDED : MOUNT_DISK_CHANGED,
                            new_disk);
     } else {
       LOG(WARNING) << "Property retrieval request failed for device "
                    << device_path << ", with error: "
                    << (error_message ? error_message : "Unknown");
     }
   }
@@ skipping 207 matching lines @@
   MountLibrary* impl;
   if (stub)
     impl = new MountLibraryStubImpl();
   else
     impl = new MountLibraryImpl();
   impl->Init();
   return impl;
 }
 
 }  // namespace chromeos