cc: Adding support for RGBA_4444 tile textures

cc/resources/resource_provider.cc

 // Copyright 2012 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/resources/resource_provider.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "base/containers/hash_tables.h"
@@ skipping 16 matching lines @@
 using WebKit::WebGraphicsContext3D;
 
 namespace cc {
 
 namespace {
 
 // Measured in seconds.
 const double kSoftwareUploadTickRate = 0.000250;
 const double kTextureUploadTickRate = 0.004;
 
-GLenum TextureToStorageFormat(GLenum texture_format) {
+GLenum TextureToStorageFormat(cc::ResourceProvider::Format format) {
   GLenum storage_format = GL_RGBA8_OES;
-  switch (texture_format) {
-    case GL_RGBA:
+  switch (format) {
+    case cc::ResourceProvider::RGBA_8888:
+    case cc::ResourceProvider::RGBA_4444:
+    case cc::ResourceProvider::LUMINANCE_8:
       break;
-    case GL_BGRA_EXT:
+    case cc::ResourceProvider::BGRA_8888:
       storage_format = GL_BGRA8_EXT;
       break;
-    default:
-      NOTREACHED();
-      break;
   }
 
   return storage_format;
 }
 
-bool IsTextureFormatSupportedForStorage(GLenum format) {
-  return (format == GL_RGBA || format == GL_BGRA_EXT);
+bool IsFormatSupportedForStorage(
+    cc::ResourceProvider::Format format) {
+  switch (format) {
+    case cc::ResourceProvider::RGBA_8888:
+    case cc::ResourceProvider::BGRA_8888:
+      return true;
+    case cc::ResourceProvider::RGBA_4444:
+    case cc::ResourceProvider::LUMINANCE_8:
+      return false;
+  }
+  return false;
 }
 
 class ScopedSetActiveTexture {
  public:
   ScopedSetActiveTexture(WebGraphicsContext3D* context3d, GLenum unit)
       : context3d_(context3d), unit_(unit) {
     DCHECK_EQ(GL_TEXTURE0, ResourceProvider::GetActiveTextureUnit(context3d_));
 
     if (unit_ != GL_TEXTURE0)
       GLC(context3d_, context3d_->activeTexture(unit_));
@@ skipping 23 matching lines @@
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(),
-      format(0),
       filter(0),
       image_id(0),
       texture_pool(0),
       wrap_mode(0),
       hint(TextureUsageAny),
-      type(static_cast<ResourceType>(0)) {}
+      type(static_cast<ResourceType>(0)),
+      texture_format(RGBA_8888) {}
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(
     unsigned texture_id,
     gfx::Size size,
-    GLenum format,
     GLenum filter,
     GLenum texture_pool,
     GLint wrap_mode,
-    TextureUsageHint hint)
+    TextureUsageHint hint,
+    Format texture_format)
     : gl_id(texture_id),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(NULL),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
-      format(format),
       filter(filter),
       image_id(0),
       texture_pool(texture_pool),
       wrap_mode(wrap_mode),
       hint(hint),
-      type(GLTexture) {
+      type(GLTexture),
+      texture_format(texture_format) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
 }
 
 ResourceProvider::Resource::Resource(
     uint8_t* pixels,
     gfx::Size size,
-    GLenum format,
     GLenum filter,
     GLint wrap_mode)
     : gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(pixels),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
-      format(format),
       filter(filter),
       image_id(0),
       texture_pool(0),
       wrap_mode(wrap_mode),
       hint(TextureUsageAny),
-      type(Bitmap) {
+      type(Bitmap),
+      texture_format(RGBA_8888) {
   DCHECK(wrap_mode == GL_CLAMP_TO_EDGE || wrap_mode == GL_REPEAT);
 }
 
 ResourceProvider::Child::Child() {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     int highp_threshold_min) {
   scoped_ptr<ResourceProvider> resource_provider(
-      new ResourceProvider(output_surface, highp_threshold_min));
+      new ResourceProvider(output_surface,
+                           highp_threshold_min));
 
   bool success = false;
   if (resource_provider->Context3d()) {
     success = resource_provider->InitializeGL();
   } else {
     resource_provider->InitializeSoftware();
     success = true;
   }
 
   if (!success)
     return scoped_ptr<ResourceProvider>();
 
   DCHECK_NE(InvalidType, resource_provider->default_resource_type());
   return resource_provider.Pass();
 }
 
 ResourceProvider::~ResourceProvider() {
   while (!resources_.empty())
     DeleteResourceInternal(resources_.begin(), ForShutdown);
 
   CleanUpGLIfNeeded();
 }
 
 bool ResourceProvider::InUseByConsumer(ResourceId id) {
   Resource* resource = GetResource(id);
   return resource->lock_for_read_count > 0 || resource->exported_count > 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResource(
-    gfx::Size size, GLenum format, GLint wrap_mode, TextureUsageHint hint) {
+    gfx::Size size,
+    GLint wrap_mode,
+    TextureUsageHint hint,
+    Format texture_format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case GLTexture:
-      return CreateGLTexture(size, format, GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
-                             wrap_mode, hint);
+      return CreateGLTexture(size,
+                             GL_TEXTURE_POOL_UNMANAGED_CHROMIUM,
+                             wrap_mode,
+                             hint,
+                             texture_format);
     case Bitmap:
-      // The only wrap_mode currently implemented in software mode is
-      // GL_CLAMP_TO_EDGE.
-      // http://crbug.com/284796
-      DCHECK(format == GL_RGBA);
+      DCHECK(texture_format == RGBA_8888);

[enne (OOO), 2013/09/13 01:39:44]

DCHECK_EQ, here and elsewhere.

[kaanb, 2013/09/13 03:43:56]

Done.

       return CreateBitmap(size);
     case InvalidType:
       break;
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateManagedResource(
-    gfx::Size size, GLenum format, GLint wrap_mode, TextureUsageHint hint) {
+    gfx::Size size,
+    GLint wrap_mode,
+    TextureUsageHint hint,
+    Format texture_format) {
   DCHECK(!size.IsEmpty());
   switch (default_resource_type_) {
     case GLTexture:
-      return CreateGLTexture(size, format, GL_TEXTURE_POOL_MANAGED_CHROMIUM,
-                             wrap_mode, hint);
+      return CreateGLTexture(size,
+                             GL_TEXTURE_POOL_MANAGED_CHROMIUM,
+                             wrap_mode,
+                             hint,
+                             texture_format);
     case Bitmap:
-      DCHECK(format == GL_RGBA);
+      DCHECK(texture_format == RGBA_8888);
       return CreateBitmap(size);
     case InvalidType:
       break;
   }
 
   LOG(FATAL) << "Invalid default resource type.";
   return 0;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateGLTexture(
     gfx::Size size,
-    GLenum format,
     GLenum texture_pool,
     GLint wrap_mode,
-    TextureUsageHint hint) {
+    TextureUsageHint hint,
+    Format texture_format) {
   DCHECK_LE(size.width(), max_texture_size_);
   DCHECK_LE(size.height(), max_texture_size_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   ResourceId id = next_id_++;
-  Resource resource(0, size, format, GL_LINEAR, texture_pool, wrap_mode, hint);
+  Resource resource(
+      0, size, GL_LINEAR, texture_pool, wrap_mode, hint, texture_format);
   resource.allocated = false;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateBitmap(gfx::Size size) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   uint8_t* pixels = new uint8_t[4 * size.GetArea()];
 
   ResourceId id = next_id_++;
-  Resource resource(pixels, size, GL_RGBA, GL_LINEAR, GL_CLAMP_TO_EDGE);
+  Resource resource(pixels, size, GL_LINEAR, GL_CLAMP_TO_EDGE);
   resource.allocated = true;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId
 ResourceProvider::CreateResourceFromExternalTexture(
     unsigned texture_target,
     unsigned texture_id) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   WebGraphicsContext3D* context3d = Context3d();
   DCHECK(context3d);
   GLC(context3d, context3d->bindTexture(texture_target, texture_id));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_MAG_FILTER, GL_LINEAR));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
   GLC(context3d, context3d->texParameteri(
       texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
 
   ResourceId id = next_id_++;
-  Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR, 0, GL_CLAMP_TO_EDGE,
-                    TextureUsageAny);
+  Resource resource(texture_id,
+                    gfx::Size(),
+                    GL_LINEAR,
+                    0,
+                    GL_CLAMP_TO_EDGE,
+                    TextureUsageAny,
+                    RGBA_8888);
   resource.external = true;
   resource.allocated = true;
   resources_[id] = resource;
   return id;
 }
 
 ResourceProvider::ResourceId ResourceProvider::CreateResourceFromTextureMailbox(
     const TextureMailbox& mailbox) {
   DCHECK(thread_checker_.CalledOnValidThread());
   // Just store the information. Mailbox will be consumed in LockForRead().
   ResourceId id = next_id_++;
   DCHECK(mailbox.IsValid());
   Resource& resource = resources_[id];
   if (mailbox.IsTexture()) {
-    resource = Resource(0, gfx::Size(), 0, GL_LINEAR, 0, GL_CLAMP_TO_EDGE,
-                        TextureUsageAny);
+    resource = Resource(0,
+                        gfx::Size(),
+                        GL_LINEAR,
+                        0,
+                        GL_CLAMP_TO_EDGE,
+                        TextureUsageAny,
+                        RGBA_8888);
   } else {
     DCHECK(mailbox.IsSharedMemory());
     base::SharedMemory* shared_memory = mailbox.shared_memory();
     DCHECK(shared_memory->memory());
     uint8_t* pixels = reinterpret_cast<uint8_t*>(shared_memory->memory());
-    resource = Resource(pixels, mailbox.shared_memory_size(),
-                        GL_RGBA, GL_LINEAR, GL_CLAMP_TO_EDGE);
+    resource = Resource(
+        pixels, mailbox.shared_memory_size(), GL_LINEAR, GL_CLAMP_TO_EDGE);
   }
   resource.external = true;
   resource.allocated = true;
   resource.mailbox = mailbox;
   return id;
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
@@ skipping 90 matching lines @@
   if (resource->gl_id) {
     DCHECK(!resource->pending_set_pixels);
     WebGraphicsContext3D* context3d = Context3d();
     DCHECK(context3d);
     DCHECK(texture_uploader_.get());
     context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id);
     texture_uploader_->Upload(image,
                               image_rect,
                               source_rect,
                               dest_offset,
-                              resource->format,
+                              resource->texture_format,
                               resource->size);
   }
 
   if (resource->pixels) {
     DCHECK(resource->allocated);
-    DCHECK(resource->format == GL_RGBA);
+    DCHECK(resource->texture_format == RGBA_8888);
     SkBitmap src_full;
     src_full.setConfig(
         SkBitmap::kARGB_8888_Config, image_rect.width(), image_rect.height());
     src_full.setPixels(const_cast<uint8_t*>(image));
     SkBitmap src_subset;
     SkIRect sk_source_rect = SkIRect::MakeXYWH(source_rect.x(),
                                                source_rect.y(),
                                                source_rect.width(),
                                                source_rect.height());
     sk_source_rect.offset(-image_rect.x(), -image_rect.y());
@@ skipping 203 matching lines @@
   DCHECK(texture_id_);
 }
 
 ResourceProvider::ScopedWriteLockGL::~ScopedWriteLockGL() {
   resource_provider_->UnlockForWrite(resource_id_);
 }
 
 void ResourceProvider::PopulateSkBitmapWithResource(
     SkBitmap* sk_bitmap, const Resource* resource) {
   DCHECK(resource->pixels);
-  DCHECK(resource->format == GL_RGBA);
+  DCHECK(resource->texture_format == RGBA_8888);
   sk_bitmap->setConfig(SkBitmap::kARGB_8888_Config,
                        resource->size.width(),
                        resource->size.height());
   sk_bitmap->setPixels(resource->pixels);
 }
 
 ResourceProvider::ScopedReadLockSoftware::ScopedReadLockSoftware(
     ResourceProvider* resource_provider,
     ResourceProvider::ResourceId resource_id)
     : resource_provider_(resource_provider),
@@ skipping 25 matching lines @@
     : output_surface_(output_surface),
       lost_output_surface_(false),
       highp_threshold_min_(highp_threshold_min),
       next_id_(1),
       next_child_(1),
       default_resource_type_(InvalidType),
       use_texture_storage_ext_(false),
       use_texture_usage_hint_(false),
       use_shallow_flush_(false),
       max_texture_size_(0),
-      best_texture_format_(0) {
+      best_texture_format_(RGBA_8888) {
   DCHECK(output_surface_->HasClient());
 }
 
 void ResourceProvider::InitializeSoftware() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_NE(Bitmap, default_resource_type_);
 
   CleanUpGLIfNeeded();
 
   default_resource_type_ = Bitmap;
   max_texture_size_ = INT_MAX / 2;
-  best_texture_format_ = GL_RGBA;
+  best_texture_format_ = RGBA_8888;
 }
 
 bool ResourceProvider::InitializeGL() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(!texture_uploader_);
   DCHECK_NE(GLTexture, default_resource_type_);
 
   WebGraphicsContext3D* context3d = Context3d();
   DCHECK(context3d);
 
   if (!context3d->makeContextCurrent())
     return false;
 
   default_resource_type_ = GLTexture;
 
   const ContextProvider::Capabilities& caps =
       output_surface_->context_provider()->ContextCapabilities();
 
   bool use_map_sub = caps.map_sub;
   bool use_bgra = caps.texture_format_bgra8888;
   use_texture_storage_ext_ = caps.texture_storage;
   use_shallow_flush_ = caps.shallow_flush;
   use_texture_usage_hint_ = caps.texture_usage;
 
   texture_uploader_ =
-      TextureUploader::Create(context3d, use_map_sub, use_shallow_flush_);
+      TextureUploader::Create(context3d,
+                              use_map_sub,
+                              use_shallow_flush_);
   GLC(context3d, context3d->getIntegerv(GL_MAX_TEXTURE_SIZE,
                                         &max_texture_size_));
   best_texture_format_ = PlatformColor::BestTextureFormat(use_bgra);
 
   return true;
 }
 
 void ResourceProvider::CleanUpGLIfNeeded() {
   WebGraphicsContext3D* context3d = Context3d();
   if (default_resource_type_ != GLTexture) {
@@ skipping 142 matching lines @@
     // deadlocks and/or security issues. The caller is responsible for
     // waiting asynchronously, and resetting sync_point before calling this.
     // However if the parent is a renderer (e.g. browser tag), it may be ok
     // (and is simpler) to wait.
     if (it->sync_point)
       GLC(context3d, context3d->waitSyncPoint(it->sync_point));
     GLC(context3d, texture_id = context3d->createTexture());
     GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, texture_id));
     GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D,
                                                      it->mailbox.name));
+    Format format = RGBA_8888;
+    switch (it->format) {
+      case 0:

[enne (OOO), 2013/09/13 01:39:44]

If somebody switched the enum order, this would break.  Can you make this case
RGBA_8888: format = RGBA_8888, etc?

Alternatively, why not just static cast and DCHECK?

[kaanb, 2013/09/13 03:43:56]

reveman@ didn't like the static_cast

[enne (OOO), 2013/09/13 03:53:25]

I think static_cast + CHECK would be the cleanest, but I think even just using
enum values in each case statement would be an improvement over literals.

[reveman, 2013/09/13 14:59:48]

yes, it's the CHECK I want and I think a switch statement is the cleanest way to
do that at the moment.

[kaanb, 2013/09/13 19:57:39]

Done.

+        format = RGBA_8888;
+        break;
+      case 1:
+        format = RGBA_4444;
+        break;
+      case 2:
+        format = BGRA_8888;
+        break;
+      case 3:
+        format = LUMINANCE_8;
+        break;
+    }

[piman, 2013/09/13 01:42:01]

Why not make TransferableResource use ResourceProvider::Format?

[kaanb, 2013/09/13 03:43:56]

It looks like TransferableResource is part of an IPC message and compilation
fails when I make TransferableResource use ResourceProvider::Format

[piman, 2013/09/13 04:56:51]

Sure, so, we should fix that.
Enums are fine to pass over IPC, you just need to declare them using
IPC_ENUM_TRAITS (see other instances in cc_messages.h).
It still needs to be checked on the receiving side (for security), but at least
you don't need a switch.

[reveman, 2013/09/13 14:32:49]

What's the proper way to check that enum values are valid? Ideally we'd have an
enum_cast<Format>() impl that checks against min/max enum values but I think
that would require something like this to be done cleanly:
https://codereview.chromium.org/22911037/

Instead of the above, I was thinking something like this:

Format format = RGBA_8888;
switch (it->format) {
  case RGBA_8888:
  case RGBA_4444:
  case BGRA_8888:
  case LUMINANCE_8:
    format = static_cast<Format>(it->format);
    break;
  default:
    NOTREACHED();
}

[kaanb, 2013/09/13 19:57:39]

I implemented reveman's suggestion for now. When change the type of the format
field to ResourceProvider::Format I get the following error:
../../cc/resources/transferable_resource.h:33:3: error: 'ResourceProvider' does
not name a type

possibly because of the circular dependency? (i.e. resource_provider.h includes
transferable_resource.h and to add the enum field I need to include
resource_provider.h from transferable_resource.h)

+
     ResourceId id = next_id_++;
     Resource resource(
-        texture_id, it->size, it->format, it->filter, 0, GL_CLAMP_TO_EDGE,
-        TextureUsageAny);
+        texture_id,
+        it->size,
+        it->filter,
+        0,
+        GL_CLAMP_TO_EDGE,
+        TextureUsageAny,
+        format);
     resource.mailbox.SetName(it->mailbox);
     // Don't allocate a texture for a child.
     resource.allocated = true;
     resource.imported_count = 1;
     resources_[id] = resource;
     child_info.parent_to_child_map[id] = it->id;
     child_info.child_to_parent_map[it->id] = id;
   }
 }
 
@@ skipping 31 matching lines @@
 
 void ResourceProvider::TransferResource(WebGraphicsContext3D* context,
                                         ResourceId id,
                                         TransferableResource* resource) {
   Resource* source = GetResource(id);
   DCHECK(!source->locked_for_write);
   DCHECK(!source->lock_for_read_count);
   DCHECK(!source->external || (source->external && source->mailbox.IsValid()));
   DCHECK(source->allocated);
   resource->id = id;
-  resource->format = source->format;
   resource->filter = source->filter;
   resource->size = source->size;
+  resource->format = source->texture_format;
 
   // TODO(skaslev) Implement this path for shared memory resources.
   DCHECK(!source->mailbox.IsSharedMemory());
 
   if (!source->mailbox.IsTexture()) {
     // This is a resource allocated by the compositor, we need to produce it.
     // Don't set a sync point, the caller will do it.
     DCHECK(source->gl_id);
     GLC(context, context->bindTexture(GL_TEXTURE_2D, source->gl_id));
     GLC(context, context->genMailboxCHROMIUM(resource->mailbox.name));
@@ skipping 16 matching lines @@
   DCHECK(!resource->image_id);
 
   if (resource->type == GLTexture) {
     WebGraphicsContext3D* context3d = Context3d();
     DCHECK(context3d);
     if (!resource->gl_pixel_buffer_id)
       resource->gl_pixel_buffer_id = context3d->createBuffer();
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->gl_pixel_buffer_id);
+    size_t bytes_per_pixel = BytesPerPixel(resource->texture_format);
     context3d->bufferData(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
-        4 * resource->size.GetArea(),
+        bytes_per_pixel * resource->size.GetArea(),
         NULL,
         GL_DYNAMIC_DRAW);
     context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   }
 
   if (resource->pixels) {
     if (resource->pixel_buffer)
       return;
 
     resource->pixel_buffer = new uint8_t[4 * resource->size.GetArea()];
@@ skipping 150 matching lines @@
     DCHECK(resource->gl_pixel_buffer_id);
     context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id);
     context3d->bindBuffer(
         GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM,
         resource->gl_pixel_buffer_id);
     if (!resource->gl_upload_query_id)
       resource->gl_upload_query_id = context3d->createQueryEXT();
     context3d->beginQueryEXT(
         GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM,
         resource->gl_upload_query_id);
+    DCHECK(resource->texture_format != RGBA_4444 ||
+           (resource->size.width() % 2) == 0);
     if (allocate) {
-      context3d->asyncTexImage2DCHROMIUM(GL_TEXTURE_2D,
-                                         0, /* level */
-                                         resource->format,
-                                         resource->size.width(),
-                                         resource->size.height(),
-                                         0, /* border */
-                                         resource->format,
-                                         GL_UNSIGNED_BYTE,
-                                         NULL);
+      context3d->asyncTexImage2DCHROMIUM(
+          GL_TEXTURE_2D,
+          0, /* level */
+          GetGLInternalFormat(resource->texture_format),
+          resource->size.width(),
+          resource->size.height(),
+          0, /* border */
+          GetGLDataFormat(resource->texture_format),
+          GetGLDataType(resource->texture_format),
+          NULL);
     } else {
-      context3d->asyncTexSubImage2DCHROMIUM(GL_TEXTURE_2D,
-                                            0, /* level */
-                                            0, /* x */
-                                            0, /* y */
-                                            resource->size.width(),
-                                            resource->size.height(),
-                                            resource->format,
-                                            GL_UNSIGNED_BYTE,
-                                            NULL);
+      context3d->asyncTexSubImage2DCHROMIUM(
+          GL_TEXTURE_2D,
+          0, /* level */
+          0, /* x */
+          0, /* y */
+          resource->size.width(),
+          resource->size.height(),
+          GetGLDataFormat(resource->texture_format),
+          GetGLDataType(resource->texture_format),
+          NULL);
     }
     context3d->endQueryEXT(GL_ASYNC_PIXEL_UNPACK_COMPLETED_CHROMIUM);
     context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   }
 
   if (resource->pixels) {
     DCHECK(!resource->mailbox.IsValid());
     DCHECK(resource->pixel_buffer);
-    DCHECK(resource->format == GL_RGBA);
+    DCHECK(resource->texture_format == RGBA_8888);
 
     std::swap(resource->pixels, resource->pixel_buffer);
     delete[] resource->pixel_buffer;
     resource->pixel_buffer = NULL;
   }
 
   resource->pending_set_pixels = true;
   resource->set_pixels_completion_forced = false;
 }
 
@@ skipping 85 matching lines @@
 void ResourceProvider::LazyAllocate(Resource* resource) {
   DCHECK(resource);
   LazyCreate(resource);
 
   DCHECK(resource->gl_id || resource->allocated);
   if (resource->allocated || !resource->gl_id)
     return;
   resource->allocated = true;
   WebGraphicsContext3D* context3d = Context3d();
   gfx::Size& size = resource->size;
-  GLenum format = resource->format;
+  Format format = resource->texture_format;
   GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id));
-  if (use_texture_storage_ext_ && IsTextureFormatSupportedForStorage(format)) {
+  if (use_texture_storage_ext_ && IsFormatSupportedForStorage(format)) {
     GLenum storage_format = TextureToStorageFormat(format);
     GLC(context3d, context3d->texStorage2DEXT(GL_TEXTURE_2D,
                                               1,
                                               storage_format,
                                               size.width(),
                                               size.height()));
   } else {
     GLC(context3d, context3d->texImage2D(GL_TEXTURE_2D,
                                          0,
-                                         format,
+                                         GetGLInternalFormat(format),
                                          size.width(),
                                          size.height(),
                                          0,
-                                         format,
-                                         GL_UNSIGNED_BYTE,
+                                         GetGLDataFormat(format),
+                                         GetGLDataType(format),
                                          NULL));
   }
 }
 
 void ResourceProvider::EnableReadLockFences(ResourceProvider::ResourceId id,
                                             bool enable) {
   Resource* resource = GetResource(id);
   resource->enable_read_lock_fences = enable;
 }
 
 void ResourceProvider::AcquireImage(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
 
   if (resource->type != GLTexture)
     return;
 
   if (resource->image_id)
     return;
 
   resource->allocated = true;
   WebGraphicsContext3D* context3d = Context3d();
   DCHECK(context3d);
-  DCHECK_EQ(static_cast<GLenum>(GL_RGBA), resource->format);
+  DCHECK_EQ(RGBA_8888, resource->texture_format);
   resource->image_id = context3d->createImageCHROMIUM(
       resource->size.width(), resource->size.height(), GL_RGBA8_OES);
   DCHECK(resource->image_id);
 }
 
 void ResourceProvider::ReleaseImage(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
 
@@ skipping 59 matching lines @@
   GLint active_unit = 0;
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 WebKit::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
+size_t ResourceProvider::BytesPerPixel(Format format) {
+  size_t components_per_pixel = 0;
+  switch (format) {
+    case RGBA_8888:
+    case RGBA_4444:
+    case BGRA_8888:
+      components_per_pixel = 4;
+      break;
+    case LUMINANCE_8:
+      components_per_pixel = 1;
+      break;
+  }
+  size_t bits_per_component = 0;
+  switch (format) {
+    case RGBA_8888:
+    case BGRA_8888:
+    case LUMINANCE_8:
+      bits_per_component = 8;
+      break;
+    case RGBA_4444:
+      bits_per_component = 4;
+      break;
+  }
+  const size_t kBitsPerByte = 8;
+  return (components_per_pixel * bits_per_component) / kBitsPerByte;
+}
+
+GLenum ResourceProvider::GetGLDataType(Format format) {
+  GLenum texture_data_type = GL_UNSIGNED_BYTE;
+  switch (format) {
+    case RGBA_4444:
+      texture_data_type = GL_UNSIGNED_SHORT_4_4_4_4;

[reveman, 2013/09/13 14:32:49]

nit: I'd remove the temporary variable and just "return
GL_UNSIGNED_SHORT_4_4_4_4;" here and in functions below.

[kaanb, 2013/09/13 19:57:39]

Done.

+      break;
+    case RGBA_8888:
+    case BGRA_8888:
+    case LUMINANCE_8:
+      texture_data_type = GL_UNSIGNED_BYTE;
+      break;
+  }
+  return texture_data_type;
+}
+
+GLenum ResourceProvider::GetGLDataFormat(Format format) {
+  GLenum data_format = GL_RGBA;
+  switch (format) {
+    case RGBA_8888:
+    case RGBA_4444:
+      data_format = GL_RGBA;
+      break;
+    case BGRA_8888:
+      data_format = GL_BGRA_EXT;
+      break;
+    case LUMINANCE_8:
+      data_format = GL_LUMINANCE;
+      break;
+  }
+  return data_format;
+}
+
+GLenum ResourceProvider::GetGLInternalFormat(Format format) {
+  return GetGLDataFormat(format);
+}
+
+unsigned ResourceProvider::GetStride(Format format) {
+  unsigned stride = 4;
+  switch (format) {
+    case RGBA_4444:
+      stride = 2;
+      break;
+    case RGBA_8888:
+    case BGRA_8888:
+    case LUMINANCE_8:
+      stride = 4;
+      break;
+  }
+  return stride;
+}
+
 }  // namespace cc