Re-land: cc: Use worker context for one-copy tile initialization.

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 <map>
 #include <set>
@@ skipping 135 matching lines @@
   // that time interval, and then uploads should have a chance to be processed.
   size_t ms_per_frame = std::floor(1000.0 / refresh_rate);
   size_t max_transfer_buffer_usage_bytes =
       ms_per_frame * kMaxBytesUploadedPerMs;
 
   // The context may request a lower limit based on the device capabilities.
   return std::min(context_capabilities.max_transfer_buffer_usage_bytes,
                   max_transfer_buffer_usage_bytes);
 }
 
-size_t GetMaxStagingResourceCount() {
-  // Upper bound for number of staging resource to allow.
-  return 32;
-}
-
 size_t GetDefaultMemoryAllocationLimit() {
   // TODO(ccameron): (http://crbug.com/137094) This 64MB default is a straggler
   // from the old texture manager and is just to give us a default memory
   // allocation before we get a callback from the GPU memory manager. We
   // should probaby either:
   // - wait for the callback before rendering anything instead
   // - push this into the GPU memory manager somehow.
   return 64 * 1024 * 1024;
 }
 
@@ skipping 1057 matching lines @@
   // TODO(reveman): We should avoid keeping around unused resources if
   // possible. crbug.com/224475
   // Unused limit is calculated from soft-limit, as hard-limit may
   // be very high and shouldn't typically be exceeded.
   size_t unused_memory_limit_in_bytes = static_cast<size_t>(
       (static_cast<int64>(global_tile_state_.soft_memory_limit_in_bytes) *
        settings_.max_unused_resource_memory_percentage) /
       100);
 
   DCHECK(resource_pool_);
-  resource_pool_->CheckBusyResources(false);
+  resource_pool_->CheckBusyResources();
   // Soft limit is used for resource pool such that memory returns to soft
   // limit after going over.
   resource_pool_->SetResourceUsageLimits(
       global_tile_state_.soft_memory_limit_in_bytes,
       unused_memory_limit_in_bytes,
       global_tile_state_.num_resources_limit);
 
-  // Release all staging resources when invisible.
-  if (staging_resource_pool_) {
-    staging_resource_pool_->CheckBusyResources(false);
-    staging_resource_pool_->SetResourceUsageLimits(
-        std::numeric_limits<size_t>::max(),
-        std::numeric_limits<size_t>::max(),
-        visible_ ? GetMaxStagingResourceCount() : 0);
-  }
-
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   // Mark priorities as dirty and schedule a PrepareTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsPrepareTilesOnImplThread();
 }
 
 scoped_ptr<RasterTilePriorityQueue> LayerTreeHostImpl::BuildRasterQueue(
@@ skipping 193 matching lines @@
 
 void LayerTreeHostImpl::ReclaimResources(const CompositorFrameAck* ack) {
   // TODO(piman): We may need to do some validation on this ack before
   // processing it.
   if (renderer_)
     renderer_->ReceiveSwapBuffersAck(*ack);
 
   // In OOM, we now might be able to release more resources that were held
   // because they were exported.
   if (resource_pool_) {
-    resource_pool_->CheckBusyResources(false);
+    resource_pool_->CheckBusyResources();
     resource_pool_->ReduceResourceUsage();
   }
   // If we're not visible, we likely released resources, so we want to
   // aggressively flush here to make sure those DeleteTextures make it to the
   // GPU process to free up the memory.
   if (output_surface_->context_provider() && !visible_) {
     output_surface_->context_provider()->ContextGL()->ShallowFlushCHROMIUM();
   }
 }
 
@@ skipping 590 matching lines @@
   // See note in LayerTreeImpl::UpdateDrawProperties.  Renderer needs to be
   // initialized to get max texture size.  Also, after releasing resources,
   // trees need another update to generate new ones.
   active_tree_->set_needs_update_draw_properties();
   if (pending_tree_)
     pending_tree_->set_needs_update_draw_properties();
   client_->UpdateRendererCapabilitiesOnImplThread();
 }
 
 void LayerTreeHostImpl::CreateTileManagerResources() {
-  CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &resource_pool_,
-                                      &staging_resource_pool_);
+  CreateResourceAndTileTaskWorkerPool(&tile_task_worker_pool_, &resource_pool_);
   // TODO(vmpstr): Initialize tile task limit at ctor time.
   tile_manager_->SetResources(
       resource_pool_.get(), tile_task_worker_pool_->AsTileTaskRunner(),
       is_synchronous_single_threaded_ ? std::numeric_limits<size_t>::max()
                                       : settings_.scheduled_raster_task_limit);
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
 }
 
 void LayerTreeHostImpl::CreateResourceAndTileTaskWorkerPool(
     scoped_ptr<TileTaskWorkerPool>* tile_task_worker_pool,
-    scoped_ptr<ResourcePool>* resource_pool,
-    scoped_ptr<ResourcePool>* staging_resource_pool) {
+    scoped_ptr<ResourcePool>* resource_pool) {
   DCHECK(GetTaskRunner());
   // TODO(vmpstr): Make this a DCHECK (or remove) when crbug.com/419086 is
   // resolved.
   CHECK(resource_provider_);
 
   // Pass the single-threaded synchronous task graph runner to the worker pool
   // if we're in synchronous single-threaded mode.
   TaskGraphRunner* task_graph_runner = task_graph_runner_;
   if (is_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();
   }
 
   ContextProvider* context_provider = output_surface_->context_provider();
   if (!context_provider) {
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
 
     *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, resource_provider_.get());
     return;
   }
 
   if (use_gpu_rasterization_) {
+    DCHECK(resource_provider_->output_surface()->worker_context_provider());
+
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
 
     int msaa_sample_count = use_msaa_ ? RequestedMSAASampleCount() : 0;
 
     *tile_task_worker_pool = GpuTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, context_provider,
         resource_provider_.get(), settings_.use_distance_field_text,
         msaa_sample_count);
     return;
   }
 
   DCHECK(GetRendererCapabilities().using_image);
 
