Remove OwnPtr from Blink.

third_party/WebKit/Source/platform/graphics/compositing/PaintArtifactCompositorTest.cpp

 // Copyright 2016 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 "platform/graphics/compositing/PaintArtifactCompositor.h"
 
 #include "base/test/test_simple_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "cc/layers/layer.h"
 #include "cc/test/fake_output_surface.h"
 #include "cc/trees/layer_tree_host.h"
 #include "cc/trees/layer_tree_settings.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/graphics/paint/PaintArtifact.h"
 #include "platform/testing/PictureMatchers.h"
 #include "platform/testing/TestPaintArtifact.h"
 #include "platform/testing/WebLayerTreeViewImplForTesting.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 namespace blink {
 namespace {
 
 using ::testing::Pointee;
 
 gfx::Transform translation(SkMScalar x, SkMScalar y)
 {
     gfx::Transform transform;
     transform.Translate(x, y);
     return transform;
 }
 
 class PaintArtifactCompositorTest : public ::testing::Test {
 protected:
     void SetUp() override
     {
         RuntimeEnabledFeatures::setSlimmingPaintV2Enabled(true);
 
         // Delay constructing the compositor until after the feature is set.
-        m_paintArtifactCompositor = adoptPtr(new PaintArtifactCompositor);
+        m_paintArtifactCompositor = wrapUnique(new PaintArtifactCompositor);
     }
 
     void TearDown() override
     {
         m_featuresBackup.restore();
     }
 
     PaintArtifactCompositor& getPaintArtifactCompositor() { return *m_paintArtifactCompositor; }
     cc::Layer* rootLayer() { return m_paintArtifactCompositor->rootLayer(); }
     void update(const PaintArtifact& artifact) { m_paintArtifactCompositor->update(artifact); }
 
 private:
     RuntimeEnabledFeatures::Backup m_featuresBackup;
-    OwnPtr<PaintArtifactCompositor> m_paintArtifactCompositor;
+    std::unique_ptr<PaintArtifactCompositor> m_paintArtifactCompositor;
 };
 
 TEST_F(PaintArtifactCompositorTest, EmptyPaintArtifact)
 {
     PaintArtifact emptyArtifact;
     update(emptyArtifact);
     EXPECT_TRUE(rootLayer()->children().empty());
 }
 
 TEST_F(PaintArtifactCompositorTest, OneChunkWithAnOffset)
@@ skipping 313 matching lines @@
     {
     }
 
     void SetUp() override
     {
         PaintArtifactCompositorTest::SetUp();
 
         cc::LayerTreeSettings settings = WebLayerTreeViewImplForTesting::defaultLayerTreeSettings();
         settings.single_thread_proxy_scheduler = false;
         settings.use_layer_lists = true;
-        m_webLayerTreeView = adoptPtr(new WebLayerTreeViewWithOutputSurface(settings));
+        m_webLayerTreeView = wrapUnique(new WebLayerTreeViewWithOutputSurface(settings));
         m_webLayerTreeView->setRootLayer(*getPaintArtifactCompositor().getWebLayer());
     }
 
     const cc::PropertyTrees& propertyTrees()
     {
         return *m_webLayerTreeView->layerTreeHost()->property_trees();
     }
 
     void update(const PaintArtifact& artifact)
     {
         PaintArtifactCompositorTest::update(artifact);
         m_webLayerTreeView->layerTreeHost()->LayoutAndUpdateLayers();
     }
 
 private:
     scoped_refptr<base::TestSimpleTaskRunner> m_taskRunner;
     base::ThreadTaskRunnerHandle m_taskRunnerHandle;
-    OwnPtr<WebLayerTreeViewWithOutputSurface> m_webLayerTreeView;
+    std::unique_ptr<WebLayerTreeViewWithOutputSurface> m_webLayerTreeView;
 };
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, EmptyPaintArtifact)
 {
     PaintArtifact emptyArtifact;
     update(emptyArtifact);
     EXPECT_TRUE(rootLayer()->children().empty());
 }
 
 TEST_F(PaintArtifactCompositorTestWithPropertyTrees, OneChunkWithAnOffset)
 {
     TestPaintArtifact artifact;
     artifact.chunk(PaintChunkProperties())
         .rectDrawing(FloatRect(50, -50, 100, 100), Color::white);
     update(artifact.build());
 
     ASSERT_EQ(1u, rootLayer()->children().size());
     const cc::Layer* child = rootLayer()->child_at(0);
     EXPECT_THAT(child->GetPicture(),
         Pointee(drawsRectangle(FloatRect(0, 0, 100, 100), Color::white)));
     EXPECT_EQ(translation(50, -50), child->screen_space_transform());
     EXPECT_EQ(gfx::Size(100, 100), child->bounds());
 }
 
 } // namespace
 } // namespace blink