Revert of Move ThreadableLoader to Oilpan heap (2/3)

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"
@@ skipping 35 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, ThreadableLoader*(ExecutionContext&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&));
+    std::unique_ptr<ThreadableLoader> create(ExecutionContext& executionContext, ThreadableLoaderClient* client, const ThreadableLoaderOptions& threadableLoaderOptions, const ResourceLoaderOptions& resourceLoaderOptions) override
+    {
+        return wrapUnique(createInternal(executionContext, client, threadableLoaderOptions, resourceLoaderOptions));
+    }
+
+    MOCK_METHOD4(createInternal, ThreadableLoader*(ExecutionContext&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&));
 };
 
 PassRefPtr<BlobDataHandle> createBlobDataHandle(const char* s)
 {
     std::unique_ptr<BlobData> data = BlobData::create();
     data->appendText(s, false);
     auto size = data->length();
     return BlobDataHandle::create(std::move(data), size);
 }
 
@@ skipping 21 matching lines @@
 
 TEST_F(FetchBlobDataConsumerHandleTest, CreateLoader)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     ResourceRequest request;
     ThreadableLoaderOptions options;
     ResourceLoaderOptions resourceLoaderOptions;
 
-    Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
+    std::unique_ptr<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.release())));
+    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");
     std::unique_ptr<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;
 
-    Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
+    std::unique_ptr<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.release()));
+    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");
     std::unique_ptr<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;
 
-    Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
+    std::unique_ptr<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.release()));
+    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");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
     std::unique_ptr<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);
     ThreadHeap::collectAllGarbage();
     checkpoint.Call(4);
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, ReadTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
-    Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
+    std::unique_ptr<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.release())));
+    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");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     std::unique_ptr<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(), std::move(src));
     HandleReaderRunner<HandleReader> runner(std::move(handle));
     std::unique_ptr<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;
 
-    Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
+    std::unique_ptr<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.release())));
+    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");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     std::unique_ptr<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(), std::move(src));
     HandleReaderRunner<HandleTwoPhaseReader> runner(std::move(handle));
     std::unique_ptr<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;
 
-    Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
+    std::unique_ptr<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.release())));
+    EXPECT_CALL(*loaderPtr, start(_));
     EXPECT_CALL(checkpoint, Call(2));
 
     RefPtr<BlobDataHandle> blobDataHandle = createBlobDataHandle("Once upon a time");
     std::unique_ptr<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(std::move(handle));
     std::unique_ptr<HandleReadResult> r = runner.wait();
     EXPECT_EQ(kUnexpectedError, r->result());
 }
 
 TEST_F(FetchBlobDataConsumerHandleTest, BodyLoadErrorTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
-    Persistent<MockThreadableLoader> loader = MockThreadableLoader::create();
+    std::unique_ptr<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.release())));
+    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");
     std::unique_ptr<WebDataConsumerHandle> handle
         = FetchBlobDataConsumerHandle::create(&document(), blobDataHandle, factory);
 
     std::unique_ptr<ReplayingHandle> src = ReplayingHandle::create();
     src->add(Command(Command::Wait));
     src->add(Command(Command::Data, "hello, "));
     src->add(Command(Command::Error));
 
@@ skipping 83 matching lines @@
     std::unique_ptr<FetchDataConsumerHandle::Reader> reader = handle->obtainFetchDataReader(nullptr);
 
     const void* buffer;
     size_t available;
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     EXPECT_FALSE(reader->drainAsBlobDataHandle());
 }
 
 } // namespace
 } // namespace blink