def initialize_bot_db(self, chromium_tests_api, bot_db, bot_update_step):
    # TODO(phajdan.jr): Bots should have no generators instead.
    if self.get('disable_tests'):
      scripts_compile_targets = {}
    else:
      scripts_compile_targets = \
          chromium_tests_api.get_compile_targets_for_scripts().json.output

    masternames = set(bot_id['mastername'] for bot_id in self._bot_ids)
    for mastername in masternames:
      test_spec = self._get_test_spec(chromium_tests_api, mastername)

      # We manually thaw the path to the elements we are modifying, since the
      # builders are frozen.
      master_dict = dict(self._bots_dict[mastername])
      builders = master_dict['builders'] = dict(master_dict['builders'])
      for loop_buildername in builders:
        builder_dict = builders[loop_buildername] = (
            dict(builders[loop_buildername]))
        builders[loop_buildername]['tests'] = (
            chromium_tests_api.generate_tests_from_test_spec(
                chromium_tests_api.m, test_spec, builder_dict,
                loop_buildername, mastername,
                # TODO(phajdan.jr): Get enable_swarming value from builder_dict.
                # Above should remove the need to get bot_config and buildername
                # in this method.
                self.get('enable_swarming', False),
                builder_dict.get('swarming_dimensions', {}),
                scripts_compile_targets,
                builder_dict.get('test_generators', []),
                bot_update_step
            ))

      bot_db._add_master_dict_and_test_spec(
          mastername, freeze(master_dict), freeze(test_spec))
Exemple #2
0
    def get_master_dict_with_dynamic_tests(self, mastername, buildername,
                                           test_spec, scripts_compile_targets):
        # We manually thaw the path to the elements we are modifying, since the
        # builders are frozen.
        master_dict = dict(self.builders[mastername])
        builders = master_dict['builders'] = dict(master_dict['builders'])
        bot_config = builders[buildername]
        for loop_buildername in builders:
            builder_dict = builders[loop_buildername] = (dict(
                builders[loop_buildername]))
            builders[loop_buildername]['tests'] = (
                self.generate_tests_from_test_spec(
                    self.m,
                    test_spec,
                    builder_dict,
                    loop_buildername,
                    mastername,
                    # TODO(phajdan.jr): Get enable_swarming value from builder_dict.
                    # Above should remove the need to get bot_config and buildername
                    # in this method.
                    bot_config.get('enable_swarming', False),
                    scripts_compile_targets,
                    builder_dict.get('test_generators', [])))

        return freeze(master_dict)
Exemple #3
0
    def initialize_bot_db(self, chromium_tests_api, bot_db, bot_update_step):
        # TODO(phajdan.jr): Get rid of disable_tests.
        if self.get('disable_tests'):
            scripts_compile_targets = {}
        else:
            scripts_compile_targets = \
                chromium_tests_api.get_compile_targets_for_scripts()

        test_generators = [
            chromium_tests_api.steps.generate_gtest,
            chromium_tests_api.steps.generate_instrumentation_test,
            chromium_tests_api.steps.generate_junit_test,
            chromium_tests_api.steps.generate_script,
            chromium_tests_api.steps.generate_isolated_script,
        ]

        masternames = set(bot_id['mastername'] for bot_id in self._bot_ids)
        for mastername in sorted(self._bots_dict):
            # We manually thaw the path to the elements we are modifying, since the
            # builders are frozen.
            master_dict = dict(self._bots_dict[mastername])

            if mastername in masternames:
                test_spec = self._get_test_spec(chromium_tests_api, mastername)

                builders = master_dict['builders'] = dict(
                    master_dict['builders'])
                for loop_buildername in builders:
                    builder_dict = builders[loop_buildername] = (dict(
                        builders[loop_buildername]))
                    builders[loop_buildername]['tests'] = (
                        chromium_tests_api.generate_tests_from_test_spec(
                            test_spec, builder_dict, loop_buildername,
                            mastername, True,
                            builder_dict.get('swarming_dimensions',
                                             {}), scripts_compile_targets,
                            test_generators, bot_update_step))
            else:
                test_spec = None

            bot_db._add_master_dict_and_test_spec(mastername,
                                                  freeze(master_dict),
                                                  freeze(test_spec))
    def initialize_bot_db(self, chromium_tests_api, bot_db, bot_update_step):
        # TODO(phajdan.jr): Bots should have no generators instead.
        if self.get('disable_tests'):
            scripts_compile_targets = {}
        else:
            scripts_compile_targets = \
                chromium_tests_api.get_compile_targets_for_scripts().json.output

        masternames = set(bot_id['mastername'] for bot_id in self._bot_ids)
        for mastername in sorted(self._bots_dict):
            # We manually thaw the path to the elements we are modifying, since the
            # builders are frozen.
            master_dict = dict(self._bots_dict[mastername])

            if mastername in masternames:
                test_spec = self._get_test_spec(chromium_tests_api, mastername)

                builders = master_dict['builders'] = dict(
                    master_dict['builders'])
                for loop_buildername in builders:
                    builder_dict = builders[loop_buildername] = (dict(
                        builders[loop_buildername]))
                    builders[loop_buildername]['tests'] = (
                        chromium_tests_api.generate_tests_from_test_spec(
                            chromium_tests_api.m,
                            test_spec,
                            builder_dict,
                            loop_buildername,
                            mastername,
                            # TODO(phajdan.jr): Get enable_swarming value from
                            # builder_dict. Above should remove the need to get
                            # bot_config and buildername in this method.
                            self.get('enable_swarming', False),
                            builder_dict.get('swarming_dimensions', {}),
                            scripts_compile_targets,
                            builder_dict.get('test_generators', []),
                            bot_update_step))
            else:
                test_spec = None

            bot_db._add_master_dict_and_test_spec(mastername,
                                                  freeze(master_dict),
                                                  freeze(test_spec))
  'recipe_engine/step',
]

BUCKET_NAME = 'chrome-codesearch'
CHROMIUM_GIT_URL = 'https://chromium.googlesource.com'

# Lists the additional repositories that should be checked out to be included
# in the source archive that is indexed by Codesearch.
ADDITIONAL_REPOS = freeze({
  'infra': '%s/infra/infra' % CHROMIUM_GIT_URL,
  'tools/chrome-devtools-frontend':\
      '%s/chromium/tools/chrome-devtools-frontend' % CHROMIUM_GIT_URL,
  'tools/chromium-jobqueue':\
      '%s/chromium/tools/chromium-jobqueue' % CHROMIUM_GIT_URL,
  'tools/chromium-shortener':\
      '%s/chromium/tools/chromium-shortener' % CHROMIUM_GIT_URL,
  'tools/command_wrapper/bin':\
      '%s/chromium/tools/command_wrapper/bin' % CHROMIUM_GIT_URL,
  'tools/depot_tools': '%s/chromium/tools/depot_tools' % CHROMIUM_GIT_URL,
  'tools/gsd_generate_index':\
      '%s/chromium/tools/gsd_generate_index' % CHROMIUM_GIT_URL,
  'tools/perf': '%s/chromium/tools/perf' % CHROMIUM_GIT_URL,
})

GENERATED_REPO = '%s/chromium/src/out' % CHROMIUM_GIT_URL
GENERATED_AUTHOR_EMAIL = '*****@*****.**'
GENERATED_AUTHOR_NAME = 'Automatic Generated Files Sync'

SPEC = freeze({
  # The builders have the following parameters:
  # - compile_targets: the compile targets.
    'depot_tools/bot_update',
    'depot_tools/gclient',
    'recipe_engine/platform',
    'recipe_engine/properties',
    'recipe_engine/raw_io',
    'recipe_engine/step',
]

BUILDERS = freeze({
    'Android ChromeDriver Tests Example': {
        'chromedriver_platform':
        'android',
        # Whether or not to update the test results log (Android only).
        'update_test_log':
        True,
        'android_packages': [
            'chrome_shell',
            'chrome_stable',
            'chrome_beta',
            'chromedriver_webview_shell',
        ],
    },
})


def RunSteps(api):
    buildername = api.properties['buildername']
    builder = BUILDERS[buildername]
    android_packages = builder.get('android_packages')
    update_test_log = builder.get('update_test_log')
]

BUILDERS = freeze({
  'chromium.mojo': {
    'builders': {
      'Chromium Mojo Linux': {
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_PLATFORM': 'linux',
        },
      },
      'Chromium Mojo Android': {
        'chromium_config': 'android',
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_PLATFORM': 'android',
          'TARGET_ARCH': 'arm',
          'TARGET_BITS': 32,
        },
        'gclient_apply_config': ['android'],
      },
      'Chromium Mojo Windows': {
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_PLATFORM': 'win',
        },
      },
    },
  },
})

Exemple #8
0
  'emulator',
  'depot_tools/gclient',
  'recipe_engine/path',
  'recipe_engine/properties',
  'recipe_engine/step',
]

REPO_URL = 'https://chromium.googlesource.com/chromium/src.git'

UNITTESTS = freeze([
  ['android_webview_unittests', None],
  ['base_unittests', ['base', 'base_unittests.isolate']],
  ['cc_unittests', None],
  ['components_unittests', ['components', 'components_unittests.isolate']],
  ['events_unittests', None],
  ['gl_tests', None],
  ['ipc_tests', None],
  ['skia_unittests', None],
  ['sql_unittests', ['sql', 'sql_unittests.isolate']],
  ['sync_unit_tests', ['sync', 'sync_unit_tests.isolate']],
  ['ui_android_unittests', None],
  ['ui_touch_selection_unittests', None],
])

