WIP GPU scheduler + delayed activation / tile draw

cc/raster/gpu_raster_buffer_provider.cc

Index: cc/raster/gpu_raster_buffer_provider.cc
diff --git a/cc/raster/gpu_raster_buffer_provider.cc b/cc/raster/gpu_raster_buffer_provider.cc
index 4cfe51aac80e16874dbb3742faca7d20e606a7d4..97065500257b4d0f72ea161af676cbbe1a52faf4 100644
--- a/cc/raster/gpu_raster_buffer_provider.cc
+++ b/cc/raster/gpu_raster_buffer_provider.cc
@@ -17,6 +17,7 @@
 #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"
@@ -131,10 +132,9 @@ 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);
 }
@@ -185,8 +185,7 @@ std::unique_ptr<RasterBuffer> GpuRasterBufferProvider::AcquireBufferForRaster(
   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(
@@ -216,6 +215,36 @@ void GpuRasterBufferProvider::OrderingBarrier() {
   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();