#! -*- python -*-
#
# Copyright (c) 2011 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.

""" Main scons script for Native Client SDK builds.

Do not invoke this script directly, but instead use the scons or scons.bat
wrapper function.  E.g.

Linux or Mac:
  ./scons [Options...]

Windows:
  scons.bat [Options...]
"""

from __future__ import with_statement

import os
import platform
import subprocess
import sys
import toolchainbinaries
from build_tools import build_utils

# ----------------------------------------------------------------------------
HELP_STRING = """
===============================================================================
Help for NaCl SDK
===============================================================================

* cleaning:            ./scons -c
* build a target:      ./scons <target>

Supported targets:
  * bot                   Runs everything that the build and try bots run.
  * debug_server_x64      Build the out-of-process debug_server.
  * debug_server_Win32    Build the out-of-process debug_server.
  * docs                  Build all of the Doxygen documentation.
  * examples              Build the examples.
  * installer             Build the SDK installer.
  * nacl-bpad             Build the native client crash reporting tool.
  * sdk_tools             Build nacl_sdk.zip and sdk_tools.tgz
  * toolchain             Update the toolchain's headers and libraries.
  * vsx                   Build the Visual Studio Plugin.

Flags:
  * USE_EXISTING_INSTALLER=1        Do not rebuild the installer if it exists.
  * chrome_browser_path=<full_path> Download Chrome to <full_path>.
  * SHOW_BROWSER=1                  Don't suppress browser GUI while performing
                                    browser tests in Linux.

More targets are listed below in the automatically generated help section.

===============================================================================
Automatically generated help follows:
===============================================================================
"""

# ----------------------------------------------------------------------------
# Perform some environment checks before running.
# Note that scons should set NACL_SDK_ROOT before this script runs.

if os.getenv('NACL_SDK_ROOT') is None:
  sys.stderr.write('NACL_SDK_ROOT must be defined as the root directory'
                   ' of NaCl SDK.\n')
  sys.exit(1)

# By default, run with a parallel build (i.e. '-j num_jobs').
# Use a default value proportional to the number of cpu cores on the system.
# To run a serial build, explicitly type '-j 1' on the command line.
try:
  import multiprocessing
  CORE_COUNT = multiprocessing.cpu_count()
except (ImportError, NotImplementedError):
  CORE_COUNT = 2  # Our buildbots seem to be dual-core typically

SetOption('num_jobs', CORE_COUNT * 2)
print 'Building with', GetOption('num_jobs'), 'parallel jobs'

# ----------------------------------------------------------------------------
# The environment_list contains all the build environments that we want to
# specify.  Selecting a particular environment is done using the --mode option.
# Each environment that we support gets appended to this list.
environment_list = []

# ----------------------------------------------------------------------------
# Create the base environment, from which all other environments are derived.
base_env = Environment(
    tools = ['component_setup'],
    CPPPATH = ['$MAIN_DIR'],
    CPPDEFINES = [
      'BOOST_ALL_NO_LIB',
    ],
    NACL_TOOLCHAIN_ROOTS = {
        ('x86', 'newlib'):
          build_utils.NormalizeToolchain(arch='x86', variant='newlib'),
        ('x86', 'glibc'):
          build_utils.NormalizeToolchain(arch='x86', variant='glibc'),
    },
    ROOT_DIR = os.path.abspath(os.getcwd()),
    SRC_DIR = os.path.dirname(os.path.dirname(os.path.abspath(os.getcwd()))),
    IS_WINDOWS = sys.platform in ['cygwin', 'win32'],
    IS_LINUX = sys.platform == 'linux2',
    IS_MAC = sys.platform == 'darwin',
    JOB_COUNT = GetOption('num_jobs')
)

# It is possible to override these values on the command line by typing
# something like this:
#   PYTHON=/path/to/my/python
base_env.SetDefault(
    PYTHON = ARGUMENTS.get('PYTHON', 'python'),
    USE_EXISTING_INSTALLER = ARGUMENTS.get('USE_EXISTING_INSTALLER', False),
    SHOW_BROWSER = ARGUMENTS.get('SHOW_BROWSER', False),
)

