Remove mutable reference argument for //device/generic_sensor/platform_sensor_reader_win.*

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"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/win/iunknown_impl.h"
 #include "base/win/scoped_propvariant.h"
 #include "device/generic_sensor/generic_sensor_consts.h"
 #include "device/generic_sensor/public/cpp/platform_sensor_configuration.h"
 #include "device/generic_sensor/public/cpp/sensor_reading.h"
 
 namespace device {
 
 // Init params for the PlatformSensorReaderWin.
 struct ReaderInitParams {
   // ISensorDataReport::GetSensorValue is not const, therefore, report
   // cannot be passed as const ref.
-  // ISensorDataReport& report - report that contains new sensor data.
-  // SensorReading& reading    - out parameter that must be populated.
+  // ISensorDataReport* report - report that contains new sensor data.
+  // SensorReading* reading    - out parameter that must be populated.
   // Returns HRESULT           - S_OK on success, otherwise error code.
-  using ReaderFunctor = base::Callback<HRESULT(ISensorDataReport& report,
-                                               SensorReading& reading)>;
+  using ReaderFunctor = base::Callback<HRESULT(ISensorDataReport* report,
+                                               SensorReading* reading)>;
   SENSOR_TYPE_ID sensor_type_id;
   ReaderFunctor reader_func;
   unsigned long min_reporting_interval_ms = 0;
 };
 
 namespace {
 
 // Gets value from  the report for provided key.
 bool GetReadingValueForProperty(REFPROPERTYKEY key,
-                                ISensorDataReport& report,
+                                ISensorDataReport* report,
                                 double* value) {
   DCHECK(value);
   base::win::ScopedPropVariant variant_value;
-  if (SUCCEEDED(report.GetSensorValue(key, variant_value.Receive()))) {
+  if (SUCCEEDED(report->GetSensorValue(key, variant_value.Receive()))) {
     if (variant_value.get().vt == VT_R8)
       *value = variant_value.get().dblVal;
     else if (variant_value.get().vt == VT_R4)
       *value = variant_value.get().fltVal;
     else
       return false;
     return true;
   }
 
   *value = 0;
   return false;
 }
 
 // Ambient light sensor reader initialization parameters.
 std::unique_ptr<ReaderInitParams> CreateAmbientLightReaderInitParams() {
   auto params = base::MakeUnique<ReaderInitParams>();
   params->sensor_type_id = SENSOR_TYPE_AMBIENT_LIGHT;
   params->reader_func =
-      base::Bind([](ISensorDataReport& report, SensorReading& reading) {
+      base::Bind([](ISensorDataReport* report, SensorReading* reading) {
         double lux = 0.0;
         if (!GetReadingValueForProperty(SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX,
                                         report, &lux)) {
           return E_FAIL;
         }
-        reading.values[0] = lux;
+        reading->values[0] = lux;
         return S_OK;
       });
   return params;
 }
 
 // Accelerometer sensor reader initialization parameters.
 std::unique_ptr<ReaderInitParams> CreateAccelerometerReaderInitParams() {
   auto params = base::MakeUnique<ReaderInitParams>();
   params->sensor_type_id = SENSOR_TYPE_ACCELEROMETER_3D;
   params->reader_func =
-      base::Bind([](ISensorDataReport& report, SensorReading& reading) {
+      base::Bind([](ISensorDataReport* report, SensorReading* reading) {
         double x = 0.0;
         double y = 0.0;
         double z = 0.0;
         if (!GetReadingValueForProperty(SENSOR_DATA_TYPE_ACCELERATION_X_G,
                                         report, &x) ||
             !GetReadingValueForProperty(SENSOR_DATA_TYPE_ACCELERATION_Y_G,
                                         report, &y) ||
             !GetReadingValueForProperty(SENSOR_DATA_TYPE_ACCELERATION_Z_G,
                                         report, &z)) {
           return E_FAIL;
         }
 
         // Windows uses coordinate system where Z axis points down from device
         // screen, therefore, using right hand notation, we have to reverse
         // sign for each axis. Values are converted from G/s^2 to m/s^2.
-        reading.values[0] = -x * kMeanGravity;
-        reading.values[1] = -y * kMeanGravity;
-        reading.values[2] = -z * kMeanGravity;
+        reading->values[0] = -x * kMeanGravity;
+        reading->values[1] = -y * kMeanGravity;
+        reading->values[2] = -z * kMeanGravity;
         return S_OK;
       });
   return params;
 }
 
 // Gyroscope sensor reader initialization parameters.
 std::unique_ptr<ReaderInitParams> CreateGyroscopeReaderInitParams() {
   auto params = base::MakeUnique<ReaderInitParams>();
   params->sensor_type_id = SENSOR_TYPE_GYROMETER_3D;
-  params->reader_func = base::Bind([](ISensorDataReport& report,
-                                      SensorReading& reading) {
+  params->reader_func = base::Bind([](ISensorDataReport* report,
+                                      SensorReading* reading) {
     double x = 0.0;
     double y = 0.0;
     double z = 0.0;
     if (!GetReadingValueForProperty(
             SENSOR_DATA_TYPE_ANGULAR_VELOCITY_X_DEGREES_PER_SECOND, report,
             &x) ||
         !GetReadingValueForProperty(
             SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Y_DEGREES_PER_SECOND, report,
             &y) ||
         !GetReadingValueForProperty(
             SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Z_DEGREES_PER_SECOND, report,
             &z)) {
       return E_FAIL;
     }
 
     // Windows uses coordinate system where Z axis points down from device
     // screen, therefore, using right hand notation, we have to reverse
     // sign for each axis. Values are converted from deg to rad.
-    reading.values[0] = -x * kRadiansInDegrees;
-    reading.values[1] = -y * kRadiansInDegrees;
-    reading.values[2] = -z * kRadiansInDegrees;
+    reading->values[0] = -x * kRadiansInDegrees;
+    reading->values[1] = -y * kRadiansInDegrees;
+    reading->values[2] = -z * kRadiansInDegrees;
     return S_OK;
   });
   return params;
 }
 
 // Magnetometer sensor reader initialization parameters.
 std::unique_ptr<ReaderInitParams> CreateMagnetometerReaderInitParams() {
   auto params = base::MakeUnique<ReaderInitParams>();
   params->sensor_type_id = SENSOR_TYPE_COMPASS_3D;
   params->reader_func =
-      base::Bind([](ISensorDataReport& report, SensorReading& reading) {
+      base::Bind([](ISensorDataReport* report, SensorReading* reading) {
         double x = 0.0;
         double y = 0.0;
         double z = 0.0;
         if (!GetReadingValueForProperty(
                 SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_X_MILLIGAUSS, report,
                 &x) ||
             !GetReadingValueForProperty(
                 SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_Y_MILLIGAUSS, report,
                 &y) ||
             !GetReadingValueForProperty(
                 SENSOR_DATA_TYPE_MAGNETIC_FIELD_STRENGTH_Z_MILLIGAUSS, report,
                 &z)) {
           return E_FAIL;
         }
 
         // Windows uses coordinate system where Z axis points down from device
         // screen, therefore, using right hand notation, we have to reverse
         // sign for each axis. Values are converted from Milligaus to
         // Microtesla.
-        reading.values[0] = -x * kMicroteslaInMilligauss;
-        reading.values[1] = -y * kMicroteslaInMilligauss;
-        reading.values[2] = -z * kMicroteslaInMilligauss;
+        reading->values[0] = -x * kMicroteslaInMilligauss;
+        reading->values[1] = -y * kMicroteslaInMilligauss;
+        reading->values[2] = -z * kMicroteslaInMilligauss;
         return S_OK;
       });
   return params;
 }
 
 // AbsoluteOrientation sensor reader initialization parameters.
 std::unique_ptr<ReaderInitParams> CreateAbsoluteOrientationReaderInitParams() {
   auto params = base::MakeUnique<ReaderInitParams>();
   params->sensor_type_id = SENSOR_TYPE_AGGREGATED_DEVICE_ORIENTATION;
   params->reader_func =
-      base::Bind([](ISensorDataReport& report, SensorReading& reading) {
+      base::Bind([](ISensorDataReport* report, SensorReading* reading) {
         base::win::ScopedPropVariant quat_variant;
-        HRESULT hr = report.GetSensorValue(SENSOR_DATA_TYPE_QUATERNION,
-                                           quat_variant.Receive());
+        HRESULT hr = report->GetSensorValue(SENSOR_DATA_TYPE_QUATERNION,
+                                            quat_variant.Receive());
         if (FAILED(hr) || quat_variant.get().vt != (VT_VECTOR | VT_UI1) ||
             quat_variant.get().caub.cElems < 16) {
           return E_FAIL;
         }
 
         float* quat = reinterpret_cast<float*>(quat_variant.get().caub.pElems);
 
         // Windows uses coordinate system where Z axis points down from device
         // screen, therefore, using right hand notation, we have to reverse
         // sign for each quaternion component.
-        reading.values[0] = -quat[0];  // x*sin(Theta/2)
-        reading.values[1] = -quat[1];  // y*sin(Theta/2)
-        reading.values[2] = -quat[2];  // z*sin(Theta/2)
-        reading.values[3] = quat[3];   // cos(Theta/2)
+        reading->values[0] = -quat[0];  // x*sin(Theta/2)
+        reading->values[1] = -quat[1];  // y*sin(Theta/2)
+        reading->values[2] = -quat[2];  // z*sin(Theta/2)
+        reading->values[3] = quat[3];   // cos(Theta/2)
         return S_OK;
       });
   return params;
 }
 
 // Creates ReaderInitParams params structure. To implement support for new
 // sensor types, new switch case should be added and appropriate fields must
 // be set:
 // sensor_type_id - GUID of the sensor supported by Windows.
 // reader_func    - Functor that is responsible to populate SensorReading from
@@ skipping 101 matching lines @@
 
     base::TimeDelta delta = time_now - timestamp;
 
     SensorReading reading;
     reading.timestamp = ((ticks_now - delta) - base::TimeTicks()).InSecondsF();
 
     // Discard update events that have non-monotonically increasing timestamp.
     if (last_sensor_reading_.timestamp > reading.timestamp)
       return E_FAIL;
 
-    hr = platform_sensor_reader_->SensorReadingChanged(*report, reading);
+    hr = platform_sensor_reader_->SensorReadingChanged(report, &reading);
     if (SUCCEEDED(hr))
       last_sensor_reading_ = reading;
     return hr;
   }
 
  private:
   PlatformSensorReaderWin* const platform_sensor_reader_;
   SensorReading last_sensor_reading_;
 
   DISALLOW_COPY_AND_ASSIGN(EventListener);
@@ skipping 117 matching lines @@
     if (SUCCEEDED(hr)) {
       base::win::ScopedComPtr<IPortableDeviceValues> return_props;
       hr = sensor_->SetProperties(props.Get(), return_props.GetAddressOf());
       return SUCCEEDED(hr);
     }
   }
   return false;
 }
 
 HRESULT PlatformSensorReaderWin::SensorReadingChanged(
-    ISensorDataReport& report,
-    SensorReading& reading) const {
+    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);
+    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