[Loader] Make ThreadableLoader non-RefCounted and be managed by OwnPtr

third_party/WebKit/Source/modules/fetch/FetchBlobDataConsumerHandleTest.cpp

 // Copyright 2015 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/FetchBlobDataConsumerHandle.h"
 
 #include "core/dom/ExecutionContext.h"
 #include "core/fetch/ResourceLoaderOptions.h"
 #include "core/loader/MockThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 #include "platform/blob/BlobData.h"
 #include "platform/blob/BlobURL.h"
 #include "platform/network/ResourceError.h"
 #include "platform/network/ResourceRequest.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/OwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include <string.h>
 
 namespace blink {
 namespace {
 
 using Result = WebDataConsumerHandle::Result;
 const Result kShouldWait = WebDataConsumerHandle::ShouldWait;
 const Result kUnexpectedError = WebDataConsumerHandle::UnexpectedError;
@@ skipping 13 matching lines @@
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::Ref;
 using ::testing::Return;
 using ::testing::SaveArg;
 using ::testing::StrictMock;
 using Checkpoint = StrictMock<::testing::MockFunction<void(int)>>;
 
 class MockLoaderFactory : public FetchBlobDataConsumerHandle::LoaderFactory {
 public:
-    MOCK_METHOD4(create, PassRefPtr<ThreadableLoader>(ExecutionContext&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&));
+    PassOwnPtr<ThreadableLoader> create(ExecutionContext& executionContext, ThreadableLoaderClient* client, const ThreadableLoaderOptions& threadableLoaderOptions, const ResourceLoaderOptions& resourceLoaderOptions) override
+    {
+        return adoptPtr(createInternal(executionContext, client, threadableLoaderOptions, resourceLoaderOptions));
+    }
+
+    MOCK_METHOD4(createInternal, ThreadableLoader*(ExecutionContext&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&));
 };
 
 PassRefPtr<BlobDataHandle> createBlobDataHandle(const char* s)
 {
     OwnPtr<BlobData> data = BlobData::create();
     data->appendText(s, false);
     auto size = data->length();
     return BlobDataHandle::create(data.release(), size);
 }
 
@@ skipping 21 matching lines @@
 
 TEST_F(FetchBlobDataConsumerHandleTest, CreateLoader)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     ResourceRequest request;
     ThreadableLoaderOptions options;
     ResourceLoaderOptions resourceLoaderOptions;
 
-    RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    OwnPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    MockThreadableLoader* loaderPtr = loader.get();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(
+    EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(
         SaveArg<2>(&options),
         SaveArg<3>(&resourceLoaderOptions),
-        Return(loader.get())));
-    EXPECT_CALL(*loader, start(_)).WillOnce(SaveArg<0>(&request));
+        Return(loader.leakPtr())));
+    EXPECT_CALL(*loaderPtr, start(_)).WillOnce(SaveArg<0>(&request));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*loader, cancel());
+    EXPECT_CALL(*loaderPtr, cancel());
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     OwnPtr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
     testing::runPendingTasks();
 
     size_t size = 0;
     handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
     checkpoint.Call(1);
     testing::runPendingTasks();
