Prevent RFH from attempting to transfer after it's been swapped out

content/public/test/browser_test_utils.cc

 // Copyright (c) 2012 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 "content/public/test/browser_test_utils.h"
 
 #include <stddef.h>
 #include <tuple>
 #include <utility>
 
@@ skipping 343 matching lines @@
   return std::move(http_response);
 }
 
 // Helper class used by the TestNavigationManager to pause navigations.
 // Note: the throttle should be added to the *end* of the list of throttles,
 // so all NavigationThrottles that should be attached observe the
 // WillStartRequest callback. RegisterThrottleForTesting has this behavior.
 class TestNavigationManagerThrottle : public NavigationThrottle {
  public:
   TestNavigationManagerThrottle(NavigationHandle* handle,
-                                base::Closure on_will_start_request_closure)
+                                base::Closure on_will_start_request_closure,
+                                base::Closure on_will_process_response_closure)
       : NavigationThrottle(handle),
-        on_will_start_request_closure_(on_will_start_request_closure) {}
+        on_will_start_request_closure_(on_will_start_request_closure),
+        on_will_process_response_closure_(on_will_process_response_closure) {}
   ~TestNavigationManagerThrottle() override {}
 
  private:
   // NavigationThrottle:
   NavigationThrottle::ThrottleCheckResult WillStartRequest() override {
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
                             on_will_start_request_closure_);
     return NavigationThrottle::DEFER;
   }
 
+  NavigationThrottle::ThrottleCheckResult WillProcessResponse() override {
+    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                            on_will_process_response_closure_);
+    return NavigationThrottle::DEFER;
+  }
+
   base::Closure on_will_start_request_closure_;
+  base::Closure on_will_process_response_closure_;
 };
 
 bool HasGzipHeader(const base::RefCountedMemory& maybe_gzipped) {
   net::GZipHeader header;
   net::GZipHeader::Status header_status = net::GZipHeader::INCOMPLETE_HEADER;
   const char* header_end = nullptr;
   while (header_status == net::GZipHeader::INCOMPLETE_HEADER) {
     header_status = header.ReadMore(maybe_gzipped.front_as<char>(),
                                     maybe_gzipped.size(),
                                     &header_end);
@@ skipping 1241 matching lines @@
 FrameFocusedObserver::~FrameFocusedObserver() {}
 
 void FrameFocusedObserver::Wait() {
   impl_->Run();
 }
 
 TestNavigationManager::TestNavigationManager(WebContents* web_contents,
                                              const GURL& url)
     : WebContentsObserver(web_contents),
       url_(url),
-      navigation_paused_(false),
+      navigation_paused_in_will_start_(false),
+      navigation_paused_in_will_process_response_(false),
       handle_(nullptr),
       handled_navigation_(false),
       weak_factory_(this) {}
 
 TestNavigationManager::~TestNavigationManager() {
   ResumeNavigation();
 }
 
 bool TestNavigationManager::WaitForWillStartRequest() {
   DCHECK(!did_finish_loop_runner_);
   if (!handle_ && handled_navigation_)
     return true;
-  if (navigation_paused_)
+  if (navigation_paused_in_will_start_)
     return true;
+  DCHECK(!navigation_paused_in_will_process_response_);
   will_start_loop_runner_ = new MessageLoopRunner();
   will_start_loop_runner_->Run();
   will_start_loop_runner_ = nullptr;
 
   // This will only be false if DidFinishNavigation is called before
   // OnWillStartRequest, which could occur if a throttle cancels the navigation
   // before the TestNavigationManagerThrottle's method is called.
   return !handled_navigation_;
 }
 
+bool TestNavigationManager::WaitForWillProcessResponse() {
+  DCHECK(!did_finish_loop_runner_);
+  if (!handle_ && handled_navigation_)
+    return true;
+  if (navigation_paused_in_will_process_response_)
+    return true;
+  // Ensure the navigation is resumed if the manager paused it previously.
+  if (navigation_paused_in_will_start_)
+    ResumeNavigation();
+  will_process_response_loop_runner_ = new MessageLoopRunner();
+  will_process_response_loop_runner_->Run();
+  will_process_response_loop_runner_ = nullptr;
+
+  // This will only be false if DidFinishNavigation is called before
+  // OnWillProcessResponse.
+  return !handled_navigation_;
+}
+
 void TestNavigationManager::WaitForNavigationFinished() {
   DCHECK(!will_start_loop_runner_);
   if (!handle_ && handled_navigation_)
     return;
   // Ensure the navigation is resumed if the manager paused it previously.
-  if (navigation_paused_)
+  if (navigation_paused_in_will_start_ ||
+      navigation_paused_in_will_process_response_) {
     ResumeNavigation();
+  }
   did_finish_loop_runner_ = new MessageLoopRunner();
   did_finish_loop_runner_->Run();
   did_finish_loop_runner_ = nullptr;
 }
 
 void TestNavigationManager::DidStartNavigation(NavigationHandle* handle) {
   if (!ShouldMonitorNavigation(handle))
     return;
 
   handle_ = handle;
   std::unique_ptr<NavigationThrottle> throttle(
       new TestNavigationManagerThrottle(
           handle_, base::Bind(&TestNavigationManager::OnWillStartRequest,
-                              weak_factory_.GetWeakPtr())));
+                              weak_factory_.GetWeakPtr()),
+          base::Bind(&TestNavigationManager::OnWillProcessResponse,
+                     weak_factory_.GetWeakPtr())));
   handle_->RegisterThrottleForTesting(std::move(throttle));
 }
 
 void TestNavigationManager::DidFinishNavigation(NavigationHandle* handle) {
   if (handle != handle_)
     return;
   handle_ = nullptr;
   handled_navigation_ = true;
-  navigation_paused_ = false;
+  navigation_paused_in_will_start_ = false;
+  navigation_paused_in_will_process_response_ = false;
 
   // Resume any clients that are waiting for the end of the navigation. Note
   // that |will_start_loop_runner_| can be running if the navigation was
   // cancelled while it was deferred.
   if (did_finish_loop_runner_)
     did_finish_loop_runner_->Quit();
   if (will_start_loop_runner_)
     will_start_loop_runner_->Quit();
+  if (will_process_response_loop_runner_)
+    will_process_response_loop_runner_->Quit();
 }
 
 void TestNavigationManager::OnWillStartRequest() {
-  navigation_paused_ = true;
+  navigation_paused_in_will_start_ = true;
   if (will_start_loop_runner_)
     will_start_loop_runner_->Quit();
 
-  // If waiting for the navigation to finish, resume the navigation.
+  // If waiting for further events in the navigation, resume the navigation.
+  if (did_finish_loop_runner_ || will_process_response_loop_runner_)
+    ResumeNavigation();
+}
+
+void TestNavigationManager::OnWillProcessResponse() {
+  navigation_paused_in_will_process_response_ = true;
+  DCHECK(!will_start_loop_runner_);
+  if (will_process_response_loop_runner_)
+    will_process_response_loop_runner_->Quit();
+
+  // If waiting for further events in the navigation, resume the navigation.
   if (did_finish_loop_runner_)
     ResumeNavigation();
 }
 
 void TestNavigationManager::ResumeNavigation() {
-  if (!navigation_paused_ || !handle_)
+  if (!(navigation_paused_in_will_start_ ||
+        navigation_paused_in_will_process_response_) ||
+      !handle_) {
     return;
-  navigation_paused_ = false;
+  }
+  navigation_paused_in_will_start_ = false;
+  navigation_paused_in_will_process_response_ = false;
   handle_->Resume();
 }
 
 bool TestNavigationManager::ShouldMonitorNavigation(NavigationHandle* handle) {
   if (handle_ || handle->GetURL() != url_)
     return false;
   if (handled_navigation_)
     return false;
   return true;
 }
 
 }  // namespace content