Do not reset navigation state when BeforeUnload is cancelled by a commit

content/test/content_browser_test_utils_internal.h

 // Copyright 2014 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.
 
 #ifndef CONTENT_TEST_CONTENT_BROWSER_TEST_UTILS_INTERNAL_H_
 #define CONTENT_TEST_CONTENT_BROWSER_TEST_UTILS_INTERNAL_H_
 
 // A collection of functions designed for use with content_shell based browser
 // tests internal to the content/ module.
 // Note: If a function here also works with browser_tests, it should be in
 // the content public API.
 
 #include <string>
 #include <vector>
 
 #include "base/macros.h"
+#include "base/memory/weak_ptr.h"
 #include "cc/surfaces/surface_id.h"
+#include "content/public/browser/navigation_handle.h"
 #include "content/public/browser/resource_dispatcher_host_delegate.h"
+#include "content/public/browser/web_contents_observer.h"
 #include "url/gurl.h"
 
 namespace cc {
 class SurfaceManager;
 }
 
 namespace content {
 
 class FrameTreeNode;
+class MessageLoopRunner;
 class RenderWidgetHostViewChildFrame;
 class Shell;
 class SiteInstance;
 class ToRenderFrameHost;
 
 // Navigates the frame represented by |node| to |url|, blocking until the
 // navigation finishes.
 void NavigateFrameToURL(FrameTreeNode* node, const GURL& url);
 
+// Sets the DialogManager to proceed by default or not when showing a
+// BeforeUnload dialog.
+void SetProceedByDefaultOnBeforeUnload(Shell* shell, bool proceed);
+
 // Creates compact textual representations of the state of the frame tree that
 // is appropriate for use in assertions.
 //
 // The diagrams show frame tree structure, the SiteInstance of current frames,
 // presence of pending frames, and the SiteInstances of any and all proxies.
 // They look like this:
 //
 //        Site A (D pending) -- proxies for B C
 //          |--Site B --------- proxies for A C
 //          +--Site C --------- proxies for B A
@@ skipping 49 matching lines @@
   void RequestBeginning(
       net::URLRequest* request,
       content::ResourceContext* resource_context,
       content::AppCacheService* appcache_service,
       ResourceType resource_type,
       ScopedVector<content::ResourceThrottle>* throttles) override;
 
   GURL url_;
 };
 
+// This class can be used to pause and resume navigations, based on a URL
+// match. Note that it only keeps track of one navigation at a time.
+class NavigationDelayer : public WebContentsObserver {

[Charlie Reis, 2016/03/29 18:33:21]

Nasko, can you review this part?  I know you've been wanting this for a while. 
(You have a TODO for it just above, on line 96.)

[nasko, 2016/03/29 20:19:06]

I'd call this something more generic, as it ideally will be able to
block/drop/delay navigations. I had TestNavigationScheduler in my strawman CL a
year ago, but needn't be that.

[clamy, 2016/03/30 13:31:11]

I went with TestNavigationManager. I can switch to Scheduler if you prefer.

+ public:
+  NavigationDelayer(WebContents* web_contents, const GURL& url);

[nasko, 2016/03/29 20:19:06]

Is the goal for this class to monitor any frame in WebContents? If so, let's put
a comment clarifying this on this constructor. I imagine in the future we will
want to monitor only a specific frame, especially since
cross_site_iframe_factory.html generates URLs that differ only in the query
string when they are for the same site.

Alternatively, this might be a useful class to expose outside of content as it
is. I haven't looked at what tests could use it though.

[clamy, 2016/03/30 13:31:11]

Precised it in a comment, + adde a TODO for a frame version.

+  ~NavigationDelayer() override;
+
+  // Waits until the navigation has been paused.
+  void WaitForNavigationPaused();

[nasko, 2016/03/29 20:19:06]

At what point will navigation be paused? Let's use the naming of the method to
make this clear. For example: WaitForCommit(), WaitForRedirect(), etc. The
default behavior should probably be to defer the navigation at the point of
interest based on the method that was called and have the testcase itself resume
it once the intended checks have been completed.

[clamy, 2016/03/30 13:31:11]

I renamed the method WaitForWillStartRequest since this is what it is waiting
for. I think WaitForNavigationFinished is okay since we're waiting for
DidFinishNavigation.

+
+  // Waits until the navigation has been finished. This should be called after
+  // WaitForNavigationPaused.

[Charlie Reis, 2016/03/29 18:33:21]

Do you also need to call ResumeNavigation before calling this?  That's what your
test is doing, and it's not clear here whether that's required.

[clamy, 2016/03/30 13:31:11]

Yes. I precised it in the comment. Added a TODO to not need it in the future.

+  void WaitForNavigationFinished();
+
+  // Resumes the navigation if it was previously paused.
+  void ResumeNavigation();
+
+ private:
+  // WebContentsObserver implementation.
+  void DidStartNavigation(NavigationHandle* handle) override;
+  void DidFinishNavigation(NavigationHandle* handle) override;
+
+  // Called when the NavigationThrottlePauses the navigation.

[nasko, 2016/03/29 20:19:06]

nit: s/NavigationThrottlePauses/NavigationThrottle pauses/?

[clamy, 2016/03/30 13:31:11]

Done.

+  void OnPausedNavigation();
+
+  const GURL url_;
+  bool navigation_paused_;
+  NavigationHandle* handle_;
+  scoped_refptr<MessageLoopRunner> loop_runner_;
+
+  base::WeakPtrFactory<NavigationDelayer> weak_factory_;
+};
+
 // Helper class to assist with hit testing surfaces in multiple processes.
 // WaitForSurfaceReady() will only return after a Surface from |target_view|
 // has been composited in the top-level frame's Surface. At that point,
 // browser process hit testing to target_view's Surface can succeed.
 class SurfaceHitTestReadyNotifier {
  public:
   SurfaceHitTestReadyNotifier(RenderWidgetHostViewChildFrame* target_view);
   ~SurfaceHitTestReadyNotifier() {}
 
   void WaitForSurfaceReady();
 
  private:
   bool ContainsSurfaceId(cc::SurfaceId container_surface_id);
 
   cc::SurfaceManager* surface_manager_;
   cc::SurfaceId root_surface_id_;
   RenderWidgetHostViewChildFrame* target_view_;
 
   DISALLOW_COPY_AND_ASSIGN(SurfaceHitTestReadyNotifier);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_TEST_CONTENT_BROWSER_TEST_UTILS_INTERNAL_H_