cc: Allocate resources on worker context.

cc/raster/one_copy_raster_buffer_provider.cc

 // Copyright 2014 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/raster/one_copy_raster_buffer_provider.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <limits>
@@ skipping 214 matching lines @@
     const RasterSource* raster_source,
     const gfx::Rect& raster_full_rect,
     const gfx::Rect& raster_dirty_rect,
     const gfx::AxisTransform2d& transform,
     const RasterSource::PlaybackSettings& playback_settings,
     uint64_t previous_content_id,
     uint64_t new_content_id) {
   if (async_worker_context_enabled_) {
     // Early out if sync token is invalid. This happens if the compositor
     // context was lost before ScheduleTasks was called.
-    if (!sync_token.HasData())
+    if (!sync_token.HasData()) {
+      DLOG(ERROR) << "Context destroyed while scheduling raster tasks";
       return;
+    }
     ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
     gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
     DCHECK(gl);
     // Synchronize with compositor.
     gl->WaitSyncTokenCHROMIUM(sync_token.GetConstData());
   }
 
   std::unique_ptr<StagingBuffer> staging_buffer =
       staging_pool_.AcquireStagingBuffer(resource, previous_content_id);
 
@@ skipping 73 matching lines @@
 void OneCopyRasterBufferProvider::CopyOnWorkerThread(
     StagingBuffer* staging_buffer,
     ResourceProvider::ScopedWriteLockGL* resource_lock,
     const gpu::SyncToken& sync_token,
     const RasterSource* raster_source,
     const gfx::Rect& rect_to_copy) {
   ContextProvider::ScopedContextLock scoped_context(worker_context_provider_);
   gpu::gles2::GLES2Interface* gl = scoped_context.ContextGL();
   DCHECK(gl);
 
-  // Create texture after synchronizing with compositor.
-  ResourceProvider::ScopedTextureProvider scoped_texture(
-      gl, resource_lock, async_worker_context_enabled_);
+  unsigned resource_texture_id = resource_lock->texture_id();
+  if (async_worker_context_enabled_)
+    resource_texture_id = resource_lock->ConsumeTexture(gl);
 
-  unsigned resource_texture_id = scoped_texture.texture_id();
   unsigned image_target = resource_provider_->GetImageTextureTarget(
       StagingBufferUsage(), staging_buffer->format);
 
   // Create and bind staging texture.
   if (!staging_buffer->texture_id) {
     gl->GenTextures(1, &staging_buffer->texture_id);
     gl->BindTexture(image_target, staging_buffer->texture_id);
     gl->TexParameteri(image_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
     gl->TexParameteri(image_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
     gl->TexParameteri(image_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ skipping 68 matching lines @@
   }
 
   if (resource_provider_->use_sync_query()) {
 #if defined(OS_CHROMEOS) && defined(ARCH_CPU_ARM_FAMILY)
     gl->EndQueryEXT(GL_COMMANDS_ISSUED_CHROMIUM);
 #else
     gl->EndQueryEXT(GL_COMMANDS_COMPLETED_CHROMIUM);
 #endif
   }
 
+  if (async_worker_context_enabled_)
+    gl->DeleteTextures(1, &resource_texture_id);
+
   const uint64_t fence_sync = gl->InsertFenceSyncCHROMIUM();
 
   // Barrier to sync worker context output to cc context.
   gl->OrderingBarrierCHROMIUM();
 
   // Generate sync token after the barrier for cross context synchronization.
   gpu::SyncToken resource_sync_token;
   gl->GenUnverifiedSyncTokenCHROMIUM(fence_sync, resource_sync_token.GetData());
   resource_lock->set_sync_token(resource_sync_token);
-  resource_lock->set_synchronized(!async_worker_context_enabled_);
 }
 
 gfx::BufferUsage OneCopyRasterBufferProvider::StagingBufferUsage() const {
   return use_partial_raster_
              ? gfx::BufferUsage::GPU_READ_CPU_READ_WRITE_PERSISTENT
              : gfx::BufferUsage::GPU_READ_CPU_READ_WRITE;
 }
 
 }  // namespace cc