Add integration tests for QUIC

tools/chrome_proxy/integration_tests/chrome_proxy_measurements.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 base64
 import logging
 import urlparse
 
 from common import chrome_proxy_measurements as measurements
 from common.chrome_proxy_measurements import ChromeProxyValidation
@@ skipping 54 matching lines @@
 
 
 class ChromeProxyBypass(ChromeProxyValidation):
   """Correctness measurement for bypass responses."""
 
   def __init__(self):
     super(ChromeProxyBypass, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
 
+  def CustomizeBrowserOptions(self, options):
+    super(ChromeProxyBypass, self).CustomizeBrowserOptions(options)
+    options.AppendExtraBrowserArgs('--disable-quic')
+
   def AddResults(self, tab, results):
     self._metrics.AddResultsForBypass(tab, results)
 
 
 class ChromeProxyHTTPSBypass(ChromeProxyValidation):
   """Correctness measurement for bypass responses."""
 
   def __init__(self):
     super(ChromeProxyHTTPSBypass, self).__init__(
         restart_after_each_page=True,
@@ skipping 113 matching lines @@
 class ChromeProxyBadHTTPSFallback(ChromeProxyValidation):
   """Checks the client falls back to HTTP proxy when HTTPS proxy errors."""
 
   def __init__(self):
     super(ChromeProxyBadHTTPSFallback, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
     self._is_chrome_proxy_enabled = True
 
   def CustomizeBrowserOptions(self, options):
-    super(ChromeProxyBadHTTPSFallback, self).CustomizeBrowserOptions(
-        options)
+    super(ChromeProxyBadHTTPSFallback, self).CustomizeBrowserOptions(options)
+    options.AppendExtraBrowserArgs('--disable-quic')
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForBadHTTPSFallback(tab, results)
 
 class ChromeProxyHTTPFallbackProbeURL(ChromeProxyValidation):
   """Correctness measurement for proxy fallback.
 
   In this test, the probe URL does not return 'OK'. Chrome is expected
   to use the fallback proxy.
   """
@@ skipping 52 matching lines @@
 
 class ChromeProxyClientType(ChromeProxyValidation):
   """Correctness measurement for Chrome-Proxy header client type directives."""
 
   def __init__(self):
     super(ChromeProxyClientType, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
     self._chrome_proxy_client_type = None
 
+  def CustomizeBrowserOptions(self, options):
+    super(ChromeProxyClientType, self).CustomizeBrowserOptions(options)
+    options.AppendExtraBrowserArgs('--disable-quic')
+
   def AddResults(self, tab, results):
     # Get the Chrome-Proxy client type from the first page in the page set, so
     # that the client type value can be used to determine which of the later
     # pages in the page set should be bypassed.
     if not self._chrome_proxy_client_type:
       client_type = self._metrics.GetClientTypeFromRequests(tab)
       if client_type:
         self._chrome_proxy_client_type = client_type
 
     self._metrics.AddResultsForClientType(tab,
                                           results,
                                           self._chrome_proxy_client_type,
                                           self._page.bypass_for_client_type)
 
 
 class ChromeProxyLoFi(ChromeProxyValidation):
   """Correctness measurement for Lo-Fi in Chrome-Proxy header."""
 
   def __init__(self):
     super(ChromeProxyLoFi, self).__init__(restart_after_each_page=True,
                                           metrics=metrics.ChromeProxyMetric())
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyLoFi, self).CustomizeBrowserOptions(options)
     options.AppendExtraBrowserArgs('--data-reduction-proxy-lo-fi=always-on')
     # Disable server experiments such as tamper detection.
     options.AppendExtraBrowserArgs(
         '--data-reduction-proxy-server-experiments-disabled')
+    options.AppendExtraBrowserArgs('--disable-quic')
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForLoFi(tab, results)
 
 class ChromeProxyCacheLoFiDisabled(ChromeProxyValidation):
   """
   Correctness measurement for Lo-Fi placeholder is not loaded from cache when a
   page is reloaded with LoFi disabled. First a test page is opened with LoFi and
   chrome proxy enabled. This allows Chrome to cache the LoFi placeholder image.
   The browser is restarted with LoFi disabled and the same test page is loaded.
@@ skipping 14 matching lines @@
 
   def WillStartBrowser(self, platform):
     super(ChromeProxyCacheLoFiDisabled, self).WillStartBrowser(platform)
     if not self._page:
       # First page load, enable LoFi and chrome proxy. Disable server
       # experiments such as tamper detection.
       self.options.AppendExtraBrowserArgs(
             '--data-reduction-proxy-lo-fi=always-on')
       self.options.AppendExtraBrowserArgs(
         '--data-reduction-proxy-server-experiments-disabled')
+      self.options.AppendExtraBrowserArgs('--disable-quic')
       self._is_lo_fi_enabled = True
     else:
       # Second page load, disable LoFi. Chrome proxy is still enabled. Disable
       # server experiments such as tamper detection.
       self.options.browser_options.extra_browser_args.discard(
             '--data-reduction-proxy-lo-fi=always-on')
       self.options.AppendExtraBrowserArgs(
         '--data-reduction-proxy-server-experiments-disabled')
+      self.options.AppendExtraBrowserArgs('--disable-quic')
       self._is_lo_fi_enabled = False
 
   def WillNavigateToPage(self, page, tab):
     super(ChromeProxyCacheLoFiDisabled, self).WillNavigateToPage(page, tab)
     if self._is_lo_fi_enabled:
       # Clear cache for the first page to pick LoFi image from server.
       tab.ClearCache(force=True)
 
   def DidNavigateToPage(self, page, tab):
     if not self._is_lo_fi_enabled:
@@ skipping 24 matching lines @@
 
   def WillStartBrowser(self, platform):
     super(ChromeProxyCacheProxyDisabled, self).WillStartBrowser(platform)
     if not self._page:
       # First page load, enable LoFi and chrome proxy. Disable server
       # experiments such as tamper detection.
       self.options.AppendExtraBrowserArgs(
             '--data-reduction-proxy-lo-fi=always-on')
       self.options.AppendExtraBrowserArgs(
         '--data-reduction-proxy-server-experiments-disabled')
+      self.options.AppendExtraBrowserArgs('--disable-quic')
     else:
       # Second page load, disable chrome proxy. LoFi is still enabled.
+      self.options.AppendExtraBrowserArgs('--disable-quic')
       self.DisableChromeProxy()
 
   def WillNavigateToPage(self, page, tab):
     super(ChromeProxyCacheProxyDisabled, self).WillNavigateToPage(page, tab)
     if self._is_chrome_proxy_enabled:
       # Clear cache for the first page to pick LoFi image from server.
       tab.ClearCache(force=True)
 
   def DidNavigateToPage(self, page, tab):
     if not self._is_chrome_proxy_enabled:
       tab.ExecuteJavaScript('window.location.reload()')
       util.WaitFor(tab.HasReachedQuiescence, 3)
 
 class ChromeProxyLoFiPreview(ChromeProxyValidation):
   """Correctness measurement for Lo-Fi preview in Chrome-Proxy header."""
 
   def __init__(self):
     super(ChromeProxyLoFiPreview, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyLoFiPreview, self).CustomizeBrowserOptions(options)
     options.AppendExtraBrowserArgs(
         '--data-reduction-proxy-lo-fi=always-on')
     options.AppendExtraBrowserArgs(
         '--enable-data-reduction-proxy-lo-fi-preview')
+    options.AppendExtraBrowserArgs('--disable-quic')
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForLoFiPreview(tab, results)
 
 class ChromeProxyExpDirective(ChromeProxyValidation):
   """Correctness measurement for experiment directives in Chrome-Proxy header.
 
   This test verifies that "exp=test" in the Chrome-Proxy request header
   causes a bypass on the experiment test page.
   """
@@ skipping 17 matching lines @@
   causes a resource to be loaded without Data Reduction Proxy transformations.
   """
 
   def __init__(self):
     super(ChromeProxyPassThrough, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyPassThrough, self).CustomizeBrowserOptions(options)
+    options.AppendExtraBrowserArgs('--disable-quic')
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForPassThrough(tab, results)
 
 class ChromeProxyHTTPToDirectFallback(ChromeProxyValidation):
   """Correctness measurement for HTTP proxy fallback to direct."""
 
   def __init__(self):
     super(ChromeProxyHTTPToDirectFallback, self).__init__(
         restart_after_each_page=True,
@@ skipping 85 matching lines @@
             ],
         'bypass': [self._metrics.AddResultsForBypass],
         }
     if not self._page.name in page_to_metrics:
       raise page_test.MeasurementFailure(
           'Invalid page name (%s) in smoke. Page name must be one of:\n%s' % (
           self._page.name, page_to_metrics.keys()))
     for add_result in page_to_metrics[self._page.name]:
       add_result(tab, results)
 
+class ChromeProxyQuicSmoke(ChromeProxyValidation):
+  """Smoke measurement for basic chrome proxy correctness when using a
+  proxy that supports QUIC."""
+
+  def __init__(self):
+    super(ChromeProxyQuicSmoke, self).__init__(restart_after_each_page=True,
+                                           metrics=metrics.ChromeProxyMetric())
+
+  def CustomizeBrowserOptions(self, options):
+    super(ChromeProxyQuicSmoke, self).CustomizeBrowserOptions(options)
+    options.AppendExtraBrowserArgs(
+      '--enable-quic')
+    options.AppendExtraBrowserArgs(
+      '--data-reduction-proxy-http-proxies=https://proxy.googlezip.net:443')
+    options.AppendExtraBrowserArgs(
+      '--force-fieldtrials=DataReductionProxyUseQuic/Enabled')
+
+  def AddResults(self, tab, results):
+    # Map a page name to its AddResults func.
+    page_to_metrics = {
+        'header validation': [self._metrics.AddResultsForHeaderValidation],
+        'compression: image': [
+            self._metrics.AddResultsForHeaderValidation,
+            self._metrics.AddResultsForDataSaving,
+            ],
+        'compression: javascript': [
+            self._metrics.AddResultsForHeaderValidation,
+            self._metrics.AddResultsForDataSaving,
+            ],
+        'compression: css': [
+            self._metrics.AddResultsForHeaderValidation,
+            self._metrics.AddResultsForDataSaving,
+            ],
+        'bypass': [self._metrics.AddResultsForBypass],
+        }
+    if not self._page.name in page_to_metrics:
+      raise page_test.MeasurementFailure(
+          'Invalid page name (%s) in QUIC smoke. '
+          'Page name must be one of:\n%s' % (
+          self._page.name, page_to_metrics.keys()))
+    for add_result in page_to_metrics[self._page.name]:
+      add_result(tab, results)
 
 PROXIED = metrics.PROXIED
 DIRECT = metrics.DIRECT
 
 class ChromeProxyClientConfig(ChromeProxyValidation):
   """Chrome proxy client configuration service validation."""
 
   def __init__(self):
     super(ChromeProxyClientConfig, self).__init__(
         restart_after_each_page=True,
         metrics=metrics.ChromeProxyMetric())
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyClientConfig, self).CustomizeBrowserOptions(options)
     options.AppendExtraBrowserArgs(
       '--enable-data-reduction-proxy-config-client')
+    options.AppendExtraBrowserArgs('--disable-quic')
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForClientConfig(tab, results)
 
 class ChromeProxyVideoValidation(page_test.PageTest):
   """Validation for video pages.
 
   Measures pages using metrics.ChromeProxyVideoMetric. Pages can be fetched
   either direct from the origin server or via the proxy. If a page is fetched
   both ways, then the PROXIED and DIRECT measurements are compared to ensure
@@ skipping 107 matching lines @@
 
   def CustomizeBrowserOptions(self, options):
     super(ChromeProxyPingback, self).CustomizeBrowserOptions(options)
     options.AppendExtraBrowserArgs(
       '--enable-data-reduction-proxy-force-pingback')
     options.AppendExtraBrowserArgs(
       '--enable-stats-collection-bindings')
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForPingback(tab, results)
+
+class ChromeProxyQuicTransaction(ChromeProxyValidation):
+  """Chrome quic proxy usage validation when connecting to a proxy that
+  supports QUIC."""
+
+  def __init__(self):
+    super(ChromeProxyQuicTransaction, self).__init__(
+        metrics=metrics.ChromeProxyMetric())
+
+  def CustomizeBrowserOptions(self, options):
+    super(ChromeProxyQuicTransaction, self).CustomizeBrowserOptions(options)
+    options.AppendExtraBrowserArgs(
+      '--enable-quic')
+    options.AppendExtraBrowserArgs(
+      '--data-reduction-proxy-http-proxies=https://proxy.googlezip.net:443')
+    options.AppendExtraBrowserArgs(
+      '--force-fieldtrials=DataReductionProxyUseQuic/Enabled')
+    options.AppendExtraBrowserArgs(
+      '--enable-stats-collection-bindings')
+
+  def AddResults(self, tab, results):
+    self._metrics.AddResultsForQuicTransaction(tab, results)