cc: Rationalize sync points and lost status for returned resources

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 162 matching lines @@
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
+      sync_point_is_from_client(false),
       read_lock_fence(NULL),
       size(),
       target(0),
       original_filter(0),
       filter(0),
       image_id(0),
       bound_image_id(0),
       dirty_image(false),
       texture_pool(0),
       wrap_mode(0),
@@ skipping 22 matching lines @@
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
+      sync_point_is_from_client(false),
       read_lock_fence(NULL),
       size(size),
       target(target),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       dirty_image(false),
       texture_pool(texture_pool),
       wrap_mode(wrap_mode),
@@ skipping 19 matching lines @@
       lock_for_read_count(0),
       imported_count(0),
       exported_count(0),
       locked_for_write(false),
       external(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
       set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
+      sync_point_is_from_client(false),
       read_lock_fence(NULL),
       size(size),
       target(0),
       original_filter(filter),
       filter(filter),
       image_id(0),
       bound_image_id(0),
       dirty_image(false),
       texture_pool(0),
       wrap_mode(wrap_mode),
@@ skipping 200 matching lines @@
     }
     resource = Resource(pixels,
                         shared_bitmap.release(),
                         mailbox.shared_memory_size(),
                         GL_LINEAR,
                         GL_CLAMP_TO_EDGE);
   }
   resource.external = true;
   resource.allocated = true;
   resource.mailbox = mailbox;
+  resource.sync_point_is_from_client = true;
   resource.release_callback =
       base::Bind(&SingleReleaseCallback::Run,
                  base::Owned(release_callback.release()));
   return id;
 }
 
 void ResourceProvider::DeleteResource(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
@@ skipping 37 matching lines @@
     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();
+    if (resource->sync_point_is_from_client)
+      sync_point = 0;
     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)
+      if (!lost_resource && resource->gl_id) {
+        DCHECK(!sync_point);
         sync_point = context3d->insertSyncPoint();
+      }
     } else {
       DCHECK(resource->mailbox.IsSharedMemory());
       base::SharedMemory* shared_memory = resource->mailbox.shared_memory();
       if (resource->pixels && shared_memory) {
         DCHECK(shared_memory->memory() == resource->pixels);
         resource->pixels = NULL;
         delete resource->shared_bitmap;
         resource->shared_bitmap = NULL;
       }
     }
@@ skipping 143 matching lines @@
 const ResourceProvider::Resource* ResourceProvider::LockForRead(ResourceId id) {
   Resource* resource = GetResource(id);
   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_EQ(resource->exported_count, 0);
   // Uninitialized! Call SetPixels or LockForWrite first.
   DCHECK(resource->allocated);
 
-  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->gl_id = texture_id_allocator_->NextId();
-      GLC(context3d, context3d->bindTexture(resource->target, resource->gl_id));
-      GLC(context3d,
-          context3d->consumeTextureCHROMIUM(resource->target,
-                                            resource->mailbox.data()));
+  if (!resource->gl_id && resource->mailbox.IsTexture()) {
+    WebGraphicsContext3D* context3d = Context3d();
+    DCHECK(context3d);
+    resource->sync_point_is_from_client = false;
+    if (resource->mailbox.sync_point()) {
+      GLC(context3d, context3d->waitSyncPoint(resource->mailbox.sync_point()));
+      resource->mailbox.ResetSyncPoint();
     }
+    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()));
+  } else {
+    LazyCreate(resource);
   }
 
   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) {
   Resource* resource = GetResource(id);
   DCHECK_GT(resource->lock_for_read_count, 0);
   DCHECK_EQ(resource->exported_count, 0);
   resource->lock_for_read_count--;
 }
 
 const ResourceProvider::Resource* ResourceProvider::LockForWrite(
     ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->locked_for_write);
   DCHECK(!resource->lock_for_read_count);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(!resource->external);
   DCHECK(!resource->lost);
   DCHECK(ReadLockFenceHasPassed(resource));
   LazyAllocate(resource);
 
+  resource->mailbox.ResetSyncPoint();
   resource->locked_for_write = true;
   return resource;
 }
 
 bool ResourceProvider::CanLockForWrite(ResourceId id) {
   Resource* resource = GetResource(id);
   return !resource->locked_for_write && !resource->lock_for_read_count &&
          !resource->exported_count && !resource->external && !resource->lost &&
          ReadLockFenceHasPassed(resource);
 }
@@ skipping 298 matching lines @@
       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 {
-      unsigned 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(context3d, context3d->waitSyncPoint(it->sync_point));
-      texture_id = texture_id_allocator_->NextId();
-      GLC(context3d, context3d->bindTexture(it->target, texture_id));
-      GLC(context3d,
-          context3d->consumeTextureCHROMIUM(it->target, it->mailbox.name));
-      resource = Resource(texture_id,
+      resource = Resource(0,
                           it->size,
                           it->target,
                           it->filter,
                           0,
                           GL_CLAMP_TO_EDGE,
                           TextureUsageAny,
                           it->format);
-      resource.mailbox.SetName(it->mailbox);
+      resource.mailbox = TextureMailbox(it->mailbox, it->sync_point);
+      resource.sync_point_is_from_client = true;
     }
     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 78 matching lines @@
     ResourceMap::iterator& map_iterator = sorted_resources[i].second;
     ResourceId local_id = map_iterator->first;
     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 (resource->gl_id) {
-      if (returned.sync_point)
+    if (returned.sync_point) {
+      DCHECK(!resource->shared_bitmap);
+      resource->sync_point_is_from_client = false;
+      if (resource->gl_id) {
         GLC(context3d, context3d->waitSyncPoint(returned.sync_point));
-    } else if (!resource->shared_bitmap) {
-      resource->mailbox =
-          TextureMailbox(resource->mailbox.name(), returned.sync_point);
+        resource->mailbox.ResetSyncPoint();
+      } else {
+        resource->mailbox =
+            TextureMailbox(resource->mailbox.name(), 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 49 matching lines @@
     GLC(context,
         context->produceTextureCHROMIUM(resource->target,
                                         resource->mailbox.name));
     source->mailbox.SetName(resource->mailbox);
   } 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();
   }
 }
 
 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 46 matching lines @@
                                    GL_TEXTURE_MIN_FILTER,
                                    resource.original_filter));
       GLC(context3d,
           context3d->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.shared_bitmap)
-      need_sync_point = true;
+    if (!resource.sync_point_is_from_client) {
+      returned.sync_point = resource.mailbox.sync_point();
+      if (!returned.sync_point && !resource.shared_bitmap)
+        need_sync_point = true;
+    }
     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) {
@@ skipping 477 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