[Android] Push gtest deps in gtest/setup.py.

build/android/pylib/valgrind_tools.py

 # Copyright (c) 2012 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.
 
 """
 Classes in this file define additional actions that need to be taken to run a
 test under some kind of runtime error detection tool.
 
 The interface is intended to be used as follows.
 
 1. For tests that simply run a native process (i.e. no activity is spawned):
 
-Call tool.CopyFiles().
+Call tool.CopyFiles(device).
 Prepend test command line with tool.GetTestWrapper().
 
 2. For tests that spawn an activity:
 
-Call tool.CopyFiles().
+Call tool.CopyFiles(device).
 Call tool.SetupEnvironment().
 Run the test as usual.
 Call tool.CleanUpEnvironment().
 """
 # pylint: disable=R0201
 
 import glob
 import logging
 import os.path
 import subprocess
@@ skipping 26 matching lines @@
 
   def GetUtilWrapper(self):
     """Returns the wrapper name for the utilities.
 
     Returns:
        A string that is to be prepended to the command line of utility
     processes (forwarder, etc.).
     """
     return ''
 
-  def CopyFiles(self):
+  @classmethod
+  def CopyFiles(cls, device):
     """Copies tool-specific files to the device, create directories, etc."""
     pass
 
   def SetupEnvironment(self):
     """Sets up the system environment for a test.
 
     This is a good place to set system properties.
     """
     pass
 
@@ skipping 23 matching lines @@
   # nothing we can do about that.
   EXTRA_OPTIONS = 'strict_memcmp=0,use_sigaltstack=1'
 
   def __init__(self, device):
     super(AddressSanitizerTool, self).__init__()
     self._device = device
     # Configure AndroidCommands to run utils (such as md5sum_bin) under ASan.
     # This is required because ASan is a compiler-based tool, and md5sum
     # includes instrumented code from base.
     device.old_interface.SetUtilWrapper(self.GetUtilWrapper())
+
+  @classmethod
+  def CopyFiles(cls, device):
+    """Copies ASan tools to the device."""
     libs = glob.glob(os.path.join(DIR_SOURCE_ROOT,
                                   'third_party/llvm-build/Release+Asserts/',
                                   'lib/clang/*/lib/linux/',
                                   'libclang_rt.asan-arm-android.so'))
     assert len(libs) == 1
-    self._lib = libs[0]
-
-  def CopyFiles(self):
-    """Copies ASan tools to the device."""
     subprocess.call([os.path.join(DIR_SOURCE_ROOT,
                                   'tools/android/asan/asan_device_setup.sh'),
-                     '--device', str(self._device),
-                     '--lib', self._lib,
+                     '--device', str(device),
+                     '--lib', libs[0],
                      '--extra-options', AddressSanitizerTool.EXTRA_OPTIONS])
-    self._device.WaitUntilFullyBooted()
+    device.WaitUntilFullyBooted()
 
   def GetTestWrapper(self):
     return AddressSanitizerTool.WRAPPER_NAME
 
   def GetUtilWrapper(self):
     """Returns the wrapper for utilities, such as forwarder.
 
     AddressSanitizer wrapper must be added to all instrumented binaries,
     including forwarder and the like. This can be removed if such binaries
     were built without instrumentation. """
@@ skipping 23 matching lines @@
   VG_DIR = '/data/local/tmp/valgrind'
   VGLOGS_DIR = '/data/local/tmp/vglogs'
 
   def __init__(self, device):
     super(ValgrindTool, self).__init__()
     self._device = device
     # exactly 31 chars, SystemProperties::PROP_NAME_MAX
     self._wrap_properties = ['wrap.com.google.android.apps.ch',
                              'wrap.org.chromium.native_test']
 
-  def CopyFiles(self):
+  @classmethod
+  def CopyFiles(cls, device):
     """Copies Valgrind tools to the device."""
