Upgrade analyze.py and related scripts to new world order.

tools/android/loading/loading_model.py

 # Copyright 2015 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.
 
 """Models for loading in chrome.
 
 (Redirect the following to the general model module once we have one)
 A model is an object with the following methods.
   CostMs(): return the cost of the model in milliseconds.
   Set(): set model-specific parameters.
@@ skipping 272 matching lines @@
       for c in children:
         assert n in c.Predecessors()  # Integrity checking
         queue.append(c)
     assert len(visited) == len(self._nodes)
     return '\n'.join(output)
 
   ##
   ## Internal items
   ##
 
-  _CONTENT_TYPE_TO_COLOR = {'html': 'red', 'css': 'green', 'script': 'blue',
-                            'json': 'purple', 'gif_image': 'grey',
-                            'image': 'orange', 'other': 'white'}
+  _CONTENT_KIND_TO_COLOR = {

[blundell, 2016/01/21 14:11:38]

Worth documenting what these mean?

[mattcary, 2016/01/21 16:11:35]

Done.

+      'application':     'blue',
+      'font':            'grey2',
+      'image':           'orange',    # This probably catches gifs?

[Benoit L, 2016/01/21 14:14:38]

it does.

[mattcary, 2016/01/21 16:11:35]

Then this isn't what we want. Well, let me land this so Colin can start using
it. I'm not sure what the priority of tweaking the graph node colors is anyway.

[Benoit L, 2016/01/21 16:20:03]

About as high as deciding on the bike shed color.

+      }
+
+  _CONTENT_TYPE_TO_COLOR = {
+      'html':            'red',
+      'css':             'green',
+      'script':          'blue',
+      'javascript':      'blue',
+      'json':            'purple',
+      'gif':             'grey',
+      'image':           'orange',
+      'jpeg':            'orange',
+      'png':             'orange',
+      'plain':           'brown3',
+      'octet-stream':    'brown3',
+      'other':           'white',
+      }
 
   # This resource type may induce a timing dependency. See _SplitChildrenByTime
   # for details.
   # TODO(mattcary): are these right?
   _CAN_BE_TIMING_PARENT = set(['script', 'magic-debug-content'])
   _CAN_MAKE_TIMING_DEPENDENCE = set(['json', 'other', 'magic-debug-content'])
 
   class _NodeInfo(object):
     """Our internal class that adds cost and other information to nodes.
 
@@ skipping 50 matching lines @@
 
     def ContentType(self):
       return self._request.GetContentType()
 
     def ShortName(self):
       """Returns either the hostname of the resource, or the filename,
       or the end of the path. Tries to include the domain as much as possible.
       """
       parsed = urlparse.urlparse(self._request.url)
       path = parsed.path
+      hostname = parsed.hostname if parsed.hostname else '?.?.?'
       if path != '' and path != '/':
         last_path = parsed.path.split('/')[-1]
         if len(last_path) < 10:
           if len(path) < 10:
-            return parsed.hostname + '/' + path
+            return hostname + '/' + path
           else:
-            return parsed.hostname + '/..' + parsed.path[-10:]
+            return hostname + '/..' + parsed.path[-10:]
         elif len(last_path) > 10:
-          return parsed.hostname + '/..' + last_path[:5]
+          return hostname + '/..' + last_path[:5]
         else:
-          return parsed.hostname + '/..' + last_path
+          return hostname + '/..' + last_path
       else:
-        return parsed.hostname
+        return hostname
 
     def Url(self):
       return self._request.url
 
     def SetEdgeCost(self, child, cost):
       assert child.Node() in self._node.Successors()
       self._edge_costs[child] = cost
 
     def AddEdgeAnnotation(self, s, annotation):
       assert s.Node() in self._node.Successors()
@@ skipping 67 matching lines @@
       next_index = len(self._nodes)
       assert request not in index_by_request
       index_by_request[request] = next_index
       node = dag.Node(next_index)
       node_info = self._NodeInfo(node, request)
       self._nodes.append(node)
       self._node_info.append(node_info)
 
     dependencies = request_dependencies_lens.RequestDependencyLens(
         trace).GetRequestDependencies()
-    for child_rq, parent_rq, reason in dependencies:
+    for parent_rq, child_rq, reason in dependencies:
       parent = self._node_info[index_by_request[parent_rq]]
       child = self._node_info[index_by_request[child_rq]]
       edge_cost = child.StartTime() - parent.EndTime()
       if edge_cost < 0:
         edge_cost = 0
         if child.StartTime() < parent.StartTime():
           logging.error('Inverted dependency: %s->%s',
                         parent.ShortName(), child.ShortName())
           # Note that child.StartTime() < parent.EndTime() appears to happen a
           # fair amount in practice.
@@ skipping 65 matching lines @@
           break
       if end_mark >= len(children_by_end_time):
         break  # It's not possible to rearrange any more children.
       if go_to_next_child:
         continue  # We can't rearrange this child, but the next child may be
                   # eligible.
       if children_by_end_time[end_mark].EndTime() <= current.StartTime():
         current.ReparentTo(parent, children_by_end_time[end_mark])
         children_by_end_time[end_mark].AddEdgeAnnotation(current, 'timing')
 
+  def _ContentTypeToColor(self, content_type):
+    if not content_type:
+      type_str = 'other'
+    elif '/' in content_type:
+      kind, type_str = content_type.split('/')
+      if kind in self._CONTENT_KIND_TO_COLOR:

[blundell, 2016/01/21 14:11:38]

hmm, also probably worth documenting the relationship between content_kind and
content_type given how this function works.

[mattcary, 2016/01/21 16:11:35]

I don't really know how these mime-types work. I think content_kind is a general
classification (image, font, application) and type is something very specific,
but I'm not really sure. 

+        return self._CONTENT_KIND_TO_COLOR[kind]
+    else:
+      type_str = content_type
+    return self._CONTENT_TYPE_TO_COLOR[type_str]
+
   def _GraphvizNode(self, index, highlight):
     """Returns a graphviz node description for a given node.
 
     Args:
       index: index of the node.
       highlight: a list of node items to emphasize. Any resource url which
         contains any highlight text will be distinguished in the output.
 
     Returns:
       A string describing the resource in graphviz format.
       The resource is color-coded according to its content type, and its shape
       is oval if its max-age is less than 300s (or if it's not cacheable).
     """
     node_info = self._node_info[index]
-    color = self._CONTENT_TYPE_TO_COLOR[node_info.ContentType()]
+    color = self._ContentTypeToColor(node_info.ContentType())
     max_age = node_info.Request().MaxAge()
     shape = 'polygon' if max_age > 300 else 'oval'
     styles = ['filled']
     if highlight:
       for fragment in highlight:
         if fragment in node_info.Url():
           styles.append('dotted')
           break
     return ('%d [label = "%s\\n%.2f->%.2f (%.2f)"; style = "%s"; '
             'fillcolor = %s; shape = %s];\n'
@@ skipping 89 matching lines @@
       Dict of image url + short name to NodeInfo.
     """
     image_to_info = {}
     for n in self._node_info:
       if (n.ContentType().startswith('image') and
           not self._IsAdUrl(n.Url())):
         key = str((n.Url(), n.ShortName(), n.StartTime()))
         assert key not in image_to_info, n.Url()
         image_to_info[key] = n
     return image_to_info