Remove DeviceLightEvent implementation

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>
 #include <objbase.h>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/win/iunknown_impl.h"
 #include "base/win/windows_version.h"
 
 namespace {
 
 const double kMeanGravity = 9.80665;
 
-void SetLightBuffer(device::DeviceLightHardwareBuffer* buffer, double lux) {
-  DCHECK(buffer);
-  buffer->seqlock.WriteBegin();
-  buffer->data.value = lux;
-  buffer->seqlock.WriteEnd();
-}
-
 }  // namespace
 
 namespace device {
 
 class DataFetcherSharedMemory::SensorEventSink
     : public ISensorEvents,
       public base::win::IUnknownImpl {
  public:
   SensorEventSink() {}
   ~SensorEventSink() override {}
@@ skipping 177 matching lines @@
 
     return true;
   }
 
  private:
   DeviceMotionHardwareBuffer* const buffer_;
 
   DISALLOW_COPY_AND_ASSIGN(SensorEventSinkMotion);
 };
 
-class DataFetcherSharedMemory::SensorEventSinkLight
-    : public DataFetcherSharedMemory::SensorEventSink {
- public:
-  explicit SensorEventSinkLight(DeviceLightHardwareBuffer* const buffer)
-      : buffer_(buffer) {}
-  ~SensorEventSinkLight() override {}
-
- protected:
-  bool UpdateSharedMemoryBuffer(ISensor* sensor,
-                                ISensorDataReport* new_data) override {
-    double lux;
-    bool has_lux;
-
-    GetSensorValue(SENSOR_DATA_TYPE_LIGHT_LEVEL_LUX, new_data, &lux, &has_lux);
-
-    if (!has_lux) {
-      // Could not get lux value.
-      return false;
-    }
-
-    SetLightBuffer(buffer_, lux);
-
-    return true;
-  }
-
- private:
-  DeviceLightHardwareBuffer* const buffer_;
-
-  DISALLOW_COPY_AND_ASSIGN(SensorEventSinkLight);
-};
-
 DataFetcherSharedMemory::DataFetcherSharedMemory() {}
 
 DataFetcherSharedMemory::~DataFetcherSharedMemory() {}
 
 DataFetcherSharedMemory::FetcherType DataFetcherSharedMemory::GetType() const {
   return FETCHER_TYPE_SEPARATE_THREAD;
 }
 
 bool DataFetcherSharedMemory::Start(ConsumerType consumer_type, void* buffer) {
   DCHECK(buffer);
@@ skipping 43 matching lines @@
                             gyrometer_available);
       if (accelerometer_available || gyrometer_available) {
         motion_buffer_->seqlock.WriteBegin();
         motion_buffer_->data.interval = GetInterval().InMilliseconds();
         motion_buffer_->seqlock.WriteEnd();
         return true;
       }
       // if no sensors are available set buffer to ready, to fire null-events.
       SetBufferAvailableState(consumer_type, true);
     } break;
-    case CONSUMER_TYPE_LIGHT: {
-      light_buffer_ = static_cast<DeviceLightHardwareBuffer*>(buffer);
-      scoped_refptr<SensorEventSink> sink(
-          new SensorEventSinkLight(light_buffer_));
-      bool sensor_light_available = RegisterForSensor(
-          SENSOR_TYPE_AMBIENT_LIGHT, sensor_light_.Receive(), sink);
-      if (sensor_light_available) {
-        SetLightBuffer(light_buffer_, -1);
-        return true;
-      }
-
-      // if no sensors are available, fire an Infinity event.
-      SetLightBuffer(light_buffer_, std::numeric_limits<double>::infinity());
-    } break;
     default:
       NOTREACHED();
   }
   return false;
 }
 
 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:
       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();
   }
   return false;
 }
 
 bool DataFetcherSharedMemory::RegisterForSensor(
     REFSENSOR_TYPE_ID sensor_type,
     ISensor** sensor,
     scoped_refptr<SensorEventSink> event_sink) {
@@ skipping 60 matching lines @@
     case CONSUMER_TYPE_MOTION:
       if (sensor_accelerometer_.Get()) {
         sensor_accelerometer_->SetEventSink(nullptr);
         sensor_accelerometer_.Reset();
       }
       if (sensor_gyrometer_.Get()) {
         sensor_gyrometer_->SetEventSink(nullptr);
         sensor_gyrometer_.Reset();
       }
       break;
-    case CONSUMER_TYPE_LIGHT:
-      if (sensor_light_.Get()) {
-        sensor_light_->SetEventSink(nullptr);
-        sensor_light_.Reset();
-      }
-      break;
     default:
       NOTREACHED();
   }
 }
 
 void DataFetcherSharedMemory::SetBufferAvailableState(
     ConsumerType consumer_type,
     bool enabled) {
   switch (consumer_type) {
     case CONSUMER_TYPE_ORIENTATION:
@@ skipping 17 matching lines @@
         motion_buffer_->data.all_available_sensors_are_active = enabled;
         motion_buffer_->seqlock.WriteEnd();
       }
       break;
     default:
       NOTREACHED();
   }
 }
 
 }  // namespace device