gpu: Refactor GpuMemoryBuffer framework for multi-process support.

ui/gl/gl_image_shm.cc

 // Copyright (c) 2013 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 "ui/gl/gl_image_shm.h"
 
 #include "base/debug/trace_event.h"
 #include "base/process/process_handle.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gfx {
 
-GLImageShm::GLImageShm(gfx::Size size) : size_(size) {
+GLImageShm::GLImageShm(const gfx::Size& size, unsigned internalformat)
+    : size_(size),
+      internalformat_(internalformat) {
 }
 
 GLImageShm::~GLImageShm() {
   Destroy();
 }
 
 bool GLImageShm::Initialize(gfx::GpuMemoryBufferHandle buffer) {
   if (!base::SharedMemory::IsHandleValid(buffer.handle))
     return false;
 
   base::SharedMemory shared_memory(buffer.handle, true);
 
   // Duplicate the handle.
   base::SharedMemoryHandle duped_shared_memory_handle;
   if (!shared_memory.ShareToProcess(base::GetCurrentProcessHandle(),
                                     &duped_shared_memory_handle)) {
     DVLOG(0) << "Failed to duplicate shared memory handle.";
     return false;
   }
 
   shared_memory_.reset(
       new base::SharedMemory(duped_shared_memory_handle, true));
   return true;
 }
 
 bool GLImageShm::BindTexImage() {
   TRACE_EVENT0("gpu", "GLImageShm::BindTexImage");
   DCHECK(shared_memory_);
 
-  const int kBytesPerPixel = 4;
-  size_t size = size_.GetArea() * kBytesPerPixel;
+  GLenum format;
+  GLenum type;
+  int bytes_per_pixel;
+  switch (internalformat_) {
+    case GL_RGBA:
+      format = GL_RGBA;
+      type = GL_UNSIGNED_BYTE;
+      bytes_per_pixel = 4;
+      break;
+    case GL_BGRA_EXT:
+      format = GL_BGRA_EXT;
+      type = GL_UNSIGNED_BYTE;
+      bytes_per_pixel = 4;
+      break;
+    default:
+      NOTREACHED();

[piman, 2013/08/01 21:19:30]

nit: this comes from the (untrusted) client side. While we don't expose this
cross-process yet, I'm pretty sure we won't go back and audit everything. So I'm
not sure NOTREACHED() is really what we want (false sense of security etc.),
though we can certainly DVLOG.

[reveman, 2013/08/08 23:19:00]

Good point. Fixed in latest patch.

+      return false;
+  }
+
+  size_t size = size_.GetArea() * bytes_per_pixel;
   DCHECK(!shared_memory_->memory());
   if (!shared_memory_->Map(size)) {
     DVLOG(0) << "Failed to map shared memory.";
     return false;
   }
 
   DCHECK(shared_memory_->memory());
   glTexImage2D(GL_TEXTURE_2D,
                0,  // mip level
-               GL_RGBA,
+               internalformat_,
                size_.width(),
                size_.height(),
                0,  // border
-               GL_RGBA,
-               GL_UNSIGNED_BYTE,
+               format,
+               type,
                shared_memory_->memory());
 
   shared_memory_->Unmap();
   return true;
 }
 
 gfx::Size GLImageShm::GetSize() {
   return size_;
 }
 
 void GLImageShm::Destroy() {
 }
 
 void GLImageShm::ReleaseTexImage() {
 }
 
 }  // namespace gfx