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"
 #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"
 #include "cc/trees/quad_culler.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/size_conversions.h"
 #include "ui/gfx/vector2d_conversions.h"
 
 namespace {
 
+const int kStagingPoolMemoryLimitWhenVisible = 32 * 1024 * 1024;

[vmpstr, 2014/04/23 17:25:46]

Can you put a TODO here to maybe move this into global_state or something like
that? Similar to our other memory limits. My concern is that this will be hard
to tune per platform.

[reveman, 2014/04/24 19:20:43]

Latest patch uses GetMaxTransferBufferUsageBytes instead, which is our current
way of tuning the amount of memory used for pending uploads. That limit might
not be perfect in this case but I think it's what we should be using long term.

+const int kStagingPoolUnusedMemoryLimit = kStagingPoolMemoryLimitWhenVisible;
+const int kStagingPoolResourceCountLimit = 48;
+
 void DidVisibilityChange(cc::LayerTreeHostImpl* id, bool visible) {
   if (visible) {
     TRACE_EVENT_ASYNC_BEGIN1("webkit",
                              "LayerTreeHostImpl::SetVisible",
                              id,
                              "LayerTreeHostImpl",
                              id);
     return;
   }
 
@@ skipping 33 matching lines @@
     return GL_TEXTURE_2D;
 
   if (context_provider->ContextCapabilities().gpu.egl_image_external)
     return GL_TEXTURE_EXTERNAL_OES;
   if (context_provider->ContextCapabilities().gpu.texture_rectangle)
     return GL_TEXTURE_RECTANGLE_ARB;
 
   return GL_TEXTURE_2D;
 }
 
+unsigned GetCopyImageTextureTarget(cc::ContextProvider* context_provider) {
+  if (!context_provider)
+    return GL_TEXTURE_2D;
+
+  if (context_provider->ContextCapabilities().gpu.egl_image_external)
+    return GL_TEXTURE_EXTERNAL_OES;
+
+  return GL_TEXTURE_2D;
+}
+
 }  // namespace
 
 namespace cc {
 
 class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
  public:
   static scoped_ptr<LayerTreeHostImplTimeSourceAdapter> Create(
       LayerTreeHostImpl* layer_tree_host_impl,
       scoped_refptr<DelayBasedTimeSource> time_source) {
     return make_scoped_ptr(
@@ skipping 168 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 870 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,
       global_tile_state_.unused_memory_limit_in_bytes,
       global_tile_state_.num_resources_limit);
 
+  // We currently use hard-coded limits for staging pool limits.
+  if (staging_resource_pool_) {
+    staging_resource_pool_->CheckBusyResources();
+    staging_resource_pool_->SetResourceUsageLimits(
+        visible_ ? kStagingPoolMemoryLimitWhenVisible : 0,
+        kStagingPoolUnusedMemoryLimit,
+        kStagingPoolResourceCountLimit);
+  }
+
   DidModifyTilePriorities();
 }
 
 void LayerTreeHostImpl::DidModifyTilePriorities() {
   DCHECK(settings_.impl_side_painting);
   // Mark priorities as dirty and schedule a ManageTiles().
   tile_priorities_dirty_ = true;
   client_->SetNeedsManageTilesOnImplThread();
 }
 
@@ skipping 586 matching lines @@
     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,
     bool allow_rasterize_on_demand) {
   DCHECK(settings_.impl_side_painting);
   DCHECK(resource_provider);
   DCHECK(proxy_->ImplThreadTaskRunner());
 
   if (using_map_image) {
-    raster_worker_pool_ =
-        ImageRasterWorkerPool::Create(proxy_->ImplThreadTaskRunner(),
-                                      RasterWorkerPool::GetTaskGraphRunner(),
-                                      resource_provider);
-    resource_pool_ =
-        ResourcePool::Create(resource_provider,
-                             GetMapImageTextureTarget(context_provider),
-                             resource_provider->best_texture_format());
+    // We need to create a staging resource pool unless we're using
+    // ImageRasterWorkerPool that implements zero-copy.
+    if (use_zero_copy || !resource_provider_->use_sync_query()) {
+      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);
+    } else {
+      // TODO(reveman): Use GetMapImageTextureTarget instead of
+      // GetCopyImageTextureTarget when GL_TEXTURE_RECTANGLE_ARB support has
+      // been added to CHROMIUM_copy_texture.
+      staging_resource_pool_ =
+          ResourcePool::Create(resource_provider,
+                               GetCopyImageTextureTarget(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));
     resource_pool_ = ResourcePool::Create(
         resource_provider,
         GL_TEXTURE_2D,
         resource_provider->memory_efficient_texture_format());
@@ skipping 25 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(),
@@ skipping 12 matching lines @@
       output_surface.get(), resource_provider.get(), skip_gl_renderer);
 
   if (!renderer_)
     return false;
 
   if (settings_.impl_side_painting) {
     CreateAndSetTileManager(
         resource_provider.get(),
         output_surface->context_provider().get(),
         GetRendererCapabilities().using_map_image,
+        settings_.use_zero_copy,
         GetRendererCapabilities().allow_rasterize_on_demand);
   }
 
   if (!settings_.throttle_frame_production) {
     // Disable VSync
     output_surface->SetThrottleFrameProduction(false);
   } else if (!settings_.begin_impl_frame_scheduling_enabled) {
     // Setup BeginFrameEmulation if it's not supported natively
     const base::TimeDelta display_refresh_interval =
       base::TimeDelta::FromMicroseconds(
@@ skipping 80 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);
   DCHECK(renderer_);
 
   EnforceZeroBudget(true);
   CreateAndSetTileManager(resource_provider_.get(),
                           NULL,
                           GetRendererCapabilities().using_map_image,
+                          settings_.use_zero_copy,
                           GetRendererCapabilities().allow_rasterize_on_demand);
   DCHECK(tile_manager_);
 
   SetOffscreenContextProvider(NULL);
 
   client_->SetNeedsCommitOnImplThread();
 }
 
 void LayerTreeHostImpl::SetViewportSize(const gfx::Size& device_viewport_size) {
   if (device_viewport_size == device_viewport_size_)
@@ skipping 1101 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