Update AccelerometerReader to support separate iio devices

chromeos/accelerometer/accelerometer_reader.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 "chromeos/accelerometer/accelerometer_reader.h"
 
 #include <string>
 
 #include "base/bind.h"
+#include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/memory/singleton.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/sequenced_worker_pool.h"
 
 namespace chromeos {
 
 namespace {
 
 // Paths to access necessary data from the accelerometer device.
 const base::FilePath::CharType kAccelerometerTriggerPath[] =
     FILE_PATH_LITERAL("/sys/bus/iio/devices/trigger0/trigger_now");
 const base::FilePath::CharType kAccelerometerDevicePath[] =
     FILE_PATH_LITERAL("/dev/cros-ec-accel");
 const base::FilePath::CharType kAccelerometerIioBasePath[] =
     FILE_PATH_LITERAL("/sys/bus/iio/devices/");
 
-// File within the device in kAccelerometerIioBasePath containing the scale of
-// the accelerometers.
-const base::FilePath::CharType kScaleFileName[] = "in_accel_scale";
-
 // This is the per source scale file in use on kernels older than 3.18. We
 // should remove this when all devices having accelerometers are on kernel 3.18
 // or later or have been patched to use new format: http://crbug.com/510831
 const base::FilePath::CharType kSourceScaleNameFormatString[] =
     "in_accel_%s_scale";
 
+// File within kAccelerometerDevicePath/device* which denotes a single scale to
+// be used across all axes.
+const base::FilePath::CharType kAccelerometerScaleFileName[] = "scale";
+
+// File within kAccelerometerDevicePath/device* which denotes the
+// AccelerometerSource for the accelerometer.
+const base::FilePath::CharType kAccelerometerLocationFileName[] = "location";
+
 // The filename giving the path to read the scan index of each accelerometer
 // axis.
 const char kAccelerometerScanIndexPath[] =
     "scan_elements/in_accel_%s_%s_index";
 
+// The filename giving the path to read the scan index of each accelerometer
+// when they are separate device paths.
+const char kSeparateAccelerometerScanIndexPath[] =
+    "scan_elements/in_accel_%s_index";
+
 // The names of the accelerometers. Matches up with the enum AccelerometerSource
 // in chromeos/accelerometer/accelerometer_types.h.
 const char kAccelerometerNames[ACCELEROMETER_SOURCE_COUNT][5] = {"lid", "base"};
 
 // The axes on each accelerometer.
-const char kAccelerometerAxes[][2] = {"y", "x", "z"};
+const char kSeparateAccelerometerAxes[][2] = {"x", "y", "z"};

[flackr, 2015/08/21 19:12:03]

It seems suspicious that the axes have changed order. Have you tested this with
a glimmer / clapper on kernel 3.18?

[jonross, 2015/08/24 18:30:34]

kernel 3.18 is not available for glimmer/clapper. On kernel 3.14 the axes are
still written in this order.

+const char kUnifiedAccelerometerAxes[][2] = {"y", "x", "z"};
 
 // The length required to read uint values from configuration files.
 const size_t kMaxAsciiUintLength = 21;
 
 // The size of individual values.
 const size_t kDataSize = 2;
 
+// The size of reading values for an entire accelerometer, when they are
+// separate device paths.
+const size_t kDataSizeForSeparateDevices = 6;
+
 // The mean acceleration due to gravity on Earth in m/s^2.
 const float kMeanGravity = 9.80665f;
 
 // The number of accelerometers.
 const int kNumberOfAccelerometers = 2;
 
 // The number of axes for which there are acceleration readings.
 const int kNumberOfAxes = 3;
 
 // The size of data in one reading of the accelerometers.
 const int kSizeOfReading = kDataSize * kNumberOfAccelerometers * kNumberOfAxes;
 
 // Reads |path| to the unsigned int pointed to by |value|. Returns true on
 // success or false on failure.
 bool ReadFileToInt(const base::FilePath& path, int* value) {
   std::string s;
   DCHECK(value);
   if (!base::ReadFileToString(path, &s, kMaxAsciiUintLength)) {
     return false;
   }
   base::TrimWhitespaceASCII(s, base::TRIM_ALL, &s);
   if (!base::StringToInt(s, value)) {
-    LOG(ERROR) << "Failed to parse \"" << s << "\" from " << path.value();
+    LOG(ERROR) << "Failed to parse int \"" << s << "\" from " << path.value();
     return false;
   }
   return true;
+}
+
+// Reads |path| to the double pointed to by |value|. Returns true on success or
+// false on failure.
+bool ReadFileToDouble(const base::FilePath& path, double* value) {
+  std::string s;
+  DCHECK(value);
+  if (!base::ReadFileToString(path, &s)) {
+    return false;
+  }
+  base::TrimWhitespaceASCII(s, base::TRIM_ALL, &s);
+  if (!base::StringToDouble(s, value)) {
+    LOG(ERROR) << "Failed to parse double \"" << s << "\" from "
+               << path.value();
+    return false;
+  }
+  return true;
 }
 
 }  // namespace
 
 const int AccelerometerReader::kDelayBetweenReadsMs = 100;
 
 // Work that runs on a base::TaskRunner. It determines the accelerometer
 // configuartion, and reads the data. Upon a successful read it will notify
 // all observers.
 class AccelerometerFileReader
@@ skipping 30 matching lines @@
     size_t length;
 
     // Which accelerometers are present on device.
     bool has[ACCELEROMETER_SOURCE_COUNT];
 
     // Scale of accelerometers (i.e. raw value * scale = m/s^2).
     float scale[ACCELEROMETER_SOURCE_COUNT][3];
 
     // Index of each accelerometer axis in data stream.
     int index[ACCELEROMETER_SOURCE_COUNT][3];
+
+    // If true the accelerometer devices must be read from distinct files.
+    bool read_device_separately;
+
+    // Length of reading per accelerometer
+    size_t device_length[ACCELEROMETER_SOURCE_COUNT];
+
+    // The path to append to |kAccelerometerDevicePath| where the accelerometer
+    // device resides.
+    base::FilePath device_path[ACCELEROMETER_SOURCE_COUNT];
   };
 
   ~AccelerometerFileReader() {}
 
