cc: Support on demand raster with ganesh

cc/trees/layer_tree_host_impl.cc

 // Copyright 2011 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/trees/layer_tree_host_impl.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/basictypes.h"
@@ skipping 2743 matching lines @@
   scroll_info->page_scale_delta = active_tree_->page_scale_delta();
   active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
 
   return scroll_info.Pass();
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
   SetViewportDamage(gfx::Rect(DrawViewportSize()));
 }
 
+void LayerTreeHostImpl::RunOnDemandRasterTask(Task* on_demand_raster_task) {
+  scoped_ptr<TaskGraphRunner> temp_task_graph_runner_holder;
+  TaskGraphRunner* task_graph_runner = NULL;
+  NamespaceToken on_demand_task_namespace;
+
+  // Use the TaskGraphRunner on correct thread and get unique namespace token.
+  if (use_gpu_rasterization_) {

[reveman, 2014/06/20 00:38:41]

Can you remove these use_gpu_rasterization_ checks from here and handle that in
CreateAndSetTileManager instead where you're already checking that variable?
What to do here depends more on what the code in that function does than
use_gpu_rasterization_. That way you can also avoid creating a new task graph
runner for each on-demand task..

[boliu, 2014/06/20 01:27:06]

Another question. If we do this, do we have to worry about on-demand raster when
impl-side painting is off? I think the SoftwareRenderer path is not specific to
impl-side painting?

[reveman, 2014/06/20 01:29:21]

I don't think we can generate picture-draw-quads without impl-side painting
turned on.

+    temp_task_graph_runner_holder.reset(new TaskGraphRunner);
+    task_graph_runner = temp_task_graph_runner_holder.get();
+    on_demand_task_namespace = task_graph_runner->GetNamespaceToken();
+  } else {
+    task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
+    if (!on_demand_task_namespace_.IsValid())
+      on_demand_task_namespace_ = task_graph_runner->GetNamespaceToken();
+    on_demand_task_namespace = on_demand_task_namespace_;
+  }
+  DCHECK(task_graph_runner);
+
+  // Construct a task graph that contains this single raster task.
+  TaskGraph graph;
+  graph.nodes.push_back(
+      TaskGraph::Node(on_demand_raster_task,
+                      RasterWorkerPool::kOnDemandRasterTaskPriority,
+                      0u));
+
+  // Schedule task and wait for task graph runner to finish running it.
+  task_graph_runner->ScheduleTasks(on_demand_task_namespace, &graph);
+
+  if (use_gpu_rasterization_) {

[boliu, 2014/06/20 01:28:16]

Also this branch can't move to CreateAndSetTileManager.

[reveman, 2014/06/20 01:32:38]

Could it instead be something like the following?

"if (on_demand_task_graph_runner_ == synchronous_task_graph_runner_.get())"

which would depend on what you do in CreateAndSetTileManager.

+    task_graph_runner->RunUntilIdle();
+  } else {
+    task_graph_runner->WaitForTasksToFinishRunning(on_demand_task_namespace);
+  }
+
+  // Collect task now that it has finished running.
+  Task::Vector completed_tasks;
+  task_graph_runner->CollectCompletedTasks(on_demand_task_namespace,
+                                           &completed_tasks);
+  DCHECK_EQ(1u, completed_tasks.size());
+  DCHECK_EQ(completed_tasks[0], on_demand_raster_task);
+}
+
 void LayerTreeHostImpl::ScrollViewportBy(gfx::Vector2dF scroll_delta) {
   DCHECK(InnerViewportScrollLayer());
   LayerImpl* scroll_layer = OuterViewportScrollLayer()
                                 ? OuterViewportScrollLayer()
                                 : InnerViewportScrollLayer();
 
   gfx::Vector2dF unused_delta = scroll_layer->ScrollBy(scroll_delta);
 
   if (!unused_delta.IsZero() && (scroll_layer == OuterViewportScrollLayer()))
     InnerViewportScrollLayer()->ScrollBy(unused_delta);
@@ skipping 334 matching lines @@
 }
 
 void LayerTreeHostImpl::UnregisterPictureLayerImpl(PictureLayerImpl* layer) {
   std::vector<PictureLayerImpl*>::iterator it =
       std::find(picture_layers_.begin(), picture_layers_.end(), layer);
   DCHECK(it != picture_layers_.end());
   picture_layers_.erase(it);
 }
 
 }  // namespace cc