[Telemetry SWX] add CPU info browser test

Bug: b:158658869
Change-Id: I5253597f59fad15243fc62e0001765d48f693b49
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2377736
Commit-Queue: Oleh Lamzin <lamzin@google.com>
Reviewed-by: Mahmoud Gawad <mgawad@google.com>
Cr-Commit-Position: refs/heads/master@{#802725}

chromeos/components/telemetry_extension_ui/resources/trusted.js

@@ -285,6 +285,23 @@ class TelemetryProxy {
     if (this.categoryToEnum_.size != categoryEnum.MAX_VALUE + 1) {
       throw RangeError('categoryToEnum_ does not contain all items from enum!');
     }
+
+    const cpuArchEnum = chromeos.health.mojom.CpuArchitectureEnum;
+
+    /**
+     * @type { !Map<!chromeos.health.mojom.CpuArchitectureEnum, !string > }
+     * @const
+     */
+    this.enumToCpuArch_ = new Map([
+      [cpuArchEnum.kUnknown, 'unknown'],
+      [cpuArchEnum.kX86_64, 'x86-64'],
+      [cpuArchEnum.kAArch64, 'AArch64'],
+      [cpuArchEnum.kArmv7l, 'Armv7l'],
+    ]);
+
+    if (this.enumToCpuArch_.size != cpuArchEnum.MAX_VALUE + 1) {
+      throw RangeError('enumToCpuArch_ does not contain all items from enum!');
+    }
   }
 
   /**
@@ -300,6 +317,32 @@ class TelemetryProxy {
     });
   }
 
+  /**
+   * @param { !chromeos.health.mojom.CpuArchitectureEnum } cpuArch
+   * @return { !string }
+   */
+  convertCpuArch(cpuArch) {
+    if (!this.enumToCpuArch_.has(cpuArch)) {
+      throw TypeError(`CPU architecture '${cpuArch}' is unknown.`);
+    }
+    return this.enumToCpuArch_.get(cpuArch);
+  }
+
+  /**
+   * @param { !chromeos.health.mojom.TelemetryInfo } telemetryInfo
+   * @return { !Object }
+   */
+  convertAllEnums(telemetryInfo) {
+    if (telemetryInfo && telemetryInfo.cpuResult &&
+        telemetryInfo.cpuResult.cpuInfo &&
+        telemetryInfo.cpuResult.cpuInfo.architecture) {
+      /** @suppress {checkTypes} */
+      telemetryInfo.cpuResult.cpuInfo.architecture =
+          this.convertCpuArch(telemetryInfo.cpuResult.cpuInfo.architecture);
+    }
+    return telemetryInfo;
+  }
+
   /**
    * This method converts Mojo types to WebIDL types applying next rules:
    *   1. remove null objects from arrays;
@@ -378,7 +421,7 @@ class TelemetryProxy {
     const telemetryInfo =
         await getOrCreateProbeService().probeTelemetryInfo(categories);
     return /** @type {!Object} */ (
-        this.convert(telemetryInfo.telemetryInfo) || {});
+        this.convert(this.convertAllEnums(telemetryInfo.telemetryInfo)) || {});
   }
 };
 

chromeos/components/telemetry_extension_ui/test/telemetry_extension_ui_browsertest.cc

@@ -198,6 +198,52 @@ void TelemetryExtensionUiBrowserTest::SetUpOnMainThread() {
         chromeos::cros_healthd::mojom::SystemResult::NewSystemInfo(
             std::move(system_info));
   }
