Allow cc to cancel GPU create calls on a worker thread at shutdown.

Once GPU code in the browser moves to the UI thread,
cc::TileTaskManagerImpl::Shutdown would run on the main thread and
cancel pending tasks and wait for in-progress ones to finish. The
latter may be waiting on tasks to the main thread to call
HostGpuMemoryBufferManager::AllocateGpuMemoryBuffer which would
deadlock. My previous fix in r873954 was complicated and ended up
needing more complexity (e.g. https://crrev.com/c/2844359) since parts
of the GPU code would need to run on the IO thread, sometimes
synchronously.

This fix will allow a future revert of the parts of the previous cl
that moved HostGpuMemoryBufferManager to the IO thread and is overall
simpler.

Bug: 904556
Change-Id: Ia795d540d8a1cd02114a885380262dbfd0eedef9
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2845201
Commit-Queue: John Abd-El-Malek <jam@chromium.org>
Reviewed-by: kylechar <kylechar@chromium.org>
Reviewed-by: Dale Curtis <dalecurtis@chromium.org>
Reviewed-by: Kenneth Russell <kbr@chromium.org>
Reviewed-by: Ted Choc <tedchoc@chromium.org>
Reviewed-by: Scott Violet <sky@chromium.org>
Cr-Commit-Position: refs/heads/master@{#877581}

diff --git a/cc/raster/zero_copy_raster_buffer_provider.cc b/cc/raster/zero_copy_raster_buffer_provider.cc
index cca625539..2184021 100644
--- a/cc/raster/zero_copy_raster_buffer_provider.cc
+++ b/cc/raster/zero_copy_raster_buffer_provider.cc

@@ -67,10 +67,12 @@
  public:
   ZeroCopyRasterBufferImpl(
       gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager,
+      base::WaitableEvent* shutdown_event,
       const ResourcePool::InUsePoolResource& in_use_resource,
       ZeroCopyGpuBacking* backing)
       : backing_(backing),
         gpu_memory_buffer_manager_(gpu_memory_buffer_manager),
+        shutdown_event_(shutdown_event),
         resource_size_(in_use_resource.size()),
         resource_format_(in_use_resource.format()),
         resource_color_space_(in_use_resource.color_space()),
@@ -124,7 +126,7 @@
     if (!gpu_memory_buffer_) {
       gpu_memory_buffer_ = gpu_memory_buffer_manager_->CreateGpuMemoryBuffer(
           resource_size_, viz::BufferFormat(resource_format_), kBufferUsage,
-          gpu::kNullSurfaceHandle);
+          gpu::kNullSurfaceHandle, shutdown_event_);
       // Note that GpuMemoryBuffer allocation can fail.
       // https://crbug.com/554541
       if (!gpu_memory_buffer_)
@@ -156,6 +158,7 @@
 
   // These fields are for use on the worker thread.
   gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager_;
+  base::WaitableEvent* shutdown_event_;
   gfx::Size resource_size_;
   viz::ResourceFormat resource_format_;
   gfx::ColorSpace resource_color_space_;
@@ -201,8 +204,8 @@
   ZeroCopyGpuBacking* backing =
       static_cast<ZeroCopyGpuBacking*>(resource.gpu_backing());
 
-  return std::make_unique<ZeroCopyRasterBufferImpl>(gpu_memory_buffer_manager_,
-                                                    resource, backing);
+  return std::make_unique<ZeroCopyRasterBufferImpl>(
+      gpu_memory_buffer_manager_, shutdown_event_, resource, backing);
 }
 
 void ZeroCopyRasterBufferProvider::Flush() {}
@@ -234,6 +237,11 @@
   return 0;
 }
 
+void ZeroCopyRasterBufferProvider::SetShutdownEvent(
+    base::WaitableEvent* shutdown_event) {
+  shutdown_event_ = shutdown_event;
+}
+
 void ZeroCopyRasterBufferProvider::Shutdown() {}
 
 }  // namespace cc