Move chrome_proxy tests from under tools/perf to tools/chrome_proxy/integration_tests.

tools/chrome_proxy/integration_tests/chrome_proxy_metrics.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 datetime
 import logging
 import os
 
+from integration_tests import network_metrics
 from telemetry.page import page_measurement
-from metrics import network
-from telemetry.value import scalar
 
 
 class ChromeProxyMetricException(page_measurement.MeasurementFailure):
   pass
 
 
 CHROME_PROXY_VIA_HEADER = 'Chrome-Compression-Proxy'
 CHROME_PROXY_VIA_HEADER_DEPRECATED = '1.1 Chrome Compression Proxy'
 
 PROXY_SETTING_HTTPS = 'proxy.googlezip.net:443'
 PROXY_SETTING_HTTPS_WITH_SCHEME = 'https://' + PROXY_SETTING_HTTPS
 PROXY_SETTING_HTTP = 'compress.googlezip.net:80'
 PROXY_SETTING_DIRECT = 'direct://'
 
 # The default Chrome Proxy bypass time is a range from one to five mintues.
 # See ProxyList::UpdateRetryInfoOnFallback in net/proxy/proxy_list.cc.
 DEFAULT_BYPASS_MIN_SECONDS = 60
 DEFAULT_BYPASS_MAX_SECONDS = 5 * 60
 
 def GetProxyInfoFromNetworkInternals(tab, url='chrome://net-internals#proxy'):
   tab.Navigate(url)
-  with open(os.path.join(os.path.dirname(__file__), 'chrome_proxy.js')) as f:
+  with open(os.path.join(os.path.dirname(__file__),
+                         'chrome_proxy_metrics.js')) as f:
     js = f.read()
     tab.ExecuteJavaScript(js)
   tab.WaitForJavaScriptExpression('performance.timing.loadEventStart', 300)
   info = tab.EvaluateJavaScript('window.__getChromeProxyInfo()')
   return info
 
 
 def ProxyRetryTimeInRange(retry_time, low, high, grace_seconds=30):
   return (retry_time >= low and
           (retry_time < high + datetime.timedelta(seconds=grace_seconds)))
 
 
-class ChromeProxyResponse(network.HTTPResponse):
+class ChromeProxyResponse(network_metrics.HTTPResponse):
   """ Represents an HTTP response from a timeleine event."""
   def __init__(self, event):
     super(ChromeProxyResponse, self).__init__(event)
 
   def ShouldHaveChromeProxyViaHeader(self):
     resp = self.response
     # Ignore https and data url
     if resp.url.startswith('https') or resp.url.startswith('data:'):
       return False
     # Ignore 304 Not Modified and cache hit.
@@ skipping 24 matching lines @@
 
   def IsSafebrowsingResponse(self):
     if (self.response.status == 307 and
         self.response.GetHeader('X-Malware-Url') == '1' and
         self.IsValidByViaHeader() and
         self.response.GetHeader('Location') == self.response.url):
       return True
     return False
 
 
-class ChromeProxyMetric(network.NetworkMetric):
+class ChromeProxyMetric(network_metrics.NetworkMetric):
   """A Chrome proxy timeline metric."""
 
   def __init__(self):
     super(ChromeProxyMetric, self).__init__()
     self.compute_data_saving = True
     self.effective_proxies = {
         "proxy": PROXY_SETTING_HTTPS_WITH_SCHEME,
         "fallback": PROXY_SETTING_HTTP,
         "direct": PROXY_SETTING_DIRECT,
         }
