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

cc/trees/layer_tree_host_impl.cc

Index: cc/trees/layer_tree_host_impl.cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index f11911aa91d64b012cb488aa0d0d029fd91bbe50..315f5c5ef65d8edf08322c12a658cdce355b421b 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -44,6 +44,7 @@
 #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"
@@ -122,6 +123,16 @@ unsigned GetMapImageTextureTarget(cc::ContextProvider* context_provider) {
   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 {
@@ -310,6 +321,7 @@ LayerTreeHostImpl::~LayerTreeHostImpl() {
   resource_pool_.reset();
   raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
+  staging_resource_pool_.reset();
 }
 
 void LayerTreeHostImpl::BeginMainFrameAborted(bool did_handle) {
@@ -1200,6 +1212,17 @@ void LayerTreeHostImpl::UpdateTileManagerMemoryPolicy(
       global_tile_state_.unused_memory_limit_in_bytes,
       global_tile_state_.num_resources_limit);
 
+  // We currently use hard-coded limits for staging pool limits.

[vmpstr, 2014/04/25 19:05:41]

nit: Is this comment still correct? We're using GetMaxTransferBufferUsageBytes

[reveman, 2014/04/25 20:18:25]

Updated comment.

+  if (staging_resource_pool_) {
+    size_t memory_limit_when_visible = GetMaxTransferBufferUsageBytes(
+        output_surface_->context_provider().get());
+    staging_resource_pool_->CheckBusyResources();
+    staging_resource_pool_->SetResourceUsageLimits(
+        visible_ ? memory_limit_when_visible : 0,
+        memory_limit_when_visible,
+        std::numeric_limits<size_t>::max());
+  }
+
   DidModifyTilePriorities();
 }
 
@@ -1806,20 +1829,43 @@ 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(),
@@ -1865,6 +1911,7 @@ bool LayerTreeHostImpl::InitializeRenderer(
   renderer_.reset();
   tile_manager_.reset();
   resource_pool_.reset();
+  staging_resource_pool_.reset();
   raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
   resource_provider_.reset();
@@ -1897,6 +1944,7 @@ bool LayerTreeHostImpl::InitializeRenderer(
         resource_provider.get(),
         output_surface->context_provider().get(),
         GetRendererCapabilities().using_map_image,
+        settings_.use_zero_copy,
         GetRendererCapabilities().allow_rasterize_on_demand);
   }
 
@@ -1997,6 +2045,7 @@ void LayerTreeHostImpl::ReleaseGL() {
   resource_pool_.reset();
   raster_worker_pool_.reset();
   direct_raster_worker_pool_.reset();
+  staging_resource_pool_.reset();
   resource_provider_->InitializeSoftware();
 
   bool skip_gl_renderer = true;
@@ -2008,6 +2057,7 @@ void LayerTreeHostImpl::ReleaseGL() {
   CreateAndSetTileManager(resource_provider_.get(),
                           NULL,
                           GetRendererCapabilities().using_map_image,
+                          settings_.use_zero_copy,
                           GetRendererCapabilities().allow_rasterize_on_demand);
   DCHECK(tile_manager_);