cc: Add zero-copy texture update support to delegating renderer.

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 1176 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;
 
+    // Need to wait for the current read lock fence to pass before we can
+    // recycle this resource.
+    if (resource->enable_read_lock_fences)
+      resource->read_lock_fence = current_read_lock_fence_;
+
     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);
     }
 
     if (!resource->marked_for_deletion)
       continue;
@@ skipping 41 matching lines @@
   resource->id = id;
   resource->format = source->format;
   resource->target = source->target;
   resource->filter = source->filter;
   resource->size = source->size;
 
   if (source->shared_bitmap) {
     resource->mailbox = source->shared_bitmap->id();
     resource->is_software = true;
   } else if (!source->mailbox.IsValid()) {
+    LazyCreate(source);
+    DCHECK(source->gl_id);
+    GLC(gl, gl->BindTexture(resource->target, source->gl_id));
+    if (source->image_id) {
+      DCHECK(source->dirty_image);
+      BindImageForSampling(source);
+    }
     // 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);
   } else {
     DCHECK(source->mailbox.IsTexture());
+    if (source->image_id && source->dirty_image) {
+      DCHECK(source->gl_id);
+      GLC(gl, gl->BindTexture(resource->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 = source->mailbox.name();
     resource->sync_point = source->mailbox.sync_point();
     source->mailbox.ResetSyncPoint();
   }
 }
 
 void ResourceProvider::DeleteAndReturnUnusedResourcesToChild(
     ChildMap::iterator child_it,
@@ skipping 212 matching lines @@
 
   ScopedSetActiveTexture scoped_active_tex(gl, unit);
   GLenum target = resource->target;
   GLC(gl, gl->BindTexture(target, resource->gl_id));
   if (filter != resource->filter) {
     GLC(gl, gl->TexParameteri(target, GL_TEXTURE_MIN_FILTER, filter));
     GLC(gl, gl->TexParameteri(target, GL_TEXTURE_MAG_FILTER, filter));
     resource->filter = filter;
   }
 
-  if (resource->image_id && resource->dirty_image) {
-    // Release image currently bound to texture.
-    if (resource->bound_image_id)
-      gl->ReleaseTexImage2DCHROMIUM(target, resource->bound_image_id);
-    gl->BindTexImage2DCHROMIUM(target, resource->image_id);
-    resource->bound_image_id = resource->image_id;
-    resource->dirty_image = false;
-  }
+  if (resource->image_id && resource->dirty_image)
+    BindImageForSampling(resource);
 
   return target;
 }
 
 void ResourceProvider::BeginSetPixels(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->pending_set_pixels);
 
   LazyCreate(resource);
   DCHECK(resource->gl_id || resource->allocated);
@@ skipping 103 matching lines @@
 }
 
 void ResourceProvider::LazyCreate(Resource* resource) {
   if (resource->type != GLTexture || resource->gl_id != 0)
     return;
 
   // Early out for resources that don't require texture creation.
   if (resource->texture_pool == 0)
     return;
 
+  DCHECK(!resource->external);
+  DCHECK(!resource->mailbox.IsValid());
   resource->gl_id = texture_id_allocator_->NextId();
 
   GLES2Interface* gl = ContextGL();
   DCHECK(gl);
 
   // Create and set texture properties. Allocation is delayed until needed.
   GLC(gl, gl->BindTexture(resource->target, resource->gl_id));
   GLC(gl,
       gl->TexParameteri(resource->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR));
   GLC(gl,
@@ skipping 48 matching lines @@
                          size.width(),
                          size.height(),
                          0,
                          GLDataFormat(format),
                          GLDataType(format),
                          NULL));
     }
   }
 }
 
+void ResourceProvider::BindImageForSampling(Resource* resource) {
+  GLES2Interface* gl = ContextGL();
+  DCHECK(resource->gl_id);
+  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::EnableReadLockFences(ResourceProvider::ResourceId id,
                                             bool enable) {
   Resource* resource = GetResource(id);
   resource->enable_read_lock_fences = enable;
 }
 
 void ResourceProvider::AcquireImage(ResourceId id) {
   Resource* resource = GetResource(id);
   DCHECK(!resource->external);
   DCHECK_EQ(resource->exported_count, 0);
@@ skipping 95 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