Fix JavaScript alerts from frames with oopif on, after a cross-process click.

content/renderer/render_frame_impl.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 "content/renderer/render_frame_impl.h"
 
 #include <map>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 1010 matching lines @@
       geolocation_dispatcher_(NULL),
       push_messaging_dispatcher_(NULL),
       presentation_dispatcher_(NULL),
       screen_orientation_dispatcher_(NULL),
       manifest_manager_(NULL),
       accessibility_mode_(AccessibilityModeOff),
       renderer_accessibility_(NULL),
       media_player_delegate_(NULL),
       is_using_lofi_(false),
       is_pasting_(false),
+      suppress_dialogs_until_swap_out_(false),
       blame_context_(nullptr),
       weak_factory_(this) {
   std::pair<RoutingIDFrameMap::iterator, bool> result =
       g_routing_id_frame_map.Get().insert(std::make_pair(routing_id_, this));
   CHECK(result.second) << "Inserting a duplicate item.";
 
   RenderThread::Get()->AddRoute(routing_id_, this);
 
   render_view_->RegisterRenderFrame(this);
 
@@ skipping 395 matching lines @@
     IPC_MESSAGE_HANDLER(FrameMsg_PostMessageEvent, OnPostMessageEvent)
     IPC_MESSAGE_HANDLER(FrameMsg_FailedNavigation, OnFailedNavigation)
     IPC_MESSAGE_HANDLER(FrameMsg_GetSavableResourceLinks,
                         OnGetSavableResourceLinks)
     IPC_MESSAGE_HANDLER(FrameMsg_GetSerializedHtmlWithLocalLinks,
                         OnGetSerializedHtmlWithLocalLinks)
     IPC_MESSAGE_HANDLER(FrameMsg_SerializeAsMHTML, OnSerializeAsMHTML)
     IPC_MESSAGE_HANDLER(FrameMsg_Find, OnFind)
     IPC_MESSAGE_HANDLER(FrameMsg_StopFinding, OnStopFinding)
     IPC_MESSAGE_HANDLER(FrameMsg_EnableViewSourceMode, OnEnableViewSourceMode)
+    IPC_MESSAGE_HANDLER(FrameMsg_SuppressDialogsUntilSwapOut,
+                        OnSuppressDialogsUntilSwapOut)
 #if defined(OS_ANDROID)
     IPC_MESSAGE_HANDLER(InputMsg_ActivateNearestFindResult,
                         OnActivateNearestFindResult)
     IPC_MESSAGE_HANDLER(FrameMsg_FindMatchRects, OnFindMatchRects)
     IPC_MESSAGE_HANDLER(FrameMsg_SelectPopupMenuItems, OnSelectPopupMenuItems)
 #elif defined(OS_MACOSX)
     IPC_MESSAGE_HANDLER(FrameMsg_SelectPopupMenuItem, OnSelectPopupMenuItem)
     IPC_MESSAGE_HANDLER(InputMsg_CopyToFindPboard, OnCopyToFindPboard)
 #endif
   IPC_END_MESSAGE_MAP()
@@ skipping 112 matching lines @@
 
   // Let WebKit know that this view is hidden so it can drop resources and
   // stop compositing.
   // TODO(creis): Support this for subframes as well.
   if (is_main_frame_) {
     render_view_->webview()->setVisibilityState(
         blink::WebPageVisibilityStateHidden, false);
   }
 
   // It is now safe to show modal dialogs again.
-  // TODO(creis): Deal with modal dialogs from subframes.
-  if (is_main_frame_)
-    render_view_->suppress_dialogs_until_swap_out_ = false;
+  suppress_dialogs_until_swap_out_ = false;

[nasko, 2016/04/04 22:00:16]

Is it safe? This RenderFrame is about to be booted and deleted, does it make
sense to allow it to show dialogs?

[Avi (use Gerrit), 2016/04/05 01:31:18]

This particular switch is to make sure that a frame can't prevent itself from
being switched out by excessive alerts. It was introduced in
https://codereview.chromium.org/50223002 but I don't fully understand it yet.

[Avi (use Gerrit), 2016/04/06 22:20:43]

Is being swapped out a guarantee that the frame is going to be deleted?

 
   Send(new FrameHostMsg_SwapOut_ACK(routing_id_));
 
   RenderViewImpl* render_view = render_view_.get();
   bool is_main_frame = is_main_frame_;
   int routing_id = GetRoutingID();
 
   // Now that all of the cleanup is complete and the browser side is notified,
   // start using the RenderFrameProxy, if one is created.
   if (proxy) {
@@ skipping 552 matching lines @@
   return Send(message);
 }
 
 bool RenderFrameImpl::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 (render_view()->suppress_dialogs_until_swap_out_)
+  if (suppress_dialogs_until_swap_out_)
     return false;
 
   bool success = false;
   base::string16 result_temp;
   if (!result)
     result = &result_temp;
 
   SendAndRunNestedMessageLoop(new FrameHostMsg_RunJavaScriptMessage(
       routing_id_, message, default_value, frame_url, type, &success, result));
   return success;
@@ skipping 1448 matching lines @@
                                  frame_->document().url(),
                                  &result);
   if (ok)
     actual_value->assign(result);
   return ok;
 }
 
 bool RenderFrameImpl::runModalBeforeUnloadDialog(bool is_reload) {
   // Don't allow further dialogs if we are waiting to swap out, since the
   // PageGroupLoadDeferrer in our stack prevents it.
-  if (render_view()->suppress_dialogs_until_swap_out_)
+  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 FrameHostMsg_RunBeforeUnloadConfirm(
       routing_id_, frame_->document().url(), is_reload, &success,
       &ignored_result));
   return success;
@@ skipping 1492 matching lines @@
     }
   }
 }
 
 void RenderFrameImpl::OnEnableViewSourceMode() {
   DCHECK(frame_);
   DCHECK(!frame_->parent());
   frame_->enableViewSourceMode(true);
 }
 
+void RenderFrameImpl::OnSuppressDialogsUntilSwapOut() {
+  // Don't show any more dialogs until we finish OnSwapOut.
+  suppress_dialogs_until_swap_out_ = true;
+}
+
 #if defined(OS_ANDROID)
 void RenderFrameImpl::OnActivateNearestFindResult(int request_id,
                                                   float x,
                                                   float y) {
   WebRect selection_rect;
   int ordinal =
       frame_->selectNearestFindMatch(WebFloatPoint(x, y), &selection_rect);
   if (ordinal == -1) {
     // Something went wrong, so send a no-op reply (force the frame to report
     // the current match count) in case the host is waiting for a response due
@@ skipping 896 matching lines @@
                                     int match_count,
                                     int ordinal,
                                     const WebRect& selection_rect,
                                     bool final_status_update) {
   Send(new FrameHostMsg_Find_Reply(routing_id_, request_id, match_count,
                                    selection_rect, ordinal,
                                    final_status_update));
 }
 
 }  // namespace content