base_env.Append(
    BUILD_SCONSCRIPTS = [
        # Keep in alphabetical order
        'build_tools/build.scons',
        'documentation/build.scons',
        'project_templates/test.scons',
    ],
)

base_env.Help(HELP_STRING)

KNOWN_SUITES = frozenset([
    'bot',
    ])


def HasBotTarget(env):
  if 'bot' in COMMAND_LINE_TARGETS:
    return True
  return False

base_env.AddMethod(HasBotTarget)


def CheckSuiteName(suite, node_name):
  '''Check whether a given test suite or alias name is a known name.

  If the suite name is not in the approved list, then this function throws
  an exception, with the node_name within the error message.

  Args:
    suite: a name of a suite that must be in the KNOWN_SUITES set
    node_name: The name of the node.  This is used for error messages
  '''
  if suite not in KNOWN_SUITES:
    raise Exception('Testsuite/Alias "%s" for target "%s" is unknown' %
                    (suite, node_name))


def AddNodeToTestSuite(env, node, suite_names, node_name, test_size='all'):
  '''Adds a test node to a given set of suite names

  These tests are automatically added to the run_all_tests target and are
  listed in the help screen.

  This function is loosely based on a function of the same name in the
  Native Client repository

  Args:
    env - The environment from which this function was called
    node - A scons node (e.g., file, command, etc) to be added to set suite
    suite_names - A list of test suite names.  For none, pass an empty list
    node_name - The target name used for running this test
    test_size - The relative run-time of this test: small, medium, or large
  '''

  # CommandTest can return an empty list when it silently discards a test
  if not node:
    return

  AlwaysBuild(node)

  for s in suite_names:
    CheckSuiteName(s, node_name)
    env.Alias(s, node)

  if test_size not in ['small', 'medium', 'large', 'all']:
    raise Exception('Invalid test size for %s' % node_name)

  # Note that COMPONENT_TEST_SIZE is set to 'large' by default, which
  # populates a largely redundant list of 'large' tests.  Note that all
  # tests are added to 'all', so setting test_size='all' is a no-op
  env.ComponentTestOutput(node_name, node, COMPONENT_TEST_SIZE=test_size)

base_env.AddMethod(AddNodeToTestSuite)


def ShouldBeCleaned(env, targets, suite_names, node_name):
  '''Determines whether a given set of targets require cleaning.

  Args:
    env - The calling environment.
    targets - Any build artifacts to which a cleaning step might apply.
              Any false object indicates that this check is skipped.
    suite_names - Any suites that might produce |targets|
    node_name - A node that might produce |targets|
  '''
  if not env.GetOption('clean'):
    return False

  if len(COMMAND_LINE_TARGETS) > 0:
    clean_this = False
    for cl_target in COMMAND_LINE_TARGETS:
      if cl_target in suite_names or cl_target == node_name:
        clean_this = True
        break
    if not clean_this:
      return False

  if not targets:
    return True
  for target in targets:
    if os.path.exists(target):
      return True
  return False


def AddCleanAction(env, targets, action, suite_names, node_name):
  '''Adds a cleanup action that scons cannot detect automatically.

  Cleaning will only occur if there is a match between the suite or nodes
  specified on the command line, and suite_names or node_name or if no
  suite or nodes are specified on the command line.  Also, at least one of the
  targets must exist on the file system.

  Args:
    env - The calling environment
    targets - Artifacts to be cleaned.
    action - The action to be performed.  It is up to the caller to ensure
             that |action| will actually remove |targets|
    suite_names - Any suites to which this cleanup target applies.
    node_name - Any nodes to which this cleanup target applies.
  '''
  if ShouldBeCleaned(env, targets, suite_names, node_name):
    env.Execute(action)

base_env.AddMethod(AddCleanAction)


def AddNodeAliases(env, node, suite_names, node_name):
  '''Allow a given node to be built under a different name or as a suite

  Args:
    env - The calling environment
    node - A target node to add to a known build alias (e.g., 'bot')
    suite_names - A list of suite names.  For none, pass an empty list.  This
                  node will be run whenever any of these suites are invoked.
                  Each suite name must match a string in KNOWN_SUITES.
    node_name - The name of this node, when run by itself
  '''

  if not node:
    return

  for s in suite_names:
    CheckSuiteName(s, node_name)
    env.Alias(s, node)

  env.Alias(node_name, node)

