[sensors](CrOS/Linux) Fix: create sensors when no scaling file is specified

device/generic_sensor/linux/platform_sensor_utils_linux.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/linux/platform_sensor_utils_linux.h"
 
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
@@ skipping 33 matching lines @@
   // treated as a non-existing one.
   for (auto const& file_names : data.sensor_file_names) {
     // Supply InitSensorPaths() with a set of files.
     // Only one file from each set should be found.
     if (!InitSensorPaths(file_names, data.base_path_sensor_linux, sensor_paths))
       return false;
   }
   return true;
 }
 
-// Returns -1 if unable to read a scaling value, 1 if scaling value is not
-// found. Otherwise, returns a scaling value read from a file.
-double GetSensorScalingValue(const base::FilePath& scale_file_path) {
-  if (!base::PathExists(scale_file_path))
-    return 1;
-
+// Returns -1 if unable to read a scaling value.
+// Otherwise, returns a scaling value read from a file.
+double ReadSensorScalingValue(const base::FilePath& scale_file_path) {
   std::string value;
   if (!base::ReadFileToString(scale_file_path, &value))
     return -1;
 
   double scaling_value;
   base::TrimWhitespaceASCII(value, base::TRIM_ALL, &value);
   if (!base::StringToDouble(value, &scaling_value))
     return -1;
   return scaling_value;
 }
 
 }  // namespace
 
 // static
 std::unique_ptr<SensorReader> SensorReader::Create(
     const SensorDataLinux& data) {
   base::ThreadRestrictions::AssertIOAllowed();
   std::vector<base::FilePath> sensor_paths;
   if (!GetSensorFilePaths(data, &sensor_paths))
     return nullptr;
 
   DCHECK(!sensor_paths.empty());
-  const base::FilePath scale_file_path =
-      sensor_paths.back().DirName().Append(data.sensor_scale_name);
-  double scaling_value = GetSensorScalingValue(scale_file_path);
+  // Scaling value is 1 if scaling file is not specified is |data| or scaling
+  // file is not found.
+  double scaling_value = 1;
+  if (!data.sensor_scale_name.empty()) {
+    const base::FilePath scale_file_path =
+        sensor_paths.back().DirName().Append(data.sensor_scale_name);
+    if (base::PathExists(scale_file_path))
+      scaling_value = ReadSensorScalingValue(scale_file_path);
+  }
 
   // A file with a scaling value is found, but couldn't be read.
   if (scaling_value == -1)
     return nullptr;
 
   return base::WrapUnique(new SensorReader(
       std::move(sensor_paths), scaling_value, data.apply_scaling_func));
 }
 
 SensorReader::SensorReader(
@@ skipping 24 matching lines @@
       return false;
     readings.values[i++] = new_value;
   }
   if (!apply_scaling_func_.is_null())
     apply_scaling_func_.Run(scaling_value_, readings);
   *reading = readings;
   return true;
 }
 
 }  // namespace device