WIP GPU scheduler + delayed activation / tile draw

cc/raster/gpu_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/gpu_raster_buffer_provider.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/trace_event/trace_event.h"
 #include "cc/base/histograms.h"
 #include "cc/playback/image_hijack_canvas.h"
 #include "cc/playback/raster_source.h"
 #include "cc/raster/scoped_gpu_raster.h"
 #include "cc/resources/resource.h"
+#include "gpu/command_buffer/client/context_support.h"
 #include "gpu/command_buffer/client/gles2_interface.h"
 #include "third_party/skia/include/core/SkMultiPictureDraw.h"
 #include "third_party/skia/include/core/SkPictureRecorder.h"
 #include "third_party/skia/include/core/SkSurface.h"
 #include "third_party/skia/include/gpu/GrContext.h"
 
 namespace cc {
 namespace {
 
 static sk_sp<SkPicture> PlaybackToPicture(
@@ skipping 94 matching lines @@
   multi_picture_draw.add(canvas, picture);
   multi_picture_draw.draw(false);
 }
 
 }  // namespace
 
 GpuRasterBufferProvider::RasterBufferImpl::RasterBufferImpl(
     GpuRasterBufferProvider* client,
     ResourceProvider* resource_provider,
     ResourceId resource_id,
-    bool async_worker_context_enabled,
     bool resource_has_previous_content)
     : client_(client),
-      lock_(resource_provider, resource_id, async_worker_context_enabled),
+      lock_(resource_provider, resource_id, true),
       resource_has_previous_content_(resource_has_previous_content) {
   client_->pending_raster_buffers_.insert(this);
 }
 
 GpuRasterBufferProvider::RasterBufferImpl::~RasterBufferImpl() {
   client_->pending_raster_buffers_.erase(this);
 }
 
 void GpuRasterBufferProvider::RasterBufferImpl::Playback(
     const RasterSource* raster_source,
@@ skipping 30 matching lines @@
   DCHECK(pending_raster_buffers_.empty());
 }
 
 std::unique_ptr<RasterBuffer> GpuRasterBufferProvider::AcquireBufferForRaster(
     const Resource* resource,
     uint64_t resource_content_id,
     uint64_t previous_content_id) {
   bool resource_has_previous_content =
       resource_content_id && resource_content_id == previous_content_id;
   return base::MakeUnique<RasterBufferImpl>(
-      this, resource_provider_, resource->id(), async_worker_context_enabled_,
-      resource_has_previous_content);
+      this, resource_provider_, resource->id(), resource_has_previous_content);
 }
 
 void GpuRasterBufferProvider::ReleaseBufferForRaster(
     std::unique_ptr<RasterBuffer> buffer) {
   // Nothing to do here. RasterBufferImpl destructor cleans up after itself.
 }
 
 void GpuRasterBufferProvider::OrderingBarrier() {
   TRACE_EVENT0("cc", "GpuRasterBufferProvider::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 GpuRasterBufferProvider::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 GpuRasterBufferProvider::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 GpuRasterBufferProvider::GetResourceFormat(
     bool must_support_alpha) const {
   return resource_provider_->best_render_buffer_format();
 }
 
 bool GpuRasterBufferProvider::IsResourceSwizzleRequired(
     bool must_support_alpha) const {
   // This doesn't require a swizzle because we rasterize to the correct format.
   return false;
 }
@@ skipping 54 matching lines @@
   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_);
 }
 
 }  // namespace cc