cc: GPU rasterize tiles synchronously in PrepareToDraw.

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 31 matching lines @@
 #include "cc/output/copy_output_request.h"
 #include "cc/output/delegating_renderer.h"
 #include "cc/output/gl_renderer.h"
 #include "cc/output/software_renderer.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #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"
 #include "cc/resources/picture_layer_tiling.h"
 #include "cc/resources/pixel_buffer_tile_task_worker_pool.h"
 #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"
 #include "cc/resources/zero_copy_tile_task_worker_pool.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/trees/damage_tracker.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/occlusion_tracker.h"
@@ skipping 977 matching lines @@
       DCHECK_GE(frame->render_passes.size(), position_from_end);
     }
   }
 }
 
 DrawResult LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
   TRACE_EVENT1("cc",
                "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();
   frame->will_draw_layers.clear();
   frame->has_no_damage = false;
 
   if (active_tree_->root_layer()) {
     gfx::Rect device_viewport_damage_rect = viewport_damage_rect_;
     viewport_damage_rect_ = gfx::Rect();
 
@@ skipping 773 matching lines @@
 
   // If we just became visible, we have to ensure that we draw high res tiles,
   // to prevent checkerboard/low res flashes.
   if (visible_)
     SetRequiresHighResToDraw();
   else
     EvictAllUIResources();
 
   // 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();
 
   if (!renderer_)
     return;
 
   renderer_->SetVisible(visible);
 }
 
 void LayerTreeHostImpl::SetNeedsAnimate() {
@@ skipping 74 matching lines @@
     pending_tree_->set_needs_update_draw_properties();
   client_->UpdateRendererCapabilitiesOnImplThread();
 }
 
 void LayerTreeHostImpl::CreateAndSetTileManager() {
   DCHECK(!tile_manager_);
   DCHECK(settings_.impl_side_painting);
   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_);
 
   base::SingleThreadTaskRunner* task_runner =
       proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                               : proxy_->MainThreadTaskRunner();
   DCHECK(task_runner);
   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 =
       proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                               : proxy_->MainThreadTaskRunner();
   DCHECK(task_runner);
 
   ContextProvider* context_provider = output_surface_->context_provider();
   if (!context_provider) {
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(),
                              GL_TEXTURE_2D,
                              resource_provider_->best_texture_format());
 
     *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
         task_runner, TileTaskWorkerPool::GetTaskGraphRunner(),
         resource_provider_.get());
+
+    *rasterizer = SoftwareRasterizer::Create();
     return;
   }
 
   if (use_gpu_rasterization_) {
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(),
                              GL_TEXTURE_2D,
                              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(
         image_target == GL_TEXTURE_RECTANGLE_ARB,
         context_provider->ContextCapabilities().gpu.texture_rectangle);
     DCHECK_IMPLIES(
         image_target == GL_TEXTURE_EXTERNAL_OES,
         context_provider->ContextCapabilities().gpu.egl_image_external);
 
     if (settings_.use_zero_copy || IsSynchronousSingleThreaded()) {
@@ skipping 41 matching lines @@
       resource_provider_.get(),
       GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
                                      settings_.renderer_settings.refresh_rate));
 }
 
 void LayerTreeHostImpl::DestroyTileManager() {
   tile_manager_ = nullptr;
   resource_pool_ = nullptr;
   staging_resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
+  rasterizer_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }
 
 bool LayerTreeHostImpl::UsePendingTreeForSync() const {
   // In impl-side painting, synchronize to the pending tree so that it has
   // time to raster before being displayed.
   return settings_.impl_side_painting;
 }
 
 bool LayerTreeHostImpl::IsSynchronousSingleThreaded() const {
@@ skipping 1398 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