Rename ScopedComPtr::Receive to ScopedComPtr::GetAddressOf

device/sensors/data_fetcher_shared_memory_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.
 
 #include "device/sensors/data_fetcher_shared_memory.h"
 
 #include <GuidDef.h>
 #include <InitGuid.h>
 #include <PortableDeviceTypes.h>
 #include <Sensors.h>
@@ skipping 216 matching lines @@
 
 bool DataFetcherSharedMemory::Start(ConsumerType consumer_type, void* buffer) {
   DCHECK(buffer);
 
   switch (consumer_type) {
     case CONSUMER_TYPE_ORIENTATION: {
       orientation_buffer_ =
           static_cast<DeviceOrientationHardwareBuffer*>(buffer);
       scoped_refptr<SensorEventSink> sink(
           new SensorEventSinkOrientation(orientation_buffer_));
-      bool inclinometer_available = RegisterForSensor(
-          SENSOR_TYPE_INCLINOMETER_3D, sensor_inclinometer_.Receive(), sink);
+      bool inclinometer_available =
+          RegisterForSensor(SENSOR_TYPE_INCLINOMETER_3D,
+                            sensor_inclinometer_.GetAddressOf(), sink);
       UMA_HISTOGRAM_BOOLEAN("InertialSensor.InclinometerWindowsAvailable",
                             inclinometer_available);
       if (inclinometer_available)
         return true;
       // if no sensors are available set buffer to ready, to fire null-events.
       SetBufferAvailableState(consumer_type, true);
     } break;
     case CONSUMER_TYPE_ORIENTATION_ABSOLUTE: {
       orientation_absolute_buffer_ =
           static_cast<DeviceOrientationHardwareBuffer*>(buffer);
       scoped_refptr<SensorEventSink> sink(
           new SensorEventSinkOrientation(orientation_absolute_buffer_));
       // Currently we use the same sensor as for orientation which provides
       // absolute angles.
       bool inclinometer_available =
           RegisterForSensor(SENSOR_TYPE_INCLINOMETER_3D,
-                            sensor_inclinometer_absolute_.Receive(), sink);
+                            sensor_inclinometer_absolute_.GetAddressOf(), sink);
       // TODO(timvolodine): consider adding UMA.
       if (inclinometer_available)
         return true;
       // if no sensors are available set buffer to ready, to fire null-events.
       SetBufferAvailableState(consumer_type, true);
     } break;
     case CONSUMER_TYPE_MOTION: {
       motion_buffer_ = static_cast<DeviceMotionHardwareBuffer*>(buffer);
       scoped_refptr<SensorEventSink> sink(
           new SensorEventSinkMotion(motion_buffer_));
-      bool accelerometer_available = RegisterForSensor(
-          SENSOR_TYPE_ACCELEROMETER_3D, sensor_accelerometer_.Receive(), sink);
+      bool accelerometer_available =
+          RegisterForSensor(SENSOR_TYPE_ACCELEROMETER_3D,
+                            sensor_accelerometer_.GetAddressOf(), sink);
       bool gyrometer_available = RegisterForSensor(
-          SENSOR_TYPE_GYROMETER_3D, sensor_gyrometer_.Receive(), sink);
+          SENSOR_TYPE_GYROMETER_3D, sensor_gyrometer_.GetAddressOf(), sink);
       UMA_HISTOGRAM_BOOLEAN("InertialSensor.AccelerometerWindowsAvailable",
                             accelerometer_available);
       UMA_HISTOGRAM_BOOLEAN("InertialSensor.GyrometerWindowsAvailable",
                             gyrometer_available);
       if (accelerometer_available || gyrometer_available) {
         motion_buffer_->seqlock.WriteBegin();
         motion_buffer_->data.interval = GetInterval().InMilliseconds();
         motion_buffer_->seqlock.WriteEnd();
         return true;
       }
@@ skipping 34 matching lines @@
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     return false;
 
   base::win::ScopedComPtr<ISensorManager> sensor_manager;
   HRESULT hr = sensor_manager.CreateInstance(CLSID_SensorManager);
   if (FAILED(hr) || !sensor_manager.Get())
     return false;
 
   base::win::ScopedComPtr<ISensorCollection> sensor_collection;
   hr = sensor_manager->GetSensorsByType(sensor_type,
-                                        sensor_collection.Receive());
+                                        sensor_collection.GetAddressOf());
 
   if (FAILED(hr) || !sensor_collection.Get())
     return false;
 
   ULONG count = 0;
   hr = sensor_collection->GetCount(&count);
   if (FAILED(hr) || !count)
     return false;
 
   hr = sensor_collection->GetAt(0, sensor);
   if (FAILED(hr) || !(*sensor))
     return false;
 
   base::win::ScopedComPtr<IPortableDeviceValues> device_values;
   if (SUCCEEDED(device_values.CreateInstance(CLSID_PortableDeviceValues))) {
     if (SUCCEEDED(device_values->SetUnsignedIntegerValue(
             SENSOR_PROPERTY_CURRENT_REPORT_INTERVAL,
             GetInterval().InMilliseconds()))) {
       base::win::ScopedComPtr<IPortableDeviceValues> return_values;
-      (*sensor)->SetProperties(device_values.Get(), return_values.Receive());
+      (*sensor)->SetProperties(device_values.Get(),
+                               return_values.GetAddressOf());
     }
   }
 
   base::win::ScopedComPtr<ISensorEvents> sensor_events;
   hr = event_sink->QueryInterface(IID_PPV_ARGS(&sensor_events));
   if (FAILED(hr) || !sensor_events.Get())
     return false;
 
   hr = (*sensor)->SetEventSink(sensor_events.Get());
   if (FAILED(hr))
@@ skipping 56 matching lines @@
         motion_buffer_->data.all_available_sensors_are_active = enabled;
         motion_buffer_->seqlock.WriteEnd();
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace device