Rename ScopedComPtr::get() to ScopedComPtr::Get()

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 140 matching lines @@
   if (!GetClientInformation(&client_info))
     return false;
 
   HRESULT hr = device->CreateInstance(__uuidof(PortableDevice), NULL,
                                       CLSCTX_INPROC_SERVER);
   if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to create an instance of IPortableDevice";
     return false;
   }
 
-  hr = (*device)->Open(pnp_device_id.c_str(), client_info.get());
+  hr = (*device)->Open(pnp_device_id.c_str(), client_info.Get());
   if (SUCCEEDED(hr))
     return true;
 
   if (hr == E_ACCESSDENIED)
     DPLOG(ERROR) << "Access denied to open the device";
   return false;
 }
 
 // Returns the unique id property key of the object specified by the
 // |object_id|.
@@ skipping 52 matching lines @@
     DPLOG(ERROR) << "Failed to get IPortableDeviceProperties interface";
     return false;
   }
 
   base::win::ScopedComPtr<IPortableDeviceKeyCollection> properties_to_read;
   if (!PopulatePropertyKeyCollection(object_id, &properties_to_read))
     return false;
 
   base::win::ScopedComPtr<IPortableDeviceValues> properties_values;
   if (FAILED(properties->GetValues(object_id.c_str(),
-                                   properties_to_read.get(),
+                                   properties_to_read.Get(),
                                    properties_values.Receive()))) {
     return false;
   }
 
   REFPROPERTYKEY key = GetUniqueIdPropertyKey(object_id);
-  return GetStringPropertyValue(properties_values.get(), key, unique_id);
+  return GetStringPropertyValue(properties_values.Get(), key, unique_id);
 }
 
 // Constructs the device storage unique identifier using |device_serial_num| and
 // |storage_id|. On success, returns true and fills in |device_storage_id|.
 bool ConstructDeviceStorageUniqueId(const base::string16& device_serial_num,
                                     const base::string16& storage_id,
                                     std::string* device_storage_id) {
   if (device_serial_num.empty() && storage_id.empty())
     return false;
 
@@ skipping 78 matching lines @@
 bool GetDeviceStorageObjectsOnBlockingThread(
     const base::string16& pnp_device_id,
     PortableDeviceWatcherWin::StorageObjects* storage_objects) {
   DCHECK(content::BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
   DCHECK(storage_objects);
   base::win::ScopedComPtr<IPortableDevice> device;
   if (!SetUp(pnp_device_id, &device))
     return false;
 
   base::string16 device_serial_num;
-  if (!GetObjectUniqueId(device.get(), WPD_DEVICE_OBJECT_ID,
+  if (!GetObjectUniqueId(device.Get(), WPD_DEVICE_OBJECT_ID,
                          &device_serial_num)) {
     return false;
   }
 
   PortableDeviceWatcherWin::StorageObjectIDs storage_obj_ids;
-  if (!GetRemovableStorageObjectIds(device.get(), &storage_obj_ids))
+  if (!GetRemovableStorageObjectIds(device.Get(), &storage_obj_ids))
     return false;
   for (PortableDeviceWatcherWin::StorageObjectIDs::const_iterator id_iter =
        storage_obj_ids.begin(); id_iter != storage_obj_ids.end(); ++id_iter) {
     base::string16 storage_persistent_id;
-    if (!GetObjectUniqueId(device.get(), *id_iter, &storage_persistent_id))
+    if (!GetObjectUniqueId(device.Get(), *id_iter, &storage_persistent_id))
       continue;
 
     std::string device_storage_id;
     if (ConstructDeviceStorageUniqueId(device_serial_num, storage_persistent_id,
                                        &device_storage_id)) {
       storage_objects->push_back(PortableDeviceWatcherWin::DeviceStorageObject(
           *id_iter, device_storage_id));
     }
   }
   return true;
@@ skipping 55 matching lines @@
     return false;
 
   std::unique_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.get(),
+    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.get(), 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 210 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