Added --channel argument to run_dev_server_tests.

catapult_build/run_dev_server_tests.py

 #!/usr/bin/env python
 # 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 argparse
 import logging
 import os
 import re
 import shutil
 import stat
 import subprocess
 import sys
 import tempfile
 import time
 import urllib2
 import zipfile
 
 from hooks import install
 
 # URL on omahaproxy.appspot.com which lists cloud storage buckets.
-OMAHA_URL = 'https://omahaproxy.appspot.com/all?os=%s&channel=stable'
+OMAHA_URL = 'https://omahaproxy.appspot.com/all?os=%s&channel=%s'
 
 # URL in cloud storage to download Chrome zip from.
 CLOUDSTORAGE_URL = ('https://commondatastorage.googleapis.com/chrome-unsigned'
                     '/desktop-W15K3Y/%s/%s/chrome-%s.zip')
 
 # Default port to run on if not auto-assigning from OS
 DEFAULT_PORT = '8111'
 
 # Mapping of sys.platform -> platform-specific names and paths.
 PLATFORM_MAPPING = {
@@ skipping 59 matching lines @@
       return path
 
   # Check if depot_tools is in the path
   for path in os.environ['PATH'].split(os.pathsep):
     if IsDepotToolsPath(path):
         return path.rstrip(os.sep)
 
   return None
 
 
-def DownloadSignedWinChromeStable(url, version):
+def DownloadSignedWinChrome(url, version):
   """On Windows, use signed Chrome since it may be more stable."""
   url = url.replace('%VERSION%', version)
   tmpdir = tempfile.mkdtemp()
   installer_path = os.path.join(tmpdir, url[url.rindex('/') + 1:])
   with open(installer_path, 'wb') as local_file:
     local_file.write(urllib2.urlopen(url).read())
   depot_tools_path = FindDepotTools()
   path_7z = os.path.join(depot_tools_path, 'win_toolchain', '7z', '7z.exe')
   command_7z = [path_7z, 'x', '-o' + tmpdir, installer_path]
   process_7z = subprocess.Popen(
     command_7z, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   out_7z, err_7z = process_7z.communicate()
   del out_7z, err_7z
   command_7z = [path_7z, 'x', '-o' + tmpdir, os.path.join(tmpdir, 'chrome.7z')]
   process_7z = subprocess.Popen(
     command_7z, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
   out_7z, err_7z = process_7z.communicate()
   return tmpdir, version
 
 
-def DownloadChromeStable():
+def DownloadChrome(channel):
   platform_data = PLATFORM_MAPPING[sys.platform]
   omaha_platform = platform_data['omaha']
-  omaha_url = OMAHA_URL % omaha_platform
+  omaha_url = OMAHA_URL % (omaha_platform, channel)
   response = urllib2.urlopen(omaha_url)
   version = response.readlines()[1].split(',')[2]
   if 'installer_url' in platform_data:
-    return DownloadSignedWinChromeStable(
+    return DownloadSignedWinChrome(
         platform_data['installer_url'], version)
   cs_url = CLOUDSTORAGE_URL % (
       version,
       platform_data['cs_dir'],
       platform_data['cs_filename'])
   tmpdir = tempfile.mkdtemp()
   zip_path = os.path.join(tmpdir, 'chrome.zip')
   with open(zip_path, 'wb') as local_file:
     local_file.write(urllib2.urlopen(cs_url).read())
   zf = zipfile.ZipFile(zip_path)
@@ skipping 37 matching lines @@
     parser = argparse.ArgumentParser(
         description='Run dev_server tests for a project.')
     parser.add_argument('--chrome_path', type=str,
                         help='Path to Chrome browser binary.')
     parser.add_argument('--no-use-local-chrome',
                         dest='use_local_chrome', action='store_false')
     parser.add_argument(
         '--no-install-hooks', dest='install_hooks', action='store_false')
     parser.add_argument('--tests', type=str,
                         help='Set of tests to run (tracing or perf_insights)')
+    parser.add_argument('--channel', type=str, default='stable',
+                        help='Chrome channel to run (stable or canary)')
     parser.set_defaults(install_hooks=True)
     parser.set_defaults(use_local_chrome=True)
     args = parser.parse_args(argv[1:])
 
     if args.install_hooks:
       install.InstallHooks()
 
     platform_data = PLATFORM_MAPPING[sys.platform]
     user_data_dir = tempfile.mkdtemp()
     tmpdir = None
@@ skipping 11 matching lines @@
     server_process = subprocess.Popen(
         server_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE,
         bufsize=1)
     time.sleep(1)
     if sys.platform != 'win32':
       output = server_process.stderr.readline()
       port = re.search(
           'Now running on http://127.0.0.1:([\d]+)', output).group(1)
 
     xvfb_process = None
+    chrome_info = None
     if args.use_local_chrome:
       chrome_path = GetLocalChromePath(args.chrome_path)
       if not chrome_path:
         logging.error('Could not find path to chrome.')
         sys.exit(1)
+      chrome_info = 'with command `%s`' % chrome_path
     else:
-      tmpdir, version = DownloadChromeStable()
+      channel = args.channel
+      if sys.platform == 'linux2' and channel == 'canary':
+        channel = 'dev'
+      assert channel in ['stable', 'beta', 'dev', 'canary']
+      tmpdir, version = DownloadChrome(channel)
       if platform_data.get('use_xfvb'):
         xvfb_process = StartXvfb()
       chrome_path = os.path.join(
           tmpdir, platform_data['chromepath'])
       os.chmod(chrome_path, os.stat(chrome_path).st_mode | stat.S_IEXEC)
       if platform_data.get('additional_paths'):
         for path in platform_data.get('additional_paths'):
           path = path.replace('%VERSION%', version)
           path = os.path.join(tmpdir, path)
           os.chmod(path, os.stat(path).st_mode | stat.S_IEXEC)
+      chrome_info = version
     chrome_command = [
         chrome_path,
         '--user-data-dir=%s' % user_data_dir,
         '--no-sandbox',
         '--no-experiments',
         '--no-first-run',
         '--noerrdialogs',
         ('http://localhost:%s/%s/tests.html?' % (port, args.tests)) +
             'headless=true&testTypeToRun=all',
     ]
-    print "Starting Chrome..."
+    print "Starting Chrome %s..." % chrome_info
     chrome_process = subprocess.Popen(
         chrome_command, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
     print "Waiting for tests to finish..."
     server_out, server_err = server_process.communicate()
     print "Killing Chrome..."
     if sys.platform == 'win32':
       # Use taskkill on Windows to make sure Chrome and all subprocesses are
       # killed.
       subprocess.call(['taskkill', '/F', '/T', '/PID', str(chrome_process.pid)])
     else:
@@ skipping 15 matching lines @@
       try:
         shutil.rmtree(tmpdir)
         shutil.rmtree(user_data_dir)
       except OSError as e:
         logging.error('Error cleaning up temp dirs %s and %s: %s' % (
             tmpdir, user_data_dir, e))
     if xvfb_process:
       xvfb_process.kill()
 
   sys.exit(server_process.returncode)