BUILDERS = freeze({
  'chromium.fyi':{
    'Android Tests (x86 emulator)': {
      'config': 'x86_builder',
      'target': 'Debug',
      'abi': 'x86',
      'api_level': 23,
      'unittests': UNITTESTS,
Exemple #9
0
# found in the LICENSE file.

from recipe_engine.types import freeze


DEPS = [
  'path',
  'shutil',
  'step',
]

TEST_CONTENTS = freeze({
  'simple': 'abcde',
  'spaces': 'abcde fgh',
  'symbols': '! ~&&',
  'multiline': '''ab
cd
efg
''',
})


def RunSteps(api):
  # remove demo.
  api.shutil.remove('foo', 'bar')

  # listdir demo.
  result = api.shutil.listdir('fake dir', '/fake/dir')
  for element in result:
    api.step('manipulate %s' % str(element), ['some', 'command'])
Exemple #10
0
  'recipe_engine/path',
  'recipe_engine/properties',
  'recipe_engine/step',
]

REPO_URL = 'https://chromium.googlesource.com/chromium/src.git'
BUILDERS = freeze({
  'chromium.fyi':{
    'Disable settings after launch emulator': {
      'config': 'x86_builder',
      'target': 'Debug',
      'abi': 'x86',
      'api_level': 23,
      'partition_size': '1024M',
      'sdcard_size': '512M',
      'provision_settings': {
        'disable_location': True,
        'disable_network': True,
        'disable_system_chrome': True,
        'remove_system_webview': True,
      },
      'sample_gtest_suite': ['sample_test', 'sample_isolate_file'],
    }
  }
})

PROPERTIES = {
  'buildername': Property(),
  'mastername': Property(),
}
Exemple #11
0
RECIPE_CONFIGS = freeze({
  'webrtc': {
    'chromium_config': 'webrtc_standalone',
    'gclient_config': 'webrtc',
    'test_suite': 'webrtc',
  },
  'webrtc_gcc': {
    'chromium_config': 'webrtc_gcc',
    'gclient_config': 'webrtc',
  },
  'webrtc_baremetal': {
    'chromium_config': 'webrtc_standalone',
    'gclient_config': 'webrtc',
    'test_suite': 'webrtc_baremetal',
  },
  'webrtc_clang': {
    'chromium_config': 'webrtc_clang',
    'gclient_config': 'webrtc',
    'test_suite': 'webrtc',
  },
  'webrtc_android': {
    'chromium_config': 'android',
    'chromium_android_config': 'webrtc',
    'gclient_config': 'webrtc',
    'gclient_apply_config': ['android'],
    'test_suite': 'android',
  },
  'webrtc_android_clang': {
    'chromium_config': 'android_clang',
    'chromium_android_config': 'webrtc',
    'gclient_config': 'webrtc',
    'gclient_apply_config': ['android'],
  },
  'webrtc_android_asan': {
    'chromium_config': 'android_asan',
    'chromium_android_config': 'webrtc',
    'gclient_config': 'webrtc',
    'gclient_apply_config': ['android'],
    'test_suite': 'android',
  },
  'webrtc_ios': {
    'chromium_config': 'webrtc_ios',
    'gclient_config': 'webrtc_ios',
  },
})
Exemple #12
0
BUILDERS = freeze({
  'chromium': chromium.SPEC,
  'chromium.android': chromium_android.SPEC,
  'chromium.chrome': chromium_chrome.SPEC,
  'chromium.chromiumos': chromium_chromiumos.SPEC,
  'chromium.fyi': chromium_fyi.SPEC,
  'chromium.goma': chromium_goma.SPEC,
  'chromium.gpu': chromium_gpu.SPEC,
  'chromium.gpu.fyi': chromium_gpu_fyi.SPEC,
  'chromium.linux': chromium_linux.SPEC,
  'chromium.lkgr': chromium_lkgr.SPEC,
  'chromium.mac': chromium_mac.SPEC,
  'chromium.memory': chromium_memory.SPEC,
  'chromium.memory.fyi': chromium_memory_fyi.SPEC,
  'chromium.mojo': chromium_mojo.SPEC,
  'chromium.perf': chromium_perf.SPEC,
  'chromium.perf.fyi': chromium_perf_fyi.SPEC,
  'chromium.webkit': chromium_webkit.SPEC,
  'chromium.webrtc': chromium_webrtc.SPEC,
  'chromium.webrtc.fyi': chromium_webrtc_fyi.SPEC,
  'chromium.win': chromium_win.SPEC,
  'client.skia': client_skia.SPEC,
  'client.v8.fyi': client_v8_fyi.SPEC,
  'tryserver.chromium.linux': tryserver_chromium_linux.SPEC,
  'tryserver.chromium.mac': tryserver_chromium_mac.SPEC,
  'tryserver.chromium.perf': tryserver_chromium_perf.SPEC,

  # Additional build configurations to test against for coverage. This is useful
  # when adding configuration options that will only be exercised in other
  # repositories.
  #
  # Note that this master is not real, and consequently this build configuration
  # will never be used in production.
  'bot_update.always_on': {
    'builders': {
      'coverage_clobber': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'clobber': True,
        'archive_build': True,
        'testing': {
          'platform': 'linux',
        },
        'gs_bucket': 'invalid',
      },
    },
  },
})
Exemple #13
0
  'filter',
  'depot_tools/gclient',
  'recipe_engine/json',
  'recipe_engine/path',
  'recipe_engine/properties',
  'recipe_engine/step',
  'depot_tools/tryserver',
]

CHROMIUM_AMP_INSTRUMENTATION_TESTS = freeze([
  {
    'gyp_target': 'content_shell_test_apk',
    'apk_under_test': 'ContentShell.apk',
    'test_apk': 'ContentShellTest.apk',
    'isolate_file_path': ['content', 'content_shell_test_apk.isolate'],
  },
  {
    'gyp_target': 'chrome_public_test_apk',
    'apk_under_test': 'ChromePublic.apk',
    'test_apk': 'ChromePublicTest.apk',
    'isolate_file_path': ['chrome', 'chrome_public_test_apk.isolate'],
  },
])

CHROMIUM_AMP_UNITTESTS = freeze([
  ['android_webview_unittests', None],
  ['base_unittests', ['base', 'base_unittests.isolate']],
  ['cc_unittests', None],
  ['components_unittests', ['components', 'components_unittests.isolate']],
  ['events_unittests', None],
  ['gl_tests', None],
  ['ipc_tests', None],
Exemple #14
0
BUILDERS = freeze({
    'basic_builder': {
        'target': 'Release',
        'build': True,
    },
    'restart_usb_builder': {
        'restart_usb': True,
        'target': 'Release',
        'build': True,
    },
    'coverage_builder': {
        'coverage': True,
        'target': 'Debug',
        'build': True,
    },
    'tester': {},
    'perf_runner': {
        'perf_config': 'sharded_perf_tests.json',
    },
    'perf_runner_user_build': {
        'perf_config': 'sharded_perf_tests.json',
        'skip_wipe': True,
    },
    'perf_runner_disable_location': {
        'perf_config': 'sharded_perf_tests.json',
        'disable_location': True,
    },
    'perf_runner_allow_low_battery': {
        'perf_config': 'sharded_perf_tests.json',
        'min_battery_level': 50,
    },
    'perf_adb_vendor_keys': {
        'adb_vendor_keys': True,
    },
    'perf_runner_allow_high_battery_temp': {
        'perf_config': 'sharded_perf_tests.json',
        'max_battery_temp': 500,
    },
    'gerrit_try_builder': {
        'build': True,
        'skip_wipe': True,
    },
    'java_method_count_builder': {
        'build': True,
        'java_method_count': True,
    },
    'webview_tester': {
        'remove_system_webview': True,
        'disable_system_chrome': True,
    },
    'slow_tester': {
        'timeout_scale': 2,
    },
    'specific_install_tester': {
        'specific_install': True,
    },
    'downgrade_install_tester': {
        'downgrade': True,
    },
    'no_strict_mode_tester': {
        'strict_mode': 'off',
    },
    'resource_size_builder': {
        'resource_size': True,
    },
    'webview_cts': {
        'run_webview_cts': True,
    },
    'last_known_devices': {
      'perf_config': 'sharded_perf_tests.json',
      'last_known_devices': '.last_devices',
    },
    'device_flags_builder': {
      'device_flags': 'device_flags_file',
    }
})
Exemple #15
0
  'recipe_engine/properties',
  'recipe_engine/step',
  'depot_tools/tryserver',
]

RECIPE_CONFIGS = freeze({
  'libyuv': {
    'chromium_config': 'libyuv',
    'gclient_config': 'libyuv',
  },
  'libyuv_clang': {
    'chromium_config': 'libyuv_clang',
    'gclient_config': 'libyuv',
  },
  'libyuv_android': {
    'chromium_config': 'libyuv_android',
    'gclient_config': 'libyuv_android',
  },
  'libyuv_android_clang': {
    'chromium_config': 'libyuv_android_clang',
    'gclient_config': 'libyuv_android',
  },
  'libyuv_ios': {
    'chromium_config': 'libyuv_ios',
    'gclient_config': 'libyuv_ios',
  },
})

BUILDERS = freeze({
  'client.libyuv': {
    'builders': {
      'Win32 Debug (VS2010)': {
Exemple #16
0
BUILDERS = freeze({
  'local_test': {
    'recipe_config': 'main_builder',
    'run_tests': True,
    'kwargs': {
      'BUILD_CONFIG': 'Debug',
      'REPO_URL': 'https://chromium.googlesource.com/chromium/src.git',
      'REPO_NAME': 'src',
    },
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_local_test_builder',
    },
    'gyp_defs': {
      'use_goma': 0,
    }
  },
  'Android Cronet Builder (dbg)': {
    'recipe_config': 'main_builder',
    'run_tests': True,
    'kwargs': {
      'BUILD_CONFIG': 'Debug',
    },
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_builder_dbg',
    },
  },
  'Android Cronet Builder': {
    'recipe_config': 'main_builder',
    'run_tests': True,
    'kwargs': {
      'BUILD_CONFIG': 'Release',
      'REPO_NAME': 'src',
    },
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_builder',
    },
  },
  'Android Cronet ARMv6 Builder': {
    'recipe_config': 'main_builder',
    'run_tests': True,
    'kwargs': {
      'BUILD_CONFIG': 'Release',
    },
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_armv6_builder',
    },
    'gyp_defs': {
      'arm_version': 6
    }
  },
  'Android Cronet ARM64 Builder': {
    'recipe_config': 'arm64_builder',
    'run_tests': False,
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_arm64_builder',
    },
    'kwargs': {
      'BUILD_CONFIG': 'Release',
    },
  },
  'Android Cronet ARM64 Builder (dbg)': {
    'recipe_config': 'arm64_builder',
    'run_tests': False,
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_arm64_builder_dbg',
    },
    'kwargs': {
      'BUILD_CONFIG': 'Debug',
    },
  },
  'Android Cronet x86 Builder': {
    'recipe_config': 'x86_builder',
    'run_tests': False,
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_x86_builder',
    },
    'kwargs': {
      'BUILD_CONFIG': 'Release',
    },
  },
  'Android Cronet x86 Builder (dbg)': {
    'recipe_config': 'x86_builder',
    'run_tests': False,
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_x86_builder_dbg',
    },
    'kwargs': {
      'BUILD_CONFIG': 'Debug',
    },
  },
  'Android Cronet MIPS Builder': {
    'recipe_config': 'mipsel_builder',
    'run_tests': False,
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_mips_builder',
    },
    'kwargs': {
      'BUILD_CONFIG': 'Release',
    },
  },
  'android_cronet_tester': {
    'recipe_config': 'main_builder',
    'run_tests': True,
    'kwargs': {
      'BUILD_CONFIG': 'Debug',
    },
    'gyp_defs': {
      'enable_data_reduction_proxy_support': 1,
    }
  },
  'Android Cronet Data Reduction Proxy Builder': {
    'recipe_config': 'main_builder',
    'run_tests': True,
    'cronet_kwargs': {
      'PERF_ID': 'android_cronet_data_reduction_proxy_builder',
    },
    'kwargs': {
      'BUILD_CONFIG': 'Release',
    },
    'gyp_defs': {
      'enable_data_reduction_proxy_support': 1,
    }
  },
})
Exemple #17
0
  'recipe_engine/json',
  'recipe_engine/path',
  'recipe_engine/platform',
  'recipe_engine/properties',
  'recipe_engine/python',
  'recipe_engine/raw_io',
  'rietveld',
  'recipe_engine/step',
  'tryserver',
]

from recipe_engine.recipe_api import Property
from recipe_engine.types import freeze

PROPERTIES = {
  'mastername': Property(default=None),
  'buildername': Property(default=None),
  'slavename': Property(default=None),
  'issue': Property(default=None),
  'patchset': Property(default=None),
  'patch_url': Property(default=None),
  'patch_project': Property(default=None),
  'repository': Property(default=None),
  'event.patchSet.ref': Property(default=None, param_name="gerrit_ref"),
  'rietveld': Property(default=None),
  'revision': Property(default=None),
  'parent_got_revision': Property(default=None),
  'deps_revision_overrides': Property(default=freeze({})),
  'fail_patch': Property(default=None, kind=str),
}
Exemple #18
0
# Constants
ANDROID_TOOLS_GIT = 'https://chromium.googlesource.com/android_tools'
TEST_FILES_URL = 'http://downloads.webmproject.org/test_data/libvpx'

# Device root is a special folder on the device which we have permissions to
# read / write
DEVICE_ROOT = '/data/local/tmp'

# TODO (joshualitt) the configure script is messed up so we need a relative
# path.  Essentially, it must be using argv[0] when invoking some of the
# scripts in the libvpx directory
CONFIGURE_PATH_REL = './libvpx/configure'

BUILDER_TO_DEVICE = freeze({
  'Nexus 5 Builder' : 'nexus_5',
  'Nexus 7 Builder': 'nexus_7'
})

from recipe_engine.recipe_api import Property

PROPERTIES = {
  'libvpx_git_url': Property(),
  'buildername': Property(),
}

def RunSteps(api, libvpx_git_url, buildername):
  # Paths and other constants
  build_root = api.path['slave_build']

  # Android tools DEPS
  android_tools_root = build_root.join('android_tools')
Exemple #19
0
  'depot_tools/gclient',
  'recipe_engine/platform',
  'recipe_engine/properties',
  'recipe_engine/step',
]

BUILDERS = freeze({
  'chromium.fyi': {
    'Android ChromeDriver Tests (dbg)': {
      'chromedriver_platform': 'android',
      'config': 'main_builder',
      'target': 'Debug',
      'update_test_log': True,
      'android_packages': [
        'chrome_beta',
        'chrome_public',
        'chrome_stable',
        'chromedriver_webview_shell',
      ],
      'install_apks': [
        'ChromeDriverWebViewShell.apk',
        'ChromePublic.apk',
      ],
    },
  },
})

REPO_URL = 'https://chromium.googlesource.com/chromium/src.git'

def RunSteps(api):
  mastername = api.properties['mastername']
  buildername = api.properties['buildername']
