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

content/renderer/render_view_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/renderer/render_view_impl.h"
 
 #include <algorithm>
 #include <cmath>
 
 #include "base/auto_reset.h"
@@ skipping 1382 matching lines @@
   std::string error_html;
   GetContentClient()->renderer()->GetNavigationErrorStrings(
       this, frame, failed_request, error, &error_html, NULL);
 
   frame->loadHTMLString(error_html,
                         GURL(kUnreachableWebDataURL),
                         error.unreachableURL,
                         replace);
 }
 
-bool RenderViewImpl::RunJavaScriptMessage(JavaScriptMessageType type,
-                                          const base::string16& message,
-                                          const base::string16& default_value,
-                                          const GURL& frame_url,
-                                          base::string16* result) {
-  // Don't allow further dialogs if we are waiting to swap out, since the
-  // PageGroupLoadDeferrer in our stack prevents it.
-  if (suppress_dialogs_until_swap_out_)
-    return false;
-
-  bool success = false;
-  base::string16 result_temp;
-  if (!result)
-    result = &result_temp;
-
-  SendAndRunNestedMessageLoop(new ViewHostMsg_RunJavaScriptMessage(
-      routing_id_, message, default_value, frame_url, type, &success, result));
-  return success;
-}
-
 bool RenderViewImpl::SendAndRunNestedMessageLoop(IPC::SyncMessage* message) {
   // Before WebKit asks us to show an alert (etc.), it takes care of doing the
   // equivalent of WebView::willEnterModalLoop.  In the case of showModalDialog
   // it is particularly important that we do not call willEnterModalLoop as
   // that would defer resource loads for the dialog itself.
   if (RenderThreadImpl::current())  // Will be NULL during unit tests.
     RenderThreadImpl::current()->DoNotNotifyWebKitOfModalLoop();
 
   message->EnableMessagePumping();  // Runs a nested message loop.
   return Send(message);
@@ skipping 295 matching lines @@
     ipc_params.accept_types.push_back(params.acceptTypes[i]);
 #if defined(OS_ANDROID)
   ipc_params.capture = params.useMediaCapture;
 #endif
 
   return ScheduleFileChooser(ipc_params, chooser_completion);
 }
 
 void RenderViewImpl::runModalAlertDialog(WebLocalFrame* frame,
                                          const WebString& message) {
-  RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_ALERT,
-                       message,
-                       base::string16(),
-                       frame->document().url(),
-                       NULL);
+  RenderFrameImpl::FromWebFrame(frame)->runModalAlertDialog(message);
 }
 
 bool RenderViewImpl::runModalConfirmDialog(WebLocalFrame* frame,
                                            const WebString& message) {
-  return RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_CONFIRM,
-                              message,
-                              base::string16(),
-                              frame->document().url(),
-                              NULL);
+  return RenderFrameImpl::FromWebFrame(frame)->runModalConfirmDialog(message);
 }
 
 bool RenderViewImpl::runModalPromptDialog(WebLocalFrame* frame,
                                           const WebString& message,
                                           const WebString& default_value,
                                           WebString* actual_value) {
-  base::string16 result;
-  bool ok = RunJavaScriptMessage(JAVASCRIPT_MESSAGE_TYPE_PROMPT,
-                                 message,
-                                 default_value,
-                                 frame->document().url(),
-                                 &result);
-  if (ok)
-    actual_value->assign(result);
-  return ok;
+  return RenderFrameImpl::FromWebFrame(frame)->
+      runModalPromptDialog(message, default_value, actual_value);
 }
 
 bool RenderViewImpl::runModalBeforeUnloadDialog(WebLocalFrame* frame,
                                                 const WebString& message) {
   bool is_reload = false;
   WebDataSource* ds = frame->provisionalDataSource();
   if (ds)
     is_reload = (ds->navigationType() == blink::WebNavigationTypeReload);
-  return runModalBeforeUnloadDialog(frame, is_reload, message);
+  return RenderFrameImpl::FromWebFrame(frame)->
+      runModalBeforeUnloadDialog(is_reload, message);
 }
 
-bool RenderViewImpl::runModalBeforeUnloadDialog(WebLocalFrame* frame,
-                                                bool is_reload,
+void RenderViewImpl::runModalAlertDialog(const WebString& message) {
+  /* bogus version of the function to avoid errors */
+  NOTIMPLEMENTED();
+}
+
+bool RenderViewImpl::runModalConfirmDialog(const WebString& message) {
+  /* bogus version of the function to avoid errors */
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool RenderViewImpl::runModalPromptDialog(const WebString& message,
+                                          const WebString& default_value,
+                                          WebString* actual_value) {
+  /* bogus version of the function to avoid errors */
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool RenderViewImpl::runModalBeforeUnloadDialog(bool is_reload,
                                                 const WebString& message) {
-  // If we are swapping out, we have already run the beforeunload handler.
-  // TODO(creis): Fix OnSwapOut to clear the frame without running beforeunload
-  // at all, to avoid running it twice.
-  if (is_swapped_out_)
-    return true;
-
-  // Don't allow further dialogs if we are waiting to swap out, since the
-  // PageGroupLoadDeferrer in our stack prevents it.
-  if (suppress_dialogs_until_swap_out_)
-    return false;
-
-  bool success = false;
-  // This is an ignored return value, but is included so we can accept the same
-  // response as RunJavaScriptMessage.
-  base::string16 ignored_result;
-  SendAndRunNestedMessageLoop(new ViewHostMsg_RunBeforeUnloadConfirm(
-      routing_id_, frame->document().url(), message, is_reload,
-      &success, &ignored_result));
-  return success;
+  /* bogus version of the function to avoid errors */
+  NOTIMPLEMENTED();
+  return false;
 }
 
 void RenderViewImpl::showValidationMessage(
     const blink::WebRect& anchor_in_root_view,
     const blink::WebString& main_text,
     const blink::WebString& sub_text,
     blink::WebTextDirection hint) {
   base::string16 wrapped_main_text = main_text;
   base::string16 wrapped_sub_text = sub_text;
   if (hint == blink::WebTextDirectionLeftToRight) {
@@ skipping 1163 matching lines @@
 }
 
 float RenderViewImpl::GetFilteredTimePerFrame() const {
   return filtered_time_per_frame();
 }
 
 blink::WebPageVisibilityState RenderViewImpl::GetVisibilityState() const {
   return visibilityState();
 }
 
-void RenderViewImpl::RunModalAlertDialog(blink::WebLocalFrame* frame,
-                                         const blink::WebString& message) {
-  return runModalAlertDialog(frame, message);
-}
-
 void RenderViewImpl::DidStartLoading() {
   main_render_frame_->didStartLoading(true);
 }
 
 void RenderViewImpl::DidStopLoading() {
   main_render_frame_->didStopLoading();
 }
 
 void RenderViewImpl::DidPlay(blink::WebMediaPlayer* player) {
   Send(new ViewHostMsg_MediaPlayingNotification(routing_id_,
@@ skipping 1752 matching lines @@
     std::vector<gfx::Size> sizes(icon_urls[i].sizes().size());
     ConvertToFaviconSizes(icon_urls[i].sizes(), &sizes);
     if (!url.isEmpty())
       urls.push_back(
           FaviconURL(url, ToFaviconType(icon_urls[i].iconType()), sizes));
   }
   SendUpdateFaviconURL(urls);
 }
 
 }  // namespace content