base_env.AddMethod(AddNodeAliases)


def CreatePythonUnitTest(env, filename, dependencies=None, disabled=False,
                         params=None, buffered=True, banner=None):
  """Returns a new build command that will run a unit test with a given file.

  Args:
    env: SCons environment
    filename: The python file that contains the unit test
    dependencies: An optional list of other files that this unit test uses
    disabled: Setting this to True will prevent the test from running
    params: Optional additional parameters for python command
    buffered: True=stdout is buffered until entirely complete;
              False=stdout is immediately displayed as it occurs.
    banner: (optional) annotation banner for build/try bots

  Returns:
    A SCons command node
  """
  dependencies = dependencies or []
  params = params or []

  basename = os.path.splitext(os.path.basename(filename))[0]
  outfilename = "%s_output.txt" % basename


  def RunPythonUnitTest(env, target, source):
    """Runs unit tests using the given target as a command.

    The argument names of this test are not very intuitive but match what is
    used conventionally throughout scons.  If the string "PASSED" does not
    occur in target when this exits, the test has failed; also a scons
    convention.

    Args:
      env: SCons's current environment.
      target: Where to write the result of the test.
      source: The command to run as the test.

    Returns:
      None for good status
      An error string for bad status
    """
    bot = build_utils.BotAnnotator()
    if banner:
      bot.BuildStep(banner)

    if disabled:
      sys.stdout.write("Test %s is disabled.\n" % basename)
      sys.stdout.flush()
      return None   # return with good status

    import subprocess

    app = [str(env['PYTHON']), str(source[0].abspath)] + map(
        lambda param: param if type(param) is str else str(param.abspath),
        params)
    bot.Print('Running: %s' % app)
    app_env = os.environ.copy()
    # We have to do this because scons overrides PYTHONPATH and does
    # not preserve what is provided by the OS.
    python_path = [env['ROOT_DIR'], app_env['PYMOX'], app_env['PYTHONPATH']]
    app_env['PYTHONPATH'] = os.pathsep.join(python_path)
    ret_val = 'Error: General Test Failure'  # Indicates failure, by default
    target_str = str(target[0])
    with open(target_str, 'w') as outfile:
      def Write(str):
        if buffered:
          outfile.write(str)
          outfile.flush()
        else:
          sys.stdout.write(str)
          sys.stdout.flush()
      Write('\n-----Begin output for Test: %s\n' % basename)
      if subprocess.call(app, env=app_env,
                         stdout=outfile if buffered else None,
                         stderr=outfile if buffered else None):
        Write('-----Error: unit test failed\n')
        ret_val = 'Error: Test Failure in %s' % basename
      else:
        ret_val = None  # Indicates success

      Write('-----End output for Test: %s\n' % basename)
    if buffered:
      with open(target_str, 'r') as resultfile:
        sys.stdout.write(resultfile.read())
      sys.stdout.flush()

    if ret_val:
      bot.BuildStepFailure()

    return ret_val

  cmd = env.Command(outfilename, filename, RunPythonUnitTest)
  env.Depends(cmd, dependencies)
  # Create dependencies for all the env.File parameters and other scons nodes
  for param in params:
    if type(param) is not str:
      env.Depends(cmd, param)

  return cmd

base_env.AddMethod(CreatePythonUnitTest)


# ----------------------------------------------------------------------------
# Support for running Chrome.  These functions access the construction
# Environment() to produce a path to Chrome.

# A Dir object representing the directory where the Chrome binaries are kept.
# You can use chrome_binaries_dir= to set this on the command line.  Defaults
# to chrome_binaries.
base_env['CHROME_DOWNLOAD_DIR'] = \
    base_env.Dir(ARGUMENTS.get('chrome_binaries_dir', '#chrome_binaries'))


