webkitpy: Avoid to use webkit_base() and literal 'LayoutTests' in BaselineOptimizer

third_party/WebKit/Tools/Scripts/webkitpy/common/checkout/baseline_optimizer.py

 # Copyright (C) 2011, Google Inc. All rights reserved.
 #
 # Redistribution and use in source and binary forms, with or without
 # modification, are permitted provided that the following conditions are
 # met:
 #
 #     * Redistributions of source code must retain the above copyright
 # notice, this list of conditions and the following disclaimer.
 #     * Redistributions in binary form must reproduce the above
 # copyright notice, this list of conditions and the following disclaimer
@@ skipping 18 matching lines @@
 import copy
 import logging
 import functools
 
 from webkitpy.common.memoized import memoized
 
 _log = logging.getLogger(__name__)
 
 
 class BaselineOptimizer(object):
-    ROOT_LAYOUT_TESTS_DIRECTORY = 'LayoutTests'
 
     def __init__(self, host, port, port_names):
         self._filesystem = host.filesystem
         self._default_port = port
         self._ports = {}
         for port_name in port_names:
             self._ports[port_name] = host.port_factory.get(port_name)
 
-        self._webkit_base = port.webkit_base()
         self._layout_tests_dir = port.layout_tests_dir()
+        self._parent_of_tests = self._filesystem.dirname(self._layout_tests_dir)
+        self._layout_tests_dir_name = self._filesystem.relpath(
+            self._layout_tests_dir, self._parent_of_tests)
 
         # Only used by unit tests.
         self.new_results_by_directory = []
 
     def optimize(self, baseline_name):
         # The virtual fallback path is the same as the non-virtual one
         # tacked on to the bottom of the non-virtual path. See
         # https://docs.google.com/a/chromium.org/drawings/d/1eGdsIKzJ2dxDDBbUaIABrN4aMLD1bqJTfyxNGZsTdmg/edit
         # for a visual representation of this.
         # So, we can optimize the virtual path, then the virtual root, and then
@@ skipping 91 matching lines @@
                 file_names.append(destination)
 
         if file_names:
             _log.debug('    Adding:')
             for platform_dir in sorted(self._platform(filename) for filename in file_names):
                 _log.debug('      ' + platform_dir)
         else:
             _log.debug('    (Nothing to add)')
 
     def _platform(self, filename):
-        platform_dir = self.ROOT_LAYOUT_TESTS_DIRECTORY + self._filesystem.sep + 'platform' + self._filesystem.sep
+        platform_dir = self._layout_tests_dir_name + self._filesystem.sep + 'platform' + self._filesystem.sep
         if filename.startswith(platform_dir):
             return filename.replace(platform_dir, '').split(self._filesystem.sep)[0]
-        platform_dir = self._filesystem.join(self._webkit_base, platform_dir)
+        platform_dir = self._filesystem.join(self._parent_of_tests, platform_dir)
         if filename.startswith(platform_dir):
             return filename.replace(platform_dir, '').split(self._filesystem.sep)[0]
         return '(generic)'
 
     def _optimize_virtual_root(self, baseline_name, non_virtual_baseline_name):
         virtual_root_baseline_path = self._filesystem.join(self._layout_tests_dir, baseline_name)
         if not self._filesystem.exists(virtual_root_baseline_path):
             return
         root_sha1 = self._filesystem.sha1(virtual_root_baseline_path)
 
         results_by_directory = self.read_results_by_directory(non_virtual_baseline_name)
         # See if all the immediate predecessors of the virtual root have the same expected result.
         for port in self._ports.values():
             directories = self._relative_baseline_search_paths(port, non_virtual_baseline_name)
             for directory in directories:
                 if directory not in results_by_directory:
                     continue
                 if results_by_directory[directory] != root_sha1:
                     return
                 break
 
         _log.debug('Deleting redundant virtual root expected result.')
         _log.debug('    Deleting (file system): ' + virtual_root_baseline_path)
         self._filesystem.remove(virtual_root_baseline_path)
 
     def _baseline_root(self, baseline_name):
         virtual_suite = self._virtual_suite(baseline_name)
         if virtual_suite:
