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 531 matching lines @@
     WebGraphicsContext3D* context3d = Context3d();
     DCHECK(context3d);
     GLC(context3d, context3d->deleteQueryEXT(resource->gl_upload_query_id));
   }
   if (resource->gl_pixel_buffer_id) {
     WebGraphicsContext3D* context3d = Context3d();
     DCHECK(context3d);
     GLC(context3d, context3d->deleteBuffer(resource->gl_pixel_buffer_id));
   }
   if (resource->mailbox.IsValid() && resource->external) {
-    unsigned sync_point = resource->mailbox.sync_point();
+    uint32 sync_point = resource->mailbox.sync_point();
     if (resource->mailbox.IsTexture()) {
       lost_resource |= lost_output_surface_;
       WebGraphicsContext3D* context3d = Context3d();
       DCHECK(context3d);
       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());
@@ skipping 175 matching lines @@
 
   LazyCreate(resource);
 
   if (resource->external) {
     if (!resource->gl_id && resource->mailbox.IsTexture()) {
       WebGraphicsContext3D* context3d = Context3d();
       DCHECK(context3d);
       if (resource->mailbox.sync_point()) {
         GLC(context3d,
             context3d->waitSyncPoint(resource->mailbox.sync_point()));
-        resource->mailbox.ResetSyncPoint();
+        resource->mailbox.set_sync_point(0);
       }
       resource->gl_id = texture_id_allocator_->NextId();
       GLC(context3d, context3d->bindTexture(resource->target, resource->gl_id));
       GLC(context3d,
           context3d->consumeTextureCHROMIUM(resource->target,
-                                            resource->mailbox.data()));
+                                            resource->mailbox.mailbox().name));
     }
   }
 
   resource->lock_for_read_count++;
   if (resource->enable_read_lock_fences)
     resource->read_lock_fence = current_read_lock_fence_;
 
   return resource;
 }
 
@@ skipping 272 matching lines @@
        it != resources.end();
        ++it) {
     TransferableResource resource;
     TransferResource(context3d, *it, &resource);
     if (!resource.sync_point && !resource.is_software)
       need_sync_point = true;
     ++resources_.find(*it)->second.exported_count;
     list->push_back(resource);
   }
   if (need_sync_point) {
-    unsigned int sync_point = context3d->insertSyncPoint();
+    uint32 sync_point = context3d->insertSyncPoint();
     for (TransferableResourceArray::iterator it = list->begin();
          it != list->end();
          ++it) {
       if (!it->sync_point)
         it->sync_point = sync_point;
     }
   }
 }
 
 void ResourceProvider::ReceiveFromChild(
@@ skipping 52 matching lines @@
       GLC(context3d,
           context3d->consumeTextureCHROMIUM(it->target, it->mailbox.name));
       resource = Resource(texture_id,
                           it->size,
                           it->target,
                           it->filter,
                           0,
                           GL_CLAMP_TO_EDGE,
                           TextureUsageAny,
                           it->format);
-      resource.mailbox.SetName(it->mailbox);
+      resource.mailbox = cc::TextureMailbox(it->mailbox, it->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 82 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(context3d, context3d->waitSyncPoint(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 43 matching lines @@
     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(context, context->bindTexture(resource->target, source->gl_id));
     GLC(context, context->genMailboxCHROMIUM(resource->mailbox.name));
     GLC(context,
         context->produceTextureCHROMIUM(resource->target,
                                         resource->mailbox.name));
-    source->mailbox.SetName(resource->mailbox);
+    source->mailbox =
+        cc::TextureMailbox(resource->mailbox, resource->target, 0);
   } 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->mailbox = source->mailbox.mailbox();
     resource->sync_point = source->mailbox.sync_point();
-    source->mailbox.ResetSyncPoint();
+    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 60 matching lines @@
     returned.lost = is_lost;
     to_return.push_back(returned);
 
     child_info->parent_to_child_map.erase(local_id);
     child_info->child_to_parent_map.erase(child_id);
     resource.imported_count = 0;
     DeleteResourceInternal(it, style);
   }
   if (need_sync_point) {
     DCHECK(context3d);
-    unsigned int sync_point = context3d->insertSyncPoint();
+    uint32 sync_point = context3d->insertSyncPoint();
     for (size_t i = 0; i < to_return.size(); ++i) {
       if (!to_return[i].sync_point)
         to_return[i].sync_point = sync_point;
     }
   }
 
   if (!to_return.empty())
     child_info->return_callback.Run(to_return);
 
   if (child_info->marked_for_deletion &&
@@ skipping 464 matching lines @@
   context->getIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 blink::WebGraphicsContext3D* ResourceProvider::Context3d() const {
   ContextProvider* context_provider = output_surface_->context_provider();
   return context_provider ? context_provider->Context3d() : NULL;
 }
 
 }  // namespace cc