Revert "build: roll infra_paths changes"

scripts/slave/recipe_modules/skia/api.py

 # Copyright 2014 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 
 import json
 import os
 import re
 import sys
 
@@ skipping 139 matching lines @@
 
   def setup(self, running_in_swarming=False):
     """Prepare the bot to run."""
     # Setup
     self.failed = []
 
     self.builder_name = self.m.properties['buildername']
     self.master_name = self.m.properties['mastername']
     self.slave_name = self.m.properties['slavename']
 
-    self.slave_dir = self.m.infra_paths['slave_build']
+    self.slave_dir = self.m.path['slave_build']
     self.skia_dir = self.slave_dir.join('skia')
     self.infrabots_dir = self.skia_dir.join('infra', 'bots')
 
     self.default_env = {}
     if running_in_swarming:
       self.default_env['CHROME_HEADLESS'] = '1'
       depot_tools = self.slave_dir.join('depot_tools')
       self.default_env['PATH'] = '%s:%%(PATH)s' % depot_tools
 
     # We run through this recipe in one of two ways:
@@ skipping 19 matching lines @@
     # Set some important variables.
     self.resource_dir = self.skia_dir.join('resources')
     self.images_dir = self.slave_dir.join('images')
     if self.running_in_swarming:
       self.swarming_out_dir = self.m.properties['swarm_out_dir']
       self.out_dir = self.slave_dir.join('out')
       self.local_skp_dir = self.slave_dir.join('skps')
     else:
       self.out_dir = self.m.path['checkout'].join('out', self.builder_name)
       self.local_skp_dir = self.slave_dir.join('playback', 'skps')
-    self.tmp_dir = self.m.infra_paths['slave_build'].join('tmp')
+    self.tmp_dir = self.m.path['slave_build'].join('tmp')
 
     self.gsutil_env_chromium_skia_gm = self.gsutil_env(BOTO_CHROMIUM_SKIA_GM)
 
     self.device_dirs = None
     self._ccache = None
     self._checked_for_ccache = False
     self.configuration = self.builder_spec['configuration']
     self.default_env.update({'SKIA_OUT': self.out_dir,
                              'BUILDTYPE': self.configuration})
     self.default_env.update(self.builder_spec['env'])
@@ skipping 39 matching lines @@
 
   def _run_once(self, fn, *args, **kwargs):
     if not hasattr(self, '_already_ran'):
       self._already_ran = {}
     if not fn.__name__ in self._already_ran:
       self._already_ran[fn.__name__] = True
       fn(*args, **kwargs)
 
   def update_repo(self, repo):
     """Update an existing repo. This is safe to call without gen_steps."""
-    repo_path = self.m.infra_paths['slave_build'].join(repo.name)
+    repo_path = self.m.path['slave_build'].join(repo.name)
     if self.m.path.exists(repo_path):
       if self.m.platform.is_win:
         git = 'git.bat'
       else:
         git = 'git'
       self.m.step('git remote set-url',
                   cmd=[git, 'remote', 'set-url', 'origin', repo.url],
                   cwd=repo_path,
                   infra_step=True)
       self.m.step('git fetch',
                   cmd=[git, 'fetch'],
                   cwd=repo_path,
                   infra_step=True)
       self.m.step('git reset',
                   cmd=[git, 'reset', '--hard', repo.revision],
                   cwd=repo_path,
                   infra_step=True)
       self.m.step('git clean',
                   cmd=[git, 'clean', '-d', '-f'],
                   cwd=repo_path,
                   infra_step=True)
 
   def checkout_steps(self):
     """Run the steps to obtain a checkout of Skia."""
     if self.running_in_swarming:
       # We should've obtained the Skia checkout through isolates, so we don't
       # need to perform the checkout ourselves.
-      self.m.path['checkout'] = self.m.infra_paths['slave_build'].join('skia')
+      self.m.path['checkout'] = self.m.path['slave_build'].join('skia')
       self.got_revision = self.m.properties['revision']
       return
 
     # Initial cleanup.
     gclient_cfg = self.m.gclient.make_config()
     skia = gclient_cfg.solutions.add()
     skia.name = 'skia'
     skia.managed = False
     skia.url = global_constants.SKIA_REPO
     skia.revision = self.m.properties.get('revision') or 'origin/master'
@@ skipping 406 matching lines @@
       self.run(
           self.m.python,
           'Upload DM Results',
           script=self.resource('upload_dm_results.py'),
           args=[
               self.dm_dir,
               self.got_revision,
               self.builder_name,
               self.m.properties['buildnumber'],
               self.m.properties['issue'] if self.is_trybot else '',
-              self.m.infra_paths['slave_build'].join('skia', 'common', 'py', 'utils'),
+              self.m.path['slave_build'].join('skia', 'common', 'py', 'utils'),
           ],
           cwd=self.m.path['checkout'],
           env=self.gsutil_env_chromium_skia_gm,
           abort_on_failure=False,
           infra_step=True)
 
     # See skia:2789.
     if ('Valgrind' in self.builder_name and
         self.builder_cfg.get('cpu_or_gpu') == 'GPU'):
       abandonGpuContext = list(args)
@@ skipping 84 matching lines @@
     if self.upload_perf_results:
       self.m.file.makedirs('perf_dir', self.perf_data_dir)
       self.flavor.copy_directory_contents_to_host(
           self.device_dirs.perf_data_dir, self.perf_data_dir)
 
       if self.running_in_swarming:
         # If we're running in Swarming, we wrote the results into the Swarming
         # out dir, so we don't need to upload.
         return
 
-      gsutil_path = self.m.infra_paths['depot_tools'].join(
+      gsutil_path = self.m.path['depot_tools'].join(
           'third_party', 'gsutil', 'gsutil')
       upload_args = [self.builder_name, self.m.properties['buildnumber'],
                      self.perf_data_dir, self.got_revision, gsutil_path]
       if self.is_trybot:
         upload_args.append(self.m.properties['issue'])
       self.run(self.m.python,
                'Upload %s Results' % target,
                script=self.resource('upload_bench_results.py'),
                args=upload_args,
                cwd=self.m.path['checkout'],
@@ skipping 26 matching lines @@
     # Don't bother to include role, which is always Test.
     # TryBots are uploaded elsewhere so they can use the same key.
     blacklist = ['role', 'is_trybot']
 
     flat = []
     for k in sorted(self.builder_cfg.keys()):
       if k not in blacklist:
         flat.append(k)
         flat.append(self.builder_cfg[k])
     return flat