[Telemetry SWX] Add memory info

Add memory info to the probe service.

Bug: b:158658869
Change-Id: I8763da7aeb1ed0047c115306180ba1e55ff2f084
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2274619
Commit-Queue: Oleh Lamzin <lamzin@google.com>
Reviewed-by: Tom Sepez <tsepez@chromium.org>
Reviewed-by: Mahmoud Gawad <mgawad@google.com>
Reviewed-by: Roland Bock <rbock@google.com>
Cr-Commit-Position: refs/heads/master@{#786260}

chromeos/components/telemetry_extension_ui/mojom/probe_service.mojom

@@ -26,6 +26,7 @@
 //           - PhysicalCpuInfo
 //           - CpuInfo
 //           - TimezoneInfo
+//           - MemoryInfo
 //   3) NonRemovableBlockDeviceInfo: use uint32 to store manufacturer_id instead
 //      of uint8 in case we want to extend manufacturer range.
 //   4) LogicalCpuInfo:
@@ -33,6 +34,8 @@
 //           cros_healthd interface;
 //      4.2) use uint64 to store idle_time_user instead of uint32,
 //           idle_time_user can easily be more than uint32 range.
+//   5) MemoryInfo: use uint64 to store page_faults_since_last_boot instead of
+//      uint32, it can be more than uint32 range.
 
 module chromeos.health.mojom;
 
@@ -60,6 +63,7 @@ enum ProbeCategoryEnum {
   kCachedVpdData,
   kCpu,
   kTimezone,
+  kMemory,
 };
 
 // An enumeration of the different categories of errors that can occur when
@@ -290,6 +294,27 @@ union TimezoneResult {
   ProbeError error;
 };
 
+// Memory information.
+struct MemoryInfo {
+  // Total memory, in KiB.
+  UInt32Value? total_memory_kib;
+  // Free memory, in KiB.
+  UInt32Value? free_memory_kib;
+  // Available memory, in KiB.
+  UInt32Value? available_memory_kib;
+  // Number of page faults since the last boot.
+  UInt64Value? page_faults_since_last_boot;
+};
+
+// Memory probe result. Can either be populated with the MemoryInfo or an
+// error retrieving the information.
+union MemoryResult {
+  // Valid MemoryInfo.
+  MemoryInfo memory_info;
+  // The error that occurred attempting to retrieve the MemoryInfo.
+  ProbeError error;
+};
+
 // A collection of all the device's telemetry information that cros_healthd is
 // capable of reporting. Note that every field in TelemetryInfo is nullable, and
 // the response for a particular ProbeTelemetryInfo request will only contain
@@ -314,4 +339,7 @@ struct TelemetryInfo {
   // Information about the device's timezone. Only present when kTimezone was
   // included in the categories input to ProbeTelemetryInfo.
   TimezoneResult? timezone_result;
+  // Information about the system's memory. Only present when kMemory was
+  // included in the categories input to ProbeTelemetryInfo.
+  MemoryResult? memory_result;
 };

chromeos/components/telemetry_extension_ui/probe_service_converters.cc

@@ -28,6 +28,8 @@ cros_healthd::mojom::ProbeCategoryEnum Convert(
       return cros_healthd::mojom::ProbeCategoryEnum::kCpu;
     case health::mojom::ProbeCategoryEnum::kTimezone:
       return cros_healthd::mojom::ProbeCategoryEnum::kTimezone;
+    case health::mojom::ProbeCategoryEnum::kMemory:
+      return cros_healthd::mojom::ProbeCategoryEnum::kMemory;
   }
   NOTREACHED();
 }
@@ -184,6 +186,28 @@ health::mojom::TimezoneResultPtr UncheckedConvertPtr(
   NOTREACHED();
 }
 