+  // When accelerometers are presented as separate iio_devices this will perform
+  // the initialize for one of the devices, at the given |iio_path| and the
+  // symbolic link |name|. |location| is defined by AccelerometerSoure.
+  bool InitializeDevice(const base::FilePath& iio_path,
+                        const base::FilePath& name,
+                        std::string* location);
+
+  // When accelerometers are presented as a single iio_device this will perform
+  // the initialization for both of them.
+  void InitializeBothAccelerometers(const base::FilePath& iio_path);

[flackr, 2015/08/21 19:12:03]

To emphasize that these two methods are for doing the same thing but for old and
new kernel behavior, how about something like InitializeLegacyAccelerometer and
InitializeAccelerometer?

[jonross, 2015/08/24 18:30:34]

I was tempted to do this when I thought we would be able to remove the legacy
path. However with no plans to bring minnie et al. up to 3.18, I'm not sure if
this is appropriate.

[flackr, 2015/08/25 21:27:55]

I think it's still appropriate. Include in the comment the kernel version(s)
each is for and probably reference the bug to remove the legacy behavior that I
filed: http://crbug.com/510831. The bug should probably be updated to reflect
what the legacy behavior now is.

It occurs to me the right solution here is probably to define a gyp flag to
switch the behavior which we can add on the chromeos side. Then the
initialization could be defined in two files and which one gets compiled in
depends on this flag. For an example where this is switched by platform, see the
InitHostLogging function:
https://code.google.com/p/chromium/codesearch#chromium/src/remoting/host/logg...

[jonross, 2015/08/25 22:26:07]

We might want to switch to the gyp flag style. From recent discussions there
isn't a plan to backport these changes to 3.14, which would leave us maintaining
these two paths for quite some time.

With touchview currently broken in ToT I would recommend that we do that as a
followup.

+
   // Attempts to read the accelerometer data. Upon a success, converts the raw
   // reading to an AccelerometerUpdate and notifies observers.
   void ReadFileAndNotify();
 
+  // When accelerometers are presented as separate iio_devices this will perform
+  // the read of both devices, from their separate locations.
+  bool ReadSeparateDevices();
+
+  // When accelerometers are presented as a single iio_device this will perform
+  // the read of the device.
+  bool ReadUnifiedDevice();
+
   // True if Initialize completed successfully, and there is an accelerometer
   // file to read.
   bool initialization_successful_;
 
   // The accelerometer configuration.
   ConfigurationData configuration_;
 
   // The observers to notify of accelerometer updates.
   scoped_refptr<base::ObserverListThreadSafe<AccelerometerReader::Observer>>
       observers_;
