cc: Adding support for RGBA_4444 tile textures

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 635 matching lines @@
   int top, right, bottom, left;
   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_);
   if (!device_background_texture->Allocate(window_rect.size(),
-                                           GL_RGB,
-                                           ResourceProvider::TextureUsageAny)) {
+                                           ResourceProvider::TextureUsageAny,
+                                           RGBA_8888)) {
     return scoped_ptr<ScopedResource>();
   } else {
     ResourceProvider::ScopedWriteLockGL lock(resource_provider_,
                                              device_background_texture->id());
     GetFramebufferTexture(lock.texture_id(),
                           device_background_texture->format(),
                           window_rect);
   }
 
   SkBitmap filtered_device_background =
       ApplyFilters(this,
                    frame->offscreen_context_provider,
                    filters,
                    device_background_texture.get());
   if (!filtered_device_background.getTexture())
     return scoped_ptr<ScopedResource>();
 
   GrTexture* texture =
       reinterpret_cast<GrTexture*>(filtered_device_background.getTexture());
   int filtered_device_background_texture_id = texture->getTextureHandle();
 
   scoped_ptr<ScopedResource> background_texture =
       ScopedResource::create(resource_provider_);
   if (!background_texture->Allocate(quad->rect.size(),
-                                    GL_RGBA,
-                                    ResourceProvider::TextureUsageFramebuffer))
+                                    ResourceProvider::TextureUsageFramebuffer,
+                                    RGBA_8888))
     return scoped_ptr<ScopedResource>();
 
   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;
@@ skipping 1001 matching lines @@
         SkBitmap::kARGB_8888_Config,
         quad->texture_size.width(),
         quad->texture_size.height());
     on_demand_tile_raster_bitmap_.allocPixels();
 
     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_RGBA,
         GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
         GL_CLAMP_TO_EDGE,
-        ResourceProvider::TextureUsageAny);
+        ResourceProvider::TextureUsageAny,
+        quad->texture_format);
   }
 
   SkBitmapDevice device(on_demand_tile_raster_bitmap_);
   SkCanvas canvas(&device);
 
   quad->picture_pile->RasterToBitmap(&canvas, quad->content_rect,
                                      quad->contents_scale, NULL);
 
+  uint8_t* bitmap_pixels = NULL;
+  SkBitmap on_demand_tile_raster_bitmap_dest;
+  SkBitmap::Config config = SkBitmapConfigFromFormat(quad->texture_format);
+  if (on_demand_tile_raster_bitmap_.getConfig() != config) {
+    on_demand_tile_raster_bitmap_.copyTo(&on_demand_tile_raster_bitmap_dest,
+                                         config);
+    // TODO(kaanb): The GL pipeline assumes a 4-byte alignment for the
+    // bitmap data. This check will be removed once crbug.com/293728 is fixed.
+    CHECK_EQ(0u, on_demand_tile_raster_bitmap_dest.rowBytes() % 4);
+    bitmap_pixels = reinterpret_cast<uint8_t*>(
+        on_demand_tile_raster_bitmap_dest.getPixels());
+  } else {
+    bitmap_pixels = reinterpret_cast<uint8_t*>(
+        on_demand_tile_raster_bitmap_.getPixels());
+  }
+
   resource_provider_->SetPixels(
       on_demand_tile_raster_resource_id_,
-      reinterpret_cast<uint8_t*>(on_demand_tile_raster_bitmap_.getPixels()),
+      bitmap_pixels,
       gfx::Rect(quad->texture_size),
       gfx::Rect(quad->texture_size),
       gfx::Vector2d());
 
   DrawContentQuad(frame, quad, on_demand_tile_raster_resource_id_);
 }
 
 struct TextureProgramBinding {
   template <class Program>
   void Set(Program* program, WebKit::WebGraphicsContext3D* context) {
@@ skipping 468 matching lines @@
     unsigned int texture_id = context_->createTexture();
     GLC(context_, context_->bindTexture(GL_TEXTURE_2D, texture_id));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
-    GetFramebufferTexture(texture_id, GL_RGBA, window_rect);
+    GetFramebufferTexture(texture_id, RGBA_8888, window_rect);
 
     gpu::Mailbox mailbox;
     unsigned sync_point = 0;
     GLC(context_, context_->genMailboxCHROMIUM(mailbox.name));
     if (mailbox.IsZero()) {
       context_->deleteTexture(texture_id);
       request->SendEmptyResult();
       return;
     }
 
@@ skipping 71 matching lines @@
         GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
     GLC(context_, context_->texParameteri(
         GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
     // Copy the contents of the current (IOSurface-backed) framebuffer into a
     // temporary texture.
     GetFramebufferTexture(temporary_texture,
-                          GL_RGBA,
+                          RGBA_8888,
                           gfx::Rect(current_surface_size_));
     temporary_fbo = context_->createFramebuffer();
     // Attach this texture to an FBO, and perform the readback from that FBO.
     GLC(context_, context_->bindFramebuffer(GL_FRAMEBUFFER, temporary_fbo));
     GLC(context_, context_->framebufferTexture2D(GL_FRAMEBUFFER,
                                                  GL_COLOR_ATTACHMENT0,
                                                  GL_TEXTURE_2D,
                                                  temporary_texture,
                                                  0));
 
@@ skipping 129 matching lines @@
     scoped_ptr<SkAutoLockPixels> lock,
     scoped_ptr<CopyOutputRequest> request,
     bool success) {
   DCHECK(request->force_bitmap_result());
 
   lock.reset();
   if (success)
     request->SendBitmapResult(bitmap.Pass());
 }
 
-void GLRenderer::GetFramebufferTexture(unsigned texture_id,
-                                       unsigned texture_format,
-                                       gfx::Rect window_rect) {
+void GLRenderer::GetFramebufferTexture(
+    unsigned texture_id, ResourceFormat texture_format, gfx::Rect window_rect) {
   DCHECK(texture_id);
   DCHECK_GE(window_rect.x(), 0);
   DCHECK_GE(window_rect.y(), 0);
   DCHECK_LE(window_rect.right(), current_surface_size_.width());
   DCHECK_LE(window_rect.bottom(), current_surface_size_.height());
 
   GLC(context_, context_->bindTexture(GL_TEXTURE_2D, texture_id));
   GLC(context_,
-      context_->copyTexImage2D(GL_TEXTURE_2D,
-                               0,
-                               texture_format,
-                               window_rect.x(),
-                               window_rect.y(),
-                               window_rect.width(),
-                               window_rect.height(),
-                               0));
+      context_->copyTexImage2D(
+          GL_TEXTURE_2D,
+          0,
+          ResourceProvider::GetGLDataFormat(texture_format),
+          window_rect.x(),
+          window_rect.y(),
+          window_rect.width(),
+          window_rect.height(),
+          0));
   GLC(context_, context_->bindTexture(GL_TEXTURE_2D, 0));
 }
 
 bool GLRenderer::UseScopedTexture(DrawingFrame* frame,
                                   const ScopedResource* texture,
                                   gfx::Rect viewport_rect) {
   DCHECK(texture->id());
   frame->current_render_pass = NULL;
   frame->current_texture = texture;
 
@@ skipping 640 matching lines @@
   // The Skia GPU backend requires a stencil buffer.  See ReinitializeGrCanvas
   // implementation.
   return gr_context_ && context_->getContextAttributes().stencil;
 }
 
 bool GLRenderer::IsContextLost() {
   return (context_->getGraphicsResetStatusARB() != GL_NO_ERROR);
 }
 
 }  // namespace cc