Remove JS dialog dependency from content.

content/browser/tab_contents/tab_contents.cc

 // Copyright (c) 2011 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/tab_contents/tab_contents.h"
 
 #include <cmath>
 
 #include "base/command_line.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/stats_counters.h"
 #include "base/string16.h"
 #include "base/string_util.h"
 #include "base/time.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/debugger/devtools_manager.h"
 #include "chrome/browser/load_from_memory_cache_details.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/notifications/desktop_notification_service_factory.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/ui/app_modal_dialogs/message_box_handler.h"
-#include "chrome/common/chrome_constants.h"
 #include "content/browser/child_process_security_policy.h"
 #include "content/browser/content_browser_client.h"
 #include "content/browser/host_zoom_map.h"
 #include "content/browser/in_process_webkit/session_storage_namespace.h"
 #include "content/browser/load_notification_details.h"
 #include "content/browser/renderer_host/render_process_host.h"
 #include "content/browser/renderer_host/render_view_host.h"
 #include "content/browser/renderer_host/render_widget_host_view.h"
 #include "content/browser/renderer_host/resource_request_details.h"
 #include "content/browser/site_instance.h"
@@ skipping 148 matching lines @@
       load_state_(net::LOAD_STATE_IDLE),
       upload_size_(0),
       upload_position_(0),
       displayed_insecure_content_(false),
       capturing_contents_(false),
       is_being_destroyed_(false),
       notify_disconnection_(false),
 #if defined(OS_WIN)
       message_box_active_(CreateEvent(NULL, TRUE, FALSE, NULL)),
 #endif
-      suppress_javascript_messages_(false),
       is_showing_before_unload_dialog_(false),
       opener_web_ui_type_(WebUI::kNoWebUI),
       closed_by_user_gesture_(false),
       minimum_zoom_percent_(
           static_cast<int>(WebKit::WebView::minTextSizeMultiplier * 100)),
       maximum_zoom_percent_(
           static_cast<int>(WebKit::WebView::maxTextSizeMultiplier * 100)),
       temporary_zoom_settings_(false),
       content_restrictions_(0) {
 
@@ skipping 12 matching lines @@
   // uses to get the routing_id.
   AddObservers();
 }
 
 TabContents::~TabContents() {
   is_being_destroyed_ = true;
 
   // We don't want any notifications while we're running our destructor.
   registrar_.RemoveAll();
 
+  // Clear out any JavaScript state.
+  if (delegate_)
+    delegate_->GetJavaScriptDialogCreator()->ResetJavaScriptState(this);
+
   NotifyDisconnected();
 
   // First cleanly close all child windows.
   // TODO(mpcomplete): handle case if MaybeCloseChildWindows() already asked
   // some of these to close.  CloseWindows is async, so it might get called
   // twice before it runs.
   CloseConstrainedWindows();
 
   // Notify any observer that have a reference on this tab contents.
   NotificationService::current()->Notify(
@@ skipping 848 matching lines @@
 
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                     DidNavigateMainFramePostCommit(details, params));
 }
 
 void TabContents::DidNavigateAnyFramePostCommit(
     RenderViewHost* render_view_host,
     const content::LoadCommittedDetails& details,
     const ViewHostMsg_FrameNavigate_Params& params) {
-  // If we navigate, start showing messages again. This does nothing to prevent
+  // If we navigate, reset JavaScript state. This does nothing to prevent
   // a malicious script from spamming messages, since the script could just
   // reload the page to stop blocking.
-  suppress_javascript_messages_ = false;
+  if (delegate_)
+    delegate_->GetJavaScriptDialogCreator()->ResetJavaScriptState(this);
 
   // Notify observers about navigation.
   FOR_EACH_OBSERVER(TabContentsObserver, observers_,
                     DidNavigateAnyFramePostCommit(details, params));
 }
 
 void TabContents::CloseConstrainedWindows() {
   // Clear out any constrained windows since we are leaving this page entirely.
   // To ensure that we iterate over every element in child_windows_ we
   // need to use a copy of child_windows_. Otherwise if
@@ skipping 446 matching lines @@
 }
 
 void TabContents::RunJavaScriptMessage(
     const RenderViewHost* rvh,
     const string16& message,
     const string16& default_prompt,
     const GURL& frame_url,
     const int flags,
     IPC::Message* reply_msg,
     bool* did_suppress_message) {
-  // Suppress javascript messages when requested and when inside a constrained
-  // popup window (because that activates them and breaks them out of the
-  // constrained window jail).
-  // Also suppress messages when showing an interstitial. The interstitial is
-  // shown over the previous page, we don't want the hidden page dialogs to
-  // interfere with the interstitial.
+  // 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 =
       rvh->is_swapped_out() ||
-      suppress_javascript_messages_ ||
       showing_interstitial_page() ||
-      (delegate() && delegate()->ShouldSuppressDialogs());
-  if (delegate())
-    suppress_this_message |=
-        (delegate()->GetConstrainingContents(this) != this);
+      !delegate_ ||
+      delegate_->ShouldSuppressDialogs();
+
+  if (!suppress_this_message) {
+    delegate_->GetJavaScriptDialogCreator()->RunJavaScriptDialog(
+        this,
+        frame_url,
+        flags,
+        message,
+        default_prompt,
+        reply_msg,
+        &suppress_this_message,
+        profile());
+  }
+
+  if (suppress_this_message) {
+    // If we are suppressing messages, just reply as if the user immediately
+    // pressed "Cancel".
+    OnDialogClosed(reply_msg, false, string16());
+  }
 
   *did_suppress_message = suppress_this_message;
-
-  if (!suppress_this_message) {
-    base::TimeDelta time_since_last_message(
-        base::TimeTicks::Now() - last_javascript_message_dismissal_);
-    bool show_suppress_checkbox = false;
-    // Show a checkbox offering to suppress further messages if this message is
-    // being displayed within kJavascriptMessageExpectedDelay of the last one.
-    if (time_since_last_message <
-        base::TimeDelta::FromMilliseconds(
-            chrome::kJavascriptMessageExpectedDelay))
-      show_suppress_checkbox = true;
-
-    RunJavascriptMessageBox(profile(),
-                            this,
-                            frame_url,
-                            flags,
-                            UTF16ToWideHack(message),
-                            UTF16ToWideHack(default_prompt),
-                            show_suppress_checkbox,
-                            reply_msg);
-  } else {
-    // If we are suppressing messages, just reply as is if the user immediately
-    // pressed "Cancel".
-    OnMessageBoxClosed(reply_msg, false, std::wstring());
-  }
 }
 
 void TabContents::RunBeforeUnloadConfirm(const RenderViewHost* rvh,
                                          const string16& message,
                                          IPC::Message* reply_msg) {
   if (delegate())
     delegate()->WillRunBeforeUnloadConfirm();
-  bool suppress_this_message = rvh->is_swapped_out() ||
-      (delegate() && delegate()->ShouldSuppressDialogs());
+
+  bool suppress_this_message =
+      rvh->is_swapped_out() ||
+      !delegate_ ||
+      delegate_->ShouldSuppressDialogs();
   if (suppress_this_message) {
     render_view_host()->JavaScriptDialogClosed(reply_msg, true, string16());
     return;
   }
+
   is_showing_before_unload_dialog_ = true;
-  RunBeforeUnloadDialog(this, UTF16ToWideHack(message), reply_msg);
+  delegate_->GetJavaScriptDialogCreator()->RunBeforeUnloadDialog(
+      this,
+      message,
+      reply_msg);
 }
 
 WebPreferences TabContents::GetWebkitPrefs() {
   Profile* profile = render_view_host()->process()->profile();
   bool is_web_ui = false;
   WebPreferences web_prefs =
       RenderViewHostDelegateHelper::GetWebkitPrefs(profile, is_web_ui);
 
   // Force accelerated compositing and 2d canvas off for chrome: and
   // chrome-extension: pages.
@@ skipping 177 matching lines @@
                           const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::RENDER_WIDGET_HOST_DESTROYED:
       view_->RenderWidgetHostDestroyed(Source<RenderWidgetHost>(source).ptr());
       break;
     default:
       NOTREACHED();
   }
 }
 
