Modified old wait sync point functions to also accept new sync tokens.

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/atomic_sequence_num.h"
@@ skipping 294 matching lines @@
       image_id(0),
       bound_image_id(0),
       hint(TEXTURE_HINT_IMMUTABLE),
       type(RESOURCE_TYPE_BITMAP),
       format(RGBA_8888),
       shared_bitmap_id(bitmap_id),
       shared_bitmap(NULL),
       gpu_memory_buffer(NULL) {}
 
 ResourceProvider::Child::Child()
-    : marked_for_deletion(false), needs_sync_points(true) {
-}
+    : marked_for_deletion(false), needs_sync_tokens(true) {}
 
 ResourceProvider::Child::~Child() {}
 
 scoped_ptr<ResourceProvider> ResourceProvider::Create(
     OutputSurface* output_surface,
     SharedBitmapManager* shared_bitmap_manager,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
     BlockingTaskRunner* blocking_main_thread_task_runner,
     int highp_threshold_min,
     size_t id_allocation_chunk_size,
@@ skipping 230 matching lines @@
     gl->DeleteQueriesEXT(1, &resource->gl_read_lock_query_id);
   }
   if (resource->gl_pixel_buffer_id) {
     DCHECK(resource->origin == Resource::INTERNAL);
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     gl->DeleteBuffers(1, &resource->gl_pixel_buffer_id);
   }
   if (resource->origin == Resource::EXTERNAL) {
     DCHECK(resource->mailbox.IsValid());
-    GLuint sync_point = resource->mailbox.sync_point();
+    gpu::SyncToken sync_token = resource->mailbox.sync_token();
     if (resource->type == RESOURCE_TYPE_GL_TEXTURE) {
       DCHECK(resource->mailbox.IsTexture());
       lost_resource |= lost_output_surface_;
       GLES2Interface* gl = ContextGL();
       DCHECK(gl);
       if (resource->gl_id) {
         gl->DeleteTextures(1, &resource->gl_id);
         resource->gl_id = 0;
         if (!lost_resource)
-          sync_point = gl->InsertSyncPointCHROMIUM();
+          sync_token = gpu::SyncToken(gl->InsertSyncPointCHROMIUM());
       }
     } else {
       DCHECK(resource->mailbox.IsSharedMemory());
       resource->shared_bitmap = nullptr;
       resource->pixels = nullptr;
     }
-    resource->release_callback_impl.Run(
-        sync_point, lost_resource, blocking_main_thread_task_runner_);
+    resource->release_callback_impl.Run(sync_token, lost_resource,
+                                        blocking_main_thread_task_runner_);
   }
   if (resource->gl_id) {
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     gl->DeleteTextures(1, &resource->gl_id);
     resource->gl_id = 0;
   }
   if (resource->shared_bitmap) {
     DCHECK(resource->origin != Resource::EXTERNAL);
     DCHECK_EQ(RESOURCE_TYPE_BITMAP, resource->type);
@@ skipping 87 matching lines @@
   DCHECK_EQ(resource->exported_count, 0);
   // Uninitialized! Call SetPixels or LockForWrite first.
   DCHECK(resource->allocated);
 
   LazyCreate(resource);
 
   if (resource->type == RESOURCE_TYPE_GL_TEXTURE && !resource->gl_id) {
     DCHECK(resource->origin != Resource::INTERNAL);
     DCHECK(resource->mailbox.IsTexture());
 
-    // Mailbox sync_points must be processed by a call to
-    // WaitSyncPointIfNeeded() prior to calling LockForRead().
-    DCHECK(!resource->mailbox.sync_point());
+    // Mailbox sync_tokens must be processed by a call to
+    // WaitSyncTokenIfNeeded() prior to calling LockForRead().
+    DCHECK(!resource->mailbox.sync_token().HasData());
 
     GLES2Interface* gl = ContextGL();
     DCHECK(gl);
     resource->gl_id = gl->CreateAndConsumeTextureCHROMIUM(
         resource->mailbox.target(), resource->mailbox.name());
   }
 
   if (!resource->pixels && resource->has_shared_bitmap_id &&
       shared_bitmap_manager_) {
     scoped_ptr<SharedBitmap> bitmap =
@@ skipping 377 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Child child_info;
   child_info.return_callback = return_callback;
 
   int child = next_child_++;
   children_[child] = child_info;
   return child;
 }
 
-void ResourceProvider::SetChildNeedsSyncPoints(int child_id, bool needs) {
+void ResourceProvider::SetChildNeedsSyncTokens(int child_id, bool needs) {
   ChildMap::iterator it = children_.find(child_id);
   DCHECK(it != children_.end());
-  it->second.needs_sync_points = needs;
+  it->second.needs_sync_tokens = needs;
 }
 
 void ResourceProvider::DestroyChild(int child_id) {
   ChildMap::iterator it = children_.find(child_id);
   DCHECK(it != children_.end());
   DestroyChildInternal(it, NORMAL);
 }
 
 void ResourceProvider::DestroyChildInternal(ChildMap::iterator it,
                                             DeleteStyle style) {
@@ skipping 22 matching lines @@
   ChildMap::const_iterator it = children_.find(child);
   DCHECK(it != children_.end());
   DCHECK(!it->second.marked_for_deletion);
   return it->second.child_to_parent_map;
 }
 
 void ResourceProvider::PrepareSendToParent(const ResourceIdArray& resources,
                                            TransferableResourceArray* list) {
   DCHECK(thread_checker_.CalledOnValidThread());
   GLES2Interface* gl = ContextGL();
-  bool need_sync_point = false;
+  bool need_sync_token = false;
   for (ResourceIdArray::const_iterator it = resources.begin();
        it != resources.end();
        ++it) {
     TransferableResource resource;
     TransferResource(gl, *it, &resource);
-    if (!resource.mailbox_holder.sync_point && !resource.is_software)
-      need_sync_point = true;
+    need_sync_token |= (!resource.mailbox_holder.sync_token.HasData() &&
+                        !resource.is_software);
     ++resources_.find(*it)->second.exported_count;
     list->push_back(resource);
   }
-  if (need_sync_point &&
+  if (need_sync_token &&
       output_surface_->capabilities().delegated_sync_points_required) {
-    GLuint sync_point = gl->InsertSyncPointCHROMIUM();
+    gpu::SyncToken sync_token(gl->InsertSyncPointCHROMIUM());
     for (TransferableResourceArray::iterator it = list->begin();
          it != list->end();
          ++it) {
-      if (!it->mailbox_holder.sync_point)
-        it->mailbox_holder.sync_point = sync_point;
+      if (!it->mailbox_holder.sync_token.HasData())
+        it->mailbox_holder.sync_token = sync_token;
     }
   }
 }
 
 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);
@@ skipping 24 matching lines @@
     if (it->is_software) {
       resource = InsertResource(local_id,
                                 Resource(it->mailbox_holder.mailbox, it->size,
                                          Resource::DELEGATED, GL_LINEAR));
     } else {
       resource = InsertResource(
           local_id, Resource(0, it->size, Resource::DELEGATED,
                              it->mailbox_holder.texture_target, it->filter,
                              TEXTURE_HINT_IMMUTABLE, it->format));
       resource->mailbox = TextureMailbox(it->mailbox_holder.mailbox,
-                                         it->mailbox_holder.texture_target,
-                                         it->mailbox_holder.sync_point);
+                                         it->mailbox_holder.sync_token,
+                                         it->mailbox_holder.texture_target);
       resource->read_lock_fences_enabled = it->read_lock_fences_enabled;
       resource->is_overlay_candidate = it->is_overlay_candidate;
     }
     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 37 matching lines @@
       continue;
 
     Resource* resource = &map_iterator->second;
 
     CHECK_GE(resource->exported_count, returned.count);
     resource->exported_count -= returned.count;
     resource->lost |= returned.lost;
     if (resource->exported_count)
       continue;
 
-    if (returned.sync_point) {
+    if (returned.sync_token.HasData()) {
       DCHECK(!resource->has_shared_bitmap_id);
       if (resource->origin == Resource::INTERNAL) {
         DCHECK(resource->gl_id);
-        gl->WaitSyncPointCHROMIUM(returned.sync_point);
+        gl->WaitSyncTokenCHROMIUM(returned.sync_token.GetConstData());
       } else {
         DCHECK(!resource->gl_id);
-        resource->mailbox.set_sync_point(returned.sync_point);
+        resource->mailbox.set_sync_token(returned.sync_token);
       }
     }
 
     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 51 matching lines @@
     if (source->image_id && source->dirty_image) {
       DCHECK(source->gl_id);
       DCHECK(source->origin == Resource::INTERNAL);
       gl->BindTexture(resource->mailbox_holder.texture_target, source->gl_id);
       BindImageForSampling(source);
     }
     // 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_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);
+    resource->mailbox_holder.sync_token = source->mailbox.sync_token();
+    source->mailbox.set_sync_token(gpu::SyncToken());
   }
 }
 
 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;
 
   if (unused.empty() && !child_info->marked_for_deletion)
     return;
 
   ReturnedResourceArray to_return;
 
   GLES2Interface* gl = ContextGL();