-            return self._filesystem.join(self.ROOT_LAYOUT_TESTS_DIRECTORY, virtual_suite.name)
-        return self.ROOT_LAYOUT_TESTS_DIRECTORY
+            return self._filesystem.join(self._layout_tests_dir_name, virtual_suite.name)
+        return self._layout_tests_dir_name
 
     def _baseline_search_path(self, port, baseline_name):
         virtual_suite = self._virtual_suite(baseline_name)
         if virtual_suite:
             return port.virtual_baseline_search_path(baseline_name)
         return port.baseline_search_path()
 
     def _virtual_suite(self, baseline_name):
         return self._default_port.lookup_virtual_suite(baseline_name)
 
     def _virtual_base(self, baseline_name):
         return self._default_port.lookup_virtual_test_base(baseline_name)
 
     def _relative_baseline_search_paths(self, port, baseline_name):
         """Returns a list of paths to check for baselines in order."""
         baseline_search_path = self._baseline_search_path(port, baseline_name)
         baseline_root = self._baseline_root(baseline_name)
-        relative_paths = [self._filesystem.relpath(path, self._webkit_base) for path in baseline_search_path]
+        relative_paths = [self._filesystem.relpath(path, self._parent_of_tests) for path in baseline_search_path]
         return relative_paths + [baseline_root]
 
     def _join_directory(self, directory, baseline_name):
         # This code is complicated because both the directory name and the
         # baseline_name have the virtual test suite in the name and the virtual
         # baseline name is not a strict superset of the non-virtual name.
         # For example, virtual/gpu/fast/canvas/foo-expected.png corresponds to
         # fast/canvas/foo-expected.png and the baseline directories are like
         # platform/mac/virtual/gpu/fast/canvas. So, to get the path to the
         # baseline in the platform directory, we need to append just
         # foo-expected.png to the directory.
         virtual_suite = self._virtual_suite(baseline_name)
         if virtual_suite:
             baseline_name_without_virtual = baseline_name[len(virtual_suite.name) + 1:]
         else:
             baseline_name_without_virtual = baseline_name
-        return self._filesystem.join(self._webkit_base, directory, baseline_name_without_virtual)
+        return self._filesystem.join(self._parent_of_tests, directory, baseline_name_without_virtual)
 
     def _results_by_port_name(self, results_by_directory, baseline_name):
         results_by_port_name = {}
         for port_name, port in self._ports.items():
             for directory in self._relative_baseline_search_paths(port, baseline_name):
                 if directory in results_by_directory:
                     results_by_port_name[port_name] = results_by_directory[directory]
                     break
         return results_by_port_name
 
     @memoized
     def _directories_immediately_preceding_root(self, baseline_name):
         directories = set()
         for port in self._ports.values():
-            directory = self._filesystem.relpath(self._baseline_search_path(port, baseline_name)[-1], self._webkit_base)
+            directory = self._filesystem.relpath(self._baseline_search_path(port, baseline_name)[-1], self._parent_of_tests)
             directories.add(directory)
         return directories
 
     def _optimize_result_for_root(self, new_results_by_directory, baseline_name):
         # The root directory (i.e. LayoutTests) is the only one that doesn't correspond
         # to a specific platform. As such, it's the only one where the baseline in fallback directories
         # immediately before it can be promoted up, i.e. if win and mac
         # have the same baseline, then it can be promoted up to be the LayoutTests baseline.
         # All other baselines can only be removed if they're redundant with a baseline earlier
         # in the fallback order. They can never promoted up.
@@ skipping 60 matching lines @@
                     # The new_directory contains a different result, so stop trying to push results up.
                     break
 
         return new_results_by_directory
 
     def _find_in_fallbackpath(self, fallback_path, current_result, results_by_directory):
         for index, directory in enumerate(fallback_path):
             if directory in results_by_directory and (results_by_directory[directory] == current_result):
                 return index, directory
         assert False, 'result %s not found in fallback_path %s, %s' % (current_result, fallback_path, results_by_directory)