@@ skipping 15 matching lines @@
 
 void AccelerometerFileReader::Initialize(
     scoped_refptr<base::SequencedTaskRunner> sequenced_task_runner) {
   DCHECK(
       base::SequencedWorkerPool::GetSequenceTokenForCurrentThread().IsValid());
   task_runner_ = sequenced_task_runner;
 
   // Check for accelerometer symlink which will be created by the udev rules
   // file on detecting the device.
   base::FilePath device;
-  if (!base::ReadSymbolicLink(base::FilePath(kAccelerometerDevicePath),
-                              &device)) {
+
+  if (base::IsDirectoryEmpty(base::FilePath(kAccelerometerDevicePath))) {
+    LOG(ERROR) << "Accelerometer device directory is empty at "
+               << kAccelerometerDevicePath;
     return;
   }
 
   if (!base::PathExists(base::FilePath(kAccelerometerTriggerPath))) {
     LOG(ERROR) << "Accelerometer trigger does not exist at"
                << kAccelerometerTriggerPath;
     return;
   }
 
-  base::FilePath iio_path(base::FilePath(kAccelerometerIioBasePath).Append(
-      device));
-
-  // Read the scale for all axes.
-  int scale_divisor = 0;
-  bool per_source_scale =
-      !ReadFileToInt(iio_path.Append(kScaleFileName), &scale_divisor);
-  if (!per_source_scale && scale_divisor == 0) {
-    LOG(ERROR) << "Accelerometer " << kScaleFileName
-               << "has scale of 0 and will not be used.";
-    return;
-  }
-
-  // Read configuration of each accelerometer axis from each accelerometer from
-  // /sys/bus/iio/devices/iio:deviceX/.
-  for (size_t i = 0; i < arraysize(kAccelerometerNames); ++i) {
-    if (per_source_scale) {
-      configuration_.has[i] = false;
-      // Read scale of accelerometer.
-      std::string accelerometer_scale_path = base::StringPrintf(
-          kSourceScaleNameFormatString, kAccelerometerNames[i]);
-      if (!ReadFileToInt(iio_path.Append(accelerometer_scale_path.c_str()),
-                         &scale_divisor)) {
-        continue;
-      }
-      if (scale_divisor == 0) {
-        LOG(ERROR) << "Accelerometer " << accelerometer_scale_path
-                   << "has scale of 0 and will not be used.";
-        continue;
-      }
+  base::FileEnumerator symlink_dir(base::FilePath(kAccelerometerDevicePath),
+                                   false, base::FileEnumerator::FILES);
+  for (base::FilePath name = symlink_dir.Next(); !name.empty();
+       name = symlink_dir.Next()) {
+    base::FilePath iio_device;
+    if (!base::ReadSymbolicLink(name, &iio_device)) {
+      LOG(ERROR) << "Failed to read symbolic link " << kAccelerometerDevicePath
+                 << "/" << name.MaybeAsASCII() << "\n";
+      return;
     }
 
-    configuration_.has[i] = true;
-    for (size_t j = 0; j < arraysize(kAccelerometerAxes); ++j) {
-      configuration_.scale[i][j] = kMeanGravity / scale_divisor;
-      std::string accelerometer_index_path = base::StringPrintf(
-          kAccelerometerScanIndexPath, kAccelerometerAxes[j],
-          kAccelerometerNames[i]);
-      if (!ReadFileToInt(iio_path.Append(accelerometer_index_path.c_str()),
-                         &(configuration_.index[i][j]))) {
-        configuration_.has[i] = false;
-        break;
-      }
+    base::FilePath iio_path(base::FilePath(kAccelerometerIioBasePath)
+                                .Append(iio_device.BaseName()));
+    std::string location;
+    if (base::ReadFileToString(
+            base::FilePath(iio_path).Append(kAccelerometerLocationFileName),
+            &location)) {
+      if (!InitializeDevice(iio_path, name, &location))
+        return;
+    } else {
+      InitializeBothAccelerometers(iio_path);
+      configuration_.device_path[ACCELEROMETER_SOURCE_SCREEN] = name.BaseName();
     }
-    if (configuration_.has[i])
-      configuration_.count++;
   }
 
   // Adjust the directions of accelerometers to match the AccelerometerUpdate
   // type specified in chromeos/accelerometer/accelerometer_types.h.
   configuration_.scale[ACCELEROMETER_SOURCE_SCREEN][0] *= -1.0f;
   for (int i = 0; i < 3; ++i) {
     configuration_.scale[ACCELEROMETER_SOURCE_ATTACHED_KEYBOARD][i] *= -1.0f;
   }
 
   // Verify indices are within bounds.
   for (int i = 0; i < ACCELEROMETER_SOURCE_COUNT; ++i) {
     if (!configuration_.has[i])
       continue;
     for (int j = 0; j < 3; ++j) {
       if (configuration_.index[i][j] < 0 ||
           configuration_.index[i][j] >=
               3 * static_cast<int>(configuration_.count)) {
+        const char* axis = configuration_.read_device_separately
+                               ? kSeparateAccelerometerAxes[j]
+                               : kUnifiedAccelerometerAxes[j];
         LOG(ERROR) << "Field index for " << kAccelerometerNames[i] << " "
-                   << kAccelerometerAxes[j] << " axis out of bounds.";
+                   << axis << " axis out of bounds.";
         return;
       }
     }
   }
-  configuration_.length = kDataSize * 3 * configuration_.count;
+
   initialization_successful_ = true;
   Read();
 }
 
 void AccelerometerFileReader::Read() {
   DCHECK(
       base::SequencedWorkerPool::GetSequenceTokenForCurrentThread().IsValid());
   ReadFileAndNotify();
   task_runner_->PostNonNestableDelayedTask(
       FROM_HERE, base::Bind(&AccelerometerFileReader::Read, this),
       base::TimeDelta::FromMilliseconds(
           AccelerometerReader::kDelayBetweenReadsMs));
 }
 
 void AccelerometerFileReader::AddObserver(
     AccelerometerReader::Observer* observer) {
   observers_->AddObserver(observer);
   if (initialization_successful_) {
     task_runner_->PostNonNestableTask(
         FROM_HERE,
         base::Bind(&AccelerometerFileReader::ReadFileAndNotify, this));
   }
 }
 
 void AccelerometerFileReader::RemoveObserver(
     AccelerometerReader::Observer* observer) {
   observers_->RemoveObserver(observer);
 }
 
+bool AccelerometerFileReader::InitializeDevice(const base::FilePath& iio_path,
+                                               const base::FilePath& name,
+                                               std::string* location) {

[flackr, 2015/08/21 19:12:02]

Should be able to share most of this code with the other Initialize method.

[jonross, 2015/08/24 18:30:35]

Will look at merging as much as possible.

+  configuration_.read_device_separately = true;
+  base::TrimWhitespaceASCII(*location, base::TRIM_ALL, location);

[flackr, 2015/08/21 19:12:03]

You should do this before passing the string in and pass in a const std::string&

[jonross, 2015/08/24 18:30:34]

Done.

+  int config_index = -1;
+  for (size_t j = 0; j < arraysize(kAccelerometerNames); ++j) {

[flackr, 2015/08/21 19:12:02]

Use std::find

[jonross, 2015/08/24 18:30:34]

Done.

+    if (*location == kAccelerometerNames[j]) {
+      config_index = j;
+      break;
+    }
+  }
+
+  if (config_index == -1) {
+    LOG(ERROR) << "Invalid location: " << location << "\n";

[flackr, 2015/08/21 19:12:03]

Identify which device this came from. Also let's call this an unrecognized
location.

[jonross, 2015/08/24 18:30:34]

Done.

+    return false;
+  }
+  configuration_.device_path[config_index] = name.BaseName();
+  configuration_.has[config_index] = true;
+
+  double scale;
+  if (!ReadFileToDouble(iio_path.Append(kAccelerometerScaleFileName), &scale)) {

[flackr, 2015/08/21 19:12:03]

nit: no curlies { }

[jonross, 2015/08/24 18:30:34]

Done.

+    return false;
+  }
+
+  for (size_t j = 0; j < arraysize(kSeparateAccelerometerAxes); ++j) {
+    std::string accelerometer_index_path = base::StringPrintf(
+        kSeparateAccelerometerScanIndexPath, kSeparateAccelerometerAxes[j]);
+    if (!ReadFileToInt(iio_path.Append(accelerometer_index_path.c_str()),
+                       &(configuration_.index[config_index][j]))) {
+      configuration_.has[config_index] = false;

[flackr, 2015/08/21 19:12:03]

Since the format has changed again, we should know now (again) whether to expect
these files to be there or not, so make this failure more verbose / fail
instantly if the axis index file is missing.

[jonross, 2015/08/24 18:30:35]

Done.

+      break;
+    }
+    configuration_.scale[config_index][j] = scale;
+  }
+  configuration_.device_length[config_index] = kDataSizeForSeparateDevices;
+  if (configuration_.has[config_index])
+    configuration_.count++;
+  return true;
+}
+
+void AccelerometerFileReader::InitializeBothAccelerometers(
+    const base::FilePath& iio_path) {
+  // Read the scale for all axes.
+  int scale_divisor = 0;
+  // Read configuration of each accelerometer axis from each accelerometer from
+  // /sys/bus/iio/devices/iio:deviceX/.
+  for (size_t i = 0; i < arraysize(kAccelerometerNames); ++i) {
+    configuration_.has[i] = false;
+    // Read scale of accelerometer.
+    std::string accelerometer_scale_path = base::StringPrintf(
+        kSourceScaleNameFormatString, kAccelerometerNames[i]);
+    if (!ReadFileToInt(iio_path.Append(accelerometer_scale_path.c_str()),
+                       &scale_divisor)) {
+      continue;
+    }
+    if (scale_divisor == 0) {
+      LOG(ERROR) << "Accelerometer " << accelerometer_scale_path
+                 << "has scale of 0 and will not be used.";
+      continue;
+    }
+
+    configuration_.has[i] = true;
+    for (size_t j = 0; j < arraysize(kUnifiedAccelerometerAxes); ++j) {
+      configuration_.scale[i][j] = kMeanGravity / scale_divisor;
+      std::string accelerometer_index_path = base::StringPrintf(
+          kAccelerometerScanIndexPath, kUnifiedAccelerometerAxes[j],
+          kAccelerometerNames[i]);
+      if (!ReadFileToInt(iio_path.Append(accelerometer_index_path.c_str()),
+                         &(configuration_.index[i][j]))) {
+        configuration_.has[i] = false;

[flackr, 2015/08/21 19:12:03]

Same rationale as 365, make this fatal again.

[jonross, 2015/08/24 18:30:34]

Done.

+        break;
+      }
+    }
+    if (configuration_.has[i])
+      configuration_.count++;
+  }
+
+  configuration_.length = kDataSize * 3 * configuration_.count;
+}
+
 void AccelerometerFileReader::ReadFileAndNotify() {
   DCHECK(initialization_successful_);
-  char reading[kSizeOfReading];
 
   // Initiate the trigger to read accelerometers simultaneously
   int bytes_written = base::WriteFile(
       base::FilePath(kAccelerometerTriggerPath), "1\n", 2);
   if (bytes_written < 2) {
-    PLOG(ERROR) << "Accelerometer trigger failure: " << bytes_written;
+    LOG(ERROR) << "Accelerometer trigger failure: " << bytes_written;

[flackr, 2015/08/21 19:12:03]

Keep the PLOG here. The purpose is to display the last system error message if
the write fails: See PLOG code here
https://code.google.com/p/chromium/codesearch#chromium/src/base/logging.h&q=P...

[jonross, 2015/08/24 18:30:34]

Done.

     return;
   }
 
   // Read resulting sample from /dev/cros-ec-accel.
-  int bytes_read = base::ReadFile(base::FilePath(kAccelerometerDevicePath),
-                                  reading, configuration_.length);
-  if (bytes_read < static_cast<int>(configuration_.length)) {
-    LOG(ERROR) << "Read " << bytes_read << " byte(s), expected "
-               << configuration_.length << " bytes from accelerometer";
+  bool result;
+  update_ = new AccelerometerUpdate();
+  if (configuration_.read_device_separately) {

[flackr, 2015/08/21 19:12:03]

Thinking this over, it's not clear to me that the read code needs to branch. We
could isolate the differences to the code which sets up the configuration data.

I'm thinking we could have a list of device files to read, for each of which you
have a list of locations in order.
e.g. pseudocode:
old config = {"/dev/cros-ec-accel": [LID, BASE]}
new config = {"/dev/cros-ec-accel/device0": [LID],
              "/dev/cros-ec-accel/device1": [BASE]}

Then once you have access to the 6 bytes of data for each accelerometer you can
call into the same old code to read the data from the correct reading array.

[jonross, 2015/08/24 18:30:34]

The updated init gives us:
old config = {"/dev/cros-ec-accel/0": [LID, BASE]}
new config = {"/dev/cros-ec-accel/0": [LID],
              "/dev/cros-ec-accel/1": [BASE]}

Where the numbers are never guaranteed.

I could update the reading to split based on the two paths. Then remerge the
generation of the update.

[flackr, 2015/08/25 21:27:55]

I think my suggestion was misunderstood, I was suggesting generating a config
structure like the above but with the correctly detected path numbers in the
initialize method so that we can have a single read method.

[jonross, 2015/08/25 22:26:07]

Ah, I did misinterpret your previous comment there.

[jonross, 2015/08/26 17:40:59]

Done.

+    result = ReadSeparateDevices();
+  } else {
+    result = ReadUnifiedDevice();
+  }
+  if (!result)
     return;
-  }
 
-  update_ = new AccelerometerUpdate();
+  observers_->Notify(FROM_HERE,
+                     &AccelerometerReader::Observer::OnAccelerometerUpdated,
+                     update_);
+}
 
+bool AccelerometerFileReader::ReadSeparateDevices() {
+  char reading[kSizeOfReading];
+  int bytes_read;
   for (int i = 0; i < ACCELEROMETER_SOURCE_COUNT; ++i) {
     if (!configuration_.has[i])
       continue;
+    bytes_read = base::ReadFile(base::FilePath(kAccelerometerDevicePath)
+                                    .Append(configuration_.device_path[i]),
+                                reading, configuration_.device_length[i]);
+    if (bytes_read < static_cast<int>(configuration_.device_length[i])) {
+      LOG(ERROR) << "Acceleromter Read " << bytes_read << " byte(s), expected "

[flackr, 2015/08/21 19:12:02]

nit: s/Accelerometer/Accelerometer

Since this is not reading from a single device anymore identify the device that
was read from.

[jonross, 2015/08/24 18:30:34]

Done.

+                 << configuration_.device_length[i]
+                 << " bytes from accelerometer";
+      return false;
+    }
 
     int16* values = reinterpret_cast<int16*>(reading);
     update_->Set(
         static_cast<AccelerometerSource>(i),
         values[configuration_.index[i][0]] * configuration_.scale[i][0],
         values[configuration_.index[i][1]] * configuration_.scale[i][1],
         values[configuration_.index[i][2]] * configuration_.scale[i][2]);
   }
-
-  observers_->Notify(FROM_HERE,
-                     &AccelerometerReader::Observer::OnAccelerometerUpdated,
-                     update_);
+  return true;
 }
 
-AccelerometerFileReader::ConfigurationData::ConfigurationData() : count(0) {
+bool AccelerometerFileReader::ReadUnifiedDevice() {
+  char reading[kSizeOfReading];
+  int bytes_read = base::ReadFile(
+      base::FilePath(kAccelerometerDevicePath)
+          .Append(configuration_.device_path[ACCELEROMETER_SOURCE_SCREEN]),
+      reading, configuration_.length);
+  if (bytes_read < static_cast<int>(configuration_.length)) {
+    LOG(ERROR) << "Accelerometer Read " << bytes_read << " byte(s), expected "
+               << configuration_.length << " bytes from accelerometer";
+    return false;
+  }
+
+  for (int i = 0; i < ACCELEROMETER_SOURCE_COUNT; ++i) {
+    if (!configuration_.has[i])
+      continue;
+    int16* values = reinterpret_cast<int16*>(reading);
+    update_->Set(
+        static_cast<AccelerometerSource>(i),
+        values[configuration_.index[i][0]] * configuration_.scale[i][0],
+        values[configuration_.index[i][1]] * configuration_.scale[i][1],
+        values[configuration_.index[i][2]] * configuration_.scale[i][2]);
+  }
+  return true;
+}
+
+AccelerometerFileReader::ConfigurationData::ConfigurationData()
+    : count(0), read_device_separately(false) {
   for (int i = 0; i < ACCELEROMETER_SOURCE_COUNT; ++i) {
     has[i] = false;
     for (int j = 0; j < 3; ++j) {
       scale[i][j] = 0;
       index[i][j] = -1;
     }
   }
 }
 
 AccelerometerFileReader::ConfigurationData::~ConfigurationData() {
@@ skipping 24 matching lines @@
 }
 
 AccelerometerReader::AccelerometerReader()
     : accelerometer_file_reader_(new AccelerometerFileReader()) {
 }
 
 AccelerometerReader::~AccelerometerReader() {
 }
 
 }  // namespace chromeos