[sensors][mac] Make sure to update the sensor value when initializing the sensor.

device/generic_sensor/platform_sensor_ambient_light_mac.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_ambient_light_mac.h"
 
 #include <IOKit/IOMessage.h>
 
 #include "base/bind.h"
 #include "device/base/synchronization/shared_memory_seqlock_buffer.h"
@@ skipping 36 matching lines @@
   default_configuration.set_frequency(kDefaultAmbientLightFrequencyHz);
   return default_configuration;
 }
 
 void PlatformSensorAmbientLightMac::IOServiceCallback(void* context,
                                                       io_service_t service,
                                                       natural_t message_type,
                                                       void* message_argument) {
   PlatformSensorAmbientLightMac* sensor =
       static_cast<PlatformSensorAmbientLightMac*>(context);
-  uint32_t scalar_output_count = 2;
-  uint64_t lux_values[2];
-  kern_return_t kr = IOConnectCallMethod(
-      sensor->light_sensor_object_, LmuFunctionIndex::kGetSensorReadingID,
-      nullptr, 0, nullptr, 0, lux_values, &scalar_output_count, nullptr, 0);
-
-  if (kr == KERN_SUCCESS)
-    sensor->UpdateReading(lux_values);
+  sensor->ReadSensorValue();

[timvolodine, 2016/10/18 19:26:13]

would it make sense to make ReadSensorValue return void and return true in
StartSensor below?

[darktears, 2016/10/18 19:56:58]

The idea here was that at some point we will need to report the error back in
JavaScript. So here I would get the return value and do what's needed to throw
it in JavaScript.

 }
 
 bool PlatformSensorAmbientLightMac::StartSensor(
     const PlatformSensorConfiguration& configuration) {
   // Tested and verified by riju that the following call works on
   // MacBookPro9,1 : Macbook Pro 15" (Mid 2012 model)
   // MacBookPro10,1 : Macbook Pro 15" (Retina Display, Early 2013 model).
   // MacBookPro10,2 : Macbook Pro 13" (Retina Display, Early 2013 model).
   // MacBookAir5,2 : Macbook Air 13" (Mid 2012 model) (by François Beaufort).
   // MacBookAir6,2 : Macbook Air 13" (Mid 2013 model).
@@ skipping 18 matching lines @@
       dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_BACKGROUND, 0));
 
   kern_return_t kr = IOServiceAddInterestNotification(
       light_sensor_port_.get(), light_sensor_service_, kIOGeneralInterest,
       IOServiceCallback, this, light_sensor_notification_.InitializeInto());
   if (kr != KERN_SUCCESS)
     return false;
 
   kr = IOServiceOpen(light_sensor_service_, mach_task_self(), 0,
                      light_sensor_object_.InitializeInto());
+  if (kr != KERN_SUCCESS)
+    return false;
 
-  return kr == KERN_SUCCESS;
+  return ReadSensorValue();

[timvolodine, 2016/10/18 19:26:13]

is it possible that ReadSensorValue returns false but later the callback is
still executed. Also, in that case do you need to unregister the callback?

[darktears, 2016/10/18 19:56:58]

Yes then we can clean it up.

 }
 
 void PlatformSensorAmbientLightMac::StopSensor() {
   light_sensor_port_.reset();
   light_sensor_notification_.reset();
   light_sensor_object_.reset();
   current_lux_ = 0.0;
 }
 
-void PlatformSensorAmbientLightMac::UpdateReading(uint64_t lux_values[2]) {
+bool PlatformSensorAmbientLightMac::ReadSensorValue() {

[timvolodine, 2016/10/18 19:26:13]

maybe better name something like: ReadAndUpdate.. or ReadAndNotify?

[darktears, 2016/10/18 19:56:58]

I will change.

+  uint32_t scalar_output_count = 2;
+  uint64_t lux_values[2];
+  kern_return_t kr = IOConnectCallMethod(
+      light_sensor_object_, LmuFunctionIndex::kGetSensorReadingID, nullptr, 0,
+      nullptr, 0, lux_values, &scalar_output_count, nullptr, 0);
+
+  if (kr != KERN_SUCCESS)
+    return false;
+
   uint64_t mean = (lux_values[0] + lux_values[1]) / 2;
   double lux = LMUvalueToLux(mean);
   if (lux == current_lux_)
-    return;
+    return true;
   current_lux_ = lux;
 
   SensorReading reading;
   reading.timestamp = (base::TimeTicks::Now() - base::TimeTicks()).InSecondsF();
   reading.values[0] = current_lux_;
   UpdateSensorReading(reading, true);
+  return true;
 }
 
 }  // namespace device