Add gpu::MailboxHolder to hold state for a gpu::Mailbox

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 526 matching lines @@
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DeleteQueriesEXT(1, &resource->gl_upload_query_id));
   }
   if (resource->gl_pixel_buffer_id) {
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     GLC(gl, gl->DeleteBuffers(1, &resource->gl_pixel_buffer_id));
   }
   if (resource->mailbox.IsValid() && resource->external) {
-    GLuint sync_point = resource->mailbox.sync_point();
+    uint32 sync_point = resource->mailbox.sync_point();
     if (resource->mailbox.IsTexture()) {
       lost_resource |= lost_output_surface_;
       GLES2Interface* gl = ContextGL();
       DCHECK(gl);
       if (resource->gl_id)
         GLC(gl, gl->DeleteTextures(1, &resource->gl_id));
       if (!lost_resource && resource->gl_id)
         sync_point = gl->InsertSyncPointCHROMIUM();
     } else {
       DCHECK(resource->mailbox.IsSharedMemory());
@@ skipping 174 matching lines @@
   DCHECK(resource->allocated);
 
   LazyCreate(resource);
 
   if (resource->external) {
     if (!resource->gl_id && resource->mailbox.IsTexture()) {
       GLES2Interface* gl = ContextGL();
       DCHECK(gl);
       if (resource->mailbox.sync_point()) {
         GLC(gl, gl->WaitSyncPointCHROMIUM(resource->mailbox.sync_point()));
-        resource->mailbox.ResetSyncPoint();
+        resource->mailbox.set_sync_point(0);
       }
       resource->gl_id = texture_id_allocator_->NextId();
       GLC(gl, gl->BindTexture(resource->target, resource->gl_id));
       GLC(gl,
           gl->ConsumeTextureCHROMIUM(resource->target,
-                                     resource->mailbox.data()));
+                                     resource->mailbox.name()));
     }
   }
 
   resource->lock_for_read_count++;
   if (resource->enable_read_lock_fences)
     resource->read_lock_fence = current_read_lock_fence_;
 
   return resource;
 }
 
@@ skipping 255 matching lines @@
 void ResourceProvider::PrepareSendToParent(const ResourceIdArray& resources,
                                            TransferableResourceArray* list) {
   DCHECK(thread_checker_.CalledOnValidThread());
   GLES2Interface* gl = ContextGL();
   bool need_sync_point = false;
   for (ResourceIdArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
     TransferableResource resource;
     TransferResource(gl, *it, &resource);
-    if (!resource.sync_point && !resource.is_software)
+    if (!resource.mailbox_holder.sync_point && !resource.is_software)
       need_sync_point = true;
     ++resources_.find(*it)->second.exported_count;
     list->push_back(resource);
   }
   if (need_sync_point) {
     GLuint sync_point = gl->InsertSyncPointCHROMIUM();
     for (TransferableResourceArray::iterator it = list->begin();
          it != list->end();
          ++it) {
-      if (!it->sync_point)
-        it->sync_point = sync_point;
+      if (!it->mailbox_holder.sync_point)
+        it->mailbox_holder.sync_point = sync_point;
     }
   }
 }
 
 void ResourceProvider::ReceiveFromChild(
     int child, const TransferableResourceArray& resources) {
   DCHECK(thread_checker_.CalledOnValidThread());
   GLES2Interface* gl = ContextGL();
   Child& child_info = children_.find(child)->second;
   DCHECK(!child_info.marked_for_deletion);
   for (TransferableResourceArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
     ResourceIdMap::iterator resource_in_map_it =
         child_info.child_to_parent_map.find(it->id);
     if (resource_in_map_it != child_info.child_to_parent_map.end()) {
       resources_[resource_in_map_it->second].imported_count++;
       continue;
     }
 
     scoped_ptr<SharedBitmap> bitmap;
     uint8_t* pixels = NULL;
     if (it->is_software) {
-      if (shared_bitmap_manager_)
-        bitmap = shared_bitmap_manager_->GetSharedBitmapFromId(it->size,
-                                                               it->mailbox);
+      if (shared_bitmap_manager_) {
+        bitmap = shared_bitmap_manager_->GetSharedBitmapFromId(
+            it->size, it->mailbox_holder.mailbox);
+      }
       if (bitmap)
         pixels = bitmap->pixels();
     }
 
     if ((!it->is_software && !gl) || (it->is_software && !pixels)) {
       TRACE_EVENT0("cc", "ResourceProvider::ReceiveFromChild dropping invalid");
       ReturnedResourceArray to_return;
       to_return.push_back(it->ToReturnedResource());
       child_info.return_callback.Run(to_return);
       continue;
     }
 
     ResourceId local_id = next_id_++;
     Resource& resource = resources_[local_id];
     if (it->is_software) {
       resource = Resource(
           pixels, bitmap.release(), it->size, GL_LINEAR, GL_CLAMP_TO_EDGE);
     } else {
       GLuint texture_id;
       // NOTE: If the parent is a browser and the child a renderer, the parent
       // is not supposed to have its context wait, because that could induce
       // 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(gl, gl->WaitSyncPointCHROMIUM(it->sync_point));
+      if (it->mailbox_holder.sync_point)
+        GLC(gl, gl->WaitSyncPointCHROMIUM(it->mailbox_holder.sync_point));
       texture_id = texture_id_allocator_->NextId();
-      GLC(gl, gl->BindTexture(it->target, texture_id));
-      GLC(gl, gl->ConsumeTextureCHROMIUM(it->target, it->mailbox.name));
+      GLC(gl, gl->BindTexture(it->mailbox_holder.texture_target, texture_id));
+      GLC(gl,
+          gl->ConsumeTextureCHROMIUM(it->mailbox_holder.texture_target,
+                                     it->mailbox_holder.mailbox.name));
       resource = Resource(texture_id,
                           it->size,
-                          it->target,
+                          it->mailbox_holder.texture_target,
                           it->filter,
                           0,
                           GL_CLAMP_TO_EDGE,
                           TextureUsageAny,
                           it->format);
-      resource.mailbox.SetName(it->mailbox);
+      resource.mailbox = TextureMailbox(
+          it->mailbox_holder.mailbox, it->mailbox_holder.texture_target, 0);
     }
     resource.child_id = child;
     // Don't allocate a texture for a child.
     resource.allocated = true;
     resource.imported_count = 1;
     child_info.parent_to_child_map[local_id] = it->id;
     child_info.child_to_parent_map[it->id] = local_id;
   }
 }
 