def ChromeArchitectureSpec(env):
  '''Determine the architecture spec for the Chrome binary.

  The architecture spec is a string that represents the host architecture.
  Possible values are:
    x86-32
    x86-64
  On Mac and Windows, the architecture spec is always x86-32, because there are
  no 64-bit version available.

  Returns: An architecture spec string for the host CPU.
  '''
  arch, _ = platform.architecture();
  # On Mac and Windows, always use a 32-bit version of Chrome (64-bit versions
  # are not available).
  if env['IS_WINDOWS'] or env['IS_MAC']:
    arch = 'x86-32'
  else:
    arch = 'x86-64' if '64' in arch else 'x86-32'
  return arch

base_env.AddMethod(ChromeArchitectureSpec)


def GetDefaultChromeBinary(env):
  '''Get a File object that represents a Chrome binary.

  By default, the test infrastructure will download a copy of Chrome that can
  be used for testing.  This method returns a File object that represents the
  downloaded Chrome binary that can be run by tests.  Note that the path to the
  binary is specific to the host platform, for example the path on Linux
  is <chrome_dir>/linux/<arch>/chrome, while on Mac it's
    <chrome_dir>/mac/<arch>/Chromium.app/Contents.MacOS/Chromium.

  Returns: A File object representing the Chrome binary.
  '''
  if env['IS_LINUX']:
    os_name = 'linux'
    binary = 'chrome'
  elif env['IS_WINDOWS']:
    os_name = 'windows'
    binary = 'chrome.exe'
  elif env['IS_MAC']:
    os_name = 'mac'
    binary = 'Chromium.app/Contents/MacOS/Chromium'
  else:
    raise Exception('Unsupported OS')

  return env.File(os.path.join(
      '${CHROME_DOWNLOAD_DIR}',
      '%s_%s' % (os_name, env.ChromeArchitectureSpec()),
      binary)) 

base_env.AddMethod(GetDefaultChromeBinary)


def GetChromeBinary(env):
  '''Return a File object that represents the downloaded Chrome binary.

  If chrome_browser_path is specified on the command line, then return a File
  object that represents that path.  Otherwise, return a File object
  representing the default downloaded Chrome (see GetDefaultChromeBinary(),
  above).

  Returns: A File object representing a Chrome binary.
  '''
  return env.File(ARGUMENTS.get('chrome_browser_path',
                                env.GetDefaultChromeBinary()))

base_env.AddMethod(GetChromeBinary)


def DependsOnChrome(env, dependency):
  '''Create a dependency on the download of Chrome.

  Creates a dependency in |env| such that Chrome gets downloaded (if necessary)
  whenever |dependency| changes.  Uses the Chrome downloader scripts built
  into NaCl; this script expects NaCl to be DEPS'ed into
  third_party/native_client/native_client.

  The Chrome binary is added as a precious node to the base Environment.  If
  we added it to the build environment env, then downloading chrome would in
  effect be specified for multiple environments.
  '''
  if not hasattr(base_env, 'download_chrome_node'):
    chrome_binary = env.GetDefaultChromeBinary()
    download_chrome_script = build_utils.JoinPathToNaClRepo(
        'native_client', 'build', 'download_chrome.py',
        root_dir=env['ROOT_DIR'])
    base_env.download_chrome_node = env.Command(
        chrome_binary,
        [],
        '${PYTHON} %s --arch=%s --dst=${CHROME_DOWNLOAD_DIR}' %
            (download_chrome_script, env.ChromeArchitectureSpec()))
    # This stops Scons from deleting the file before running the step above.
    env.NoClean(chrome_binary)
    env.Precious(chrome_binary)
  env.Depends(dependency, base_env.download_chrome_node)

base_env.AddMethod(DependsOnChrome)


# ----------------------------------------------------------------------------
# Targets for updating sdk headers and libraries
# NACL_SDK_XXX vars are defined by  site_scons/site_tools/naclsdk.py
# NOTE: Our task here is complicated by the fact that there might already be
#       some (outdated) headers/libraries at the new location
#       One of the hacks we employ here is to make every library depend
#       on the installation on ALL headers (sdk_headers)

# Contains all the headers to be installed
sdk_headers = base_env.Alias('extra_sdk_update_header', [])
# Contains all the libraries and .o files to be installed
libs_platform = base_env.Alias('extra_sdk_libs_platform', [])
libs = base_env.Alias('extra_sdk_libs', [])
base_env.Alias('extra_sdk_update', [libs, libs_platform])