-  bool need_sync_point = false;
+  bool need_sync_token = false;
   for (size_t i = 0; i < unused.size(); ++i) {
     ResourceId local_id = unused[i];
 
     ResourceMap::iterator it = resources_.find(local_id);
     CHECK(it != resources_.end());
     Resource& resource = it->second;
 
     DCHECK(!resource.locked_for_write);
     DCHECK(child_info->parent_to_child_map.count(local_id));
 
@@ skipping 29 matching lines @@
 
       gl->BindTexture(resource.target, resource.gl_id);
       gl->TexParameteri(resource.target, GL_TEXTURE_MIN_FILTER,
                         resource.original_filter);
       gl->TexParameteri(resource.target, GL_TEXTURE_MAG_FILTER,
                         resource.original_filter);
     }
 
     ReturnedResource returned;
     returned.id = child_id;
-    returned.sync_point = resource.mailbox.sync_point();
-    if (!returned.sync_point && resource.type == RESOURCE_TYPE_GL_TEXTURE)
-      need_sync_point = true;
+    returned.sync_token = resource.mailbox.sync_token();
+    need_sync_token |= (!returned.sync_token.HasData() &&
+                        resource.type == RESOURCE_TYPE_GL_TEXTURE);
     returned.count = resource.imported_count;
     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 && child_info->needs_sync_points) {
+  if (need_sync_token && child_info->needs_sync_tokens) {
     DCHECK(gl);
-    GLuint sync_point = gl->InsertSyncPointCHROMIUM();
+    gpu::SyncToken sync_token(gl->InsertSyncPointCHROMIUM());
     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[i].sync_token.HasData())
+        to_return[i].sync_token = sync_token;
     }
   }
 
   if (!to_return.empty())
     child_info->return_callback.Run(to_return,
                                     blocking_main_thread_task_runner_);
 
   if (child_info->marked_for_deletion &&
       child_info->parent_to_child_map.empty()) {
     DCHECK(child_info->child_to_parent_map.empty());
@@ skipping 103 matching lines @@
   DCHECK(resource->image_id);
 
   // Release image currently bound to texture.
   if (resource->bound_image_id)
     gl->ReleaseTexImage2DCHROMIUM(resource->target, resource->bound_image_id);
   gl->BindTexImage2DCHROMIUM(resource->target, resource->image_id);
   resource->bound_image_id = resource->image_id;
   resource->dirty_image = false;
 }
 
-void ResourceProvider::WaitSyncPointIfNeeded(ResourceId id) {
+void ResourceProvider::WaitSyncTokenIfNeeded(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(resource->allocated);
   if (resource->type != RESOURCE_TYPE_GL_TEXTURE || resource->gl_id)
     return;
-  if (!resource->mailbox.sync_point())
-    return;
-  DCHECK(resource->mailbox.IsValid());
-  GLES2Interface* gl = ContextGL();
-  DCHECK(gl);
-  gl->WaitSyncPointCHROMIUM(resource->mailbox.sync_point());
-  resource->mailbox.set_sync_point(0);
+  if (resource->mailbox.sync_token().HasData()) {
+    DCHECK(resource->mailbox.IsValid());
+    GLES2Interface* gl = ContextGL();
+    DCHECK(gl);
+    gl->WaitSyncTokenCHROMIUM(resource->mailbox.sync_token().GetConstData());
+    resource->mailbox.set_sync_token(gpu::SyncToken());
+  }
 }
 
 GLint ResourceProvider::GetActiveTextureUnit(GLES2Interface* gl) {
   GLint active_unit = 0;
   gl->GetIntegerv(GL_ACTIVE_TEXTURE, &active_unit);
   return active_unit;
 }
 
 GLenum ResourceProvider::GetImageTextureTarget(ResourceFormat format) {
   gfx::BufferFormat buffer_format = BufferFormat(format);
@@ skipping 67 matching lines @@
       const int kImportance = 2;
       pmd->CreateSharedGlobalAllocatorDump(guid);
       pmd->AddOwnershipEdge(dump->guid(), guid, kImportance);
     }
   }
 
   return true;
 }
 
 }  // namespace cc