[Telemetry] Add MemoryRoutineFinished info and event

This change adds the MemoryRoutineFinished info and event to
the Chrome Extension layer.

Bug: b/286031590, b/294819343
Test: browser_tests
--gtest_filter="*TelemetryExtensionDiagnosticRoutineObserverBrowserTest*"

NO_IFTTT=Documentation for this change will be done in one batch

Change-Id: I65566634ed6068fa1648a7a39a713f4159b57fe2
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/4762694
Reviewed-by: Ethan Cheng <yycheng@google.com>
Reviewed-by: Tim <tjudkins@chromium.org>
Commit-Queue: Bastian Kersting <bkersting@google.com>
Cr-Commit-Position: refs/heads/main@{#1184623}

chrome/browser/chromeos/extensions/telemetry/api/routines/BUILD.gn

@@ -30,6 +30,7 @@ source_set("unit_tests") {
     ":routines",
     "//chrome/common/chromeos/extensions/api",
     "//chromeos/crosapi/mojom",
+    "//testing/gmock",
     "//testing/gtest",
   ]
 }

chrome/browser/chromeos/extensions/telemetry/api/routines/diagnostic_routine_converters.cc

@@ -50,6 +50,29 @@ cx_diag::RoutineWaitingInfo UncheckedConvertPtr(
   return result;
 }
 
+cx_diag::MemtesterResult UncheckedConvertPtr(
+    crosapi::TelemetryDiagnosticMemtesterResultPtr input) {
+  cx_diag::MemtesterResult result;
+  result.passed_items = ConvertVector(input->passed_items);
+  result.failed_items = ConvertVector(input->failed_items);
+
+  return result;
+}
+
+cx_diag::MemoryRoutineFinishedInfo UncheckedConvertPtr(
+    crosapi::TelemetryDiagnosticMemoryRoutineDetailPtr input,
+    base::Uuid uuid,
+    bool has_passed) {
+  cx_diag::MemoryRoutineFinishedInfo result;
+
+  result.uuid = uuid.AsLowercaseString();
+  result.has_passed = has_passed;
+  result.bytes_tested = input->bytes_tested;
+  result.result = ConvertPtr(std::move(input->result));
+
+  return result;
+}
+
 }  // namespace unchecked
 
 cx_diag::RoutineWaitingReason Convert(
@@ -68,4 +91,52 @@ cx_diag::RoutineWaitingReason Convert(
   NOTREACHED_NORETURN();
 }
 
+cx_diag::MemtesterTestItemEnum Convert(
+    crosapi::TelemetryDiagnosticMemtesterTestItemEnum input) {
+  switch (input) {
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kUnmappedEnumField:
+      return cx_diag::MemtesterTestItemEnum::kNone;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kUnknown:
+      return cx_diag::MemtesterTestItemEnum::kUnknown;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kStuckAddress:
+      return cx_diag::MemtesterTestItemEnum::kStuckAddress;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareAND:
+      return cx_diag::MemtesterTestItemEnum::kCompareAnd;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareDIV:
+      return cx_diag::MemtesterTestItemEnum::kCompareDiv;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareMUL:
+      return cx_diag::MemtesterTestItemEnum::kCompareMul;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareOR:
+      return cx_diag::MemtesterTestItemEnum::kCompareOr;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareSUB:
+      return cx_diag::MemtesterTestItemEnum::kCompareSub;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareXOR:
+      return cx_diag::MemtesterTestItemEnum::kCompareXor;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::
+        kSequentialIncrement:
+      return cx_diag::MemtesterTestItemEnum::kSequentialIncrement;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kBitFlip:
+      return cx_diag::MemtesterTestItemEnum::kBitFlip;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kBitSpread:
+      return cx_diag::MemtesterTestItemEnum::kBitSpread;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kBlockSequential:
+      return cx_diag::MemtesterTestItemEnum::kBlockSequential;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCheckerboard:
+      return cx_diag::MemtesterTestItemEnum::kCheckerboard;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kRandomValue:
+      return cx_diag::MemtesterTestItemEnum::kRandomValue;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kSolidBits:
+      return cx_diag::MemtesterTestItemEnum::kSolidBits;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kWalkingOnes:
+      return cx_diag::MemtesterTestItemEnum::kWalkingOnes;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kWalkingZeroes:
+      return cx_diag::MemtesterTestItemEnum::kWalkingZeroes;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::k8BitWrites:
+      return cx_diag::MemtesterTestItemEnum::kByteWrites;
+    case crosapi::TelemetryDiagnosticMemtesterTestItemEnum::k16BitWrites:
+      return cx_diag::MemtesterTestItemEnum::kWordWrites;
+  }
+  NOTREACHED_NORETURN();
+}
+
 }  // namespace chromeos::converters::routines

chrome/browser/chromeos/extensions/telemetry/api/routines/diagnostic_routine_converters.h

@@ -36,11 +36,34 @@ api::os_diagnostics::RoutineWaitingInfo UncheckedConvertPtr(
     base::Uuid uuid,
     uint32_t percentage);
 
+api::os_diagnostics::MemtesterResult UncheckedConvertPtr(
+    crosapi::mojom::TelemetryDiagnosticMemtesterResultPtr input);
+
+api::os_diagnostics::MemoryRoutineFinishedInfo UncheckedConvertPtr(
+    crosapi::mojom::TelemetryDiagnosticMemoryRoutineDetailPtr input,
+    base::Uuid uuid,
+    bool has_passed);
+
 }  // namespace unchecked
 
 api::os_diagnostics::RoutineWaitingReason Convert(
     crosapi::mojom::TelemetryDiagnosticRoutineStateWaiting::Reason input);
 
+api::os_diagnostics::MemtesterTestItemEnum Convert(
+    crosapi::mojom::TelemetryDiagnosticMemtesterTestItemEnum input);
+
+template <class InputT,
+          class OutputT = decltype(Convert(std::declval<InputT>())),
+          class = std::enable_if_t<std::is_enum_v<InputT> ||
+                                   std::is_integral_v<InputT>>>
+std::vector<OutputT> ConvertVector(std::vector<InputT> input) {
+  std::vector<OutputT> output;
+  for (auto elem : input) {
+    output.push_back(Convert(std::move(elem)));
+  }
+  return output;
+}
+
 template <class InputT,
           class... Types,
           class OutputT = decltype(unchecked::UncheckedConvertPtr(

chrome/browser/chromeos/extensions/telemetry/api/routines/diagnostic_routine_converters_unittest.cc

@@ -9,6 +9,7 @@
 #include "base/uuid.h"
 #include "chrome/common/chromeos/extensions/api/diagnostics.h"
 #include "chromeos/crosapi/mojom/telemetry_diagnostic_routine_service.mojom.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace chromeos::converters::routines {
@@ -69,6 +70,64 @@ TEST(TelemetryExtensionDiagnosticRoutineConvertersTest, RoutineWaitingInfo) {
   EXPECT_EQ(static_cast<uint32_t>(*result.percentage), kPercentage);
 }
 
+TEST(TelemetryExtensionDiagnosticRoutineConvertersTest,
+     MemoryRoutineFinishedInfo) {
+  constexpr bool kHasPassed = true;
+  constexpr uint32_t kBytesTested = 42;
+  const base::Uuid kUuid = base::Uuid::GenerateRandomV4();
+
+  auto input = crosapi::TelemetryDiagnosticMemoryRoutineDetail::New();
+  input->bytes_tested = kBytesTested;
+
+  auto memtester_result = crosapi::TelemetryDiagnosticMemtesterResult::New();
+  memtester_result->passed_items = {
+      crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareDIV,
+      crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareMUL};
+  memtester_result->failed_items = {
+      crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareAND,
+      crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareSUB};
+  input->result = std::move(memtester_result);
+
+  auto result = ConvertPtr(std::move(input), kUuid, kHasPassed);
+
+  ASSERT_TRUE(result.uuid.has_value());
+  EXPECT_EQ(*result.uuid, kUuid.AsLowercaseString());
+
+  ASSERT_TRUE(result.has_passed.has_value());
+  EXPECT_EQ(*result.has_passed, kHasPassed);
+
+  ASSERT_TRUE(result.result.has_value());
+  EXPECT_THAT(
+      result.result.value().passed_items,
+      testing::ElementsAre(cx_diag::MemtesterTestItemEnum::kCompareDiv,
+                           cx_diag::MemtesterTestItemEnum::kCompareMul));
+  EXPECT_THAT(
+      result.result.value().failed_items,
+      testing::ElementsAre(cx_diag::MemtesterTestItemEnum::kCompareAnd,
+                           cx_diag::MemtesterTestItemEnum::kCompareSub));
+}
+
+TEST(TelemetryExtensionDiagnosticRoutineConvertersTest, MemtesterResult) {
+  auto input = crosapi::TelemetryDiagnosticMemtesterResult::New();
+  input->passed_items = {
+      crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareDIV,
+      crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareMUL};
+  input->failed_items = {
+      crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareAND,
+      crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareSUB};
+
+  auto result = ConvertPtr(std::move(input));
+
+  EXPECT_THAT(
+      result.passed_items,
+      testing::ElementsAre(cx_diag::MemtesterTestItemEnum::kCompareDiv,
+                           cx_diag::MemtesterTestItemEnum::kCompareMul));
+  EXPECT_THAT(
+      result.failed_items,
+      testing::ElementsAre(cx_diag::MemtesterTestItemEnum::kCompareAnd,
+                           cx_diag::MemtesterTestItemEnum::kCompareSub));
+}
+
 TEST(TelemetryExtensionDiagnosticRoutineConvertersTest, RoutineWaitingReason) {
   EXPECT_EQ(Convert(crosapi::TelemetryDiagnosticRoutineStateWaiting::Reason::
                         kUnmappedEnumField),
@@ -83,4 +142,69 @@ TEST(TelemetryExtensionDiagnosticRoutineConvertersTest, RoutineWaitingReason) {
             cx_diag::RoutineWaitingReason::kWaitingUserInput);
 }
 
+TEST(TelemetryExtensionDiagnosticRoutineConvertersTest, MemtesterTestItemEnum) {
+  EXPECT_EQ(Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::
+                        kUnmappedEnumField),
+            cx_diag::MemtesterTestItemEnum::kNone);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kUnknown),
+      cx_diag::MemtesterTestItemEnum::kUnknown);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kStuckAddress),
+      cx_diag::MemtesterTestItemEnum::kStuckAddress);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareAND),
+      cx_diag::MemtesterTestItemEnum::kCompareAnd);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareDIV),
+      cx_diag::MemtesterTestItemEnum::kCompareDiv);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareMUL),
+      cx_diag::MemtesterTestItemEnum::kCompareMul);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareOR),
+      cx_diag::MemtesterTestItemEnum::kCompareOr);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareSUB),
+      cx_diag::MemtesterTestItemEnum::kCompareSub);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCompareXOR),
+      cx_diag::MemtesterTestItemEnum::kCompareXor);
+  EXPECT_EQ(Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::
+                        kSequentialIncrement),
+            cx_diag::MemtesterTestItemEnum::kSequentialIncrement);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kBitFlip),
+      cx_diag::MemtesterTestItemEnum::kBitFlip);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kBitSpread),
+      cx_diag::MemtesterTestItemEnum::kBitSpread);
+  EXPECT_EQ(
+      Convert(
+          crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kBlockSequential),
+      cx_diag::MemtesterTestItemEnum::kBlockSequential);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kCheckerboard),
+      cx_diag::MemtesterTestItemEnum::kCheckerboard);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kRandomValue),
+      cx_diag::MemtesterTestItemEnum::kRandomValue);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kSolidBits),
+      cx_diag::MemtesterTestItemEnum::kSolidBits);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kWalkingOnes),
+      cx_diag::MemtesterTestItemEnum::kWalkingOnes);
+  EXPECT_EQ(
+      Convert(
+          crosapi::TelemetryDiagnosticMemtesterTestItemEnum::kWalkingZeroes),
+      cx_diag::MemtesterTestItemEnum::kWalkingZeroes);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::k8BitWrites),
+      cx_diag::MemtesterTestItemEnum::kByteWrites);
+  EXPECT_EQ(
+      Convert(crosapi::TelemetryDiagnosticMemtesterTestItemEnum::k16BitWrites),
+      cx_diag::MemtesterTestItemEnum::kWordWrites);
+}
+
 }  // namespace chromeos::converters::routines