-gfx::NativeWindow TabContents::GetMessageBoxRootWindow() {
-  return view_->GetTopLevelNativeWindow();
-}
+// Overridden from JavaScriptDialogDelegate
 
-void TabContents::OnMessageBoxClosed(IPC::Message* reply_msg,
-                                     bool success,
-                                     const std::wstring& user_input) {
-  last_javascript_message_dismissal_ = base::TimeTicks::Now();
+void TabContents::OnDialogClosed(IPC::Message* reply_msg,
+                                 bool success,
+                                 const 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();
 
     tab_close_start_time_ = base::TimeTicks();
   }
   is_showing_before_unload_dialog_ = false;
   render_view_host()->JavaScriptDialogClosed(reply_msg,
                                              success,
-                                             WideToUTF16Hack(user_input));
+                                             user_input);
 }
 
-void TabContents::SetSuppressMessageBoxes(bool suppress_message_boxes) {
-  set_suppress_javascript_messages(suppress_message_boxes);
+gfx::NativeWindow TabContents::GetDialogRootWindow() {
+  return view_->GetTopLevelNativeWindow();
 }
 
 TabContents* TabContents::AsTabContents() {
   return this;
 }
 
 ExtensionHost* TabContents::AsExtensionHost() {
   return NULL;
 }
 
 void TabContents::set_encoding(const std::string& encoding) {
   encoding_ = content::GetContentClient()->browser()->
       GetCanonicalEncodingNameByAliasName(encoding);
 }
 
 void TabContents::SwapInRenderViewHost(RenderViewHost* rvh) {
   render_manager_.SwapInRenderViewHost(rvh);
 }
 
 void TabContents::CreateViewAndSetSizeForRVH(RenderViewHost* rvh) {
   RenderWidgetHostView* rwh_view = view()->CreateViewForWidget(rvh);
   rwh_view->SetSize(view()->GetContainerSize());
 }
 
 void TabContents::OnOnlineStateChanged(bool online) {
   render_view_host()->Send(new ViewMsg_NetworkStateChanged(
       render_view_host()->routing_id(), online));
 }