Remove more unmapped media galleries histograms.

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 <stddef.h>
 #include <stdint.h>
 
 #include <dbt.h>
 #include <fileapi.h>
 #include <shlobj.h>
 #include <winioctl.h>
 
 #include <algorithm>
 
 #include "base/bind_helpers.h"
-#include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/sys_info.h"
 #include "base/task_runner_util.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "base/time/time.h"
 #include "base/win/scoped_handle.h"
@@ skipping 10 matching lines @@
 const DWORD kMaxPathBufLen = MAX_PATH + 1;
 
 const char kDeviceInfoTaskRunnerName[] = "device-info-task-runner";
 
 enum DeviceType {
   FLOPPY,
   REMOVABLE,
   FIXED,
 };
 
-// Histogram values for recording frequencies of eject attempts and
-// outcomes.
-enum EjectWinLockOutcomes {
-  LOCK_ATTEMPT,
-  LOCK_TIMEOUT,
-  LOCK_TIMEOUT2,
-  NUM_LOCK_OUTCOMES,
-};
-
 // We are trying to figure out whether the drive is a fixed volume,
 // a removable storage, or a floppy. A "floppy" here means "a volume we
 // want to basically ignore because it won't fit media and will spin
 // if we touch it to get volume metadata." GetDriveType returns DRIVE_REMOVABLE
 // on either floppy or removable volumes. The DRIVE_CDROM type is handled
 // as a floppy, as are DRIVE_UNKNOWN and DRIVE_NO_ROOT_DIR, as there are
 // reports that some floppy drives don't report as DRIVE_REMOVABLE.
 DeviceType GetDeviceType(const base::string16& mount_point) {
   UINT drive_type = GetDriveType(mount_point.c_str());
   if (drive_type == DRIVE_FIXED || drive_type == DRIVE_REMOTE ||
@@ skipping 186 matching lines @@
   }
 
   DWORD bytes_returned = 0;  // Unused, but necessary for ioctl's.
 
   // Lock the drive to be ejected (so that other processes can't open
   // files on it). If this fails, it means some other process has files
   // open on the device. Note that the lock is released when the volume
   // handle is closed, and this is done by the ScopedHandle above.
   BOOL locked = DeviceIoControl(volume_handle.Get(), FSCTL_LOCK_VOLUME,
                                 NULL, 0, NULL, 0, &bytes_returned, NULL);
-  UMA_HISTOGRAM_ENUMERATION("StorageMonitor.EjectWinLock",
-                            LOCK_ATTEMPT, NUM_LOCK_OUTCOMES);
   if (!locked) {
-    UMA_HISTOGRAM_ENUMERATION("StorageMonitor.EjectWinLock",
-                              iteration == 0 ? LOCK_TIMEOUT : LOCK_TIMEOUT2,
-                              NUM_LOCK_OUTCOMES);
     const int kNumLockRetries = 1;
     const base::TimeDelta kLockRetryInterval =
         base::TimeDelta::FromMilliseconds(500);
     if (iteration < kNumLockRetries) {
       // Try again -- the lock may have been a transient one. This happens on
       // things like AV disk lock for some reason, or another process
       // transient disk lock.
       task_runner->PostDelayedTask(
           FROM_HERE,
           base::Bind(&EjectDeviceInThreadPool,
@@ skipping 266 matching lines @@
     callback.Run(StorageMonitor::EJECT_FAILURE);
     return;
   }
 
   device_info_task_runner_->PostTask(
       FROM_HERE, base::Bind(&EjectDeviceInThreadPool, device, callback,
                             device_info_task_runner_, 0));
 }
 
 }  // namespace storage_monitor