Drop replacesCurrentHistoryItem, NavigationType

third_party/WebKit/Source/web/tests/WebFrameTest.cpp

 /*
  * Copyright (C) 2010 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 4082 matching lines @@
   webViewHelper.webView()->mainFrame()->reload(
       WebFrameLoadType::ReloadBypassingCache);
   // start another reload before request is delivered.
   FrameTestHelpers::reloadFrameBypassingCache(
       webViewHelper.webView()->mainFrame());
 }
 
 class ClearScrollStateOnCommitWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
-  void didCommitProvisionalLoad(WebLocalFrame* frame,
+  void didCommitProvisionalLoad(WebDataSource*,
+                                WebFrameLoadType,
                                 const WebHistoryItem&,
                                 WebHistoryCommitType) override {
-    frame->view()->resetScrollAndScaleState();
+    if (m_webView)
+      m_webView->resetScrollAndScaleState();
   }
+
+  void setWebView(WebView* webView) { m_webView = webView; }
+
+ private:
+  WebView* m_webView = nullptr;
 };
 
 TEST_F(WebFrameTest, ReloadWithOverrideURLPreservesState) {
   const std::string firstURL = "200-by-300.html";
   const std::string secondURL = "content-width-1000.html";
   const std::string thirdURL = "very_tall_div.html";
   const float pageScaleFactor = 1.1684f;
   const int pageWidth = 120;
   const int pageHeight = 100;
 
   registerMockedHttpURLLoad(firstURL);
   registerMockedHttpURLLoad(secondURL);
   registerMockedHttpURLLoad(thirdURL);
 
   ClearScrollStateOnCommitWebFrameClient client;
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + firstURL, true, &client);
   webViewHelper.resize(WebSize(pageWidth, pageHeight));
   webViewHelper.webView()->mainFrame()->setScrollOffset(
       WebSize(pageWidth / 4, pageHeight / 4));
   webViewHelper.webView()->setPageScaleFactor(pageScaleFactor);
+  client.setWebView(webViewHelper.webView());
 
   WebSize previousOffset =
       webViewHelper.webView()->mainFrame()->getScrollOffset();
   float previousScale = webViewHelper.webView()->pageScaleFactor();
 
   // Reload the page and end up at the same url. State should be propagated.
   webViewHelper.webView()->mainFrame()->reloadWithOverrideURL(
       toKURL(m_baseURL + firstURL), WebFrameLoadType::ReloadMainResource);
   FrameTestHelpers::pumpPendingRequestsForFrameToLoad(
       webViewHelper.webView()->mainFrame());
@@ skipping 1981 matching lines @@
   TestSubstituteDataWebFrameClient() : m_commitCalled(false) {}
 
   virtual void didFailProvisionalLoad(WebLocalFrame* frame,
                                       const WebURLError& error,
                                       WebHistoryCommitType) {
     frame->loadHTMLString("This should appear",
                           toKURL("data:text/html,chromewebdata"),
                           error.unreachableURL, true);
   }
 
-  virtual void didCommitProvisionalLoad(WebLocalFrame* frame,
+  virtual void didCommitProvisionalLoad(WebDataSource* dataSource,
+                                        WebFrameLoadType,
                                         const WebHistoryItem&,
                                         WebHistoryCommitType) {
-    if (frame->dataSource()->response().url() !=
+    if (dataSource->response().url() !=
         WebURL(URLTestHelpers::toKURL("about:blank")))
       m_commitCalled = true;
   }
 
   bool commitCalled() const { return m_commitCalled; }
 
  private:
   bool m_commitCalled;
 };
 
@@ skipping 31 matching lines @@
       webViewHelper.webView(), std::numeric_limits<size_t>::max());
   EXPECT_EQ("This should appear", text.utf8());
   EXPECT_TRUE(webFrameClient.commitCalled());
 }
 
 class TestWillInsertBodyWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   TestWillInsertBodyWebFrameClient() : m_numBodies(0), m_didLoad(false) {}
 
-  void didCommitProvisionalLoad(WebLocalFrame*,
+  void didCommitProvisionalLoad(WebDataSource*,
+                                WebFrameLoadType,
                                 const WebHistoryItem&,
                                 WebHistoryCommitType) override {
     m_numBodies = 0;
     m_didLoad = true;
   }
 
   void didCreateDocumentElement(WebLocalFrame*) override {
     EXPECT_EQ(0, m_numBodies);
   }
 
@@ skipping 650 matching lines @@
   webViewHelper.initializeAndLoad(m_baseURL + "first_party_redirect.html",
                                   true);
   EXPECT_TRUE(
       webViewHelper.webView()->mainFrame()->document().firstPartyForCookies() ==
       redirectURL);
 }
 
 class TestNavigationPolicyWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
-  void didNavigateWithinPage(WebLocalFrame*,
+  void didNavigateWithinPage(WebDataSource*,
+                             WebFrameLoadType,
                              const WebHistoryItem&,
                              WebHistoryCommitType,
                              bool) override {
     EXPECT_TRUE(false);
   }
 };
 
 TEST_P(ParameterizedWebFrameTest, SimulateFragmentAnchorMiddleClick) {
   registerMockedHttpURLLoad("fragment_middle_click.html");
   TestNavigationPolicyWebFrameClient client;
@@ skipping 146 matching lines @@
   // Pump requests one more time after the javascript URL has executed to
   // trigger the actual POST load request.
   FrameTestHelpers::pumpPendingRequestsForFrameToLoad(
       webViewHelper.webView()->mainFrame());
   EXPECT_EQ(WebString::fromUTF8("POST"),
             frame->dataSource()->getRequest().httpMethod());
 
   FrameTestHelpers::reloadFrame(frame);
   EXPECT_EQ(WebCachePolicy::ValidatingCacheData,
             frame->dataSource()->getRequest().getCachePolicy());
-  EXPECT_EQ(WebNavigationTypeFormResubmitted,
-            frame->dataSource()->navigationType());
 }
 
 TEST_P(ParameterizedWebFrameTest, LoadHistoryItemReload) {
   registerMockedHttpURLLoad("fragment_middle_click.html");
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad(m_baseURL + "fragment_middle_click.html",
                                   true);
   WebFrame* frame = webViewHelper.webView()->mainFrame();
   const FrameLoader& mainFrameLoader =
       webViewHelper.webView()->mainFrameImpl()->frame()->loader();
@@ skipping 55 matching lines @@
   }
 
   virtual void didStopLoading() {
     if (m_parentClient) {
       m_parentClient->didStopLoading();
       return;
     }
     TestWebFrameClient::didStopLoading();
   }
 
-  void willSendRequest(WebLocalFrame*, WebURLRequest& request) override {
+  void willSendRequest(WebLocalFrame*,
+                       WebURLRequest& request,
+                       WebFrameLoadType) override {
     m_policy = request.getCachePolicy();
     m_willSendRequestCallCount++;
   }
 
  private:
   TestCachePolicyWebFrameClient* m_parentClient;
 
   WebCachePolicy m_policy;
   TestCachePolicyWebFrameClient* m_childClient;
   int m_willSendRequestCallCount;
@@ skipping 36 matching lines @@
   EXPECT_EQ(childClient.getCachePolicy(),
             WebCachePolicy::UseProtocolCachePolicy);
 }
 
 class TestSameDocumentWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   TestSameDocumentWebFrameClient()
       : m_frameLoadTypeReloadMainResourceSeen(false) {}
 
-  virtual void willSendRequest(WebLocalFrame* frame, WebURLRequest&) {
+  virtual void willSendRequest(WebLocalFrame* frame,
+                               WebURLRequest&,
+                               WebFrameLoadType) {
     FrameLoader& frameLoader = toWebLocalFrameImpl(frame)->frame()->loader();
     if (frameLoader.provisionalDocumentLoader()->loadType() ==
         FrameLoadTypeReloadMainResource)
       m_frameLoadTypeReloadMainResourceSeen = true;
   }
 
   bool frameLoadTypeReloadMainResourceSeen() const {
     return m_frameLoadTypeReloadMainResourceSeen;
   }
 
@@ skipping 21 matching lines @@
       webViewHelper.webView()->mainFrame());
 
   EXPECT_TRUE(client.frameLoadTypeReloadMainResourceSeen());
 }
 
 class TestSameDocumentWithImageWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   TestSameDocumentWithImageWebFrameClient() : m_numOfImageRequests(0) {}
 
-  virtual void willSendRequest(WebLocalFrame*, WebURLRequest& request) {
+  virtual void willSendRequest(WebLocalFrame*,
+                               WebURLRequest& request,
+                               WebFrameLoadType) {
     if (request.getRequestContext() == WebURLRequest::RequestContextImage) {
       m_numOfImageRequests++;
       EXPECT_EQ(WebCachePolicy::UseProtocolCachePolicy,
                 request.getCachePolicy());
     }
   }
 
   int numOfImageRequests() const { return m_numOfImageRequests; }
 
  private:
@@ skipping 90 matching lines @@
   EXPECT_EQ(client.stopLoadingCount(), 2);
   EXPECT_EQ(client.differentDocumentStartCount(), 1);
 }
 
 class TestDidNavigateCommitTypeWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   TestDidNavigateCommitTypeWebFrameClient()
       : m_lastCommitType(WebHistoryInertCommit) {}
 
-  void didNavigateWithinPage(WebLocalFrame*,
+  void didNavigateWithinPage(WebDataSource*,
+                             WebFrameLoadType,
                              const WebHistoryItem&,
                              WebHistoryCommitType type,
                              bool) override {
     m_lastCommitType = type;
   }
 
   WebHistoryCommitType lastCommitType() const { return m_lastCommitType; }
 
  private:
   WebHistoryCommitType m_lastCommitType;
@@ skipping 16 matching lines @@
               nullptr, FrameLoader::resourceRequestFromHistoryItem(
                            item.get(), WebCachePolicy::UseProtocolCachePolicy)),
           FrameLoadTypeBackForward, item.get(), HistorySameDocumentLoad);
   EXPECT_EQ(WebBackForwardCommit, client.lastCommitType());
 }
 
 class TestHistoryWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
  public:
   TestHistoryWebFrameClient() {
     m_replacesCurrentHistoryItem = false;
-    m_frame = nullptr;
   }
 
-  void didStartProvisionalLoad(WebLocalFrame* frame) {
-    WebDataSource* ds = frame->provisionalDataSource();
-    m_replacesCurrentHistoryItem = ds->replacesCurrentHistoryItem();
-    m_frame = frame;
+  void didStartProvisionalLoad(WebDataSource*, WebFrameLoadType loadType) {
+    m_replacesCurrentHistoryItem =
+        loadType == WebFrameLoadType::ReplaceCurrentItem;
   }
 
   bool replacesCurrentHistoryItem() { return m_replacesCurrentHistoryItem; }
-  WebFrame* frame() { return m_frame; }
 
  private:
   bool m_replacesCurrentHistoryItem;
-  WebFrame* m_frame;
 };
 
 // Tests that the first navigation in an initially blank subframe will result in
 // a history entry being replaced and not a new one being added.
 TEST_P(ParameterizedWebFrameTest, FirstBlankSubframeNavigation) {
   registerMockedHttpURLLoad("history.html");
   registerMockedHttpURLLoad("find.html");
 
   TestHistoryWebFrameClient client;
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad("about:blank", true, &client);
 
   WebFrame* frame = webViewHelper.webView()->mainFrame();
 
   frame->executeScript(WebScriptSource(WebString::fromUTF8(
       "document.body.appendChild(document.createElement('iframe'))")));
 
   WebFrame* iframe = frame->firstChild();
   ASSERT_EQ(&client, toWebLocalFrameImpl(iframe)->client());
-  EXPECT_EQ(iframe, client.frame());
 
   std::string url1 = m_baseURL + "history.html";
   FrameTestHelpers::loadFrame(iframe, url1);
-  EXPECT_EQ(iframe, client.frame());
   EXPECT_EQ(url1, iframe->document().url().string().utf8());
   EXPECT_TRUE(client.replacesCurrentHistoryItem());
 
   std::string url2 = m_baseURL + "find.html";
   FrameTestHelpers::loadFrame(iframe, url2);
-  EXPECT_EQ(iframe, client.frame());
   EXPECT_EQ(url2, iframe->document().url().string().utf8());
   EXPECT_FALSE(client.replacesCurrentHistoryItem());
 }
 
 // Tests that a navigation in a frame with a non-blank initial URL will create
 // a new history item, unlike the case above.
 TEST_P(ParameterizedWebFrameTest, FirstNonBlankSubframeNavigation) {
   registerMockedHttpURLLoad("history.html");
   registerMockedHttpURLLoad("find.html");
 
   TestHistoryWebFrameClient client;
   FrameTestHelpers::WebViewHelper webViewHelper;
   webViewHelper.initializeAndLoad("about:blank", true, &client);
 
   WebFrame* frame = webViewHelper.webView()->mainFrame();
 
   std::string url1 = m_baseURL + "history.html";
   FrameTestHelpers::loadFrame(
       frame,
       "javascript:var f = document.createElement('iframe'); "
       "f.src = '" +
           url1 +
           "';"
           "document.body.appendChild(f)");
 
   WebFrame* iframe = frame->firstChild();
-  EXPECT_EQ(iframe, client.frame());
   EXPECT_EQ(url1, iframe->document().url().string().utf8());
 
   std::string url2 = m_baseURL + "find.html";
   FrameTestHelpers::loadFrame(iframe, url2);
-  EXPECT_EQ(iframe, client.frame());
   EXPECT_EQ(url2, iframe->document().url().string().utf8());
   EXPECT_FALSE(client.replacesCurrentHistoryItem());
 }
 
 // Test verifies that layout will change a layer's scrollable attibutes
 TEST_F(WebFrameTest, overflowHiddenRewrite) {
   registerMockedHttpURLLoad("non-scrollable.html");
   std::unique_ptr<FakeCompositingWebViewClient> fakeCompositingWebViewClient =
       WTF::makeUnique<FakeCompositingWebViewClient>();
   FrameTestHelpers::WebViewHelper webViewHelper;
@@ skipping 1526 matching lines @@
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // clients.
   reset();
 }
 
 class RemoteToLocalSwapWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   explicit RemoteToLocalSwapWebFrameClient(WebRemoteFrame* remoteFrame)
       : m_historyCommitType(WebHistoryInertCommit),
-        m_remoteFrame(remoteFrame) {}
+        m_remoteFrame(remoteFrame),
+        m_localFrame(nullptr) {}
 
   void didCommitProvisionalLoad(
-      WebLocalFrame* frame,
+      WebDataSource*,
+      WebFrameLoadType,
       const WebHistoryItem&,
       WebHistoryCommitType historyCommitType) override {
     m_historyCommitType = historyCommitType;
-    m_remoteFrame->swap(frame);
+    if (m_localFrame)
+      m_remoteFrame->swap(m_localFrame);
   }
 
   WebHistoryCommitType historyCommitType() const { return m_historyCommitType; }
+  void setLocalFrame(WebLocalFrame* localFrame) { m_localFrame = localFrame; }
 
   WebHistoryCommitType m_historyCommitType;
   WebRemoteFrame* m_remoteFrame;
+  WebLocalFrame* m_localFrame;
 };
 
 // The commit type should be Initial if we are swapping a RemoteFrame to a
 // LocalFrame as it is first being created.  This happens when another frame
 // exists in the same process, such that we create the RemoteFrame before the
 // first navigation occurs.
 TEST_F(WebFrameSwapTest, HistoryCommitTypeAfterNewRemoteToLocalSwap) {
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient;
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, &remoteFrameClient);
   WebFrame* targetFrame = mainFrame()->firstChild();
   ASSERT_TRUE(targetFrame);
   targetFrame->swap(remoteFrame);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame);
 
   RemoteToLocalSwapWebFrameClient client(remoteFrame);
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
       &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
+  client.setLocalFrame(localFrame);
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(WebInitialCommitInChildFrame, client.historyCommitType());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // TestWebFrameClient.
   reset();
   remoteFrame->close();
 }
 
 // The commit type should be Standard if we are swapping a RemoteFrame to a
 // LocalFrame after commits have already happened in the frame.  The browser
 // process will inform us via setCommittedFirstRealLoad.
 TEST_F(WebFrameSwapTest, HistoryCommitTypeAfterExistingRemoteToLocalSwap) {
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient;
   WebRemoteFrame* remoteFrame =
       WebRemoteFrame::create(WebTreeScopeType::Document, &remoteFrameClient);
   WebFrame* targetFrame = mainFrame()->firstChild();
   ASSERT_TRUE(targetFrame);
   targetFrame->swap(remoteFrame);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame);
 
   RemoteToLocalSwapWebFrameClient client(remoteFrame);
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
       &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
+  client.setLocalFrame(localFrame);
   localFrame->setCommittedFirstRealLoad();
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(WebStandardCommit, client.historyCommitType());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
   // TestWebFrameClient.
   reset();
   remoteFrame->close();
 }
 
@@ skipping 13 matching lines @@
   targetFrame->swap(remoteFrame);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame);
   EXPECT_EQ(uniqueName.utf8(),
             WebString(remoteFrame->frame()->tree().uniqueName()).utf8());
 
   // Swap back to a LocalFrame.
   RemoteToLocalSwapWebFrameClient client(remoteFrame);
   WebLocalFrame* localFrame = WebLocalFrame::createProvisional(
       &client, nullptr, nullptr, remoteFrame, WebSandboxFlags::None);
+  client.setLocalFrame(localFrame);
   FrameTestHelpers::loadFrame(localFrame, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(uniqueName.utf8(), localFrame->uniqueName().utf8());
   EXPECT_EQ(uniqueName.utf8(), WebString(toWebLocalFrameImpl(localFrame)
                                              ->frame()
                                              ->loader()
                                              .currentItem()
                                              ->target())
                                    .utf8());
 
   // Repeat with no name on the frame.
   // (note that uniqueName is immutable after first real commit).
   localFrame->setName("");
   WebString uniqueName2 = localFrame->uniqueName();
   EXPECT_EQ("frame1", uniqueName2.utf8());
 
   FrameTestHelpers::TestWebRemoteFrameClient remoteFrameClient2;
   WebRemoteFrameImpl* remoteFrame2 = WebRemoteFrameImpl::create(
       WebTreeScopeType::Document, &remoteFrameClient2);
   localFrame->swap(remoteFrame2);
   ASSERT_TRUE(mainFrame()->firstChild());
   ASSERT_EQ(mainFrame()->firstChild(), remoteFrame2);
   EXPECT_EQ(uniqueName2.utf8(),
             WebString(remoteFrame2->frame()->tree().uniqueName()).utf8());
 
   RemoteToLocalSwapWebFrameClient client2(remoteFrame2);
   WebLocalFrame* localFrame2 = WebLocalFrame::createProvisional(
       &client2, nullptr, nullptr, remoteFrame2, WebSandboxFlags::None);
+  client.setLocalFrame(localFrame);
   FrameTestHelpers::loadFrame(localFrame2, m_baseURL + "subframe-hello.html");
   EXPECT_EQ(uniqueName2.utf8(), localFrame2->uniqueName().utf8());
   EXPECT_EQ(uniqueName2.utf8(), WebString(toWebLocalFrameImpl(localFrame2)
                                               ->frame()
                                               ->loader()
                                               .currentItem()
                                               ->target())
                                     .utf8());
 
   // Manually reset to break WebViewHelper's dependency on the stack allocated
@@ skipping 164 matching lines @@
 
   view->close();
 }
 
 class CommitTypeWebFrameClient : public FrameTestHelpers::TestWebFrameClient {
  public:
   explicit CommitTypeWebFrameClient()
       : m_historyCommitType(WebHistoryInertCommit) {}
 
   void didCommitProvisionalLoad(
-      WebLocalFrame*,
+      WebDataSource*,
+      WebFrameLoadType,
       const WebHistoryItem&,
       WebHistoryCommitType historyCommitType) override {
     m_historyCommitType = historyCommitType;
   }
 
   WebHistoryCommitType historyCommitType() const { return m_historyCommitType; }
 
  private:
   WebHistoryCommitType m_historyCommitType;
 };
@@ skipping 789 matching lines @@
 
 class CallbackOrderingWebFrameClient
     : public FrameTestHelpers::TestWebFrameClient {
  public:
   CallbackOrderingWebFrameClient() : m_callbackCount(0) {}
 
   void didStartLoading(bool toDifferentDocument) override {
     EXPECT_EQ(0, m_callbackCount++);
     FrameTestHelpers::TestWebFrameClient::didStartLoading(toDifferentDocument);
   }
-  void didStartProvisionalLoad(WebLocalFrame*) override {
+  void didStartProvisionalLoad(WebDataSource*, WebFrameLoadType) override {
     EXPECT_EQ(1, m_callbackCount++);
   }
-  void didCommitProvisionalLoad(WebLocalFrame*,
+  void didCommitProvisionalLoad(WebDataSource*,
+                                WebFrameLoadType,
                                 const WebHistoryItem&,
                                 WebHistoryCommitType) override {
     EXPECT_EQ(2, m_callbackCount++);
   }
   void didFinishDocumentLoad(WebLocalFrame*) override {
     EXPECT_EQ(3, m_callbackCount++);
   }
   void didHandleOnloadEvents(WebLocalFrame*) override {
     EXPECT_EQ(4, m_callbackCount++);
   }
@@ skipping 365 matching lines @@
     ExpectedRequest(const KURL& url, WebURLRequest::Priority priority)
         : url(url), priority(priority), seen(false) {}
 
     KURL url;
     WebURLRequest::Priority priority;
     bool seen;
   };
 
   TestResourcePriorityWebFrameClient() {}
 
-  void willSendRequest(WebLocalFrame*, WebURLRequest& request) override {
+  void willSendRequest(WebLocalFrame*,
+                       WebURLRequest& request,
+                       WebFrameLoadType) override {
     ExpectedRequest* expectedRequest = m_expectedRequests.get(request.url());
     DCHECK(expectedRequest);
     EXPECT_EQ(expectedRequest->priority, request.getPriority());
     expectedRequest->seen = true;
   }
 
   void addExpectedRequest(const KURL& url, WebURLRequest::Priority priority) {
     m_expectedRequests.add(url,
                            WTF::makeUnique<ExpectedRequest>(url, priority));
   }
@@ skipping 753 matching lines @@
 
   EXPECT_TRUE(mainFrameClient.childClient().didCallFrameDetached());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidStopLoading());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidFinishDocumentLoad());
   EXPECT_TRUE(mainFrameClient.childClient().didCallDidHandleOnloadEvents());
 
   webViewHelper.reset();
 }
 
 }  // namespace blink