Rename checkpoint() method to getCheckpoint().

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

 // 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 <memory>
 #include "core/loader/DocumentThreadableLoader.h"
 #include "core/loader/ThreadableLoaderClient.h"
 #include "core/loader/ThreadableLoadingContext.h"
@@ skipping 96 matching lines @@
 class ThreadableLoaderTestHelper {
  public:
   virtual ~ThreadableLoaderTestHelper() {}
 
   virtual void createLoader(ThreadableLoaderClient*,
                             CrossOriginRequestPolicy) = 0;
   virtual void startLoader(const ResourceRequest&) = 0;
   virtual void cancelLoader() = 0;
   virtual void cancelAndClearLoader() = 0;
   virtual void clearLoader() = 0;
-  virtual Checkpoint& checkpoint() = 0;
+  virtual Checkpoint& getCheckpoint() = 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))) {}
@@ skipping 12 matching lines @@
   void startLoader(const ResourceRequest& request) override {
     m_loader->start(request);
   }
 
   void cancelLoader() override { m_loader->cancel(); }
   void cancelAndClearLoader() override {
     m_loader->cancel();
     m_loader = nullptr;
   }
   void clearLoader() override { m_loader = nullptr; }
-  Checkpoint& checkpoint() override { return m_checkpoint; }
+  Checkpoint& getCheckpoint() override { return m_checkpoint; }
   void callCheckpoint(int n) override { m_checkpoint.Call(n); }
 
   void onSetUp() override {}
 
   void onServeRequests() override {}
 
   void onTearDown() override {
     if (m_loader) {
       m_loader->cancel();
       m_loader = nullptr;
@@ skipping 54 matching lines @@
     m_loader = nullptr;
   }
 
   // Must be called on the worker thread.
   void clearLoader() override {
     DCHECK(m_workerThread);
     DCHECK(m_workerThread->isCurrentThread());
     m_loader = nullptr;
   }
 
-  Checkpoint& checkpoint() override { return m_checkpoint; }
+  Checkpoint& getCheckpoint() override { return m_checkpoint; }
 
   void callCheckpoint(int n) override {
     testing::runPendingTasks();
 
     std::unique_ptr<WaitableEvent> completionEvent =
         WTF::makeUnique<WaitableEvent>();
     postTaskToWorkerGlobalScope(
         BLINK_FROM_HERE,
         crossThreadBind(&WorkerThreadableLoaderTestHelper::workerCallCheckpoint,
                         crossThreadUnretained(this),
@@ skipping 131 matching lines @@
 
   void startLoader(const KURL& url) {
     ResourceRequest request(url);
     request.setRequestContext(WebURLRequest::RequestContextObject);
     m_helper->startLoader(request);
   }
 
   void cancelLoader() { m_helper->cancelLoader(); }
   void cancelAndClearLoader() { m_helper->cancelAndClearLoader(); }
   void clearLoader() { m_helper->clearLoader(); }
-  Checkpoint& checkpoint() { return m_helper->checkpoint(); }
+  Checkpoint& getCheckpoint() { return m_helper->getCheckpoint(); }
   void callCheckpoint(int n) { m_helper->callCheckpoint(n); }
 
   void serveRequests() {
     m_helper->onServeRequests();
     Platform::current()->getURLLoaderMockFactory()->serveAsynchronousRequests();
   }
 
   void createLoader(CrossOriginRequestPolicy crossOriginRequestPolicy =
                         AllowCrossOriginRequests) {
     m_helper->createLoader(client(), crossOriginRequestPolicy);
@@ skipping 72 matching lines @@
                         ::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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2))
+  EXPECT_CALL(getCheckpoint(), Call(2))
       .WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
   EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
-  EXPECT_CALL(checkpoint(), Call(3));
+  EXPECT_CALL(getCheckpoint(), Call(3));
 
   startLoader(successURL());
   callCheckpoint(2);
   callCheckpoint(3);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelAndClearAfterStart) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2))
+  EXPECT_CALL(getCheckpoint(), Call(2))
       .WillOnce(
           InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelAndClearLoader));
   EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
