Cleanup: Remove ScopedGenericObj usage in chrome/.

chrome/browser/storage_monitor/storage_monitor_linux.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.
 
 // StorageMonitorLinux implementation.
 
 #include "chrome/browser/storage_monitor/storage_monitor_linux.h"
 
 #include <mntent.h>
 #include <stdio.h>
@@ skipping 142 matching lines @@
 
   char device_type;
   if (S_ISCHR(device_stat.st_mode))
     device_type = 'c';
   else if (S_ISBLK(device_stat.st_mode))
     device_type = 'b';
   else
     return storage_info.Pass();  // Not a supported type.
 
   ScopedUdevDeviceObject device(
-      udev_device_new_from_devnum(udev_obj, device_type, device_stat.st_rdev));
+      udev_device_new_from_devnum(udev_obj.get(), device_type,
+                                  device_stat.st_rdev));
   if (!device.get())
     return storage_info.Pass();
 
-  string16 volume_label = UTF8ToUTF16(GetUdevDevicePropertyValue(device,
+  string16 volume_label = UTF8ToUTF16(GetUdevDevicePropertyValue(device.get(),
                                                                  kLabel));
-  string16 vendor_name = UTF8ToUTF16(GetUdevDevicePropertyValue(device,
+  string16 vendor_name = UTF8ToUTF16(GetUdevDevicePropertyValue(device.get(),
                                                                 kVendor));
-  string16 model_name = UTF8ToUTF16(GetUdevDevicePropertyValue(device, kModel));
+  string16 model_name = UTF8ToUTF16(GetUdevDevicePropertyValue(device.get(),
+                                                               kModel));
 
-  std::string unique_id = MakeDeviceUniqueId(device);
+  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 = udev_device_get_sysattr_value(device, kRemovableSysAttr);
+  const char* value =
+      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 =
-        udev_device_get_parent_with_subsystem_devtype(device,
+        udev_device_get_parent_with_subsystem_devtype(device.get(),
                                                       kBlockSubsystemKey,
                                                       kDiskDeviceTypeKey);
     value = 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;
   }
 
   results_recorder.set_result(true);
 
   storage_info.reset(new StorageInfo(
       StorageInfo::MakeDeviceId(type, unique_id),
       string16(),
       mount_point.value(),
       volume_label,
       vendor_name,
       model_name,
-      GetDeviceStorageSize(device_path, device)));
+      GetDeviceStorageSize(device_path, device.get())));
   return storage_info.Pass();
 }
 
 MtabWatcherLinux* CreateMtabWatcherLinuxOnFileThread(
     const base::FilePath& mtab_path,
     base::WeakPtr<MtabWatcherLinux::Delegate> delegate) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   // Owned by caller.
   return new MtabWatcherLinux(mtab_path, delegate);
 }
@@ skipping 287 matching lines @@
   MountPointInfo mount_point_info;
   mount_point_info.mount_device = mount_device;
   mount_point_info.storage_info = *storage_info;
   mount_info_map_[mount_point] = mount_point_info;
   mount_priority_map_[mount_device][mount_point] = removable;
   if (removable)
     receiver()->ProcessAttach(*storage_info);
 }
 
 }  // namespace chrome