AlwaysBuild(sdk_headers)

# ----------------------------------------------------------------------------
# The following section contains proxy nodes which can be used to create
# dependencies between targets that are not in the same scope or environment.
toolchain_node = base_env.Alias('toolchain', [])


def GetToolchainNode(env):
  '''Returns the node associated with the toolchain build target'''
  return toolchain_node

base_env.AddMethod(GetToolchainNode)


def GetHeadersNode(env):
  return sdk_headers

base_env.AddMethod(GetHeadersNode)

installer_prereqs_node = base_env.Alias('installer_prereqs', [])


def GetInstallerPrereqsNode(env):
  return installer_prereqs_node

base_env.AddMethod(GetInstallerPrereqsNode)

installer_test_node = base_env.Alias('installer_test_node', [])


def GetInstallerTestNode(env):
  return installer_test_node

base_env.AddMethod(GetInstallerTestNode)


def AddHeaderToSdk(env, nodes, subdir = 'nacl/', base_dirs = None):
  """Add a header file to the toolchain.  By default, Native Client-specific
  headers go under nacl/, but there are non-specific headers, such as
  the OpenGLES2 headers, that go under their own subdir.

  Args:
    env: Environment in which we were called.
    nodes: A list of node objects to add to the toolchain
    subdir: This is appended to each base_dir
    base_dirs: A list of directories to install the node to"""
  if not base_dirs:
    # TODO(mball): This won't work for PNaCl:
    base_dirs = [os.path.join(dir, 'x86_64-nacl', 'include')
                 for dir in env['NACL_TOOLCHAIN_ROOTS'].values()]

  for base_dir in base_dirs:
    node = env.Replicate(os.path.join(base_dir, subdir), nodes)
    env.Depends(sdk_headers, node)
    env.Depends(toolchain_node, node)
  return node

base_env.AddMethod(AddHeaderToSdk)


def AddLibraryToSdkHelper(env, nodes, is_lib, is_platform):
  """"Helper function to install libs/objs into the toolchain
  and associate the action with the extra_sdk_update.

  Args:
    env: Environment in which we were called.
    nodes: list of libc/objs
    is_lib: treat nodes as libs
    is_platform: nodes are truly platform specific
  """
  env.Requires(nodes, sdk_headers)

  dir = ARGUMENTS.get('extra_sdk_lib_destination')
  if not dir:
    dir = '${NACL_SDK_LIB}/'

  if is_lib:
    n = env.ReplicatePublished(dir, nodes, 'link')
  else:
    n = env.Replicate(dir, nodes)

  if is_platform:
    env.Alias('extra_sdk_libs_platform', n)
  else:
    env.Alias('extra_sdk_libs', n)
  return n


def AddLibraryToSdk(env, nodes, is_platform=False):
  return AddLibraryToSdkHelper(env, nodes, True, is_platform)

base_env.AddMethod(AddLibraryToSdk)


# ----------------------------------------------------------------------------
# This is a simple environment that is primarily for targets that aren't built
# directly by scons, and therefore don't need any special environment setup.
build_env = base_env.Clone(
    BUILD_TYPE = 'build',
    BUILD_GROUPS = ['default', 'all'],
    BUILD_TYPE_DESCRIPTION = 'Default build environment',
    HOST_PLATFORMS = '*',
    )

environment_list.append(build_env)

# ----------------------------------------------------------------------------
# Get the appropriate build command depending on the environment.


def SconsBuildCommand(env):
  '''Return the build command used to run separate scons instances.
  Args:
    env: The construction Environment() that is building using scons.
  Returns:
    A string representing the platform-specific build command that will run the
    scons instances.
  '''
  if env['IS_WINDOWS']:
    return 'scons.bat --jobs=%s' % GetOption('num_jobs')
  else:
    return './scons --jobs=%s' % GetOption('num_jobs')

# ----------------------------------------------------------------------------
# Add a builder for examples.  This adds an Alias() node named 'examples' that
# is always built.  There is some special handling for the clean mode, since
# SCons relies on actual build products for its clean processing and will not
# run Alias() actions during clean unless they actually produce something.


