[LoaderTest] Add unit tests for Document/WorkerThreadableLoader

third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp

Index: third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp
diff --git a/third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp b/third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp
new file mode 100644
index 0000000000000000000000000000000000000000..08cf8f8ec9d2d7f5d53927ffa24b8f42b8cda87f
--- /dev/null
+++ b/third_party/WebKit/Source/core/loader/ThreadableLoaderTest.cpp
@@ -0,0 +1,842 @@
+// Copyright 2016 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 "core/loader/ThreadableLoader.h"
+
+#include "core/dom/CrossThreadTask.h"
+#include "core/fetch/ResourceLoaderOptions.h"
+#include "core/loader/DocumentThreadableLoader.h"
+#include "core/loader/ThreadableLoaderClient.h"

[tyoshino (SeeGerritForStatus), 2016/03/03 14:43:19]

also include ThreadableLoader.h

[hiroshige, 2016/03/08 23:40:59]

It is included in Line 5.

[tyoshino (SeeGerritForStatus), 2016/03/09 06:26:12]

ahh, sorry.

+#include "core/loader/WorkerThreadableLoader.h"
+#include "core/testing/DummyPageHolder.h"
+#include "core/workers/WorkerThreadTestHelper.h"
+#include "platform/ThreadSafeFunctional.h"
+#include "platform/WaitableEvent.h"
+#include "platform/network/ResourceError.h"
+#include "platform/network/ResourceRequest.h"
+#include "platform/network/ResourceResponse.h"
+#include "platform/network/ResourceTimingInfo.h"
+#include "platform/testing/URLTestHelpers.h"
+#include "platform/testing/UnitTestHelpers.h"
+#include "platform/weborigin/KURL.h"
+#include "public/platform/Platform.h"
+#include "public/platform/WebURLLoadTiming.h"
+#include "public/platform/WebURLResponse.h"
+#include "public/platform/WebUnitTestSupport.h"
+#include "testing/gtest/include/gtest/gtest.h"

[tyoshino (SeeGerritForStatus), 2016/03/03 14:43:19]

Add

PassOwnPtr.h
WorkerLoaderProxy.h
OwnPtr.h
RefPtr.h
IntSize.h
CrossThreadCopier.h
Assertions.h
gmock.h
ContentSecurityPolicy.h
ContentSecurityPolicyParsers.h
Vector.h
V8CacheOptions.h
WebThreadSupportingGC.h

forward declare SecurityOrigin

[hiroshige, 2016/03/08 23:40:59]

Added:
I moved the related code to WorkerThreadTestHelper.h and add #include of the
following there:
Should we add CrossThreadCopier.h?
In general, I include ThreadSafeFunctional.h for threadSafeBind() but not
CrossThreadCopier.
Added include to here and to WorkerThreadTestHelper.h, because just a forward
declaration of SecurityOrigin is not sufficient.

[tyoshino (SeeGerritForStatus), 2016/03/09 06:26:12]

looks good
I suggested that since this file is using AllowCrossThreadAccess() directly.
ok

