cc: Add initial GPU-to-GPU copy rasterizer implementation.

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 26 matching lines @@
 #include "cc/output/compositor_frame_metadata.h"
 #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/direct_raster_worker_pool.h"
+#include "cc/resources/image_copy_raster_worker_pool.h"
 #include "cc/resources/image_raster_worker_pool.h"
 #include "cc/resources/memory_history.h"
 #include "cc/resources/picture_layer_tiling.h"
 #include "cc/resources/pixel_buffer_raster_worker_pool.h"
 #include "cc/resources/prioritized_resource_manager.h"
 #include "cc/resources/raster_worker_pool.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/texture_mailbox_deleter.h"
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/scheduler/delay_based_time_source.h"
@@ skipping 198 matching lines @@
       overdraw_bottom_height_(0.f),
       device_viewport_valid_for_tile_management_(true),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation),
       micro_benchmark_controller_(this),
       need_to_update_visible_tiles_before_draw_(false),
 #if DCHECK_IS_ON
       did_lose_called_(false),
 #endif
       shared_bitmap_manager_(manager),
-      id_(id) {
+      id_(id),
+      transfer_buffer_memory_limit_(0u) {
   DCHECK(proxy_->IsImplThread());
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initial_debug_state);
 
   if (settings.calculate_top_controls_position) {
     top_controls_manager_ =
         TopControlsManager::Create(this,
                                    settings.top_controls_height,
                                    settings.top_controls_show_threshold,
@@ skipping 27 matching lines @@
   if (pending_tree_)
     pending_tree_->Shutdown();
   active_tree_->Shutdown();
   recycle_tree_.reset();
   pending_tree_.reset();
   active_tree_.reset();
   tile_manager_.reset();
   resource_pool_.reset();
   raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
+  staging_resource_pool_.reset();
 }
 
 void LayerTreeHostImpl::BeginMainFrameAborted(bool did_handle) {
   // If the begin frame data was handled, then scroll and scale set was applied
   // by the main thread, so the active tree needs to be updated as if these sent
   // values were applied and committed.
   if (did_handle) {
     active_tree_->ApplySentScrollAndScaleDeltasFromAbortedCommit();
     active_tree_->ResetContentsTexturesPurged();
   }
@@ skipping 873 matching lines @@
 
   DCHECK(resource_pool_);
   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);
 
+  // Staging pool resources are used as transfer buffers so we use
+  // |transfer_buffer_memory_limit_| as the memory limit for this resource pool.
+  if (staging_resource_pool_) {
+    staging_resource_pool_->CheckBusyResources();
+    staging_resource_pool_->SetResourceUsageLimits(
+        visible_ ? transfer_buffer_memory_limit_ : 0,
+        transfer_buffer_memory_limit_,
+        std::numeric_limits<size_t>::max());
+  }
+
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   DCHECK(settings_.impl_side_painting);
   // Mark priorities as dirty and schedule a ManageTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsManageTilesOnImplThread();
 }
 
@@ skipping 599 matching lines @@
   // 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::CreateAndSetTileManager(
     ResourceProvider* resource_provider,
     ContextProvider* context_provider,
-    bool using_map_image,
+    bool use_zero_copy,

[vmpstr, 2014/04/30 22:42:41]

I would DCHECK(!use_zero_copy || !use_one_copy) for sanity

[reveman, 2014/04/30 23:23:56]

That's currently allowed and I don't think we need to prevent the user from
requesting both. use_zero_copy takes precedence when both are specified.

FYI, I would have made this an enum and multi choice about:flag instead if my
intentions were not to make one_copy the default behavior asap and simply remove
that flag. 

+    bool use_one_copy,
     bool allow_rasterize_on_demand) {
   DCHECK(settings_.impl_side_painting);
   DCHECK(resource_provider);
   DCHECK(proxy_->ImplThreadTaskRunner());
 
-  if (using_map_image) {
+  transfer_buffer_memory_limit_ =
+      GetMaxTransferBufferUsageBytes(context_provider);
+
+  if (use_zero_copy) {
+    resource_pool_ =
+        ResourcePool::Create(resource_provider,
+                             GetMapImageTextureTarget(context_provider),
+                             resource_provider->best_texture_format());
     raster_worker_pool_ =
         ImageRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
                                       RasterWorkerPool::GetTaskGraphRunner(),
                                       resource_provider);
-    resource_pool_ =
+  } else if (use_one_copy) {
+    // We need to create a staging resource pool when using copy rasterizer.
+    staging_resource_pool_ =
         ResourcePool::Create(resource_provider,
                              GetMapImageTextureTarget(context_provider),
                              resource_provider->best_texture_format());
+    resource_pool_ =
+        ResourcePool::Create(resource_provider,
+                             GL_TEXTURE_2D,
+                             resource_provider->best_texture_format());
+
+    raster_worker_pool_ = ImageCopyRasterWorkerPool::Create(
+        proxy_->ImplThreadTaskRunner(),
+        RasterWorkerPool::GetTaskGraphRunner(),
+        resource_provider,
+        staging_resource_pool_.get());
   } else {
     raster_worker_pool_ = PixelBufferRasterWorkerPool::Create(
         proxy_->ImplThreadTaskRunner(),
         RasterWorkerPool::GetTaskGraphRunner(),
         resource_provider,
-        GetMaxTransferBufferUsageBytes(context_provider));
+        transfer_buffer_memory_limit_);
     resource_pool_ = ResourcePool::Create(
         resource_provider,
         GL_TEXTURE_2D,
         resource_provider->memory_efficient_texture_format());
   }
   direct_raster_worker_pool_ = DirectRasterWorkerPool::Create(
       proxy_->ImplThreadTaskRunner(), resource_provider, context_provider);
   tile_manager_ =
       TileManager::Create(this,
                           resource_pool_.get(),
@@ skipping 19 matching lines @@
 
   // 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
   // before we destroy the old resource provider.
   ReleaseTreeResources();
 
   // Note: order is important here.
   renderer_.reset();
   tile_manager_.reset();
   resource_pool_.reset();
+  staging_resource_pool_.reset();
   raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
   resource_provider_.reset();
   output_surface_.reset();
 
   if (!output_surface->BindToClient(this))
     return false;
 
   scoped_ptr<ResourceProvider> resource_provider =
       ResourceProvider::Create(output_surface.get(),
                                shared_bitmap_manager_,
                                settings_.highp_threshold_min,
                                settings_.use_rgba_4444_textures,
                                settings_.texture_id_allocation_chunk_size);
 
   if (output_surface->capabilities().deferred_gl_initialization)
     EnforceZeroBudget(true);
 
   bool skip_gl_renderer = false;
   CreateAndSetRenderer(
       output_surface.get(), resource_provider.get(), skip_gl_renderer);
 
+  transfer_buffer_memory_limit_ =
+      GetMaxTransferBufferUsageBytes(output_surface->context_provider().get());
+
   if (settings_.impl_side_painting) {
     CreateAndSetTileManager(
         resource_provider.get(),
         output_surface->context_provider().get(),
-        GetRendererCapabilities().using_map_image,
+        // Use zero-copy rasterizer by default when using shared memory
+        // resources.
+        (settings_.use_zero_copy ||

[vmpstr, 2014/04/30 22:42:41]

nit: consider determining this ahead of time:

bool use_zero_copy = ...;
bool use_one_copy = ...;
CreateAndSetTileManager(..., use_zero_copy, use_one_copy, ...);

[reveman, 2014/04/30 23:23:56]

Good idea. Done.

+         GetRendererCapabilities().using_shared_memory_resources) &&

[reveman, 2014/04/30 19:01:09]

This should get us the behavior we want with the Software Renderer, which is to
always use zero-copy. Let me know if it's better to a new explicit Renderer
capability for this instead of using |using_shared_memory_resources|.

+            GetRendererCapabilities().using_map_image,
+        // Sync query support is required by one-copy rasterizer.
+        settings_.use_one_copy && GetRendererCapabilities().using_map_image &&
+            resource_provider->use_sync_query(),
         GetRendererCapabilities().allow_rasterize_on_demand);
   }
 
   // Initialize vsync parameters to sane values.
   const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(base::Time::kMicrosecondsPerSecond /
                                         settings_.refresh_rate);
   CommitVSyncParameters(base::TimeTicks(), display_refresh_interval);
 
   // TODO(brianderson): Don't use a hard-coded parent draw time.
@@ skipping 44 matching lines @@
   DCHECK(output_surface_->capabilities().deferred_gl_initialization);
   DCHECK(settings_.impl_side_painting);
   DCHECK(output_surface_->context_provider());
 
   ReleaseTreeResources();
   renderer_.reset();
   tile_manager_.reset();
   resource_pool_.reset();
   raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
+  staging_resource_pool_.reset();
   resource_provider_->InitializeSoftware();
 
   bool skip_gl_renderer = true;
   CreateAndSetRenderer(
       output_surface_.get(), resource_provider_.get(), skip_gl_renderer);
 
   EnforceZeroBudget(true);
+  DCHECK(GetRendererCapabilities().using_map_image);
   CreateAndSetTileManager(resource_provider_.get(),
                           NULL,
-                          GetRendererCapabilities().using_map_image,
+                          true,
+                          false,
                           GetRendererCapabilities().allow_rasterize_on_demand);
   DCHECK(tile_manager_);
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
     return;
 
@@ skipping 1084 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc