(Reland) Port WebGL extension availability tests to the integration test harness.

content/test/gpu/gpu_tests/test_expectations.py

 # Copyright 2013 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 fnmatch
 import urlparse
 
 # Valid expectation conditions are:
 #
 # Operating systems:
@@ skipping 18 matching lines @@
 BROWSER_TYPE_CONDITIONS = [
     'android-webview-shell', 'android-content-shell', 'android-chromium',
     'debug', 'release']
 
 class Expectation(object):
   """Represents a single test expectation for a page.
 
   Supports conditions based on operating system (e.g., win, mac) and
   browser type (e.g. 'debug', 'release').
 
+  The pattern, if a URL, *must* be a relative URL. Absolute URLs
+  (e.g. starting with a scheme like http://, https://, file://) are
+  not allowed. A ValueError is raised if one is passed to __init__.
+
   Subclass this class and call super.__init__ last in your constructor
   in order to add new user-defined conditions. The conditions are
   parsed at the end of this class's constructor, so be careful not to
   overwrite the results of the constructor call!
+
   """
 
   def __init__(self, expectation, pattern, conditions=None, bug=None):
     self.expectation = expectation.lower()
+    if pattern.find('://') > 0:
+      raise ValueError('Absolute URLs are not allowed in patterns')
     self.pattern = pattern
     self.bug = bug
 
     self.os_conditions = []
     self.browser_conditions = []
 
     if conditions:
       for c in conditions:
         self.ParseCondition(c)
 
@@ skipping 25 matching lines @@
       self.os_conditions.append(cl)
     elif cl in BROWSER_TYPE_CONDITIONS:
       self.browser_conditions.append(condition)
     else:
       raise ValueError('Unknown expectation condition: "%s"' % cl)
 
 
 class TestExpectations(object):
   """A class which defines the expectations for a page set test execution"""
 
-  def __init__(self):
+  def __init__(self, url_prefixes=None):
     self._expectations = []
+    self._url_prefixes = []
     self._skip_matching_names = False
     self._built_expectation_cache = True
     self._ClearExpectationsCache()
     self.SetExpectations()
+    if url_prefixes:
+      for p in url_prefixes:
+        self._url_prefixes.append(p)
 
   def SetExpectations(self):
     """Called on creation. Override to set up custom expectations."""
     pass
 
   def Fail(self, pattern, conditions=None, bug=None):
     self._Expect('fail', pattern, conditions, bug)
 
   def Skip(self, pattern, conditions=None, bug=None):
     self._Expect('skip', pattern, conditions, bug)
@@ skipping 45 matching lines @@
     self._built_expectation_cache = True
     self._skip_matching_names = False
 
   def _GetNormalizedURL(self, url, browser):
     # Telemetry uses backslashes in its file:// URLs on Windows,
     # breaking matching of test expectations.
     if not browser.platform.GetOSName() == 'win':
       return url
     return url.replace('\\', '/')
 
-  def _GetURLPath(self, url):
-    components = urlparse.urlsplit(url)
+  def _GetURLPath(self, url, browser):
+    normalized_url = self._GetNormalizedURL(url, browser)
+    components = urlparse.urlsplit(normalized_url)
     # For compatibility, the file:// scheme must be treated specially.
     # The top-level directory shows up in the netloc portion of the URL.
     if components[0] == 'file':
       url_path = components[1] + components[2]
     else:
       url_path = components[2]
     # Chop any leading slash since the expectations used by this class
     # assume that.
     if url_path and url_path[0] == '/':
       url_path = url_path[1:]
     # Python's urlsplit doesn't seem to handle query arguments for
     # file:// URLs properly. Split them off manually.
     query_index = url_path.find('?')
     if query_index > 0:
       url_path = url_path[0:query_index]
+    # Look for the URL prefixes specified at construction time, and
+    # trim the first one found, if any.
+    if self._url_prefixes:
+      for p in self._url_prefixes:
+        if url_path.startswith(p):
+          url_path = url_path[len(p):]
+          break
     return url_path
 
   def _GetExpectationObjectForPage(self, browser, page):
     if not self._built_expectation_cache:
       self._BuildExpectationsCache(browser, page)
     # First attempt to look up by the page's URL or name.
     e = None
     # Relative URL (common case).
-    url = self._GetNormalizedURL(page.url, browser)
-    url_path = self._GetURLPath(url)
+    url_path = self._GetURLPath(page.url, browser)
     if url_path:
       e = self._expectations_by_pattern.get(url_path)
     if e:
       return e
-    e = self._expectations_by_pattern.get(url)
-    if e:
-      return e
     if page.name:
       e = self._expectations_by_pattern.get(page.name)
     if e:
       return e
     # Fall back to scanning through the expectations containing
     # wildcards.
     for e in self._expectations_with_wildcards:
       if self.ExpectationAppliesToPage(e, browser, page):
         return e
     return None
@@ skipping 28 matching lines @@
     Args:
       expectation: an instance of a subclass of Expectation, created
           by a call to CreateExpectation.
       browser: the currently running browser.
       page: the page to be run.
     """
     # While building the expectations cache we need to match
     # everything except the page's name or URL.
     if not self._skip_matching_names:
       # Relative URL.
-      if not fnmatch.fnmatch(self._GetURLPath(page.url),
+      if not fnmatch.fnmatch(self._GetURLPath(page.url, browser),
                              expectation.pattern):
-        # Absolute URL.
-        if not fnmatch.fnmatch(page.url,
-                               expectation.pattern):
-          # Name.
-          if not (page.name and fnmatch.fnmatch(page.name,
-                                                expectation.pattern)):
-            return False
+        # Name.
+        if not (page.name and fnmatch.fnmatch(page.name,
+                                              expectation.pattern)):
+          return False
 
     platform = browser.platform
     os_matches = (not expectation.os_conditions or
         platform.GetOSName() in expectation.os_conditions or
         platform.GetOSVersionName() in expectation.os_conditions)
 
     browser_matches = (
       (not expectation.browser_conditions) or
       browser.browser_type in expectation.browser_conditions)
 
     return os_matches and browser_matches