Move modal dialogs from WebViewClient to WebFrameClient, part 1/3.

content/browser/web_contents/web_contents_impl.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/browser/web_contents/web_contents_impl.h"
 
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 2849 matching lines @@
 
 void WebContentsImpl::ShowContextMenu(RenderFrameHost* render_frame_host,
                                       const ContextMenuParams& params) {
   // Allow WebContentsDelegates to handle the context menu operation first.
   if (delegate_ && delegate_->HandleContextMenu(params))
     return;
 
   render_view_host_delegate_view_->ShowContextMenu(render_frame_host, params);
 }
 
+void WebContentsImpl::RunJavaScriptMessage(
+    RenderFrameHost* rfh,
+    const base::string16& message,
+    const base::string16& default_prompt,
+    const GURL& frame_url,
+    JavaScriptMessageType javascript_message_type,
+    IPC::Message* reply_msg,
+    bool* did_suppress_message) {
+  // Suppress JavaScript dialogs when requested. Also suppress messages when
+  // showing an interstitial as it's shown over the previous page and we don't
+  // want the hidden page's dialogs to interfere with the interstitial.
+  bool suppress_this_message =
+      static_cast<RenderFrameHostImpl*>(rfh)->is_swapped_out() ||
+      ShowingInterstitialPage() ||
+      !delegate_ ||
+      delegate_->ShouldSuppressDialogs() ||
+      !delegate_->GetJavaScriptDialogManager();
+
+  if (!suppress_this_message) {
+    std::string accept_lang = GetContentClient()->browser()->
+      GetAcceptLangs(GetBrowserContext());
+    dialog_manager_ = delegate_->GetJavaScriptDialogManager();
+    dialog_manager_->RunJavaScriptDialog(
+        this,
+        frame_url.GetOrigin(),
+        accept_lang,
+        javascript_message_type,
+        message,
+        default_prompt,
+        base::Bind(&WebContentsImpl::OnDialogClosed,
+                   base::Unretained(this),
+                   rfh,
+                   reply_msg),
+        &suppress_this_message);
+  }
+
+  *did_suppress_message = suppress_this_message;
+
+  if (suppress_this_message) {
+    // If we are suppressing messages, just reply as if the user immediately
+    // pressed "Cancel".
+    OnDialogClosed(rfh, reply_msg, false, base::string16());
+  }
+
+  // OnDialogClosed (two lines up) may have caused deletion of this object (see
+  // http://crbug.com/288961 ). The only safe thing to do here is return.
+}
+
+void WebContentsImpl::RunBeforeUnloadConfirm(
+    RenderFrameHost* rfh,
+    const base::string16& message,
+    bool is_reload,
+    IPC::Message* reply_msg) {
+  RenderFrameHostImpl* rfhi = static_cast<RenderFrameHostImpl*>(rfh);
+  RenderViewHostImpl* rvhi =
+      static_cast<RenderViewHostImpl*>(rfh->GetRenderViewHost());
+  if (delegate_)
+    delegate_->WillRunBeforeUnloadConfirm();
+
+  bool suppress_this_message =
+      rvhi->rvh_state() != RenderViewHostImpl::STATE_DEFAULT ||
+      !delegate_ ||
+      delegate_->ShouldSuppressDialogs() ||
+      !delegate_->GetJavaScriptDialogManager();
+  if (suppress_this_message) {
+    // The reply must be sent to the RFH that sent the request.
+    rfhi->JavaScriptDialogClosed(reply_msg, true, base::string16());
+    return;
+  }
+
+  is_showing_before_unload_dialog_ = true;
+  dialog_manager_ = delegate_->GetJavaScriptDialogManager();
+  dialog_manager_->RunBeforeUnloadDialog(
+      this, message, is_reload,
+      base::Bind(&WebContentsImpl::OnDialogClosed, base::Unretained(this), rfh,
+                 reply_msg));
+}
+
 WebContents* WebContentsImpl::GetAsWebContents() {
   return this;
 }
 
 RenderViewHostDelegateView* WebContentsImpl::GetDelegateView() {
   return render_view_host_delegate_view_;
 }
 
 RendererPreferences WebContentsImpl::GetRendererPrefs(
     BrowserContext* browser_context) const {
@@ skipping 364 matching lines @@
       new_params.source_routing_id = MSG_ROUTING_NONE;
     }
   }
 
   // In most cases, we receive this from a swapped out RenderViewHost.
   // It is possible to receive it from one that has just been swapped in,
   // in which case we might as well deliver the message anyway.
   Send(new ViewMsg_PostMessageEvent(GetRoutingID(), new_params));
 }
 