+
+namespace blink {
+
+namespace {
+
+using ::testing::_;
+using ::testing::AtMost;
+using ::testing::InSequence;
+using ::testing::InvokeWithoutArgs;
+using ::testing::StrEq;
+using ::testing::Truly;
+using Checkpoint = ::testing::StrictMock<::testing::MockFunction<void(int)>>;
+
+class MockThreadableLoaderClient : public ThreadableLoaderClient {
+public:
+    static PassOwnPtr<MockThreadableLoaderClient> create()
+    {
+        return adoptPtr(new ::testing::StrictMock<MockThreadableLoaderClient>);
+    }
+    MOCK_METHOD2(didSendData, void(unsigned long long, unsigned long long));
+    MOCK_METHOD3(didReceiveResponse, void(unsigned long, const ResourceResponse&, PassOwnPtr<WebDataConsumerHandle>));
+    MOCK_METHOD2(didReceiveData, void(const char*, unsigned));
+    MOCK_METHOD2(didReceiveCachedMetadata, void(const char*, int));
+    MOCK_METHOD2(didFinishLoading, void(unsigned long, double));
+    MOCK_METHOD1(didFail, void(const ResourceError&));
+    MOCK_METHOD1(didFailAccessControlCheck, void(const ResourceError&));
+    MOCK_METHOD0(didFailRedirectCheck, void());
+    MOCK_METHOD1(didReceiveResourceTiming, void(const ResourceTimingInfo&));
+    MOCK_METHOD1(didDownloadData, void(int));
+
+protected:
+    MockThreadableLoaderClient() = default;
+};
+
+bool isCancellation(const ResourceError& error)
+{
+    return error.isCancellation();
+}
+
+bool isNotCancellation(const ResourceError& error)
+{
+    return !error.isCancellation();
+}
+
+KURL successURL() { return KURL(KURL(), "http://example.com/success"); }
+KURL errorURL() { return KURL(KURL(), "http://example.com/error"); }
+KURL redirectURL() { return KURL(KURL(), "http://example.com/redirect"); }
+KURL redirectLoopURL() { return KURL(KURL(), "http://example.com/loop"); }
+
+enum ThreadableLoaderToTest {
+    DocumentThreadableLoaderTest,
+    WorkerThreadableLoaderTest
+};
+
+class ThreadableLoaderTestHelper {
+public:
+    virtual ~ThreadableLoaderTestHelper() { }
+
+    virtual void createLoader(ThreadableLoaderClient*, CrossOriginRequestPolicy) = 0;
+    virtual void startLoader(const ResourceRequest&) = 0;
+    virtual void cancelLoader() = 0;
+    virtual void clearLoader() = 0;
+    virtual Checkpoint& checkpoint() = 0;
+    virtual void callCheckpoint(int) = 0;
+    virtual void onSetUp() = 0;
+    virtual void onServeRequests() = 0;
+    virtual void onTearDown() = 0;
+};
+
+class DocumentThreadableLoaderTestHelper : public ThreadableLoaderTestHelper {
+public:
+    DocumentThreadableLoaderTestHelper()
+        : m_dummyPageHolder(DummyPageHolder::create(IntSize(1, 1)))
+    {
+    }
+
+    void createLoader(ThreadableLoaderClient* client, CrossOriginRequestPolicy crossOriginRequestPolicy) override
+    {
+        ThreadableLoaderOptions options;
+        options.crossOriginRequestPolicy = crossOriginRequestPolicy;
+        ResourceLoaderOptions resourceLoaderOptions;
+        m_loader = DocumentThreadableLoader::create(document(), client, options, resourceLoaderOptions);
+    }
+
+    void startLoader(const ResourceRequest& request) override
+    {
+        m_loader->start(request);
+    }
+
+    void cancelLoader() override { m_loader->cancel(); }
+    void clearLoader() override { m_loader.clear(); }
+    Checkpoint& checkpoint() override { return m_checkpoint; }
+    void callCheckpoint(int n) override { m_checkpoint.Call(n); }
+
+    void onSetUp() override
+    {
+    }
+
+    void onServeRequests() override
+    {
+    }
+
+    void onTearDown() override
+    {
+        m_loader.clear();
+    }
+
+private:
+    Document& document() { return m_dummyPageHolder->document(); }
+
+    OwnPtr<DummyPageHolder> m_dummyPageHolder;
+    Checkpoint m_checkpoint;
+    OwnPtr<DocumentThreadableLoader> m_loader;
+};
+
+class WorkerThreadableLoaderTestHelper : public ThreadableLoaderTestHelper, public WorkerLoaderProxyProvider {
+public:
+    WorkerThreadableLoaderTestHelper()
+        : m_dummyPageHolder(DummyPageHolder::create(IntSize(1, 1)))
+    {
+    }
+
+    void createLoader(ThreadableLoaderClient* client, CrossOriginRequestPolicy crossOriginRequestPolicy) override
+    {
+        OwnPtr<WaitableEvent> completionEvent = adoptPtr(new WaitableEvent());
+        postTaskToWorkerGlobalScope(createCrossThreadTask(
+            &WorkerThreadableLoaderTestHelper::workerCreateLoader,
+            AllowCrossThreadAccess(this),
+            AllowCrossThreadAccess(client),
+            AllowCrossThreadAccess(completionEvent.get()),
+            crossOriginRequestPolicy));
+        completionEvent->wait();
+    }
+
+    void startLoader(const ResourceRequest& request) override
+    {
+        OwnPtr<WaitableEvent> completionEvent = adoptPtr(new WaitableEvent());
+        postTaskToWorkerGlobalScope(createCrossThreadTask(
+            &WorkerThreadableLoaderTestHelper::workerStartLoader,
+            AllowCrossThreadAccess(this),
+            AllowCrossThreadAccess(completionEvent.get()),
+            request));
+        completionEvent->wait();
+    }
+
+    // Must be called on the worker thread.
+    void cancelLoader() override
+    {
+        ASSERT(m_workerThread);
+        ASSERT(m_workerThread->isCurrentThread());
+        m_loader->cancel();
+    }
+
+    // Must be called on the worker thread.
+    void clearLoader() override
+    {
+        ASSERT(m_workerThread);
+        ASSERT(m_workerThread->isCurrentThread());
+        m_loader.clear();
+    }
+
+    Checkpoint& checkpoint() override
+    {
+        return m_checkpoint;
+    }
+
+    void callCheckpoint(int n) override
+    {
+        testing::runPendingTasks();
+
+        OwnPtr<WaitableEvent> completionEvent = adoptPtr(new WaitableEvent());
+        postTaskToWorkerGlobalScope(createCrossThreadTask(
+            &WorkerThreadableLoaderTestHelper::workerCallCheckpoint,
+            AllowCrossThreadAccess(this),
+            AllowCrossThreadAccess(completionEvent.get()),
+            n));
+        completionEvent->wait();
+    }
+
+    void onSetUp() override
+    {
+        m_mockWorkerReportingProxy = adoptPtr(new MockWorkerReportingProxy());
+        m_securityOrigin = document().securityOrigin();
+        m_workerThread = adoptRef(new WorkerThreadForTest(
+            this,
+            *m_mockWorkerReportingProxy));
+
+        expectWorkerLifetimeReportingCalls();
+        startWorkerThread();
+        waitForInitWorkerThread();
+    }
+
+    void onServeRequests() override
+    {
+        testing::runPendingTasks();
+    }
+
+    void onTearDown() override
+    {
+        postTaskToWorkerGlobalScope(createCrossThreadTask(&WorkerThreadableLoaderTestHelper::clearLoader, AllowCrossThreadAccess(this)));
+        m_workerThread->terminateAndWait();
+
+        // Needed to clean up the things on the main thread side and
+        // avoid Resource leaks.
+        testing::runPendingTasks();
+
+        m_workerThread->workerLoaderProxy()->detachProvider(this);
+    }
+
+private:
+    Document& document() { return m_dummyPageHolder->document(); }
+
+    void expectWorkerLifetimeReportingCalls()
+    {
+        EXPECT_CALL(*m_mockWorkerReportingProxy, workerGlobalScopeStarted(_)).Times(1);
+        EXPECT_CALL(*m_mockWorkerReportingProxy, didEvaluateWorkerScript(true)).Times(1);
+        EXPECT_CALL(*m_mockWorkerReportingProxy, workerThreadTerminated()).Times(1);
+        EXPECT_CALL(*m_mockWorkerReportingProxy, willDestroyWorkerGlobalScope()).Times(1);
+    }
+
+    void startWorkerThread()
+    {
+        OwnPtr<Vector<CSPHeaderAndType>> headers = adoptPtr(new Vector<CSPHeaderAndType>());
+        CSPHeaderAndType headerAndType("contentSecurityPolicy", ContentSecurityPolicyHeaderTypeReport);
+        headers->append(headerAndType);
+
+        OwnPtrWillBeRawPtr<WorkerClients> clients = nullptr;
+
+        m_workerThread->start(WorkerThreadStartupData::create(
+            KURL(ParsedURLString, "http://fake.url/"),
+            "fake user agent",
+            "//fake source code",
+            nullptr,
+            DontPauseWorkerGlobalScopeOnStart,
+            headers.release(),
+            m_securityOrigin.get(),
+            clients.release(),
+            V8CacheOptionsDefault));
+    }
+
+    void waitForInitWorkerThread()
+    {
+        OwnPtr<WaitableEvent> completionEvent = adoptPtr(new WaitableEvent());
+        m_workerThread->backingThread().postTask(BLINK_FROM_HERE, threadSafeBind(&WaitableEvent::signal, AllowCrossThreadAccess(completionEvent.get())));
+        completionEvent->wait();
+    }
+
+    void workerCreateLoader(ThreadableLoaderClient* client, WaitableEvent* event, CrossOriginRequestPolicy crossOriginRequestPolicy)
+    {
+        ASSERT(m_workerThread);
+        ASSERT(m_workerThread->isCurrentThread());
+
+        ThreadableLoaderOptions options;
+        options.crossOriginRequestPolicy = crossOriginRequestPolicy;
+        ResourceLoaderOptions resourceLoaderOptions;
+        ASSERT(m_workerThread->workerGlobalScope()->isWorkerGlobalScope());

[tyoshino (SeeGerritForStatus), 2016/03/03 14:43:20]

OK, but wonder what kind of mistake we want to catch by this.

[hiroshige, 2016/03/08 23:40:59]

I think I added this ASSERT() from
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/WebKit...
i.e. to ensure ThreadableLoader::create() creates WorkerThreadableLoader.

[tyoshino (SeeGerritForStatus), 2016/03/09 06:26:12]

Ah, I see. I understood the motivation. But this would still look strange for
readers of this unittest without the knowledge of ThreadableLoader::create()
implementation.

Could you please add a comment like:

// ThreadableLoader::create() determines whether it should create
// a DocumentThreadableLoader or WorkerThreadableLoader based on
// isWorkerGlobalScope(). Ensure that we're passing an execution
// context that satisfies this requirement.

[hiroshige, 2016/03/11 19:52:14]

Done.

+        m_loader = ThreadableLoader::create(*m_workerThread->workerGlobalScope(), client, options, resourceLoaderOptions);
+        ASSERT(m_loader);
+        event->signal();
+    }
+
+    void workerStartLoader(WaitableEvent* event, PassOwnPtr<CrossThreadResourceRequestData> requestData)
+    {
+        ASSERT(m_workerThread);
+        ASSERT(m_workerThread->isCurrentThread());
+
+        ResourceRequest request(requestData.get());
+        m_loader->start(request);
+        event->signal();
+    }
+
+    void workerCallCheckpoint(WaitableEvent* event, int n)
+    {
+        ASSERT(m_workerThread);
+        ASSERT(m_workerThread->isCurrentThread());
+        m_checkpoint.Call(n);
+        event->signal();
+    }
+
+    // WorkerLoaderProxyProvider methods.
+    void postTaskToLoader(PassOwnPtr<ExecutionContextTask> task) override
+    {
+        ASSERT(m_workerThread);
+        ASSERT(m_workerThread->isCurrentThread());
+        document().postTask(BLINK_FROM_HERE, task);
+    }
+
+    bool postTaskToWorkerGlobalScope(PassOwnPtr<ExecutionContextTask> task) override
+    {
+        ASSERT(m_workerThread);
+        m_workerThread->postTask(BLINK_FROM_HERE, task);
+        return true;
+    }
+
+    RefPtr<SecurityOrigin> m_securityOrigin;
+    OwnPtr<MockWorkerReportingProxy> m_mockWorkerReportingProxy;
+    RefPtr<WorkerThreadForTest> m_workerThread;
+
+    OwnPtr<DummyPageHolder> m_dummyPageHolder;
+    Checkpoint m_checkpoint;
+    // |m_loader| must be touched only from the worker thread only.
+    OwnPtr<ThreadableLoader> m_loader;
+};
+
+class ThreadableLoaderTest : public ::testing::TestWithParam<ThreadableLoaderToTest> {
+public:
+    ThreadableLoaderTest()
+    {
+        switch (GetParam()) {
+        case DocumentThreadableLoaderTest:
+            m_helper = adoptPtr(new DocumentThreadableLoaderTestHelper);
+            break;
+        case WorkerThreadableLoaderTest:
+            m_helper = adoptPtr(new WorkerThreadableLoaderTestHelper);
+            break;
+        }
+    }
+
+    void startLoader(const KURL& url)
+    {
+        ResourceRequest request(url);
+        request.setRequestContext(WebURLRequest::RequestContextInternal);
+        m_helper->startLoader(request);
+    }
+
+    void cancelLoader() { m_helper->cancelLoader(); }
+    void clearLoader() { m_helper->clearLoader(); }
+    Checkpoint& checkpoint() { return m_helper->checkpoint(); }
+    void callCheckpoint(int n) { m_helper->callCheckpoint(n); }
+
+    void serveRequests()
+    {
+        m_helper->onServeRequests();
+        Platform::current()->unitTestSupport()->serveAsynchronousMockedRequests();
+    }
+
+    void createLoader(CrossOriginRequestPolicy crossOriginRequestPolicy = AllowCrossOriginRequests)
+    {
+        m_helper->createLoader(client(), crossOriginRequestPolicy);
+    }
+
+    MockThreadableLoaderClient* client() const { return m_client.get(); }
+
+private:
+    void SetUp() override
+    {
+        setUpSuccessURL();
+        setUpErrorURL();
+        setUpRedirectURL();
+        setUpRedirectLoopURL();
+
+        m_client = MockThreadableLoaderClient::create();
+        m_helper->onSetUp();
+    }
+
+    void TearDown() override
+    {
+        m_helper->onTearDown();
+        Platform::current()->unitTestSupport()->unregisterAllMockedURLs();
+        m_client.clear();
+    }
+
+    void setUpSuccessURL()
+    {
+        URLTestHelpers::registerMockedURLLoad(successURL(), "fox-null-terminated.html", "text/html");
+    }
+
+    void setUpErrorURL()
+    {
+        URLTestHelpers::registerMockedErrorURLLoad(errorURL());
+    }
+
+    void setUpRedirectURL()
+    {
+        KURL url = redirectURL();
+
+        WebURLLoadTiming timing;
+        timing.initialize();
+
+        WebURLResponse response;
+        response.initialize();
+        response.setURL(url);
+        response.setHTTPStatusCode(301);
+        response.setLoadTiming(timing);
+        response.addHTTPHeaderField("Location", successURL().string());
+        response.addHTTPHeaderField("Access-Control-Allow-Origin", "null");
+
+        URLTestHelpers::registerMockedURLLoadWithCustomResponse(url, "fox-null-terminated.html", "", response);
+    }
+
+    void setUpRedirectLoopURL()
+    {
+        KURL url = redirectLoopURL();
+
+        WebURLLoadTiming timing;
+        timing.initialize();
+
+        WebURLResponse response;
+        response.initialize();
+        response.setURL(url);
+        response.setHTTPStatusCode(301);
+        response.setLoadTiming(timing);
+        response.addHTTPHeaderField("Location", redirectLoopURL().string());
+        response.addHTTPHeaderField("Access-Control-Allow-Origin", "null");
+
+        URLTestHelpers::registerMockedURLLoadWithCustomResponse(url, "fox-null-terminated.html", "", response);
+    }
+
+    OwnPtr<MockThreadableLoaderClient> m_client;
+    OwnPtr<ThreadableLoaderTestHelper> m_helper;
+};
+
+INSTANTIATE_TEST_CASE_P(Document,
+    ThreadableLoaderTest,
+    ::testing::Values(DocumentThreadableLoaderTest));
+
+INSTANTIATE_TEST_CASE_P(Worker,
+    ThreadableLoaderTest,
+    ::testing::Values(WorkerThreadableLoaderTest));
+
+TEST_P(ThreadableLoaderTest, StartAndStop)
+{
+}
+
+TEST_P(ThreadableLoaderTest, CancelAfterStart)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);

[tyoshino (SeeGerritForStatus), 2016/03/03 14:43:19]

is this checkpoint for ensuring that the following expected calls happen after
createLoader() completes?

[hiroshige, 2016/03/08 23:40:59]

Yes, i.e. not synchronously in createLoader().

+
+    EXPECT_CALL(checkpoint(), Call(2)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+    EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
+    EXPECT_CALL(checkpoint(), Call(3));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    callCheckpoint(3);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearAfterStart)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+    EXPECT_CALL(checkpoint(), Call(3));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    callCheckpoint(3);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, CancelInDidReceiveResponse)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+    EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearInDidReceiveResponse)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, CancelIndidReceiveData)