-    self._device.RunShellCommand(
+    device.RunShellCommand(
         'rm -r %s; mkdir %s' % (ValgrindTool.VG_DIR, ValgrindTool.VG_DIR))
-    self._device.RunShellCommand(
+    device.RunShellCommand(
         'rm -r %s; mkdir %s' % (ValgrindTool.VGLOGS_DIR,
                                 ValgrindTool.VGLOGS_DIR))
-    files = self.GetFilesForTool()
-    self._device.PushChangedFiles(
+    files = cls.GetFilesForTool()
+    device.PushChangedFiles(
         [((os.path.join(DIR_SOURCE_ROOT, f),
           os.path.join(ValgrindTool.VG_DIR, os.path.basename(f)))
          for f in files)])
 
   def SetupEnvironment(self):
     """Sets up device environment."""
     self._device.RunShellCommand('chmod 777 /data/local/tmp')
     self._device.RunShellCommand('setenforce 0')
     for prop in self._wrap_properties:
       self._device.RunShellCommand(
           'setprop %s "logwrapper %s"' % (prop, self.GetTestWrapper()))
     SetChromeTimeoutScale(self._device, self.GetTimeoutScale())
 
   def CleanUpEnvironment(self):
     """Cleans up device environment."""
     for prop in self._wrap_properties:
       self._device.RunShellCommand('setprop %s ""' % (prop,))
     SetChromeTimeoutScale(self._device, None)
 
-  def GetFilesForTool(self):
+  @staticmethod
+  def GetFilesForTool():
     """Returns a list of file names for the tool."""
     raise NotImplementedError()
 
   def NeedsDebugInfo(self):
     """Whether this tool requires debug info.
 
     Returns:
       True if this tool can not work with stripped binaries.
     """
     return True
 
 
 class MemcheckTool(ValgrindTool):
   """Memcheck tool."""
 
   def __init__(self, device):
     super(MemcheckTool, self).__init__(device)
 
-  def GetFilesForTool(self):
+  @staticmethod
+  def GetFilesForTool():
     """Returns a list of file names for the tool."""
     return ['tools/valgrind/android/vg-chrome-wrapper.sh',
             'tools/valgrind/memcheck/suppressions.txt',
             'tools/valgrind/memcheck/suppressions_android.txt']
 
   def GetTestWrapper(self):
     """Returns a string that is to be prepended to the test command line."""
     return ValgrindTool.VG_DIR + '/' + 'vg-chrome-wrapper.sh'
 
   def GetTimeoutScale(self):
     """Returns a multiplier that should be applied to timeout values."""
     return 30
 
 
 class TSanTool(ValgrindTool):
   """ThreadSanitizer tool. See http://code.google.com/p/data-race-test ."""
 
   def __init__(self, device):
     super(TSanTool, self).__init__(device)
 
-  def GetFilesForTool(self):
+  @staticmethod
+  def GetFilesForTool():
     """Returns a list of file names for the tool."""
     return ['tools/valgrind/android/vg-chrome-wrapper-tsan.sh',
             'tools/valgrind/tsan/suppressions.txt',
             'tools/valgrind/tsan/suppressions_android.txt',
             'tools/valgrind/tsan/ignores.txt']
 
   def GetTestWrapper(self):
     """Returns a string that is to be prepended to the test command line."""
     return ValgrindTool.VG_DIR + '/' + 'vg-chrome-wrapper-tsan.sh'
 
@@ skipping 23 matching lines @@
   if not tool_name:
     return BaseTool()
 
   ctor = TOOL_REGISTRY.get(tool_name)
   if ctor:
     return ctor(device)
   else:
     print 'Unknown tool %s, available tools: %s' % (
         tool_name, ', '.join(sorted(TOOL_REGISTRY.keys())))
     sys.exit(1)
+
+def PushFilesForTool(tool_name, device):
+  """Pushes the files required for |tool_name| to |device|.
+
+  Args:
+    tool_name: Name of the tool to create.
+    device: A DeviceUtils instance.
+  """
+  if not tool_name:
+    return
+
+  clazz = TOOL_REGISTRY.get(tool_name)
+  if clazz:
+    clazz.CopyFiles(device)
+  else:
+    print 'Unknown tool %s, available tools: %s' % (
+        tool_name, ', '.join(sorted(TOOL_REGISTRY.keys())))
+    sys.exit(1)
+