Update from https://crrev.com/316786

cc/resources/tile_task_worker_pool_unittest.cc

 // Copyright 2013 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/resources/tile_task_worker_pool.h"
 
 #include <limits>
 #include <vector>
 
 #include "base/cancelable_callback.h"
 #include "cc/base/unique_notifier.h"
 #include "cc/resources/bitmap_tile_task_worker_pool.h"
+#include "cc/resources/gpu_rasterizer.h"
 #include "cc/resources/gpu_tile_task_worker_pool.h"
 #include "cc/resources/one_copy_tile_task_worker_pool.h"
 #include "cc/resources/picture_pile.h"
 #include "cc/resources/picture_pile_impl.h"
 #include "cc/resources/pixel_buffer_tile_task_worker_pool.h"
 #include "cc/resources/raster_buffer.h"
 #include "cc/resources/resource_pool.h"
 #include "cc/resources/resource_provider.h"
 #include "cc/resources/scoped_resource.h"
 #include "cc/resources/tile_task_runner.h"
@@ skipping 96 matching lines @@
     unsigned id;
     bool canceled;
   };
 
   typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
 
   enum NamedTaskSet { REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW, ALL };
 
   TileTaskWorkerPoolTest()
       : context_provider_(TestContextProvider::Create()),
+        worker_context_provider_(TestContextProvider::Create()),
         all_tile_tasks_finished_(
             base::MessageLoopProxy::current().get(),
             base::Bind(&TileTaskWorkerPoolTest::AllTileTasksFinished,
                        base::Unretained(this))),
         timeout_seconds_(5),
         timed_out_(false) {}
 
   // Overridden from testing::Test:
   void SetUp() override {
     switch (GetParam()) {
@@ skipping 14 matching lines @@
         Create3dOutputSurfaceAndResourceProvider();
         staging_resource_pool_ = ResourcePool::Create(resource_provider_.get(),
                                                       GL_TEXTURE_2D);
         tile_task_worker_pool_ = OneCopyTileTaskWorkerPool::Create(
             base::MessageLoopProxy::current().get(),
             TileTaskWorkerPool::GetTaskGraphRunner(), context_provider_.get(),
             resource_provider_.get(), staging_resource_pool_.get());
         break;
       case TILE_TASK_WORKER_POOL_TYPE_GPU:
         Create3dOutputSurfaceAndResourceProvider();
+        rasterizer_ = GpuRasterizer::Create(
+            context_provider_.get(), resource_provider_.get(), false, false, 0);
         tile_task_worker_pool_ = GpuTileTaskWorkerPool::Create(
             base::MessageLoopProxy::current().get(),
             TileTaskWorkerPool::GetTaskGraphRunner(),
-            resource_provider_.get());
+            static_cast<GpuRasterizer*>(rasterizer_.get()));
         break;
       case TILE_TASK_WORKER_POOL_TYPE_BITMAP:
         CreateSoftwareOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = BitmapTileTaskWorkerPool::Create(
             base::MessageLoopProxy::current().get(),
             TileTaskWorkerPool::GetTaskGraphRunner(), resource_provider_.get());
         break;
     }
 
     DCHECK(tile_task_worker_pool_);
@@ skipping 87 matching lines @@
                    base::Unretained(this), base::Passed(&resource), id),
         lock, &empty));
   }
 
   const std::vector<RasterTaskResult>& completed_tasks() const {
     return completed_tasks_;
   }
 
  private:
   void Create3dOutputSurfaceAndResourceProvider() {
-    output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
+    output_surface_ = FakeOutputSurface::Create3d(
+                          context_provider_, worker_context_provider_).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
     TestWebGraphicsContext3D* context3d = context_provider_->TestContext3d();
     context3d->set_support_sync_query(true);
     resource_provider_ = ResourceProvider::Create(output_surface_.get(), NULL,
                                                   &gpu_memory_buffer_manager_,
                                                   NULL, 0, false, 1).Pass();
   }
 
   void CreateSoftwareOutputSurfaceAndResourceProvider() {
     output_surface_ = FakeOutputSurface::CreateSoftware(
@@ skipping 14 matching lines @@
     completed_tasks_.push_back(result);
   }
 
   void OnTimeout() {
     timed_out_ = true;
     base::MessageLoop::current()->Quit();
   }
 
  protected:
   scoped_refptr<TestContextProvider> context_provider_;
+  scoped_refptr<TestContextProvider> worker_context_provider_;
+  scoped_ptr<Rasterizer> rasterizer_;
   FakeOutputSurfaceClient output_surface_client_;
   scoped_ptr<FakeOutputSurface> output_surface_;
   scoped_ptr<ResourceProvider> resource_provider_;
   scoped_ptr<ResourcePool> staging_resource_pool_;
   scoped_ptr<TileTaskWorkerPool> tile_task_worker_pool_;
   TestGpuMemoryBufferManager gpu_memory_buffer_manager_;
   TestSharedBitmapManager shared_bitmap_manager_;
   base::CancelableClosure timeout_;
   UniqueNotifier all_tile_tasks_finished_;
   int timeout_seconds_;
@@ skipping 79 matching lines @@
     TileTaskWorkerPoolTests,
     TileTaskWorkerPoolTest,
     ::testing::Values(TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER,
                       TILE_TASK_WORKER_POOL_TYPE_ZERO_COPY,
                       TILE_TASK_WORKER_POOL_TYPE_ONE_COPY,
                       TILE_TASK_WORKER_POOL_TYPE_GPU,
                       TILE_TASK_WORKER_POOL_TYPE_BITMAP));
 
 }  // namespace
 }  // namespace cc