cc: Propagate read lock fences constraints to parent compositors.

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 569 matching lines @@
 
 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->marked_for_deletion);
   DCHECK_EQ(resource->imported_count, 0);
   DCHECK(resource->pending_set_pixels || !resource->locked_for_write);
 
-  if (resource->exported_count > 0 || resource->lock_for_read_count > 0) {
+  if (resource->exported_count > 0 || resource->lock_for_read_count > 0 ||
+      !ReadLockFenceHasPassed(resource)) {
     resource->marked_for_deletion = true;
     return;
   } else {
     DeleteResourceInternal(it, NORMAL);
   }
 }
 
 void ResourceProvider::DeleteResourceInternal(ResourceMap::iterator it,
                                               DeleteStyle style) {
   TRACE_EVENT0("cc", "ResourceProvider::DeleteResourceInternal");
@@ skipping 339 matching lines @@
          !resource->lost && ReadLockFenceHasPassed(resource);
 }
 
 void ResourceProvider::UnlockForWrite(ResourceProvider::Resource* resource) {
   DCHECK(resource->locked_for_write);
   DCHECK_EQ(resource->exported_count, 0);
   DCHECK(resource->origin == Resource::INTERNAL);
   resource->locked_for_write = false;
 }
 
+void ResourceProvider::EnableReadLockFences(ResourceId id) {
+  Resource* resource = GetResource(id);
+  DCHECK(resource);
+  resource->read_lock_fences_enabled = true;
+}
+
 ResourceProvider::ScopedReadLockGL::ScopedReadLockGL(
     ResourceProvider* resource_provider,
     ResourceId resource_id)
     : resource_provider_(resource_provider),
       resource_id_(resource_id),
       resource_(resource_provider->LockForRead(resource_id)) {
   DCHECK(resource_);
 }
 
 ResourceProvider::ScopedReadLockGL::~ScopedReadLockGL() {
@@ skipping 408 matching lines @@
                    GL_LINEAR, it->is_repeated ? GL_REPEAT : GL_CLAMP_TO_EDGE));
     } else {
       resource = InsertResource(
           local_id, Resource(0, it->size, Resource::DELEGATED,
                              it->mailbox_holder.texture_target, it->filter, 0,
                              it->is_repeated ? GL_REPEAT : GL_CLAMP_TO_EDGE,
                              TEXTURE_HINT_IMMUTABLE, it->format));
       resource->mailbox = TextureMailbox(it->mailbox_holder.mailbox,
                                          it->mailbox_holder.texture_target,
                                          it->mailbox_holder.sync_point);
+      resource->read_lock_fences_enabled = it->read_lock_fences_enabled;
     }
     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 35 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;
 
-    // Need to wait for the current read lock fence to pass before we can
-    // recycle this resource.
-    if (resource->read_lock_fences_enabled) {
-      if (current_read_lock_fence_.get())
-        current_read_lock_fence_->Set();
-      resource->read_lock_fence = current_read_lock_fence_;
-    }
-
     if (returned.sync_point) {
       DCHECK(!resource->has_shared_bitmap_id);
       if (resource->origin == Resource::INTERNAL) {
         DCHECK(resource->gl_id);
         gl->WaitSyncPointCHROMIUM(returned.sync_point);
       } else {
         DCHECK(!resource->gl_id);
         resource->mailbox.set_sync_point(returned.sync_point);
       }
     }
@@ skipping 24 matching lines @@
   Resource* source = GetResource(id);
   DCHECK(!source->locked_for_write);
   DCHECK(!source->lock_for_read_count);
   DCHECK(source->origin != Resource::EXTERNAL || source->mailbox.IsValid());
   DCHECK(source->allocated);
   resource->id = id;
   resource->format = source->format;
   resource->mailbox_holder.texture_target = source->target;
   resource->filter = source->filter;
   resource->size = source->size;
+  resource->read_lock_fences_enabled = source->read_lock_fences_enabled;
   resource->is_repeated = (source->wrap_mode == GL_REPEAT);
 
   if (source->type == RESOURCE_TYPE_BITMAP) {
     resource->mailbox_holder.mailbox = source->shared_bitmap_id;
     resource->is_software = true;
   } else if (!source->mailbox.IsValid()) {
     LazyCreate(source);
     DCHECK(source->gl_id);
     DCHECK(source->origin == Resource::INTERNAL);
     if (source->image_id) {
@@ skipping 49 matching lines @@
 
     DCHECK(!resource.locked_for_write);
     DCHECK(child_info->parent_to_child_map.count(local_id));
 
     ResourceId child_id = child_info->parent_to_child_map[local_id];
     DCHECK(child_info->child_to_parent_map.count(child_id));
 
     bool is_lost =
         resource.lost ||
         (resource.type == RESOURCE_TYPE_GL_TEXTURE && lost_output_surface_);
-    if (resource.exported_count > 0 || resource.lock_for_read_count > 0) {
+    if (resource.exported_count > 0 || resource.lock_for_read_count > 0 ||
+        !ReadLockFenceHasPassed(&resource)) {
       if (style != FOR_SHUTDOWN) {
         // Defer this until we receive the resource back from the parent or
         // the read lock is released.
         resource.marked_for_deletion = true;
         continue;
       }
 
       // We still have an exported_count, so we'll have to lose it.
       is_lost = true;
     }
@@ skipping 482 matching lines @@
 }
 
 class GrContext* ResourceProvider::GrContext(bool worker_context) const {
   ContextProvider* context_provider =
       worker_context ? output_surface_->worker_context_provider()
                      : output_surface_->context_provider();
   return context_provider ? context_provider->GrContext() : NULL;
 }
 
 }  // namespace cc