Disable drive scan on startup to avoid spinning 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/bind_helpers.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;
 
@@ skipping 146 matching lines @@
 }
 
 }  // namespace
 
 namespace chrome {
 
 const int kWorkerPoolNumThreads = 3;
 const char* kWorkerPoolNamePrefix = "DeviceInfoPool";
 
 VolumeMountWatcherWin::VolumeMountWatcherWin()
-    : device_info_worker_pool_(new base::SequencedWorkerPool(
-          kWorkerPoolNumThreads, kWorkerPoolNamePrefix)),
-      weak_factory_(this),
+    : weak_factory_(this),
       notifications_(NULL) {
   get_attached_devices_callback_ = base::Bind(&GetAttachedDevices);
   get_device_details_callback_ = base::Bind(&GetDeviceDetails);
+
+  device_info_worker_pool_ = new base::SequencedWorkerPool(
+      kWorkerPoolNumThreads, kWorkerPoolNamePrefix);
+  task_runner_ =
+      device_info_worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
+          device_info_worker_pool_->GetSequenceToken(),
+          base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 }
 
 // static
 base::FilePath VolumeMountWatcherWin::DriveNumberToFilePath(int drive_number) {
   if (drive_number < 0 || drive_number > 25)
     return base::FilePath();
   string16 path(L"_:\\");
   path[0] = L'A' + drive_number;
   return base::FilePath(path);
 }
 
 // In order to get all the weak pointers created on the UI thread, and doing
 // synchronous Windows calls in the worker pool, this kicks off a chain of
 // events which will
 // a) Enumerate attached devices
 // b) Create weak pointers for which to send completion signals from
 // c) Retrieve metadata on the volumes and then
 // d) Notify that metadata to listeners.
 void VolumeMountWatcherWin::Init() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   // When VolumeMountWatcherWin is created, the message pumps are not running
   // so a posted task from the constructor would never run. Therefore, do all
   // the initializations here.
-  device_info_worker_pool_->PostTask(FROM_HERE, base::Bind(
-      &FindExistingDevicesAndAdd, get_attached_devices_callback_,
-      weak_factory_.GetWeakPtr()));
+  // Disabled pending resolution of http://crbug.com/173953
+  // task_runner_->PostTask(FROM_HERE, base::Bind(
+  //     &FindExistingDevicesAndAdd, get_attached_devices_callback_,
+  //     weak_factory_.GetWeakPtr()));
+
+  // This task is a mystery. Without it, the ToastCrasher test fails, but
+  // it isn't clear why. Need to move pool creation later?
+  task_runner_->PostTask(FROM_HERE, base::Bind(&base::DoNothing));
 }
 
 // static
 void VolumeMountWatcherWin::FindExistingDevicesAndAdd(
     base::Callback<std::vector<base::FilePath>(void)>
         get_attached_devices_callback,
     base::WeakPtr<chrome::VolumeMountWatcherWin> volume_watcher) {
   std::vector<base::FilePath> removable_devices =
       get_attached_devices_callback.Run();
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
       &chrome::VolumeMountWatcherWin::AddDevicesOnUIThread,
       volume_watcher, removable_devices));
 }
 
 void VolumeMountWatcherWin::AddDevicesOnUIThread(
     std::vector<base::FilePath> removable_devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-  scoped_refptr<base::TaskRunner> runner =
-      device_info_worker_pool_->GetTaskRunnerWithShutdownBehavior(
-          base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
   for (size_t i = 0; i < removable_devices.size(); i++) {
     if (ContainsKey(pending_device_checks_, removable_devices[i]))
       continue;
     pending_device_checks_.insert(removable_devices[i]);
-    runner->PostTask(FROM_HERE,
-                     base::Bind(&RetrieveInfoForDeviceAndAdd,
-                                removable_devices[i],
-                                get_device_details_callback_,
-                                weak_factory_.GetWeakPtr()));
+    task_runner_->PostTask(FROM_HERE,
+                           base::Bind(&RetrieveInfoForDeviceAndAdd,
+                                      removable_devices[i],
+                                      get_device_details_callback_,
+                                      weak_factory_.GetWeakPtr()));
   }
 }
 
 // static
 void VolumeMountWatcherWin::RetrieveInfoForDeviceAndAdd(
     const base::FilePath& device_path,
     base::Callback<bool(const base::FilePath&, string16*, std::string*,
                         string16*, bool*, uint64*)> get_device_details_callback,
     base::WeakPtr<chrome::VolumeMountWatcherWin> volume_watcher) {
   string16 device_location;
@@ skipping 147 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