Simplify CommandLine parameterizing J3 Instrumentation Tests

build/android/pylib/local/device/local_device_instrumentation_test_run.py

 # Copyright 2015 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import contextlib
 import logging
 import os
 import posixpath
 import re
 import sys
@@ skipping 301 matching lines @@
 
   #override
   def _GetUniqueTestName(self, test):
     return instrumentation_test_instance.GetUniqueTestName(test)
 
   #override
   def _RunTest(self, device, test):
     extras = {}
 
     flags_to_add = []
-    flags_to_remove = []
     test_timeout_scale = None
     if self._test_instance.coverage_directory:
       coverage_basename = '%s.ec' % ('%s_group' % test[0]['method']
           if isinstance(test, list) else test['method'])
       extras['coverage'] = 'true'
       coverage_directory = os.path.join(
           device.GetExternalStoragePath(), 'chrome', 'test', 'coverage')
       coverage_device_file = os.path.join(
           coverage_directory, coverage_basename)
       extras['coverageFile'] = coverage_device_file
@@ skipping 35 matching lines @@
       test_name = instrumentation_test_instance.GetTestName(test)
       test_display_name = self._GetUniqueTestName(test)
       if test['is_junit4']:
         target = '%s/%s' % (
             self._test_instance.test_package,
             self._test_instance.test_runner_junit4)
       else:
         target = '%s/%s' % (
             self._test_instance.test_package, self._test_instance.test_runner)
       extras['class'] = test_name
-      if 'flags' in test:
-        flags_to_add.extend(test['flags'].add)
-        flags_to_remove.extend(test['flags'].remove)
+      if 'flags' in test and test['flags']:
+        flags_to_add.extend(test['flags'])
       timeout = self._GetTimeoutFromAnnotations(
         test['annotations'], test_display_name)
 
       test_timeout_scale = self._GetTimeoutScaleFromAnnotations(
           test['annotations'])
       if test_timeout_scale and test_timeout_scale != 1:
         valgrind_tools.SetChromeTimeoutScale(
             device, test_timeout_scale * self._test_instance.timeout_scale)
 
     logging.info('preparing to run %s: %s', test_display_name, test)
 
     render_tests_device_output_dir = None
     if _IsRenderTest(test):
       # TODO(mikecase): Add DeviceTempDirectory class and use that instead.
       render_tests_device_output_dir = posixpath.join(
           device.GetExternalStoragePath(),
           'render_test_output_dir')
       flags_to_add.append('--render-test-output-dir=%s' %
                           render_tests_device_output_dir)
 
-    if flags_to_add or flags_to_remove:
+    if flags_to_add:
       self._CreateFlagChangerIfNeeded(device)
-      self._flag_changers[str(device)].PushFlags(
-        add=flags_to_add, remove=flags_to_remove)
+      self._flag_changers[str(device)].PushFlags(add=flags_to_add)
 
     time_ms = lambda: int(time.time() * 1e3)
     start_ms = time_ms()
 
     stream_name = 'logcat_%s_%s_%s' % (
         test_name.replace('#', '.'),
         time.strftime('%Y%m%dT%H%M%S-UTC', time.gmtime()),
         device.serial)
     logmon = logdog_logcat_monitor.LogdogLogcatMonitor(
         device.adb, stream_name, filter_specs=LOGCAT_FILTERS)
 
     with contextlib_ext.Optional(
         logmon, self._test_instance.should_save_logcat):
       with _LogTestEndpoints(device, test_name):
         with contextlib_ext.Optional(
             trace_event.trace(test_name),
             self._env.trace_output):
           output = device.StartInstrumentation(
               target, raw=True, extras=extras, timeout=timeout, retries=0)
 
     logcat_url = logmon.GetLogcatURL()
     duration_ms = time_ms() - start_ms
-    if flags_to_add or flags_to_remove:
+    if flags_to_add:
       self._flag_changers[str(device)].Restore()
     if test_timeout_scale:
       valgrind_tools.SetChromeTimeoutScale(
           device, self._test_instance.timeout_scale)
 
     # TODO(jbudorick): Make instrumentation tests output a JSON so this
     # doesn't have to parse the output.
     result_code, result_bundle, statuses = (
         self._test_instance.ParseAmInstrumentRawOutput(output))
     results = self._test_instance.GenerateTestResults(
         result_code, result_bundle, statuses, start_ms, duration_ms)
     for result in results:
       if logcat_url:
         result.SetLink('logcat', logcat_url)
 
     if _IsRenderTest(test):
       # Render tests do not cause test failure by default. So we have to check
       # to see if any failure images were generated even if the test does not
       # fail.
       try:
         self._ProcessRenderTestResults(
             device, render_tests_device_output_dir, results)
       finally:
         device.RemovePath(render_tests_device_output_dir,
                           recursive=True, force=True)
 
     # Update the result name if the test used flags.
-    if flags_to_add or flags_to_remove:
+    if flags_to_add:
       for r in results:
         if r.GetName() == test_name:
           r.SetName(test_display_name)
 
     # Add UNKNOWN results for any missing tests.
     iterable_test = test if isinstance(test, list) else [test]
     test_names = set(self._GetUniqueTestName(t) for t in iterable_test)
     results_names = set(r.GetName() for r in results)
     results.extend(
         base_test_result.BaseTestResult(u, base_test_result.ResultType.UNKNOWN)
@@ skipping 223 matching lines @@
     timeout *= cls._GetTimeoutScaleFromAnnotations(annotations)
 
     return timeout
 
 def _IsRenderTest(test):
   """Determines if a test or list of tests has a RenderTest amongst them."""
   if not isinstance(test, list):
     test = [test]
   return any([RENDER_TEST_FEATURE_ANNOTATION in t['annotations'].get(
               FEATURE_ANNOTATION, {}).get('value', ()) for t in test])