-void WebContentsImpl::RunJavaScriptMessage(
+void WebContentsImpl::RunJavaScriptMessageOBSOLETE(
     RenderViewHost* rvh,
     const base::string16& message,
     const base::string16& default_prompt,
     const GURL& frame_url,
     JavaScriptMessageType javascript_message_type,
     IPC::Message* reply_msg,
     bool* did_suppress_message) {
   // Suppress JavaScript dialogs when requested. Also suppress messages when
   // showing an interstitial as it's shown over the previous page and we don't
   // want the hidden page's dialogs to interfere with the interstitial.
   bool suppress_this_message =
       static_cast<RenderViewHostImpl*>(rvh)->IsSwappedOut() ||
       ShowingInterstitialPage() ||
       !delegate_ ||
       delegate_->ShouldSuppressDialogs() ||
       !delegate_->GetJavaScriptDialogManager();
 
   if (!suppress_this_message) {
     std::string accept_lang = GetContentClient()->browser()->
       GetAcceptLangs(GetBrowserContext());
     dialog_manager_ = delegate_->GetJavaScriptDialogManager();
     dialog_manager_->RunJavaScriptDialog(
         this,
         frame_url.GetOrigin(),
         accept_lang,
         javascript_message_type,
         message,
         default_prompt,
-        base::Bind(&WebContentsImpl::OnDialogClosed,
+        base::Bind(&WebContentsImpl::OnDialogClosedOBSOLETE,
                    base::Unretained(this),
                    rvh,
                    reply_msg),
         &suppress_this_message);
   }
 
   *did_suppress_message = suppress_this_message;
 
   if (suppress_this_message) {
     // If we are suppressing messages, just reply as if the user immediately
     // pressed "Cancel".
-    OnDialogClosed(rvh, reply_msg, false, base::string16());
+    OnDialogClosedOBSOLETE(rvh, reply_msg, false, base::string16());
   }
 
   // OnDialogClosed (two lines up) may have caused deletion of this object (see
   // http://crbug.com/288961 ). The only safe thing to do here is return.
 }
 
-void WebContentsImpl::RunBeforeUnloadConfirm(RenderViewHost* rvh,
-                                             const base::string16& message,
-                                             bool is_reload,
-                                             IPC::Message* reply_msg) {
+void WebContentsImpl::RunBeforeUnloadConfirmOBSOLETE(
+    RenderViewHost* rvh,
+    const base::string16& message,
+    bool is_reload,
+    IPC::Message* reply_msg) {
   RenderViewHostImpl* rvhi = static_cast<RenderViewHostImpl*>(rvh);
   if (delegate_)
     delegate_->WillRunBeforeUnloadConfirm();
 
   bool suppress_this_message =
       rvhi->rvh_state() != RenderViewHostImpl::STATE_DEFAULT ||
       !delegate_ ||
       delegate_->ShouldSuppressDialogs() ||
       !delegate_->GetJavaScriptDialogManager();
   if (suppress_this_message) {
     // The reply must be sent to the RVH that sent the request.
     rvhi->JavaScriptDialogClosed(reply_msg, true, base::string16());
     return;
   }
 
   is_showing_before_unload_dialog_ = true;
   dialog_manager_ = delegate_->GetJavaScriptDialogManager();
   dialog_manager_->RunBeforeUnloadDialog(
       this, message, is_reload,
-      base::Bind(&WebContentsImpl::OnDialogClosed, base::Unretained(this), rvh,
+      base::Bind(&WebContentsImpl::OnDialogClosedOBSOLETE,
+                 base::Unretained(this),
+                 rvh,
                  reply_msg));
 }
 
 bool WebContentsImpl::AddMessageToConsole(int32 level,
                                           const base::string16& message,
                                           int32 line_no,
                                           const base::string16& source_id) {
   if (!delegate_)
     return false;
   return delegate_->AddMessageToConsole(this, level, message, line_no,
@@ skipping 257 matching lines @@
   return web_contents_android->GetJavaObject();
 }
 
 bool WebContentsImpl::CreateRenderViewForInitialEmptyDocument() {
   return CreateRenderViewForRenderManager(GetRenderViewHost(),
                                           MSG_ROUTING_NONE,
                                           NULL);
 }
 #endif
 
-void WebContentsImpl::OnDialogClosed(RenderViewHost* rvh,
-                                     IPC::Message* reply_msg,
-                                     bool success,
-                                     const base::string16& user_input) {
+void WebContentsImpl::OnDialogClosedOBSOLETE(RenderViewHost* rvh,
+                                             IPC::Message* reply_msg,
+                                             bool success,
+                                             const base::string16& user_input) {
   if (is_showing_before_unload_dialog_ && !success) {
     // If a beforeunload dialog is canceled, we need to stop the throbber from
     // spinning, since we forced it to start spinning in Navigate.
     DidStopLoading(rvh->GetMainFrame());
     controller_.DiscardNonCommittedEntries();
 
     FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                       BeforeUnloadDialogCancelled());
   }
   is_showing_before_unload_dialog_ = false;
-  static_cast<RenderViewHostImpl*>(
-      rvh)->JavaScriptDialogClosed(reply_msg, success, user_input);
+  static_cast<RenderViewHostImpl*>(rvh)->
+      JavaScriptDialogClosed(reply_msg, success, user_input);
+}
+
+void WebContentsImpl::OnDialogClosed(RenderFrameHost* rfh,
+                                     IPC::Message* reply_msg,
+                                     bool success,
+                                     const base::string16& user_input) {
+  if (is_showing_before_unload_dialog_ && !success) {
+    // If a beforeunload dialog is canceled, we need to stop the throbber from
+    // spinning, since we forced it to start spinning in Navigate.
+    DidStopLoading(rfh);
+    controller_.DiscardNonCommittedEntries();
+
+    FOR_EACH_OBSERVER(WebContentsObserver, observers_,
+                      BeforeUnloadDialogCancelled());
+  }
+  is_showing_before_unload_dialog_ = false;
+  static_cast<RenderFrameHostImpl*>(rfh)->
+      JavaScriptDialogClosed(reply_msg, success, user_input);
 }
 
 void WebContentsImpl::SetEncoding(const std::string& encoding) {
   encoding_ = GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 void WebContentsImpl::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view_->CreateViewForWidget(rvh);
   // Can be NULL during tests.
@@ skipping 64 matching lines @@
 
 void WebContentsImpl::OnPreferredSizeChanged(const gfx::Size& old_size) {
   if (!delegate_)
     return;
   const gfx::Size new_size = GetPreferredSize();
   if (new_size != old_size)
     delegate_->UpdatePreferredSize(this, new_size);
 }
 
 }  // namespace content