Use Signal Callback in Ambient Light Sensor

ambient_light_sensor.cc

-// Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
+// Copyright (c) 2011 The Chromium OS 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 "power_manager/ambient_light_sensor.h"
 
 #include <fcntl.h>
 #include <errno.h>
 #include <string.h>
 
 #include "base/logging.h"
 
 namespace power_manager {
 
 // Period in which to poll the ambient light sensor.
 static const int kSensorPollPeriodMs = 1000;
 
 AmbientLightSensor::AmbientLightSensor(BacklightController* controller)
     : controller_(controller),
       als_fd_(-1),
       last_level_(0),
       is_polling_(false),
       disable_polling_(false),
       still_deferring_(false) {}
 
 AmbientLightSensor::~AmbientLightSensor() {
   if (als_fd_ >= 0)
     close(als_fd_);
 }
 
-bool AmbientLightSensor::DeferredInit(AmbientLightSensor* self) {
+bool AmbientLightSensor::DeferredInit() {
   // tsl2561 is currently the only supported light sensor.
   // If the lux file is not immediately found, issue a deferral
   // message and try again later.
-  self->als_fd_ = open("/sys/class/iio/device0/lux", O_RDONLY);
-  if (self->als_fd_ == -1) {
-    if (self->still_deferring_)
+  als_fd_ = open("/sys/class/iio/device0/lux", O_RDONLY);
+  if (als_fd_ == -1) {
+    if (still_deferring_)
       return false;
     LOG(WARNING) << "Deferring lux: " << strerror(errno);
-    self->still_deferring_ = true;
+    still_deferring_ = true;
     return false;
   }
-  if (self->still_deferring_)
+  if (still_deferring_)
     LOG(INFO) << "Finally found the lux file";
   return true;
 }
 
 bool AmbientLightSensor::Init() {
   if (controller_)
     controller_->set_light_sensor(this);
   return true;
 }
 
@@ skipping 11 matching lines @@
   // it is already on.
   // is_polling_ resolves the race.  No locking is needed in this single
   // threaded application.
   disable_polling_ = false;
   if (is_polling_)
     return; // already polling.
 
   // Start polling.
   LOG(INFO) << "Enabling light sensor poll";
   is_polling_ = true;
-  g_timeout_add(kSensorPollPeriodMs, ReadAls, this);
+  g_timeout_add(kSensorPollPeriodMs, ReadAlsThunk, this);
 }
 
-gboolean AmbientLightSensor::ReadAls(gpointer data) {
-  AmbientLightSensor* self = static_cast<AmbientLightSensor*>(data);
-  if (self->disable_polling_) {
-    self->is_polling_ = false;
+gboolean AmbientLightSensor::ReadAls() {
+  if (disable_polling_) {
+    is_polling_ = false;
     return false; // Returning false removes the timeout.
   }
 
   // We really want to read the ambient light level.
   // Complete the deferred lux file open if necessary.
-  if (self->als_fd_ < 0) {
-    if (!DeferredInit(self))
+  if (als_fd_ < 0) {
+    if (!DeferredInit())
       return true; // Return true to try again later.
   }
 
   char buffer[10];
   int n;
-  if (lseek(self->als_fd_, 0, SEEK_SET) != 0 ||
-      (n = read(self->als_fd_, buffer, sizeof(buffer) - 1)) == -1) {
+  if (lseek(als_fd_, 0, SEEK_SET) != 0 ||
+      (n = read(als_fd_, buffer, sizeof(buffer) - 1)) == -1) {
     LOG(WARNING) << "Unable to read light sensor file";
   }
   if (n > 0 && n < static_cast<int>(sizeof(buffer))) {
     buffer[n] = '\0';
     int luxval = atoi(buffer);
     int64 level = Tsl2563LuxToLevel(luxval);
-    if (level != self->last_level_ && self->controller_)
-      self->controller_->SetAlsBrightnessLevel(level);
-    self->last_level_ = level;
+    if (level != last_level_ && controller_)
+      controller_->SetAlsBrightnessLevel(level);
+    last_level_ = level;
   }
   return true;
 }
 
 int64 AmbientLightSensor::Tsl2563LuxToLevel(int luxval) {
   // Notes on tsl2563 Ambient Light Response (_ALR) table:
   //
   // measurement location: lux file value, intended luma level
   //            dark room: 0,              0
   //               office: 75,             50
@@ skipping 18 matching lines @@
   // there is an exact match), or just off the end of the table if there is no
   // next highest value.
   int* bound = std::lower_bound(lux_table, lux_table + arraysize(lux_table),
                                 luxval);
 
   // Normalize table pointer to 100.
   return ((bound - lux_table) * 100 / arraysize(lux_table));
 }
 
 }  // namespace power_manager