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
Ref
hiroshige
2016/03/08 23:40:59
Added:
tyoshino (SeeGerritForStatus)
2016/03/09 06:26:12
looks good
|
+ |
+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 cat
hiroshige
2016/03/08 23:40:59
I think I added this ASSERT() from
https://code.go
tyoshino (SeeGerritForStatus)
2016/03/09 06:26:12
Ah, I see. I understood the motivation. But this w
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
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 c
tyoshino (SeeGerritForStatus)
2016/03/09 06:26:12
Thanks. Please add a short comment explaining that
Kunihiko Sakamoto
2016/03/10 02:17:31
hiroshige@ is correct, WorkerThreadableLoader does
hiroshige
2016/03/10 03:20:08
Thanks! Then I'll make the expectation more strict
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 |