def BuildExamples(env, target, source):
  '''Build the examples.

  This runs the build command in the 'examples' directory.

  Args:
    env: The construction Environment() that is building the examples.
    target: The target that triggered this build.  Not used.
    source: The sources used for this build.  Not used.
  '''
  os_env = os.environ.copy()
  os_env['NACL_TARGET_PLATFORM'] = '.'
  subprocess.check_call(SconsBuildCommand(env),
                        cwd='examples',
                        env=os_env,
                        shell=True)


def CleanExamples(env, target, source):
  '''Clean the examples.

  This runs the clean command in the 'examples' directory.

  Args:
    env: The construction Environment() that is building the examples.
  '''
  os_env = os.environ.copy()
  os_env['NACL_TARGET_PLATFORM'] = '.'
  subprocess.check_call('%s --clean' % SconsBuildCommand(env),
                        cwd='examples',
                        env=os_env,
                        shell=True)


examples_builder = build_env.Alias('examples', [toolchain_node], BuildExamples)
build_env.AlwaysBuild(examples_builder)
build_env.AddCleanAction(['examples'], CleanExamples, ['bot'],
                         examples_builder)


def DependsOnExamples(env, dependency):
  env.Depends(dependency, examples_builder)

build_env.AddMethod(DependsOnExamples)


# ----------------------------------------------------------------------------
# Add helper functions that build/clean a test by invoking scons under the
# test directory (|cwd|, when specified).  These functions are meant to be
# called from corresponding project-specific 'Build<project>Test' and
# 'Clean<project>Test' functions in the local test.scons scripts.  Note that the
# CleanNaClTest does not require a |cwd| because its cwd is always '.'


def BuildNaClTest(env, cwd):
  '''Build the test.

  This runs the build command in the test directory from which it is called.

  Args:
    env: The construction Environment() that is building the test.
    cwd: The directory under which the test's build.scons rests.
  '''
  subprocess.check_call('%s stage' % SconsBuildCommand(env),
                        cwd=cwd,
                        shell=True)

build_env.AddMethod(BuildNaClTest)


def CleanNaClTest(env):
  '''Clean the test.

  This runs the clean command in the test directory from which it is called.

  Args:
    env: The construction Environment() that is building the test.
    cwd: The directory under which the test's build.scons rests.
  '''
  subprocess.check_call('%s stage --clean' % SconsBuildCommand(env),
                        shell=True)
  # The step above still leaves behind two empty 'opt' directories, so a second
  # cleaning pass is necessary.
  subprocess.check_call('%s --clean' % SconsBuildCommand(env),
                        shell=True)

build_env.AddMethod(CleanNaClTest)

# ----------------------------------------------------------------------------
# Enable PPAPIBrowserTester() functionality using nacltest.js
# NOTE: The three main functions in this section: PPAPIBrowserTester(),
# CommandTest(), and AutoDepsCommand() are 'LITE' versions of their counterparts
# provided by Native Client @ third_party/native_client/native_client/SConstruct


def SetupBrowserEnv(env):
  '''Set up the environment for running the browser.

  This copies environment parameters provided by the OS in order to run the
  browser reliably.

  Args:
    env: The construction Environment() that runs the browser.
  '''
  EXTRA_ENV = ['XAUTHORITY', 'HOME', 'DISPLAY', 'SSH_TTY', 'KRB5CCNAME']
  for var_name in EXTRA_ENV:
    if var_name in os.environ:
      env['ENV'][var_name] = os.environ[var_name]

  env.Append(
    PYTHONPATH = [
        build_utils.JoinPathToNaClRepo(
            'third_party', 'pylib',
            root_dir=os.getenv('NACL_SDK_ROOT')),
        build_utils.JoinPathToNaClRepo(
            'tools', 'valgrind',
            root_dir=os.getenv('NACL_SDK_ROOT')),
        ]
    )


