Replace AllowCrossThreadAccess() + non-GCed pointers with crossThreadUnretained()

third_party/WebKit/Source/platform/graphics/Canvas2DLayerBridgeTest.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 343 matching lines @@
     (*bridgePtr)->flush();
     doneEvent->signal();
 }
 
 void postAndWaitCreateBridgeTask(const WebTraceLocation& location, WebThread* testThread, Canvas2DLayerBridgePtr* bridgePtr, gpu::gles2::GLES2Interface* gl, Canvas2DLayerBridgeTest* testHost)
 {
     std::unique_ptr<WaitableEvent> bridgeCreatedEvent = wrapUnique(new WaitableEvent());
     testThread->getWebTaskRunner()->postTask(
         location,
         threadSafeBind(&runCreateBridgeTask,
-            AllowCrossThreadAccess(bridgePtr),
-            AllowCrossThreadAccess(gl),
-            AllowCrossThreadAccess(testHost),
-            AllowCrossThreadAccess(bridgeCreatedEvent.get())));
+            crossThreadUnretained(bridgePtr),
+            crossThreadUnretained(gl),
+            crossThreadUnretained(testHost),
+            crossThreadUnretained(bridgeCreatedEvent.get())));
     bridgeCreatedEvent->wait();
 }
 
 void runDestroyBridgeTask(Canvas2DLayerBridgePtr* bridgePtr, WaitableEvent* doneEvent)
 {
     bridgePtr->clear();
     if (doneEvent)
         doneEvent->signal();
 }
 
 void postDestroyBridgeTask(const WebTraceLocation& location, WebThread* testThread, Canvas2DLayerBridgePtr* bridgePtr)
 {
     testThread->getWebTaskRunner()->postTask(
         location,
         threadSafeBind(&runDestroyBridgeTask,
-            AllowCrossThreadAccess(bridgePtr),
+            crossThreadUnretained(bridgePtr),
             nullptr));
 }
 
 void postAndWaitDestroyBridgeTask(const WebTraceLocation& location, WebThread* testThread, Canvas2DLayerBridgePtr* bridgePtr)
 {
     std::unique_ptr<WaitableEvent> bridgeDestroyedEvent = wrapUnique(new WaitableEvent());
     testThread->getWebTaskRunner()->postTask(
         location,
         threadSafeBind(&runDestroyBridgeTask,
-            AllowCrossThreadAccess(bridgePtr),
-            AllowCrossThreadAccess(bridgeDestroyedEvent.get())));
+            crossThreadUnretained(bridgePtr),
+            crossThreadUnretained(bridgeDestroyedEvent.get())));
     bridgeDestroyedEvent->wait();
 }
 
 void runSetIsHiddenTask(Canvas2DLayerBridge* bridge, bool value, WaitableEvent* doneEvent)
 {
     bridge->setIsHidden(value);
     if (doneEvent)
         doneEvent->signal();
 }
 
 void postSetIsHiddenTask(const WebTraceLocation& location, WebThread* testThread, Canvas2DLayerBridge* bridge, bool value, WaitableEvent* doneEvent = nullptr)
 {
     testThread->getWebTaskRunner()->postTask(
         location,
         threadSafeBind(&runSetIsHiddenTask,
-            AllowCrossThreadAccess(bridge),
+            crossThreadUnretained(bridge),
             value,
-            AllowCrossThreadAccess(doneEvent)));
+            crossThreadUnretained(doneEvent)));
 }
 
 void postAndWaitSetIsHiddenTask(const WebTraceLocation& location, WebThread* testThread, Canvas2DLayerBridge* bridge, bool value)
 {
     std::unique_ptr<WaitableEvent> doneEvent = wrapUnique(new WaitableEvent());
     postSetIsHiddenTask(location, testThread, bridge, value, doneEvent.get());
     doneEvent->wait();
 }
 
 class MockImageBuffer : public ImageBuffer {
@@ skipping 157 matching lines @@
     bridge->flush();
     doneEvent->signal();
 }
 
 void postAndWaitRenderingTask(const WebTraceLocation& location, WebThread* testThread, Canvas2DLayerBridge* bridge)
 {
     std::unique_ptr<WaitableEvent> doneEvent = wrapUnique(new WaitableEvent());
     testThread->getWebTaskRunner()->postTask(
         location,
         threadSafeBind(&runRenderingTask,
-            AllowCrossThreadAccess(bridge),
-            AllowCrossThreadAccess(doneEvent.get())));
+            crossThreadUnretained(bridge),
+            crossThreadUnretained(doneEvent.get())));
     doneEvent->wait();
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED && CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU
 TEST_F(Canvas2DLayerBridgeTest, BackgroundRenderingWhileHibernating)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_BackgroundRenderingWhileHibernating)
 #endif
 {
     FakeGLES2Interface gl;
@@ skipping 325 matching lines @@
     std::unique_ptr<MockLogger> mockLogger = wrapUnique(new MockLogger);
     MockLogger* mockLoggerPtr = mockLogger.get();
     bridge->setLoggerForTesting(std::move(mockLogger));
 
     // Test entering hibernation
     std::unique_ptr<WaitableEvent> hibernationAbortedEvent = wrapUnique(new WaitableEvent());
     EXPECT_CALL(*mockLoggerPtr, reportHibernationEvent(Canvas2DLayerBridge::HibernationScheduled));
     EXPECT_CALL(*mockLoggerPtr, reportHibernationEvent(Canvas2DLayerBridge::HibernationAbortedDueToPendingDestruction))
         .WillOnce(testing::InvokeWithoutArgs(hibernationAbortedEvent.get(), &WaitableEvent::signal));
     postSetIsHiddenTask(BLINK_FROM_HERE, testThread.get(), bridge.get(), true);
-    testThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&Canvas2DLayerBridge::beginDestruction, AllowCrossThreadAccess(bridge.get())));
+    testThread->getWebTaskRunner()->postTask(BLINK_FROM_HERE, threadSafeBind(&Canvas2DLayerBridge::beginDestruction, crossThreadUnretained(bridge.get())));
     hibernationAbortedEvent->wait();
 
     ::testing::Mock::VerifyAndClearExpectations(mockLoggerPtr);
 
     // Tear down bridge on thread
     postAndWaitDestroyBridgeTask(BLINK_FROM_HERE, testThread.get(), &bridge);
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, HibernationAbortedDueToVisibilityChange)
@@ skipping 147 matching lines @@
     EXPECT_FALSE(bridge->prepareMailbox(&mailbox, 0));
     EXPECT_TRUE(bridge->checkSurfaceValid());
 
     // Tear down the bridge on the thread so that 'bridge' can go out of scope
     // without crashing due to thread checks
     postAndWaitDestroyBridgeTask(BLINK_FROM_HERE, testThread.get(), &bridge);
 }
 
 
 } // namespace blink