[Android] Add a configurable environment for devil/. (RELAND 2)

build/android/devil/devil_env.py

Index: build/android/devil/devil_env.py
diff --git a/build/android/devil/devil_env.py b/build/android/devil/devil_env.py
new file mode 100644
index 0000000000000000000000000000000000000000..87733b5364e61196829c97bcf762a04e4315449a
--- /dev/null
+++ b/build/android/devil/devil_env.py
@@ -0,0 +1,141 @@
+# 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 json
+import logging
+import os
+import sys
+import tempfile
+import threading
+
+# TODO(jbudorick): Update this once dependency_manager moves to catapult.
+CATAPULT_BASE_PATH = os.path.abspath(os.path.join(
+    os.path.dirname(__file__), os.pardir, os.pardir, os.pardir,
+    'tools', 'telemetry'))
+
+@contextlib.contextmanager
+def SysPath(path):
+  sys.path.append(path)
+  yield
+  if sys.path[-1] != path:
+    logging.debug('Expected %s at the end of sys.path. Full sys.path: %s',
+                  path, str(sys.path))
+    sys.path.remove(path)
+  else:
+    sys.path.pop()
+
+with SysPath(CATAPULT_BASE_PATH):
+  from catapult_base import dependency_manager # pylint: disable=import-error
+
+_ANDROID_BUILD_TOOLS = {'aapt', 'dexdump', 'split-select'}
+
+_DEVIL_DEFAULT_CONFIG = os.path.abspath(os.path.join(
+    os.path.dirname(__file__), 'devil_dependencies.json'))
+
+_LEGACY_ENVIRONMENT_VARIABLES = {
+  'ADB_PATH': {
+    'dependency_name': 'adb',
+    'platform': 'android_host',
+  },
+  'ANDROID_SDK_ROOT': {
+    'dependency_name': 'android_sdk',
+    'platform': 'android_host',
+  },
+}
+
+
+def _GetEnvironmentVariableConfig():
+  env_var_config = {}
+  for k, v in _LEGACY_ENVIRONMENT_VARIABLES.iteritems():
+    path = os.environ.get(k)
+    if path:
+      env_var_config[v['dependency_name']] = {
+        'file_info': {
+          v['platform']: {
+            'local_paths': [path]
+          }
+        }
+      }
+  return env_var_config
+
+
+class _Environment(object):
+
+  def __init__(self):
+    self._config = None
+    self._config_init_lock = threading.Lock()
+    self._dm = None
+
+  def Initialize(self, configs=None, config_files=None):
+    """Initialize devil's environment from configuration files.
+
+    This uses all configurations provided via |configs| and |config_files|
+    to determine the locations of devil's dependencies. Configurations should
+    all take the form described by catapult_base.dependency_manager.BaseConfig.
+    If no configurations are provided, a default one will be used if available.
+
+    Args:
+      configs: An optional list of dict configurations.
+      config_files: An optional list of files to load
+    """
+
+    # Make sure we only initialize self._config once.
+    with self._config_init_lock:

[aiolos (Not reviewing), 2015/12/02 23:47:07]

This might be racy since you aren't waiting for any prior initialization to
finish. (If Initialize was called twice, the second call will wait for
self._config to be created, but will return before the initialization of the
dependency_manager finishes.)

I would just remove self._config, and replace it with a check on self._dm
existing. And then have the rest of the initialization happen within the locked
scope.

[jbudorick, 2015/12/03 01:04:35]

wow, yikes. Done.

+      if self._config is not None:
+        return
+      self._config = {}
+
+    if configs is None:
+      configs = []
+
+    env_config = _GetEnvironmentVariableConfig()
+    if env_config:
+      configs.insert(0, env_config)
+    self._InitializeRecursive(
+        configs=configs,
+        config_files=config_files)
+
+  def _InitializeRecursive(self, configs=None, config_files=None):
+    # This recurses through configs to create temporary files for each and
+    # take advantage of context managers to appropriately close those files.
+    # TODO(jbudorick): Remove this recursion if/when dependency_manager
+    # supports loading configurations directly from a dict.
+    if configs:
+      with tempfile.NamedTemporaryFile() as next_config_file:
+        next_config_file.write(json.dumps(configs[0]))
+        next_config_file.flush()
+        self._InitializeRecursive(
+            configs=configs[1:],
+            config_files=[next_config_file.name] + (config_files or []))
+    else:
+      config_files = config_files or []
+      if 'DEVIL_ENV_CONFIG' in os.environ:
+        config_files.append(os.environ.get('DEVIL_ENV_CONFIG'))
+      config_files.append(_DEVIL_DEFAULT_CONFIG)
+
+      self._dm = dependency_manager.DependencyManager(
+          [dependency_manager.BaseConfig(c) for c in config_files])
+
+  def FetchPath(self, dependency, arch=None, device=None):
+    if self._dm is None:
+      self.Initialize()
+    if dependency in _ANDROID_BUILD_TOOLS:
+      self.FetchPath('android_build_tools_libc++', arch=arch, device=device)
+    return self._dm.FetchPath(dependency, _GetPlatform(arch, device))
+
+  def LocalPath(self, dependency, arch=None, device=None):
+    if self._dm is None:
+      self.Initialize()
+    return self._dm.LocalPath(dependency, _GetPlatform(arch, device))
+
+
+def _GetPlatform(arch, device):
+  if not arch:
+    arch = device.product_cpu_abi if device else 'host'
+  return 'android_%s' % arch
+
+
+config = _Environment()
+