Add CommandLineArgumentParameter and use it for WebView 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 logging
 import re
 import time
 
 from devil.android import device_errors
 from pylib import flag_changer
@@ skipping 67 matching lines @@
       logging.info('instrumentation data deps:')
       for h, d in host_device_tuples:
         logging.info('%r -> %r', h, d)
       dev.PushChangedFiles(host_device_tuples)
       if self._test_instance.flags:
         if not self._test_instance.package_info:
           logging.error("Couldn't set flags: no package info")
         elif not self._test_instance.package_info.cmdline_file:
           logging.error("Couldn't set flags: no cmdline_file")
         else:
-          self._flag_changers[str(dev)] = flag_changer.FlagChanger(
-              dev, self._test_instance.package_info.cmdline_file)
+          self._CreateFlagChangerIfNeeded(dev)
           logging.debug('Attempting to set flags: %r',
                         self._test_instance.flags)
           self._flag_changers[str(dev)].AddFlags(self._test_instance.flags)
 
     self._env.parallel_devices.pMap(
         individual_device_set_up,
         self._test_instance.GetDataDependencies())
 
   def TearDown(self):
     def individual_device_tear_down(dev):
       if str(dev) in self._flag_changers:
         self._flag_changers[str(dev)].Restore()
 
     self._env.parallel_devices.pMap(individual_device_tear_down)
 
+  def _CreateFlagChangerIfNeeded(self, device):
+    if not str(device) in self._flag_changers:
+      self._flag_changers[str(device)] = flag_changer.FlagChanger(
+        device, self._test_instance.package_info.cmdline_file)
+
   #override
   def _CreateShards(self, tests):
     return tests
 
   #override
   def _GetTests(self):
     return self._test_instance.GetTests()
 
   #override
   def _GetTestName(self, test):
     return '%s#%s' % (test['class'], test['method'])
 
+  def _GetTestNameForDisplay(self, test):
+    display_name = self._GetTestName(test)
+    flags = test['flags']
+    if flags.add:
+      display_name = '%s with {%s}' % (display_name, ' '.join(flags.add))
+    if flags.remove:
+      display_name = '%s without {%s}' % (display_name, ' '.join(flags.remove))
+    return display_name
+
   #override
   def _RunTest(self, device, test):
     extras = self._test_instance.GetHttpServerEnvironmentVars()
 
+    flags = None
     if isinstance(test, list):
       if not self._test_instance.driver_apk:
         raise Exception('driver_apk does not exist. '
                         'Please build it and try again.')
 
       def name_and_timeout(t):
         n = self._GetTestName(t)
         i = self._GetTimeoutFromAnnotations(t['annotations'], n)
         return (n, i)
 
       test_names, timeouts = zip(*(name_and_timeout(t) for t in test))
 
       test_name = ','.join(test_names)
+      test_display_name = test_name
       target = '%s/%s' % (
           self._test_instance.driver_package,
           self._test_instance.driver_name)
       extras.update(
           self._test_instance.GetDriverEnvironmentVars(
               test_list=test_names))
       timeout = sum(timeouts)
     else:
       test_name = self._GetTestName(test)
+      test_display_name = test_name
       target = '%s/%s' % (
           self._test_instance.test_package, self._test_instance.test_runner)
       extras['class'] = test_name
-      timeout = self._GetTimeoutFromAnnotations(test['annotations'], test_name)
+      if 'flags' in test:
+        flags = test['flags']
+        test_display_name = self._GetTestNameForDisplay(test)
+      timeout = self._GetTimeoutFromAnnotations(
+        test['annotations'], test_display_name)
 
-    logging.info('preparing to run %s: %s', test_name, test)
+    logging.info('preparing to run %s: %s', test_display_name, test)
 
-    time_ms = lambda: int(time.time() * 1e3)
-    start_ms = time_ms()
-    output = device.StartInstrumentation(
-        target, raw=True, extras=extras, timeout=timeout, retries=0)
-    duration_ms = time_ms() - start_ms
+    if flags:
+      self._CreateFlagChangerIfNeeded(device)
+      self._flag_changers[str(device)].PushFlags(
+        add=flags.add, remove=flags.remove)
+
+    try:
+      time_ms = lambda: int(time.time() * 1e3)
+      start_ms = time_ms()
+      output = device.StartInstrumentation(
+          target, raw=True, extras=extras, timeout=timeout, retries=0)
+      duration_ms = time_ms() - start_ms
+    finally:
+      if flags:
+        self._flag_changers[str(device)].Restore()
 
     # TODO(jbudorick): Make instrumentation tests output a JSON so this
     # doesn't have to parse the output.
-    logging.debug('output from %s:', test_name)
+    logging.debug('output from %s:', test_display_name)
     for l in output:
       logging.debug('  %s', l)
 
     result_code, result_bundle, statuses = (
         self._test_instance.ParseAmInstrumentRawOutput(output))
     results = self._test_instance.GenerateTestResults(
         result_code, result_bundle, statuses, start_ms, duration_ms)
+    if flags:
+      for r in results:
+        if r.GetName() == test_name:
+          r.SetName(test_display_name)
     if DidPackageCrashOnDevice(self._test_instance.test_package, device):
       for r in results:
         if r.GetType() == base_test_result.ResultType.UNKNOWN:
           r.SetType(base_test_result.ResultType.CRASH)
     # TODO(jbudorick): ClearApplicationState on failure before switching
     # instrumentation tests to platform mode.
     return results
 
   #override
   def _ShouldShard(self):
@@ skipping 11 matching lines @@
 
     try:
       scale = int(annotations.get('TimeoutScale', 1))
     except ValueError as e:
       logging.warning("Non-integer value of TimeoutScale ignored. (%s)", str(e))
       scale = 1
     timeout *= scale
 
     return timeout