Hotlist Slow: Remove extra thread pool created by VolumeMountWatcherWin.

components/storage_monitor/volume_mount_watcher_win.cc

 // Copyright 2014 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 "components/storage_monitor/volume_mount_watcher_win.h"
 
 #include <windows.h>
 
 #include <dbt.h>
 #include <fileapi.h>
@@ skipping 16 matching lines @@
 #include "content/public/browser/user_metrics.h"
 
 using content::BrowserThread;
 
 namespace storage_monitor {
 
 namespace {
 
 const DWORD kMaxPathBufLen = MAX_PATH + 1;
 
+const char* kDeviceInfoTaskRunnerName = "device-info-task-runner";

[Lei Zhang, 2015/03/03 19:23:50]

const char foo[]

[tommycli, 2015/03/03 19:31:37]

Done.

+
 enum DeviceType {
   FLOPPY,
   REMOVABLE,
   FIXED,
 };
 
 // Histogram values for recording frequencies of eject attempts and
 // outcomes.
 enum EjectWinLockOutcomes {
   LOCK_ATTEMPT,
@@ skipping 270 matching lines @@
         base::Bind(callback, StorageMonitor::EJECT_FAILURE));
     return;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                           base::Bind(callback, StorageMonitor::EJECT_OK));
 }
 
 }  // namespace
 
-const int kWorkerPoolNumThreads = 3;
-const char* kWorkerPoolNamePrefix = "DeviceInfoPool";
-
 VolumeMountWatcherWin::VolumeMountWatcherWin()
-    : device_info_worker_pool_(new base::SequencedWorkerPool(
-          kWorkerPoolNumThreads, kWorkerPoolNamePrefix)),
-      notifications_(NULL),
-      weak_factory_(this) {
-  task_runner_ =
-      device_info_worker_pool_->GetSequencedTaskRunnerWithShutdownBehavior(
-          device_info_worker_pool_->GetSequenceToken(),
-          base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
+    : notifications_(NULL), weak_factory_(this) {
+  base::SequencedWorkerPool* pool = content::BrowserThread::GetBlockingPool();
+  device_info_task_runner_ = pool->GetSequencedTaskRunnerWithShutdownBehavior(
+      pool->GetNamedSequenceToken(kDeviceInfoTaskRunnerName),
+      base::SequencedWorkerPool::CONTINUE_ON_SHUTDOWN);
 }
 
 // static
 base::FilePath VolumeMountWatcherWin::DriveNumberToFilePath(int drive_number) {
   if (drive_number < 0 || drive_number > 25)
     return base::FilePath();
   base::string16 path(L"_:\\");
   path[0] = static_cast<base::char16>('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.
   base::PostTaskAndReplyWithResult(
-      task_runner_.get(), FROM_HERE, GetAttachedDevicesCallback(),
+      device_info_task_runner_.get(), FROM_HERE, GetAttachedDevicesCallback(),
       base::Bind(&VolumeMountWatcherWin::AddDevicesOnUIThread,
                  weak_factory_.GetWeakPtr()));
 }
 
 void VolumeMountWatcherWin::AddDevicesOnUIThread(
     std::vector<base::FilePath> removable_devices) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   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]);
-    task_runner_->PostTask(
+    device_info_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&VolumeMountWatcherWin::RetrieveInfoForDeviceAndAdd,
                    removable_devices[i], GetDeviceDetailsCallback(),
                    weak_factory_.GetWeakPtr()));
   }
 }
 
 // static
 void VolumeMountWatcherWin::RetrieveInfoForDeviceAndAdd(
     const base::FilePath& device_path,
@@ skipping 108 matching lines @@
   }
 }
 
 void VolumeMountWatcherWin::SetNotifications(
     StorageMonitor::Receiver* notifications) {
   notifications_ = notifications;
 }
 
 VolumeMountWatcherWin::~VolumeMountWatcherWin() {
   weak_factory_.InvalidateWeakPtrs();
-  device_info_worker_pool_->Shutdown();
 }
 
 void VolumeMountWatcherWin::HandleDeviceAttachEventOnUIThread(
     const base::FilePath& device_path,
     const StorageInfo& info) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   device_metadata_[device_path] = info;
 
   if (notifications_)
@@ skipping 24 matching lines @@
   base::FilePath device = MediaStorageUtil::FindDevicePathById(device_id);
   if (device.empty()) {
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
   if (device_metadata_.erase(device) == 0) {
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
 
-  task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&EjectDeviceInThreadPool, device, callback, task_runner_, 0));
+  device_info_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&EjectDeviceInThreadPool, device, callback,
+                            device_info_task_runner_, 0));
 }
 
 }  // namespace storage_monitor