[tyoshino (SeeGerritForStatus), 2016/03/03 14:43:19]

did -> Did

[hiroshige, 2016/03/08 23:40:59]

Done.

+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didReceiveData(_, _)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+    EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearIndidReceiveData)

[tyoshino (SeeGerritForStatus), 2016/03/03 14:43:19]

did -> Did

[hiroshige, 2016/03/08 23:40:59]

Done.

+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didReceiveData(_, _)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, DidFinishLoading)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didReceiveData(StrEq("fox"), 4));
+    EXPECT_CALL(*client(), didReceiveResourceTiming(_)).Times(AtMost(1));

[tyoshino (SeeGerritForStatus), 2016/03/03 14:43:20]

please explain why the expectation is AtMost(1)

[hiroshige, 2016/03/08 23:40:59]

Because it is called in DocumentThreadableLoader case but not
WorkerThreadableLoader case.

ksakamoto@, you added this callback in
https://codereview.chromium.org/1184403003.
Is this expected to be called also in workers?
If so, I'll fix it and update the tests.

[tyoshino (SeeGerritForStatus), 2016/03/09 06:26:12]

Thanks. Please add a short comment explaining that after receiving reply from
ksakamoto@.

[Kunihiko Sakamoto, 2016/03/10 02:17:31]

hiroshige@ is correct, WorkerThreadableLoader doesn't call this.
(This callback is for ResourceTimingInfo plumbing from main thread to
WorkerThreadableLoader.)

