Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

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 193 matching lines @@
 }
 
 // Constructs a unique identifier for the object specified by the |object_id|.
 // On success, returns true and fills in |unique_id|.
 bool GetObjectUniqueId(IPortableDevice* device,
                        const base::string16& object_id,
                        base::string16* unique_id) {
   DCHECK(device);
   DCHECK(unique_id);
   base::win::ScopedComPtr<IPortableDeviceContent> content;
-  HRESULT hr = device->Content(content.Receive());
+  HRESULT hr = device->Content(content.GetAddressOf());
   if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to get IPortableDeviceContent interface";
     return false;
   }
 
   base::win::ScopedComPtr<IPortableDeviceProperties> properties;
-  hr = content->Properties(properties.Receive());
+  hr = content->Properties(properties.GetAddressOf());
   if (FAILED(hr)) {
     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_values.Receive()))) {
+  if (FAILED(properties->GetValues(object_id.c_str(), properties_to_read.Get(),
+                                   properties_values.GetAddressOf()))) {
     return false;
   }
 
   REFPROPERTYKEY key = GetUniqueIdPropertyKey(object_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,
@@ skipping 10 matching lines @@
 }
 
 // Gets a list of removable storage object identifiers present in |device|.
 // On success, returns true and fills in |storage_object_ids|.
 bool GetRemovableStorageObjectIds(
     IPortableDevice* device,
     PortableDeviceWatcherWin::StorageObjectIDs* storage_object_ids) {
   DCHECK(device);
   DCHECK(storage_object_ids);
   base::win::ScopedComPtr<IPortableDeviceCapabilities> capabilities;
-  HRESULT hr = device->Capabilities(capabilities.Receive());
+  HRESULT hr = device->Capabilities(capabilities.GetAddressOf());
   if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to get IPortableDeviceCapabilities interface";
     return false;
   }
 
   base::win::ScopedComPtr<IPortableDevicePropVariantCollection> storage_ids;
   hr = capabilities->GetFunctionalObjects(WPD_FUNCTIONAL_CATEGORY_STORAGE,
-                                          storage_ids.Receive());
+                                          storage_ids.GetAddressOf());
   if (FAILED(hr)) {
     DPLOG(ERROR) << "Failed to get IPortableDevicePropVariantCollection";
     return false;
   }
 
   DWORD num_storage_obj_ids = 0;
   hr = storage_ids->GetCount(&num_storage_obj_ids);
   if (FAILED(hr))
     return false;
 
@@ skipping 382 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