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)),
+      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 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),
+      format(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),
+      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));

[reveman, 2013/09/13 20:24:31]

nit: looks like this fits on one line

[kaanb, 2013/09/13 22:35:23]

Done.

 
   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 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,
+                             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_EQ(RGBA_8888, format);
       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 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,
+                             format);
     case Bitmap:
-      DCHECK(format == GL_RGBA);
+      DCHECK_EQ(RGBA_8888, format);
       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 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, 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 96 matching lines @@
     texture_uploader_->Upload(image,
                               image_rect,
                               source_rect,
                               dest_offset,
                               resource->format,
                               resource->size);
   }
 
   if (resource->pixels) {
     DCHECK(resource->allocated);
-    DCHECK(resource->format == GL_RGBA);
+    DCHECK_EQ(RGBA_8888, resource->format);
     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_EQ(RGBA_8888, resource->format);
   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));
+    // TODO(kaanb): change TransferableResource to use the Format enum.
+    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();

[reveman, 2013/09/13 20:24:31]

As piman already pointed out, we can't use NOTREACHED here if this is the place
where we check the validity of the format value. Just removing this default case
and using RGBA_8888 for invalid values might be fine. 

[kaanb, 2013/09/13 22:35:23]

We don't need the switch statement anymore as TransferableResource uses the
ResourceFormat enum.

+    }
+
     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->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->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->format != RGBA_4444 ||

[reveman, 2013/09/13 20:24:31]

Can we avoid this format specific check? Shouldn't "(resource->size.width() % 2)
== 0" be true for all formats?

[kaanb, 2013/09/13 22:35:23]

There are unittests that upload 13x13 textures in RGBA format. That being said,
as far as I remember those tests were testing TextureUploader, I copied the
check from TextureUploader to here for consistency.

+           (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->format),
+          resource->size.width(),
+          resource->size.height(),
+          0, /* border */
+          GetGLDataFormat(resource->format),
+          GetGLDataType(resource->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->format),
+          GetGLDataType(resource->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_EQ(RGBA_8888, resource->format);
 
     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->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->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) {
+  switch (format) {
+    case RGBA_4444:
+      return GL_UNSIGNED_SHORT_4_4_4_4;
+    case RGBA_8888:
+    case BGRA_8888:
+    case LUMINANCE_8:
+      return GL_UNSIGNED_BYTE;
+  }
+  return GL_UNSIGNED_BYTE;

[reveman, 2013/09/13 20:24:31]

I think you can add a NOTREACHED() above this line.

[kaanb, 2013/09/13 22:35:23]

Done.

+}
+
+GLenum ResourceProvider::GetGLDataFormat(Format format) {
+  switch (format) {
+    case RGBA_8888:
+    case RGBA_4444:
+      return GL_RGBA;
+    case BGRA_8888:
+      return GL_BGRA_EXT;
+    case LUMINANCE_8:
+      return GL_LUMINANCE;
+  }
+  return GL_RGBA;

[reveman, 2013/09/13 20:24:31]

and NOTREACHED() here too.

[kaanb, 2013/09/13 22:35:23]

Done.

+}
+
+GLenum ResourceProvider::GetGLInternalFormat(Format format) {
+  return GetGLDataFormat(format);
+}
+
 }  // namespace cc