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 261 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.
   This second page load should not pick the LoFi placeholder from cache and
   original image should be loaded. This test should be run with
   --profile-type=default command line for the same user profile and cache to be
   used across the two page loads.
   """
 
   def __init__(self):
     super(ChromeProxyCacheLoFiDisabled, self).__init__(
             restart_after_each_page=True,
             metrics=metrics.ChromeProxyMetric(),
             clear_cache_before_each_run=False)
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForLoFiCache(tab, results, self._is_lo_fi_enabled)
 
   def WillStartBrowser(self, platform):
     super(ChromeProxyCacheLoFiDisabled, self).WillStartBrowser(platform)
+    self.options.AppendExtraBrowserArgs('--disable-quic')
     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._is_lo_fi_enabled = True
     else:
       # Second page load, disable LoFi. Chrome proxy is still enabled. Disable
@@ skipping 32 matching lines @@
             restart_after_each_page=True,
             metrics=metrics.ChromeProxyMetric(),
             clear_cache_before_each_run=False)
 
   def AddResults(self, tab, results):
     self._metrics.AddResultsForLoFiCache(tab, results,
                                          self._is_chrome_proxy_enabled)
 
   def WillStartBrowser(self, platform):
     super(ChromeProxyCacheProxyDisabled, self).WillStartBrowser(platform)
+    self.options.AppendExtraBrowserArgs('--disable-quic')
     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')
     else:
       # Second page load, disable chrome proxy. LoFi is still enabled.
       self.DisableChromeProxy()
@@ skipping 16 matching lines @@
     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(page_test.PageTest):
+  """Smoke measurement for basic chrome proxy correctness when using a
+  proxy that supports QUIC."""
+
+  def __init__(self, *args, **kwargs):
+    super(ChromeProxyQuicSmoke, self).__init__(*args, **kwargs)
+    self._metrics = metrics.ChromeProxyMetric()
+    self._enable_proxy = True
+
+  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')
+    options.AppendExtraBrowserArgs('--enable-spdy-proxy-auth')
+
+  def WillNavigateToPage(self, page, tab):
+    if self._enable_proxy:
+      measurements.WaitForViaHeader(tab)
+    tab.ClearCache(force=True)
+    self._metrics.Start(page, tab)
+
+  def ValidateAndMeasurePage(self, page, tab, results):
+    # Wait for the load event.
+    tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
+    self._metrics.Stop(page, tab)
+    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 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' % (
+          page.name, page_to_metrics.keys()))
+    for add_result in page_to_metrics[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(page_test.PageTest):
+  """Chrome quic proxy usage validation when connecting to a proxy that
+  supports QUIC."""
+
+  def __init__(self, *args, **kwargs):
+    super(ChromeProxyQuicTransaction, self).__init__(*args, **kwargs)
+    self._metrics = metrics.ChromeProxyMetric()
+    self._enable_proxy = True
+
+  def CustomizeBrowserOptions(self, 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-spdy-proxy-auth')
+    options.AppendExtraBrowserArgs(
+      '--enable-stats-collection-bindings')
+
+  def WillNavigateToPage(self, page, tab):
+    if self._enable_proxy:
+      measurements.WaitForViaHeader(tab)
+    tab.ClearCache(force=True)
+    self._metrics.Start(page, tab)
+
+  def ValidateAndMeasurePage(self, page, tab, results):
+    # Wait for the load event.
+    tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
+    self._metrics.Stop(page, tab)
+    self._metrics.AddResultsForQuicTransaction(tab, results)