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 37 matching lines @@
   DCHECK(!source->lock_for_read_count);
   DCHECK(!source->external || (source->external && source->mailbox.IsValid()));
   DCHECK(source->allocated);
   DCHECK_EQ(source->wrap_mode, GL_CLAMP_TO_EDGE);
   resource->id = id;
   resource->format = source->format;
   resource->target = source->target;
   resource->filter = source->filter;
   resource->size = source->size;
 
+  LazyCreate(source);

[danakj, 2014/01/16 17:55:52]

Why this? You're transferring a resource that has never been allocated/written
to?

[piman, 2014/01/16 21:54:34]

I don't think it's correct here, actually.
This would create a new texture id for an imported or external resource, but not
even Consume the mailbox into it, so we're in a limbo state where we have a
texture id and a mailbox, but they don't correspond to each other.

Maybe this should move into the "else if (!source->mailbox.IsValid())" block
below, gated by source->image_id ?

[reveman, 2014/01/17 01:38:39]

We've created and written to the GLImage but it has not yet been bound to a
texture so there hasn't been a need to create the texture. This is in part to be
nice to android_webview where we need to delay GL commands until draw time.

[reveman, 2014/01/17 01:38:39]

Hm, is texture_pool not 0 in those cases? Makes sense to move it to the "else if
(!source->mailbox.IsValid())" block anyhow but I'd rather not have it gated by
"source->image_id" and instead make sure LazyCreate does the right thing here
and not mess with imported/external resources.

+
   if (source->shared_bitmap) {
     resource->mailbox = source->shared_bitmap->id();
     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(gl, gl->BindTexture(resource->target, source->gl_id));
+    if (source->image_id) {
+      DCHECK(source->dirty_image);
+      BindImageForSampling(source);
+    }
     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) {

[piman, 2014/01/16 21:54:34]

Add a DCHECK(source->gl_id);
The only reason we'd get here (we have a mailbox and an image_id) is if we
already sent the resource at least once (it can't be imported or external), in
which case, we'd have created the texture in the previous block the first time
around.

[reveman, 2014/01/17 01:38:39]

Done.

+      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 171 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