def PPAPIBrowserTester(env,
                       target,
                       url,
                       files,
                       timeout=20):
  '''The main test wrapper for browser integration tests.

  This constructs the command that invokes the browser_tester.py script on an
  existing Chrome binary (to be downloaded if necessary).

  Args:
    env: The construction Environment() that runs the browser.
    target: The output file to which the output of the test is to be written.
    url: The test web page.
    files: The files necessary for the web page to be served.
    timeout: How long to wait for a response before concluding failure.

  Returns: A command node that executes the browser test.
  '''

  env = env.Clone()
  SetupBrowserEnv(env)

  python_tester_script = build_utils.JoinPathToNaClRepo(
      'native_client', 'tools', 'browser_tester', 'browser_tester.py',
      root_dir=env['ROOT_DIR'])

  # Check if browser GUI needs to be suppressed (possible only in Linux)
  headless_prefix = []
  if not env['SHOW_BROWSER'] and env['IS_LINUX']:
    headless_prefix = ['xvfb-run', '--auto-servernum']

  command = headless_prefix + [
      '${PYTHON}', python_tester_script,
      '--browser_path', env.GetChromeBinary(),
      '--url', url,
      # Fail if there is no response for X seconds.
      '--timeout', str(timeout)]

  for dep_file in files:
    command.extend(['--file', dep_file])

  cmd = env.CommandTest(target,
                         command,
                         # Set to 'huge' so that the browser tester's timeout
                         # takes precedence over the default of the test suite.
                         size='huge',
                         capture_output=False)
  env.DependsOnChrome(cmd)

  return cmd

build_env.AddMethod(PPAPIBrowserTester)


def CommandTest(env,
                name,
                command,
                size='small',
                capture_output=True):
  '''The wrapper for testing execution of a command and logging details.

  This constructs the command that invokes the command_tester.py script on a
  given command.

  Args:
    env: The construction Environment() that runs the command.
    name: The output file to which the output of the tester is to be written.
    command: The command to be tested.
    size: This dictates certain timeout thresholds.
    capture_output: This specifies whether the command's output needs to be
                    captured for further processing. When this option is False,
                    stdout and stderr will be streamed out. For more info, see
                    <NACL_REPO>/native_client/tools/command_tester.py

  Returns: A command node that executes the command test.
  '''
  TEST_TIME_THRESHOLD = {
    'small':   2,
    'medium': 10,
    'large':  60,
    'huge': 1800,
    }

  if not name.endswith('out') or name.startswith('$'):
    raise Exception('ERROR: bad test filename for test output %r' % name)

  arch_string = env.ChromeArchitectureSpec();
  if env['IS_LINUX']:
    platform_string = 'linux'
  elif env['IS_MAC']:
    platform_string = 'mac'
  elif env['IS_WINDOWS']:
    platform_string = 'windows'

  name = '${TARGET_ROOT}/test_results/' + name
  max_time = TEST_TIME_THRESHOLD[size]

  script_flags = ['--name', name,
                  '--report', name,
                  '--time_warning', str(max_time),
                  '--time_error', str(10 * max_time),
                  '--perf_env_description', platform_string + '_' + arch_string,
                  '--arch', 'x86',
                  '--subarch', arch_string[-2:],
                  ]
  if not capture_output:
    script_flags.extend(['--capture_output', '0'])

  test_script = build_utils.JoinPathToNaClRepo(
      'native_client', 'tools', 'command_tester.py',
      root_dir=env['ROOT_DIR'])
  command = ['${PYTHON}', test_script] + script_flags + command
  return AutoDepsCommand(env, name, command)

build_env.AddMethod(CommandTest)


def AutoDepsCommand(env, name, command):
  """AutoDepsCommand() takes a command as an array of arguments.  Each
  argument may either be:

   * a string, or
   * a Scons file object, e.g. one created with env.File() or as the
     result of another build target.

  In the second case, the file is automatically declared as a
  dependency of this command.

  Args:
    env: The construction Environment() that runs the command.
    name: The target file to which the output is to be written.
    command: The command to be executed.

  Returns: A command node in the standard SCons format.
  """
  deps = []
  for index, arg in enumerate(command):
    if not isinstance(arg, str):
      if len(Flatten(arg)) != 1:
        # Do not allow this, because it would cause "deps" to get out
        # of sync with the indexes in "command".
        # See http://code.google.com/p/nativeclient/issues/detail?id=1086
        raise AssertionError('Argument to AutoDepsCommand() actually contains '
                             'multiple (or zero) arguments: %r' % arg)
      command[index] = '${SOURCES[%d].abspath}' % len(deps)
      deps.append(arg)

  return env.Command(name, deps, ' '.join(command))