-  EXPECT_CALL(checkpoint(), Call(3));
+  EXPECT_CALL(getCheckpoint(), Call(3));
 
   startLoader(successURL());
   callCheckpoint(2);
   callCheckpoint(3);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelInDidReceiveResponse) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _))
       .WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
   EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
 
   startLoader(successURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelAndClearInDidReceiveResponse) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _))
       .WillOnce(
           InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelAndClearLoader));
   EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
 
   startLoader(successURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelInDidReceiveData) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didReceiveData(_, _))
       .WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
   EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
 
   startLoader(successURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelAndClearInDidReceiveData) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didReceiveData(_, _))
       .WillOnce(
           InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelAndClearLoader));
   EXPECT_CALL(*client(), didFail(Truly(isCancellation)));
 
   startLoader(successURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, DidFinishLoading) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didReceiveData(StrEq("fox"), 4));
   // We expect didReceiveResourceTiming() calls in DocumentThreadableLoader;
   // it's used to connect DocumentThreadableLoader to WorkerThreadableLoader,
   // not to ThreadableLoaderClient.
   EXPECT_CALL(*client(), didReceiveResourceTiming(_));
   EXPECT_CALL(*client(), didFinishLoading(_, _));
 
   startLoader(successURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelInDidFinishLoading) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didReceiveData(_, _));
   EXPECT_CALL(*client(), didReceiveResourceTiming(_));
   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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didReceiveData(_, _));
   EXPECT_CALL(*client(), didReceiveResourceTiming(_));
   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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didFail(Truly(isNotCancellation)));
 
   startLoader(errorURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelInDidFail) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(DenyCrossOriginRequests);
   callCheckpoint(1);
 
   EXPECT_CALL(
       *client(),
       didFail(ResourceError(errorDomainBlinkInternal, 0, errorURL().getString(),
                             "Cross origin requests are not supported.")));
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
 
   startLoader(errorURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelInDidFailInStart) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(DenyCrossOriginRequests);
   callCheckpoint(1);
 
   EXPECT_CALL(*client(), didFail(_))
       .WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::cancelLoader));
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
 
   startLoader(errorURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, ClearInDidFailInStart) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(DenyCrossOriginRequests);
   callCheckpoint(1);
 
   EXPECT_CALL(*client(), didFail(_))
       .WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
 
   startLoader(errorURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, DidFailAccessControlCheck) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(UseAccessControl);
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(
       *client(),
       didFailAccessControlCheck(ResourceError(
           errorDomainBlinkInternal, 0, successURL().getString(),
           "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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(UseAccessControl);
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), 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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(UseAccessControl);
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), 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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didReceiveData(StrEq("fox"), 4));
   EXPECT_CALL(*client(), didReceiveResourceTiming(_));
   EXPECT_CALL(*client(), didFinishLoading(_, _));
 
   startLoader(redirectURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelInRedirectDidFinishLoading) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didReceiveData(StrEq("fox"), 4));
   EXPECT_CALL(*client(), didReceiveResourceTiming(_));
   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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader();
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didReceiveResponseMock(_, _, _));
   EXPECT_CALL(*client(), didReceiveData(StrEq("fox"), 4));
   EXPECT_CALL(*client(), didReceiveResourceTiming(_));
   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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(UseAccessControl);
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didFailRedirectCheck());
 
   startLoader(redirectLoopURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 TEST_P(ThreadableLoaderTest, CancelInDidFailRedirectCheck) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(UseAccessControl);
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), 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));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(UseAccessControl);
   callCheckpoint(1);
 
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
   EXPECT_CALL(*client(), didFailRedirectCheck())
       .WillOnce(InvokeWithoutArgs(this, &ThreadableLoaderTest::clearLoader));
 
   startLoader(redirectLoopURL());
   callCheckpoint(2);
   serveRequests();
 }
 
 // This test case checks blink doesn't crash even when the response arrives
 // synchronously.
 TEST_P(ThreadableLoaderTest, GetResponseSynchronously) {
   InSequence s;
-  EXPECT_CALL(checkpoint(), Call(1));
+  EXPECT_CALL(getCheckpoint(), Call(1));
   createLoader(UseAccessControl);
   callCheckpoint(1);
 
   EXPECT_CALL(*client(), didFailAccessControlCheck(_));
-  EXPECT_CALL(checkpoint(), Call(2));
+  EXPECT_CALL(getCheckpoint(), Call(2));
 
   // Currently didFailAccessControlCheck is dispatched synchronously. This
   // test is not saying that didFailAccessControlCheck should be dispatched
   // synchronously, but is saying that even when a response is served
   // synchronously it should not lead to a crash.
   startLoader(KURL(KURL(), "about:blank"));
   callCheckpoint(2);
 }
 
 }  // namespace
 
 }  // namespace blink