Support single-threaded impl-side painting

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 1724 matching lines @@
 
 void LayerTreeHostImpl::SetTopControlsLayoutHeight(float height) {
   if (active_tree_->top_controls_layout_height() == height)
     return;
 
   active_tree_->set_top_controls_layout_height(height);
   UpdateViewportContainerSizes();
   SetFullRootLayerDamage();
 }
 
+void LayerTreeHostImpl::SynchronouslyInitializeAllTiles() {
+  // Only valid for the single-threaded non-scheduled/synchronous case
+  // using the zero copy raster worker pool.
+  DCHECK(!proxy_->HasImplThread());
+  DCHECK(!settings_.single_thread_proxy_scheduler);

[reveman, 2014/10/28 03:46:33]

nit: can we DCHECK to make sure that settings.scheduled_raster_task_limit and
settings.use_zero_copy are set correctly too as this won't do what the name
indicate that it does otherwise?

[enne (OOO), 2014/10/28 16:49:56]

We only need the zero copy DCHECK if I follow your other nits.

The reason single_thread_synchronous_task_graph_runner_ is a scoped ptr is so
that it's only valid when it's actually being used.  If I make it a member
variable instead of a scoped_ptr, I can add a bool variable that says if it's
valid or not, but to me that seems easier to screw up.

[reveman, 2014/10/28 18:08:24]

hm, this will only initialize some tiles if settings.scheduled_raster_task_limit
is not high enough afaict. I guess we can change the name to
SynchronouslyInitializeAllTilesWithScheduledRasterTasks() or something like that
to make the behavior less strict.
Do we really need more state to track if it's valid to use this than what we
already have? If we're going to use a scoped_ptr as a mechanism to tell if it's
valid to use this then shouldn't the DCHECKs above be replaced by
DCHECK(single_thread_synchronous_task_graph_runner_)?

scoped_ptr DCHECK or existing DCHECKs + zero-copy and task-limit DCHECKs to
validate correct behavior are both solutions I'm fine with. I you think it's
necessary to add a bool when removing the scoped_ptr then I'd rather you keep
the scoped_ptr.

+  single_thread_synchronous_task_graph_runner_->RunUntilIdle();
+}
+
 void LayerTreeHostImpl::DidLoseOutputSurface() {
   if (resource_provider_)
     resource_provider_->DidLoseOutputSurface();
   client_->DidLoseOutputSurfaceOnImplThread();
 }
 
 bool LayerTreeHostImpl::HaveRootScrollLayer() const {
   return !!InnerViewportScrollLayer();
 }
 
@@ skipping 257 matching lines @@
   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());
 
     raster_worker_pool_ =
-        BitmapRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
+        BitmapRasterWorkerPool::Create(task_runner,
                                        RasterWorkerPool::GetTaskGraphRunner(),
                                        resource_provider_.get());
   } else if (use_gpu_rasterization_) {
     resource_pool_ =
         ResourcePool::Create(resource_provider_.get(),
                              GL_TEXTURE_2D,
                              resource_provider_->best_texture_format());
 
     raster_worker_pool_ =
         GpuRasterWorkerPool::Create(task_runner,
                                     context_provider,
                                     resource_provider_.get(),
                                     settings_.use_distance_field_text);
   } else if (UseZeroCopyRasterizer()) {
     resource_pool_ = ResourcePool::Create(
         resource_provider_.get(),
         GetMapImageTextureTarget(context_provider->ContextCapabilities()),
         resource_provider_->best_texture_format());
 
-    raster_worker_pool_ =
-        ZeroCopyRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
-                                         RasterWorkerPool::GetTaskGraphRunner(),
-                                         resource_provider_.get());
+    bool synchronous_single_threaded =
+        !proxy_->HasImplThread() && !settings_.single_thread_proxy_scheduler;
+
+    TaskGraphRunner* task_graph_runner;
+    if (synchronous_single_threaded) {
+      DCHECK(!single_thread_synchronous_task_graph_runner_);
+      single_thread_synchronous_task_graph_runner_.reset(new TaskGraphRunner);
+      task_graph_runner = single_thread_synchronous_task_graph_runner_.get();
+    } else {
+      task_graph_runner = RasterWorkerPool::GetTaskGraphRunner();
+    }

[reveman, 2014/10/28 03:46:33]

I think you can replace all this with:

synchronous_single_threaded
    ? &single_thread_synchronous_task_graph_runner_
    : RasterWorkerPool::GetTaskGraphRunner()

below if you just avoid using "new" to allocate
single_thread_synchronous_task_graph_runner_.

+
+    raster_worker_pool_ = ZeroCopyRasterWorkerPool::Create(
+        task_runner, task_graph_runner, resource_provider_.get());
   } else if (UseOneCopyRasterizer()) {
     // We need to create a staging resource pool when using copy rasterizer.
     staging_resource_pool_ = ResourcePool::Create(
         resource_provider_.get(),
         GetMapImageTextureTarget(context_provider->ContextCapabilities()),
         resource_provider_->best_texture_format());
     resource_pool_ =
         ResourcePool::Create(resource_provider_.get(),
                              GL_TEXTURE_2D,
                              resource_provider_->best_texture_format());
@@ skipping 28 matching lines @@
 
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::DestroyTileManager() {
   tile_manager_ = nullptr;
   resource_pool_ = nullptr;
   staging_resource_pool_ = nullptr;
   raster_worker_pool_ = 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::UseZeroCopyRasterizer() const {
   return settings_.use_zero_copy && GetRendererCapabilities().using_image;
@@ skipping 1374 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