chrome/browser/chromeos/extensions/telemetry/api/routines/diagnostic_routine_observation.cc

@@ -24,6 +24,27 @@ namespace {
 namespace crosapi = ::crosapi::mojom;
 namespace cx_diag = api::os_diagnostics;
 
+std::unique_ptr<extensions::Event> GetEventForFinishedRoutine(
+    crosapi::TelemetryDiagnosticRoutineStateFinishedPtr finished,
+    base::Uuid uuid,
+    content::BrowserContext* browser_context) {
+  switch (finished->detail->which()) {
+    case crosapi::TelemetryDiagnosticRoutineDetail::Tag::kUnrecognizedArgument:
+      LOG(WARNING) << "Got unknown routine detail";
+      return nullptr;
+    case crosapi::TelemetryDiagnosticRoutineDetail::Tag::kMemory: {
+      auto finished_info = converters::routines::ConvertPtr(
+          std::move(finished->detail->get_memory()), uuid,
+          finished->has_passed);
+      return std::make_unique<extensions::Event>(
+          extensions::events::OS_DIAGNOSTICS_ON_MEMORY_ROUTINE_FINISHED,
+          cx_diag::OnMemoryRoutineFinished::kEventName,
+          base::Value::List().Append(finished_info.ToValue()), browser_context);
+    }
+  }
+  NOTREACHED_NORETURN();
+}
+
 }  // namespace
 
 DiagnosticRoutineObservation::DiagnosticRoutineObservation(
@@ -76,9 +97,14 @@ void DiagnosticRoutineObservation::OnRoutineStateChange(
           base::Value::List().Append(running_info.ToValue()), browser_context_);
       break;
     }
-    case crosapi::TelemetryDiagnosticRoutineStateUnion::Tag::kFinished:
-      NOTIMPLEMENTED();
-      break;
+    case crosapi::TelemetryDiagnosticRoutineStateUnion::Tag::kFinished: {
+      event = GetEventForFinishedRoutine(
+          std::move(state->state_union->get_finished()), uuid_,
+          browser_context_);
+      if (!event) {
+        return;
+      }
+    }
   }
 
   extensions::EventRouter::Get(browser_context_)