cc: Use a normal texture for background texture.

cc/output/gl_renderer.cc

 // Copyright 2010 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/output/gl_renderer.h"
 
 #include <algorithm>
 #include <limits>
 #include <set>
 #include <string>
@@ skipping 881 matching lines @@
 
   int top, right, bottom, left;
   quad->background_filters.GetOutsets(&top, &right, &bottom, &left);
   window_rect.Inset(-left, -top, -right, -bottom);
 
   window_rect.Intersect(
       MoveFromDrawToWindowSpace(frame->current_render_pass->output_rect));
 
   scoped_ptr<ScopedResource> device_background_texture =
       ScopedResource::Create(resource_provider_);
-  // The TextureUsageFramebuffer hint makes ResourceProvider avoid immutable
-  // storage allocation (texStorage2DEXT) for this texture. copyTexImage2D fails
-  // when called on a texture having immutable storage.
+  // CopyTexImage2D fails when called on a texture having immutable storage.
   device_background_texture->Allocate(
-      window_rect.size(), ResourceProvider::TextureUsageFramebuffer, RGBA_8888);
+      window_rect.size(), ResourceProvider::TextureHintDefault, RGBA_8888);

[dshwang, 2014/08/18 19:28:08]

Here is only one logic change. Other changes are just due to enum.
Now we don't call following function for this texture.
TexParameteri(GL_TEXTURE_2D, GL_TEXTURE_USAGE_ANGLE,
GL_FRAMEBUFFER_ATTACHMENT_ANGLE);
So ANGLE doesn't make a render target texture on Direct3D

[danakj, 2014/08/20 14:46:17]

Why not just use TextureUsageAny here, why do we need the new enum values?

[dshwang, 2014/08/20 15:08:35]

That's good question.
Currently, This line wants to alloc texture by glTexImage2D so this uses
TextureUsageFramebuffer although this texture is not attached to framebuffer
object. It uses TextureUsageFramebuffer implementation detail.
TextureUsageAny will alloc texture by glTexStorage2D while
TextureUsageFramebuffer will alloc texture by glTexImage2D and then notify
GL_FRAMEBUFFER_ATTACHMENT_ANGLE to ANGLE.
There are two problem.
1. TextureUsageFramebuffer has two different properties; mutable texture and
framebuffer hint.
2. TextureUsageAny doesn't sounds like immutable texture.

So I split TextureUsageFramebuffer into TextureHintDefault and
TextureHintFramebuffer
- TextureHintDefault: neither immutable texture nor framebuffer target
- TextureHintImmutable: alloc by glTexStorage2D if possible. If you want, I can
change it to TextureUsageAny.
- TextureHintFramebuffer: notify it's framebuffer target

Most cases use TextureHintImmutable. Some cases use TextureHintFramebuffer. Only
this line use TextureHintDefault.

In addition, it's possible for texture to have both TextureHintFramebuffer and
TextureHintImmutable properties, because both are independent on each other.
This CL doesn't handle it, so I'll update the CL to handle this case.

   {
     ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
                                              device_background_texture->id());
     GetFramebufferTexture(
         lock.texture_id(), device_background_texture->format(), window_rect);
   }
 
   skia::RefPtr<SkImageFilter> filter = RenderSurfaceFilters::BuildImageFilter(
       quad->background_filters, device_background_texture->size());
 
@@ skipping 17 matching lines @@
     filtered_device_background_texture_id = texture->getTextureHandle();
   } else {
     lock.reset(new ResourceProvider::ScopedReadLockGL(
         resource_provider_, device_background_texture->id()));
     filtered_device_background_texture_id = lock->texture_id();
   }
 
   scoped_ptr<ScopedResource> background_texture =
       ScopedResource::Create(resource_provider_);
   background_texture->Allocate(
-      quad->rect.size(), ResourceProvider::TextureUsageFramebuffer, RGBA_8888);
+      quad->rect.size(), ResourceProvider::TextureHintFramebuffer, RGBA_8888);
 
   const RenderPass* target_render_pass = frame->current_render_pass;
   bool using_background_texture =
       UseScopedTexture(frame, background_texture.get(), quad->rect);
 
   if (using_background_texture) {
     // Copy the readback pixels from device to the background texture for the
     // surface.
     gfx::Transform device_to_framebuffer_transform;
     QuadRectTransform(
@@ skipping 967 matching lines @@
 void GLRenderer::DrawPictureQuad(const DrawingFrame* frame,
                                  const PictureDrawQuad* quad) {
   if (on_demand_tile_raster_bitmap_.width() != quad->texture_size.width() ||
       on_demand_tile_raster_bitmap_.height() != quad->texture_size.height()) {
     on_demand_tile_raster_bitmap_.allocN32Pixels(quad->texture_size.width(),
                                                  quad->texture_size.height());
 
     if (on_demand_tile_raster_resource_id_)
       resource_provider_->DeleteResource(on_demand_tile_raster_resource_id_);
 
-    on_demand_tile_raster_resource_id_ =
-        resource_provider_->CreateGLTexture(quad->texture_size,
-                                            GL_TEXTURE_2D,
-                                            GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
-                                            GL_CLAMP_TO_EDGE,
-                                            ResourceProvider::TextureUsageAny,
-                                            quad->texture_format);
+    on_demand_tile_raster_resource_id_ = resource_provider_->CreateGLTexture(
+        quad->texture_size,
+        GL_TEXTURE_2D,
+        GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
+        GL_CLAMP_TO_EDGE,
+        ResourceProvider::TextureHintImmutable,
+        quad->texture_format);
   }
 
   // Create and run on-demand raster task for tile.
   scoped_refptr<Task> on_demand_raster_task(
       new OnDemandRasterTaskImpl(quad->picture_pile,
                                  &on_demand_tile_raster_bitmap_,
                                  quad->content_rect,
                                  quad->contents_scale));
   client_->RunOnDemandRasterTask(on_demand_raster_task.get());
 
@@ skipping 1268 matching lines @@
     context_support_->ScheduleOverlayPlane(
         overlay.plane_z_order,
         overlay.transform,
         pending_overlay_resources_.back()->texture_id(),
         overlay.display_rect,
         overlay.uv_rect);
   }
 }
 
 }  // namespace cc