Remove OwnPtr from Blink.

third_party/WebKit/Source/modules/websockets/DocumentWebSocketChannelTest.cpp

 // Copyright 2014 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 "modules/websockets/WebSocketChannel.h"
 
 #include "core/dom/DOMArrayBuffer.h"
 #include "core/dom/Document.h"
 #include "core/fileapi/Blob.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/websockets/DocumentWebSocketChannel.h"
 #include "modules/websockets/WebSocketChannelClient.h"
 #include "platform/heap/Handle.h"
 #include "platform/v8_inspector/public/ConsoleTypes.h"
 #include "platform/weborigin/KURL.h"
 #include "public/platform/WebSecurityOrigin.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/websockets/WebSocketHandle.h"
 #include "public/platform/modules/websockets/WebSocketHandleClient.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
-#include "wtf/OwnPtr.h"
+#include "wtf/PtrUtil.h"
 #include "wtf/Vector.h"
 #include "wtf/text/WTFString.h"
+#include <memory>
 #include <stdint.h>
 
 using testing::_;
 using testing::InSequence;
 using testing::PrintToString;
 using testing::AnyNumber;
 
 
 namespace blink {
 
 namespace {
 
 typedef testing::StrictMock< testing::MockFunction<void(int)>> Checkpoint;
 
 class MockWebSocketChannelClient : public GarbageCollectedFinalized<MockWebSocketChannelClient>, public WebSocketChannelClient {
     USING_GARBAGE_COLLECTED_MIXIN(MockWebSocketChannelClient);
 public:
     static MockWebSocketChannelClient* create()
     {
         return new testing::StrictMock<MockWebSocketChannelClient>();
     }
 
     MockWebSocketChannelClient() { }
 
     ~MockWebSocketChannelClient() override { }
 
     MOCK_METHOD2(didConnect, void(const String&, const String&));
     MOCK_METHOD1(didReceiveTextMessage, void(const String&));
-    void didReceiveBinaryMessage(PassOwnPtr<Vector<char>> payload) override
+    void didReceiveBinaryMessage(std::unique_ptr<Vector<char>> payload) override
     {
         didReceiveBinaryMessageMock(*payload);
     }
     MOCK_METHOD1(didReceiveBinaryMessageMock, void(const Vector<char>&));
     MOCK_METHOD0(didError, void());
     MOCK_METHOD1(didConsumeBufferedAmount, void(uint64_t));
     MOCK_METHOD0(didStartClosingHandshake, void());
     MOCK_METHOD3(didClose, void(ClosingHandshakeCompletionStatus, unsigned short, const String&));
 
     DEFINE_INLINE_VIRTUAL_TRACE()
@@ skipping 68 matching lines @@
             InSequence s;
             EXPECT_CALL(*handle(), connect(WebURL(KURL(KURL(), "ws://localhost/")), _, _, handleClient()));
             EXPECT_CALL(*handle(), flowControl(65536));
             EXPECT_CALL(*channelClient(), didConnect(String("a"), String("b")));
         }
         EXPECT_TRUE(channel()->connect(KURL(KURL(), "ws://localhost/"), "x"));
         handleClient()->didConnect(handle(), WebString("a"), WebString("b"));
         ::testing::Mock::VerifyAndClearExpectations(this);
     }
 
-    OwnPtr<DummyPageHolder> m_pageHolder;
+    std::unique_ptr<DummyPageHolder> m_pageHolder;
     Persistent<MockWebSocketChannelClient> m_channelClient;
     MockWebSocketHandle* m_handle;
     Persistent<DocumentWebSocketChannel> m_channel;
     unsigned long m_sumOfConsumedBufferedAmount;
 };
 
 MATCHER_P2(MemEq, p, len,
     std::string("pointing to memory")
     + (negation ? " not" : "")
     + " equal to \""
@@ skipping 78 matching lines @@
     {
         InSequence s;
         EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("foo", 3), 3));
     }
 
     handleClient()->didReceiveFlowControl(handle(), 16);
     EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
     Vector<char> fooVector;
     fooVector.append("foo", 3);
