content: Add command line flag for native GPU memory buffers.

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 133 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);
 }
 
-unsigned GetMapImageTextureTarget(
-    const ContextProvider::Capabilities& context_capabilities) {
-// TODO(reveman): This should be a setting passed to the compositor instead
-// of hard-coded here. The target that need to be used depends on our choice
-// of GpuMemoryBuffer type. Note: SURFACE_TEXTURE needs EXTERNAL_OES,
-// IO_SURFACE needs RECTANGLE_ARB. crbug.com/431059
-#if defined(OS_ANDROID)
-  if (context_capabilities.gpu.egl_image_external)
-    return GL_TEXTURE_EXTERNAL_OES;
-#endif
-  if (context_capabilities.gpu.texture_rectangle)
-    return GL_TEXTURE_RECTANGLE_ARB;
-
-  return GL_TEXTURE_2D;
-}
-
 size_t GetMaxStagingResourceCount() {
   // Upper bound for number of staging resource to allow.
   return 32;
 }
 
 }  // namespace
 
 LayerTreeHostImpl::FrameData::FrameData() : has_no_damage(false) {
 }
 
@@ skipping 1821 matching lines @@
     scoped_ptr<ResourcePool>* staging_resource_pool) {
   base::SingleThreadTaskRunner* task_runner =
       proxy_->HasImplThread() ? proxy_->ImplThreadTaskRunner()
                               : proxy_->MainThreadTaskRunner();
   DCHECK(task_runner);
 
   ContextProvider* context_provider = output_surface_->context_provider();
   bool should_use_zero_copy_rasterizer =
       settings_.use_zero_copy || IsSynchronousSingleThreaded();
 
+  unsigned image_target = GL_TEXTURE_2D;
+#if defined(OS_MACOSX)
+  // GL_TEXTURE_RECTANGLE_ARB target is required by IOSurface backed images.
+  DCHECK(context_provider->ContextCapabilities().gpu.texture_rectangle);

[piman, 2014/11/25 18:12:21]

Would it make sense to ask the GpuMemoryBufferImpl which texture target it
should use?

[reveman, 2014/11/25 19:36:11]

Maybe. I'm not sure I want the concept of GL texture targets at the
gfx::GpuMemoryBuffer level. We could add something to the CHROMIUM_image API for
this but I'm not sure exactly what that would look like. And if we make it a
buffer specific setting in cc (where we're not currently assuming that all
buffers are of the same type) it breaks our current resource pool usage where we
assume that all buffers use the same target.

Another option is to introduce a new chromium only texture target that must be
used with CHROMIUM_image, call it EXTERNAL_CHROMIUM. The use of this target
would be limited much in the same way as EXTERNAL_OES. The GPU service would
then automatically use the correct GL target based on buffer type. I think this
would be cleanest solution but hard to implement as texture coordinates can't be
normalized in the RECTANGLE_ARB case...

I think it's easiest to handle this using ifdefs and a setting for now.

+  image_target = GL_TEXTURE_RECTANGLE_ARB;
+#endif
+  if (settings_.use_image_external) {
+    DCHECK(context_provider->ContextCapabilities().gpu.egl_image_external);
+    image_target = GL_TEXTURE_EXTERNAL_OES;
+  }
+
   if (!context_provider) {
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(),
                              GL_TEXTURE_2D,
                              resource_provider_->best_texture_format());
 
     *raster_worker_pool =
         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 (should_use_zero_copy_rasterizer && CanUseZeroCopyRasterizer()) {
-    *resource_pool = ResourcePool::Create(
-        resource_provider_.get(),
-        GetMapImageTextureTarget(context_provider->ContextCapabilities()),
-        resource_provider_->best_texture_format());
+    *resource_pool =
+        ResourcePool::Create(resource_provider_.get(), image_target,
+                             resource_provider_->best_texture_format());
 
     TaskGraphRunner* task_graph_runner;
     if (IsSynchronousSingleThreaded()) {
       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();
     }
 
     *raster_worker_pool = ZeroCopyRasterWorkerPool::Create(
         task_runner, task_graph_runner, resource_provider_.get());
   } else if (settings_.use_one_copy && CanUseOneCopyRasterizer()) {
     // 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());
+    *staging_resource_pool =
+        ResourcePool::Create(resource_provider_.get(), image_target,
+                             resource_provider_->best_texture_format());
     *resource_pool =
         ResourcePool::Create(resource_provider_.get(),
                              GL_TEXTURE_2D,
                              resource_provider_->best_texture_format());
 
     *raster_worker_pool =
         OneCopyRasterWorkerPool::Create(task_runner,
                                         RasterWorkerPool::GetTaskGraphRunner(),
                                         context_provider,
                                         resource_provider_.get(),
@@ skipping 1426 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