[Aura] Added Support for rendering software compositor frames as cc::TextureLayers.

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/debug/alias.h"
@@ skipping 65 matching lines @@
       locked_for_write(false),
       external(false),
       exported(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(),
+      shared_memory(NULL),
       format(0),
       filter(0),
       image_id(0),
       type(static_cast<ResourceType>(0)) {}
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(
     unsigned texture_id, gfx::Size size, GLenum format, GLenum filter)
     : gl_id(texture_id),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(NULL),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       locked_for_write(false),
       external(false),
       exported(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),
+      shared_memory(NULL),
       format(format),
       filter(filter),
       image_id(0),
       type(GLTexture) {}
 
 ResourceProvider::Resource::Resource(
     uint8_t* pixels, gfx::Size size, GLenum format, GLenum filter)
     : gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(pixels),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       locked_for_write(false),
       external(false),
       exported(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),
+      shared_memory(NULL),
       format(format),
       filter(filter),
       image_id(0),
       type(Bitmap) {}
 
 ResourceProvider::Child::Child() {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
@@ skipping 125 matching lines @@
   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_++;
-  unsigned texture_id = 0;
-  Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR);
-  resource.external = true;
-  resource.allocated = true;
-  resource.mailbox = mailbox;
-  resources_[id] = resource;
+  if (mailbox.IsTexture()) {

[piman, 2013/05/28 20:58:57]

nit: I think we should DCHECK that the mailbox IsValid() and then if it's not a
texture DCHECK that mailbox.IsSharedMemory()
I don't think we should allow giving the RP an invalid resource, I suspect bad
things will happen in other places.

[slavi, 2013/05/29 18:31:48]

Done.

+    unsigned texture_id = 0;
+    Resource resource(texture_id, gfx::Size(), 0, GL_LINEAR);
+    resource.external = true;
+    resource.allocated = true;
+    resource.mailbox = mailbox;
+    resources_[id] = resource;
+  } else if (mailbox.IsSharedMemory()) {
+    uint8_t *pixels = NULL;
+    Resource resource(pixels, mailbox.size(), 0, GL_LINEAR);
+    resource.external = true;
+    resource.allocated = true;
+    resource.mailbox = mailbox;
+    resources_[id] = resource;
+  }
   return id;
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->lock_for_read_count);
   DCHECK(!resource->marked_for_deletion);
@@ skipping 30 matching lines @@
   if (resource->gl_upload_query_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     GLC(context3d, context3d->deleteQueryEXT(resource->gl_upload_query_id));
   }
   if (resource->gl_pixel_buffer_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     GLC(context3d, context3d->deleteBuffer(resource->gl_pixel_buffer_id));
   }
