Split the constructor of ThreadableLoader into two methods (ctor and start())

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/ThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
@@ skipping 33 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_METHOD5(create, PassRefPtr<ThreadableLoader>(ExecutionContext&, ThreadableLoaderClient*, const ResourceRequest&, const ThreadableLoaderOptions&, const ResourceLoaderOptions&));
+    MOCK_METHOD4(create, PassRefPtr<ThreadableLoader>(ExecutionContext&, ThreadableLoaderClient*, const ThreadableLoaderOptions&, const ResourceLoaderOptions&));
 };
 
 class MockThreadableLoader : public ThreadableLoader {
 public:
     static PassRefPtr<MockThreadableLoader> create() { return adoptRef(new StrictMock<MockThreadableLoader>); }
 
+    MOCK_METHOD1(start, void(const ResourceRequest&));
     MOCK_METHOD1(overrideTimeout, void(unsigned long));
     MOCK_METHOD0(cancel, void());
 
 protected:
     MockThreadableLoader() = default;
 };
 
 PassRefPtr<BlobDataHandle> createBlobDataHandle(const char* s)
 {
     OwnPtr<BlobData> data = BlobData::create();
@@ skipping 30 matching lines @@
     Checkpoint checkpoint;
 
     ResourceRequest request;
     ThreadableLoaderOptions options;
     ResourceLoaderOptions resourceLoaderOptions;
 
     RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _, _)).WillOnce(DoAll(
-        SaveArg<2>(&request),
-        SaveArg<3>(&options),
-        SaveArg<4>(&resourceLoaderOptions),
+    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(
+        SaveArg<2>(&options),
+        SaveArg<3>(&resourceLoaderOptions),
         Return(loader.get())));
+    EXPECT_CALL(*loader, start(_)).WillOnce(SaveArg<0>(&request));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*loader, 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);
@@ skipping 19 matching lines @@
 
 TEST_F(FetchBlobDataConsumerHandleTest, CancelLoaderWhenStopped)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _, _)).WillOnce(Return(loader.get()));
+    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(Return(loader.get()));
+    EXPECT_CALL(*loader, start(_));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*loader, 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();
 
     InSequence s;
     EXPECT_CALL(checkpoint, Call(1));
-    EXPECT_CALL(*factory, create(Ref(document()), _, _, _, _)).WillOnce(Return(loader.get()));
+    EXPECT_CALL(*factory, create(Ref(document()), _, _, _)).WillOnce(Return(loader.get()));
+    EXPECT_CALL(*loader, start(_));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(checkpoint, Call(3));
     EXPECT_CALL(*loader, 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();
@@ skipping 13 matching lines @@
 TEST_F(FetchBlobDataConsumerHandleTest, ReadTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
     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(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
+    EXPECT_CALL(*loader, start(_));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*loader, 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, "));
@@ skipping 16 matching lines @@
 TEST_F(FetchBlobDataConsumerHandleTest, TwoPhaseReadTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
     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(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
+    EXPECT_CALL(*loader, start(_));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*loader, 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, "));
@@ skipping 16 matching lines @@
 TEST_F(FetchBlobDataConsumerHandleTest, LoadErrorTest)
 {
     auto factory = new StrictMock<MockLoaderFactory>;
     Checkpoint checkpoint;
 
     RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
     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(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
+    EXPECT_CALL(*loader, 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();
     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(*factory, create(Ref(document()), _, _, _)).WillOnce(DoAll(SaveArg<1>(&client), Return(loader.get())));
+    EXPECT_CALL(*loader, start(_));
     EXPECT_CALL(checkpoint, Call(2));
     EXPECT_CALL(*loader, 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, "));
@@ skipping 85 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