cc: Allow TEXTURE_RECTANGLE_ARB to be used for tile textures.

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 38 matching lines @@
 #include "cc/resources/ui_resource_bitmap.h"
 #include "cc/scheduler/delay_based_time_source.h"
 #include "cc/scheduler/texture_uploader.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/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 {
 
 void DidVisibilityChange(cc::LayerTreeHostImpl* id, bool visible) {
   if (visible) {
     TRACE_EVENT_ASYNC_BEGIN1("webkit",
                              "LayerTreeHostImpl::SetVisible",
@@ skipping 27 matching lines @@
 }
 
 size_t GetMaxRasterTasksUsageBytes(cc::ContextProvider* context_provider) {
   // Transfer-buffer/raster-tasks limits are different but related. We make
   // equal here, as this is ideal when using transfer buffers. When not using
   // transfer buffers we should still limit raster to something similar, to
   // preserve caching behavior (and limit memory waste when priorities change).
   return GetMaxTransferBufferUsageBytes(context_provider);
 }
 
+GLenum GetMapImageTextureTarget(cc::ContextProvider* context_provider) {
+  if (!context_provider)
+    return GL_TEXTURE_2D;
+
+  // TODO(reveman): Determine if GL_TEXTURE_EXTERNAL_OES works well on
+  // Android before we enable this. crbug.com/322780
+#if !defined(OS_ANDROID)
+  if (context_provider->ContextCapabilities().egl_image_external)
+    return GL_TEXTURE_EXTERNAL_OES;
+  if (context_provider->ContextCapabilities().texture_rectangle)
+    return GL_TEXTURE_RECTANGLE_ARB;
+#endif
+
+  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 1537 matching lines @@
     bool using_map_image) {
   DCHECK(settings_.impl_side_painting);
   DCHECK(resource_provider);
   tile_manager_ =
       TileManager::Create(this,
                           resource_provider,
                           settings_.num_raster_threads,
                           rendering_stats_instrumentation_,
                           using_map_image,
                           GetMaxTransferBufferUsageBytes(context_provider),
-                          GetMaxRasterTasksUsageBytes(context_provider));
+                          GetMaxRasterTasksUsageBytes(context_provider),
+                          GetMapImageTextureTarget(context_provider));
 
   UpdateTileManagerMemoryPolicy(ActualManagedMemoryPolicy());
   need_to_update_visible_tiles_before_draw_ = false;
 }
 
 void LayerTreeHostImpl::EnforceZeroBudget(bool zero_budget) {
   SetManagedMemoryPolicy(cached_managed_memory_policy_, zero_budget);
 }
 
 bool LayerTreeHostImpl::InitializeRenderer(
@@ skipping 1168 matching lines @@
   if (evicted_ui_resources_.empty())
     client_->OnCanDrawStateChanged(CanDraw());
 }
 
 void LayerTreeHostImpl::ScheduleMicroBenchmark(
     scoped_ptr<MicroBenchmarkImpl> benchmark) {
   micro_benchmark_controller_.ScheduleRun(benchmark.Pass());
 }
 
 }  // namespace cc