-  if (settings_.use_zero_copy) {
+  bool use_zero_copy = settings_.use_zero_copy;
+  // TODO(reveman): Remove this when mojo supports worker contexts.
+  // crbug.com/522440

[reveman, 2015/08/19 15:50:13]

This temporary solution allows us to land this without having to implement
proper worker context support in mojo.

+  if (!resource_provider_->output_surface()->worker_context_provider()) {
+    LOG(ERROR)
+        << "Forcing zero-copy tile initialization as worker context is missing";
+    use_zero_copy = true;
+  }
+
+  if (use_zero_copy) {
     *resource_pool = ResourcePool::Create(resource_provider_.get());
 
     *tile_task_worker_pool = ZeroCopyTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, resource_provider_.get());
     return;
   }
 
   if (settings_.use_one_copy) {
-    // Synchronous single-threaded mode depends on tiles being ready to
-    // draw when raster is complete.  Therefore, it must use one of zero
-    // copy, software raster, or GPU raster.
-    DCHECK(!is_synchronous_single_threaded_);
-
-    // We need to create a staging resource pool when using copy rasterizer.
-    *staging_resource_pool = ResourcePool::Create(resource_provider_.get());
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
 
     int max_copy_texture_chromium_size =
         context_provider->ContextCapabilities()
             .gpu.max_copy_texture_chromium_size;
 
     *tile_task_worker_pool = OneCopyTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, context_provider,
-        resource_provider_.get(), staging_resource_pool_.get(),
-        max_copy_texture_chromium_size,
-        settings_.use_persistent_map_for_gpu_memory_buffers);
+        resource_provider_.get(), max_copy_texture_chromium_size,
+        settings_.use_persistent_map_for_gpu_memory_buffers,
+        settings_.max_staging_buffers);
     return;
   }
 
   // Synchronous single-threaded mode depends on tiles being ready to
   // draw when raster is complete.  Therefore, it must use one of zero
   // copy, software raster, or GPU raster (in the branches above).
   DCHECK(!is_synchronous_single_threaded_);
 
   *resource_pool = ResourcePool::Create(
       resource_provider_.get(), GL_TEXTURE_2D);
@@ skipping 22 matching lines @@
 void LayerTreeHostImpl::PostFrameTimingEvents(
     scoped_ptr<FrameTimingTracker::CompositeTimingSet> composite_events,
     scoped_ptr<FrameTimingTracker::MainFrameTimingSet> main_frame_events) {
   client_->PostFrameTimingEventsOnImplThread(composite_events.Pass(),
                                              main_frame_events.Pass());
 }
 
 void LayerTreeHostImpl::CleanUpTileManager() {
   tile_manager_->FinishTasksAndCleanUp();
   resource_pool_ = nullptr;
-  staging_resource_pool_ = nullptr;
   tile_task_worker_pool_ = nullptr;
   single_thread_synchronous_task_graph_runner_ = nullptr;
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
     scoped_ptr<OutputSurface> output_surface) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::InitializeRenderer");
 
   // Since we will create a new resource provider, we cannot continue to use
   // the old resources (i.e. render_surfaces and texture IDs). Clear them
@@ skipping 13 matching lines @@
     return false;
   }
 
   output_surface_ = output_surface.Pass();
   resource_provider_ = ResourceProvider::Create(
       output_surface_.get(), shared_bitmap_manager_, gpu_memory_buffer_manager_,
       proxy_->blocking_main_thread_task_runner(),
       settings_.renderer_settings.highp_threshold_min,
       settings_.renderer_settings.use_rgba_4444_textures,
       settings_.renderer_settings.texture_id_allocation_chunk_size,
-      settings_.use_persistent_map_for_gpu_memory_buffers,
       settings_.use_image_texture_targets);
 
   CreateAndSetRenderer();
 
   // Since the new renderer may be capable of MSAA, update status here.
   UpdateGpuRasterizationStatus();
 
   CreateTileManagerResources();
   RecreateTreeResources();
 
@@ skipping 1397 matching lines @@
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc