Bug 1508694 Turn off talos stylo sequential threads tp6 r=jmaher
authorFlorin Strugariu <fstrugariu@mozilla.com>
Fri, 31 May 2019 12:47:26 +0000
changeset 476406 c09907b969869882de85af64500b63b5b97e987c
parent 476405 c3cf80ebcd293ef1ca4895047da216879513b236
child 476407 d9e1572a77372a8878b5f54df916862d0b388037
push id36094
push useraiakab@mozilla.com
push dateFri, 31 May 2019 21:48:40 +0000
treeherdermozilla-central@a73077366144 [default view] [failures only]
perfherder[talos] [build metrics] [platform microbench] (compared to previous push)
reviewersjmaher
bugs1508694
milestone69.0a1
first release with
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
last release without
nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
Bug 1508694 Turn off talos stylo sequential threads tp6 r=jmaher Differential Revision: https://phabricator.services.mozilla.com/D32977
taskcluster/ci/test/talos.yml
taskcluster/ci/test/test-sets.yml
testing/mozharness/configs/talos/linux64_config_taskcluster.py
testing/mozharness/configs/talos/linux_config.py
testing/mozharness/configs/talos/mac_config.py
testing/mozharness/configs/talos/windows_config.py
testing/mozharness/configs/talos/windows_taskcluster_config.py
testing/mozharness/configs/talos/windows_vm_config.py
testing/mozharness/mozharness/mozilla/testing/talos.py
testing/talos/mach_commands.py
testing/talos/talos.json
testing/talos/talos/cmdline.py
testing/talos/talos/mitmproxy/__init__.py
testing/talos/talos/mitmproxy/alternate-server-replay.py
testing/talos/talos/mitmproxy/mitmproxy-playback-set.manifest
testing/talos/talos/mitmproxy/mitmproxy-rel-bin-linux64.manifest
testing/talos/talos/mitmproxy/mitmproxy-rel-bin-osx.manifest
testing/talos/talos/mitmproxy/mitmproxy.py
testing/talos/talos/mitmproxy/mitmproxy_requirements.txt
testing/talos/talos/mitmproxy/python3.manifest
testing/talos/talos/mitmproxy/python3_x64.manifest
testing/talos/talos/run_tests.py
testing/talos/talos/test.py
testing/talos/talos/ttest.py
testing/talos/talos/unittests/test_config.py
--- a/taskcluster/ci/test/talos.yml
+++ b/taskcluster/ci/test/talos.yml
@@ -368,50 +368,16 @@ talos-tp5o:
             windows10-aarch64/opt: ['mozilla-central', 'try']
             macosx.*64(?:-shippable)?(?:-qr)?/opt: ['mozilla-central', 'try']
             default: ['mozilla-beta', 'trunk', 'try']
     max-run-time: 1800
     mozharness:
         extra-options:
             - --suite=tp5o
 
-talos-tp6:
-    description: "Talos tp6"
-    try-name: tp6
-    treeherder-symbol: T(tp6)
-    run-on-projects:
-        by-test-platform:
-            linux64-ccov/.*: ['try']
-            windows10-64-ccov/.*: ['try']
-            (?:windows10-64|windows7-32|linux64)(?:-qr)?/opt: ['mozilla-central', 'try']
-            windows10-aarch64/opt: ['mozilla-central', 'try']
-            macosx.*64(?:-shippable)?(?:-qr)?/opt: ['mozilla-central', 'try']
-            default: ['trunk', 'try']
-    max-run-time: 1200
-    mozharness:
-        extra-options:
-            - --suite=tp6
-
-talos-tp6-stylo-threads:
-    description: "Talos Stylo sequential tp6"
-    try-name: tp6-stylo-threads
-    treeherder-symbol: Tss(tp6)
-    max-run-time: 1200
-    run-on-projects:
-        by-test-platform:
-            linux64-ccov/.*: ['try']
-            windows10-64-ccov/.*: ['try']
-            (?:windows10-64|windows7-32|linux64)(?:-qr)?/opt: ['mozilla-central', 'try']
-            windows10-aarch64/opt: ['mozilla-central', 'try']
-            macosx.*64(?:-shippable)?(?:-qr)?/opt: ['mozilla-central', 'try']
-            default: ['mozilla-beta', 'trunk', 'try']
-    mozharness:
-        extra-options:
-            - --suite=tp6-stylo-threads
-
 talos-tabswitch:
     description: "Talos page scroll (tabswitch)"
     try-name: tabswitch
     treeherder-symbol: T(tabswitch)
     max-run-time: 900
     run-on-projects:
         by-test-platform:
             windows10-64-ccov/.*: ['try']
--- a/taskcluster/ci/test/test-sets.yml
+++ b/taskcluster/ci/test/test-sets.yml
@@ -68,17 +68,16 @@ talos:
     - talos-g4
     - talos-g5
     - talos-other
     - talos-sessionrestore-many-windows
     - talos-svgr
     - talos-tp5o
     - talos-perf-reftest
     - talos-perf-reftest-singletons
-    - talos-tp6-stylo-threads
     - talos-tabswitch
     # - talos-h1 Bug 1487031 - Disabled for not finding actionable regressions
     # - talos-h2 Bug 1487031 - Disabled for not finding actionable regressions
 
 talos-ux:
     - talos-g4
 
 raptor-firefox:
@@ -374,17 +373,16 @@ macosx64-talos:
     - talos-g4
     - talos-g5
     - talos-other
     - talos-sessionrestore-many-windows
     - talos-svgr
     - talos-tp5o
     - talos-perf-reftest
     - talos-perf-reftest-singletons
-    - talos-tp6-stylo-threads
     # - talos-tabswitch # Bug 1453007 times out
     # - talos-h1 # too long to unpack profile- Bug 1442893
 
 macosx64-qr-tests:
     - crashtest
 
 linux32-tests:
     - web-platform-tests
--- a/testing/mozharness/configs/talos/linux64_config_taskcluster.py
+++ b/testing/mozharness/configs/talos/linux64_config_taskcluster.py
@@ -25,15 +25,14 @@ config = {
     "exes": exes,
     "title": os.uname()[1].lower().split('.')[0],
     "default_actions": [
         "clobber",
         "download-and-extract",
         "populate-webroot",
         "create-virtualenv",
         "install",
-        "setup-mitmproxy",
         "run-tests",
     ],
     "minidump_stackwalk_path": MINIDUMP_STACKWALK_PATH,
     "minidump_tooltool_manifest_path": TOOLTOOL_MANIFEST_PATH,
     "tooltool_cache": "/builds/worker/tooltool-cache",
 }
--- a/testing/mozharness/configs/talos/linux_config.py
+++ b/testing/mozharness/configs/talos/linux_config.py
@@ -15,15 +15,14 @@ config = {
     "virtualenv_path": VENV_PATH,
     "title": os.uname()[1].lower().split('.')[0],
     "default_actions": [
         "clobber",
         "download-and-extract",
         "populate-webroot",
         "create-virtualenv",
         "install",
-        "setup-mitmproxy",
         "run-tests",
     ],
     "minidump_stackwalk_path": MINIDUMP_STACKWALK_PATH,
     "minidump_tooltool_manifest_path": TOOLTOOL_MANIFEST_PATH,
     "tooltool_cache": "/builds/tooltool_cache",
 }
