cc: Fix the format of GpuMemoryBuffer for SurfaceTexture

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 62 matching lines @@
 #include "cc/trees/layer_tree_host_common.h"
 #include "cc/trees/layer_tree_impl.h"
 #include "cc/trees/single_thread_proxy.h"
 #include "cc/trees/tree_synchronizer.h"
 #include "gpu/GLES2/gl2extchromium.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/geometry/size_conversions.h"
 #include "ui/gfx/geometry/vector2d_conversions.h"
+#include "ui/gfx/gpu_memory_buffer.h"
 
 namespace cc {
 namespace {
 
 // Small helper class that saves the current viewport location as the user sees
 // it and resets to the same location.
 class ViewportAnchor {
  public:
   ViewportAnchor(LayerImpl* inner_scroll, LayerImpl* outer_scroll)
   : inner_(inner_scroll),
@@ skipping 2003 matching lines @@
   // 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);
+    *resource_pool = ResourcePool::Create(
+        resource_provider_.get(),
+        std::vector<uint>(gfx::GpuMemoryBuffer::FORMAT_LAST + 1,
+                          GL_TEXTURE_2D));
 
     *tile_task_worker_pool = BitmapTileTaskWorkerPool::Create(
         GetTaskRunner(), task_graph_runner, resource_provider_.get());
     return;
   }
 
   if (use_gpu_rasterization_) {
-    *resource_pool =
-        ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
+    *resource_pool = ResourcePool::Create(
+        resource_provider_.get(),
+        std::vector<uint>(gfx::GpuMemoryBuffer::FORMAT_LAST + 1,
+                          GL_TEXTURE_2D));
 
     int msaa_sample_count =
         use_msaa_ ? settings_.gpu_rasterization_msaa_sample_count : 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);
-  unsigned image_target = settings_.use_image_texture_target;
-  DCHECK_IMPLIES(image_target == GL_TEXTURE_RECTANGLE_ARB,
-                 context_provider->ContextCapabilities().gpu.texture_rectangle);
-  DCHECK_IMPLIES(
-      image_target == GL_TEXTURE_EXTERNAL_OES,
-      context_provider->ContextCapabilities().gpu.egl_image_external);
+  std::vector<uint> image_targets = settings_.use_image_texture_targets;
 
   if (settings_.use_zero_copy) {
     *resource_pool =
-        ResourcePool::Create(resource_provider_.get(), image_target);
+        ResourcePool::Create(resource_provider_.get(), image_targets);
 
     *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(), image_target);
-    *resource_pool =
-        ResourcePool::Create(resource_provider_.get(), GL_TEXTURE_2D);
+        ResourcePool::Create(resource_provider_.get(), image_targets);
+    *resource_pool = ResourcePool::Create(
+        resource_provider_.get(),
+        std::vector<uint>(gfx::GpuMemoryBuffer::FORMAT_LAST + 1,
+                          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);
     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);
+      resource_provider_.get(),
+      std::vector<uint>(gfx::GpuMemoryBuffer::FORMAT_LAST + 1, GL_TEXTURE_2D));
 
   *tile_task_worker_pool = PixelBufferTileTaskWorkerPool::Create(
       GetTaskRunner(), task_graph_runner_, context_provider,
       resource_provider_.get(),
       GetMaxTransferBufferUsageBytes(context_provider->ContextCapabilities(),
                                      settings_.renderer_settings.refresh_rate));
 }
 
 void LayerTreeHostImpl::RecordMainFrameTiming(
     const BeginFrameArgs& start_of_main_frame_args,
@@ skipping 1421 matching lines @@
   if (active_tree()) {
     LayerAnimationValueProvider* layer = active_tree()->LayerById(layer_id);
     if (layer)
       return layer->ScrollOffsetForAnimation();
   }
 
   return gfx::ScrollOffset();
 }
 
 }  // namespace cc