+health::mojom::MemoryInfoPtr UncheckedConvertPtr(
+    cros_healthd::mojom::MemoryInfoPtr input) {
+  return health::mojom::MemoryInfo::New(
+      Convert(input->total_memory_kib),
+      Convert(input->free_memory_kib),
+      Convert(input->available_memory_kib),
+      Convert(static_cast<uint64_t>(input->page_faults_since_last_boot)));
+}
+
+health::mojom::MemoryResultPtr UncheckedConvertPtr(
+    cros_healthd::mojom::MemoryResultPtr input) {
+  switch (input->which()) {
+    case cros_healthd::mojom::MemoryResult::Tag::MEMORY_INFO:
+      return health::mojom::MemoryResult::NewMemoryInfo(
+          ConvertPtr(std::move(input->get_memory_info())));
+    case cros_healthd::mojom::MemoryResult::Tag::ERROR:
+      return health::mojom::MemoryResult::NewError(
+          ConvertPtr(std::move(input->get_error())));
+  }
+  NOTREACHED();
+}
+
 health::mojom::TelemetryInfoPtr UncheckedConvertPtr(
     cros_healthd::mojom::TelemetryInfoPtr input) {
   return health::mojom::TelemetryInfo::New(
@@ -191,7 +215,8 @@ health::mojom::TelemetryInfoPtr UncheckedConvertPtr(
       ConvertPtr(std::move(input->block_device_result)),
       ConvertPtr(std::move(input->vpd_result)),
       ConvertPtr(std::move(input->cpu_result)),
-      ConvertPtr(std::move(input->timezone_result)));
+      ConvertPtr(std::move(input->timezone_result)),
+      ConvertPtr(std::move(input->memory_result)));
 }
 
 }  // namespace unchecked

chromeos/components/telemetry_extension_ui/probe_service_converters.h

@@ -73,6 +73,12 @@ health::mojom::TimezoneInfoPtr UncheckedConvertPtr(
 health::mojom::TimezoneResultPtr UncheckedConvertPtr(
     cros_healthd::mojom::TimezoneResultPtr input);
 
+health::mojom::MemoryInfoPtr UncheckedConvertPtr(
+    cros_healthd::mojom::MemoryInfoPtr input);
+
+health::mojom::MemoryResultPtr UncheckedConvertPtr(
+    cros_healthd::mojom::MemoryResultPtr input);
+
 health::mojom::TelemetryInfoPtr UncheckedConvertPtr(
     cros_healthd::mojom::TelemetryInfoPtr input);
 

chromeos/components/telemetry_extension_ui/probe_service_converters_unittest.cc

@@ -23,7 +23,8 @@ TEST(ProbeServiceConvertors, ConvertCategoryVector) {
       health::mojom::ProbeCategoryEnum::kNonRemovableBlockDevices,
       health::mojom::ProbeCategoryEnum::kCachedVpdData,
       health::mojom::ProbeCategoryEnum::kCpu,
-      health::mojom::ProbeCategoryEnum::kTimezone};
+      health::mojom::ProbeCategoryEnum::kTimezone,
+      health::mojom::ProbeCategoryEnum::kMemory};
   EXPECT_THAT(
       ConvertCategoryVector(kInput),
       ElementsAre(
@@ -31,7 +32,8 @@ TEST(ProbeServiceConvertors, ConvertCategoryVector) {
           cros_healthd::mojom::ProbeCategoryEnum::kNonRemovableBlockDevices,
           cros_healthd::mojom::ProbeCategoryEnum::kCachedVpdData,
           cros_healthd::mojom::ProbeCategoryEnum::kCpu,
-          cros_healthd::mojom::ProbeCategoryEnum::kTimezone));
+          cros_healthd::mojom::ProbeCategoryEnum::kTimezone,
+          cros_healthd::mojom::ProbeCategoryEnum::kMemory));
 }
 
 // Tests that |ConvertPtr| function returns nullptr if input is nullptr.
@@ -403,6 +405,44 @@ TEST(ProbeServiceConvertors, TimezoneResultPtrError) {
   EXPECT_TRUE(output->is_error());
 }
 
