Remove implicit conversions from scoped_refptr to T* in components/

components/storage_monitor/portable_device_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.
 //
 // Any tasks that communicates with the portable device may take >100ms to
 // complete. Those tasks should be run on an blocking thread instead of the
 // UI thread.
 
 #include "components/storage_monitor/portable_device_watcher_win.h"
 
@@ skipping 405 matching lines @@
     return false;
 
   scoped_ptr<base::char16*[]> pnp_device_ids(
       new base::char16*[pnp_device_count]);
   hr = portable_device_mgr->GetDevices(pnp_device_ids.get(), &pnp_device_count);
   if (FAILED(hr))
     return false;
 
   for (DWORD index = 0; index < pnp_device_count; ++index) {
     PortableDeviceWatcherWin::DeviceDetails device_details;
-    if (GetDeviceInfoOnBlockingThread(
-        portable_device_mgr, pnp_device_ids[index], &device_details))
+    if (GetDeviceInfoOnBlockingThread(portable_device_mgr.get(),
+                                      pnp_device_ids[index], &device_details))
       devices->push_back(device_details);
     CoTaskMemFree(pnp_device_ids[index]);
   }
   return !devices->empty();
 }
 
 // Handles the device attach event message on a media task runner.
 // |pnp_device_id| specifies the attached plug and play device ID string. On
 // success, returns true and populates |device_details| with device information.
 // On failure, returns false.
 bool HandleDeviceAttachedEventOnBlockingThread(
     const base::string16& pnp_device_id,
     PortableDeviceWatcherWin::DeviceDetails* device_details) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(device_details);
   base::win::ScopedComPtr<IPortableDeviceManager> portable_device_mgr;
   if (!GetPortableDeviceManager(&portable_device_mgr))
     return false;
   // Sometimes, portable device manager doesn't have the new device details.
   // Refresh the manager device list to update its details.
   portable_device_mgr->RefreshDeviceList();
-  return GetDeviceInfoOnBlockingThread(portable_device_mgr, pnp_device_id,
+  return GetDeviceInfoOnBlockingThread(portable_device_mgr.get(), pnp_device_id,
                                        device_details);
 }
 
 // Registers |hwnd| to receive portable device notification details. On success,
 // returns the device notifications handle else returns NULL.
 HDEVNOTIFY RegisterPortableDeviceNotification(HWND hwnd) {
   GUID dev_interface_guid = GUID_NULL;
   HRESULT hr = CLSIDFromString(kWPDDevInterfaceGUID, &dev_interface_guid);
   if (FAILED(hr))
     return NULL;
@@ skipping 109 matching lines @@
   HandleDeviceDetachEvent(device_location);
 
   callback.Run(StorageMonitor::EJECT_OK);
 }
 
 void PortableDeviceWatcherWin::EnumerateAttachedDevices() {
   DCHECK(media_task_runner_.get());
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   Devices* devices = new Devices;
   base::PostTaskAndReplyWithResult(
-      media_task_runner_,
-      FROM_HERE,
+      media_task_runner_.get(), FROM_HERE,
       base::Bind(&EnumerateAttachedDevicesOnBlockingThread, devices),
       base::Bind(&PortableDeviceWatcherWin::OnDidEnumerateAttachedDevices,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(devices)));
 }
 
 void PortableDeviceWatcherWin::OnDidEnumerateAttachedDevices(
     const Devices* devices, const bool result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(devices);
   if (!result)
     return;
   for (Devices::const_iterator device_iter = devices->begin();
        device_iter != devices->end(); ++device_iter) {
     OnDidHandleDeviceAttachEvent(&(*device_iter), result);
   }
 }
 
 void PortableDeviceWatcherWin::HandleDeviceAttachEvent(
     const base::string16& pnp_device_id) {
   DCHECK(media_task_runner_.get());
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DeviceDetails* device_details = new DeviceDetails;
   base::PostTaskAndReplyWithResult(
-      media_task_runner_,
-      FROM_HERE,
+      media_task_runner_.get(), FROM_HERE,
       base::Bind(&HandleDeviceAttachedEventOnBlockingThread, pnp_device_id,
                  device_details),
       base::Bind(&PortableDeviceWatcherWin::OnDidHandleDeviceAttachEvent,
                  weak_ptr_factory_.GetWeakPtr(), base::Owned(device_details)));
 }
 
 void PortableDeviceWatcherWin::OnDidHandleDeviceAttachEvent(
     const DeviceDetails* device_details, const bool result) {
   DCHECK(content::BrowserThread::CurrentlyOn(content::BrowserThread::UI));
   DCHECK(device_details);
@@ skipping 47 matching lines @@
     if (storage_notifications_) {
       storage_notifications_->ProcessDetach(
           storage_map_iter->second.device_id());
     }
     storage_map_.erase(storage_map_iter);
   }
   device_map_.erase(device_iter);
 }
 
 }  // namespace storage_monitor