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

third_party/WebKit/Source/modules/fetch/FetchFormDataConsumerHandleTest.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/FetchFormDataConsumerHandle.h"
 
 #include "core/dom/DOMTypedArray.h"
 #include "core/html/FormData.h"
-#include "core/loader/ThreadableLoader.h"
+#include "core/loader/MockThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/testing/DummyPageHolder.h"
 #include "modules/fetch/DataConsumerHandleTestUtil.h"
 #include "platform/network/ResourceResponse.h"
 #include "platform/testing/UnitTestHelpers.h"
 #include "platform/weborigin/KURL.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "wtf/PassOwnPtr.h"
 #include "wtf/PassRefPtr.h"
 #include "wtf/RefPtr.h"
 #include "wtf/Vector.h"
 #include "wtf/text/TextEncoding.h"
 #include "wtf/text/WTFString.h"
 #include <string.h>
 
 namespace blink {
 namespace {
 
 using Result = WebDataConsumerHandle::Result;
 const Result kOk = WebDataConsumerHandle::Ok;
 const Result kDone = WebDataConsumerHandle::Done;
 const Result kShouldWait = WebDataConsumerHandle::ShouldWait;
 const WebDataConsumerHandle::Flags kNone = WebDataConsumerHandle::FlagNone;
 using HandleReader = DataConsumerHandleTestUtil::HandleReader;
 using HandleTwoPhaseReader = DataConsumerHandleTestUtil::HandleTwoPhaseReader;
 using HandleReadResult = DataConsumerHandleTestUtil::HandleReadResult;
 template <typename T>
 using HandleReaderRunner = DataConsumerHandleTestUtil::HandleReaderRunner<T>;
 using ReplayingHandle = DataConsumerHandleTestUtil::ReplayingHandle;
 using Command = DataConsumerHandleTestUtil::Command;
 
+using ::testing::_;
+using ::testing::InvokeWithoutArgs;
+
 String toString(const Vector<char>& data)
 {
     return String(data.data(), data.size());
 }
 
-class NoopLoader final : public ThreadableLoader {
-public:
-    static PassRefPtr<ThreadableLoader> create() { return adoptRef(new NoopLoader); }
-    void overrideTimeout(unsigned long) override {}
-    void cancel() override {}
-};
-
 class LoaderFactory : public FetchBlobDataConsumerHandle::LoaderFactory {
 public:
-    explicit LoaderFactory(PassOwnPtr<WebDataConsumerHandle> handle) : m_handle(handle) {}
-    PassRefPtr<ThreadableLoader> create(ExecutionContext&, ThreadableLoaderClient* client, const ResourceRequest&, const ThreadableLoaderOptions&, const ResourceLoaderOptions&) override
+    explicit LoaderFactory(PassOwnPtr<WebDataConsumerHandle> handle)
+        : m_client(nullptr)
+        , m_handle(handle) {}
+    PassRefPtr<ThreadableLoader> create(ExecutionContext&, ThreadableLoaderClient* client, const ThreadableLoaderOptions&, const ResourceLoaderOptions&) override
     {
-        RefPtr<ThreadableLoader> loader = NoopLoader::create();
-        client->didReceiveResponse(0, ResourceResponse(), m_handle.release());
+        m_client = client;
+
+        RefPtr<MockThreadableLoader> loader = MockThreadableLoader::create();
+        EXPECT_CALL(*loader, start(_)).Times(1).WillOnce(InvokeWithoutArgs(this, &LoaderFactory::handleDidReceiveResponse));

[hiroshige, 2016/02/05 08:11:53]

nit: |Times(1).WillOnce(...)| looks redundant. Is just |.WillOnce(...)|
sufficient?

[tyoshino (SeeGerritForStatus), 2016/02/09 14:42:02]

Yeah. We're using the StrictMock, so WillOnce() is sufficient. I thought that
it's insufficient for non strict mocks, but the NiceMock also fails when extra
calls happen.

+        EXPECT_CALL(*loader, cancel()).Times(1);
         return loader.release();
     }
 
 private:
+    void handleDidReceiveResponse()
+    {
+        m_client->didReceiveResponse(0, ResourceResponse(), m_handle.release());
+    }
+
+    ThreadableLoaderClient* m_client;
     OwnPtr<WebDataConsumerHandle> m_handle;
 };
 
 class FetchFormDataConsumerHandleTest : public ::testing::Test {
 public:
     FetchFormDataConsumerHandleTest() : m_page(DummyPageHolder::create(IntSize(1, 1))) {}
 
 protected:
     Document* document() { return &m_page->document(); }
 
@@ skipping 355 matching lines @@
     EXPECT_EQ(kShouldWait, reader->beginRead(&buffer, kNone, &available));
     testing::runPendingTasks();
     EXPECT_EQ(kOk, reader->beginRead(&buffer, kNone, &available));
     EXPECT_FALSE(reader->drainAsFormData());
     reader->endRead(0);
     EXPECT_FALSE(reader->drainAsFormData());
 }
 
 } // namespace
 } // namespace blink