@@ skipping 15 matching lines @@
 
     super(ChromeProxyMetric, self).AddResults(tab, results)
     for resp in self.IterResponses(tab):
       if resp.response.served_from_cache:
         resources_from_cache += 1
       if resp.HasChromeProxyViaHeader():
         resources_via_proxy += 1
       else:
         resources_direct += 1
 
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'resources_via_proxy', 'count',
-        resources_via_proxy))
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'resources_from_cache', 'count',
-        resources_from_cache))
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'resources_direct', 'count', resources_direct))
+    results.Add('resources_via_proxy', 'count', resources_via_proxy)
+    results.Add('resources_from_cache', 'count', resources_from_cache)
+    results.Add('resources_direct', 'count', resources_direct)
 
   def AddResultsForHeaderValidation(self, tab, results):
     via_count = 0
     bypass_count = 0
     for resp in self.IterResponses(tab):
       if resp.IsValidByViaHeader():
         via_count += 1
       elif tab and self.IsProxyBypassed(tab):
         logging.warning('Proxy bypassed for %s', resp.response.url)
         bypass_count += 1
       else:
         r = resp.response
         raise ChromeProxyMetricException, (
             '%s: Via header (%s) is not valid (refer=%s, status=%d)' % (
                 r.url, r.GetHeader('Via'), r.GetHeader('Referer'), r.status))
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'checked_via_header', 'count', via_count))
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'request_bypassed', 'count', bypass_count))
+    results.Add('checked_via_header', 'count', via_count)
+    results.Add('request_bypassed', 'count', bypass_count)
 
   def IsProxyBypassed(self, tab):
     """ Returns True if all configured proxies are bypassed."""
     info = GetProxyInfoFromNetworkInternals(tab)
     if not info['enabled']:
       raise ChromeProxyMetricException, (
           'Chrome proxy should be enabled. proxy info: %s' % info)
 
     bad_proxies = [str(p['proxy']) for p in info['badProxies']].sort()
     proxies = [self.effective_proxies['proxy'],
@@ skipping 46 matching lines @@
     if tab:
       info = GetProxyInfoFromNetworkInternals(tab)
       if not info['enabled']:
         raise ChromeProxyMetricException, (
             'Chrome proxy should be enabled. proxy info: %s' % info)
       self.VerifyBadProxies(
           info['badProxies'],
           [self.effective_proxies['proxy'],
            self.effective_proxies['fallback']])
 
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'bypass', 'count', bypass_count))
+    results.Add('bypass', 'count', bypass_count)
 
   def AddResultsForSafebrowsing(self, tab, results):
     count = 0
     safebrowsing_count = 0
     for resp in self.IterResponses(tab):
       count += 1
       if resp.IsSafebrowsingResponse():
         safebrowsing_count += 1
       else:
         r = resp.response
         raise ChromeProxyMetricException, (
             '%s: Not a valid safe browsing response.\n'
             'Reponse: status=(%d, %s)\nHeaders:\n %s' % (
                 r.url, r.status, r.status_text, r.headers))
     if count == safebrowsing_count:
-      results.AddValue(scalar.ScalarValue(
-          results.current_page, 'safebrowsing', 'boolean', True))
+      results.Add('safebrowsing', 'boolean', True)
     else:
       raise ChromeProxyMetricException, (
           'Safebrowsing failed (count=%d, safebrowsing_count=%d)\n' % (
               count, safebrowsing_count))
 
   def AddResultsForHTTPFallback(
       self, tab, results, expected_proxies=None, expected_bad_proxies=None):
     info = GetProxyInfoFromNetworkInternals(tab)
     if not 'enabled' in info or not info['enabled']:
       raise ChromeProxyMetricException, (
@@ skipping 12 matching lines @@
           str(proxies), str(expected_proxies)))
 
     bad_proxies = []
     if 'badProxies' in info and info['badProxies']:
       bad_proxies = [p['proxy'] for p in info['badProxies']
                      if 'proxy' in p and p['proxy']]
     if bad_proxies != expected_bad_proxies:
       raise ChromeProxyMetricException, (
           'Wrong bad proxies (%s). Expect: "%s"' % (
           str(bad_proxies), str(expected_bad_proxies)))
-    results.AddValue(scalar.ScalarValue(
-        results.current_page, 'http_fallback', 'boolean', True))
+    results.Add('http_fallback', 'boolean', True)