cc: Fix logic for detecting when raster tasks were throttled

cc/resources/raster_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/raster_worker_pool.h"
 
 #include <limits>
 #include <vector>
 
 #include "cc/resources/image_raster_worker_pool.h"
@@ skipping 52 matching lines @@
  protected:
   virtual ~TestRasterWorkerPoolTaskImpl() {}
 
  private:
   const Reply reply_;
   RasterThread raster_thread_;
 
   DISALLOW_COPY_AND_ASSIGN(TestRasterWorkerPoolTaskImpl);
 };
 
+class BlockingRasterWorkerPoolTaskImpl : public TestRasterWorkerPoolTaskImpl {
+ public:
+  BlockingRasterWorkerPoolTaskImpl(const Resource* resource,
+                                   const Reply& reply,
+                                   base::Lock* lock,
+                                   TaskVector* dependencies,
+                                   bool use_gpu_rasterization)
+      : TestRasterWorkerPoolTaskImpl(resource,
+                                     reply,
+                                     dependencies,
+                                     use_gpu_rasterization),
+        lock_(lock) {}
+
+  // Overridden from TestRasterWorkerPoolTaskImpl:
+  virtual bool RunOnWorkerThread(unsigned thread_index,
+                                 void* buffer,
+                                 gfx::Size size,
+                                 int stride) OVERRIDE {
+    base::AutoLock lock(*lock_);
+    return TestRasterWorkerPoolTaskImpl::RunOnWorkerThread(
+        thread_index, buffer, size, stride);
+  }
+  virtual void CompleteOnOriginThread() OVERRIDE {}
+
+ protected:
+  virtual ~BlockingRasterWorkerPoolTaskImpl() {}
+
+ private:
+  base::Lock* lock_;
+
+  DISALLOW_COPY_AND_ASSIGN(BlockingRasterWorkerPoolTaskImpl);
+};
+
 class RasterWorkerPoolTest : public testing::Test,
                              public RasterWorkerPoolClient  {
  public:
   RasterWorkerPoolTest()
       : context_provider_(TestContextProvider::Create()),
         check_interval_milliseconds_(1),
         timeout_seconds_(5),
         timed_out_(false) {
     output_surface_ = FakeOutputSurface::Create3d(context_provider_).Pass();
     CHECK(output_surface_->BindToClient(&output_surface_client_));
@@ skipping 100 matching lines @@
         RasterWorkerPool::RasterTask(new TestRasterWorkerPoolTaskImpl(
             const_resource,
             base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
                        base::Unretained(this),
                        base::Passed(&resource),
                        id),
             &empty.tasks_,
             use_gpu_rasterization)));
   }
 
+  void AppendBlockingTask(unsigned id, base::Lock* lock) {
+    const gfx::Size size(1, 1);
+
+    scoped_ptr<ScopedResource> resource(
+        ScopedResource::Create(resource_provider()));
+    resource->Allocate(size, ResourceProvider::TextureUsageAny, RGBA_8888);
+    const Resource* const_resource = resource.get();
+
+    RasterWorkerPool::Task::Set empty;
+    tasks_.push_back(
+        RasterWorkerPool::RasterTask(new BlockingRasterWorkerPoolTaskImpl(
+            const_resource,
+            base::Bind(&RasterWorkerPoolTest::OnTaskCompleted,
+                       base::Unretained(this),
+                       base::Passed(&resource),
+                       id),
+            lock,
+            &empty.tasks_,
+            false)));
+  }
+
   virtual void OnTaskCompleted(
       scoped_ptr<ScopedResource> resource,
       unsigned id,
       const PicturePileImpl::Analysis& analysis,
       bool was_canceled,
       TestRasterWorkerPoolTaskImpl::RasterThread raster_thread) {}
 
  private:
   void ScheduleCheckForCompletedTasks() {
     check_.Reset(base::Bind(&RasterWorkerPoolTest::OnCheckForCompletedTasks,
@@ skipping 169 matching lines @@
   }
 
   virtual void AfterTest() OVERRIDE {
     ASSERT_EQ(1u, tasks_.size());
     tasks_.clear();
   }
 };
 
 PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestFailedMapResource);
 
+class RasterWorkerPoolTestFalseThrottling : public RasterWorkerPoolTest {
+ public:
+  // Overridden from RasterWorkerPoolTest:
+  virtual void BeginTest() OVERRIDE {
+    // This test checks that replacing a pending raster task with another does
+    // not prevent the DidFinishRunningTasks notification from being sent.
+
+    // Schedule a task that is prevented from completing with a lock.
+    lock_.Acquire();
+    AppendBlockingTask(0u, &lock_);
+    ScheduleTasks();
+
+    // Schedule another task to replace the still-pending task. Because the old
+    // task is not a throttled task in the new task set, it should not prevent
+    // DidFinishRunningTasks from getting signaled.
+    tasks_.clear();
+    AppendTask(1u, false);
+    ScheduleTasks();
+
+    // Unblock the first task to allow the second task to complete.
+    lock_.Release();
+  }
+
+  virtual void AfterTest() OVERRIDE {}
+
+  virtual void DidFinishRunningTasks() OVERRIDE {
+    EndTest();
+  }
+
+  base::Lock lock_;
+};
+
+PIXEL_BUFFER_AND_IMAGE_TEST_F(RasterWorkerPoolTestFalseThrottling);
+
 }  // namespace
 
 }  // namespace cc