Remove OwnPtr from Blink.

third_party/WebKit/Source/modules/fetch/ResponseTest.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/fetch/Response.h"
 
 #include "bindings/core/v8/ExceptionState.h"
 #include "bindings/core/v8/ScriptState.h"
 #include "core/dom/Document.h"
 #include "core/frame/Frame.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/fetch/BodyStreamBuffer.h"
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 #include "modules/fetch/DataConsumerHandleUtil.h"
 #include "modules/fetch/FetchResponseData.h"
 #include "platform/blob/BlobData.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "public/platform/modules/serviceworker/WebServiceWorkerResponse.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/PtrUtil.h"
+#include <memory>
 
 namespace blink {
 namespace {
 
-PassOwnPtr<WebServiceWorkerResponse> createTestWebServiceWorkerResponse()
+std::unique_ptr<WebServiceWorkerResponse> createTestWebServiceWorkerResponse()
 {
     const KURL url(ParsedURLString, "http://www.webresponse.com/");
     const unsigned short status = 200;
     const String statusText = "the best status text";
     struct {
         const char* key;
         const char* value;
     } headers[] = { { "cache-control", "no-cache" }, { "set-cookie", "foop" }, { "foo", "bar" }, { 0, 0 } };
 
-    OwnPtr<WebServiceWorkerResponse> webResponse = adoptPtr(new WebServiceWorkerResponse());
+    std::unique_ptr<WebServiceWorkerResponse> webResponse = wrapUnique(new WebServiceWorkerResponse());
     webResponse->setURL(url);
     webResponse->setStatus(status);
     webResponse->setStatusText(statusText);
     webResponse->setResponseType(WebServiceWorkerResponseTypeDefault);
     for (int i = 0; headers[i].key; ++i)
         webResponse->setHeader(WebString::fromUTF8(headers[i].key), WebString::fromUTF8(headers[i].value));
     return webResponse;
 }
 
 class ServiceWorkerResponseTest : public ::testing::Test {
 public:
     ServiceWorkerResponseTest()
         : m_page(DummyPageHolder::create(IntSize(1, 1))) { }
 
     ScriptState* getScriptState() { return ScriptState::forMainWorld(m_page->document().frame()); }
     ExecutionContext* getExecutionContext() { return getScriptState()->getExecutionContext(); }
 
 private:
-    OwnPtr<DummyPageHolder> m_page;
+    std::unique_ptr<DummyPageHolder> m_page;
 };
 
 
 TEST_F(ServiceWorkerResponseTest, FromFetchResponseData)
 {
     const KURL url(ParsedURLString, "http://www.response.com");
 
     FetchResponseData* fetchResponseData = FetchResponseData::create();
     fetchResponseData->setURL(url);
 
     Response* response = Response::create(getExecutionContext(), fetchResponseData);
     ASSERT(response);
     EXPECT_EQ(url, response->url());
 }
 
 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponse)
 {
-    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
+    std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
     Response* response = Response::create(getScriptState(), *webResponse);
     ASSERT(response);
     EXPECT_EQ(webResponse->url(), response->url());
     EXPECT_EQ(webResponse->status(), response->status());
     EXPECT_STREQ(webResponse->statusText().utf8().c_str(), response->statusText().utf8().data());
 
     Headers* responseHeaders = response->headers();
 
     WebVector<WebString> keys = webResponse->getHeaderKeys();
     EXPECT_EQ(keys.size(), responseHeaders->headerList()->size());
     for (size_t i = 0, max = keys.size(); i < max; ++i) {
         WebString key = keys[i];
         TrackExceptionState exceptionState;
         EXPECT_STREQ(webResponse->getHeader(key).utf8().c_str(), responseHeaders->get(key, exceptionState).utf8().data());
         EXPECT_FALSE(exceptionState.hadException());
     }
 }
 
 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseDefault)
 {
-    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
+    std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
     webResponse->setResponseType(WebServiceWorkerResponseTypeDefault);
     Response* response = Response::create(getScriptState(), *webResponse);
 
     Headers* responseHeaders = response->headers();
     TrackExceptionState exceptionState;
     EXPECT_STREQ("foop", responseHeaders->get("set-cookie", exceptionState).utf8().data());
     EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data());
     EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionState).utf8().data());
     EXPECT_FALSE(exceptionState.hadException());
 }
 
 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseBasic)
 {
-    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
+    std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
     webResponse->setResponseType(WebServiceWorkerResponseTypeBasic);
     Response* response = Response::create(getScriptState(), *webResponse);
 
     Headers* responseHeaders = response->headers();
     TrackExceptionState exceptionState;
     EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().data());
     EXPECT_STREQ("bar", responseHeaders->get("foo", exceptionState).utf8().data());
     EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionState).utf8().data());
     EXPECT_FALSE(exceptionState.hadException());
 }
 
 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseCORS)
 {
-    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
+    std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
     webResponse->setResponseType(WebServiceWorkerResponseTypeCORS);
     Response* response = Response::create(getScriptState(), *webResponse);
 
     Headers* responseHeaders = response->headers();
     TrackExceptionState exceptionState;
     EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().data());
     EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data());
     EXPECT_STREQ("no-cache", responseHeaders->get("cache-control", exceptionState).utf8().data());
     EXPECT_FALSE(exceptionState.hadException());
 }
 
 TEST_F(ServiceWorkerResponseTest, FromWebServiceWorkerResponseOpaque)
 {
-    OwnPtr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
+    std::unique_ptr<WebServiceWorkerResponse> webResponse = createTestWebServiceWorkerResponse();
     webResponse->setResponseType(WebServiceWorkerResponseTypeOpaque);
     Response* response = Response::create(getScriptState(), *webResponse);
 
     Headers* responseHeaders = response->headers();
     TrackExceptionState exceptionState;
     EXPECT_STREQ("", responseHeaders->get("set-cookie", exceptionState).utf8().data());
     EXPECT_STREQ("", responseHeaders->get("foo", exceptionState).utf8().data());
     EXPECT_STREQ("", responseHeaders->get("cache-control", exceptionState).utf8().data());
     EXPECT_FALSE(exceptionState.hadException());
 }
