cc: Use correct message loop proxy in BlockingTaskRunner

cc/layers/delegated_frame_resource_collection_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 "base/bind.h"
 #include "base/run_loop.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
 #include "cc/layers/delegated_frame_resource_collection.h"
 #include "cc/resources/returned_resource.h"
 #include "cc/resources/transferable_resource.h"
+#include "cc/trees/blocking_task_runner.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace cc {
 namespace {
 
 class DelegatedFrameResourceCollectionTest
     : public testing::Test,
       public DelegatedFrameResourceCollectionClient {
  protected:
   DelegatedFrameResourceCollectionTest() : resources_available_(false) {}
@@ skipping 49 matching lines @@
   // Start with one ref.
   EXPECT_TRUE(resource_collection_->HasOneRef());
 
   ReturnCallback return_callback =
       resource_collection_->GetReturnResourcesCallbackForImplThread();
 
   // Callback shouldn't take a ref since it's sent to other threads.
   EXPECT_TRUE(resource_collection_->HasOneRef());
 }
 
-void ReturnResourcesOnThread(ReturnCallback callback,
-                             const ReturnedResourceArray& resources,
-                             base::WaitableEvent* event) {
-  callback.Run(resources);
+void ReturnResourcesOnThread(
+    ReturnCallback callback,
+    const ReturnedResourceArray& resources,
+    base::WaitableEvent* event,
+    scoped_refptr<BlockingTaskRunner> main_thread_task_runner) {
+  callback.Run(resources, main_thread_task_runner);
   if (event)
     event->Wait();
 }
 
 // Tests that the ReturnCallback can run safely on threads even after the
 // last references to the collection were dropped.
 // Flaky: crbug.com/313441
 TEST_F(DelegatedFrameResourceCollectionTest, Thread) {
   base::Thread thread("test thread");
   thread.Start();
+  scoped_refptr<BlockingTaskRunner> main_thread_task_runner(
+      BlockingTaskRunner::Create(base::MessageLoopProxy::current()));
 
   TransferableResourceArray resources = CreateResourceArray();
   resource_collection_->ReceivedResources(resources);
   resource_collection_->RefResources(resources);
 
   ReturnedResourceArray returned_resources;
   TransferableResource::ReturnResources(resources, &returned_resources);
 
   base::WaitableEvent event(false, false);
 
   {
     base::RunLoop run_loop;
     resources_available_closure_ = run_loop.QuitClosure();
 
     thread.message_loop()->PostTask(
         FROM_HERE,
         base::Bind(
             &ReturnResourcesOnThread,
             resource_collection_->GetReturnResourcesCallbackForImplThread(),
             returned_resources,
-            &event));
+            &event,
+            main_thread_task_runner));
 
     run_loop.Run();
   }
   EXPECT_TRUE(ReturnAndResetResourcesAvailable());
   EXPECT_EQ(1u, returned_resources_.size());
   EXPECT_EQ(444u, returned_resources_[0].id);
   EXPECT_EQ(1, returned_resources_[0].count);
   returned_resources_.clear();
 
   // The event prevents the return resources callback from being deleted.
@@ skipping 18 matching lines @@
   EXPECT_EQ(444u, returned_resources_[0].id);
   EXPECT_EQ(1, returned_resources_[0].count);
   EXPECT_TRUE(returned_resources_[0].lost);
   returned_resources_.clear();
 
   base::WaitableEvent* null_event = NULL;
   thread.message_loop()->PostTask(FROM_HERE,
                                   base::Bind(&ReturnResourcesOnThread,
                                              return_callback,
                                              returned_resources,
-                                             null_event));
+                                             null_event,
+                                             main_thread_task_runner));
 
   thread.Stop();
 }
 
 }  // namespace
 }  // namespace cc