Exemple #20
0
Isolating a test is required in order to run it using this recipe.
"""

from recipe_engine.types import freeze

DEPS = [
    'chromium',
    'isolate',
    'properties',
    'swarming_client',
]

# TODO(nodir): pass these arguments from builder to tester once triggering from
# recipes lands. This is needed for ARM testers http://crbug.com/359338
TEST_ARGS = freeze({
    'browser_tests': ['--gtest_filter=*NaCl*.*'],
    'sandbox_linux_unittests': ['--test-launcher-print-test-stdio=always'],
})


def RunSteps(api):
    config_name = api.properties.get('chromium_config') or 'chromium'
    api.chromium.set_config(config_name)

    api.swarming_client.checkout()

    revision = api.properties['parent_got_revision']
    webkit_revision = api.properties['parent_got_webkit_revision']
    for test in sorted(api.isolate.isolated_tests):
        api.isolate.runtest(test,
                            revision,
                            webkit_revision,
Exemple #21
0
  'depot_tools/gclient',
  'file',
  'recipe_engine/path',
  'recipe_engine/platform',
  'recipe_engine/properties',
  'recipe_engine/python',
  'recipe_engine/step',
  'v8',
]

BUILDERS = freeze({
  'client.v8.fyi': {
    'builders': {
      'V8 - node.js integration - lkgr': {
        'testing': {
          'platform': 'linux',
        },
      },
    },
  },
})


def _build_and_test(api, suffix=''):
  api.step(
    'configure node.js%s' % suffix,
    [api.path['slave_build'].join('node.js', 'configure')],
    cwd=api.path['slave_build'].join('node.js'),
  )

  api.step(
Exemple #22
0
    'recipe_engine/path',
    'recipe_engine/properties',
    'recipe_engine/python',
    'recipe_engine/raw_io',
    'recipe_engine/runtime',
    'recipe_engine/step',
]

BUILDERS = freeze({
    'chromium-lkgr-finder': {
        'project': 'chromium',
        'repo': 'https://chromium.googlesource.com/chromium/src',
        'ref': 'refs/heads/lkgr',
        'lkgr_status_gs_path': 'chromium-v8/chromium-lkgr-status',
    },
    'V8 lkgr finder': {
        'project': 'v8',
        'repo': 'https://chromium.googlesource.com/v8/v8',
        'ref': 'refs/heads/lkgr',
        'lkgr_status_gs_path': 'chromium-v8/lkgr-status',
        'allowed_lag': 4,
    },
})

PROPERTIES = {
    'project':
    Property(
        kind=str,
        default=None,
        help='Project for which LKGR should be calculated.',
    ),
Exemple #23
0
    },
    'test_args': ['--no-pixel-tests'],
    'additional_expectations': [
      'v8', 'tools', 'blink_tests', 'TestExpectations',
    ],
    'component': {'path': 'src/v8', 'revision': '%s'},
    'testing': {'platform': platform},
  }


BUILDERS = freeze({
  'client.v8.fyi': {
    'builders': {
      'V8-Blink Win': V8Builder('Release', 32, 'win'),
      'V8-Blink Mac': V8Builder('Release', 64, 'mac'),
      'V8-Blink Linux 32': V8Builder('Release', 32, 'linux'),
      'V8-Blink Linux 64': V8Builder('Release', 64, 'linux'),
      'V8-Blink Linux 64 (dbg)': V8Builder('Debug', 64, 'linux'),
    },
  },
})


def RunSteps(api):
  mastername = api.properties.get('mastername')
  buildername = api.properties.get('buildername')
  master_dict = BUILDERS.get(mastername, {})
  bot_config = master_dict.get('builders', {}).get(buildername)

  # Sync chromium to HEAD.
  api.gclient.set_config('chromium')
Exemple #24
0
BUILDERS = freeze({
  'chromium': chromium.SPEC,
  'chromium.android': chromium_android.SPEC,
  'chromium.android.fyi': chromium_android_fyi.SPEC,
  'chromium.chrome': chromium_chrome.SPEC,
  'chromium.chromiumos': chromium_chromiumos.SPEC,
  'chromium.fyi': chromium_fyi.SPEC,
  'chromium.goma': chromium_goma.SPEC,
  'chromium.gpu': chromium_gpu.SPEC,
  'chromium.gpu.fyi': chromium_gpu_fyi.SPEC,
  'chromium.linux': chromium_linux.SPEC,
  'chromium.lkgr': chromium_lkgr.SPEC,
  'chromium.mac': chromium_mac.SPEC,
  'chromium.memory': chromium_memory.SPEC,
  'chromium.perf': chromium_perf.SPEC,
  'chromium.perf.fyi': chromium_perf_fyi.SPEC,
  'chromium.swarm': chromium_swarm.SPEC,
  'chromium.webkit': chromium_webkit.SPEC,
  'chromium.webrtc': chromium_webrtc.SPEC,
  'chromium.webrtc.fyi': chromium_webrtc_fyi.SPEC,
  'chromium.win': chromium_win.SPEC,
  'client.skia': client_skia.SPEC,
  'client.v8.chromium': client_v8_chromium.SPEC,
  'client.v8.fyi': client_v8_fyi.SPEC,
  'tryserver.chromium.mac': tryserver_chromium_mac.SPEC,
  'tryserver.chromium.perf': tryserver_chromium_perf.SPEC,

  # Additional build configurations to test against for coverage. This is useful
  # when adding configuration options that will only be exercised in other
  # repositories.
  #
  # Note that this master is not real, and consequently this build configuration
  # will never be used in production.
  'bot_update.always_on': {
    'builders': {
      'coverage_clobber': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'clobber': True,
        'archive_build': True,
        'testing': {
          'platform': 'linux',
        },
        'gs_bucket': 'invalid',
      },
    },
  },
})
# See
# https://code.google.com/p/chromium/codesearch#chromium/src/tools/binary_size/template/D3SymbolTreeMap.js&l=74
SYMBOL_MAP = freeze({
    'A': 'global_absolute',
    'B': 'global_uninitialized_data',
    'b': 'local_uninitialized_data',
    'C': 'global_uninitialized_common',
    'D': 'global_initialized_data',
    'd': 'local_initialized_data',
    'G': 'global_small initialized_data',
    'g': 'local_small_initialized_data',
    'i': 'indirect_function',
    'N': 'debugging',
    'p': 'stack_unwind',
    'R': 'global_read_only_data',
    'r': 'local_read_only_data',
    'S': 'global_small_uninitialized_data',
    's': 'local_small_uninitialized_data',
    'T': 'global_code',
    't': 'local_code',
    'U': 'undefined',
    'u': 'unique',
    'V': 'global_weak_object',
    'v': 'local_weak_object',
    'W': 'global_weak_symbol',
    'w': 'local_weak_symbol',
    '@': 'vtable_entry',
    '-': 'stabs_debugging',
    '?': 'unrecognized',
})

Exemple #26
0
BUILDERS = freeze({
  'chromium.android': {
    'Android x64 Builder (dbg)': {
      'recipe_config': 'x64_builder_mb',
      'check_licenses': FYIStep,
      'gclient_apply_config': ['android', 'chrome_internal'],
    },
    'Android x86 Builder (dbg)' : {
      'recipe_config': 'x86_builder_mb',
      'check_licenses': FYIStep,
      'gclient_apply_config': ['android', 'chrome_internal'],
    },
    'Android MIPS Builder (dbg)': {
      'recipe_config': 'mipsel_builder_mb',
      'check_licenses': FYIStep,
      'gclient_apply_config': ['android', 'chrome_internal'],
    },
  },
  'chromium.perf.fyi': {
    'android_oilpan_builder': {
      'recipe_config': 'oilpan_builder',
      'gclient_apply_config': ['android', 'chrome_internal'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      'upload': {
        'bucket': 'chromium-android',
        'path': lambda api: (
          '%s/build_product_%s.zip' % (api.properties['buildername'],
                                       api.properties['revision'])),
      }
    }
  },
  'chromium.perf': {
    'Android Builder': {
      'recipe_config': 'main_builder_rel_mb',
      'gclient_apply_config': ['android', 'perf'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      'upload': {
        'bucket': 'chrome-perf',
        'path': lambda api: ('android_perf_rel/full-build-linux_%s.zip'
                             % api.properties['revision']),
      },
      'run_mb': True,
      'targets': [
        'android_tools',
        'cc_perftests',
        'chrome_public_apk',
        'gpu_perftests',
      ],
    },
    'Android arm64 Builder': {
      'recipe_config': 'arm64_builder_rel_mb',
      'gclient_apply_config': ['android', 'perf'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      'upload': {
        'bucket': 'chrome-perf',
        'path': lambda api: (
            'android_perf_rel_arm64/full-build-linux_%s.zip'
            % api.properties['revision']),
      },
      'run_mb': True,
      'targets': [
        'android_tools',
        'cc_perftests',
        'chrome_public_apk',
        'gpu_perftests',
      ],
    }
  },
  'tryserver.chromium.perf': {
    'android_perf_bisect_builder': {
      'recipe_config': 'perf',
      'gclient_apply_config': ['android', 'perf'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      # Perf bisect builders uses custom file names for binaries with
      # DEPS changes, and the logic for this is in zip_build.py.
      'zip_and_upload': {
        'bucket': 'chrome-perf',
      }
    },
    'android_arm64_perf_bisect_builder': {
      'recipe_config': 'arm64_builder',
      'gclient_apply_config': ['android', 'perf'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      # Perf bisect builders uses custom file names for binaries with
      # DEPS changes, and the logic for this is in zip_build.py.
      'zip_and_upload': {
        'bucket': 'chrome-perf',
      }
    },
  },
  'client.v8.fyi': {
    'Android Builder': {
      'recipe_config': 'perf',
      'gclient_apply_config': [
        'android',
        'perf',
        'v8_bleeding_edge_git',
        'chromium_lkcr',
        'show_v8_revision',
      ],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      'upload': {
        'bucket': 'v8-android',
        'path': lambda api: ('v8_android_perf_rel/full-build-linux_%s.zip'
                             % api.properties['revision']),
      },
      'set_component_rev': {'name': 'src/v8', 'rev_str': '%s'},
    }
  },
})
Exemple #27
0
  return master_spec

def _ChromiumPerfFyiTesters():
  testers = [
    _CreateTestSpec('Android Power Nexus 5X Perf', 'android-power-nexus-5x',
        required_apks=['ChromePublic.apk'], num_device_shards=7,
        num_host_shards=1),
  ]

  master_spec = {}
  for spec in testers:
    master_spec.update(spec)
  return master_spec

BUILDERS = freeze({
  'chromium.perf': _ChromiumPerfTesters(),
  'chromium.perf.fyi': _ChromiumPerfFyiTesters(),
})


def RunSteps(api):
  mastername = api.properties['mastername']
  buildername = api.properties['buildername']
  # TODO(akuegel): Move the configs in builders.py in chromium_tests to this
  # recipe, and get rid of duplications.
  builder = dict(BUILDERS[mastername][buildername])
  builder_config = builder.get('recipe_config', 'base_config')
  kwargs = {
    'REPO_NAME':'src',
    'REPO_URL':REPO_URL,
    'INTERNAL':False,
    'BUILD_CONFIG':'Release',
Exemple #28
0
BUILDERS = freeze({
  'tryserver.v8': {
    'builders': {
      'v8_linux_chromium_gn_rel': {
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_PLATFORM': 'linux',
          'TARGET_BITS': 64,
        },
        'gclient_apply_config': [
          'v8_bleeding_edge_git',
          'chromium_lkcr',
          'show_v8_revision',
        ],
        'root_override': 'src/v8',
        'set_component_rev': {'name': 'src/v8', 'rev_str': '%s'},
      },
      'v8_android_chromium_gn_dbg': {
        'chromium_apply_config': ['gn_minimal_symbols'],
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Debug',
          'TARGET_PLATFORM': 'android',
          'TARGET_ARCH': 'arm',
        },
        'gclient_apply_config': [
          'android',
          'v8_bleeding_edge_git',
          'chromium_lkcr',
          'show_v8_revision',
        ],
        'root_override': 'src/v8',
        'set_component_rev': {'name': 'src/v8', 'rev_str': '%s'},
      },
    },
  },
  'client.v8.fyi': {
    'builders': {
      'V8 Linux GN': {
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_PLATFORM': 'linux',
          'TARGET_BITS': 64,
        },
        'gclient_apply_config': [
          'v8_bleeding_edge_git',
          'chromium_lkcr',
          'show_v8_revision',
        ],
        'set_component_rev': {'name': 'src/v8', 'rev_str': '%s'},
      },
      'V8 Android GN (dbg)': {
        'chromium_apply_config': ['gn_minimal_symbols'],
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Debug',
          'TARGET_PLATFORM': 'android',
          'TARGET_ARCH': 'arm',
        },
        'gclient_apply_config': [
          'android',
          'v8_bleeding_edge_git',
          'chromium_lkcr',
          'show_v8_revision',
        ],
        'set_component_rev': {'name': 'src/v8', 'rev_str': '%s'},
      },
    },
  },
})
Exemple #29
0
  'recipe_engine/python',
  'recipe_engine/raw_io',
  'recipe_engine/step',
  'v8',
]

AUTO_REVIEWERS = [
  '*****@*****.**',
  '*****@*****.**',
  '*****@*****.**',
]
BASE_URL = 'https://chromium.googlesource.com'
V8_REPO = BASE_URL + '/v8/v8'
CR_REPO = BASE_URL + '/chromium/src'
V8_DEPS_DIFFS = freeze({
  'tools/gyp': 'build/gyp',
})

# Skip these dependencies (list without solution name prefix).
BLACKLIST = [
  'test/mozilla/data',
  'test/simdjs/data',
  'test/test262/data',
]

def GetDEPS(api, name, repo):
  # Make a fake spec. Gclient is not nice to us when having two solutions
  # side by side. The latter checkout kills the former's gclient file.
  spec = ('solutions=[{'
      '\'managed\':False,'
      '\'name\':\'%s\','
Exemple #30
0
from recipe_engine.types import freeze

DEPS = [
    'depot_tools/infra_paths',
    'file',
    'recipe_engine/path',
    'recipe_engine/raw_io',
    'recipe_engine/step',
]

TEST_CONTENTS = freeze({
    'simple': 'abcde',
    'spaces': 'abcde fgh',
    'symbols': '! ~&&',
    'multiline': '''ab
cd
efg
''',
})


def RunSteps(api):
    # listdir demo.
    result = api.file.listdir('fake dir', '/fake/dir')
    for element in result:
        api.step('manipulate %s' % str(element), ['some', 'command'])

    result = api.file.listdir('other', '/faker/dir')
    for element in result:
        api.step('manipulate %s' % str(element), ['some', 'command'])
DETERMINISTIC_BUILDERS = freeze({
  'Android deterministic': {
    'chromium_config': 'android',
    'chromium_config_kwargs': {
      'BUILD_CONFIG': 'Release',
      'TARGET_BITS': 32,
      'TARGET_PLATFORM': 'android',
    },
    'platform': 'linux',
    'targets': ['all'],
  },
  'Linux deterministic': {
    'chromium_config': 'chromium',
    'gclient_config': 'chromium',
    'platform': 'linux',
    'targets': ['all'],
  },
  'Mac deterministic': {
    'chromium_config': 'chromium',
    'gclient_config': 'chromium',
    'platform': 'mac',
    'targets': ['all'],
  },
  'Windows deterministic': {
    'chromium_config': 'chromium',
    'gclient_config': 'chromium',
    'platform': 'win',
    'targets': ['all'],
  },
  'Windows Clang deterministic': {
    'chromium_config': 'chromium_win_clang',
    'gclient_config': 'chromium',
    'platform': 'win',
    'targets': ['all'],
  },
})
Exemple #32
0
BUILDERS = freeze({
    'tryserver.chromium.linux': {
        'builders': {
            'linux_chromium_gn_upload': {
                'chromium_config_kwargs': {
                    'BUILD_CONFIG': 'Release',
                    'TARGET_PLATFORM': 'linux',
                    'TARGET_BITS': 64,
                },

                # We need this to pull the Linux sysroots.
                'gclient_apply_config': ['chrome_internal'],
            },
        },
    },
    'tryserver.chromium.mac': {
        'builders': {
            'mac_chromium_gn_upload': {
                'chromium_config_kwargs': {
                    'BUILD_CONFIG': 'Release',
                    'TARGET_PLATFORM': 'mac',
                    'TARGET_BITS': 64,
                },
            },
        },
    },
    'tryserver.chromium.win': {
        'builders': {
            'win8_chromium_gn_upload': {
                'chromium_config_kwargs': {
                    'BUILD_CONFIG': 'Release',
                    'TARGET_PLATFORM': 'win',
                    'TARGET_BITS': 32,
                },
            },
        },
    },
})
  'recipe_engine/properties',
  'recipe_engine/python',
  'recipe_engine/raw_io',
  'recipe_engine/step',
  'swarming',
  'test_results',
  'test_utils',
  'depot_tools/tryserver',
]


# TODO(phajdan.jr): Remove special case for layout tests.
# This could be done by moving layout tests to main waterfall.
CHROMIUM_BLINK_TESTS_BUILDERS = freeze([
  'linux_blink_oilpan_rel',
  'linux_chromium_rel_ng',
  'mac_chromium_rel_ng',
  'win_chromium_rel_ng',
])


CHROMIUM_BLINK_TESTS_EXTRA_ARGS = freeze({
  'linux_blink_oilpan_rel': [
    '--additional-expectations',
    'src/third_party/WebKit/LayoutTests/OilpanExpectations',
  ],
})


CHROMIUM_BLINK_TESTS_PATHS = freeze([
  # Service worker code is primarily tested in Blink layout tests.
  'content/browser/bluetooth',
Exemple #34
0
from recipe_engine.types import freeze
from recipe_engine.recipe_api import Property

DEPS = [
    'cronet',
    'properties',
]

BUILDERS = freeze({
    'local_test': {
        'recipe_config': 'main_builder',
        'run_tests': True,
        'upload_package': True,
        'kwargs': {
            'BUILD_CONFIG': 'Debug',
        },
        'gyp_defs': {
            'use_goma': 0,
        }
    },
})

PROPERTIES = {
    'buildername': Property(),
}


def RunSteps(api, buildername):
    builder_config = BUILDERS.get(buildername, {})
    recipe_config = builder_config['recipe_config']
Exemple #35
0
    'recipe_engine/python',
    'recipe_engine/raw_io',
    'recipe_engine/step',
    'v8',
]

AUTO_REVIEWERS = [
    '*****@*****.**',
    '*****@*****.**',
    '*****@*****.**',
]
BASE_URL = 'https://chromium.googlesource.com'
V8_REPO = BASE_URL + '/v8/v8'
CR_REPO = BASE_URL + '/chromium/src'
V8_DEPS_DIFFS = freeze({
    'tools/gyp': 'build/gyp',
})

# Skip these dependencies (list without solution name prefix).
BLACKLIST = [
    'test/mozilla/data',
    'test/simdjs/data',
    'test/test262/data',
]


def GetDEPS(api, name, repo):
    # Make a fake spec. Gclient is not nice to us when having two solutions
    # side by side. The latter checkout kills the former's gclient file.
    spec = ('solutions=[{'
            '\'managed\':False,'
BUILDERS = freeze({
    'tryserver.chromium.linux': {
        'builders': {
            'linux_upload_clang': {
                'chromium_config_kwargs': {
                    'BUILD_CONFIG': 'Release',
                    'TARGET_PLATFORM': 'linux',
                    'TARGET_BITS': 64,
                },

                # We need this to build the Clang toolchain
                # with proper AddressSanitizer prebuilts for
                # Chrome on Android.
                'gclient_apply_config': ['android'],
            },
        },
    },
    'tryserver.chromium.mac': {
        'builders': {
            'mac_upload_clang': {
                'chromium_config_kwargs': {
                    'BUILD_CONFIG': 'Release',
                    'TARGET_PLATFORM': 'mac',
                    'TARGET_BITS': 64,
                },
            },
        },
    },
    'tryserver.chromium.win': {
        'builders': {
            'win_upload_clang': {
                'chromium_config_kwargs': {
                    'BUILD_CONFIG': 'Release',
                    'TARGET_PLATFORM': 'win',
                    'TARGET_BITS': 32,
                },
            },
        },
    },
})
Exemple #37
0
PGO_BUILDERS = freeze({
  'chromium.fyi': {
    'Chromium Win PGO Builder': {
      'recipe_config': 'chromium',
      'chromium_config_instrument': 'chromium_pgo_instrument',
      'chromium_config_optimize': 'chromium_pgo_optimize',
      'gclient_config': 'chromium',
      'clobber': True,
      'chromium_config_kwargs': {
        'BUILD_CONFIG': 'Release',
        'TARGET_BITS': 32,
      },
      'testing': {
        'platform': 'win',
      },
    },
    'Chromium Win x64 PGO Builder': {
      'recipe_config': 'chromium',
      'chromium_config_instrument': 'chromium_pgo_instrument',
      'chromium_config_optimize': 'chromium_pgo_optimize',
      'gclient_config': 'chromium',
      'clobber': True,
      'chromium_config_kwargs': {
        'BUILD_CONFIG': 'Release',
        'TARGET_BITS': 64,
      },
    },
  },
  'tryserver.chromium.win': {
    'win_pgo': {
      'recipe_config': 'chromium',
      'chromium_config_instrument': 'chromium_pgo_instrument',
      'chromium_config_optimize': 'chromium_pgo_optimize',
      'gclient_config': 'chromium',
      'chromium_config_kwargs': {
        'BUILD_CONFIG': 'Release',
        'TARGET_BITS': 32,
      },
      'testing': {
        'platform': 'win',
      },
    },
  },
})
Exemple #38
0
BUILDERS = freeze({
    'basic_builder': {
        'target': 'Release',
        'build': True,
    },
    'restart_usb_builder': {
        'restart_usb': True,
        'target': 'Release',
        'build': True,
    },
    'coverage_builder': {
        'coverage': True,
        'target': 'Debug',
        'build': True,
    },
    'tester': {},
    'perf_runner': {
        'perf_config': 'sharded_perf_tests.json',
    },
    'perf_runner_user_build': {
        'perf_config': 'sharded_perf_tests.json',
        'skip_wipe': True,
    },
    'perf_runner_disable_location': {
        'perf_config': 'sharded_perf_tests.json',
        'disable_location': True,
    },
    'perf_runner_allow_low_battery': {
        'perf_config': 'sharded_perf_tests.json',
        'min_battery_level': 50,
    },
    'perf_adb_vendor_keys': {
        'adb_vendor_keys': True,
    },
    'perf_runner_allow_high_battery_temp': {
        'perf_config': 'sharded_perf_tests.json',
        'max_battery_temp': 500,
    },
    'gerrit_try_builder': {
        'build': True,
        'skip_wipe': True,
    },
    'java_method_count_builder': {
        'build': True,
        'java_method_count': True,
    },
    'webview_tester': {
        'remove_system_webview': True,
        'disable_system_chrome': True,
    },
    'slow_tester': {
        'timeout_scale': 2,
    },
    'specific_install_tester': {
        'specific_install': True,
    },
    'downgrade_install_tester': {
        'downgrade': True,
    },
    'no_strict_mode_tester': {
        'strict_mode': 'off',
    },
    'resource_size_builder': {
        'resource_size': True,
    },
    'webview_cts': {
        'run_webview_cts': True,
    },
    'last_known_devices': {
        'perf_config': 'sharded_perf_tests.json',
        'last_known_devices': '.last_devices',
    },
    'device_flags_builder': {
        'device_flags': 'device_flags_file',
    }
})
Exemple #39
0
BUILDERS = freeze({
  'chromium.android': {
    'Android x64 Builder (dbg)': {
      'recipe_config': 'x64_builder',
      'check_licenses': FYIStep,
      'gclient_apply_config': ['android', 'chrome_internal'],
    },
    'Android x86 Builder (dbg)' : {
      'recipe_config': 'x86_builder',
      'check_licenses': FYIStep,
      'gclient_apply_config': ['android', 'chrome_internal'],
    },
    'Android MIPS Builder (dbg)': {
      'recipe_config': 'mipsel_builder',
      'check_licenses': FYIStep,
      'gclient_apply_config': ['android', 'chrome_internal'],
    },
  },
  'chromium.perf.fyi': {
    'android_oilpan_builder': {
      'recipe_config': 'oilpan_builder',
      'gclient_apply_config': ['android', 'chrome_internal'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      'upload': {
        'bucket': 'chromium-android',
        'path': lambda api: (
          '%s/build_product_%s.zip' % (api.properties['buildername'],
                                       api.properties['revision'])),
      }
    }
  },
  'chromium.perf': {
    'Android Builder': {
      'recipe_config': 'perf',
      'gclient_apply_config': ['android', 'perf'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      'upload': {
        'bucket': 'chrome-perf',
        'path': lambda api: ('android_perf_rel/full-build-linux_%s.zip'
                             % api.properties['revision']),
      }
    },
    'Android arm64 Builder': {
      'recipe_config': 'arm64_builder',
      'gclient_apply_config': ['android', 'perf'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      'upload': {
        'bucket': 'chrome-perf',
        'path': lambda api: (
            'android_perf_rel_arm64/full-build-linux_%s.zip'
            % api.properties['revision']),
      }
    }
  },
  'tryserver.chromium.perf': {
    'android_perf_bisect_builder': {
      'recipe_config': 'perf',
      'gclient_apply_config': ['android', 'perf'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      # Perf bisect builders uses custom file names for binaries with
      # DEPS changes, and the logic for this is in zip_build.py.
      'zip_and_upload': {
        'bucket': 'chrome-perf',
      }
    },
    'android_arm64_perf_bisect_builder': {
      'recipe_config': 'arm64_builder',
      'gclient_apply_config': ['android', 'perf'],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      # Perf bisect builders uses custom file names for binaries with
      # DEPS changes, and the logic for this is in zip_build.py.
      'zip_and_upload': {
        'bucket': 'chrome-perf',
      }
    },
  },
  'client.v8.fyi': {
    'Android Builder': {
      'recipe_config': 'perf',
      'gclient_apply_config': [
        'android',
        'perf',
        'v8_bleeding_edge_git',
        'chromium_lkcr',
        'show_v8_revision',
      ],
      'kwargs': {
        'BUILD_CONFIG': 'Release',
      },
      'upload': {
        'bucket': 'v8-android',
        'path': lambda api: ('v8_android_perf_rel/full-build-linux_%s.zip'
                             % api.properties['revision']),
      },
      'set_component_rev': {'name': 'src/v8', 'rev_str': '%s'},
    }
  },
})
Exemple #40
0
    'step',
]

REPO_URL = 'https://chromium.googlesource.com/chromium/src.git'

WEBVIEW_APK = 'SystemWebView.apk'

WEBVIEW_SHELL_APK = 'SystemWebViewShell.apk'

INSTRUMENTATION_TESTS = freeze([
    {
        'test': 'SystemWebViewShellLayoutTest',
        'gyp_target': 'system_webview_shell_layout_test_apk',
        'kwargs': {
            'install_apk': {
                'package': 'org.chromium.webview_shell.test',
                'apk': 'SystemWebViewShellLayoutTest.apk'
            },
            'isolate_file_path':
            'android_webview/system_webview_shell_test_apk.isolate',
        },
    },
])


def RunSteps(api):
    api.chromium_android.configure_from_properties('webview_perf',
                                                   REPO_NAME='src',
                                                   REPO_URL=REPO_URL,
                                                   INTERNAL=False,
                                                   BUILD_CONFIG='Release')
Exemple #41
0
TEST_CONFIGS = freeze({
    'benchmarks': {
        'name': 'Benchmarks',
        'tests': ['benchmarks'],
        'test_args': ['--download-data'],
    },
    'deopt': {
        'tool': 'run-deopt-fuzzer',
        'isolated_target': 'run-deopt-fuzzer',
    },
    'jsfunfuzz': {
        'tool': 'jsfunfuzz',
        'isolated_target': 'jsfunfuzz',
    },
    'gcmole': {
        'tool': 'run-gcmole',
        'isolated_target': 'run-gcmole',
    },
    'mjsunit': {
        'name': 'Mjsunit',
        'tests': ['mjsunit'],
    },
    'mjsunit_extra': {
        'name': 'Mjsunit - extra',
        'tests': ['mjsunit'],
        'variants': V8Variant('extra'),
    },
    'mjsunit_sp_frame_access': {
        'name': 'Mjsunit - sp frame access',
        'tests': ['mjsunit'],
        'test_args': ['--extra-flags=--turbo_sp_frame_access'],
        'variants': V8Variant('turbofan'),
    },
    'mozilla': {
        'name': 'Mozilla',
        'tests': ['mozilla'],
    },
    'optimize_for_size': {
        'name': 'OptimizeForSize',
        'tests': ['optimize_for_size'],
        'suite_mapping': ['mjsunit', 'cctest', 'webkit', 'intl'],
        'test_args': ['--extra-flags=--optimize-for-size'],
        'variants': V8Variant('default'),
    },
    'simpleleak': {
        'tool': 'run-valgrind',
        'isolated_target': 'run-valgrind',
    },
    'test262': {
        'name': 'Test262 - no variants',
        'tests': ['test262'],
        'test_args': ['--download-data'],
        'variants': V8Variant('default'),
    },
    'test262_extra': {
        'name': 'Test262 - extra',
        'tests': ['test262'],
        'test_args': ['--download-data'],
        'variants': V8Variant('extra'),
    },
    'test262_variants': {
        'name': 'Test262',
        'tests': ['test262'],
        'test_args': ['--download-data'],
    },
    'unittests': {
        'name': 'Unittests',
        'tests': ['unittests'],
    },
    'v8initializers': {
        'tool': 'check-static-initializers',
        'isolated_target': 'check-static-initializers',
    },
    'v8testing': {
        'name':
        'Check',
        'tests': ['bot_default'],
        'suite_mapping':
        ['mjsunit', 'cctest', 'webkit', 'message', 'preparser', 'intl'],
    },
    'v8testing_extra': {
        'name':
        'Check - extra',
        'tests': ['bot_default'],
        'suite_mapping':
        ['mjsunit', 'cctest', 'webkit', 'message', 'preparser', 'intl'],
        'variants':
        V8Variant('extra'),
    },
    'webkit': {
        'name': 'Webkit',
        'tests': ['webkit'],
    },
})
    'recipe_engine/path',
    'recipe_engine/properties',
    'recipe_engine/step',
]

REPO_URL = 'https://chromium.googlesource.com/chromium/src.git'
BUILDERS = freeze({
    'chromium.fyi': {
        'Disable settings after launch emulator': {
            'config': 'x86_builder',
            'target': 'Debug',
            'abi': 'x86',
            'api_level': 23,
            'partition_size': '1024M',
            'sdcard_size': '512M',
            'provision_settings': {
                'disable_location': True,
                'disable_network': True,
                'disable_system_chrome': True,
                'remove_system_webview': True,
            },
            'sample_gtest_suite': ['sample_test', 'sample_isolate_file'],
        }
    }
})

PROPERTIES = {
    'buildername': Property(),
    'mastername': Property(),
}
Exemple #43
0
PROPERTIES = {
  'buildername': Property(),
}


TEST_BUILDERS = freeze({
  'chromium_pgo.test' : {
    'Test builder': {
      'recipe_config': 'chromium',
      'chromium_config_instrument': 'chromium_pgo_instrument',
      'chromium_config_optimize': 'chromium_pgo_optimize',
      'gclient_config': 'chromium',
      'clobber': True,
      'patch_root': 'src',
      'chromium_config_kwargs': {
        'BUILD_CONFIG': 'Release',
        'TARGET_BITS': 32,
      },
      'testing': {
        'platform': 'win',
      },
    },
  }
})


def RunSteps(api, buildername):
  buildername = api.properties['buildername']
  mastername = api.properties['mastername']
  bot_config = TEST_BUILDERS.get(mastername, {}).get(buildername)
Exemple #44
0
BUILDERS = freeze({
  'client.webrtc': {
    'builders': {
      'Linux64 Release (Libfuzzer)': {
        'recipe_config': 'webrtc',
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_BITS': 64,
        },
        'chromium_apply_config': ['webrtc_libfuzzer'],
        'bot_type': 'builder',
        'testing': {'platform': 'linux'},
      },
    },
  },
  'tryserver.webrtc': {
    'builders': {
      'linux_libfuzzer_rel': {
        'recipe_config': 'webrtc',
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_BITS': 64,
        },
        'chromium_apply_config': ['webrtc_libfuzzer'],
        'bot_type': 'builder',
        'testing': {'platform': 'linux'},
      },
    },
  },
})
Exemple #45
0
            'path': 'src/v8',
            'revision': '%s'
        },
        'testing': {
            'platform': platform
        },
    }


BUILDERS = freeze({
    'client.v8.fyi': {
        'builders': {
            'V8-Blink Win': V8Builder('Release', 32, 'win'),
            'V8-Blink Mac': V8Builder('Release', 64, 'mac'),
            'V8-Blink Linux 64': V8Builder('Release', 64, 'linux'),
            'V8-Blink Linux 64 - future': V8Builder('Release', 64, 'linux'),
            # TODO(machenbach): Remove this after master restart.
            'V8-Blink Linux 64 - ignition': V8Builder('Release', 64, 'linux'),
            'V8-Blink Linux 64 (dbg)': V8Builder('Debug', 64, 'linux'),
        },
    },
})


def determine_new_future_failures(caller_api, extra_args):
    tests = [
        caller_api.chromium_tests.steps.BlinkTest(extra_args=extra_args + [
            '--additional-expectations',
            caller_api.path['checkout'].join('v8', 'tools', 'blink_tests',
                                             'TestExpectationsFuture'),
            '--additional-driver-flag',
    'recipe_engine/step',
]

BUCKET_NAME = 'chrome-codesearch'
CHROMIUM_GIT_URL = 'https://chromium.googlesource.com'

# Lists the additional repositories that should be checked out to be included
# in the source archive that is indexed by Codesearch.
ADDITIONAL_REPOS = freeze({
    'infra': '%s/infra/infra' % CHROMIUM_GIT_URL,
    'tools/chrome-devtools-frontend':\
      '%s/chromium/tools/chrome-devtools-frontend' % CHROMIUM_GIT_URL,
    'tools/chromium-jobqueue':\
      '%s/chromium/tools/chromium-jobqueue' % CHROMIUM_GIT_URL,
    'tools/chromium-shortener':\
      '%s/chromium/tools/chromium-shortener' % CHROMIUM_GIT_URL,
    'tools/command_wrapper/bin':\
      '%s/chromium/tools/command_wrapper/bin' % CHROMIUM_GIT_URL,
    'tools/depot_tools': '%s/chromium/tools/depot_tools' % CHROMIUM_GIT_URL,
    'tools/deps2git': '%s/chromium/tools/deps2git' % CHROMIUM_GIT_URL,
    'tools/gsd_generate_index':\
      '%s/chromium/tools/gsd_generate_index' % CHROMIUM_GIT_URL,
    'tools/perf': '%s/chromium/tools/perf' % CHROMIUM_GIT_URL,
})

LINUX_GN_ARGS = [
    'is_clang=true',
    'is_component_build=true',
    'is_debug=true',
    'goma_dir="/b/build/goma"',
    'symbol_level=1',
    'target_cpu="x64"',
BUILDERS = freeze({
    'tryserver.v8': {
        'builders': {
            'v8_linux_layout_rel': {
                'chromium_config_kwargs': {
                    'BUILD_CONFIG': 'Release',
                    'TARGET_BITS': 64,
                },
                'compile_only': False,
                'v8_blink_flavor': True,
                'root_override': 'src/v8',
                'set_custom_revs': {
                    'src/v8': 'bleeding_edge:%(revision)s',
                },
                'testing': {
                    'platform': 'linux',
                },
            },
            'v8_linux_layout_dbg': {
                'chromium_config_kwargs': {
                    'BUILD_CONFIG': 'Debug',
                    'TARGET_BITS': 64,
                },
                'compile_only': False,
                'v8_blink_flavor': True,
                'root_override': 'src/v8',
                'set_custom_revs': {
                    'src/v8': 'bleeding_edge:%(revision)s',
                },
                'testing': {
                    'platform': 'linux',
                },
            },
        },
    },
})
Exemple #48
0
 def _properties(self):
     if self._frozen_properties is None:
         self._frozen_properties = freeze(
             self.properties_client.get_properties())
     return self._frozen_properties
Exemple #49
0
from recipe_engine.types import freeze
from recipe_engine.recipe_api import Property

DEPS = [
  'cronet',
  'recipe_engine/properties',
]

BUILDERS = freeze({
  'local_test': {
    'recipe_config': 'main_builder',
    'run_tests': True,
    'upload_package': True,
    'kwargs': {
      'BUILD_CONFIG': 'Debug',
    },
    'gyp_defs': {
      'use_goma': 0,
    }
  },
})


PROPERTIES = {
  'buildername': Property(),
}


def RunSteps(api, buildername):
  builder_config = BUILDERS.get(buildername, {})
Exemple #50
0
        _CreateTestSpec('Android Galaxy S5 Perf',
                        'android-galaxy-s5',
                        required_apks=['ChromePublic.apk'],
                        num_device_shards=7,
                        num_host_shards=1,
                        target_bits=32),
    ]

    master_spec = {}
    for spec in testers:
        master_spec.update(spec)
    return master_spec


BUILDERS = freeze({
    'chromium.perf': _ChromiumPerfTesters(),
    'chromium.perf.fyi': _ChromiumPerfFyiTesters(),
})


def RunSteps(api):
    mastername = api.properties['mastername']
    buildername = api.properties['buildername']
    # TODO(akuegel): Move the configs in builders.py in chromium_tests to this
    # recipe, and get rid of duplications.
    builder = dict(BUILDERS[mastername][buildername])
    builder_config = builder.get('recipe_config', 'base_config')
    kwargs = {
        'REPO_NAME': 'src',
        'REPO_URL': REPO_URL,
        'INTERNAL': False,
        'BUILD_CONFIG': 'Release',
Exemple #51
0
        'component': {
            'path': 'src/v8',
            'revision': '%s'
        },
        'testing': {
            'platform': platform
        },
    }


BUILDERS = freeze({
    'client.v8.fyi': {
        'builders': {
            'V8-Blink Win': V8Builder('Release', 32, 'win'),
            'V8-Blink Mac': V8Builder('Release', 64, 'mac'),
            'V8-Blink Linux 32': V8Builder('Release', 32, 'linux'),
            'V8-Blink Linux 64': V8Builder('Release', 64, 'linux'),
            'V8-Blink Linux 64 (dbg)': V8Builder('Debug', 64, 'linux'),
        },
    },
})


def RunSteps(api):
    mastername = api.properties.get('mastername')
    buildername = api.properties.get('buildername')
    master_dict = BUILDERS.get(mastername, {})
    bot_config = master_dict.get('builders', {}).get(buildername)

    # Sync chromium to HEAD.
    api.gclient.set_config('chromium')
Exemple #52
0
            'android-webview-nexus6',
            required_apks=['SystemWebView.apk', 'SystemWebViewShell.apk'],
            num_device_shards=6,
            num_host_shards=3,
            target_bits=32,
            browser_name='android-webview',
            uses_webview=True),
    ]
    master_spec = {}
    for spec in testers:
        master_spec.update(spec)
    return master_spec


BUILDERS = freeze({
    'chromium.perf': _ChromiumPerfTesters(),
})


def RunSteps(api):
    mastername = api.properties['mastername']
    buildername = api.properties['buildername']
    # TODO(akuegel): Move the configs in builders.py in chromium_tests to this
    # recipe, and get rid of duplications.
    builder = dict(BUILDERS[mastername][buildername])
    builder_config = builder.get('recipe_config', 'base_config')
    kwargs = {
        'REPO_NAME': 'src',
        'REPO_URL': REPO_URL,
        'INTERNAL': False,
        'BUILD_CONFIG': 'Release',
Exemple #53
0
BUILDERS = freeze({
    'basic_builder': {
        'target': 'Release',
        'build': True,
    },
    'restart_usb_builder': {
        'restart_usb': True,
        'target': 'Release',
        'build': True,
    },
    'coverage_builder': {
        'coverage': True,
        'target': 'Debug',
        'build': True,
    },
    'tester': {},
    'perf_runner': {
        'perf_config': 'sharded_perf_tests.json',
    },
    'perf_runner_user_build': {
        'perf_config': 'sharded_perf_tests.json',
        'skip_wipe': True,
    },
    'perf_runner_disable_location': {
        'perf_config': 'sharded_perf_tests.json',
        'disable_location': True,
    },
    'perf_runner_allow_low_battery': {
        'perf_config': 'sharded_perf_tests.json',
        'min_battery_level': 50,
    },
    'perf_adb_vendor_keys': {
        'adb_vendor_keys': True,
    },
    'perf_runner_allow_high_battery_temp': {
        'perf_config': 'sharded_perf_tests.json',
        'max_battery_temp': 500,
    },
    'gerrit_try_builder': {
        'build': True,
        'skip_wipe': True,
    },
    'webview_tester': {
        'android_apply_config': ['remove_all_system_webviews'],
    },
    'slow_tester': {
        'timeout_scale': 2,
    },
    'downgrade_install_tester': {
        'specific_install': True,
        'downgrade': True,
    },
    'keep_data_install_tester': {
        'specific_install': True,
        'keep_data': True,
    },
    'no_strict_mode_tester': {
        'strict_mode': 'off',
    },
    'resource_size_builder': {
        'resource_size': True,
    },
    'webview_cts': {
        'run_webview_cts': True,
    },
    'last_known_devices': {
        'perf_config': 'sharded_perf_tests.json',
        'last_known_devices': '.last_devices',
    },
    'device_flags_builder': {
        'device_flags': 'device_flags_file',
    },
    'no_cache_builder': {
        'use_git_cache': False,
    },
    'json_results_file': {
        'json_results_file': 'json_results_file',
    },
    'render_results': {
        'render_results_dir': 'chrome/test/data/android/render_tests',
    },
    'result_details': {
        'result_details': True,
        'store_tombstones': True,
    },
    'enable_platform_mode': {
        'perf_config': 'sharded_perf_tests.json',
        'enable_platform_mode': True,
        'write_buildbot_json': True,
    },
    'timestamp_as_point_id': {
        'perf_config': 'sharded_perf_tests.json',
        'timestamp_as_point_id': True
    },
    'telemetry_browser_tests_tester': {
        'run_telemetry_browser_tests': True,
    },
    'use_devil_adb': {
        'android_apply_config': ['use_devil_adb'],
    },
    'remove_system_vrcore': {
        'android_apply_config': ['remove_system_vrcore'],
    },
    'stackwalker': {
        'run_stackwalker': True,
    },
    'asan': {
        'chromium_apply_config': ['chromium_asan'],
    }
})
Exemple #54
0
        "chromium_apply_config": chromium_configs,
        "chromium_config_kwargs": {"BUILD_CONFIG": config, "TARGET_BITS": bits},
        "test_args": ["--no-pixel-tests"],
        "additional_expectations": ["v8", "tools", "blink_tests", "TestExpectations"],
        "component": {"path": "src/v8", "revision": "%s"},
        "testing": {"platform": platform},
    }


BUILDERS = freeze(
    {
        "client.v8.fyi": {
            "builders": {
                "V8-Blink Win": V8Builder("Release", 32, "win"),
                "V8-Blink Mac": V8Builder("Release", 64, "mac"),
                "V8-Blink Linux 64": V8Builder("Release", 64, "linux"),
                "V8-Blink Linux 64 - ignition": V8Builder("Release", 64, "linux"),
                "V8-Blink Linux 64 (dbg)": V8Builder("Debug", 64, "linux"),
            }
        }
    }
)


def determine_new_ignition_failures(caller_api, extra_args):
    tests = [
        caller_api.chromium_tests.steps.BlinkTest(
            extra_args=extra_args
            + [
                "--additional-expectations",
                caller_api.path["checkout"].join("v8", "tools", "blink_tests", "TestExpectationsIgnition"),
BUILDERS = freeze({
    'tryserver.chromium.perf': {
        'builders': {
            'android_one_perf_bisect': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_nexus5_perf_bisect': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_nexus5X_perf_bisect': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_nexus6_perf_bisect': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_nexus7_perf_bisect': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_nexus9_perf_bisect': {
                'recipe_config': 'arm64_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_s5_perf_bisect': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_s5_perf_cq': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_fyi_perf_bisect': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
            },
            'android_webview_arm64_aosp_perf_bisect': {
                'recipe_config': 'main_builder_rel_mb',
                'gclient_apply_config': ['android', 'perf'],
                'bucket': 'chrome-perf',
                'webview': True,
            },
        },
    },
})
Exemple #56
0
DETERMINISTIC_BUILDERS = freeze({
    'Android deterministic': {
        'chromium_config': 'android',
        'chromium_config_kwargs': {
            'BUILD_CONFIG': 'Release',
            'TARGET_BITS': 32,
            'TARGET_PLATFORM': 'android',
        },
        'platform': 'linux',
        'targets': ['all'],
    },
    'Linux deterministic': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'platform': 'linux',
        'targets': ['all'],
    },
    'Mac deterministic': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'platform': 'mac',
        'targets': ['all'],
    },
    'Windows deterministic': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'platform': 'win',
        'targets': ['all'],
    },
    'Windows Clang deterministic': {
        'chromium_config': 'chromium_win_clang',
        'gclient_config': 'chromium',
        'platform': 'win',
        'targets': ['all'],
    },

    # Debug builder.
    'Android deterministic (dbg)': {
        'chromium_config': 'android',
        'chromium_config_kwargs': {
            'BUILD_CONFIG': 'Debug',
            'TARGET_BITS': 32,
            'TARGET_PLATFORM': 'android',
        },
        'platform': 'linux',
        'targets': ['all'],
    },
    'Linux deterministic (dbg)': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'platform': 'linux',
        'targets': ['all'],
    },
    'Mac deterministic (dbg)': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'platform': 'mac',
        'targets': ['all'],
    },

    # runs in tryserver.chromium.linux.
    'linux_chromium_clobber_deterministic': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'platform': 'linux',
        'targets': ['all'],
    },
    # runs in chromium.linux.
    'Deterministic Linux': {
        'chromium_config': 'chromium',
        'gclient_config': 'chromium',
        'platform': 'linux',
        'targets': ['all'],
    },
})
Exemple #57
0
BUILDERS = freeze({
  'chromium.fyi': {
    'builders': {
      'Libfuzzer Upload Linux ASan': {
        'chromium_config': 'chromium_clang',
        'chromium_apply_config': [ 'proprietary_codecs' ],
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_PLATFORM': 'linux',
          'TARGET_BITS': 64,
        },
        'upload_bucket': 'chromium-browser-libfuzzer',
        'upload_directory': 'asan',
      },
      'Libfuzzer Upload Linux MSan': {
        'chromium_config': 'chromium_clang',
        'chromium_apply_config': ['msan', 'msan_full_origin_tracking',
                                  'prebuilt_instrumented_libraries',
                                  'proprietary_codecs' ],
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_PLATFORM': 'linux',
          'TARGET_BITS': 64,
        },
        'upload_bucket': 'chromium-browser-libfuzzer',
        'upload_directory': 'msan',
      },
      'Libfuzzer Upload Linux UBSan': {
        'chromium_config': 'chromium_clang',
        'chromium_apply_config': [ 'proprietary_codecs' ],
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_PLATFORM': 'linux',
          'TARGET_BITS': 64,
        },
        'upload_bucket': 'chromium-browser-libfuzzer',
        'upload_directory': 'ubsan',
      },
    },
  },
})
Exemple #58
0
  'recipe_engine/step',
]


BUILDERS = freeze({
  'chromium.fyi': {
    'builders': {
      'Win LKGR (DrM)': {
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_BITS': 32,
        },
        'upload_bucket': 'chromium-browser-drfuzz',
        'upload_directory': 'chromium_win32',
        'bot_type': 'builder',
      },
      'Win LKGR (DrM 64)': {
        'chromium_config_kwargs': {
          'BUILD_CONFIG': 'Release',
          'TARGET_BITS': 64,
        },
        'upload_bucket': 'chromium-browser-drfuzz',
        'upload_directory': 'chromium_win64',
        'bot_type': 'builder',
      },
    },
  },
})


def gn_refs(api, step_name, args):
  """Runs gn refs with given additional arguments.
Exemple #59
0
 def __init__(self, **kwargs):
   super(PropertiesApi, self).__init__(**kwargs)
   self._properties = freeze(self._engine.properties)