@@ skipping 80 matching lines @@
     CHECK_GE(resource->exported_count, returned.count);
     resource->exported_count -= returned.count;
     resource->lost |= returned.lost;
     if (resource->exported_count)
       continue;
 
     if (resource->gl_id) {
       if (returned.sync_point)
         GLC(gl, gl->WaitSyncPointCHROMIUM(returned.sync_point));
     } else if (!resource->shared_bitmap) {
-      resource->mailbox =
-          TextureMailbox(resource->mailbox.name(), returned.sync_point);
+      resource->mailbox.set_sync_point(returned.sync_point);
     }
 
     if (!resource->marked_for_deletion)
       continue;
 
     if (!resource->child_id) {
       // The resource belongs to this ResourceProvider, so it can be destroyed.
       DeleteResourceInternal(map_iterator, Normal);
       continue;
     }
@@ skipping 27 matching lines @@
                                         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);
   DCHECK_EQ(source->wrap_mode, GL_CLAMP_TO_EDGE);
   resource->id = id;
   resource->format = source->format;
-  resource->target = source->target;
+  resource->mailbox_holder.texture_target = source->target;
   resource->filter = source->filter;
   resource->size = source->size;
 
   if (source->shared_bitmap) {
-    resource->mailbox = source->shared_bitmap->id();
+    resource->mailbox_holder.mailbox = source->shared_bitmap->id();
     resource->is_software = true;
   } else if (!source->mailbox.IsValid()) {
     // 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(gl, gl->BindTexture(resource->target, source->gl_id));
-    GLC(gl, gl->GenMailboxCHROMIUM(resource->mailbox.name));
     GLC(gl,
-        gl->ProduceTextureCHROMIUM(resource->target, resource->mailbox.name));
-    source->mailbox.SetName(resource->mailbox);
+        gl->BindTexture(resource->mailbox_holder.texture_target,
+                        source->gl_id));
+    GLC(gl, gl->GenMailboxCHROMIUM(resource->mailbox_holder.mailbox.name));
+    GLC(gl,
+        gl->ProduceTextureCHROMIUM(resource->mailbox_holder.texture_target,
+                                   resource->mailbox_holder.mailbox.name));
+    source->mailbox = TextureMailbox(resource->mailbox_holder);
   } else {
     DCHECK(source->mailbox.IsTexture());
     // This is either an external resource, or a compositor resource that we
     // already exported. Make sure to forward the sync point that we were given.
-    resource->mailbox = source->mailbox.name();
-    resource->sync_point = source->mailbox.sync_point();
-    source->mailbox.ResetSyncPoint();
+    resource->mailbox_holder.mailbox = source->mailbox.mailbox();
+    resource->mailbox_holder.texture_target = source->mailbox.target();
+    resource->mailbox_holder.sync_point = source->mailbox.sync_point();
+    source->mailbox.set_sync_point(0);
   }
 }
 
 void ResourceProvider::DeleteAndReturnUnusedResourcesToChild(
     ChildMap::iterator child_it,
     DeleteStyle style,
     const ResourceIdArray& unused) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(child_it != children_.end());
   Child* child_info = &child_it->second;
@@ skipping 521 matching lines @@
   gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 GLES2Interface* ResourceProvider::ContextGL() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->ContextGL() : NULL;
 }
 
 }  // namespace cc