build_env.AddMethod(AutoDepsCommand)


def BuildVSSolution(env, target_name, solution, project_config=None):
  """BuildVSSolution() Builds a Visual Studio solution.

  Args:
    env: The construction Environment() that runs the command.
    target_name: The name of the target.  Build output will be written to
      [target_name]_build_output.txt.
    solution: The solution to build.
    project_config: A valid project configuration string to pass into devenv.
      This provides support for building specific configurations, i.e.
      'Debug|Win32', 'Debug|x64', 'Release|Win32', 'Release|x64'.  Note that the
      string must be in quotes to work.  devenv will default to Win32 if this
      is not provided.

  Returns the Command() used to build the target, so other targets can be made
  to depend on it.
  """
  vs_build_action = ['vcvarsall', '&&', 'devenv', '${SOURCE}', '/build']
  if project_config:
    vs_build_action.extend([project_config])

  build_command = env.Command(target='%s_build_output.txt' % target_name,
                              source=solution,
                              action=' '.join(vs_build_action))
  env.AddNodeAliases(build_command, ['bot'], target_name)
  return build_command

build_env.AddMethod(BuildVSSolution)


def CleanVSSolution(env, target_name, solution_dir):
  """CleanVSSolution() Cleans up a Visual Studio solution's build results.
  
  The clean target created by this function is added to the 'bot' target as
  well as the target specified.  The function will clean any build artifacts
  that could possibly be generated under the solution directory.

  Args:
    env: The construction Environment() that runs the command.
    target_name: The name of the target which builds whatever should be cleaned
      up.
    solution_dir: The directory under which VS build artifacts are to be
      expected.  This function will look for Debug, Release, and x64 build
      targets.
  """
  clean_targets = [os.path.join(solution_dir, 'Debug'),
                   os.path.join(solution_dir, 'Release'),
                   os.path.join(solution_dir, 'x64')]

  for target in clean_targets:
    clean_action = ['rmdir', '/Q', '/S', target]
    env.AddCleanAction([target],
                       Action(' '.join(clean_action)),
                       ['bot'],
                       target_name)

build_env.AddMethod(CleanVSSolution)


def TestVSSolution(env, target_name, test_container, type, size, build_cmd):
  """Defines a set of tests to be added to the scons test set.

  This function adds a test solution generated by Visual Studio.  It can either
  run mstest or, for natively compiled solutions, it can run an executable.

  Args:
    env: The construction Environment() that runs the command.
    target_name: The name of the target which resulted in the test container.
      A name that clearly marks the target as a test is recommended here.
    test_container: The fully qualified path to the dll or exe that contains
      the tests.
    type: The type test package to expect as a string.  This can be 'dll' or
      'exe'.
    size: Which test harness to add the tests to; small, medium, or large
    build_cmd: The command which builds the target being tested.
  """
  test_action = test_container
  if type is 'dll':
    test_action = ' '.join(['vcvarsall',
                            '&&',
                            'mstest',
                            '/testcontainer:%s' % test_container,
                            '/resultsfile:${TARGET}'])

  # Can't use the test container as SOURCE because it is generated indirectly
  # and using it as source would declare an explicit dependency on a target,
  # generated by scons.  Files that exist in the environment can be used in that
  # way, but only if they exist at the time when scons starts to run, or if
  # the are explicit Command targets.  As a result, source is empty.
  test_command = env.Command(
      target='%s_test_results.trx' % target_name,
      source='',
      action=test_action)

  env.Depends(test_command, build_cmd)
  env.AddNodeToTestSuite(test_command,
                         ['bot'],
                         target_name,
                         size)
  return test_command

build_env.AddMethod(TestVSSolution)


# ----------------------------------------------------------------------------
BuildComponents(environment_list)

# Require specifying an explicit target only when not cleaning
if not GetOption('clean'):
  Default(None)