Add protocol and port to HTTPResponse.

tools/chrome_proxy/webdriver/common.py

 # Copyright 2016 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 argparse
 import json
 import os
 import re
 import socket
 import shlex
@@ skipping 24 matching lines @@
     'be considered valid')
   parser.add_argument('--android', help='If given, attempts to run the test on '
     'Android via adb. Ignores usage of --chrome_exec', action='store_true')
   parser.add_argument('--android_package', nargs=1,
     default='com.android.chrome', help='Set the android package for Chrome')
   parser.add_argument('--chrome_exec', nargs=1, type=str, help='The path to '
     'the Chrome or Chromium executable')
   parser.add_argument('chrome_driver', nargs=1, type=str, help='The path to '
     'the ChromeDriver executable. If not given, the default system chrome '
     'will be used.')
-  parser.add_argument('-b', '--buffer', help='The standard output and standard '
-    'error streams are buffered during the test run. Output during a passing '
-    'test is discarded. Output is echoed normally on test fail or error and is '
-    'added to the failure messages.', action='store_true')
+  parser.add_argument('--disable_buffer', help='Causes stdout and stderr from '
+    'tests to output normally. Otherwise, the standard output and standard '
+    'error streams are buffered during the test run, and output during a '
+    'passing test is discarded. Output will always be echoed normally on test '
+    'fail or error and is added to the failure messages.', action='store_true')
   parser.add_argument('-c', '--catch', help='Control-C during the test run '
     'waits for the current test to end and then reports all the results so '
     'far. A second Control-C raises the normal KeyboardInterrupt exception.',
     action='store_true')
   parser.add_argument('-f', '--failfast', help='Stop the test run on the first '
     'error or failure.', action='store_true')
   # TODO(robertogden): Log sys.argv here.
   return parser.parse_args(sys.argv[1:])
 
 def HandleException(test_name=None):
@@ skipping 241 matching lines @@
     all_messages = []
     for log in self._driver.execute('getLog', {'type': 'performance'})['value']:
       message = json.loads(log['message'])['message']
       if re.match(method_filter, message['method']):
         all_messages.append(message)
     return all_messages
 
   def GetHTTPResponses(self, include_favicon=False):
     """Parses the Performance Logs and returns a list of HTTPResponse objects.
 
-    This function should be called exactly once after every page load.
+    Use caution when calling this function  multiple times. Only responses
+    since the last time this function was called are returned (or since Chrome
+    started, whichever is later).
 
     Args:
       include_favicon: A bool that if True will include responses for favicons.
     Returns:
       A list of HTTPResponse objects, each representing a single completed HTTP
       transaction by Chrome.
     """
     def MakeHTTPResponse(log_dict):
       params = log_dict['params']
       response_dict = params['response']
       http_response_dict = {
-        'response_headers': response_dict['headers'],
-        'request_headers': response_dict['requestHeaders'],
-        'url': response_dict['url'],
-        'status': response_dict['status'],
-        'request_type': params['type']
+        'response_headers': response_dict['headers'] if 'headers' in
+          response_dict else {},
+        'request_headers': response_dict['requestHeaders'] if 'requestHeaders'
+          in response_dict else {},
+        'url': response_dict['url'] if 'url' in response_dict else '',
+        'protocol': response_dict['protocol'] if 'protocol' in response_dict
+          else '',
+        'port': response_dict['remotePort'] if 'remotePort' in response_dict
+          else -1,
+        'status': response_dict['status'] if 'status' in response_dict else -1,
+        'request_type': params['type'] if 'type' in params else ''
       }
       return HTTPResponse(**http_response_dict)
     all_responses = []
     for message in self.GetPerformanceLogs():
       response = MakeHTTPResponse(message)
       is_favicon = response.url.endswith('favicon.ico')
       if not is_favicon or include_favicon:
         all_responses.append(response)
     return all_responses
 
 class HTTPResponse:
   """This class represents a single HTTP transaction (request and response) by
   Chrome.
 
   This class also includes several convenience functions for ChromeProxy
   specific assertions.
 
   Attributes:
     _response_headers: A dict of response headers.
     _request_headers: A dict of request headers.
     _url: the fetched url
+    _protocol: The protocol used to get the response.
+    _port: The remote port number used to get the response.
     _status: The integer status code of the response
     _request_type: What caused this request (Document, XHR, etc)
     _flags: A Namespace object from ParseFlags()
   """
 
-  def __init__(self, response_headers, request_headers, url, status,
-      request_type):
+  def __init__(self, response_headers, request_headers, url, protocol, port,
+      status, request_type):
     self._response_headers = response_headers
     self._request_headers = request_headers
     self._url = url
+    self._protocol = protocol
+    self._port = port
     self._status = status
     self._request_type = request_type
     self._flags = ParseFlags()
 
   def __str__(self):
     self_dict = {
       'response_headers': self._response_headers,
       'request_headers': self._request_headers,
       'url': self._url,
+      'protocol': self._protocol,
+      'port': self._port,
       'status': self._status,
       'request_type': self._request_type
     }
     return json.dumps(self_dict)
 
   @property
   def response_headers(self):
     return self._response_headers
 
   @property
   def request_headers(self):
     return self._request_headers
 
   @property
   def url(self):
     return self._url
 
   @property
+  def protocol(self):
+    return self._protocol
+
+  @property
+  def port(self):
+    return self._port
+
+  @property
   def status(self):
     return self._status
 
   @property
   def request_type(self):
     return self._request_type
 
   def ResponseHasViaHeader(self):
     return 'via' in self._response_headers and (self._response_headers['via'] ==
       self._flags.via_header_value)
 
   def WasXHR(self):
     return self.request_type == 'XHR'
+
+  def UsedHTTP(self):
+    return self._protocol == 'http/1.1'
+
+  def UsedHTTP2(self):
+    return self._protocol == 'h2'