+  {
+    auto c_state1 = chromeos::cros_healthd::mojom::CpuCStateInfo::New();
+    c_state1->name = "C1";
+    c_state1->time_in_state_since_last_boot_us = 1125899906875957;
+
+    auto c_state2 = chromeos::cros_healthd::mojom::CpuCStateInfo::New();
+    c_state2->name = "C2";
+    c_state2->time_in_state_since_last_boot_us = 1125899906877777;
+
+    auto logical_info1 = chromeos::cros_healthd::mojom::LogicalCpuInfo::New();
+    logical_info1->max_clock_speed_khz = 2147494759;
+    logical_info1->scaling_max_frequency_khz = 1073764046;
+    logical_info1->scaling_current_frequency_khz = 536904245;
+    logical_info1->c_states.push_back(std::move(c_state1));
+    logical_info1->c_states.push_back(std::move(c_state2));
+    // Idle time cannot be tested in browser test, because it requires USER_HZ
+    // system constant to convert idle_time_user_hz to milliseconds.
+    logical_info1->idle_time_user_hz = 0;
+
+    auto logical_info2 = chromeos::cros_healthd::mojom::LogicalCpuInfo::New();
+    logical_info2->max_clock_speed_khz = 1147494759;
+    logical_info2->scaling_max_frequency_khz = 1063764046;
+    logical_info2->scaling_current_frequency_khz = 936904246;
+    // Idle time cannot be tested in browser test, because it requires USER_HZ
+    // system constant to convert idle_time_user_hz to milliseconds.
+    logical_info2->idle_time_user_hz = 0;
+
+    auto physical_info1 = chromeos::cros_healthd::mojom::PhysicalCpuInfo::New();
+    physical_info1->model_name = "i9";
+    physical_info1->logical_cpus.push_back(std::move(logical_info1));
+    physical_info1->logical_cpus.push_back(std::move(logical_info2));
+
+    auto physical_info2 = chromeos::cros_healthd::mojom::PhysicalCpuInfo::New();
+    physical_info2->model_name = "i9-low-powered";
+
+    auto cpu_info = chromeos::cros_healthd::mojom::CpuInfo::New();
+    cpu_info->num_total_threads = 2147483759;
+    cpu_info->architecture =
+        chromeos::cros_healthd::mojom::CpuArchitectureEnum::kArmv7l;
+    cpu_info->physical_cpus.push_back(std::move(physical_info1));
+    cpu_info->physical_cpus.push_back(std::move(physical_info2));
+
+    telemetry_info->cpu_result =
+        chromeos::cros_healthd::mojom::CpuResult::NewCpuInfo(
+            std::move(cpu_info));
+  }
 
   DCHECK(chromeos::cros_healthd::FakeCrosHealthdClient::Get());
 

chromeos/components/telemetry_extension_ui/test/telemetry_extension_ui_browsertest.js

@@ -118,6 +118,31 @@ TEST_F('TelemetryExtensionUIBrowserTest', 'ConvertDiagnosticsEnums', () => {
   testDone();
 });
 
+// Tests that Telemetry correctly converts Mojo enums to strings.
+TEST_F('TelemetryExtensionUIBrowserTest', 'ConvertTelemetryEnums', () => {
+  // Unit tests for convertCommandToEnum
+  const cpuArchEnum = chromeos.health.mojom.CpuArchitectureEnum;
+
+  assertEquals(telemetryProxy.convertCpuArch(cpuArchEnum.kUnknown), 'unknown');
+  assertEquals(telemetryProxy.convertCpuArch(cpuArchEnum.kX86_64), 'x86-64');
+  assertEquals(telemetryProxy.convertCpuArch(cpuArchEnum.kAArch64), 'AArch64');
+  assertEquals(telemetryProxy.convertCpuArch(cpuArchEnum.kArmv7l), 'Armv7l');
+
+  // Check that convertAllEnums converts all Mojo enums to strings and does not
+  // crash if some enums are not present in TelemetryInfo.
+  assertDeepEquals(telemetryProxy.convertAllEnums({}), {});
+  assertDeepEquals(
+      telemetryProxy.convertAllEnums({cpuResult: {}}), {cpuResult: {}});
+  assertDeepEquals(
+      telemetryProxy.convertAllEnums({
+        cpuResult:
+            {cpuInfo: {architecture: cpuArchEnum.kX86_64, physicalCpus: []}}
+      }),
+      {cpuResult: {cpuInfo: {architecture: 'x86-64', physicalCpus: []}}});
+
+  testDone();
+});
+
 // Tests that Telemetry.convert method correctly converts Mojo types into WebIDL
 // types.
 TEST_F(

chromeos/components/telemetry_extension_ui/test/untrusted_browsertest.js

@@ -172,7 +172,38 @@ UNTRUSTED_TEST('UntrustedRequestTelemetryInfo', async () => {
         discardTimeSecondsSinceLastBoot: 77777777777777
       }]
     },
-    vpdResult: {vpdInfo: {skuNumber: 'sku-18'}}
+    vpdResult: {vpdInfo: {skuNumber: 'sku-18'}},
+    cpuResult: {
+      cpuInfo: {
+        numTotalThreads: 2147483759,
+        architecture: 'Armv7l',
+        physicalCpus: [
+          {
+            modelName: 'i9',
+            logicalCpus: [
+              {
+                maxClockSpeedKhz: 2147494759,
+                scalingMaxFrequencyKhz: 1073764046,
+                scalingCurrentFrequencyKhz: 536904245,
+                idleTimeMs: 0,
+                cStates: [
+                  {name: 'C1', timeInStateSinceLastBootUs: 1125899906875957},
+                  {name: 'C2', timeInStateSinceLastBootUs: 1125899906877777}
+                ]
+              },
+              {
+                maxClockSpeedKhz: 1147494759,
+                scalingMaxFrequencyKhz: 1063764046,
+                scalingCurrentFrequencyKhz: 936904246,
+                idleTimeMs: 0,
+                cStates: []
+              }
+            ]
+          },
+          {modelName: 'i9-low-powered', logicalCpus: []}
+        ]
+      }
+    }
   });
 });