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),
+      set_pixels_completion_forced(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),
+      set_pixels_completion_forced(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),
+      set_pixels_completion_forced(false),
       allocated(false),
       enable_read_lock_fences(false),
       read_lock_fence(NULL),
       size(size),
       format(format),
       filter(filter),
       type(Bitmap) {}
 
 ResourceProvider::Child::Child() {}
 
@@ skipping 300 matching lines @@
 
   context3d->shallowFlushCHROMIUM();
   return true;
 }
 
 const ResourceProvider::Resource* ResourceProvider::LockForRead(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->set_pixels_completion_forced);
   DCHECK(!resource->exported);
   // Uninitialized! Call SetPixels or LockForWrite first.
   DCHECK(resource->allocated);
 
   if (!resource->gl_id && resource->external && !resource->mailbox.IsEmpty()) {
     WebGraphicsContext3D* context3d = output_surface_->context3d();
     DCHECK(context3d);
     if (resource->mailbox.sync_point()) {
       GLC(context3d, context3d->waitSyncPoint(resource->mailbox.sync_point()));
       resource->mailbox.ResetSyncPoint();
@@ skipping 557 matching lines @@
 }
 
 void ResourceProvider::BindForSampling(ResourceProvider::ResourceId resource_id,
                                        GLenum target, GLenum filter) {
   DCHECK(thread_checker_.CalledOnValidThread());
   WebGraphicsContext3D* context3d = output_surface_->context3d();
   ResourceMap::iterator it = resources_.find(resource_id);
   DCHECK(it != resources_.end());
   Resource* resource = &it->second;
   DCHECK(resource->lock_for_read_count);
-  DCHECK(!resource->locked_for_write);
+  DCHECK(!resource->locked_for_write || resource->set_pixels_completion_forced);
 
   GLC(context3d, context3d->bindTexture(target, resource->gl_id));
   if (filter != resource->filter) {
     GLC(context3d, context3d->texParameteri(target,
                                             GL_TEXTURE_MIN_FILTER,
                                             filter));
     GLC(context3d, context3d->texParameteri(target,
                                             GL_TEXTURE_MAG_FILTER,
                                             filter));
     resource->filter = filter;
@@ skipping 48 matching lines @@
                                             NULL);
     }
     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;
+  resource->set_pixels_completion_forced = false;
+}
+
+void ResourceProvider::ForceSetPixelsToComplete(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->set_pixels_completion_forced);
+
+  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));
+  }
+
+  resource->set_pixels_completion_forced = 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->pending_set_pixels);
 
@@ skipping 89 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