@@ skipping 35 matching lines @@
     EXPECT_CALL(*client2, didFetchDataLoadedString(String("Hello, world")));
 
     response->internalBodyBuffer()->startLoading(FetchDataLoader::createLoaderAsString(), client1);
     clonedResponse->internalBodyBuffer()->startLoading(FetchDataLoader::createLoaderAsString(), client2);
     blink::testing::runPendingTasks();
 }
 
 BodyStreamBuffer* createHelloWorldBuffer(ScriptState* scriptState)
 {
     using Command = DataConsumerHandleTestUtil::Command;
-    OwnPtr<DataConsumerHandleTestUtil::ReplayingHandle> src(DataConsumerHandleTestUtil::ReplayingHandle::create());
+    std::unique_ptr<DataConsumerHandleTestUtil::ReplayingHandle> src(DataConsumerHandleTestUtil::ReplayingHandle::create());
     src->add(Command(Command::Data, "Hello, "));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Done));
     return new BodyStreamBuffer(scriptState, createFetchDataConsumerHandleFromWebHandle(std::move(src)));
 }
 
 TEST_F(ServiceWorkerResponseTest, BodyStreamBufferCloneDefault)
 {
     BodyStreamBuffer* buffer = createHelloWorldBuffer(getScriptState());
     FetchResponseData* fetchResponseData = FetchResponseData::createWithBuffer(buffer);
@@ skipping 51 matching lines @@
     EXPECT_CALL(*client1, didFetchDataLoadFailed());
     EXPECT_CALL(*client2, didFetchDataLoadFailed());
 
     response->internalBodyBuffer()->startLoading(FetchDataLoader::createLoaderAsString(), client1);
     clonedResponse->internalBodyBuffer()->startLoading(FetchDataLoader::createLoaderAsString(), client2);
     blink::testing::runPendingTasks();
 }
 
 } // namespace
 } // namespace blink