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 '

[RyanSturm, 2016/12/13 21:30:11]

These are awesome. Can you make the buffer one default, and change the flag to
disable it instead?

--disable_buffer maybe

[Robert Ogden, 2016/12/13 21:51:26]

Done.

+    '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('-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):
   """Writes the exception being handled and a stack trace to stderr.
 
   Args:
     test_name: The string name of the test that led to this exception.
   """
   sys.stderr.write("**************************************\n")
@@ skipping 235 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.

[RyanSturm, 2016/12/13 21:30:11]

nit: s/exactly once/at most once/

nit, maybe: You should enforce that it is only called at most once per page load
or remove the comment.
Does this break if you call it more than once per page load or is just 
ineffecient?

[Robert Ogden, 2016/12/13 21:51:26]

Clarified

 
     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'