diagnostics: wire routine system interface backend

Bug: 1125150
Cq-Depend: chromium:2528302
Test: browser_tests --gtest_filter=Diagnostics*
Change-Id: Ia0df0ca9f0e5f468d1c020f0d09dcc5c10a313ff
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2552893
Commit-Queue: Joon Ahn <joonbug@chromium.org>
Reviewed-by: Zentaro Kavanagh <zentaro@chromium.org>
Cr-Commit-Position: refs/heads/master@{#830910}

chrome/test/data/webui/chromeos/diagnostics/cpu_card_test.js

@@ -4,7 +4,7 @@
 
 import 'chrome://diagnostics/cpu_card.js';
 
-import {CpuUsage, RoutineName, SystemDataProviderInterface, SystemInfo} from 'chrome://diagnostics/diagnostics_types.js';
+import {CpuUsage, RoutineType, SystemDataProviderInterface, SystemInfo} from 'chrome://diagnostics/diagnostics_types.js';
 import {fakeCpuUsage, fakeSystemInfo} from 'chrome://diagnostics/fake_data.js';
 import {FakeSystemDataProvider} from 'chrome://diagnostics/fake_system_data_provider.js';
 import {getSystemDataProvider, setSystemDataProviderForTesting} from 'chrome://diagnostics/mojo_interface_provider.js';

chrome/test/data/webui/chromeos/diagnostics/fake_system_routine_controller_test.js

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import {RoutineName, RoutineRunner, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
+import {RoutineRunner, RoutineType, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
 import {FakeSystemRoutineController} from 'chrome://diagnostics/fake_system_routine_controller.js';
 import {PromiseResolver} from 'chrome://resources/js/promise_resolver.m.js';
 
@@ -25,38 +25,36 @@ export function fakeSystemRoutineContollerTestSuite() {
    * promise must be forced to resolve either by chaining it with additional
    * promises or returning it from the test.
    *
-   * @param {!RoutineName} expectedName
+   * @param {!RoutineType} expectedType
    * @param {!StandardRoutineResult} expectedResult
    * @return {!Promise}
    */
-  function runRoutineAndAssertStandardResult(expectedName, expectedResult) {
+  function runRoutineAndAssertStandardResult(expectedType, expectedResult) {
     let resolver = new PromiseResolver();
 
-    /** @type {!RoutineRunner} */
-    const routineRunnerRemote = {
+    const routineRunnerRemote = /** @type {!RoutineRunner} */ ({
       onRoutineResult: (resultInfo) => {
-        assertEquals(expectedName, resultInfo.name);
+        assertEquals(expectedType, resultInfo.type);
 
         if (resultInfo.result.hasOwnProperty('simpleResult')) {
           assertEquals(expectedResult, resultInfo.result.simpleResult);
 
-          // Can't have both simpleResult and batteryRateResult
-          assertFalse(resultInfo.result.hasOwnProperty('batteryRateResult'));
+          // Can't have both simpleResult and powerResult
+          assertFalse(resultInfo.result.hasOwnProperty('powerResult'));
         }
 
-        if (resultInfo.result.hasOwnProperty('batteryRateResult')) {
-          assertEquals(
-              expectedResult, resultInfo.result.batteryRateResult.result);
+        if (resultInfo.result.hasOwnProperty('powerResult')) {
+          assertEquals(expectedResult, resultInfo.result.powerResult.result);
 
-          // Can't have both simpleResult and batteryRateResult
+          // Can't have both simpleResult and powerResult
           assertFalse(resultInfo.result.hasOwnProperty('simpleResult'));
         }
 
         resolver.resolve();
       }
-    };
+    });
 
-    return controller.runRoutine(expectedName, routineRunnerRemote).then(() => {
+    return controller.runRoutine(expectedType, routineRunnerRemote).then(() => {
       return resolver.promise;
     });
   }
@@ -66,12 +64,12 @@ export function fakeSystemRoutineContollerTestSuite() {
    * promise must be forced to resolve either by chaining it with additional
    * promises or returning it from the test.
    *
-   * @param {!RoutineName} expectedName
+   * @param {!RoutineType} expectedType
    * @param {!StandardRoutineResult} expectedResult
    * @return {!Promise}
    */
   function runRoutineAndAssertStandardResultManualResolve(
-      expectedName, expectedResult) {
+      expectedType, expectedResult) {
     let resolver = new PromiseResolver();
 
     // Nothing should be running yet.
@@ -80,21 +78,21 @@ export function fakeSystemRoutineContollerTestSuite() {
     // Use this to detect if the routine resolved too early.
     let wasRun = false;
 
-    /** @type {!RoutineRunner} */
-    const routineRunnerRemote = {
+
+    const routineRunnerRemote = /** @type {!RoutineRunner} */ ({
       onRoutineResult: (resultInfo) => {
         assertTrue(controller.isRoutineInProgressForTesting());
         assertFalse(wasRun);
-        assertEquals(expectedName, resultInfo.name);
+        assertEquals(expectedType, resultInfo.type);
         assertEquals(expectedResult, resultInfo.result.simpleResult);
 
         // Mark that the test completed.
         wasRun = true;
         resolver.resolve();
       }
-    };
+    });
 
-    controller.runRoutine(expectedName, routineRunnerRemote).then(() => {
+    controller.runRoutine(expectedType, routineRunnerRemote).then(() => {
       assertTrue(wasRun);
       assertFalse(controller.isRoutineInProgressForTesting());
     });
@@ -116,68 +114,78 @@ export function fakeSystemRoutineContollerTestSuite() {
   test('NonExistantTest', () => {
     // A routine that hasn't had a fake result set will return kErrorExecuting.
     return runRoutineAndAssertStandardResult(
-        RoutineName.kCpuStress, StandardRoutineResult.kErrorExecuting);
+        chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+        chromeos.diagnostics.mojom.StandardRoutineResult.kExecutionError);
   });
 
   test('ExpectedResultPass', () => {
-    const routineName = RoutineName.kCpuStress;
-    const expectedResult = StandardRoutineResult.kTestPassed;
-    controller.setFakeStandardRoutineResult(routineName, expectedResult);
+    const routineType = chromeos.diagnostics.mojom.RoutineType.kCpuStress;
+    const expectedResult =
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed;
+    controller.setFakeStandardRoutineResult(routineType, expectedResult);
 
-    return runRoutineAndAssertStandardResult(routineName, expectedResult);
+    return runRoutineAndAssertStandardResult(routineType, expectedResult);
   });
 
   test('ExpectedResultFail', () => {
-    const routineName = RoutineName.kCpuStress;
-    const expectedResult = StandardRoutineResult.kTestFailed;
-    controller.setFakeStandardRoutineResult(routineName, expectedResult);
+    const routineType = chromeos.diagnostics.mojom.RoutineType.kCpuStress;
+    const expectedResult =
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed;
+    controller.setFakeStandardRoutineResult(routineType, expectedResult);
 
-    return runRoutineAndAssertStandardResult(routineName, expectedResult);
+    return runRoutineAndAssertStandardResult(routineType, expectedResult);
   });
 
-  test('ExpectedBatteryRateResultPass', () => {
-    const routineName = RoutineName.kCharge;
-    const expectedResult = StandardRoutineResult.kTestPassed;
-    controller.setFakeStandardRoutineResult(routineName, expectedResult);
+  test('ExpectedPowerResultPass', () => {
+    const routineType = chromeos.diagnostics.mojom.RoutineType.kCpuCache;
+    const expectedResult =
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed;
+    controller.setFakeStandardRoutineResult(routineType, expectedResult);
 
-    return runRoutineAndAssertStandardResult(routineName, expectedResult);
+    return runRoutineAndAssertStandardResult(routineType, expectedResult);
   });
 
-  test('ExpectedBatteryRateResultFail', () => {
-    const routineName = RoutineName.kCharge;
-    const expectedResult = StandardRoutineResult.kTestFailed;
-    controller.setFakeStandardRoutineResult(routineName, expectedResult);
+  test('ExpectedPowerResultFail', () => {
+    const routineType = chromeos.diagnostics.mojom.RoutineType.kCpuCache;
+    const expectedResult =
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed;
+    controller.setFakeStandardRoutineResult(routineType, expectedResult);
 
-    return runRoutineAndAssertStandardResult(routineName, expectedResult);
+    return runRoutineAndAssertStandardResult(routineType, expectedResult);
   });
 
   test('ExpectedResultPassManualResolve', () => {
-    const routineName = RoutineName.kCpuStress;
-    const expectedResult = StandardRoutineResult.kTestPassed;
-    controller.setFakeStandardRoutineResult(routineName, expectedResult);
+    const routineType = chromeos.diagnostics.mojom.RoutineType.kCpuStress;
+    const expectedResult =
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed;
+    controller.setFakeStandardRoutineResult(routineType, expectedResult);
 
     // Tests will only resolve when done manually.
     controller.setDelayTimeInMillisecondsForTesting(-1);
 
     return runRoutineAndAssertStandardResultManualResolve(
-        routineName, expectedResult);
+        routineType, expectedResult);
   });
 
   test('ExpectedResultFailManualResolve', () => {
-    const routineName = RoutineName.kCpuStress;
-    const expectedResult = StandardRoutineResult.kTestFailed;
-    controller.setFakeStandardRoutineResult(routineName, expectedResult);
+    const routineType = chromeos.diagnostics.mojom.RoutineType.kCpuStress;
+    const expectedResult =
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed;
+    controller.setFakeStandardRoutineResult(routineType, expectedResult);
 
     // Tests will only resolve when done manually.
     controller.setDelayTimeInMillisecondsForTesting(-1);
 
     return runRoutineAndAssertStandardResultManualResolve(
-        routineName, expectedResult);
+        routineType, expectedResult);
   });
 
   test('GetSupportedRoutines', () => {
-    /** @type {!Array<!RoutineName>} */
-    const expected = [RoutineName.kCpuStress, RoutineName.kCpuCache];
+    /** @type {!Array<!RoutineType>} */
+    const expected = [
+      chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache
+    ];
 
     controller.setFakeSupportedRoutines(expected);
     return controller.getSupportedRoutines().then((result) => {

chrome/test/data/webui/chromeos/diagnostics/routine_list_executor_test.js

@@ -2,7 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import {BatteryRateRoutineResult, RoutineName, RoutineResultInfo, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
+import {PowerRoutineResult, RoutineResultInfo, RoutineType, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
 import {FakeSystemRoutineController} from 'chrome://diagnostics/fake_system_routine_controller.js';
 import {ExecutionProgress, ResultStatusItem, RoutineListExecutor} from 'chrome://diagnostics/routine_list_executor.js';
 
@@ -33,38 +33,40 @@ export function fakeRoutineListExecutorTestSuite() {
    */
   function runRoutinesAndAssertResults(routines) {
     let expectedCallbacks = [];
-    let routineNames = [];
+    let routineTypes = [];
     routines.forEach((routine) => {
       // Set the result into the fake.
       assertNotEquals(undefined, routine);
       assertNotEquals(undefined, routine.result);
 
-      // simpleResult or batteryRateResult must exist.
+      // simpleResult or powerResult must exist.
       assertTrue(
           routine.result.hasOwnProperty('simpleResult') ||
-          routine.result.hasOwnProperty('batteryRateResult'));
+          routine.result.hasOwnProperty('powerResult'));
 
       if (routine.result.hasOwnProperty('simpleResult')) {
         controller.setFakeStandardRoutineResult(
-            routine.name, /** @type {!StandardRoutineResult} */
+            /** @type {!RoutineType} */ (routine.type),
+            /** @type {!StandardRoutineResult} */
             (routine.result.simpleResult));
       } else {
-        assertTrue(routine.result.batteryRateResult.hasOwnProperty('result'));
-        controller.setFakeBatteryRateRoutineResult(
-            routine.name, /** @type {!BatteryRateRoutineResult} */
-            (routine.result.batteryRateResult));
+        assertTrue(routine.result.powerResult.hasOwnProperty('simpleResult'));
+        controller.setFakePowerRoutineResult(
+            /** @type {!RoutineType} */ (routine.type),
+            /** @type {!PowerRoutineResult} */
+            (routine.result.powerResult));
       }
 
       // Build the list of routines to run.
-      routineNames.push(routine.name);
+      routineTypes.push(routine.type);
 
       // Add the "running" callback to the list.
-      let status = new ResultStatusItem(routine.name);
+      let status = new ResultStatusItem(routine.type);
       status.progress = ExecutionProgress.kRunning;
       expectedCallbacks.push(status);
 
       // Add the "completed" callback to the list.
-      status = new ResultStatusItem(routine.name);
+      status = new ResultStatusItem(routine.type);
       status.progress = ExecutionProgress.kCompleted;
       status.result = routine.result;
       expectedCallbacks.push(status);
@@ -81,15 +83,21 @@ export function fakeRoutineListExecutorTestSuite() {
       if (status.progress === ExecutionProgress.kRunning) {
         assertEquals(null, status.result);
       } else {
-        assertEquals(
-            expectedCallbacks[upto].result.simpleResult,
-            status.result.simpleResult);
+        if (expectedCallbacks[upto].result.hasOwnProperty('simpleResult')) {
+          assertEquals(
+              expectedCallbacks[upto].result.simpleResult,
+              status.result.simpleResult);
+        } else {
+          assertEquals(
+              expectedCallbacks[upto].result.powerResult.simpleResult,
+              status.result.powerResult.simpleResult);
+        }
       }
 
       upto++;
     };
 
-    return executor.runRoutines(routineNames, statusCallback).then(() => {
+    return executor.runRoutines(routineTypes, statusCallback).then(() => {
       // Ensure that all the callbacks were sent.
       assertEquals(expectedCallbacks.length, upto);
     });
@@ -98,8 +106,11 @@ export function fakeRoutineListExecutorTestSuite() {
   test('SingleTest', () => {
     /** @type {!Array<!RoutineResultInfo>} */
     const routines = [{
-      name: RoutineName.kCpuStress,
-      result: {simpleResult: StandardRoutineResult.kTestFailed}
+      type: chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+      result: {
+        simpleResult:
+            chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed
+      }
     }];
     return runRoutinesAndAssertResults(routines);
   });
@@ -108,26 +119,39 @@ export function fakeRoutineListExecutorTestSuite() {
     /** @type {!Array<!RoutineResultInfo>} */
     const routines = [
       {
-        name: RoutineName.kCpuStress,
-        result: {simpleResult: StandardRoutineResult.kTestPassed}
+        type: chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+        result: {
+          simpleResult:
+              chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed
+        }
       },
       {
-        name: RoutineName.kCpuCache,
-        result: {simpleResult: StandardRoutineResult.kTestFailed}
+        type: chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+        result: {
+          simpleResult:
+              chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed
+        }
       },
       {
-        name: RoutineName.kFloatingPoint,
-        result: {simpleResult: StandardRoutineResult.kTestPassed}
+        type: chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
+        result: {
+          simpleResult:
+              chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed
+        }
       },
       {
-        name: RoutineName.kPrimeSearch,
-        result: {simpleResult: StandardRoutineResult.kTestFailed}
+        type: chromeos.diagnostics.mojom.RoutineType.kCpuPrime,
+        result: {
+          simpleResult:
+              chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed
+        }
       },
       {
-        name: RoutineName.kCharge,
+        type: chromeos.diagnostics.mojom.RoutineType.kBatteryCharge,
         result: {
-          batteryRateResult: {
-            result: StandardRoutineResult.kTestFailed,
+          powerResult: {
+            simpleResult:
+                chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed,
             isCharging: true,
             percentDelta: 10,
             timeDeltaSeconds: 10

chrome/test/data/webui/chromeos/diagnostics/routine_result_entry_test.js

@@ -4,7 +4,7 @@
 
 import 'chrome://diagnostics/routine_result_entry.js';
 
-import {RoutineName, RoutineResult, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
+import {RoutineResult, RoutineType, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
 import {ExecutionProgress, ResultStatusItem} from 'chrome://diagnostics/routine_list_executor.js';
 import {BadgeType} from 'chrome://diagnostics/text_badge.js';
 import {loadTimeData} from 'chrome://resources/js/load_time_data.m.js';
@@ -62,7 +62,7 @@ export function routineResultEntryTestSuite() {
 
   /**
    * Creates a result status item without a final result.
-   * @param {!RoutineName} routine
+   * @param {!RoutineType} routine
    * @param {!ExecutionProgress} progress
    * @return {!ResultStatusItem}
    */
@@ -74,7 +74,7 @@ export function routineResultEntryTestSuite() {
 
   /**
    * Creates a completed result status item with a result.
-   * @param {!RoutineName} routine
+   * @param {!RoutineType} routine
    * @param {!RoutineResult} result
    * @return {!ResultStatusItem}
    */
@@ -115,7 +115,8 @@ export function routineResultEntryTestSuite() {
 
   test('NotStartedTest', () => {
     const item = createIncompleteStatus(
-        RoutineName.kCpuStress, ExecutionProgress.kNotStarted);
+        chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+        ExecutionProgress.kNotStarted);
     return initializeEntryWithItem(item).then(() => {
       assertEquals(
           getNameText(),
@@ -131,7 +132,8 @@ export function routineResultEntryTestSuite() {
 
   test('RunningTest', () => {
     const item = createIncompleteStatus(
-        RoutineName.kCpuStress, ExecutionProgress.kRunning);
+        chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+        ExecutionProgress.kRunning);
     return initializeEntryWithItem(item).then(() => {
       assertEquals(
           getNameText(),
@@ -147,8 +149,10 @@ export function routineResultEntryTestSuite() {
 
   test('PassedTest', () => {
     const item = createCompletedStatus(
-        RoutineName.kCpuStress, /** @type {!RoutineResult} */ ({
-          simpleResult: StandardRoutineResult.kTestPassed
+        chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+        /** @type {!RoutineResult} */ ({
+          simpleResult:
+              chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed
         }));
     return initializeEntryWithItem(item).then(() => {
       assertEquals(
@@ -165,8 +169,10 @@ export function routineResultEntryTestSuite() {
 
   test('FailedTest', () => {
     const item = createCompletedStatus(
-        RoutineName.kCpuStress, /** @type {!RoutineResult} */ ({
-          simpleResult: StandardRoutineResult.kTestFailed
+        chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+        /** @type {!RoutineResult} */ ({
+          simpleResult:
+              chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed
         }));
     return initializeEntryWithItem(item).then(() => {
       assertEquals(
@@ -181,11 +187,13 @@ export function routineResultEntryTestSuite() {
     });
   });
 
-  test('BatteryTest', () => {
+  test('PowerTest', () => {
     const item = createCompletedStatus(
-        RoutineName.kCharge, /** @type {!RoutineResult} */ ({
-          batteryRateResult: {
-            result: StandardRoutineResult.kTestPassed,
+        chromeos.diagnostics.mojom.RoutineType.kBatteryCharge,
+        /** @type {!RoutineResult} */ ({
+          powerResult: {
+            simpleResult:
+                chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed,
             isCharging: true,
             percentDelta: 10,
             timeDeltaSeconds: 10

chrome/test/data/webui/chromeos/diagnostics/routine_result_list_test.js

@@ -4,7 +4,7 @@
 
 import 'chrome://diagnostics/routine_result_list.js';
 
-import {RoutineName, RoutineResult, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
+import {RoutineResult, RoutineType, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
 import {ExecutionProgress, ResultStatusItem} from 'chrome://diagnostics/routine_list_executor.js';
 
 import {assertDeepEquals, assertEquals, assertFalse, assertNotEquals, assertTrue} from '../../chai_assert.js';
@@ -29,7 +29,7 @@ export function routineResultListTestSuite() {
 
   /**
    * Initializes the routine-result-list and sets the list of routines.
-   * @param {!Array<!RoutineName>} routines
+   * @param {!Array<!RoutineType>} routines
    * @return {!Promise}
    */
   function initializeRoutineResultList(routines) {
@@ -95,10 +95,10 @@ export function routineResultListTestSuite() {
   });
 
   test('InitializedRoutines', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kCpuCache,
-      RoutineName.kFloatingPoint,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+      chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
     ];
 
     return initializeRoutineResultList(routines).then(() => {
@@ -113,10 +113,10 @@ export function routineResultListTestSuite() {
   });
 
   test('InitializeThenClearRoutines', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kCpuCache,
-      RoutineName.kFloatingPoint,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+      chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
     ];
 
     return initializeRoutineResultList(routines)
@@ -131,10 +131,10 @@ export function routineResultListTestSuite() {
   });
 
   test('VerifyStatusUpdates', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kCpuCache,
-      RoutineName.kFloatingPoint,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+      chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
     ];
 
     return initializeRoutineResultList(routines).then(() => {
@@ -160,8 +160,10 @@ export function routineResultListTestSuite() {
             // Move the first routine to completed state.
             status = new ResultStatusItem(routines[0]);
             status.progress = ExecutionProgress.kCompleted;
-            status.result = /** @type {!RoutineResult} */ (
-                {simpleResult: StandardRoutineResult.kTestPassed});
+            status.result = /** @type {!RoutineResult} */ ({
+              simpleResult:
+                  chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed
+            });
             routineResultListElement.onStatusUpdate(status);
 
             return flushTasks();
@@ -172,7 +174,7 @@ export function routineResultListTestSuite() {
                 ExecutionProgress.kCompleted, getEntries()[0].item.progress);
             assertNotEquals(null, getEntries()[0].item.result);
             assertEquals(
-                StandardRoutineResult.kTestPassed,
+                chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed,
                 getEntries()[0].item.result.simpleResult);
 
             status = new ResultStatusItem(routines[1]);
@@ -190,8 +192,10 @@ export function routineResultListTestSuite() {
             // Move the second routine to completed state.
             status = new ResultStatusItem(routines[1]);
             status.progress = ExecutionProgress.kCompleted;
-            status.result = /** @type {!RoutineResult} */ (
-                {simpleResult: StandardRoutineResult.kTestPassed});
+            status.result = /** @type {!RoutineResult} */ ({
+              simpleResult:
+                  chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed
+            });
             routineResultListElement.onStatusUpdate(status);
 
             return flushTasks();
@@ -202,7 +206,7 @@ export function routineResultListTestSuite() {
                 ExecutionProgress.kCompleted, getEntries()[1].item.progress);
             assertNotEquals(null, getEntries()[1].item.result);
             assertEquals(
-                StandardRoutineResult.kTestPassed,
+                chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed,
                 getEntries()[0].item.result.simpleResult);
 
             return flushTasks();

chrome/test/data/webui/chromeos/diagnostics/routine_section_test.js

@@ -5,8 +5,8 @@
 import 'chrome://diagnostics/routine_result_entry.js';
 import 'chrome://diagnostics/routine_section.js';
 
-import {RoutineName, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
-import {fakeBatteryRoutineResults, fakeRoutineResults} from 'chrome://diagnostics/fake_data.js';
+import {RoutineType, StandardRoutineResult} from 'chrome://diagnostics/diagnostics_types.js';
+import {fakePowerRoutineResults, fakeRoutineResults} from 'chrome://diagnostics/fake_data.js';
 import {FakeSystemRoutineController} from 'chrome://diagnostics/fake_system_routine_controller.js';
 import {setSystemRoutineControllerForTesting} from 'chrome://diagnostics/mojo_interface_provider.js';
 import {ExecutionProgress} from 'chrome://diagnostics/routine_list_executor.js';
@@ -35,7 +35,7 @@ export function routineSectionTestSuite() {
 
     // Enable all routines by default.
     routineController.setFakeSupportedRoutines(
-        [...fakeRoutineResults.keys(), ...fakeBatteryRoutineResults.keys()]);
+        [...fakeRoutineResults.keys(), ...fakePowerRoutineResults.keys()]);
 
     setSystemRoutineControllerForTesting(routineController);
   });
@@ -49,7 +49,7 @@ export function routineSectionTestSuite() {
 
   /**
    * Initializes the element and sets the routines.
-   * @param {!Array<!RoutineName>} routines
+   * @param {!Array<!RoutineType>} routines
    */
   function initializeRoutineSection(routines) {
     assertFalse(!!routineSectionElement);
@@ -166,10 +166,10 @@ export function routineSectionTestSuite() {
   });
 
   test('ClickButtonDisablesButton', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kCpuCache,
-      RoutineName.kFloatingPoint,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+      chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
     ];
 
     return initializeRoutineSection(routines)
@@ -185,10 +185,10 @@ export function routineSectionTestSuite() {
   });
 
   test('ResultListToggleButton', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kCpuCache,
-      RoutineName.kFloatingPoint,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+      chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
     ];
 
     // TODO(joonbug): Use visibility assert over testing .hidden attr.
@@ -221,10 +221,10 @@ export function routineSectionTestSuite() {
   });
 
   test('ClickButtonInitializesResultList', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kCpuCache,
-      RoutineName.kFloatingPoint,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+      chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
     ];
 
     return initializeRoutineSection(routines)
@@ -284,17 +284,20 @@ export function routineSectionTestSuite() {
   });
 
   test('ResultListFiltersBySupported', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kCpuCache,
-      RoutineName.kMemory,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+      chromeos.diagnostics.mojom.RoutineType.kMemory,
     ];
 
     routineController.setFakeStandardRoutineResult(
-        RoutineName.kMemory, StandardRoutineResult.kTestPassed);
+        chromeos.diagnostics.mojom.RoutineType.kMemory,
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed);
     routineController.setFakeStandardRoutineResult(
-        RoutineName.kCpuCache, StandardRoutineResult.kTestPassed);
-    routineController.setFakeSupportedRoutines([RoutineName.kMemory]);
+        chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed);
+    routineController.setFakeSupportedRoutines(
+        [chromeos.diagnostics.mojom.RoutineType.kMemory]);
 
     return initializeRoutineSection(routines)
         .then(() => {
@@ -303,7 +306,9 @@ export function routineSectionTestSuite() {
         .then(() => {
           const entries = getEntries();
           assertEquals(1, entries.length);
-          assertEquals(RoutineName.kMemory, entries[0].item.routine);
+          assertEquals(
+              chromeos.diagnostics.mojom.RoutineType.kMemory,
+              entries[0].item.routine);
           // Resolve the running test.
           return routineController.resolveRoutineForTesting();
         })
@@ -313,18 +318,21 @@ export function routineSectionTestSuite() {
         .then(() => {
           const entries = getEntries();
           assertEquals(1, entries.length);
-          assertEquals(RoutineName.kMemory, entries[0].item.routine);
+          assertEquals(
+              chromeos.diagnostics.mojom.RoutineType.kMemory,
+              entries[0].item.routine);
         });
   });
 
   test('ResultListStatusSuccess', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kMemory,
+      chromeos.diagnostics.mojom.RoutineType.kMemory,
     ];
 
     routineController.setFakeStandardRoutineResult(
-        RoutineName.kMemory, StandardRoutineResult.kTestPassed);
+        chromeos.diagnostics.mojom.RoutineType.kMemory,
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed);
 
     return initializeRoutineSection(routines)
         .then(() => {
@@ -365,16 +373,18 @@ export function routineSectionTestSuite() {
   });
 
   test('ResultListStatusFail', () => {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     const routines = [
-      RoutineName.kFloatingPoint,
-      RoutineName.kCpuCache,
+      chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
+      chromeos.diagnostics.mojom.RoutineType.kCpuCache,
     ];
 
     routineController.setFakeStandardRoutineResult(
-        RoutineName.kFloatingPoint, StandardRoutineResult.kTestFailed);
+        chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed);
     routineController.setFakeStandardRoutineResult(
-        RoutineName.kCpuCache, StandardRoutineResult.kTestPassed);
+        chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+        chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed);
 
     return initializeRoutineSection(routines)
         .then(() => {

chromeos/components/diagnostics_ui/resources/battery_status_card.js

@@ -15,7 +15,7 @@ import {I18nBehavior} from 'chrome://resources/js/i18n_behavior.m.js';
 import {loadTimeData} from 'chrome://resources/js/load_time_data.m.js';
 import {html, Polymer} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
 
-import {BatteryChargeStatus, BatteryHealth, BatteryInfo, RoutineName, SystemDataProviderInterface} from './diagnostics_types.js'
+import {BatteryChargeStatus, BatteryHealth, BatteryInfo, RoutineType, SystemDataProviderInterface} from './diagnostics_types.js'
 import {getSystemDataProvider} from './mojo_interface_provider.js';
 import {mojoString16ToString} from './mojo_utils.js';
 
@@ -65,13 +65,13 @@ Polymer({
       type: Object,
     },
 
-    /** @private {!Array<!RoutineName>} */
+    /** @private {!Array<!RoutineType>} */
     routines_: {
       type: Array,
       value: () => {
         return [
-          RoutineName.kCharge,
-          RoutineName.kDischarge,
+          chromeos.diagnostics.mojom.RoutineType.kBatteryCharge,
+          chromeos.diagnostics.mojom.RoutineType.kBatteryDischarge,
         ];
       }
     },

chromeos/components/diagnostics_ui/resources/cpu_card.js

@@ -14,7 +14,7 @@ import './strings.m.js';
 import {I18nBehavior} from 'chrome://resources/js/i18n_behavior.m.js';
 import {loadTimeData} from 'chrome://resources/js/load_time_data.m.js';
 import {html, Polymer} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
-import {CpuUsage, RoutineName, SystemDataProviderInterface, SystemInfo} from './diagnostics_types.js';
+import {CpuUsage, RoutineType, SystemDataProviderInterface, SystemInfo} from './diagnostics_types.js';
 import {getSystemDataProvider} from './mojo_interface_provider.js';
 
 /**
@@ -40,15 +40,15 @@ Polymer({
   cpuUsageObserverReceiver_: null,
 
   properties: {
-    /** @private {!Array<!RoutineName>} */
+    /** @private {!Array<!RoutineType>} */
     routines_: {
       type: Array,
       value: () => {
         return [
-          RoutineName.kCpuStress,
-          RoutineName.kCpuCache,
-          RoutineName.kFloatingPoint,
-          RoutineName.kPrimeSearch,
+          chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+          chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+          chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
+          chromeos.diagnostics.mojom.RoutineType.kCpuPrime,
         ];
       }
     },

chromeos/components/diagnostics_ui/resources/diagnostics_types.js

@@ -102,83 +102,42 @@ export let CpuUsage;
 
 /**
  * Enumeration of routines.
- * @enum {number}
+ * @typedef {chromeos.diagnostics.mojom.RoutineType}
  */
-export let RoutineName = {
-  kCpuStress: 0,
-  kCpuCache: 1,
-  kFloatingPoint: 2,
-  kPrimeSearch: 3,
-  kMemory: 4,
-  kCharge: 5,
-  kDischarge: 6,
-};
+export let RoutineType;
 
 /**
  * Type alias for StandardRoutineResult.
- * @enum {number}
+ * @typedef {chromeos.diagnostics.mojom.StandardRoutineResult}
  */
-export let StandardRoutineResult = {
-  kTestPassed: 0,
-  kTestFailed: 1,
-  kErrorExecuting: 2,
-  kUnableToRun: 3,
-};
+export let StandardRoutineResult;
 
 /**
- * Type alias for BatteryRateRoutineResult.
- * @typedef {{
- *   result: !StandardRoutineResult,
- *   isCharging: boolean,
- *   percentDelta: number,
- *   timeDeltaSeconds: number,
- * }}
+ * Type alias for PowerRoutineResult.
+ * @typedef {chromeos.diagnostics.mojom.PowerRoutineResult}
  */
-export let BatteryRateRoutineResult;
+export let PowerRoutineResult;
 
 /**
  * Type alias for RoutineResult.
- * @typedef {{
- *   simpleResult: (!StandardRoutineResult|undefined),
- *   batteryRateResult: (!BatteryRateRoutineResult|undefined),
- * }}
+ * @typedef {chromeos.diagnostics.mojom.RoutineResult}
  */
 export let RoutineResult;
 
 /**
  * Type alias for RoutineResultInfo.
- * @typedef {{
- *   name: !RoutineName,
- *   result: !RoutineResult,
- * }}
+ * @typedef {chromeos.diagnostics.mojom.RoutineResultInfo}
  */
 export let RoutineResultInfo;
 
-/**
- * Type of RoutineRunner.onRoutineResult function.
- * @typedef {!function(!RoutineResultInfo)}
- */
-export let RoutineResultFunction;
-
 /**
  * Type alias for RoutineRunner.
- * @typedef {{
- *   onRoutineResult: !RoutineResultFunction,
- * }}
+ * @typedef {chromeos.diagnostics.mojom.RoutineRunnerInterface}
  */
 export let RoutineRunner;
 
-/**
- * Type of SystemRoutineController.RunRoutine function.
- * @typedef {!function(!RoutineName, !RoutineRunner): !Promise}
- */
-export let RunRoutineFunction;
-
 /**
  * Type alias for SystemRoutineControllerInterface.
- * TODO(zentaro): Replace with a real mojo type when implemented.
- * @typedef {{
- *   runRoutine: !RunRoutineFunction,
- * }}
+ * @typedef {chromeos.diagnostics.mojom.SystemRoutineControllerInterface}
  */
 export let SystemRoutineControllerInterface;

chromeos/components/diagnostics_ui/resources/fake_data.js

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import { BatteryChargeStatus, BatteryHealth, BatteryInfo, BatteryRateRoutineResult, CpuUsage, ExternalPowerSource, MemoryUsage, RoutineName, StandardRoutineResult, SystemInfo } from './diagnostics_types.js'
-import { stringToMojoString16 } from './mojo_utils.js';
+import {BatteryChargeStatus, BatteryHealth, BatteryInfo, CpuUsage, ExternalPowerSource, MemoryUsage, PowerRoutineResult, RoutineType, StandardRoutineResult, SystemInfo} from './diagnostics_types.js'
+import {stringToMojoString16} from './mojo_utils.js';
 
 /** @type {!Array<!BatteryChargeStatus>} */
 export const fakeBatteryChargeStatus = [
@@ -129,10 +129,10 @@ export const fakeSystemInfo = {
   cpuModelName: 'BestCpu SoFast 1000',
   cpuThreadsCount: 8,
   cpuMaxClockSpeedKhz: 1000,
-  deviceCapabilities: { hasBattery: true },
+  deviceCapabilities: {hasBattery: true},
   marketingName: 'Coolest Chromebook',
   totalMemoryKib: 128000,
-  versionInfo: { milestoneVersion: 'M99' },
+  versionInfo: {milestoneVersion: 'M99'},
 };
 
 /** @type {!SystemInfo} */
@@ -141,34 +141,49 @@ export const fakeSystemInfoWithoutBattery = {
   cpuModelName: 'BestCpu SoFast 1000',
   cpuThreadsCount: 8,
   cpuMaxClockSpeedKhz: 1000,
-  deviceCapabilities: { hasBattery: false },
+  deviceCapabilities: {hasBattery: false},
   marketingName: 'Coolest Chromebook',
   totalMemoryKib: 128000,
-  versionInfo: { milestoneVersion: 'M99' },
+  versionInfo: {milestoneVersion: 'M99'},
 };
 
-/** @type {!Map<!RoutineName, !StandardRoutineResult>} */
+/** @type {!Map<!RoutineType, !StandardRoutineResult>} */
 export const fakeRoutineResults = new Map([
-  [RoutineName.kCpuStress, StandardRoutineResult.kTestPassed],
-  [RoutineName.kCpuCache, StandardRoutineResult.kTestPassed],
-  [RoutineName.kFloatingPoint, StandardRoutineResult.kTestFailed],
-  [RoutineName.kPrimeSearch, StandardRoutineResult.kErrorExecuting],
-  [RoutineName.kMemory, StandardRoutineResult.kTestPassed],
+  [
+    chromeos.diagnostics.mojom.RoutineType.kCpuStress,
+    chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed
+  ],
+  [
+    chromeos.diagnostics.mojom.RoutineType.kCpuCache,
+    chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed
+  ],
+  [
+    chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint,
+    chromeos.diagnostics.mojom.StandardRoutineResult.kTestFailed
+  ],
+  [
+    chromeos.diagnostics.mojom.RoutineType.kCpuPrime,
+    chromeos.diagnostics.mojom.StandardRoutineResult.kExecutionError
+  ],
+  [
+    chromeos.diagnostics.mojom.RoutineType.kMemory,
+    chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed
+  ],
 ]);
 
-/** @type {!Map<!RoutineName, !BatteryRateRoutineResult>} */
-export const fakeBatteryRoutineResults = new Map([
+/** @type {!Map<!RoutineType, !PowerRoutineResult>} */
+export const fakePowerRoutineResults = new Map([
   [
-    RoutineName.kCharge, {
-      result: StandardRoutineResult.kTestPassed,
+    chromeos.diagnostics.mojom.RoutineType.kBatteryCharge, {
+      result: chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed,
       is_charging: true,
       percent_delta: 5,
       time_delta_seconds: 10
     }
   ],
   [
-    RoutineName.kDischarge, {
-      result: StandardRoutineResult.kUnableToRun,
+    chromeos.diagnostics.mojom.RoutineType.kBatteryDischarge, {
+      result: chromeos.diagnostics.mojom.StandardRoutineResult.kUnableToRun,
       is_charging: false,
       percent_delta: 0,
       time_delta_seconds: 0

chromeos/components/diagnostics_ui/resources/fake_system_routine_controller.js

@@ -5,7 +5,7 @@
 import {assert} from 'chrome://resources/js/assert.m.js';
 import {PromiseResolver} from 'chrome://resources/js/promise_resolver.m.js';
 
-import {BatteryRateRoutineResult, RoutineName, RoutineResult, RoutineResultInfo, RoutineRunner, StandardRoutineResult} from './diagnostics_types.js';
+import {PowerRoutineResult, RoutineResult, RoutineResultInfo, RoutineRunner, RoutineType, StandardRoutineResult, SystemRoutineControllerInterface} from './diagnostics_types.js';
 import {FakeMethodResolver} from './fake_method_resolver.js';
 
 /**
@@ -13,12 +13,13 @@ import {FakeMethodResolver} from './fake_method_resolver.js';
  * Implements a fake version of the SystemRoutineController mojo interface.
  */
 
+/** @implements {SystemRoutineControllerInterface} */
 export class FakeSystemRoutineController {
   constructor() {
     /** @private {!FakeMethodResolver} */
     this.methods_ = new FakeMethodResolver();
 
-    /** private !Map<!RoutineName, !RoutineResult> */
+    /** private !Map<!RoutineType, !RoutineResult> */
     this.routineResults_ = new Map();
 
     /**
@@ -42,17 +43,17 @@ export class FakeSystemRoutineController {
     this.remote_ = null;
 
     /**
-     * Holds the name of the routine currently running.
-     * @private {?RoutineName}
+     * Holds the type of the routine currently running.
+     * @private {?RoutineType}
      */
-    this.routineName_ = null;
+    this.routineType_ = null;
 
     this.registerMethods();
   }
 
   /*
    * Implements SystemRoutineController.GetSupportedRoutines
-   * @return {!Promise<!{routines: !Array<!RoutineName>}>}
+   * @return {!Promise<!{routines: !Array<!RoutineType>}>}
    */
   getSupportedRoutines() {
     return this.methods_.resolveMethod('getSupportedRoutines');
@@ -60,7 +61,7 @@ export class FakeSystemRoutineController {
 
   /**
    * Sets the value that will be returned when calling getSupportedRoutines().
-   * @param {!Array<!RoutineName>} routines
+   * @param {!Array<!RoutineType>} routines
    */
   setFakeSupportedRoutines(routines) {
     this.methods_.setResult('getSupportedRoutines', {routines: routines});
@@ -68,14 +69,14 @@ export class FakeSystemRoutineController {
 
   /*
    * Implements SystemRoutineController.RunRoutine.
-   * @param {!RoutineName} routineName
+   * @param {!RoutineType} routineType
    * @param {!RoutineRunner} remoteRunner
    * @return {!Promise}
    */
-  runRoutine(routineName, remoteRunner) {
+  runRoutine(routineType, remoteRunner) {
     this.resolver_ = new PromiseResolver();
     this.remote_ = remoteRunner;
-    this.routineName_ = routineName;
+    this.routineType_ = routineType;
 
     // If there is a positive or zero delay then setup a timer, otherwise
     // the routine will wait until resolveRoutineForTesting() is called.
@@ -97,20 +98,20 @@ export class FakeSystemRoutineController {
 
   /**
    *
-   * @param {!RoutineName} routineName
+   * @param {!RoutineType} routineType
    * @param {!StandardRoutineResult} routineResult
    */
-  setFakeStandardRoutineResult(routineName, routineResult) {
-    this.routineResults_.set(routineName, {simpleResult: routineResult});
+  setFakeStandardRoutineResult(routineType, routineResult) {
+    this.routineResults_.set(routineType, {simpleResult: routineResult});
   }
 
   /**
    *
-   * @param {!RoutineName} routineName
-   * @param {!BatteryRateRoutineResult} routineResult
+   * @param {!RoutineType} routineType
+   * @param {!PowerRoutineResult} routineResult
    */
-  setFakeBatteryRateRoutineResult(routineName, routineResult) {
-    this.routineResults_.set(routineName, {batteryRateResult: routineResult});
+  setFakePowerRoutineResult(routineType, routineResult) {
+    this.routineResults_.set(routineType, {powerResult: routineResult});
   }
 
   /**
@@ -155,21 +156,23 @@ export class FakeSystemRoutineController {
 
   /**
    * Returns the expected result for a running routine.
-   * @return {RoutineResultInfo}
+   * @return {!RoutineResultInfo}
    * @private
    */
   getResultInfo_() {
-    assert(this.routineName_ != null);
-    let result = this.routineResults_.get(this.routineName_);
+    assert(this.routineType_ != null);
+    let result = this.routineResults_.get(this.routineType_);
     if (result == undefined) {
-      result = {simpleResult: StandardRoutineResult.kErrorExecuting};
+      result = {
+        simpleResult:
+            chromeos.diagnostics.mojom.StandardRoutineResult.kExecutionError
+      };
     }
 
-    /** @type {!RoutineResultInfo} */
-    const resultInfo = {
-      name: this.routineName_,
+    const resultInfo = /** @type {!RoutineResultInfo} */ ({
+      type: this.routineType_,
       result: result,
-    };
+    });
 
     return resultInfo;
   }
@@ -184,6 +187,6 @@ export class FakeSystemRoutineController {
     this.resolver_.resolve();
     this.resolver_ = null;
     this.remote_ = null;
-    this.routineName_ = null;
+    this.routineType_ = null;
   }
 }

chromeos/components/diagnostics_ui/resources/memory_card.js

@@ -14,7 +14,7 @@ import './strings.m.js';
 import {I18nBehavior} from 'chrome://resources/js/i18n_behavior.m.js';
 import {html, Polymer} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
 
-import {MemoryUsage, RoutineName, SystemDataProviderInterface} from './diagnostics_types.js'
+import {MemoryUsage, RoutineType, SystemDataProviderInterface} from './diagnostics_types.js'
 import {getSystemDataProvider} from './mojo_interface_provider.js';
 
 /**
@@ -41,12 +41,12 @@ Polymer({
   memoryUsageObserverReceiver_: null,
 
   properties: {
-    /** @private {!Array<!RoutineName>} */
+    /** @private {!Array<!RoutineType>} */
     routines_: {
       type: Array,
       value: () => {
         return [
-          RoutineName.kMemory,
+          chromeos.diagnostics.mojom.RoutineType.kMemory,
         ];
       }
     },

chromeos/components/diagnostics_ui/resources/mojo_interface_provider.js

@@ -10,8 +10,8 @@ import './system_routine_controller.mojom-lite.js';
 
 import {assert} from 'chrome://resources/js/assert.m.js';
 
-import {BatteryRateRoutineResult, RoutineName, StandardRoutineResult, SystemDataProviderInterface, SystemInfo, SystemRoutineControllerInterface} from './diagnostics_types.js';
-import {fakeBatteryChargeStatus, fakeBatteryHealth, fakeBatteryInfo, fakeBatteryRoutineResults, fakeCpuUsage, fakeMemoryUsage, fakeRoutineResults, fakeSystemInfo} from './fake_data.js';
+import {PowerRoutineResult, RoutineType, StandardRoutineResult, SystemDataProviderInterface, SystemInfo, SystemRoutineControllerInterface} from './diagnostics_types.js';
+import {fakeBatteryChargeStatus, fakeBatteryHealth, fakeBatteryInfo, fakeCpuUsage, fakeMemoryUsage, fakePowerRoutineResults, fakeRoutineResults, fakeSystemInfo} from './fake_data.js';
 import {FakeSystemDataProvider} from './fake_system_data_provider.js';
 import {FakeSystemRoutineController} from './fake_system_routine_controller.js';
 
@@ -21,61 +21,6 @@ import {FakeSystemRoutineController} from './fake_system_routine_controller.js';
  * to override them with test/fake implementations.
  */
 
-/**
- * Sets up a FakeSystemDataProvider to be used at runtime.
- * TODO(zentaro): Remove once mojo bindings are implemented.
- */
-function setupFakeSystemDataProvider_() {
-  // Create provider.
-  let provider = new FakeSystemDataProvider();
-
-  // Setup fake method data.
-  provider.setFakeBatteryChargeStatus(fakeBatteryChargeStatus);
-  provider.setFakeBatteryHealth(fakeBatteryHealth);
-  provider.setFakeBatteryInfo(fakeBatteryInfo);
-  provider.setFakeCpuUsage(fakeCpuUsage);
-  provider.setFakeMemoryUsage(fakeMemoryUsage);
-  provider.setFakeSystemInfo(fakeSystemInfo);
-
-  // Start the timers to generate some observations.
-  provider.startTriggerIntervals();
-
-  // Set the fake provider.
-  setSystemDataProviderForTesting(provider);
-}
-
-/**
- * Sets up a FakeSystemRoutineController to be used at runtime.
- * TODO(zentaro): Remove once mojo bindings are implemented.
- */
-function setupFakeSystemRoutineController_() {
-  // Create controller.
-  let controller = new FakeSystemRoutineController();
-
-  // Add a small delay while running fake routines.
-  controller.setDelayTimeInMillisecondsForTesting(2000);
-
-  // Add fake results for routines.
-  for (const [routine, result] of fakeRoutineResults.entries()) {
-    controller.setFakeStandardRoutineResult(
-        /** @type{!RoutineName} */ (routine),
-        /** @type{!StandardRoutineResult} */ (result));
-  }
-
-  for (const [routine, result] of fakeBatteryRoutineResults.entries()) {
-    controller.setFakeBatteryRateRoutineResult(
-        /** @type {!RoutineName} */ (routine),
-        /** @type {!BatteryRateRoutineResult} */ (result));
-  }
-
-  // Enable fake set of routines.
-  controller.setFakeSupportedRoutines(
-      [...fakeRoutineResults.keys(), ...fakeBatteryRoutineResults.keys()]);
-
-  // Set the fake controller.
-  setSystemRoutineControllerForTesting(controller);
-}
-
 /**
  * @type {?SystemDataProviderInterface}
  */
@@ -118,8 +63,8 @@ export function setSystemRoutineControllerForTesting(testController) {
  */
 export function getSystemRoutineController() {
   if (!systemRoutineController) {
-    // TODO(zentaro): Instantiate a real mojo interface here.
-    setupFakeSystemRoutineController_();
+    systemRoutineController =
+        chromeos.diagnostics.mojom.SystemRoutineController.getRemote();
   }
 
   assert(!!systemRoutineController);

chromeos/components/diagnostics_ui/resources/routine_list_executor.js

@@ -4,7 +4,8 @@
 
 import {assert} from 'chrome://resources/js/assert.m.js';
 import {PromiseResolver} from 'chrome://resources/js/promise_resolver.m.js';
-import {RoutineName, RoutineResult, RoutineResultInfo, SystemRoutineControllerInterface} from './diagnostics_types.js';
+
+import {RoutineResult, RoutineResultInfo, RoutineRunner, RoutineType, SystemRoutineControllerInterface} from './diagnostics_types.js';
 
 /**
  * Represents the execution progress of a test routine.
@@ -23,7 +24,7 @@ export let ExecutionProgress = {
  */
 export class ResultStatusItem {
   constructor(routine) {
-    /** @type {!RoutineName} */
+    /** @type {!RoutineType} */
     this.routine = routine;
 
     /** @type {!ExecutionProgress} */
@@ -48,6 +49,10 @@ class ExecutionContext {
   constructor() {
     /** @private {!PromiseResolver} */
     this.resolver_ = new PromiseResolver();
+
+    this.routineRunner = new chromeos.diagnostics.mojom.RoutineRunnerReceiver(
+        /** @type {!chromeos.diagnostics.mojom.RoutineRunnerInterface} */ (
+            this));
   }
 
   /**
@@ -56,11 +61,16 @@ class ExecutionContext {
    **/
   onRoutineResult(result) {
     this.resolver_.resolve(result);
+    this.close();
   }
 
   whenComplete() {
     return this.resolver_.promise;
   }
+
+  close() {
+    this.routineRunner.$.close();
+  }
 }
 
 /**
@@ -75,13 +85,16 @@ export class RoutineListExecutor {
   constructor(routineController) {
     /** @private {!SystemRoutineControllerInterface} */
     this.routineController_ = routineController;
+
+    /** @private {?ExecutionContext} */
+    this.currentExecutionContext_ = null;
   }
 
   /*
    * Executes a list of routines providing a status callback as each test
    * starts and finishes. The return promise will resolve when all tests are
    * completed.
-   * @param {!Array<!RoutineName>} routines
+   * @param {!Array<!RoutineType>} routines
    * @type {!function(!ResultStatusItem)} statusCallback
    * @param {!Promise}
    */
@@ -98,22 +111,31 @@ export class RoutineListExecutor {
         status.progress = ExecutionProgress.kRunning;
         statusCallback(status);
 
+        this.currentExecutionContext_ = new ExecutionContext();
         // Create a new remote and execute the next test.
-        let test = new ExecutionContext();
-        return this.routineController_.runRoutine(name, test).then(() => {
-          // When the test completes, notify the status callback of the
-          // result.
-          return test.whenComplete().then((info) => {
-            assert(info.name === name);
-            const status = new ResultStatusItem(name);
-            status.progress = ExecutionProgress.kCompleted;
-            status.result = info.result;
-            statusCallback(status);
-          });
+        this.routineController_.runRoutine(
+            name,
+            this.currentExecutionContext_.routineRunner.$
+                .bindNewPipeAndPassRemote());
+
+        // When the test completes, notify the status callback of the
+        // result.
+        return this.currentExecutionContext_.whenComplete().then((info) => {
+          assert(info.type === name);
+          const status = new ResultStatusItem(name);
+          status.progress = ExecutionProgress.kCompleted;
+          status.result = info.result;
+          statusCallback(status);
         });
       });
     });
 
     return promise;
   }
+
+  close() {
+    if (this.currentExecutionContext_) {
+      this.currentExecutionContext_.close();
+    }
+  }
 }

chromeos/components/diagnostics_ui/resources/routine_result_entry.html

@@ -8,7 +8,7 @@
 
 <div class="entryRow">
   <!-- TODO(zentaro): Create mapping to localized strings. -->
-  <div id="routine">[[routineName_]]</div>
+  <div id="routine">[[routineType_]]</div>
   <text-badge id="status" badge-type="[[getBadgeType_(item.progress, item.result)]]"
   		value="[[getBadgeText_(item.progress, item.result)]]"
   		hidden="[[!isTestStarted_(item.progress)]]">

chromeos/components/diagnostics_ui/resources/routine_result_entry.js

@@ -9,30 +9,31 @@ import './text_badge.js';
 import {assert, assertNotReached} from 'chrome://resources/js/assert.m.js';
 import {loadTimeData} from 'chrome://resources/js/load_time_data.m.js';
 import {html, Polymer} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
-import {RoutineName, RoutineResult, StandardRoutineResult} from './diagnostics_types.js';
+
+import {RoutineResult, RoutineType, StandardRoutineResult} from './diagnostics_types.js';
 import {ExecutionProgress, ResultStatusItem} from './routine_list_executor.js';
 import {BadgeType} from './text_badge.js';
 
 /**
  * Resolves a routine name to its corresponding localized string name.
- * @param {!RoutineName} routineName
+ * @param {!RoutineType} routineType
  * @return {string}
  */
-export function getRoutineName(routineName) {
-  switch (routineName) {
-    case RoutineName.kCharge:
+export function getRoutineType(routineType) {
+  switch (routineType) {
+    case chromeos.diagnostics.mojom.RoutineType.kBatteryCharge:
       return loadTimeData.getString('batteryChargeRoutineText');
-    case RoutineName.kDischarge:
+    case chromeos.diagnostics.mojom.RoutineType.kBatteryDischarge:
       return loadTimeData.getString('batteryDischargeRoutineText');
-    case RoutineName.kCpuCache:
+    case chromeos.diagnostics.mojom.RoutineType.kCpuCache:
       return loadTimeData.getString('cpuCacheRoutineText');
-    case RoutineName.kCpuStress:
+    case chromeos.diagnostics.mojom.RoutineType.kCpuStress:
       return loadTimeData.getString('cpuStressRoutineText');
-    case RoutineName.kFloatingPoint:
+    case chromeos.diagnostics.mojom.RoutineType.kCpuFloatingPoint:
       return loadTimeData.getString('cpuFloatingPointAccuracyRoutineText');
-    case RoutineName.kPrimeSearch:
+    case chromeos.diagnostics.mojom.RoutineType.kCpuPrime:
       return loadTimeData.getString('cpuPrimeSearchRoutineText');
-    case RoutineName.kMemory:
+    case chromeos.diagnostics.mojom.RoutineType.kMemory:
       return loadTimeData.getString('memoryRoutineText');
     default:
       // Values should always be found in the enum.
@@ -57,19 +58,21 @@ Polymer({
     },
 
     /** @private */
-    routineName_: {
+    routineType_: {
       type: String,
       computed: 'getRunningRoutineString_(item.routine)',
     },
   },
+
   /**
    * Get the localized string name for the routine.
-   * @param {!RoutineName} routine
+   * @param {!RoutineType} routine
    * @return {string}
    */
   getRunningRoutineString_(routine) {
-    return loadTimeData.getStringF('routineNameText', getRoutineName(routine));
+    return loadTimeData.getStringF('routineNameText', getRoutineType(routine));
   },
+
   /**
    * @param {!RoutineResult} result
    * @return {!StandardRoutineResult}
@@ -83,9 +86,9 @@ Polymer({
       return /** @type {!StandardRoutineResult} */ (result.simpleResult);
     }
 
-    if (result.hasOwnProperty('batteryRateResult')) {
+    if (result.hasOwnProperty('powerResult')) {
       return /** @type {!StandardRoutineResult} */ (
-          result.batteryRateResult.result);
+          result.powerResult.simpleResult);
     }
 
     assertNotReached();
@@ -102,7 +105,7 @@ Polymer({
 
     if (this.item.result &&
         this.getSimpleResult_(this.item.result) ===
-            StandardRoutineResult.kTestPassed) {
+            chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed) {
       return 'SUCCESS';
     }
 
@@ -120,7 +123,7 @@ Polymer({
 
     if (this.item.result &&
         this.getSimpleResult_(this.item.result) ===
-            StandardRoutineResult.kTestPassed) {
+            chromeos.diagnostics.mojom.StandardRoutineResult.kTestPassed) {
       return BadgeType.SUCCESS;
     }
     return BadgeType.ERROR;

chromeos/components/diagnostics_ui/resources/routine_result_list.js

@@ -8,7 +8,7 @@ import './routine_result_entry.js';
 
 import {assert} from 'chrome://resources/js/assert.m.js';
 import {html, Polymer} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
-import {RoutineName} from './diagnostics_types.js';
+import {RoutineType} from './diagnostics_types.js';
 import {ResultStatusItem} from './routine_list_executor.js'
 
 /**
@@ -38,7 +38,7 @@ Polymer({
    * Resets the list and creates a new list with all routines in the unstarted
    * state. Called by the parent RoutineResultSection when the user starts
    * a test run.
-   * @param {!Array<!RoutineName>} routines
+   * @param {!Array<!RoutineType>} routines
    */
   initializeTestRun(routines) {
     this.clearRoutines();
@@ -56,7 +56,7 @@ Polymer({
 
   /**
    * Add a new unstarted routine to the end of the list.
-   * @param {!RoutineName} routine
+   * @param {!RoutineType} routine
    * @private
    */
   addRoutine_(routine) {

chromeos/components/diagnostics_ui/resources/routine_section.js

@@ -13,10 +13,10 @@ import {I18nBehavior} from 'chrome://resources/js/i18n_behavior.m.js';
 import {loadTimeData} from 'chrome://resources/js/load_time_data.m.js';
 import {html, Polymer} from 'chrome://resources/polymer/v3_0/polymer/polymer_bundled.min.js';
 
-import {RoutineName, StandardRoutineResult, SystemRoutineControllerInterface} from './diagnostics_types.js';
+import {RoutineType, StandardRoutineResult, SystemRoutineControllerInterface} from './diagnostics_types.js';
 import {getSystemRoutineController} from './mojo_interface_provider.js';
 import {ExecutionProgress, RoutineListExecutor} from './routine_list_executor.js';
-import {getRoutineName} from './routine_result_entry.js';
+import {getRoutineType} from './routine_result_entry.js';
 import {BadgeType} from './text_badge.js';
 
 /**
@@ -48,7 +48,7 @@ Polymer({
   systemRoutineController_: null,
 
   properties: {
-    /** @type {!Array<!RoutineName>} */
+    /** @type {!Array<!RoutineType>} */
     routines: {
       type: Array,
       value: () => [],
@@ -113,11 +113,12 @@ Polymer({
               filteredRoutines,
               (status) => {
                 this.currentTestName_ = loadTimeData.getStringF(
-                    'routineNameText', getRoutineName(status.routine));
+                    'routineNameText', getRoutineType(status.routine));
 
                 if (status.result &&
                     status.result.simpleResult !==
-                        StandardRoutineResult.kTestPassed) {
+                        chromeos.diagnostics.mojom.StandardRoutineResult
+                            .kTestPassed) {
                   this.hasTestFailure_ = true;
                 }
 
@@ -125,12 +126,21 @@ Polymer({
               })
           .then(() => {
             this.executionStatus_ = ExecutionProgress.kCompleted;
-            this.systemRoutineController_ = null;
             this.isTestRunning = false;
+            this.cleanUp_();
           });
     });
   },
 
+  /** @private */
+  cleanUp_() {
+    if (this.executor_) {
+      this.executor_.close();
+      this.executor_ = null;
+    }
+    this.systemRoutineController_ = null;
+  },
+
   /** @private */
   onToggleReportClicked_() {
     // Toggle report list visibility
@@ -182,6 +192,11 @@ Polymer({
     return this.hasTestFailure_ ? 'Test failed' : 'Test succeeded';
   },
 
+  /** @override */
+  detached() {
+    this.cleanUp_();
+  },
+
   /** @override */
   created() {},
 });