Eliminate getting disk metadata for floppy drives.

chrome/browser/storage_monitor/volume_mount_watcher_win.cc

 // 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 "chrome/browser/storage_monitor/volume_mount_watcher_win.h"
 
 #include <windows.h>
 #include <dbt.h>
 #include <fileapi.h>
 
 #include "base/stl_util.h"
 #include "base/string_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/storage_monitor/media_device_notifications_utils.h"
 #include "chrome/browser/storage_monitor/media_storage_util.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
 
 namespace {
 
 const DWORD kMaxPathBufLen = MAX_PATH + 1;
 
-bool IsRemovable(const string16& mount_point) {
+enum DeviceType {
+  FLOPPY,
+  REMOVABLE,
+  FIXED

[vandebo (ex-Chrome), 2013/03/06 01:49:08]

nit: add , at end so that future additions don't have to change this line.

[Greg Billock, 2013/03/06 18:33:24]

Done.

+};
+
+DeviceType GetDeviceType(const string16& mount_point) {
   if (GetDriveType(mount_point.c_str()) != DRIVE_REMOVABLE)
-    return false;
+    return FIXED;
 
   // We don't consider floppy disks as removable, so check for that.
   string16 device = mount_point;
   if (EndsWith(mount_point, L"\\", false))
     device = mount_point.substr(0, device.length() - 1);
   string16 device_path;
   if (!QueryDosDevice(device.c_str(), WriteInto(&device_path, kMaxPathBufLen),
                       kMaxPathBufLen))
-    return true;
-  return device_path.find(L"Floppy") == string16::npos;
+    return REMOVABLE;
+  return device_path.find(L"Floppy") == string16::npos ? REMOVABLE : FLOPPY;
 }
 
 // Returns 0 if the devicetype is not volume.
 uint32 GetVolumeBitMaskFromBroadcastHeader(LPARAM data) {
   DEV_BROADCAST_VOLUME* dev_broadcast_volume =
       reinterpret_cast<DEV_BROADCAST_VOLUME*>(data);
   if (dev_broadcast_volume->dbcv_devicetype == DBT_DEVTYP_VOLUME)
     return dev_broadcast_volume->dbcv_unitmask;
   return 0;
 }
@@ skipping 26 matching lines @@
                       string16* name,
                       bool* removable,
                       uint64* volume_size) {
   string16 mount_point;
   if (!GetVolumePathName(device_path.value().c_str(),
                          WriteInto(&mount_point, kMaxPathBufLen),
                          kMaxPathBufLen)) {
     return false;
   }
 
+  DeviceType device_type = GetDeviceType(mount_point);
   if (removable)
-    *removable = IsRemovable(mount_point);
+    *removable = (device_type == REMOVABLE);
 
   if (device_location)
     *device_location = mount_point;
 
+  // If we're adding a floppy drive, return without querying any more
+  // drive metadata -- it will cause the floppy drive to seek.
+  if (device_type == FLOPPY)
+    return true;
+
   if (volume_size)
     *volume_size = GetVolumeSize(mount_point);
 
   if (unique_id) {
     string16 guid;
     if (!GetVolumeNameForVolumeMountPoint(mount_point.c_str(),
                                           WriteInto(&guid, kMaxPathBufLen),
                                           kMaxPathBufLen)) {
       return false;
     }
@@ skipping 33 matching lines @@
                                        kMaxPathBufLen);
   if (find_handle == INVALID_HANDLE_VALUE)
     return result;
 
   while (true) {
     string16 volume_path;
     DWORD return_count;
     if (GetVolumePathNamesForVolumeName(volume_name.c_str(),
                                         WriteInto(&volume_path, kMaxPathBufLen),
                                         kMaxPathBufLen, &return_count)) {
-      if (IsRemovable(volume_path))
+      if (GetDeviceType(volume_path) == REMOVABLE)

[vandebo (ex-Chrome), 2013/03/06 01:49:08]

Actually I'm not sure we want this at all.  If we expect all devices to be in
cache, then we should query all existing devices on startup.

[Greg Billock, 2013/03/06 18:33:24]

That makes sense. Let's get rid of it. Although will we end up hanging on remote
network drives or anything like that then? Perhaps we should do that separately
to make sure we're ok. But more to the point, shouldn't this have resulted in no
floppy seeks before? I thought I had figured out that we ended up getting
metadata for all volumes, but this looks like it should skip floppies on
startup. Do you think there's a hole in our floppy detection logic? It looks a
bit ad hoc.

Also, should we treat CDROM device type the same way? It's a separate code, and
we don't want to spin the CDROM.

         result.push_back(base::FilePath(volume_path));
     } else {
       DPLOG(ERROR);
     }
     if (!FindNextVolume(find_handle, WriteInto(&volume_name, kMaxPathBufLen),
                         kMaxPathBufLen)) {
       if (GetLastError() != ERROR_NO_MORE_FILES)
         DPLOG(ERROR);
       break;
     }
@@ skipping 235 matching lines @@
   // If the device isn't type removable (like a CD), it won't be there.
   if (device_info == device_metadata_.end())
     return;
 
   if (notifications_)
     notifications_->ProcessDetach(device_info->second.device_id);
   device_metadata_.erase(device_info);
 }
 
 }  // namespace chrome