-  if (!resource->mailbox.IsEmpty() && resource->external) {
-    WebGraphicsContext3D* context3d = output_surface_->context3d();
-    DCHECK(context3d);
+  if (resource->mailbox.IsValid() && resource->external) {
     unsigned sync_point = resource->mailbox.sync_point();
-    if (!lost_resource && resource->gl_id) {
-      GLC(context3d, context3d->bindTexture(
-          resource->mailbox.target(), resource->gl_id));
-      GLC(context3d, context3d->produceTextureCHROMIUM(
-          resource->mailbox.target(), resource->mailbox.data()));
+    if (resource->mailbox.IsTexture()) {
+      WebGraphicsContext3D* context3d = output_surface_->context3d();
+      DCHECK(context3d);
+      if (!lost_resource && resource->gl_id) {
+        GLC(context3d, context3d->bindTexture(
+            resource->mailbox.target(), resource->gl_id));
+        GLC(context3d, context3d->produceTextureCHROMIUM(
+            resource->mailbox.target(), resource->mailbox.data()));
+      }
+      if (resource->gl_id)
+        GLC(context3d, context3d->deleteTexture(resource->gl_id));
+      if (!lost_resource && resource->gl_id)
+        sync_point = context3d->insertSyncPoint();
+    } else {
+      DCHECK(resource->mailbox.IsSharedMemory());
+      if (resource->shared_memory) {
+        DCHECK(resource->shared_memory->memory() == resource->pixels);
+        delete resource->shared_memory;
+        resource->shared_memory = NULL;
+        resource->pixels = NULL;
+      }
     }
-    if (resource->gl_id)
-      GLC(context3d, context3d->deleteTexture(resource->gl_id));
-    if (!lost_resource && resource->gl_id)
-      sync_point = context3d->insertSyncPoint();
     resource->mailbox.RunReleaseCallback(sync_point, lost_resource);
   }
   if (resource->pixels)
     delete[] resource->pixels;
   if (resource->pixel_buffer)
     delete[] resource->pixel_buffer;
 
   resources_.erase(it);
 }
 
@@ skipping 121 matching lines @@
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(!resource->locked_for_write ||
          resource->set_pixels_completion_forced) <<
       "locked for write: " << resource->locked_for_write <<
       " pixels completion forced: " << resource->set_pixels_completion_forced;
   DCHECK(!resource->exported);
   // Uninitialized! Call SetPixels or LockForWrite first.
   DCHECK(resource->allocated);
 
-  if (!resource->gl_id && resource->external && !resource->mailbox.IsEmpty()) {
-    WebGraphicsContext3D* context3d = output_surface_->context3d();
-    DCHECK(context3d);
-    if (resource->mailbox.sync_point()) {
-      GLC(context3d, context3d->waitSyncPoint(resource->mailbox.sync_point()));
-      resource->mailbox.ResetSyncPoint();
+  if (resource->external) {
+    if (!resource->gl_id && resource->mailbox.IsTexture()) {
+      WebGraphicsContext3D* context3d = output_surface_->context3d();
+      DCHECK(context3d);
+      if (resource->mailbox.sync_point()) {
+        GLC(context3d,
+            context3d->waitSyncPoint(resource->mailbox.sync_point()));
+        resource->mailbox.ResetSyncPoint();
+      }
+      resource->gl_id = context3d->createTexture();
+      GLC(context3d, context3d->bindTexture(
+          resource->mailbox.target(), resource->gl_id));
+      GLC(context3d, context3d->consumeTextureCHROMIUM(
+          resource->mailbox.target(), resource->mailbox.data()));
+    } else if (!resource->shared_memory && resource->mailbox.IsSharedMemory()) {
+      CHECK(!resource->pixels);
+      resource->size = resource->mailbox.size();
+      resource->shared_memory = new base::SharedMemory(
+          resource->mailbox.handle(), false);
+      const size_t size = 4 * resource->size.GetArea();
+      bool success = resource->shared_memory->Map(size);
+      CHECK(success);
+      resource->format = GL_RGBA;
+      resource->pixels =
+          reinterpret_cast<uint8_t*>(resource->shared_memory->memory());
     }
-    resource->gl_id = context3d->createTexture();
-    GLC(context3d, context3d->bindTexture(
-        resource->mailbox.target(), resource->gl_id));
-    GLC(context3d, context3d->consumeTextureCHROMIUM(
-        resource->mailbox.target(), resource->mailbox.data()));
   }
 
   resource->lock_for_read_count++;
   if (resource->enable_read_lock_fences)
     resource->read_lock_fence = current_read_lock_fence_;
 
   return resource;
 }
 
 void ResourceProvider::UnlockForRead(ResourceId id) {
@@ skipping 321 matching lines @@
   }
   for (TransferableResourceArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
     ResourceMap::iterator map_iterator = resources_.find(it->id);
     DCHECK(map_iterator != resources_.end());
     Resource* resource = &map_iterator->second;
     DCHECK(resource->exported);
     resource->exported = false;
     resource->filter = it->filter;
-    DCHECK(resource->mailbox.Equals(it->mailbox));
+    DCHECK(resource->mailbox.Contains(it->mailbox));
     if (resource->gl_id) {
       if (it->sync_point)
         GLC(context3d, context3d->waitSyncPoint(it->sync_point));
       GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id));
       GLC(context3d, context3d->consumeTextureCHROMIUM(GL_TEXTURE_2D,
                                                        it->mailbox.name));
     } else {
       resource->mailbox = TextureMailbox(resource->mailbox.name(),
                                          resource->mailbox.callback(),
                                          it->sync_point);
     }
     if (resource->marked_for_deletion)
       DeleteResourceInternal(map_iterator, Normal);
   }
 }
 
 bool ResourceProvider::TransferResource(WebGraphicsContext3D* context,
                                         ResourceId id,
                                         TransferableResource* resource) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* source = &it->second;
   DCHECK(!source->locked_for_write);
   DCHECK(!source->lock_for_read_count);
-  DCHECK(!source->external || (source->external && !source->mailbox.IsEmpty()));
+  DCHECK(!source->external || (source->external && source->mailbox.IsValid()));
   DCHECK(source->allocated);
   if (source->exported)
     return false;
   resource->id = id;
   resource->format = source->format;
   resource->filter = source->filter;
   resource->size = source->size;
 
-  if (source->mailbox.IsEmpty()) {
+  // TODO(skaslev) Implement this path for shared memory resources.

[piman, 2013/05/28 20:58:57]

This needs to be at least a DCHECK or something. Right now, it would fall into
the !source->mailbox.IsTexture() path and crash on a NULL context3d or
something. Better to be explicit about it upfront - and the test right below
would be less confusing.

[slavi, 2013/05/29 18:31:48]

Done.

+  if (!source->mailbox.IsTexture()) {
     GLC(context3d, context3d->genMailboxCHROMIUM(resource->mailbox.name));
     source->mailbox.SetName(resource->mailbox);
   } else {
     resource->mailbox = source->mailbox.name();
   }
 
   if (source->gl_id) {
     GLC(context, context->bindTexture(GL_TEXTURE_2D, source->gl_id));
     GLC(context, context->produceTextureCHROMIUM(GL_TEXTURE_2D,
                                                  resource->mailbox.name));
@@ skipping 477 matching lines @@
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   DCHECK(context3d);
   int stride = 0;
   context3d->getImageParameterivCHROMIUM(
       resource->image_id, GL_IMAGE_ROWBYTES_CHROMIUM, &stride);
   return stride;
 }
 
 
 }  // namespace cc