+TEST(ProbeServiceConvertors, MemoryInfoPtr) {
+  constexpr uint32_t kTotalMemoryKib = 100000;
+  constexpr uint32_t kFreeMemoryKib = 10000;
+  constexpr uint32_t kAvailableMemoryKib = 1000;
+  constexpr uint32_t kPageFaultsSinceLastBoot = 100;
+
+  auto input = cros_healthd::mojom::MemoryInfo::New();
+  input->total_memory_kib = kTotalMemoryKib;
+  input->free_memory_kib = kFreeMemoryKib;
+  input->available_memory_kib = kAvailableMemoryKib;
+  input->page_faults_since_last_boot = kPageFaultsSinceLastBoot;
+
+  const auto output = ConvertPtr(input.Clone());
+  ASSERT_TRUE(output);
+  EXPECT_EQ(output->total_memory_kib,
+            health::mojom::UInt32Value::New(kTotalMemoryKib));
+  EXPECT_EQ(output->free_memory_kib,
+            health::mojom::UInt32Value::New(kFreeMemoryKib));
+  EXPECT_EQ(output->available_memory_kib,
+            health::mojom::UInt32Value::New(kAvailableMemoryKib));
+  EXPECT_EQ(output->page_faults_since_last_boot,
+            health::mojom::UInt64Value::New(kPageFaultsSinceLastBoot));
+}
+
+TEST(ProbeServiceConvertors, MemoryResultPtrInfo) {
+  const health::mojom::MemoryResultPtr output =
+      ConvertPtr(cros_healthd::mojom::MemoryResult::NewMemoryInfo(nullptr));
+  ASSERT_TRUE(output);
+  EXPECT_TRUE(output->is_memory_info());
+}
+
+TEST(ProbeServiceConvertors, MemoryResultPtrError) {
+  const health::mojom::MemoryResultPtr output =
+      ConvertPtr(cros_healthd::mojom::MemoryResult::NewError(nullptr));
+  ASSERT_TRUE(output);
+  EXPECT_TRUE(output->is_error());
+}
+
 TEST(ProbeServiceConvertors, TelemetryInfoPtrHasBatteryResult) {
   constexpr int64_t kCycleCount = 1;
 
@@ -527,6 +567,29 @@ TEST(ProbeServiceConvertors, TelemetryInfoPtrHasTimezoneResult) {
   EXPECT_EQ(timezone_info_output->posix, kPosix);
 }
 
+TEST(ProbeServiceConvertors, TelemetryInfoPtrHasMemoryResult) {
+  constexpr uint32_t kTotalMemoryKib = 10000;
+
+  auto input = cros_healthd::mojom::TelemetryInfo::New();
+  {
+    auto memory_info = cros_healthd::mojom::MemoryInfo::New();
+    memory_info->total_memory_kib = kTotalMemoryKib;
+
+    input->memory_result = cros_healthd::mojom::MemoryResult::NewMemoryInfo(
+        std::move(memory_info));
+  }
+
+  const health::mojom::TelemetryInfoPtr output = ConvertPtr(std::move(input));
+  ASSERT_TRUE(output);
+  ASSERT_TRUE(output->memory_result);
+  ASSERT_TRUE(output->memory_result->is_memory_info());
+
+  const auto& memory_info_output = output->memory_result->get_memory_info();
+  ASSERT_TRUE(memory_info_output);
+  EXPECT_EQ(memory_info_output->total_memory_kib,
+            health::mojom::UInt32Value::New(kTotalMemoryKib));
+}
+
 TEST(ProbeServiceConvertors, TelemetryInfoPtrWithNullFields) {
   const health::mojom::TelemetryInfoPtr telemetry_info_output =
       ConvertPtr(cros_healthd::mojom::TelemetryInfo::New());
@@ -536,6 +599,7 @@ TEST(ProbeServiceConvertors, TelemetryInfoPtrWithNullFields) {
   EXPECT_FALSE(telemetry_info_output->vpd_result);
   EXPECT_FALSE(telemetry_info_output->cpu_result);
   EXPECT_FALSE(telemetry_info_output->timezone_result);
+  EXPECT_FALSE(telemetry_info_output->memory_result);
 }
 
 }  // namespace probe_service_converters

chromeos/components/telemetry_extension_ui/test/untrusted_browsertest.js

@@ -64,6 +64,7 @@ UNTRUSTED_TEST('UntustedRequestTelemetryInfo', async () => {
       'batteryResult': null,
       'blockDeviceResult': null,
       'cpuResult': null,
+      'memoryResult': null,
       'timezoneResult': null,
       'vpdResult': null,
     }