chromeos: Add CPU temperature reader

chromeos/system/cpu_temperature_reader.cc

+// Copyright 2017 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/system/cpu_temperature_reader.h"
+
+#include "base/files/file_enumerator.h"
+#include "base/files/file_path.h"
+#include "base/files/file_util.h"
+#include "base/location.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
+#include "base/task_scheduler/post_task.h"
+#include "base/task_scheduler/task_traits.h"
+
+namespace chromeos {
+namespace system {
+
+using CPUTemperatureInfo = CPUTemperatureReader::CPUTemperatureInfo;
+
+namespace {
+
+// The location we read our CPU temperature and channel label from.
+constexpr char kDefaultHwmonDir[] = "/sys/class/hwmon/";
+constexpr char kDeviceDir[] = "device";
+constexpr char kHwmonDirectoryPattern[] = "hwmon*";
+constexpr char kCPUTempFilePattern[] = "temp*_input";
+
+// The contents of sysfs files might contain a newline at the end. Use this
+// function to read from a sysfs file and remove the newline.
+bool ReadFileContentsAndTrimWhitespace(const base::FilePath& path,
+                                       std::string* contents_out) {
+  if (!base::ReadFileToString(path, contents_out))
+    return false;
+  base::TrimWhitespaceASCII(*contents_out, base::TRIM_TRAILING, contents_out);
+  return true;
+}
+
+// Reads the temperature as degrees Celsius from the file at |path|, which is
+// expected to contain the temperature in millidegrees Celsius. Converts the
+// value into degrees and then stores it in |*temp_celsius_out|. returns true if
+// the value was successfully read from file, parsed as an int, and converted.
+bool ReadTemperatureFromPath(const base::FilePath& path,
+                             double* temp_celsius_out) {
+  std::string temperature_string;
+  if (!ReadFileContentsAndTrimWhitespace(path, &temperature_string))
+    return false;
+  uint32_t temperature = 0;
+  if (!base::StringToUint(temperature_string, &temperature))
+    return false;
+  *temp_celsius_out = temperature / 1000.0;
+  return true;
+}
+
+// Gets the label describing this temperature. Use the file "temp*_label" if it
+// is present, or fall back on the file "name" or |label_path|.
+std::string GetLabelFromPath(const base::FilePath& label_path) {
+  std::string label;
+  if (base::PathExists(label_path) &&
+      ReadFileContentsAndTrimWhitespace(base::FilePath(label_path), &label) &&
+      !label.empty()) {
+    return label;
+  }
+
+  base::FilePath name_path = label_path.DirName().Append("name");
+  if (base::PathExists(name_path) &&
+      ReadFileContentsAndTrimWhitespace(name_path, &label) && !label.empty()) {
+    return label;
+  }
+  return label_path.value();
+}
+
+}  // namespace
+
+CPUTemperatureReader::CPUTemperatureInfo::CPUTemperatureInfo() {}
+
+CPUTemperatureReader::CPUTemperatureInfo::~CPUTemperatureInfo() = default;
+
+CPUTemperatureReader::CPUTemperatureReader() : hwmon_dir_(kDefaultHwmonDir) {}
+
+CPUTemperatureReader::~CPUTemperatureReader() = default;
+
+std::vector<CPUTemperatureInfo> CPUTemperatureReader::GetCPUTemperatures() {
+  std::vector<CPUTemperatureInfo> result;
+
+  // Get directories /sys/class/hwmon/hwmon*.
+  base::FileEnumerator hwmon_enumerator(base::FilePath(hwmon_dir_), false,
+                                        base::FileEnumerator::DIRECTORIES,
+                                        kHwmonDirectoryPattern);
+  for (base::FilePath hwmon_path = hwmon_enumerator.Next(); !hwmon_path.empty();
+       hwmon_path = hwmon_enumerator.Next()) {
+    // Get temp*_input files in hwmon*/ and hwmon*/device/.
+    if (base::PathExists(hwmon_path.Append(kDeviceDir))) {
+      hwmon_path = hwmon_path.Append(kDeviceDir);
+    }
+    base::FileEnumerator enumerator(
+        hwmon_path, false, base::FileEnumerator::FILES, kCPUTempFilePattern);
+    for (base::FilePath temperature_path = enumerator.Next();
+         !temperature_path.empty(); temperature_path = enumerator.Next()) {
+      CPUTemperatureInfo info;
+      if (!ReadTemperatureFromPath(temperature_path, &info.temp_celsius)) {
+        LOG(WARNING) << "Unable to read CPU temperature from "
+                     << temperature_path.value();
+        continue;
+      }
+      // Get appropriate temp*_label file.
+      if (temperature_path.value().empty()) {

[Daniel Erat, 2017/04/24 20:16:50]

what are you trying to catch with this check? looking at the implementation of
FilePath, i'm not convinced that this can ever be empty (particularly if
ReadTemperatureFromPath succeeded using the same path earlier).

[Simon Que, 2017/04/24 22:25:48]

Done.

+        LOG(WARNING) << "Unable to parse a path to temp*_input file as ASCII";
+        continue;
+      }
+      std::string label_path = temperature_path.value();
+      base::ReplaceSubstringsAfterOffset(&label_path, 0, "input", "label");
+      info.label = GetLabelFromPath(base::FilePath(label_path));
+      result.push_back(info);
+    }
+  }
+  return result;
+}
+
+}  // namespace system
+}  // namespace chromeos