cc: Add TaskGraphRunner sub-namespaces with task concurrency limits.

cc/resources/task_graph_runner_perftest.cc

 // Copyright 2014 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.
 
 #include "cc/resources/task_graph_runner.h"
 
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/time/time.h"
@@ skipping 210 matching lines @@
     }
   }
 
   void BuildTaskGraph(const PerfTaskImpl::Vector& top_level_tasks,
                       const PerfTaskImpl::Vector& tasks,
                       const PerfTaskImpl::Vector& leaf_tasks,
                       TaskGraph* graph) {
     DCHECK(graph->nodes.empty());
     DCHECK(graph->edges.empty());
 
+    int sub_namespace = 0;
+    int max_concurrent_tasks = 4;
+
     for (PerfTaskImpl::Vector::const_iterator it = leaf_tasks.begin();
          it != leaf_tasks.end();
          ++it) {
-      graph->nodes.push_back(TaskGraph::Node(it->get(), 0u, 0u));
+      graph->nodes.push_back(TaskGraph::Node(it->get(), 0u, 0u, sub_namespace,
+                                             max_concurrent_tasks));
     }
 
     for (PerfTaskImpl::Vector::const_iterator it = tasks.begin();
          it != tasks.end();
          ++it) {
-      graph->nodes.push_back(TaskGraph::Node(it->get(), 0u, leaf_tasks.size()));
+      graph->nodes.push_back(TaskGraph::Node(it->get(), 0u, leaf_tasks.size(),
+                                             sub_namespace,
+                                             max_concurrent_tasks));
 
       for (PerfTaskImpl::Vector::const_iterator leaf_it = leaf_tasks.begin();
            leaf_it != leaf_tasks.end();
            ++leaf_it) {
         graph->edges.push_back(TaskGraph::Edge(leaf_it->get(), it->get()));
       }
 
       for (PerfTaskImpl::Vector::const_iterator top_level_it =
                top_level_tasks.begin();
            top_level_it != top_level_tasks.end();
            ++top_level_it) {
         graph->edges.push_back(TaskGraph::Edge(it->get(), top_level_it->get()));
       }
     }
 
     for (PerfTaskImpl::Vector::const_iterator it = top_level_tasks.begin();
          it != top_level_tasks.end();
          ++it) {
-      graph->nodes.push_back(TaskGraph::Node(it->get(), 0u, tasks.size()));
+      graph->nodes.push_back(TaskGraph::Node(
+          it->get(), 0u, tasks.size(), sub_namespace, max_concurrent_tasks));
     }
   }
 
   size_t CollectCompletedTasks(Task::Vector* completed_tasks) {
     DCHECK(completed_tasks->empty());
     task_graph_runner_->CollectCompletedTasks(namespace_token_,
                                               completed_tasks);
     return completed_tasks->size();
   }
 
@@ skipping 33 matching lines @@
   RunScheduleAndExecuteTasksTest("0_1_0", 0, 1, 0);
   RunScheduleAndExecuteTasksTest("0_32_0", 0, 32, 0);
   RunScheduleAndExecuteTasksTest("2_1_0", 2, 1, 0);
   RunScheduleAndExecuteTasksTest("2_32_0", 2, 32, 0);
   RunScheduleAndExecuteTasksTest("2_1_1", 2, 1, 1);
   RunScheduleAndExecuteTasksTest("2_32_1", 2, 32, 1);
 }
 
 }  // namespace
 }  // namespace cc