Convert device sensors structs from Blink to Chromium naming

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 101 matching lines @@
 
     GetSensorValue(SENSOR_DATA_TYPE_TILT_X_DEGREES, new_data, &beta, &has_beta);
     GetSensorValue(SENSOR_DATA_TYPE_TILT_Y_DEGREES, new_data, &gamma,
                    &has_gamma);
     GetSensorValue(SENSOR_DATA_TYPE_TILT_Z_DEGREES, new_data, &alpha,
                    &has_alpha);
 
     if (buffer_) {
       buffer_->seqlock.WriteBegin();
       buffer_->data.alpha = alpha;
-      buffer_->data.hasAlpha = has_alpha;
+      buffer_->data.has_alpha = has_alpha;
       buffer_->data.beta = beta;
-      buffer_->data.hasBeta = has_beta;
+      buffer_->data.has_beta = has_beta;
       buffer_->data.gamma = gamma;
-      buffer_->data.hasGamma = has_gamma;
+      buffer_->data.has_gamma = has_gamma;
       buffer_->data.absolute = has_alpha || has_beta || has_gamma;
-      buffer_->data.allAvailableSensorsAreActive = true;
+      buffer_->data.all_available_sensors_are_active = true;
       buffer_->seqlock.WriteEnd();
     }
 
     return true;
   }
 
  private:
   DeviceOrientationHardwareBuffer* const buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(SensorEventSinkOrientation);
@@ skipping 26 matching lines @@
                      &has_acceleration_including_gravity_x);
       GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Y_G, new_data,
                      &acceleration_including_gravity_y,
                      &has_acceleration_including_gravity_y);
       GetSensorValue(SENSOR_DATA_TYPE_ACCELERATION_Z_G, new_data,
                      &acceleration_including_gravity_z,
                      &has_acceleration_including_gravity_z);
 
       if (buffer_) {
         buffer_->seqlock.WriteBegin();
-        buffer_->data.accelerationIncludingGravityX =
+        buffer_->data.acceleration_including_gravity_x =
             -acceleration_including_gravity_x * kMeanGravity;
-        buffer_->data.hasAccelerationIncludingGravityX =
+        buffer_->data.has_acceleration_including_gravity_x =
             has_acceleration_including_gravity_x;
-        buffer_->data.accelerationIncludingGravityY =
+        buffer_->data.acceleration_including_gravity_y =
             -acceleration_including_gravity_y * kMeanGravity;
-        buffer_->data.hasAccelerationIncludingGravityY =
+        buffer_->data.has_acceleration_including_gravity_y =
             has_acceleration_including_gravity_y;
-        buffer_->data.accelerationIncludingGravityZ =
+        buffer_->data.acceleration_including_gravity_z =
             -acceleration_including_gravity_z * kMeanGravity;
-        buffer_->data.hasAccelerationIncludingGravityZ =
+        buffer_->data.has_acceleration_including_gravity_z =
             has_acceleration_including_gravity_z;
         // TODO(timvolodine): consider setting this after all
         // sensors have fired.
-        buffer_->data.allAvailableSensorsAreActive = true;
+        buffer_->data.all_available_sensors_are_active = true;
         buffer_->seqlock.WriteEnd();
       }
 
     } else if (IsEqualIID(sensor_type, SENSOR_TYPE_GYROMETER_3D)) {
       double alpha, beta, gamma;
       bool has_alpha, has_beta, has_gamma;
 
       GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_X_DEGREES_PER_SECOND,
                      new_data, &alpha, &has_alpha);
       GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Y_DEGREES_PER_SECOND,
                      new_data, &beta, &has_beta);
       GetSensorValue(SENSOR_DATA_TYPE_ANGULAR_VELOCITY_Z_DEGREES_PER_SECOND,
                      new_data, &gamma, &has_gamma);
 
       if (buffer_) {
         buffer_->seqlock.WriteBegin();
-        buffer_->data.rotationRateAlpha = alpha;
-        buffer_->data.hasRotationRateAlpha = has_alpha;
-        buffer_->data.rotationRateBeta = beta;
-        buffer_->data.hasRotationRateBeta = has_beta;
-        buffer_->data.rotationRateGamma = gamma;
-        buffer_->data.hasRotationRateGamma = has_gamma;
-        buffer_->data.allAvailableSensorsAreActive = true;
+        buffer_->data.rotation_rate_alpha = alpha;
+        buffer_->data.has_rotation_rate_alpha = has_alpha;
+        buffer_->data.rotation_rate_beta = beta;
+        buffer_->data.has_rotation_rate_beta = has_beta;
+        buffer_->data.rotation_rate_gamma = gamma;
+        buffer_->data.has_rotation_rate_gamma = has_gamma;
+        buffer_->data.all_available_sensors_are_active = true;
         buffer_->seqlock.WriteEnd();
       }
     }
 
     return true;
   }
 
  private:
   DeviceMotionHardwareBuffer* const buffer_;
 
@@ skipping 225 matching lines @@
   }
 }
 
 void DataFetcherSharedMemory::SetBufferAvailableState(
     ConsumerType consumer_type,
     bool enabled) {
   switch (consumer_type) {
     case CONSUMER_TYPE_ORIENTATION:
       if (orientation_buffer_) {
         orientation_buffer_->seqlock.WriteBegin();
-        orientation_buffer_->data.allAvailableSensorsAreActive = enabled;
+        orientation_buffer_->data.all_available_sensors_are_active = enabled;
         orientation_buffer_->seqlock.WriteEnd();
       }
       break;
     case CONSUMER_TYPE_ORIENTATION_ABSOLUTE:
       if (orientation_absolute_buffer_) {
         orientation_absolute_buffer_->seqlock.WriteBegin();
-        orientation_absolute_buffer_->data.allAvailableSensorsAreActive =
+        orientation_absolute_buffer_->data.all_available_sensors_are_active =
             enabled;
         orientation_absolute_buffer_->seqlock.WriteEnd();
       }
       break;
     case CONSUMER_TYPE_MOTION:
       if (motion_buffer_) {
         motion_buffer_->seqlock.WriteBegin();
-        motion_buffer_->data.allAvailableSensorsAreActive = enabled;
+        motion_buffer_->data.all_available_sensors_are_active = enabled;
         motion_buffer_->seqlock.WriteEnd();
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace device