Clovis: update resource sack to use new dependency graph.

tools/android/loading/graph.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.
 
 """Support for graphs."""
 
 import collections
 
 
 class Node(object):
@@ skipping 25 matching lines @@
 
   A graph is identified by a list of nodes and a list of edges. It does not need
   to be acyclic, but then some methods will fail.
   """
   def __init__(self, nodes, edges):
     """Builds a graph from a set of node and edges.
 
     Note that the edges referencing a node not in the provided list are dropped.
 
     Args:
-      nodes: ([Node]) List of nodes.
-      edges: ([Edge]) List of Edges.
+      nodes: ([Node]) Sequence of Nodes.
+      edges: ([Edge]) Sequence of Edges.
     """
-    assert all(isinstance(node, Node) for node in nodes)
-    assert all(isinstance(edge, Edge) for edge in edges)
     self._nodes = set(nodes)
     self._edges = set(filter(
         lambda e: e.from_node in self._nodes and e.to_node in self._nodes,
         edges))
+    assert all(isinstance(node, Node) for node in self._nodes)
+    assert all(isinstance(edge, Edge) for edge in self._edges)
     self._in_edges = {n: [] for n in self._nodes}
     self._out_edges = {n: [] for n in self._nodes}
     for edge in self._edges:
       self._out_edges[edge.from_node].append(edge)
       self._in_edges[edge.to_node].append(edge)
 
   def OutEdges(self, node):
     """Returns a list of edges starting from a node.
     """
     return self._out_edges[node]
@@ skipping 101 matching lines @@
       node = (i for i in self._nodes if costs[i] == max_cost).next()
       path_list.append(node)
       while self.InEdges(node):
         predecessors = [e.from_node for e in self.InEdges(node)]
         node = reduce(
             lambda costliest_node, next_node:
             next_node if costs[next_node] > costs[costliest_node]
             else costliest_node, predecessors)
         path_list.insert(0, node)
     return max_cost