[hiroshige, 2016/03/10 03:20:08]

Thanks! Then I'll make the expectation more strict, i.e.
didReceiveResourceTiming() is called once in the case of DocumenThreadableLoader
only, and add a comment.

[hiroshige, 2016/03/11 19:52:14]

Done.

+    EXPECT_CALL(*client(), didFinishLoading(_, _));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, CancelInDidFinishLoading)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didReceiveData(_, _));
+    EXPECT_CALL(*client(), didReceiveResourceTiming(_)).Times(AtMost(1));
+    EXPECT_CALL(*client(), didFinishLoading(_, _)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearInDidFinishLoading)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didReceiveData(_, _));
+    EXPECT_CALL(*client(), didReceiveResourceTiming(_)).Times(AtMost(1));
+    EXPECT_CALL(*client(), didFinishLoading(_, _)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, DidFail)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didFail(Truly(isNotCancellation)));
+
+    startLoader(errorURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, CancelInDidFail)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didFail(_)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+
+    startLoader(errorURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearInDidFail)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didFail(_)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+
+    startLoader(errorURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, DidFailInStart)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(DenyCrossOriginRequests);
+    callCheckpoint(1);
+
+    EXPECT_CALL(*client(), didFail(ResourceError(errorDomainBlinkInternal, 0, errorURL().string(), "Cross origin requests are not supported.")));
+    EXPECT_CALL(checkpoint(), Call(2));
+
+    startLoader(errorURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, CancelInDidFailInStart)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(DenyCrossOriginRequests);
+    callCheckpoint(1);
+
+    EXPECT_CALL(*client(), didFail(_)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+    EXPECT_CALL(checkpoint(), Call(2));
+
+    startLoader(errorURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearInDidFailInStart)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(DenyCrossOriginRequests);
+    callCheckpoint(1);
+
+    EXPECT_CALL(*client(), didFail(_)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+    EXPECT_CALL(checkpoint(), Call(2));
+
+    startLoader(errorURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, DidFailAccessControlCheck)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(UseAccessControl);
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didFailAccessControlCheck(ResourceError(errorDomainBlinkInternal, 0, successURL().string(), "No 'Access-Control-Allow-Origin' header is present on the requested resource. Origin 'null' is therefore not allowed access.")));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, CancelInDidFailAccessControlCheck)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(UseAccessControl);
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didFailAccessControlCheck(_)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearInDidFailAccessControlCheck)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(UseAccessControl);
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didFailAccessControlCheck(_)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+
+    startLoader(successURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, RedirectDidFinishLoading)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didReceiveData(StrEq("fox"), 4));
+    EXPECT_CALL(*client(), didReceiveResourceTiming(_)).Times(AtMost(1));
+    EXPECT_CALL(*client(), didFinishLoading(_, _));
+
+    startLoader(redirectURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, CancelInRedirectDidFinishLoading)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didReceiveData(StrEq("fox"), 4));
+    EXPECT_CALL(*client(), didReceiveResourceTiming(_)).Times(AtMost(1));
+    EXPECT_CALL(*client(), didFinishLoading(_, _)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+
+    startLoader(redirectURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearInRedirectDidFinishLoading)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader();
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didReceiveResponse(_, _, _));
+    EXPECT_CALL(*client(), didReceiveData(StrEq("fox"), 4));
+    EXPECT_CALL(*client(), didReceiveResourceTiming(_)).Times(AtMost(1));
+    EXPECT_CALL(*client(), didFinishLoading(_, _)).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+
+    startLoader(redirectURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, DidFailRedirectCheck)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(UseAccessControl);
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didFailRedirectCheck());
+
+    startLoader(redirectLoopURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, CancelInDidFailRedirectCheck)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(UseAccessControl);
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didFailRedirectCheck()).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
+
+    startLoader(redirectLoopURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+TEST_P(ThreadableLoaderTest, ClearInDidFailRedirectCheck)
+{
+    InSequence s;
+    EXPECT_CALL(checkpoint(), Call(1));
+    createLoader(UseAccessControl);
+    callCheckpoint(1);
+
+    EXPECT_CALL(checkpoint(), Call(2));
+    EXPECT_CALL(*client(), didFailRedirectCheck()).WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
+
+    startLoader(redirectLoopURL());
+    callCheckpoint(2);
+    serveRequests();
+}
+
+} // namespace
+
+} // namespace blink