Update from https://crrev.com/309717

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_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"
@@ skipping 97 matching lines @@
     unsigned id;
     bool canceled;
   };
 
   typedef std::vector<scoped_refptr<RasterTask>> RasterTaskVector;
 
   enum NamedTaskSet { ALL, REQUIRED_FOR_ACTIVATION, REQUIRED_FOR_DRAW };
 
   TileTaskWorkerPoolTest()
       : 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()) {
       case TILE_TASK_WORKER_POOL_TYPE_PIXEL_BUFFER:
         Create3dOutputSurfaceAndResourceProvider();
         tile_task_worker_pool_ = PixelBufferTileTaskWorkerPool::Create(
             base::MessageLoopProxy::current().get(),
@@ skipping 31 matching lines @@
 
     DCHECK(tile_task_worker_pool_);
     tile_task_worker_pool_->AsTileTaskRunner()->SetClient(this);
   }
 
   void TearDown() override {
     tile_task_worker_pool_->AsTileTaskRunner()->Shutdown();
     tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
   }
 
+  void AllTileTasksFinished() {
+    tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
+    base::MessageLoop::current()->Quit();
+  }
+
   // Overriden from TileTaskWorkerPoolClient:
   void DidFinishRunningTileTasks(TaskSet task_set) override {
-    if (task_set == ALL) {
-      tile_task_worker_pool_->AsTileTaskRunner()->CheckForCompletedTasks();
-      base::MessageLoop::current()->Quit();
-    }
+    if (task_set == ALL)
+      all_tile_tasks_finished_.Schedule();
   }
+
   TaskSetCollection TasksThatShouldBeForcedToComplete() const override {
     return TaskSetCollection();
   }
 
   void RunMessageLoopUntilAllTasksHaveCompleted() {
     if (timeout_seconds_) {
       timeout_.Reset(base::Bind(&TileTaskWorkerPoolTest::OnTimeout,
                                 base::Unretained(this)));
       base::MessageLoopProxy::current()->PostDelayedTask(
           FROM_HERE, timeout_.callback(),
@@ skipping 94 matching lines @@
  protected:
   scoped_refptr<TestContextProvider> context_provider_;
   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_;
   bool timed_out_;
   RasterTaskVector tasks_;
   std::vector<RasterTaskResult> completed_tasks_;
 };
 
 TEST_P(TileTaskWorkerPoolTest, Basic) {
   AppendTask(0u);
   AppendTask(1u);
   ScheduleTasks();
@@ skipping 69 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