--- a/testing/mozharness/configs/talos/mac_config.py
+++ b/testing/mozharness/configs/talos/mac_config.py
@@ -8,17 +8,16 @@ config = {
     "virtualenv_path": VENV_PATH,
     "title": os.uname()[1].lower().split('.')[0],
     "default_actions": [
         "clobber",
         "download-and-extract",
         "populate-webroot",
         "create-virtualenv",
         "install",
-        "setup-mitmproxy",
         "run-tests",
     ],
     "run_cmd_checks_enabled": True,
     "preflight_run_cmd_suites": [],
     "postflight_run_cmd_suites": [],
     "minidump_stackwalk_path": "macosx64-minidump_stackwalk",
     "minidump_tooltool_manifest_path": "config/tooltool-manifests/macosx64/releng.manifest",
     "tooltool_cache": "/builds/tooltool_cache",
--- a/testing/mozharness/configs/talos/windows_config.py
+++ b/testing/mozharness/configs/talos/windows_config.py
@@ -17,23 +17,14 @@ config = {
     },
     "title": socket.gethostname().split('.')[0],
     "default_actions": [
         "clobber",
         "download-and-extract",
         "populate-webroot",
         "create-virtualenv",
         "install",
-        "setup-mitmproxy",
         "run-tests",
     ],
     "tooltool_cache": os.path.join('c:\\', 'build', 'tooltool_cache'),
     "minidump_stackwalk_path": "win32-minidump_stackwalk.exe",
-    "minidump_tooltool_manifest_path": "config/tooltool-manifests/win32/releng.manifest",
-    "python3_manifest": {
-        "win32": "python3.manifest",
-        "win64": "python3_x64.manifest",
-    },
-    "env": {
-        # python3 requires C runtime, found in firefox installation; see bug 1361732
-        "PATH": "%(PATH)s;c:\\slave\\test\\build\\application\\firefox;"
-    }
+    "minidump_tooltool_manifest_path": "config/tooltool-manifests/win32/releng.manifest"
 }
--- a/testing/mozharness/configs/talos/windows_taskcluster_config.py
+++ b/testing/mozharness/configs/talos/windows_taskcluster_config.py
@@ -14,23 +14,14 @@ config = {
         'python': PYTHON,
         'hg': os.path.join(os.environ['PROGRAMFILES'], 'Mercurial', 'hg'),
     },
     "title": socket.gethostname().split('.')[0],
     "default_actions": [
         "populate-webroot",
         "create-virtualenv",
         "install",
-        "setup-mitmproxy",
         "run-tests",
     ],
     "tooltool_cache": os.path.join('Y:\\', 'tooltool-cache'),
     "minidump_stackwalk_path": "win32-minidump_stackwalk.exe",
-    "minidump_tooltool_manifest_path": "config/tooltool-manifests/win32/releng.manifest",
-    "python3_manifest": {
-        "win32": "python3.manifest",
-        "win64": "python3_x64.manifest",
-    },
-    "env": {
-        # python3 requires C runtime, found in firefox installation; see bug 1361732
-        "PATH": "%(PATH)s;%(CD)s\\build\\application\\firefox;"
-    }
+    "minidump_tooltool_manifest_path": "config/tooltool-manifests/win32/releng.manifest"
 }
--- a/testing/mozharness/configs/talos/windows_vm_config.py
+++ b/testing/mozharness/configs/talos/windows_vm_config.py
@@ -16,23 +16,14 @@ config = {
     },
     "title": socket.gethostname().split('.')[0],
     "default_actions": [
         "clobber",
         "download-and-extract",
         "populate-webroot",
         "create-virtualenv",
         "install",
-        "setup-mitmproxy",
         "run-tests",
     ],
     "tooltool_cache": os.path.join('c:\\', 'build', 'tooltool_cache'),
     "minidump_stackwalk_path": "win32-minidump_stackwalk.exe",
-    "minidump_tooltool_manifest_path": "config/tooltool-manifests/win32/releng.manifest",
-    "python3_manifest": {
-        "win32": "python3.manifest",
-        "win64": "python3_x64.manifest",
-    },
-    "env": {
-        # python3 requires C runtime, found in firefox installation; see bug 1361732
-        "PATH": "%(PATH)s;c:\\slave\\test\\build\\application\\firefox;"
-    }
+    "minidump_tooltool_manifest_path": "config/tooltool-manifests/win32/releng.manifest"
 }
--- a/testing/mozharness/mozharness/mozilla/testing/talos.py
+++ b/testing/mozharness/mozharness/mozilla/testing/talos.py
@@ -174,25 +174,23 @@ class Talos(TestingMixin, MercurialScrip
 
     def __init__(self, **kwargs):
         kwargs.setdefault('config_options', self.config_options)
         kwargs.setdefault('all_actions', ['clobber',
                                           'download-and-extract',
                                           'populate-webroot',
                                           'create-virtualenv',
                                           'install',
-                                          'setup-mitmproxy',
                                           'run-tests',
                                           ])
         kwargs.setdefault('default_actions', ['clobber',
                                               'download-and-extract',
                                               'populate-webroot',
                                               'create-virtualenv',
                                               'install',
-                                              'setup-mitmproxy',
                                               'run-tests',
                                               ])
         kwargs.setdefault('config', {})
         super(Talos, self).__init__(**kwargs)
 
         self.workdir = self.query_abs_dirs()['abs_work_dir']  # convenience
 
         self.run_local = self.config.get('run_local')
@@ -204,24 +202,16 @@ class Talos(TestingMixin, MercurialScrip
         self.obj_path = self.config.get("obj_path")
         self.tests = None
         self.gecko_profile = self.config.get('gecko_profile') or \
             "--geckoProfile" in self.config.get("talos_extra_options", []) or \
             "--gecko-profile" in self.config.get("talos_extra_options", [])
         self.gecko_profile_interval = self.config.get('gecko_profile_interval')
         self.pagesets_name = None
         self.benchmark_zip = None
-        # some platforms download a mitmproxy release binary
-        self.mitmproxy_rel_bin = None
-        # zip file found on tooltool that contains all of the mitmproxy recordings
-        self.mitmproxy_recording_set = None
-        # files inside the recording set
-        self.mitmproxy_recordings_file_list = self.config.get('mitmproxy', None)
-        # path to mitdump tool itself, in py3 venv
-        self.mitmdump = None
 
     # We accept some configuration options from the try commit message in the format
     # mozharness: <options>
     # Example try commit message:
     #   mozharness: --gecko-profile try: <stuff>
     def query_gecko_profile_options(self):
         gecko_results = []
         # finally, if gecko_profile is set, we add that to the talos options
@@ -270,29 +260,16 @@ class Talos(TestingMixin, MercurialScrip
         """
         if self.benchmark_zip:
             return self.benchmark_zip
         if self.query_talos_json_config() and self.suite is not None:
             self.benchmark_zip = self.talos_json_config['suites'][self.suite].get('benchmark_zip')
             self.benchmark_zip_manifest = 'jetstream-benchmark.manifest'
             return self.benchmark_zip
 
-    def query_mitmproxy_recordings_file_list(self):
-        """ When using mitmproxy we also need the name of the playback files that are included
-        inside the playback archive.
-        """
-        if self.mitmproxy_recordings_file_list:
-            return self.mitmproxy_recordings_file_list
-        if self.query_talos_json_config() and self.suite is not None:
-            talos_opts = self.talos_json_config['suites'][self.suite].get('talos_options', None)
-            for index, val in enumerate(talos_opts):
-                if val == '--mitmproxy':
-                    self.mitmproxy_recordings_file_list = talos_opts[index + 1]
-            return self.mitmproxy_recordings_file_list
-
     def get_suite_from_test(self):
         """ Retrieve the talos suite name from a given talos test name."""
         # running locally, single test name provided instead of suite; go through tests and
         # find suite name
         suite_name = None
         if self.query_talos_json_config():
             if '-a' in self.config['talos_extra_options']:
                 test_name_index = self.config['talos_extra_options'].index('-a') + 1
@@ -333,28 +310,17 @@ class Talos(TestingMixin, MercurialScrip
         # options overwritten from **kw
         kw_options = {'executablePath': binary_path}
         if 'suite' in self.config:
             kw_options['suite'] = self.config['suite']
         if self.config.get('title'):
             kw_options['title'] = self.config['title']
         if self.symbols_path:
             kw_options['symbolsPath'] = self.symbols_path
-        # if using mitmproxy, we've already created a py3 venv just
-        # for it; need to add the path to that env/mitdump tool
-        if self.mitmdump:
-            kw_options['mitmdumpPath'] = self.mitmdump
-            # also need to have recordings list; get again here from talos.json, in case talos was
-            # invoked via '-a' and therefore the --mitmproxy param wasn't used on command line
-            if not self.config.get('mitmproxy', None):
-                file_list = self.query_mitmproxy_recordings_file_list()
-                if file_list is not None:
-                    kw_options['mitmproxy'] = file_list
-                else:
-                    self.fatal("Talos requires list of mitmproxy playback files, use --mitmproxy")
+
         kw_options.update(kw)
         # talos expects tests to be in the format (e.g.) 'ts:tp5:tsvg'
         tests = kw_options.get('activeTests')
         if tests and not isinstance(tests, basestring):
             tests = ':'.join(tests)  # Talos expects this format
             kw_options['activeTests'] = tests
         for key, value in kw_options.items():
             options.extend(['--%s' % key, value])
@@ -448,141 +414,16 @@ class Talos(TestingMixin, MercurialScrip
             shutil.rmtree(dest)
 
         self.info("Copying webkit benchmarks from %s to %s" % (src, dest))
         try:
             shutil.copytree(src, dest)
         except Exception:
             self.critical("Error copying webkit benchmarks from %s to %s" % (src, dest))
 
-    def setup_mitmproxy(self):
-        """Some talos tests require the use of mitmproxy to playback the pages,
-        set it up here.
-        """
-        if not self.query_mitmproxy_recording_set():
-            self.info("Skipping: mitmproxy is not required")
-            return
-
-        os_name = self.platform_name()
-
-        # on windows we need to install a pytyon 3 virtual env; on macosx and linux we
-        # use a mitmdump pre-built binary that doesn't need an external python 3
-        if 'win' in os_name:
-            # setup python 3.x virtualenv
-            self.setup_py3_virtualenv()
-
-        # install mitmproxy
-        self.install_mitmproxy()
-
-        # download the recording set; will be overridden by the --no-download
-        if ('talos_extra_options' in self.config and
-                '--no-download' not in self.config['talos_extra_options']) or \
-                'talos_extra_options' not in self.config:
-            self.download_mitmproxy_recording_set()
-        else:
-            self.info("Not downloading mitmproxy recording set because no-download was specified")
-
-    def setup_py3_virtualenv(self):
-        """Mitmproxy needs Python 3.x; set up a separate py 3.x env here"""
-        self.info("Setting up python 3.x virtualenv, required for mitmproxy")
-        # first download the py3 package
-        self.py3_path = self.fetch_python3()
-        # now create the py3 venv
-        self.py3_venv_configuration(python_path=self.py3_path, venv_path='py3venv')
-        self.py3_create_venv()
-        self.py3_install_modules(["cffi==1.10.0"])
-        requirements = [os.path.join(self.talos_path, 'talos',
-                                     'mitmproxy', 'mitmproxy_requirements.txt')]
-        self.py3_install_requirement_files(requirements)
-        # add py3 executables path to system path
-        sys.path.insert(1, self.py3_path_to_executables())
-
-    def install_mitmproxy(self):
-        """Install the mitmproxy tool into the Python 3.x env"""
-        self.info("Installing mitmproxy")
-        if 'win' in self.platform_name():
-            self.py3_install_modules(modules=['mitmproxy'])
-            self.mitmdump = os.path.join(self.py3_path_to_executables(), 'mitmdump')
-        else:
-            # on macosx and linux64 we use a prebuilt mitmproxy release binary
-            mitmproxy_path = os.path.join(self.talos_path, 'talos', 'mitmproxy')
-            self.mitmdump = os.path.join(mitmproxy_path, 'mitmdump')
-            if not os.path.exists(self.mitmdump):
-                # download the mitmproxy release binary; will be overridden by the --no-download
-                if ('talos_extra_options' in self.config and
-                    '--no-download' not in self.config['talos_extra_options']) or \
-                   'talos_extra_options' not in self.config:
-                    if 'osx' in self.platform_name():
-                        _platform = 'osx'
-                    else:
-                        _platform = 'linux64'
-                    self.query_mitmproxy_rel_bin(_platform)
-                    if self.mitmproxy_rel_bin is None:
-                        self.fatal("Aborting: mitmproxy_release_bin_osx not found in talos.json")
-                    self.download_mitmproxy_binary(_platform)
-                else:
-                    self.info("Not downloading mitmproxy rel binary because no-download was "
-                              "specified")
-            self.info('The mitmdump macosx binary is found at: %s' % self.mitmdump)
-        self.run_command([self.mitmdump, '--version'], env=self.query_env())
-
-    def query_mitmproxy_rel_bin(self, platform):
-        """Mitmproxy requires external playback archives to be downloaded and extracted"""
-        if self.mitmproxy_rel_bin:
-            return self.mitmproxy_rel_bin
-        if self.query_talos_json_config() and self.suite is not None:
-            config_key = "mitmproxy_release_bin_" + platform
-            self.mitmproxy_rel_bin = self.talos_json_config['suites'][self.suite].get(config_key,
-                                                                                      False)
-            return self.mitmproxy_rel_bin
-
-    def download_mitmproxy_binary(self, platform):
-        """Download the mitmproxy release binary from tooltool"""
-        self.info("Downloading the mitmproxy release binary using tooltool")
-        dest = os.path.join(self.talos_path, 'talos', 'mitmproxy')
-        _manifest = "mitmproxy-rel-bin-%s.manifest" % platform
-        manifest_file = os.path.join(self.talos_path, 'talos', 'mitmproxy', _manifest)
-
-        if platform in ['osx', 'linux64']:
-            self.tooltool_fetch(
-                manifest_file,
-                output_dir=dest,
-                cache=self.config.get('tooltool_cache')
-            )
-
-            archive = os.path.join(dest, self.mitmproxy_rel_bin)
-            tar = self.query_exe('tar')
-            unzip_cmd = [tar, '-xvzf', archive, '-C', dest]
-            self.run_command(unzip_cmd, halt_on_failure=True)
-
-    def query_mitmproxy_recording_set(self):
-        """Mitmproxy requires external playback archives to be downloaded and extracted"""
-        if self.mitmproxy_recording_set:
-            return self.mitmproxy_recording_set
-        if self.query_talos_json_config() and self.suite is not None:
-            self.mitmproxy_recording_set = (
-                self.talos_json_config['suites'][self.suite].get('mitmproxy_recording_set', False))
-            return self.mitmproxy_recording_set
-
-    def download_mitmproxy_recording_set(self):
-        """Download the set of mitmproxy recording files that will be played back"""
-        self.info("Downloading the mitmproxy recording set using tooltool")
-        dest = os.path.join(self.talos_path, 'talos', 'mitmproxy')
-        manifest_file = os.path.join(self.talos_path, 'talos',
-                                     'mitmproxy', 'mitmproxy-playback-set.manifest')
-        self.tooltool_fetch(
-            manifest_file,
-            output_dir=dest,
-            cache=self.config.get('tooltool_cache')
-        )
-        archive = os.path.join(dest, self.mitmproxy_recording_set)
-        unzip = self.query_exe('unzip')
-        unzip_cmd = [unzip, '-q', '-o', archive, '-d', dest]
-        self.run_command(unzip_cmd, halt_on_failure=True)
-
     # Action methods. {{{1
     # clobber defined in BaseScript
 
     def download_and_extract(self, extract_dirs=None, suite_categories=None):
         return super(Talos, self).download_and_extract(
             suite_categories=['common', 'talos']
         )
 
@@ -705,19 +546,16 @@ class Talos(TestingMixin, MercurialScrip
             self.mkdir_p(env['MOZ_UPLOAD_DIR'])
         env = self.query_env(partial_env=env, log_level=INFO)
         # adjust PYTHONPATH to be able to use talos as a python package
         if 'PYTHONPATH' in env:
             env['PYTHONPATH'] = self.talos_path + os.pathsep + env['PYTHONPATH']
         else:
             env['PYTHONPATH'] = self.talos_path
 
-        # mitmproxy needs path to mozharness when installing the cert
-        env['SCRIPTSPATH'] = scripts_path
-
         if self.repo_path is not None:
             env['MOZ_DEVELOPER_REPO_DIR'] = self.repo_path
         if self.obj_path is not None:
             env['MOZ_DEVELOPER_OBJ_DIR'] = self.obj_path
 
         if self.config['enable_webrender']:
             env['MOZ_WEBRENDER'] = '1'
             env['MOZ_ACCELERATED'] = '1'
@@ -777,25 +615,8 @@ class Talos(TestingMixin, MercurialScrip
                 self._validate_treeherder_data(parser)
                 if not self.run_local:
                     # copy results to upload dir so they are included as an artifact
                     dest = os.path.join(env['MOZ_UPLOAD_DIR'], 'perfherder-data.json')
                     self._artifact_perf_data(parser, dest)
 
         self.record_status(parser.worst_tbpl_status,
                            level=parser.worst_log_level)
-
-    def fetch_python3(self):
-        manifest_file = os.path.join(
-            self.talos_path,
-            'talos',
-            'mitmproxy',
-            self.config.get('python3_manifest')[self.platform_name()])
-        output_dir = self.query_abs_dirs()['abs_work_dir']
-        # Slowdown: The unzipped Python3 installation gets deleted every time
-        self.tooltool_fetch(
-            manifest_file,
-            output_dir=output_dir,
-            cache=self.config.get('tooltool_cache')
-        )
-        python3_path = os.path.join(output_dir, 'python3.6', 'python')
-        self.run_command([python3_path, '--version'], env=self.query_env())
-        return python3_path
--- a/testing/talos/mach_commands.py
+++ b/testing/talos/mach_commands.py
@@ -46,17 +46,16 @@ class TalosRunner(MozbuildObject):
                                             'talos-venv')
         self.python_interp = sys.executable
         self.talos_args = talos_args
 
     def make_config(self):
         default_actions = ['populate-webroot']
         default_actions.extend([
             'create-virtualenv',
-            'setup-mitmproxy',
             'run-tests',
         ])
         self.config = {
             'run_local': True,
             'talos_json': self.talos_json,
             'binary_path': self.binary_path,
             'repo_path': self.topsrcdir,
             'obj_path': self.topobjdir,
--- a/testing/talos/talos.json
+++ b/testing/talos/talos.json
@@ -63,47 +63,13 @@
         "xperf": {
             "tests": ["tp5n"],
             "pagesets_name": "tp5n.zip",
             "talos_options": [
                 "--xperf_path",
                 "\"c:/Program Files (x86)/Windows Kits/10/Windows Performance Toolkit/xperf.exe\""
             ]
         },
-        "tp6": {
-            "tests": ["tp6_youtube", "tp6_amazon", "tp6_facebook"],
-            "mitmproxy_release_bin_osx": "mitmproxy-2.0.2-osx.tar.gz",
-            "mitmproxy_release_bin_linux64": "mitmproxy-2.0.2-linux.tar.gz",
-            "mitmproxy_recording_set": "mitmproxy-recording-set-win10.zip",
-            "talos_options": [
-                "--mitmproxy",
-                "mitmproxy-recording-google.mp mitmproxy-recording-youtube.mp mitmproxy-recording-amazon.mp mitmproxy-recording-facebook.mp",
-                "--firstNonBlankPaint"
-            ]
-        },
-        "tp6-stylo-threads": {
-            "tests": ["tp6_youtube", "tp6_amazon", "tp6_facebook"],
-            "mitmproxy_release_bin_osx": "mitmproxy-2.0.2-osx.tar.gz",
-            "mitmproxy_release_bin_linux64": "mitmproxy-2.0.2-linux.tar.gz",
-            "mitmproxy_recording_set": "mitmproxy-recording-set-win10.zip",
-            "talos_options": [
-                "--stylo-threads=1",
-                "--mitmproxy",
-                "mitmproxy-recording-google.mp mitmproxy-recording-youtube.mp mitmproxy-recording-amazon.mp mitmproxy-recording-facebook.mp",
-                "--firstNonBlankPaint"
-            ]
-        },
         "h1": {
             "tests": ["ts_paint_heavy"]
-        },
-        "h2": {
-            "tests": ["tp6_google_heavy", "tp6_youtube_heavy", "tp6_amazon_heavy", "tp6_facebook_heavy"],
-            "mitmproxy_release_bin_osx": "mitmproxy-2.0.2-osx.tar.gz",
-            "mitmproxy_release_bin_linux64": "mitmproxy-2.0.2-linux.tar.gz",
-            "mitmproxy_recording_set": "mitmproxy-recording-set-win10.zip",
-            "talos_options": [
-                "--mitmproxy",
-                "mitmproxy-recording-google.mp mitmproxy-recording-youtube.mp mitmproxy-recording-amazon.mp mitmproxy-recording-facebook.mp",
-                "--firstNonBlankPaint"
-            ]
         }
     }
 }
--- a/testing/talos/talos/cmdline.py
+++ b/testing/talos/talos/cmdline.py
@@ -117,21 +117,16 @@ def create_parser(mach_interface=False):
             help="Time to wait for the browser to output to the log file")
     add_arg('--errorFile', dest='error_filename',
             default=os.path.abspath('browser_failures.txt'),
             help="Filename to store the errors found during the test."
                  " Currently used for xperf only.")
     add_arg('--setpref', action='append', default=[], dest="extraPrefs",
             metavar="PREF=VALUE",
             help="defines an extra user preference")
-    add_arg('--mitmproxy',
-            help='Test uses mitmproxy to serve the pages, specify the '
-                 'path and name of the mitmdump file to playback')
-    add_arg('--mitmdumpPath',
-            help="Path to mitmproxy's mitmdump playback tool")
     add_arg("--firstNonBlankPaint", action='store_true', dest="fnbpaint",
             help="Wait for firstNonBlankPaint event before recording the time")
     add_arg('--webServer', dest='webserver',
             help="DEPRECATED")
     if not mach_interface:
         add_arg('--develop', action='store_true', default=False,
                 help="useful for running tests on a developer machine."
                      " Doesn't upload to the graph servers.")
deleted file mode 100644
deleted file mode 100644
--- a/testing/talos/talos/mitmproxy/alternate-server-replay.py
+++ /dev/null
@@ -1,186 +0,0 @@
-# This file was copied from mitmproxy/addons/serverplayback.py release tag 2.0.2 and modified by
-# Benjamin Smedberg
-
-# Altered features:
-# * --kill returns 404 rather than dropping the whole HTTP/2 connection on the floor
-# * best-match response handling is used to improve success rates
-from __future__ import absolute_import, print_function
-
-import hashlib
-import sys
-import urllib
-from collections import defaultdict
-
-from mitmproxy import ctx
-from mitmproxy import exceptions
-from mitmproxy import http
-from mitmproxy import io
-from typing import Any  # noqa
-from typing import List  # noqa
-
-
-class ServerPlayback:
-    def __init__(self, replayfiles):
-        self.options = None
-        self.replayfiles = replayfiles
-        self.flowmap = {}
-
-    def load(self, flows):
-        for i in flows:
-            if i.response:
-                l = self.flowmap.setdefault(self._hash(i.request), [])
-                l.append(i)
-
-    def clear(self):
-        self.flowmap = {}
-
-    def _parse(self, r):
-        """
-            Return (path, queries, formdata, content) for a request.
-        """
-        _, _, path, _, query, _ = urllib.parse.urlparse(r.url)
-        queriesArray = urllib.parse.parse_qsl(query, keep_blank_values=True)
-        queries = defaultdict(list)
-        for k, v in queriesArray:
-            queries[k].append(v)
-
-        content = None
-        formdata = None
-        if r.raw_content != b'':
-            if r.multipart_form:
-                formdata = r.multipart_form
-            elif r.urlencoded_form:
-                formdata = r.urlencoded_form
-            else:
-                content = r.content
-        return (path, queries, formdata, content)
-
-    def _hash(self, r):
-        """
-            Calculates a loose hash of the flow request.
-        """
-        path, queries, _, _ = self._parse(r)
-
-        key = [str(r.port), str(r.scheme), str(r.method), str(path)]  # type: List[Any]
-        if not self.options.server_replay_ignore_host:
-            key.append(r.host)
-
-        if len(queries):
-            key.append("?")
-
-        return hashlib.sha256(
-            repr(key).encode("utf8", "surrogateescape")
-        ).digest()
-
-    def _match(self, request_a, request_b):
-        """
-            Calculate a match score between two requests.
-            Match algorithm:
-              * identical query keys: 3 points
-              * matching query param present: 1 point
-              * matching query param value: 3 points
-              * identical form keys: 3 points
-              * matching form param present: 1 point
-              * matching form param value: 3 points
-              * matching body (no multipart or encoded form): 4 points
-        """
-        match = 0
-
-        path_a, queries_a, form_a, content_a = self._parse(request_a)
-        path_b, queries_b, form_b, content_b = self._parse(request_b)
-
-        keys_a = set(queries_a.keys())
-        keys_b = set(queries_b.keys())
-        if keys_a == keys_b:
-            match += 3
-
-        for key in keys_a:
-            values_a = set(queries_a[key])
-            values_b = set(queries_b[key])
-            if len(values_a) == len(values_b):
-                match += 1
-            if values_a == values_b:
-                match += 3
-
-        if form_a and form_b:
-            keys_a = set(form_a.keys())
-            keys_b = set(form_b.keys())
-            if keys_a == keys_b:
-                match += 3
-
-            for key in keys_a:
-                values_a = set(form_a.get_all(key))
-                values_b = set(form_b.get_all(key))
-                if len(values_a) == len(values_b):
-                    match += 1
-                if values_a == values_b:
-                    match += 3
-
-        elif content_a and (content_a == content_b):
-            match += 4
-
-        return match
-
-    def next_flow(self, request):
-        """
-            Returns the next flow object, or None if no matching flow was
-            found.
-        """
-        hsh = self._hash(request)
-        flows = self.flowmap.get(hsh, None)
-        if flows is None:
-            return None
-
-        # if it's an exact match, great!
-        if len(flows) == 1:
-            candidate = flows[0]
-            if (candidate.request.url == request.url and
-               candidate.request.raw_content == request.raw_content):
-                ctx.log.info("For request {} found exact replay match".format(request.url))
-                return candidate
-
-        # find the best match between the request and the available flow candidates
-        match = -1
-        flow = None
-        ctx.log.debug("Candiate flows for request: {}".format(request.url))
-        for candidate_flow in flows:
-            candidate_match = self._match(candidate_flow.request, request)
-            ctx.log.debug("  score={} url={}".format(candidate_match, candidate_flow.request.url))
-            if candidate_match > match:
-                match = candidate_match
-                flow = candidate_flow
-        ctx.log.info("For request {} best match {} with score=={}".format(request.url,
-                     flow.request.url, match))
-        return candidate_flow
-
-    def configure(self, options, updated):
-        self.options = options
-        self.clear()
-        try:
-            flows = io.read_flows_from_paths(self.replayfiles)
-        except exceptions.FlowReadException as e:
-            raise exceptions.OptionsError(str(e))
-        self.load(flows)
-
-    def request(self, f):
-        if self.flowmap:
-            rflow = self.next_flow(f.request)
-            if rflow:
-                response = rflow.response.copy()
-                response.is_replay = True
-                if self.options.refresh_server_playback:
-                    response.refresh()
-                f.response = response
-            elif self.options.replay_kill_extra:
-                ctx.log.warn(
-                    "server_playback: killed non-replay request {}".format(
-                        f.request.url
-                    )
-                )
-                f.response = http.HTTPResponse.make(404, b'', {'content-type': 'text/plain'})
-
-
-def start():
-    files = sys.argv[1:]
-    print("Replaying from files: {}".format(files))
-    return ServerPlayback(files)
deleted file mode 100644
--- a/testing/talos/talos/mitmproxy/mitmproxy-playback-set.manifest
+++ /dev/null
@@ -1,9 +0,0 @@
-[
-    {
-        "filename": "mitmproxy-recording-set-win10.zip",
-        "size": 9189938,
-        "digest": "e904917ed6bf1cef7201284385dc603a283e8e22f992876f17edcf0f1f20db95b609f0d8c7f593b4a0a6c20957dcb6a4d502c562ed74fb6cf4bc255c2f691f32",
-        "algorithm": "sha512",
-        "unpack": false
-    }
-]
\ No newline at end of file
deleted file mode 100644
--- a/testing/talos/talos/mitmproxy/mitmproxy-rel-bin-linux64.manifest
+++ /dev/null
@@ -1,9 +0,0 @@
-[
-    {
-        "filename": "mitmproxy-2.0.2-linux.tar.gz",
-        "size": 48997542,
-        "digest": "b032e04b8763206a19f80b78062efa59dc901ad32fd8d6cf2d20e22744711352da61e75d93a0d93d645179153534f72a154f73432837db415c9b0cd9d981f012",
-        "algorithm": "sha512",
-        "unpack": false
-    }
-]
deleted file mode 100644
--- a/testing/talos/talos/mitmproxy/mitmproxy-rel-bin-osx.manifest
+++ /dev/null
@@ -1,9 +0,0 @@
-[
-    {
-        "filename": "mitmproxy-2.0.2-osx.tar.gz",
-        "size": 32324573,
-        "digest": "06423c76e7e99fd9705eae3dc6e2423b1ffb8c42caa98fd010d59dc6ed1f0827376e238c48108106da558444b826e085a58aeb30cf9c79e9d0122a2cb17ae8e6",
-        "algorithm": "sha512",
-        "unpack": false
-    }
-]
deleted file mode 100644
--- a/testing/talos/talos/mitmproxy/mitmproxy.py
+++ /dev/null
@@ -1,197 +0,0 @@
-'''This helps loading mitmproxy's cert and change proxy settings for Firefox.'''
-# This Source Code Form is subject to the terms of the Mozilla Public
-# License, v. 2.0. If a copy of the MPL was not distributed with this
-# file, You can obtain one at http://mozilla.org/MPL/2.0/.
-from __future__ import absolute_import
-
-import os
-import subprocess
-import sys
-import time
-
-import mozinfo
-import psutil
-from mozlog import get_proxy_logger
-
-here = os.path.dirname(os.path.realpath(__file__))
-LOG = get_proxy_logger()
-
-# path for mitmproxy certificate, generated auto after mitmdump is started
-# on local machine it is 'HOME', however it is different on production machines
-try:
-    DEFAULT_CERT_PATH = os.path.join(os.getenv('HOME'),
-                                     '.mitmproxy', 'mitmproxy-ca-cert.cer')
-except Exception:
-    DEFAULT_CERT_PATH = os.path.join(os.getenv('HOMEDRIVE'), os.getenv('HOMEPATH'),
-                                     '.mitmproxy', 'mitmproxy-ca-cert.cer')
-
-# to install mitmproxy certificate into Firefox and turn on/off proxy
-POLICIES_CONTENT_ON = '''{
-  "policies": {
-    "Certificates": {
-      "Install": ["%(cert)s"]
-    },
-    "Proxy": {
-      "Mode": "manual",
-      "HTTPProxy": "127.0.0.1:8080",
-      "SSLProxy": "127.0.0.1:8080",
-      "Passthrough": "",
-      "Locked": true
-    }
-  }
-}'''
-
-POLICIES_CONTENT_OFF = '''{
-  "policies": {
-    "Proxy": {
-      "Mode": "none",
-      "Locked": false
-    }
-  }
-}'''
-
-
-def install_mitmproxy_cert(mitmproxy_proc, browser_path):
-    """Install the CA certificate generated by mitmproxy, into Firefox
-    1. Create a directory called distribution in the same directory as the Firefox executable
-    2. Create a file called policies.json with:
-    {
-      "policies": {
-        "certificates": {
-          "Install": ["FULL_PATH_TO_CERT"]
-        }
-      }
-    }
-    """
-    LOG.info("Installing mitmproxy CA certficate into Firefox")
-    # browser_path is the exe, we want the folder
-    policies_dir = os.path.dirname(browser_path)
-    # on macosx we need to remove the last folders 'MacOS'
-    # and the policies json needs to go in ../Content/Resources/
-    if 'mac' in mozinfo.os:
-        policies_dir = os.path.join(policies_dir[:-6], "Resources")
-    # for all platforms the policies json goes in a 'distribution' dir
-    policies_dir = os.path.join(policies_dir, "distribution")
-
-    cert_path = DEFAULT_CERT_PATH
-    # for windows only
-    if mozinfo.os == 'win':
-        cert_path = cert_path.replace('\\', '\\\\')
-
-    if not os.path.exists(policies_dir):
-        LOG.info("creating folder: %s" % policies_dir)
-        os.makedirs(policies_dir)
-    else:
-        LOG.info("folder already exists: %s" % policies_dir)
-
-    write_policies_json(policies_dir,
-                        policies_content=POLICIES_CONTENT_ON %
-                        {'cert': cert_path})
-
-    # cannot continue if failed to add CA cert to Firefox, need to check
-    if not is_mitmproxy_cert_installed(policies_dir):
-        LOG.error('Aborting: failed to install mitmproxy CA cert into Firefox')
-        stop_mitmproxy_playback(mitmproxy_proc)
-        sys.exit()
-
-
-def write_policies_json(location, policies_content):
-    policies_file = os.path.join(location, "policies.json")
-    LOG.info("writing: %s" % policies_file)
-
-    with open(policies_file, 'w') as fd:
-        fd.write(policies_content)
-
-
-def read_policies_json(location):
-    policies_file = os.path.join(location, "policies.json")
-    LOG.info("reading: %s" % policies_file)
-
-    with open(policies_file, 'r') as fd:
-        return fd.read()
-
-
-def is_mitmproxy_cert_installed(policies_dir):
-    """Verify mitmxproy CA cert was added to Firefox"""
-    try:
-        # read autoconfig file, confirm mitmproxy cert is in there
-        contents = read_policies_json(policies_dir)
-        LOG.info("Firefox policies file contents:")
-        LOG.info(contents)
-
-        cert_path = DEFAULT_CERT_PATH
-        # for windows only
-        if mozinfo.os == 'win':
-            cert_path = cert_path.replace('\\', '\\\\')
-
-        if (POLICIES_CONTENT_ON % {
-                'cert': cert_path}) in contents:
-            LOG.info("Verified mitmproxy CA certificate is installed in Firefox")
-        else:
-            return False
-    except Exception as e:
-        LOG.info("failed to read Firefox policies file, exeption: %s" % e)
-        return False
-    return True
-
-
-def start_mitmproxy_playback(mitmdump_path,
-                             mitmproxy_recording_path,
-                             mitmproxy_recordings_list,
-                             browser_path):
-    """Startup mitmproxy and replay the specified flow file"""
-    mitmproxy_recordings = []
-    # recording names can be provided in comma-separated list; build py list including path
-    for recording in mitmproxy_recordings_list:
-        mitmproxy_recordings.append(os.path.join(mitmproxy_recording_path, recording))
-
-    # cmd line to start mitmproxy playback using custom playback script is as follows:
-    # <path>/mitmdump -s "<path>mitmdump-alternate-server-replay/alternate-server-replay.py
-    #  <path>recording-1.mp <path>recording-2.mp..."
-    param = os.path.join(here, 'alternate-server-replay.py')
-    env = os.environ.copy()
-
-    # this part is platform-specific
-    if mozinfo.os == 'win':
-        param2 = '""' + param.replace('\\', '\\\\\\') + ' ' + \
-                 ' '.join(mitmproxy_recordings).replace('\\', '\\\\\\') + '""'
-        sys.path.insert(1, mitmdump_path)
-        # mitmproxy needs some DLL's that are a part of Firefox itself, so add to path
-        env["PATH"] = os.path.dirname(browser_path) + ";" + env["PATH"]
-    else:
-        # mac and linux
-        param2 = param + ' ' + ' '.join(mitmproxy_recordings)
-        env["PATH"] = os.path.dirname(browser_path)
-
-    command = [mitmdump_path, '-k', '-s', param2]
-
-    LOG.info("Starting mitmproxy playback using env path: %s" % env["PATH"])
-    LOG.info("Starting mitmproxy playback using command: %s" % ' '.join(command))
-    # to turn off mitmproxy log output, use these params for Popen:
-    # Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, env=env)
-    mitmproxy_proc = subprocess.Popen(command, env=env)
-    time.sleep(10)
-    data = mitmproxy_proc.poll()
-    if data is None:
-        LOG.info("Mitmproxy playback successfully started as pid %d" % mitmproxy_proc.pid)
-        return mitmproxy_proc
-    # cannot continue as we won't be able to playback the pages
-    LOG.error('Aborting: mitmproxy playback process failed to start, poll returned: %s' % data)
-    sys.exit()
-
-
-def stop_mitmproxy_playback(mitmproxy_proc):
-    """Stop the mitproxy server playback"""
-    LOG.info("Stopping mitmproxy playback, killing process %d" % mitmproxy_proc.pid)
-    if mozinfo.os == 'win':
-        mitmproxy_proc.kill()
-    else:
-        mitmproxy_proc.terminate()
-    time.sleep(10)
-    if mitmproxy_proc.pid in psutil.pids():
-        # I *think* we can still continue, as process will be automatically
-        # killed anyway when mozharness is done (?) if not, we won't be able
-        # to startup mitmxproy next time if it is already running
-        LOG.error("Failed to kill the mitmproxy playback process")
-    else:
-        LOG.info("Successfully killed the mitmproxy playback process")
deleted file mode 100644
--- a/testing/talos/talos/mitmproxy/mitmproxy_requirements.txt
+++ /dev/null
@@ -1,35 +0,0 @@
-argh==0.26.2
-asn1crypto==0.22.0
-blinker==1.4
-pycparser==2.17
-cffi==1.10.0
-brotlipy==0.6.0
-certifi==2017.4.17
-click==6.7
-construct==2.8.12
-cryptography==2.1.4
-cssutils==1.0.2
-EditorConfig==0.12.1
-h2==2.6.2
-hpack==3.0.0
-html2text==2016.9.19
-hyperframe==4.0.2
-idna==2.5
-jsbeautifier==1.6.12
-kaitaistruct==0.6
-mitmproxy==2.0.2
-packaging==16.8
-passlib==1.7.1
-pathtools==0.1.2
-pyasn1==0.2.3
-pyOpenSSL==16.2.0
-pyparsing==2.2.0
-pyperclip==1.5.27
-PyYAML==3.12
-requests==2.13.0
-ruamel.yaml==0.13.14
-six==1.10.0
-sortedcontainers==1.5.7
-tornado==4.4.3
-urwid==1.3.1
-watchdog==0.8.3
deleted file mode 100644
--- a/testing/talos/talos/mitmproxy/python3.manifest
+++ /dev/null
@@ -1,10 +0,0 @@
-[
-  {
-    "size": 15380470,
-    "visibility": "public",
-    "digest": "cd78b88d95b69bef99d7192b71dd34118700f44db0a0069a13bfd4943b131e8d7fdac83859f8ac15d873d4b329eef69d8d75d0a6746d06fdcfc5d06da0c9784c",
-    "algorithm": "sha512",
-    "unpack": true,
-    "filename": "python3.6.zip"
-  }
-]
deleted file mode 100644
--- a/testing/talos/talos/mitmproxy/python3_x64.manifest
+++ /dev/null
@@ -1,10 +0,0 @@
-[
-  {
-    "size": 16026760,
-    "visibility": "public",
-    "digest": "379428e3955671213a245ccd9ccf6f9d17d368db68c02da8baed7be629f2691127cd3e3f86807b25e2098d9840083fdc07946ab1bed0c14db4a5b628a47ed9ef",
-    "algorithm": "sha512",
-    "unpack": true,
-    "filename": "python3.6.amd64.zip"
-  }
-]
--- a/testing/talos/talos/run_tests.py
+++ b/testing/talos/talos/run_tests.py
@@ -15,17 +15,16 @@ import urllib
 
 import mozhttpd
 import mozinfo
 import mozversion
 
 from talos import utils
 from mozlog import get_proxy_logger
 from talos.config import get_configs, ConfigurationError
-from talos.mitmproxy import mitmproxy
 from talos.results import TalosResults
 from talos.ttest import TTest
 from talos.utils import TalosError, TalosRegression
 
 # directory of this file
 here = os.path.dirname(os.path.realpath(__file__))
 LOG = get_proxy_logger()
 
@@ -219,39 +218,16 @@ def run_tests(config, browser_config):
 
     # measuring the difference of a a certain thread level
     if config.get('stylothreads', 0) > 0:
         talos_results.add_extra_option('%s_thread' % config['stylothreads'])
 
     if config['gecko_profile']:
         talos_results.add_extra_option('geckoProfile')
 
-    # some tests use mitmproxy to playback pages
-    mitmproxy_recordings_list = config.get('mitmproxy', False)
-    if mitmproxy_recordings_list is not False:
-        # needed so can tell talos ttest to allow external connections
-        browser_config['mitmproxy'] = True
-
-        # start mitmproxy playback; this also generates the CA certificate
-        mitmdump_path = config.get('mitmdumpPath', False)
-        if mitmdump_path is False:
-            # cannot continue, need path for mitmdump playback tool
-            raise TalosError('Aborting: mitmdumpPath not provided on cmd line but is required')
-
-        mitmproxy_recording_path = os.path.join(here, 'mitmproxy')
-        mitmproxy_proc = mitmproxy.start_mitmproxy_playback(mitmdump_path,
-                                                            mitmproxy_recording_path,
-                                                            mitmproxy_recordings_list.split(),
-                                                            browser_config['browser_path'])
-
-        # install the generated CA certificate into Firefox
-        # mitmproxy cert setup needs path to mozharness install; mozharness has set this
-        mitmproxy.install_mitmproxy_cert(mitmproxy_proc,
-                                         browser_config['browser_path'])
-
     testname = None
 
     # run the tests
     timer = utils.Timer()
     LOG.suite_start(tests=[test['name'] for test in tests])
     try:
         for test in tests:
             testname = test['name']
@@ -316,20 +292,16 @@ def run_tests(config, browser_config):
         # indicate a failure to buildbot, turn the job red
         return 2
     finally:
         LOG.suite_end()
         httpd.stop()
 
     LOG.info("Completed test suite (%s)" % timer.elapsed())
 
-    # if mitmproxy was used for page playback, stop it
-    if mitmproxy_recordings_list is not False:
-        mitmproxy.stop_mitmproxy_playback(mitmproxy_proc)
-
     # output results
     if results_urls and not browser_config['no_upload_results']:
         talos_results.output(results_urls)
         if browser_config['develop'] or config['gecko_profile']:
             print("Thanks for running Talos locally. Results are in %s"
                   % (results_urls['output_urls']))
 
     # when running talos locally with gecko profiling on, use the view-gecko-profile
--- a/testing/talos/talos/test.py
+++ b/testing/talos/talos/test.py
@@ -892,82 +892,16 @@ class perf_reftest_singletons(Pageloader
     gecko_profile_entries = 2000000
     filters = filter.ignore_first.prepare(5) + filter.median.prepare()
     unit = 'ms'
     lower_is_better = True
     alert_threshold = 5.0
 
 
 @register_test()
-class tp6_google(QuantumPageloadTest):
-    """
-    Quantum Pageload Test - Google
-    """
-    tpmanifest = '${talos}/tests/quantum_pageload/quantum_pageload_google.manifest'
-    fnbpaint = False
-    tphero = True
-
-
-@register_test()
-class tp6_google_heavy(tp6_google):
-    """
-    tp6_google test ran against a heavy-user profile
-    """
-    profile = 'simple'
-
-
-@register_test()
-class tp6_youtube(QuantumPageloadTest):
-    """
-    Quantum Pageload Test - YouTube
-    """
-    tpmanifest = '${talos}/tests/quantum_pageload/quantum_pageload_youtube.manifest'
-
-
-@register_test()
-class tp6_youtube_heavy(tp6_youtube):
-    """
-    tp6_youtube test ran against a heavy-user profile
-    """
-    profile = 'simple'
-
-
-@register_test()
-class tp6_amazon(QuantumPageloadTest):
-    """
-    Quantum Pageload Test - Amazon
-    """
-    tpmanifest = '${talos}/tests/quantum_pageload/quantum_pageload_amazon.manifest'
-
-
-@register_test()
-class tp6_amazon_heavy(tp6_amazon):
-    """
-    tp6_amazon test ran against a heavy-user profile
-    """
-    profile = 'simple'
-
-
-@register_test()
-class tp6_facebook(QuantumPageloadTest):
-    """
-    Quantum Pageload Test - Facebook
-    """
-    tpmanifest = '${talos}/tests/quantum_pageload/quantum_pageload_facebook.manifest'
-
-
-@register_test()
-class tp6_facebook_heavy(tp6_facebook):
-    """
-    tp6_facebook test ran against a heavy-user profile
-    """
-    profile = 'simple'
-
-
-@register_test()
 class displaylist_mutate(PageloaderTest):
     """
     Test modifying single items in a large display list. Measure transaction speed
     to the compositor.
     """
     tpmanifest = '${talos}/tests/layout/displaylist_mutate.manifest'
     tpcycles = 1
     tppagecycles = 5
--- a/testing/talos/talos/ttest.py
+++ b/testing/talos/talos/ttest.py
@@ -124,21 +124,16 @@ class TTest(object):
             setup.env['MOZ_INSTRUMENT_EVENT_LOOP'] = '1'
             setup.env['MOZ_INSTRUMENT_EVENT_LOOP_THRESHOLD'] = '20'
             setup.env['MOZ_INSTRUMENT_EVENT_LOOP_INTERVAL'] = '10'
             global_counters['responsiveness'] = []
 
         setup.env['JSGC_DISABLE_POISONING'] = '1'
         setup.env['MOZ_DISABLE_NONLOCAL_CONNECTIONS'] = '1'
 
-        # if using mitmproxy we must allow access to 'external' sites
-        if browser_config.get('mitmproxy', False):
-            LOG.info('Using mitmproxy so setting MOZ_DISABLE_NONLOCAL_CONNECTIONS to 0')
-            setup.env['MOZ_DISABLE_NONLOCAL_CONNECTIONS'] = '0'
-
         # instantiate an object to hold test results
         test_results = results.TestResults(
             test_config,
             global_counters,
             browser_config.get('framework')
         )
 
         for i in range(test_config['cycles']):
--- a/testing/talos/talos/unittests/test_config.py
+++ b/testing/talos/talos/unittests/test_config.py
@@ -223,25 +223,16 @@ class Test_get_config(object):
         cls.argv_tsvg_static = '--activeTests tsvg_static -e /some/random/path'.split()
         cls.argv_tsvgr_opacity = '--activeTests tsvgr_opacity -e /some/random/path'.split()
         cls.argv_tscrollx = '--activeTests tscrollx -e /some/random/path'.split()
         cls.argv_a11yr = '--activeTests a11yr -e /some/random/path'.split()
         cls.argv_speedometer = '--activeTests speedometer -e /some/random/path'.split()
         cls.argv_perf_reftest = '--activeTests perf_reftest -e /some/random/path'.split()
         cls.argv_perf_reftest_singletons = \
             '--activeTests perf_reftest_singletons -e /some/random/path'.split()
-        cls.argv_tp6_google = '--activeTests tp6_google -e /some/random/path'.split()
-        cls.argv_tp6_google_heavy = '--activeTests tp6_google_heavy -e /some/random/path'.split()
-        cls.argv_tp6_youtube = '--activeTests tp6_youtube -e /some/random/path'.split()
-        cls.argv_tp6_youtube_heavy = '--activeTests tp6_youtube_heavy -e /some/random/path'.split()
-        cls.argv_tp6_amazon = '--activeTests tp6_amazon -e /some/random/path'.split()
-        cls.argv_tp6_amazon_heavy = '--activeTests tp6_amazon_heavy -e /some/random/path'.split()
-        cls.argv_tp6_facebook = '--activeTests tp6_facebook -e /some/random/path'.split()
-        cls.argv_tp6_facebook_heavy = \
-            '--activeTests tp6_facebook_heavy -e /some/random/path'.split()
 
     @classmethod
     def teardown_class(cls):
         conftest.remove_develop_files()
 
     def test_correctly_overrides_test_valus(self):
         config = get_config(self.argv)
         assert bool(config) is True
@@ -894,140 +885,16 @@ class Test_get_config(object):
         assert test_config['tptimeout'] == 30000
         assert test_config['gecko_profile_interval'] == 1
         assert test_config['gecko_profile_entries'] == 2000000
         assert test_config['filters'] is not None
         assert test_config['unit'] == 'ms'
         assert test_config['lower_is_better'] is True
         assert test_config['alert_threshold'] == 5.0
 
-    def test_tp6_google_has_expected_attributes(self):
-        config = get_config(self.argv_tp6_google)
-        test_config = config['tests'][0]
-
-        assert test_config['name'] == 'tp6_google'
-        assert test_config['tpcycles'] == 1
-        assert test_config['tppagecycles'] == 25
-        assert test_config['gecko_profile_interval'] == 1
-        assert test_config['gecko_profile_entries'] == 2000000
-        assert test_config['filters'] is not None
-        assert test_config['unit'] == 'ms'
-        assert test_config['lower_is_better'] is True
-        assert test_config['fnbpaint'] is False
-        assert test_config['tpmanifest'] != \
-            '${talos}/tests/quantum_pageload/quantum_pageload_google.manifest'
-
-    def test_tp6_google_heavy_has_expected_attributes(self):
-        config = get_config(self.argv_tp6_google_heavy)
-        test_config = config['tests'][0]
-
-        assert test_config['name'] == 'tp6_google_heavy'
-        assert test_config['tpcycles'] == 1
-        assert test_config['tppagecycles'] == 25
-        assert test_config['gecko_profile_interval'] == 1
-        assert test_config['gecko_profile_entries'] == 2000000
-        assert test_config['filters'] is not None
-        assert test_config['unit'] == 'ms'
-        assert test_config['lower_is_better'] is True
-        assert test_config['fnbpaint'] is False
-        assert test_config['profile'] == 'simple'
-
-    def test_tp6_youtube_has_expected_attributes(self):
-        config = get_config(self.argv_tp6_youtube)
-        test_config = config['tests'][0]
-
-        assert test_config['name'] == 'tp6_youtube'
-        assert test_config['tpcycles'] == 1
-        assert test_config['tppagecycles'] == 25
-        assert test_config['gecko_profile_interval'] == 1
-        assert test_config['gecko_profile_entries'] == 2000000
-        assert test_config['filters'] is not None
-        assert test_config['unit'] == 'ms'
-        assert test_config['lower_is_better'] is True
-        assert test_config['fnbpaint'] is True
-        assert test_config['tpmanifest'] != \
-            '${talos}/tests/quantum_pageload/quantum_pageload_youtube.manifest'
-
-    def test_tp6_youtube_heavy_has_expected_attributes(self):
-        config = get_config(self.argv_tp6_youtube_heavy)
-        test_config = config['tests'][0]
-
-        assert test_config['name'] == 'tp6_youtube_heavy'
-        assert test_config['tpcycles'] == 1
-        assert test_config['tppagecycles'] == 25
-        assert test_config['gecko_profile_interval'] == 1
-        assert test_config['gecko_profile_entries'] == 2000000
-        assert test_config['filters'] is not None
-        assert test_config['unit'] == 'ms'
-        assert test_config['lower_is_better'] is True
-        assert test_config['fnbpaint'] is True
-        assert test_config['profile'] == 'simple'
-
-    def test_tp6_amazon_has_expected_attributes(self):
-        config = get_config(self.argv_tp6_amazon)
-        test_config = config['tests'][0]
-
-        assert test_config['name'] == 'tp6_amazon'
-        assert test_config['tpcycles'] == 1
-        assert test_config['tppagecycles'] == 25
-        assert test_config['gecko_profile_interval'] == 1
-        assert test_config['gecko_profile_entries'] == 2000000
-        assert test_config['filters'] is not None
-        assert test_config['unit'] == 'ms'
-        assert test_config['lower_is_better'] is True
-        assert test_config['fnbpaint'] is True
-        assert test_config['tpmanifest'] != \
-            '${talos}/tests/quantum_pageload/quantum_pageload_amazon.manifest'
-
-    def test_tp6_amazon_heavy_has_expected_attributes(self):
-        config = get_config(self.argv_tp6_amazon_heavy)
-        test_config = config['tests'][0]
-
-        assert test_config['name'] == 'tp6_amazon_heavy'
-        assert test_config['tpcycles'] == 1
-        assert test_config['tppagecycles'] == 25
-        assert test_config['gecko_profile_interval'] == 1
-        assert test_config['gecko_profile_entries'] == 2000000
-        assert test_config['filters'] is not None
-        assert test_config['unit'] == 'ms'
-        assert test_config['lower_is_better'] is True
-        assert test_config['fnbpaint'] is True
-        assert test_config['profile'] == 'simple'
-
-    def test_tp6_facebook_has_expected_attributes(self):
-        config = get_config(self.argv_tp6_facebook)
-        test_config = config['tests'][0]
-
-        assert test_config['name'] == 'tp6_facebook'
-        assert test_config['tpcycles'] == 1
-        assert test_config['tppagecycles'] == 25
-        assert test_config['gecko_profile_interval'] == 1
-        assert test_config['gecko_profile_entries'] == 2000000
-        assert test_config['filters'] is not None
-        assert test_config['unit'] == 'ms'
-        assert test_config['lower_is_better'] is True
-        assert test_config['fnbpaint'] is True
-        assert test_config['tpmanifest'] != \
-            '${talos}/tests/quantum_pageload/quantum_pageload_facebook.manifest'
-
-    def test_tp6_facebook_heavy_has_expected_attributes(self):
-        config = get_config(self.argv_tp6_facebook_heavy)
-        test_config = config['tests'][0]
-
-        assert test_config['name'] == 'tp6_facebook_heavy'
-        assert test_config['tpcycles'] == 1
-        assert test_config['tppagecycles'] == 25
-        assert test_config['gecko_profile_interval'] == 1
-        assert test_config['gecko_profile_entries'] == 2000000
-        assert test_config['filters'] is not None
-        assert test_config['unit'] == 'ms'
-        assert test_config['lower_is_better'] is True
-        assert test_config['fnbpaint'] is True
-        assert test_config['profile'] == 'simple'
-
 
 @mock.patch('talos.config.get_browser_config')
 @mock.patch('talos.config.get_config')
 def test_get_configs(get_config_mock, get_browser_config_mock):
     # unpacks in right order
     get_config_mock.return_value = 'first'
     get_browser_config_mock.return_value = 'second'