-    channel()->sendBinaryAsCharVector(adoptPtr(new Vector<char>(fooVector)));
+    channel()->sendBinaryAsCharVector(wrapUnique(new Vector<char>(fooVector)));
 
     EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInVectorWithNullBytes)
 {
     connect();
     {
         InSequence s;
         EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("\0ar", 3), 3));
         EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("b\0z", 3), 3));
         EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("qu\0", 3), 3));
         EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("\0\0\0", 3), 3));
     }
 
     handleClient()->didReceiveFlowControl(handle(), 16);
     EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
     {
         Vector<char> v;
         v.append("\0ar", 3);
-        channel()->sendBinaryAsCharVector(adoptPtr(new Vector<char>(v)));
+        channel()->sendBinaryAsCharVector(wrapUnique(new Vector<char>(v)));
     }
     {
         Vector<char> v;
         v.append("b\0z", 3);
-        channel()->sendBinaryAsCharVector(adoptPtr(new Vector<char>(v)));
+        channel()->sendBinaryAsCharVector(wrapUnique(new Vector<char>(v)));
     }
     {
         Vector<char> v;
         v.append("qu\0", 3);
-        channel()->sendBinaryAsCharVector(adoptPtr(new Vector<char>(v)));
+        channel()->sendBinaryAsCharVector(wrapUnique(new Vector<char>(v)));
     }
     {
         Vector<char> v;
         v.append("\0\0\0", 3);
-        channel()->sendBinaryAsCharVector(adoptPtr(new Vector<char>(v)));
+        channel()->sendBinaryAsCharVector(wrapUnique(new Vector<char>(v)));
     }
 
     EXPECT_EQ(12ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInVectorNonLatin1UTF8)
 {
     connect();
     EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("\xe7\x8b\x90", 3), 3));
 
     handleClient()->didReceiveFlowControl(handle(), 16);
     EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
     Vector<char> v;
     v.append("\xe7\x8b\x90", 3);
-    channel()->sendBinaryAsCharVector(adoptPtr(new Vector<char>(v)));
+    channel()->sendBinaryAsCharVector(wrapUnique(new Vector<char>(v)));
 
     EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInVectorNonUTF8)
 {
     connect();
     EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeBinary, MemEq("\x80\xff\xe7", 3), 3));
 
     handleClient()->didReceiveFlowControl(handle(), 16);
     EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
     Vector<char> v;
     v.append("\x80\xff\xe7", 3);
-    channel()->sendBinaryAsCharVector(adoptPtr(new Vector<char>(v)));
+    channel()->sendBinaryAsCharVector(wrapUnique(new Vector<char>(v)));
 
     EXPECT_EQ(3ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInVectorNonLatin1UTF8Continuation)
 {
     connect();
     Checkpoint checkpoint;
     {
         InSequence s;
         EXPECT_CALL(*handle(), send(false, WebSocketHandle::MessageTypeBinary, MemEq("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7", 16), 16));
         EXPECT_CALL(checkpoint, Call(1));
         EXPECT_CALL(*handle(), send(true, WebSocketHandle::MessageTypeContinuation, MemEq("\x8b\x90", 2), 2));
     }
 
     handleClient()->didReceiveFlowControl(handle(), 16);
     EXPECT_CALL(*channelClient(), didConsumeBufferedAmount(_)).Times(AnyNumber());
 
     Vector<char> v;
     v.append("\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90\xe7\x8b\x90", 18);
-    channel()->sendBinaryAsCharVector(adoptPtr(new Vector<char>(v)));
+    channel()->sendBinaryAsCharVector(wrapUnique(new Vector<char>(v)));
     checkpoint.Call(1);
 
     handleClient()->didReceiveFlowControl(handle(), 16);
 
     EXPECT_EQ(18ul, m_sumOfConsumedBufferedAmount);
 }
 
 TEST_F(DocumentWebSocketChannelTest, sendBinaryInArrayBuffer)
 {
     connect();
@@ skipping 336 matching lines @@
         EXPECT_CALL(*channelClient(), didError());
         EXPECT_CALL(*channelClient(), didClose(WebSocketChannelClient::ClosingHandshakeIncomplete, WebSocketChannel::CloseEventCodeAbnormalClosure, String()));
     }
 
     channel()->fail("fail message from WebSocket", ErrorMessageLevel, SourceLocation::create(String(), 0, 0, nullptr));
 }
 
 } // namespace
 
 } // namespace blink