tools/android/loading: Properly detect page loading failures

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 157 matching lines @@
     from_service_worker: (bool) Whether the request was served by a Service
                          Worker.
     timing: (Timing) Request timing, extended with loading_finished.
     status: (int) Response status code.
     status_text: (str) Response status text received in the status line.
     encoded_data_length: (int) Total encoded data length.
     data_chunks: (list) [(offset, encoded_data_length), ...] List of data
                  chunks received, with their offset in ms relative to
                  Timing.requestTime.
     failed: (bool) Whether the request failed.
+    error_text: (str) User friendly error message when request failed.
     start_msec: (float) Request start time, in milliseconds from chrome start.
     end_msec: (float) Request end time, in milliseconds from chrome start.
       start_msec.
   """
   REQUEST_PRIORITIES = ('VeryLow', 'Low', 'Medium', 'High', 'VeryHigh')
   RESOURCE_TYPES = ('Document', 'Stylesheet', 'Image', 'Media', 'Font',
                     'Script', 'TextTrack', 'XHR', 'Fetch', 'EventSource',
                     'WebSocket', 'Manifest', 'Other')
   INITIATORS = ('parser', 'script', 'other', 'redirect')
   INITIATING_REQUEST = 'initiating_request'
@@ skipping 16 matching lines @@
     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.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
   def end_msec(self):
     if self.start_msec is None:
       return None
     return self.start_msec + self.timing.LargestOffset()
@@ skipping 518 matching lines @@
     r.request_id = '%s%s.%d' % (request_id, self._REDIRECT_SUFFIX,
                                  redirect_index + 1)
     initiator = {
         'type': 'redirect', Request.INITIATING_REQUEST: r.request_id}
     self._requests_in_flight[r.request_id] = (r, RequestTrack._STATUS_FINISHED)
     del self._requests_in_flight[request_id]
     self._FinalizeRequest(r.request_id)
     return initiator
 
   def _RequestServedFromCache(self, request_id, _):
-    assert request_id in self._requests_in_flight
+    if request_id not in self._requests_in_flight:
+      return
     (request, status) = self._requests_in_flight[request_id]
     assert status == RequestTrack._STATUS_SENT
     request.served_from_cache = True
 
   def _ResponseReceived(self, request_id, params):
     assert request_id in self._requests_in_flight
     (r, status) = self._requests_in_flight[request_id]
     if status == RequestTrack._STATUS_RESPONSE:
       # Duplicated messages (apart from the timestamp) are OK.
       old_params = self._request_id_to_response_received[request_id]
@@ skipping 26 matching lines @@
     # 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)
     self._requests_in_flight[request_id] = (r, RequestTrack._STATUS_RESPONSE)
     self._request_id_to_response_received[request_id] = params
 
   def _DataReceived(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)
     offset = r._TimestampOffsetFromStartMs(params['timestamp'])
     r.data_chunks.append((offset, params['encodedDataLength']))
     self._requests_in_flight[request_id] = (r, RequestTrack._STATUS_DATA)
 
   def _LoadingFinished(self, request_id, params):
-    assert request_id in self._requests_in_flight
+    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']
     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, _):
+  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]
     r.failed = True
+    r.error_text = params['errorText']
     self._requests_in_flight[request_id] = (r, RequestTrack._STATUS_FINISHED)
     self._FinalizeRequest(request_id)
 
   def _FinalizeRequest(self, request_id):
-    assert request_id in self._requests_in_flight
+    if request_id not in self._requests_in_flight:
+      return
     (request, status) = self._requests_in_flight[request_id]
     assert status == RequestTrack._STATUS_FINISHED
     del self._requests_in_flight[request_id]
     self._completed_requests_by_id[request_id] = request
     self._requests.append(request)
 
   def __eq__(self, o):
     return self._requests == o._requests
 
 
@@ skipping 13 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)