cc: Complete pending tile uploads if they are needed for tree activation

cc/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/resource_provider.h"
 
 #include <limits.h>
 
 #include "base/debug/alias.h"
 #include "base/hash_tables.h"
@@ skipping 56 matching lines @@
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(NULL),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       locked_for_write(false),
       external(false),
       exported(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
+      wait_for_set_pixels_inserted(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(),
       format(0),
       filter(0),
       type(static_cast<ResourceType>(0)) {}
 
 ResourceProvider::Resource::~Resource() {}
 
 ResourceProvider::Resource::Resource(
     unsigned texture_id, gfx::Size size, GLenum format, GLenum filter)
     : gl_id(texture_id),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(NULL),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       locked_for_write(false),
       external(false),
       exported(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
+      wait_for_set_pixels_inserted(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
       format(format),
       filter(filter),
       type(GLTexture) {}
 
 ResourceProvider::Resource::Resource(
     uint8_t* pixels, gfx::Size size, GLenum format, GLenum filter)
     : gl_id(0),
       gl_pixel_buffer_id(0),
       gl_upload_query_id(0),
       pixels(pixels),
       pixel_buffer(NULL),
       lock_for_read_count(0),
       locked_for_write(false),
       external(false),
       exported(false),
       marked_for_deletion(false),
       pending_set_pixels(false),
+      wait_for_set_pixels_inserted(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
       format(format),
       filter(filter),
       type(Bitmap) {}
 
 ResourceProvider::Child::Child() {}
 
@@ skipping 949 matching lines @@
     context3d->endQueryEXT(GL_ASYNC_PIXEL_TRANSFERS_COMPLETED_CHROMIUM);
     context3d->bindBuffer(GL_PIXEL_UNPACK_TRANSFER_BUFFER_CHROMIUM, 0);
   }
 
   if (resource->pixels)
     SetPixelsFromBuffer(id);
 
   resource->pending_set_pixels = true;
 }
 
+void ResourceProvider::InsertWaitForSetPixels(ResourceId id) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  ResourceMap::iterator it = resources_.find(id);
+  CHECK(it != resources_.end());
+  Resource* resource = &it->second;
+  DCHECK(resource->locked_for_write);
+  DCHECK(resource->pending_set_pixels);
+  DCHECK(!resource->wait_for_set_pixels_inserted);
+
+  if (resource->gl_id) {
+    WebGraphicsContext3D* context3d = output_surface_->context3d();
+    GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, resource->gl_id));
+    GLC(context3d, context3d->waitAsyncTexImage2DCHROMIUM(GL_TEXTURE_2D));
+    GLC(context3d, context3d->bindTexture(GL_TEXTURE_2D, 0));
+  }
+
+  UnlockForWrite(id);
+  resource->wait_for_set_pixels_inserted = true;
+}
+
 bool ResourceProvider::DidSetPixelsComplete(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
-  DCHECK(resource->locked_for_write);
+  DCHECK(resource->locked_for_write || resource->wait_for_set_pixels_inserted);
   DCHECK(resource->pending_set_pixels);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     DCHECK(resource->gl_upload_query_id);
     unsigned complete = 1;
     context3d->getQueryObjectuivEXT(
         resource->gl_upload_query_id,
         GL_QUERY_RESULT_AVAILABLE_EXT,
         &complete);
     if (!complete)
       return false;
   }
 
   resource->pending_set_pixels = false;
-  UnlockForWrite(id);
+  if (!resource->wait_for_set_pixels_inserted)
+    UnlockForWrite(id);

[epenner, 2013/03/11 19:18:40]

Can you explain why we do this only when there is no wait inserted?  It seems
like it should be the opposite to me.

In any case it seems fishy that if you call this function twice in a row that
UnlockForWrite will get called the second time through since we set it to false
the first time.

[Sami, 2013/03/12 14:13:07]

I guess the confusion comes from the fact that forcing the upload to complete
also unlocks the resource, so we have to check here whether we already unlocked.
I'll rework this so that we keep the resource locked but allow reading/sampling
from it if the completion was forced.

+  resource->wait_for_set_pixels_inserted = false;
 
   return true;
 }
 
 void ResourceProvider::AbortSetPixels(ResourceId id) {
   DCHECK(thread_checker_.CalledOnValidThread());
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->locked_for_write);

[reveman, 2013/03/12 06:25:58]

you need a "|| resource->wait_for_set_pixels_inserted" here too as the tile
manager might call abort anytime before DidSetPixelsComplete returns true.

[Sami, 2013/03/12 14:13:07]

Well spotted, done.

   DCHECK(resource->pending_set_pixels);
 
   if (resource->gl_id) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     DCHECK(resource->gl_upload_query_id);
     // CHROMIUM_async_pixel_transfers currently doesn't have a way to
     // abort an upload. The best we can do is delete the query and
     // the texture.
     context3d->deleteQueryEXT(resource->gl_upload_query_id);
     resource->gl_upload_query_id = 0;
     context3d->deleteTexture(resource->gl_id);
     resource->gl_id = CreateTextureId(context3d);
     resource->allocated = false;
   }
 
   resource->pending_set_pixels = false;
   UnlockForWrite(id);

[reveman, 2013/03/12 06:25:58]

and you'll need your wait_for_set_pixels_inserted check from
DidSetPixelsComplete here too.

[Sami, 2013/03/12 14:13:07]

Done.

 }
 
 void ResourceProvider::AllocateForTesting(ResourceId id) {
   ResourceMap::iterator it = resources_.find(id);
   CHECK(it != resources_.end());
   Resource* resource = &it->second;
   LazyAllocate(resource);
 }
 
 void ResourceProvider::LazyAllocate(Resource* resource) {
@@ skipping 36 matching lines @@
 }
 
 void ResourceProvider::SetOffscreenContextProvider(
     scoped_refptr<cc::ContextProvider> offscreen_context_provider) {
   if (offscreen_context_provider)
     offscreen_context_provider->BindToCurrentThread();
   offscreen_context_provider_ = offscreen_context_provider;
 }
 
 }  // namespace cc