Use underscores to separate words in filenames in webkitpy.

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 10 matching lines @@
 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 import copy
 import logging
+import functools
 
 from webkitpy.common.memoized import memoized
-from functools import reduce
 
 _log = logging.getLogger(__name__)
 
 
 # FIXME: Should this function be somewhere more general?
 def _invert_dictionary(dictionary):
     inverted_dictionary = {}
     for key, value in dictionary.items():
         if inverted_dictionary.get(value):
             inverted_dictionary[value].append(key)
@@ skipping 50 matching lines @@
         # 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)
 
     def read_results_by_directory(self, baseline_name):
         results_by_directory = {}
-        directories = reduce(set.union, map(set, [self._relative_baseline_search_paths(
+        directories = functools.reduce(set.union, map(set, [self._relative_baseline_search_paths(
             port, baseline_name) for port in self._ports.values()]))
 
         for directory in directories:
             path = self._join_directory(directory, baseline_name)
             if self._filesystem.exists(path):
                 results_by_directory[directory] = self._filesystem.sha1(path)
         return results_by_directory
 
     def _results_by_port_name(self, results_by_directory, baseline_name):
         results_by_port_name = {}
@@ skipping 12 matching lines @@
             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.
-        directories_immediately_preceding_root = self._directories_immediately_preceding_root(baseline_name)
+        immediately_preceding_root = self._directories_immediately_preceding_root(baseline_name)
 
         shared_result = None
         root_baseline_unused = False
-        for directory in directories_immediately_preceding_root:
+        for directory in immediately_preceding_root:
             this_result = new_results_by_directory.get(directory)
 
             # If any of these directories don't have a baseline, there's no optimization we can do.
             if not this_result:
                 return
 
             if not shared_result:
                 shared_result = this_result
             elif shared_result != this_result:
                 root_baseline_unused = True
 
         baseline_root = self._baseline_root(baseline_name)
 
         # The root baseline is unused if all the directories immediately preceding the root
         # have a baseline, but have different baselines, so the baselines can't be promoted up.
         if root_baseline_unused:
             if baseline_root in new_results_by_directory:
                 del new_results_by_directory[baseline_root]
             return
 
         new_results_by_directory[baseline_root] = shared_result
-        for directory in directories_immediately_preceding_root:
+        for directory in immediately_preceding_root:
             del new_results_by_directory[directory]
 
     def _find_optimal_result_placement(self, baseline_name):
         results_by_directory = self.read_results_by_directory(baseline_name)
         results_by_port_name = self._results_by_port_name(results_by_directory, baseline_name)
-        port_names_by_result = _invert_dictionary(results_by_port_name)
 
         new_results_by_directory = self._remove_redundant_results(
-            results_by_directory, results_by_port_name, port_names_by_result, baseline_name)
+            results_by_directory, results_by_port_name, baseline_name)
         self._optimize_result_for_root(new_results_by_directory, baseline_name)
 
         return results_by_directory, new_results_by_directory
 
-    def _remove_redundant_results(self, results_by_directory, results_by_port_name, port_names_by_result, baseline_name):
+    def _remove_redundant_results(self, results_by_directory, results_by_port_name, baseline_name):
         new_results_by_directory = copy.copy(results_by_directory)
         for port_name, port in self._ports.items():
             current_result = results_by_port_name.get(port_name)
 
             # This happens if we're missing baselines for a port.
             if not current_result:
                 continue
 
             fallback_path = self._relative_baseline_search_paths(port, baseline_name)
             current_index, current_directory = self._find_in_fallbackpath(fallback_path, current_result, new_results_by_directory)
             for index in range(current_index + 1, len(fallback_path)):
                 new_directory = fallback_path[index]
-                if not new_directory in new_results_by_directory:
+                if new_directory not in new_results_by_directory:
                     # No result for this baseline in this directory.
                     continue
                 elif new_results_by_directory[new_directory] == current_result:
                     # Result for new_directory are redundant with the result earlier in the fallback order.
                     if current_directory in new_results_by_directory:
                         del new_results_by_directory[current_directory]
                 else:
                     # The new_directory contains a different result, so stop trying to push results up.
                     break
 
@@ skipping 10 matching lines @@
         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)
         if filename.startswith(platform_dir):
             return filename.replace(platform_dir, '').split(self._filesystem.sep)[0]
         return '(generic)'
 
     def _move_baselines(self, baseline_name, results_by_directory, new_results_by_directory):
         data_for_result = {}
         for directory, result in results_by_directory.items():
-            if not result in data_for_result:
+            if result not in data_for_result:
                 source = self._join_directory(directory, baseline_name)
                 data_for_result[result] = self._filesystem.read_binary_file(source)
 
         fs_files = []
         for directory, result in results_by_directory.items():
             if new_results_by_directory.get(directory) != result:
                 file_name = self._join_directory(directory, baseline_name)
                 if self._filesystem.exists(file_name):
                     fs_files.append(file_name)
 
@@ skipping 50 matching lines @@
         _log.debug("  %s:", basename)
         _log.debug("    Before: ")
         self.write_by_directory(results_by_directory, _log.debug, "      ")
         _log.debug("    After: ")
         self.write_by_directory(new_results_by_directory, _log.debug, "      ")
 
         self._move_baselines(baseline_name, results_by_directory, new_results_by_directory)
         return True
 
     def _optimize_virtual_root(self, baseline_name, non_virtual_baseline_name):
-        virtual_root_expected_baseline_path = self._filesystem.join(self._layout_tests_dir, baseline_name)
-        if not self._filesystem.exists(virtual_root_expected_baseline_path):
+        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_expected_baseline_path)
+        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_expected_baseline_path)
-        self._filesystem.remove(virtual_root_expected_baseline_path)
+        _log.debug("    Deleting (file system): " + virtual_root_baseline_path)
+        self._filesystem.remove(virtual_root_baseline_path)
 
     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 the regular path.
 
         _log.debug("Optimizing regular fallback path.")
         result = self._optimize_subtree(baseline_name)
         non_virtual_baseline_name = self._virtual_base(baseline_name)
         if not non_virtual_baseline_name:
             return result
 
         self._optimize_virtual_root(baseline_name, non_virtual_baseline_name)
 
         _log.debug("Optimizing non-virtual fallback path.")
         result |= self._optimize_subtree(non_virtual_baseline_name)
         return result