[Win] Implement deviceorientationabsolute data fetcher.

content/browser/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 "content/browser/device_sensors/data_fetcher_shared_memory.h"
 
 #include <GuidDef.h>
 #include <InitGuid.h>
 #include <PortableDeviceTypes.h>
 #include <Sensors.h>
@@ skipping 245 matching lines @@
 
  private:
   DeviceLightHardwareBuffer* const buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(SensorEventSinkLight);
 };
 
 DataFetcherSharedMemory::DataFetcherSharedMemory()
     : motion_buffer_(nullptr),
       orientation_buffer_(nullptr),
+      orientation_absolute_buffer_(nullptr),
       light_buffer_(nullptr) {
 }
 
 DataFetcherSharedMemory::~DataFetcherSharedMemory() {
 }
 
 DataFetcherSharedMemory::FetcherType DataFetcherSharedMemory::GetType() const {
   return FETCHER_TYPE_SEPARATE_THREAD;
 }
 
@@ skipping 11 matching lines @@
             SENSOR_TYPE_INCLINOMETER_3D, sensor_inclinometer_.Receive(), 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:
-      NOTIMPLEMENTED();
+      {
+        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);
+        // 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 gyrometer_available = RegisterForSensor(
@@ skipping 35 matching lines @@
 }
 
 bool DataFetcherSharedMemory::Stop(ConsumerType consumer_type) {
   DisableSensors(consumer_type);
   switch (consumer_type) {
     case CONSUMER_TYPE_ORIENTATION:
       SetBufferAvailableState(consumer_type, false);
       orientation_buffer_ = nullptr;
       return true;
     case CONSUMER_TYPE_ORIENTATION_ABSOLUTE:
-      NOTIMPLEMENTED();
-      break;
+      SetBufferAvailableState(consumer_type, false);
+      orientation_absolute_buffer_ = nullptr;
+      return true;
     case CONSUMER_TYPE_MOTION:
       SetBufferAvailableState(consumer_type, false);
       motion_buffer_ = nullptr;
       return true;
     case CONSUMER_TYPE_LIGHT:
       SetLightBuffer(light_buffer_, -1);
       light_buffer_ = nullptr;
       return true;
     default:
       NOTREACHED();
@@ skipping 54 matching lines @@
 
 void DataFetcherSharedMemory::DisableSensors(ConsumerType consumer_type) {
   switch(consumer_type) {
     case CONSUMER_TYPE_ORIENTATION:
       if (sensor_inclinometer_.get()) {
         sensor_inclinometer_->SetEventSink(nullptr);
         sensor_inclinometer_.Release();
       }
       break;
     case CONSUMER_TYPE_ORIENTATION_ABSOLUTE:
-      NOTIMPLEMENTED();
+      if (sensor_inclinometer_absolute_.get()) {
+        sensor_inclinometer_absolute_->SetEventSink(nullptr);
+        sensor_inclinometer_absolute_.Release();
+      }
       break;
     case CONSUMER_TYPE_MOTION:
       if (sensor_accelerometer_.get()) {
         sensor_accelerometer_->SetEventSink(nullptr);
         sensor_accelerometer_.Release();
       }
       if (sensor_gyrometer_.get()) {
         sensor_gyrometer_->SetEventSink(nullptr);
         sensor_gyrometer_.Release();
       }
@@ skipping 12 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_->seqlock.WriteEnd();
       }
       break;
+    case CONSUMER_TYPE_ORIENTATION_ABSOLUTE:
+      if (orientation_absolute_buffer_) {
+        orientation_absolute_buffer_->seqlock.WriteBegin();
+        orientation_absolute_buffer_->data.allAvailableSensorsAreActive =
+            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_->seqlock.WriteEnd();
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace content