JavaScript dialogs cause a page to lose fullscreen.

content/browser/web_contents/web_contents_impl_browsertest.cc

 // Copyright 2013 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 "base/macros.h"
 #include "base/run_loop.h"
 #include "base/strings/pattern.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "build/build_config.h"
@@ skipping 924 matching lines @@
   // still be loading after that.
   cross_site_delayer.WaitForNavigationFinished();
   EXPECT_TRUE(shell()->web_contents()->IsLoading());
 }
 
 namespace {
 
 class TestJavaScriptDialogManager : public JavaScriptDialogManager,
                                     public WebContentsDelegate {
  public:
-  TestJavaScriptDialogManager() : message_loop_runner_(new MessageLoopRunner) {}
+  TestJavaScriptDialogManager()
+      : is_fullscreen_(false), message_loop_runner_(new MessageLoopRunner) {}
   ~TestJavaScriptDialogManager() override {}
 
   void Wait() {
     message_loop_runner_->Run();
     message_loop_runner_ = new MessageLoopRunner;
   }
 
   std::string last_message() { return last_message_; }
 
   // WebContentsDelegate
 
   JavaScriptDialogManager* GetJavaScriptDialogManager(
       WebContents* source) override {
     return this;
   }
 
+  void EnterFullscreenModeForTab(WebContents* web_contents,
+                                 const GURL& origin) override {
+    is_fullscreen_ = true;
+  }
+
+  void ExitFullscreenModeForTab(WebContents*) override {
+    is_fullscreen_ = false;
+  }
+
+  bool IsFullscreenForTabOrPending(
+      const WebContents* web_contents) const override {
+    return is_fullscreen_;
+  }
+
   // JavaScriptDialogManager
 
   void RunJavaScriptDialog(WebContents* web_contents,
                            const GURL& origin_url,
                            JavaScriptDialogType dialog_type,
                            const base::string16& message_text,
                            const base::string16& default_prompt_text,
                            const DialogClosedCallback& callback,
                            bool* did_suppress_message) override {
     last_message_ = base::UTF16ToUTF8(message_text);
     *did_suppress_message = true;
 
     message_loop_runner_->Quit();
   };
 
   void RunBeforeUnloadDialog(WebContents* web_contents,
                              bool is_reload,
-                             const DialogClosedCallback& callback) override {}
+                             const DialogClosedCallback& callback) override {
+    callback.Run(true, base::string16());
+    message_loop_runner_->Quit();
+  }
 
   bool HandleJavaScriptDialog(WebContents* web_contents,
                               bool accept,
                               const base::string16* prompt_override) override {
     return true;
   }
 
   void CancelDialogs(WebContents* web_contents,
                      bool reset_state) override {}
 
  private:
   std::string last_message_;
 
+  bool is_fullscreen_;
+
   // The MessageLoopRunner used to spin the message loop.
   scoped_refptr<MessageLoopRunner> message_loop_runner_;
 
   DISALLOW_COPY_AND_ASSIGN(TestJavaScriptDialogManager);
 };
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest,
                        JavaScriptDialogsInMainAndSubframes) {
@@ skipping 385 matching lines @@
   tab_observer.Wait();
   ASSERT_TRUE(saw_override);
 
   BrowserThread::PostTask(
       BrowserThread::IO, FROM_HERE,
       base::Bind(&ResourceDispatcherHost::SetDelegate,
                  base::Unretained(ResourceDispatcherHostImpl::Get()),
                  old_delegate));
 }
 
+IN_PROC_BROWSER_TEST_F(WebContentsImplBrowserTest,
+                       DialogsFromJavaScriptEndFullscreen) {
+  WebContentsImpl* wc = static_cast<WebContentsImpl*>(shell()->web_contents());
+  TestJavaScriptDialogManager dialog_manager;
+  wc->SetDelegate(&dialog_manager);
+
+  GURL url("about:blank");
+  EXPECT_TRUE(NavigateToURL(shell(), url));
+
+  // alert
+  wc->EnterFullscreenMode(url);
+  EXPECT_TRUE(wc->IsFullscreenForCurrentTab());
+  std::string script = "alert('hi')";
+  EXPECT_TRUE(content::ExecuteScript(wc, script));
+  dialog_manager.Wait();
+  EXPECT_FALSE(wc->IsFullscreenForCurrentTab());
+
+  // confirm
+  wc->EnterFullscreenMode(url);
+  EXPECT_TRUE(wc->IsFullscreenForCurrentTab());
+  script = "confirm('hi')";
+  EXPECT_TRUE(content::ExecuteScript(wc, script));
+  dialog_manager.Wait();
+  EXPECT_FALSE(wc->IsFullscreenForCurrentTab());
+
+  // prompt
+  wc->EnterFullscreenMode(url);
+  EXPECT_TRUE(wc->IsFullscreenForCurrentTab());
+  script = "prompt('hi')";
+  EXPECT_TRUE(content::ExecuteScript(wc, script));
+  dialog_manager.Wait();
+  EXPECT_FALSE(wc->IsFullscreenForCurrentTab());
+
+  // beforeunload
+  wc->EnterFullscreenMode(url);
+  EXPECT_TRUE(wc->IsFullscreenForCurrentTab());
+  // Disable the hang monitor (otherwise there will be a race between the
+  // beforeunload dialog and the beforeunload hang timer) and give the page a
+  // gesture to allow dialogs.
+  wc->GetMainFrame()->DisableBeforeUnloadHangMonitorForTesting();
+  wc->GetMainFrame()->ExecuteJavaScriptWithUserGestureForTests(
+      base::string16());
+  script = "window.onbeforeunload=function(e){ return 'x' };";
+  EXPECT_TRUE(content::ExecuteScript(wc, script));
+  EXPECT_TRUE(NavigateToURL(shell(), url));
+  dialog_manager.Wait();
+  EXPECT_FALSE(wc->IsFullscreenForCurrentTab());
+
+  wc->SetDelegate(nullptr);
+  wc->SetJavaScriptDialogManagerForTesting(nullptr);
+}
+
 }  // namespace content