sandwich: Handle 200 responses with no data.

tools/android/loading/request_track.py

 # Copyright (c) 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.
 
 """The request data track.
 
 When executed, parses a JSON dump of DevTools messages.
 """
 
 import bisect
@@ skipping 191 matching lines @@
     self.timestamp = -1
     self.wall_time = -1
     self.initiator = None
     self.resource_type = None
     self.served_from_cache = False
     self.from_disk_cache = False
     self.from_service_worker = False
     self.timing = None
     self.status = None
     self.status_text = None
+    self.response_headers_length = 0
     self.encoded_data_length = 0
     self.data_chunks = []
     self.failed = False
     self.error_text = None
 
   @property
   def start_msec(self):
     return self.timing.request_time * 1000
 
   @property
@@ skipping 24 matching lines @@
     for (k, v) in data_dict.items():
       setattr(result, k, v)
     if not result.response_headers:
       result.response_headers = {}
     if result.timing:
       result.timing = Timing.FromJsonDict(result.timing)
     else:
       result.timing = Timing(request_time=result.timestamp)
     return result
 
-  def GetEncodedDataLength(self):
+  def GetResponseTransportLength(self):
     """Get the total amount of encoded data no matter whether load has finished
     or not.
     """
     assert self.HasReceivedResponse()
     assert not self.from_disk_cache and not self.served_from_cache
-    assert self.protocol != 'about'
-    if self.failed:
-      # TODO(gabadie): Once crbug.com/622018 is fixed, remove this branch.
-      return 0
+    assert self.protocol not in {'about', 'blob', 'data'}
     if self.timing.loading_finished != Timing.UNVAILABLE:
       encoded_data_length = self.encoded_data_length
-      assert encoded_data_length > 0
     else:
       encoded_data_length = sum(
           [chunk_size for _, chunk_size in self.data_chunks])
       assert encoded_data_length > 0 or len(self.data_chunks) == 0
-    return encoded_data_length
+    return encoded_data_length + self.response_headers_length
 
   def GetHTTPResponseHeader(self, header_name):
     """Gets the value of a HTTP response header.
 
     Does a case-insensitive search for the header name in the HTTP response
     headers, in order to support servers that use a wrong capitalization.
     """
     lower_case_name = header_name.lower()
     result = None
     for name, value in self.response_headers.iteritems():
@@ skipping 445 matching lines @@
   def _HandleRedirect(self, request_id, params):
     (r, status) = self._requests_in_flight[request_id]
     assert status == RequestTrack._STATUS_SENT
     # The second request contains timing information pertaining to the first
     # one. Finalize the first request.
     assert 'redirectResponse' in params
     redirect_response = params['redirectResponse']
 
     _CopyFromDictToObject(redirect_response, r,
                           (('headers', 'response_headers'),
-                           ('encodedDataLength', 'encoded_data_length'),
+                           ('encodedDataLength', 'response_headers_length'),
                            ('fromDiskCache', 'from_disk_cache'),
                            ('protocol', 'protocol'), ('status', 'status'),
                            ('statusText', 'status_text')))
     r.timing = Timing.FromDevToolsDict(redirect_response['timing'])
 
     redirect_index = self._redirects_count_by_id[request_id]
     self._redirects_count_by_id[request_id] += 1
     r.request_id = '%s%s.%d' % (request_id, self._REDIRECT_SUFFIX,
                                  redirect_index + 1)
     initiator = {
@@ skipping 35 matching lines @@
       assert r.resource_type == params.get('type', 'Other')
     response = params['response']
     _CopyFromDictToObject(
         response, r, (('status', 'status'), ('mimeType', 'mime_type'),
                       ('fromDiskCache', 'from_disk_cache'),
                       ('fromServiceWorker', 'from_service_worker'),
                       ('protocol', 'protocol'), ('statusText', 'status_text'),
                       # Actual request headers are not known before reaching the
                       # network stack.
                       ('requestHeaders', 'request_headers'),
+                      ('encodedDataLength', 'response_headers_length'),
                       ('headers', 'response_headers')))
     timing_dict = {}
     # Some URLs don't have a timing dict (e.g. data URLs), and timings for
     # cached requests are stale.
     # TODO(droger): the timestamp is inacurate, get the real timings instead.
     if not response.get('timing') or r.served_from_cache:
       timing_dict = {'requestTime': r.timestamp}
     else:
       timing_dict = response['timing']
     r.timing = Timing.FromDevToolsDict(timing_dict)
@@ skipping 10 matching lines @@
     r.data_chunks.append((offset, params['encodedDataLength']))
     self._requests_in_flight[request_id] = (r, RequestTrack._STATUS_DATA)
 
   def _LoadingFinished(self, request_id, params):
     if request_id not in self._requests_in_flight:
       return
     (r, status) = self._requests_in_flight[request_id]
     assert (status == RequestTrack._STATUS_RESPONSE
             or status == RequestTrack._STATUS_DATA)
     r.encoded_data_length = params['encodedDataLength']
-    assert (r.encoded_data_length > 0 or r.protocol in {'about', 'data'} or
-            r.from_disk_cache or r.served_from_cache)
     r.timing.loading_finished = r._TimestampOffsetFromStartMs(
         params['timestamp'])
     self._requests_in_flight[request_id] = (r, RequestTrack._STATUS_FINISHED)
     self._FinalizeRequest(request_id)
 
   def _LoadingFailed(self, request_id, params):
     if request_id not in self._requests_in_flight:
       logging.warning('An unknown request failed: %s' % request_id)
       return
     (r, _) = self._requests_in_flight[request_id]
@@ skipping 29 matching lines @@
 
 
 if __name__ == '__main__':
   import json
   import sys
   events = json.load(open(sys.argv[1], 'r'))
   request_track = RequestTrack(None)
   for event in events:
     event_method = event['method']
     request_track.Handle(event_method, event)