Remove unmapped media galleries histograms.

components/storage_monitor/storage_monitor_linux.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.
 
 // StorageMonitorLinux implementation.
 
 #include "components/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <limits>
 #include <list>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/process/kill.h"
 #include "base/process/launch.h"
 #include "base/process/process.h"
 #include "base/stl_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/storage_monitor/media_storage_util.h"
 #include "components/storage_monitor/removable_device_constants.h"
@@ skipping 69 matching lines @@
 };
 
 // Returns the storage partition size of the device specified by |device_path|.
 // If the requested information is unavailable, returns 0.
 uint64_t GetDeviceStorageSize(const base::FilePath& device_path,
                               struct udev_device* device) {
   // sysfs provides the device size in units of 512-byte blocks.
   const std::string partition_size =
       device::UdevDeviceGetSysattrValue(device, kSizeSysAttr);
 
-  // Keep track of device size, to see how often this information is
-  // unavailable.
-  UMA_HISTOGRAM_BOOLEAN(
-      "RemovableDeviceNotificationsLinux.device_partition_size_available",
-      !partition_size.empty());
-
   uint64_t total_size_in_bytes = 0;
   if (!base::StringToUint64(partition_size, &total_size_in_bytes))
     return 0;
   return (total_size_in_bytes <= std::numeric_limits<uint64_t>::max() / 512)
              ? total_size_in_bytes * 512
              : 0;
 }
 
 // Gets the device information using udev library.
 std::unique_ptr<StorageInfo> GetDeviceInfo(const base::FilePath& device_path,
@@ skipping 28 matching lines @@
     return storage_info;
 
   base::string16 volume_label = base::UTF8ToUTF16(
       device::UdevDeviceGetPropertyValue(device.get(), kLabel));
   base::string16 vendor_name = base::UTF8ToUTF16(
       device::UdevDeviceGetPropertyValue(device.get(), kVendor));
   base::string16 model_name = base::UTF8ToUTF16(
       device::UdevDeviceGetPropertyValue(device.get(), kModel));
 
   std::string unique_id = MakeDeviceUniqueId(device.get());
-
-  // Keep track of device info details to see how often we get invalid values.
-  MediaStorageUtil::RecordDeviceInfoHistogram(true, unique_id, volume_label);
-
   const char* value =
       device::udev_device_get_sysattr_value(device.get(), kRemovableSysAttr);
   if (!value) {
     // |parent_device| is owned by |device| and does not need to be cleaned
     // up.
     struct udev_device* parent_device =
         device::udev_device_get_parent_with_subsystem_devtype(
             device.get(),
             kBlockSubsystemKey,
             kDiskDeviceTypeKey);
     value = device::udev_device_get_sysattr_value(parent_device,
                                                   kRemovableSysAttr);
   }
   const bool is_removable = (value && atoi(value) == 1);
 
   StorageInfo::Type type = StorageInfo::FIXED_MASS_STORAGE;
   if (is_removable) {
-    if (MediaStorageUtil::HasDcim(mount_point))
-      type = StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM;
-    else
-      type = StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM;
+    type = MediaStorageUtil::HasDcim(mount_point)
+               ? StorageInfo::REMOVABLE_MASS_STORAGE_WITH_DCIM
+               : StorageInfo::REMOVABLE_MASS_STORAGE_NO_DCIM;
   }
 
   results_recorder.set_result(true);
 
-  storage_info.reset(new StorageInfo(
-      StorageInfo::MakeDeviceId(type, unique_id),
-      mount_point.value(),
-      volume_label,
-      vendor_name,
-      model_name,
-      GetDeviceStorageSize(device_path, device.get())));
+  storage_info = base::MakeUnique<StorageInfo>(
+      StorageInfo::MakeDeviceId(type, unique_id), mount_point.value(),
+      volume_label, vendor_name, model_name,
+      GetDeviceStorageSize(device_path, device.get()));
   return storage_info;
 }
 
 MtabWatcherLinux* CreateMtabWatcherLinuxOnFileThread(
     const base::FilePath& mtab_path,
     base::WeakPtr<MtabWatcherLinux::Delegate> delegate) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   // Owned by caller.
   return new MtabWatcherLinux(mtab_path, delegate);
 }
@@ skipping 265 matching lines @@
   mount_priority_map_[mount_device][mount_point] = removable;
   receiver()->ProcessAttach(*storage_info);
 }
 
 StorageMonitor* StorageMonitor::CreateInternal() {
   const base::FilePath kDefaultMtabPath("/etc/mtab");
   return new StorageMonitorLinux(kDefaultMtabPath);
 }
 
 }  // namespace storage_monitor