cc: GPU rasterize tiles synchronously in PrepareToDraw.

cc/trees/layer_tree_host_impl.cc

Index: cc/trees/layer_tree_host_impl.cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index abec01ea496df05eecf176593b53c3a7772ff7ff..0cf44b391b262610b5f335a065960753deadc4cf 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -49,6 +49,7 @@
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/resources/bitmap_tile_task_worker_pool.h"
 #include "cc/resources/eviction_tile_priority_queue.h"
+#include "cc/resources/gpu_rasterizer.h"
 #include "cc/resources/gpu_tile_task_worker_pool.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/one_copy_tile_task_worker_pool.h"
@@ -57,6 +58,7 @@
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/raster_tile_priority_queue.h"
 #include "cc/resources/resource_pool.h"
+#include "cc/resources/software_rasterizer.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "cc/resources/tile_task_worker_pool.h"
 #include "cc/resources/ui_resource_bitmap.h"
@@ -1054,18 +1056,18 @@ DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
                "LayerTreeHostImpl::PrepareToDraw",
                "SourceFrameNumber",
                active_tree_->source_frame_number());
-  // This will cause NotifyTileStateChanged() to be called for any visible tiles
-  // that completed, which will add damage to the frame for them so they appear
-  // as part of the current frame being drawn.
-  if (settings().impl_side_painting)
-    tile_manager_->UpdateVisibleTiles();
-
   UMA_HISTOGRAM_CUSTOM_COUNTS(
       "Compositing.NumActiveLayers", active_tree_->NumLayers(), 1, 400, 20);
 
   bool ok = active_tree_->UpdateDrawProperties();
   DCHECK(ok) << "UpdateDrawProperties failed during draw";
 
+  // This will cause NotifyTileStateChanged() to be called for any visible tiles
+  // that completed, which will add damage to the frame for them so they appear
+  // as part of the current frame being drawn.
+  if (settings().impl_side_painting)
+    tile_manager_->UpdateVisibleTiles(global_tile_state_);
+
   frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
   frame->render_passes.clear();
   frame->render_passes_by_id.clear();
@@ -1859,6 +1861,7 @@ void LayerTreeHostImpl::SetVisible(bool visible) {
 
   // Evict tiles immediately if invisible since this tab may never get another
   // draw or timer tick.
+  // TODO(vmiura): Make sure we do evict tiles in all modes.
   if (!visible_)
     PrepareTiles();
 
@@ -1953,8 +1956,8 @@ void LayerTreeHostImpl::CreateAndSetTileManager() {
   DCHECK(output_surface_);
   DCHECK(resource_provider_);
 
-  CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &resource_pool_,
-                                      &staging_resource_pool_);
+  CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &rasterizer_,

[vmpstr, 2014/12/23 09:54:42]

..AndRasterizer? :) Can TileManager own the rasterizer instead?

[hendrikw, 2014/12/23 18:10:33]

Do you want TileManager to take a enum (GPU or software), and have it create the
rasterizer?

[vmiura, 2014/12/23 18:33:13]

TileManager doesn't have access to context_provider, resource_provider,
use_dff...

  *rasterizer =
         GpuRasterizer::Create(context_provider, resource_provider_.get(),
                                           settings_.use_distance_field_text,
false);

[hendrikw, 2014/12/23 18:54:29]

oh fun.

[vmiura, 2014/12/23 19:08:25]

Flowing rasterizer specific settings through TileManager doesn't sound right. 
If anything, it seems to me that either Rasterizer should own TileManager, or
they should both remain peers on LTHI.

[vmpstr, 2014/12/23 20:00:01]

I meant to say we can create it here, but why store it on LTHI? Can we just pass
the ownership to tile manager? It doesn't really matter, I guess, since we do a
similar thing with tile task worker pool, but in either case
CreateResourceAndTileTaskWorkerPool dosen't seem like the right name anymore.
Maybe we can split this up into more functions or rename it to something more
appropriate. 

+                                      &resource_pool_, &staging_resource_pool_);
   DCHECK(tile_task_worker_pool_);
   DCHECK(resource_pool_);
 
@@ -1965,15 +1968,17 @@ void LayerTreeHostImpl::CreateAndSetTileManager() {
   size_t scheduled_raster_task_limit =
       IsSynchronousSingleThreaded() ? std::numeric_limits<size_t>::max()
                                     : settings_.scheduled_raster_task_limit;
-  tile_manager_ = TileManager::Create(
-      this, task_runner, resource_pool_.get(),
-      tile_task_worker_pool_->AsTileTaskRunner(), scheduled_raster_task_limit);
+  tile_manager_ =
+      TileManager::Create(this, task_runner, resource_pool_.get(),
+                          tile_task_worker_pool_->AsTileTaskRunner(),
+                          rasterizer_.get(), scheduled_raster_task_limit);
 
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
 }
 
 void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
+    scoped_ptr<Rasterizer>* rasterizer,
     scoped_ptr<ResourcePool>* resource_pool,
     scoped_ptr<ResourcePool>* staging_resource_pool) {
   base::SingleThreadTaskRunner* task_runner =
@@ -1991,6 +1996,8 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
         task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
         resource_provider_.get());
+
+    *rasterizer = SoftwareRasterizer::Create();
     return;
   }
 
@@ -2001,11 +2008,17 @@ void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
                              resource_provider_->best_texture_format());
 
     *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
-        task_runner, context_provider, resource_provider_.get(),
-        settings_.use_distance_field_text);
+        task_runner, TileTaskWorkerPool::GetTaskGraphRunner());
+
+    *rasterizer =
+        GpuRasterizer::Create(context_provider, resource_provider_.get(),
+                              settings_.use_distance_field_text, false);
+
     return;
   }
 
+  *rasterizer = SoftwareRasterizer::Create();
+
   if (GetRendererCapabilities().using_image) {
     unsigned image_target = settings_.use_image_texture_target;
     DCHECK_IMPLIES(
@@ -2067,6 +2080,7 @@ void LayerTreeHostImpl::DestroyTileManager() {
   resource_pool_ = nullptr;
   staging_resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
+  rasterizer_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }