WIP GPU scheduler + delayed activation / tile draw

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>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/histograms.h"
 #include "cc/base/math_util.h"
 #include "cc/resources/platform_color.h"
 #include "cc/resources/resource_format.h"
 #include "cc/resources/resource_util.h"
 #include "cc/resources/scoped_resource.h"
 #include "gpu/GLES2/gl2extchromium.h"
+#include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "ui/gfx/buffer_format_util.h"
 
 namespace cc {
 namespace {
 
 // 4MiB is the size of 4 512x512 tiles, which has proven to be a good
 // default batch size for copy operations.
 const int kMaxBytesPerCopyOperation = 1024 * 1024 * 4;
 
 }  // namespace
 
 OneCopyRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
     OneCopyRasterBufferProvider* client,
     ResourceProvider* resource_provider,
     const Resource* resource,
-    uint64_t previous_content_id,
-    bool async_worker_context_enabled)
+    uint64_t previous_content_id)
     : client_(client),
       resource_(resource),
-      lock_(resource_provider, resource->id(), async_worker_context_enabled),
+      lock_(resource_provider, resource->id(), true),
       previous_content_id_(previous_content_id) {
   client_->pending_raster_buffers_.insert(this);
 }
 
 OneCopyRasterBufferProvider::RasterBufferImpl::~RasterBufferImpl() {
   client_->pending_raster_buffers_.erase(this);
 }
 
 void OneCopyRasterBufferProvider::RasterBufferImpl::Playback(
     const RasterSource* raster_source,
@@ skipping 45 matching lines @@
 }
 
 std::unique_ptr<RasterBuffer>
 OneCopyRasterBufferProvider::AcquireBufferForRaster(
     const Resource* resource,
     uint64_t resource_content_id,
     uint64_t previous_content_id) {
   // TODO(danakj): If resource_content_id != 0, we only need to copy/upload
   // the dirty rect.
   return base::MakeUnique<RasterBufferImpl>(this, resource_provider_, resource,
-                                            previous_content_id,
-                                            async_worker_context_enabled_);
+                                            previous_content_id);
 }
 
 void OneCopyRasterBufferProvider::ReleaseBufferForRaster(
     std::unique_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
 void OneCopyRasterBufferProvider::OrderingBarrier() {
   TRACE_EVENT0("cc", "OneCopyRasterBufferProvider::OrderingBarrier");
 
   gpu::gles2::GLES2Interface* gl = compositor_context_provider_->ContextGL();
   if (async_worker_context_enabled_) {
     GLuint64 fence = gl->InsertFenceSyncCHROMIUM();
     gl->OrderingBarrierCHROMIUM();
 
     gpu::SyncToken sync_token;
     gl->GenUnverifiedSyncTokenCHROMIUM(fence, sync_token.GetData());
 
     DCHECK(sync_token.HasData() ||
            gl->GetGraphicsResetStatusKHR() != GL_NO_ERROR);
 
     for (RasterBufferImpl* buffer : pending_raster_buffers_)
       buffer->set_sync_token(sync_token);
   } else {
     gl->OrderingBarrierCHROMIUM();
   }
   pending_raster_buffers_.clear();
 }
 
+bool OneCopyRasterBufferProvider::IsResourceReadyToDraw(
+    const Resource* resource) {
+  if (async_worker_context_enabled_) {
+    gpu::SyncToken sync_token =
+        resource_provider_->GetSyncTokenForResource(resource->id());
+    if (sync_token.HasData()) {
+      return worker_context_provider_->ContextSupport()->IsFenceSyncReleased(
+          sync_token.release_count());
+    }
+  }
+  return true;
+}
+
+void OneCopyRasterBufferProvider::SignalResourcesReadyToDraw(
+    const std::vector<const Resource*>& resources,
+    const base::Closure& callback) {
+  if (async_worker_context_enabled_) {
+    ResourceProvider::ResourceIdArray resource_ids;
+    for (const Resource* resource : resources)
+      resource_ids.push_back(resource->id());
+
+    gpu::SyncToken sync_token =
+        resource_provider_->GetSyncTokenForResources(resource_ids);
+    compositor_context_provider_->ContextSupport()->SignalSyncToken(sync_token,
+                                                                    callback);
+  } else if (!callback.is_null()) {
+    callback.Run();
+  }
+}
+
 ResourceFormat OneCopyRasterBufferProvider::GetResourceFormat(
     bool must_support_alpha) const {
   if (resource_provider_->IsResourceFormatSupported(preferred_tile_format_) &&
       (DoesResourceFormatSupportAlpha(preferred_tile_format_) ||
        !must_support_alpha)) {
     return preferred_tile_format_;
   }
 
   return resource_provider_->best_texture_format();
 }
@@ skipping 234 matching lines @@
   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