Remove unused record and replay functionality.

tools/testing/dart/test_runner.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 /**
  * Classes and methods for executing tests.
  *
  * This module includes:
  * - Managing parallel execution of tests, including timeout checks.
  * - Evaluating the output of each test as pass/fail/crash/timeout.
  */
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 // We need to use the 'io' prefix here, otherwise io.exitCode will shadow
 // CommandOutput.exitCode in subclasses of CommandOutput.
 import 'dart:io' as io;
 import 'dart:math' as math;
 
 import 'android.dart';
 import 'browser_controller.dart';
 import 'configuration.dart';
 import 'dependency_graph.dart' as dgraph;
 import 'expectation.dart';
 import 'path.dart';
-import 'record_and_replay.dart';
 import 'runtime_configuration.dart';
 import 'test_progress.dart';
 import 'test_suite.dart';
 import 'utils.dart';
 
 const int CRASHING_BROWSER_EXITCODE = -10;
 const int SLOW_TIMEOUT_MULTIPLIER = 4;
 const int NON_UTF_FAKE_EXITCODE = 0xFFFD;
 
 const MESSAGE_CANNOT_OPEN_DISPLAY = 'Gtk-WARNING **: cannot open display';
@@ skipping 2848 matching lines @@
       if (globalConfiguration.isVerbose) {
         testRunner.logger = DebugLogger.info;
       }
       _browserTestRunners[configuration] = testRunner;
       await testRunner.start();
     }
     return _browserTestRunners[configuration];
   }
 }
 
-class RecordingCommandExecutor implements CommandExecutor {
-  TestCaseRecorder _recorder;
-
-  RecordingCommandExecutor(Path path) : _recorder = new TestCaseRecorder(path);
-
-  Future<CommandOutput> runCommand(node, ProcessCommand command, int timeout) {
-    assert(node.dependencies.length == 0);
-    assert(_cleanEnvironmentOverrides(command.environmentOverrides));
-    _recorder.nextCommand(command, timeout);
-    // Return dummy CommandOutput
-    var output =
-        createCommandOutput(command, 0, false, [], [], const Duration(), false);
-    return new Future.value(output);
-  }
-
-  Future cleanup() {
-    _recorder.finish();
-    return new Future.value();
-  }
-
-  // Returns [:true:] if the environment contains only 'DART_CONFIGURATION'
-  bool _cleanEnvironmentOverrides(Map environment) {
-    if (environment == null) return true;
-    return environment.length == 0 ||
-        (environment.length == 1 &&
-            environment.containsKey("DART_CONFIGURATION"));
-  }
-}
-
-class ReplayingCommandExecutor implements CommandExecutor {
-  TestCaseOutputArchive _archive = new TestCaseOutputArchive();
-
-  ReplayingCommandExecutor(Path path) {
-    _archive.loadFromPath(path);
-  }
-
-  Future cleanup() => new Future.value();
-
-  Future<CommandOutput> runCommand(node, ProcessCommand command, int timeout) {
-    assert(node.dependencies.length == 0);
-    return new Future.value(_archive.outputOf(command));
-  }
-}
-
 bool shouldRetryCommand(CommandOutput output) {
   if (!output.successful) {
     List<String> stdout, stderr;
 
     decodeOutput() {
       if (stdout == null && stderr == null) {
         stdout = decodeUtf8(output.stderr).split("\n");
         stderr = decodeUtf8(output.stderr).split("\n");
       }
     }
@@ skipping 160 matching lines @@
 
   ProcessQueue(
       this._globalConfiguration,
       int maxProcesses,
       int maxBrowserProcesses,
       DateTime startTime,
       List<TestSuite> testSuites,
       this._eventListener,
       this._allDone,
       [bool verbose = false,
-      String recordingOutputFile,
-      String recordedInputFile,
       AdbDevicePool adbDevicePool]) {
     void setupForListing(TestCaseEnqueuer testCaseEnqueuer) {
       _graph.events
           .where((event) => event is dgraph.GraphSealedEvent)
           .listen((_) {
         var testCases = testCaseEnqueuer.remainingTestCases.toList();
         testCases.sort((a, b) => a.displayName.compareTo(b.displayName));
 
         print("\nGenerating all matching test cases ....\n");
 
@@ skipping 60 matching lines @@
               print("");
             }
           }
 
           if (commandQueue != null) {
             commandQueue.dumpState();
           }
         });
       }
 
-      bool recording = recordingOutputFile != null;
-      bool replaying = recordedInputFile != null;
-
       // When the graph building is finished, notify event listeners.
       _graph.events
           .where((event) => event is dgraph.GraphSealedEvent)
           .listen((event) {
         eventAllTestsKnown();
       });
 
       // Queue commands as they become "runnable"
       new CommandEnqueuer(_graph);
 
       // CommandExecutor will execute commands
-      CommandExecutor executor;
-      if (recording) {
-        executor = new RecordingCommandExecutor(new Path(recordingOutputFile));
-      } else if (replaying) {
-        executor = new ReplayingCommandExecutor(new Path(recordedInputFile));
-      } else {
-        executor = new CommandExecutorImpl(
-            _globalConfiguration, maxProcesses, maxBrowserProcesses,
-            adbDevicePool: adbDevicePool);
-      }
+      var executor = new CommandExecutorImpl(
+          _globalConfiguration, maxProcesses, maxBrowserProcesses,
+          adbDevicePool: adbDevicePool);
 
       // Run "runnable commands" using [executor] subject to
       // maxProcesses/maxBrowserProcesses constraint
       commandQueue = new CommandQueue(_graph, testCaseEnqueuer, executor,
           maxProcesses, maxBrowserProcesses, verbose);
 
       // Finish test cases when all commands were run (or some failed)
       var testCaseCompleter =
           new TestCaseCompleter(_graph, testCaseEnqueuer, commandQueue);
       testCaseCompleter.finishedTestCases.listen((TestCase finishedTestCase) {
         resetDebugTimer();
 
-        // If we're recording, we don't report any TestCases to listeners.
-        if (!recording) {
-          eventFinishedTestCase(finishedTestCase);
-        }
+        eventFinishedTestCase(finishedTestCase);
       }, onDone: () {
         // Wait until the commandQueue/exectutor is done (it may need to stop
         // batch runners, browser controllers, ....)
         commandQueue.done.then((_) {
           cancelDebugTimer();
           eventAllTestsDone();
         });
       });
 
       resetDebugTimer();
@@ skipping 38 matching lines @@
     }
   }
 
   void eventAllTestsDone() {
     for (var listener in _eventListener) {
       listener.allDone();
     }
     _allDone();
   }
 }