Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

device/generic_sensor/platform_sensor_reader_win.cc

 // Copyright 2016 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.
 
 #include "device/generic_sensor/platform_sensor_reader_win.h"
 
 #include <Sensors.h>
 
 #include "base/callback.h"
 #include "base/memory/ptr_util.h"
@@ skipping 339 matching lines @@
   return base::WrapUnique(
       new PlatformSensorReaderWin(sensor, std::move(params)));
 }
 
 // static
 base::win::ScopedComPtr<ISensor> PlatformSensorReaderWin::GetSensorForType(
     REFSENSOR_TYPE_ID sensor_type,
     base::win::ScopedComPtr<ISensorManager> sensor_manager) {
   base::win::ScopedComPtr<ISensor> sensor;
   base::win::ScopedComPtr<ISensorCollection> sensor_collection;
-  HRESULT hr = sensor_manager->GetSensorsByType(sensor_type,
-                                                sensor_collection.Receive());
+  HRESULT hr = sensor_manager->GetSensorsByType(
+      sensor_type, sensor_collection.GetAddressOf());
   if (FAILED(hr) || !sensor_collection)
     return sensor;
 
   ULONG count = 0;
   hr = sensor_collection->GetCount(&count);
   if (SUCCEEDED(hr) && count > 0)
-    sensor_collection->GetAt(0, sensor.Receive());
+    sensor_collection->GetAt(0, sensor.GetAddressOf());
   return sensor;
 }
 
 PlatformSensorReaderWin::PlatformSensorReaderWin(
     base::win::ScopedComPtr<ISensor> sensor,
     std::unique_ptr<ReaderInitParams> params)
     : init_params_(std::move(params)),
       task_runner_(base::ThreadTaskRunnerHandle::Get()),
       sensor_active_(false),
       client_(nullptr),
@@ skipping 53 matching lines @@
   base::win::ScopedComPtr<IPortableDeviceValues> props;
   if (SUCCEEDED(props.CreateInstance(CLSID_PortableDeviceValues))) {
     unsigned interval =
         (1 / configuration.frequency()) * base::Time::kMillisecondsPerSecond;
 
     HRESULT hr = props->SetUnsignedIntegerValue(
         SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL, interval);
 
     if (SUCCEEDED(hr)) {
       base::win::ScopedComPtr<IPortableDeviceValues> return_props;
-      hr = sensor_->SetProperties(props.Get(), return_props.Receive());
+      hr = sensor_->SetProperties(props.Get(), return_props.GetAddressOf());
       return SUCCEEDED(hr);
     }
   }
   return false;
 }
 
 HRESULT PlatformSensorReaderWin::SensorReadingChanged(
     ISensorDataReport& report,
     SensorReading& reading) const {
   if (!client_)
     return E_FAIL;
 
   HRESULT hr = init_params_->reader_func.Run(report, reading);
   if (SUCCEEDED(hr))
     client_->OnReadingUpdated(reading);
   return hr;
 }
 
 void PlatformSensorReaderWin::SensorError() {
   if (client_)
     client_->OnSensorError();
 }
 
 unsigned long PlatformSensorReaderWin::GetMinimalReportingIntervalMs() const {
   return init_params_->min_reporting_interval_ms;
 }
 
 }  // namespace device