@@ skipping 13 matching lines @@
     EXPECT_EQ(DocumentContext, resourceLoaderOptions.requestInitiatorContext);
     EXPECT_EQ(RequestAsynchronously, resourceLoaderOptions.synchronousPolicy);
     EXPECT_EQ(NotCORSEnabled, resourceLoaderOptions.corsEnabled);
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, CancelLoaderWhenStopped)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
-    RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    OwnPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    MockThreadableLoader* loaderPtr = loader.get();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(Return(loader.get()));
-    EXPECT_CALL(*loader, start(_));
+    EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(Return(loader.leakPtr()));
+    EXPECT_CALL(*loaderPtr, start(_));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*loader, cancel());
+    EXPECT_CALL(*loaderPtr, cancel());
     EXPECT_CALL(checkpoint, Call(3));
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     OwnPtr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
     testing::runPendingTasks();
 
     size_t size = 0;
     handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     document().stopActiveDOMObjects();
     checkpoint.Call(3);
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, CancelLoaderWhenDestinationDetached)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
-    RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    OwnPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    MockThreadableLoader* loaderPtr = loader.get();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(Return(loader.get()));
-    EXPECT_CALL(*loader, start(_));
+    EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(Return(loader.leakPtr()));
+    EXPECT_CALL(*loaderPtr, start(_));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(checkpoint, Call(3));
-    EXPECT_CALL(*loader, cancel());
+    EXPECT_CALL(*loaderPtr, cancel());
     EXPECT_CALL(checkpoint, Call(4));
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     OwnPtr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
     OwnPtr<WebDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
     testing::runPendingTasks();
 
     size_t size = 0;
     reader->read(nullptr, 0, kNone, &size);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     handle = nullptr;
     reader = nullptr;
     checkpoint.Call(3);
     Heap::collectAllGarbage();
     checkpoint.Call(4);
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, ReadTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
-    RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    OwnPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    MockThreadableLoader* loaderPtr = loader.get();
     ThreadableLoaderClient* client = nullptr;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
-    EXPECT_CALL(*loader, start(_));
+    EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.leakPtr())));
+    EXPECT_CALL(*loaderPtr, start(_));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*loader, cancel());
+    EXPECT_CALL(*loaderPtr, cancel());
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     OwnPtr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     OwnPtr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Done));
 
     size_t size = 0;
     handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     client->didReceiveResponse(0, ResourceResponse(), src.release());
     HandleReaderRunner<HandleReader> runner(handle.release());
     OwnPtr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     EXPECT_EQ("hello, world", toString(r->data()));
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, TwoPhaseReadTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
-    RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    OwnPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    MockThreadableLoader* loaderPtr = loader.get();
     ThreadableLoaderClient* client = nullptr;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
-    EXPECT_CALL(*loader, start(_));
+    EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.leakPtr())));
+    EXPECT_CALL(*loaderPtr, start(_));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*loader, cancel());
+    EXPECT_CALL(*loaderPtr, cancel());
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     OwnPtr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     OwnPtr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Data, "world"));
     src->add(Command(Command::Wait));
     src->add(Command(Command::Done));
 
     size_t size = 0;
     handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     client->didReceiveResponse(0, ResourceResponse(), src.release());
     HandleReaderRunner<HandleTwoPhaseReader> runner(handle.release());
     OwnPtr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kDone, r->result());
     EXPECT_EQ("hello, world", toString(r->data()));
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, LoadErrorTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
-    RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    OwnPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    MockThreadableLoader* loaderPtr = loader.get();
     ThreadableLoaderClient* client = nullptr;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
-    EXPECT_CALL(*loader, start(_));
+    EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.leakPtr())));
+    EXPECT_CALL(*loaderPtr, start(_));
     EXPECT_CALL(checkpoint, Call(2));
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     OwnPtr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     size_t size = 0;
     handle->obtainReader(nullptr)->read(nullptr, 0, kNone, &size);
     checkpoint.Call(1);
     testing::runPendingTasks();
     checkpoint.Call(2);
     client->didFail(ResourceError());
     HandleReaderRunner<HandleReader> runner(handle.release());
     OwnPtr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kUnexpectedError, r->result());
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, BodyLoadErrorTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
-    RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    OwnPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+    MockThreadableLoader* loaderPtr = loader.get();
     ThreadableLoaderClient* client = nullptr;
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
-    EXPECT_CALL(*loader, start(_));
+    EXPECT_CALL(*factory, createInternal(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.leakPtr())));
+    EXPECT_CALL(*loaderPtr, start(_));
     EXPECT_CALL(checkpoint, Call(2));
-    EXPECT_CALL(*loader, cancel());
+    EXPECT_CALL(*loaderPtr, cancel());
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     OwnPtr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     OwnPtr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Error));
 
@@ skipping 83 matching lines @@
     OwnPtr<FetchDataConsumerHandle::Reader> reader = handle->obtainReader(nullptr);
 
     const void* buffer;
     size_t available;
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     EXPECT_FALSE(reader->drainAsBlobDataHandle());
 }
 
 } // namespace
 } // namespace blink