Revert of [blink] Unique pointers in Platform.h

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 489 matching lines @@
 };
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, HibernationLifeCycle)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationLifeCycle)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 32 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, HibernationReEntry)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationReEntry)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 39 matching lines @@
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest,
        HibernationLifeCycleWithDeferredRenderingDisabled)
 #else
 TEST_F(Canvas2DLayerBridgeTest,
        DISABLED_HibernationLifeCycleWithDeferredRenderingDisabled)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
   bridge->DisableDeferral(kDisableDeferralReasonUnknown);
   MockImageBuffer mock_image_buffer;
   EXPECT_CALL(mock_image_buffer, ResetCanvas(_)).Times(AnyNumber());
   bridge->SetImageBuffer(&mock_image_buffer);
@@ skipping 58 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED && CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU
 TEST_F(Canvas2DLayerBridgeTest, BackgroundRenderingWhileHibernating)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_BackgroundRenderingWhileHibernating)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 44 matching lines @@
 TEST_F(Canvas2DLayerBridgeTest,
        BackgroundRenderingWhileHibernatingWithDeferredRenderingDisabled)
 #else
 TEST_F(
     Canvas2DLayerBridgeTest,
     DISABLED_BackgroundRenderingWhileHibernatingWithDeferredRenderingDisabled)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
   MockImageBuffer mock_image_buffer;
   EXPECT_CALL(mock_image_buffer, ResetCanvas(_)).Times(AnyNumber());
   bridge->SetImageBuffer(&mock_image_buffer);
   bridge->DisableDeferral(kDisableDeferralReasonUnknown);
@@ skipping 52 matching lines @@
 
 #if CANVAS2D_HIBERNATION_ENABLED && CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU
 TEST_F(Canvas2DLayerBridgeTest, DisableDeferredRenderingWhileHibernating)
 #else
 TEST_F(Canvas2DLayerBridgeTest,
        DISABLED_DisableDeferredRenderingWhileHibernating)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
   MockImageBuffer mock_image_buffer;
   EXPECT_CALL(mock_image_buffer, ResetCanvas(_)).Times(AnyNumber());
   bridge->SetImageBuffer(&mock_image_buffer);
 
@@ skipping 50 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, TeardownWhileHibernating)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_TeardownWhileHibernating)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 23 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, SnapshotWhileHibernating)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_SnapshotWhileHibernating)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 42 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, TeardownWhileHibernationIsPending)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_TeardownWhileHibernationIsPending)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 27 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, HibernationAbortedDueToPendingTeardown)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationAbortedDueToPendingTeardown)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 25 matching lines @@
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, HibernationAbortedDueToVisibilityChange)
 #else
 TEST_F(Canvas2DLayerBridgeTest,
        DISABLED_HibernationAbortedDueToVisibilityChange)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 25 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, HibernationAbortedDueToLostContext)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_HibernationAbortedDueToLostContext)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 22 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED
 TEST_F(Canvas2DLayerBridgeTest, PrepareMailboxWhileHibernating)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_PrepareMailboxWhileHibernating)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 28 matching lines @@
 }
 
 #if CANVAS2D_HIBERNATION_ENABLED && CANVAS2D_BACKGROUND_RENDER_SWITCH_TO_CPU
 TEST_F(Canvas2DLayerBridgeTest, PrepareMailboxWhileBackgroundRendering)
 #else
 TEST_F(Canvas2DLayerBridgeTest, DISABLED_PrepareMailboxWhileBackgroundRendering)
 #endif
 {
   FakeGLES2Interface gl;
   std::unique_ptr<WebThread> test_thread =
-      Platform::Current()->CreateThread("TestThread");
+      WTF::WrapUnique(Platform::Current()->CreateThread("TestThread"));
 
   // The Canvas2DLayerBridge has to be created on the thread that will use it
   // to avoid WeakPtr thread check issues.
   Canvas2DLayerBridgePtr bridge;
   PostAndWaitCreateBridgeTask(BLINK_FROM_HERE, test_thread.get(), &bridge, &gl,
                               this);
 
   // Register an alternate Logger for tracking hibernation events
   std::unique_ptr<MockLogger> mock_logger = WTF::WrapUnique(new MockLogger);
   MockLogger* mock_logger_ptr = mock_logger.get();
@@ skipping 118 matching lines @@
   EXPECT_FALSE(bridge->HasRecordedDrawCommands());
   ::testing::Mock::VerifyAndClearExpectations(&gl);
 
   EXPECT_CALL(gl, Flush()).Times(1);
   bridge->FlushGpu();
   EXPECT_FALSE(bridge->HasRecordedDrawCommands());
   ::testing::Mock::VerifyAndClearExpectations(&gl);
 }
 
 }  // namespace blink