Revert "Refactor sudden termination"

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/lazy_instance.h"
@@ skipping 218 matching lines @@
                                    ->render_manager()
                                    ->GetRenderWidgetHostView();
   set->insert(rwhv);
 }
 
 void SetAccessibilityModeOnFrame(AccessibilityMode mode,
                                  RenderFrameHost* frame_host) {
   static_cast<RenderFrameHostImpl*>(frame_host)->SetAccessibilityMode(mode);
 }
 
-// Enable sudden termination for the current RenderFrameHost of
-// |frame_tree_node| if the ID of its SiteInstance is |site_instance_id|.  Used
-// with FrameTree::ForEach.
-bool EnableSuddenTermination(int32 site_instance_id,
-                             FrameTreeNode* frame_tree_node) {
-  if (frame_tree_node->current_frame_host()->GetSiteInstance()->GetId()
-      == site_instance_id) {
-    frame_tree_node->current_frame_host()
-        ->set_override_sudden_termination_status(true);
-  }
-  return true;
-}
-
-// Returns false and sets |sudden_termination_allowed| to false if sudden
-// termination is not allowed for the current RenderFrameHost of
-// |frame_tree_node|. Used with FrameTree::ForEach.
-bool SuddenTerminationAllowed(bool* sudden_termination_allowed,
-                              FrameTreeNode* frame_tree_node) {
-  if (frame_tree_node->current_frame_host()->SuddenTerminationAllowed())
-    return true;
-  *sudden_termination_allowed = false;
-  return false;
-}
-
 // Returns true if at least one of the nodes in the |frame_tree| is loading.
 bool IsFrameTreeLoading(FrameTree& frame_tree) {
   bool is_loading = false;
   frame_tree.ForEach(base::Bind(&IsNodeLoading, &is_loading));
   return is_loading;
 }
 
 }  // namespace
 
 WebContents* WebContents::Create(const WebContents::CreateParams& params) {
@@ skipping 575 matching lines @@
 }
 
 bool WebContentsImpl::IsFullAccessibilityModeForTesting() const {
   return accessibility_mode_ == AccessibilityModeComplete;
 }
 
 #if defined(OS_WIN)
 void WebContentsImpl::SetParentNativeViewAccessible(
 gfx::NativeViewAccessible accessible_parent) {
   accessible_parent_ = accessible_parent;
-  RenderFrameHostImpl* rfh = GetMainFrame();
+  RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
   if (rfh)
     rfh->SetParentNativeViewAccessible(accessible_parent);
 }
 #endif
 
 const base::string16& WebContentsImpl::GetTitle() const {
   // Transient entries take precedence. They are used for interstitial pages
   // that are shown on top of existing pages.
   NavigationEntry* entry = controller_.GetTransientEntry();
   std::string accept_languages =
@@ skipping 313 matching lines @@
 }
 
 void WebContentsImpl::WasUnOccluded() {
   for (RenderWidgetHostView* view : GetRenderWidgetHostViewsInTree()) {
     if (view)
       view->WasUnOccluded();
   }
 }
 
 bool WebContentsImpl::NeedToFireBeforeUnload() {
-  bool sudden_termination_allowed = true;
-  frame_tree_.ForEach(base::Bind(
-        &SuddenTerminationAllowed, &sudden_termination_allowed));
   // TODO(creis): Should we fire even for interstitial pages?
   return WillNotifyDisconnection() &&
       !ShowingInterstitialPage() &&
-      !sudden_termination_allowed;
+      !static_cast<RenderViewHostImpl*>(
+          GetRenderViewHost())->SuddenTerminationAllowed();
 }
 
 void WebContentsImpl::DispatchBeforeUnload(bool for_cross_site_transition) {
-  GetMainFrame()->DispatchBeforeUnload(for_cross_site_transition);
+  static_cast<RenderFrameHostImpl*>(GetMainFrame())->DispatchBeforeUnload(
+      for_cross_site_transition);
 }
 
 void WebContentsImpl::Stop() {
   GetRenderManager()->Stop();
   FOR_EACH_OBSERVER(WebContentsObserver, observers_, NavigationStopped());
 }
 
 WebContents* WebContentsImpl::Clone() {
   // We use our current SiteInstance since the cloned entry will use it anyway.
   // We pass our own opener so that the cloned page can access it if it was
@@ skipping 228 matching lines @@
   // Notify the delegate if an embedded fullscreen widget was focused.
   if (delegate_ && render_widget_host &&
       delegate_->EmbedsFullscreenWidget() &&
       render_widget_host->GetView() == GetFullscreenRenderWidgetHostView())
     delegate_->WebContentsFocused(this);
 }
 
 void WebContentsImpl::RenderWidgetWasResized(
     RenderWidgetHostImpl* render_widget_host,
     bool width_changed) {
-  RenderFrameHostImpl* rfh = GetMainFrame();
+  RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
   if (!rfh || render_widget_host != rfh->GetRenderWidgetHost())
     return;
 
   FOR_EACH_OBSERVER(WebContentsObserver, observers_,
                     MainFrameWasResized(width_changed));
 }
 
 void WebContentsImpl::ScreenInfoChanged() {
   if (browser_plugin_embedder_)
     browser_plugin_embedder_->ScreenInfoChanged();
@@ skipping 412 matching lines @@
   if (BrowserPluginGuest::IsGuest(new_contents))
     return new_contents;
 
   if (!new_contents->GetRenderProcessHost()->HasConnection() ||
       !new_contents->GetRenderViewHost()->GetView())
     return NULL;
 
   // Resume blocked requests for both the RenderViewHost and RenderFrameHost.
   // TODO(brettw): It seems bogus to reach into here and initialize the host.
   static_cast<RenderViewHostImpl*>(new_contents->GetRenderViewHost())->Init();
-  new_contents->GetMainFrame()->Init();
+  static_cast<RenderFrameHostImpl*>(new_contents->GetMainFrame())->Init();
 
   return new_contents;
 }
 
 RenderWidgetHostView* WebContentsImpl::GetCreatedWidget(int route_id) {
   PendingWidgetViews::iterator iter = pending_widget_views_.find(route_id);
   if (iter == pending_widget_views_.end()) {
     DCHECK(false);
     return NULL;
   }
@@ skipping 97 matching lines @@
     delegate_->MoveValidationMessage(this, anchor_in_root_view);
 }
 
 void WebContentsImpl::DidSendScreenRects(RenderWidgetHostImpl* rwh) {
   if (browser_plugin_embedder_)
     browser_plugin_embedder_->DidSendScreenRects();
 }
 
 BrowserAccessibilityManager*
     WebContentsImpl::GetRootBrowserAccessibilityManager() {
-  RenderFrameHostImpl* rfh = GetMainFrame();
+  RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
   return rfh ? rfh->browser_accessibility_manager() : NULL;
 }
 
 BrowserAccessibilityManager*
     WebContentsImpl::GetOrCreateRootBrowserAccessibilityManager() {
-  RenderFrameHostImpl* rfh = GetMainFrame();
+  RenderFrameHostImpl* rfh = static_cast<RenderFrameHostImpl*>(GetMainFrame());
   return rfh ? rfh->GetOrCreateBrowserAccessibilityManager() : NULL;
 }
 
 void WebContentsImpl::UpdatePreferredSize(const gfx::Size& pref_size) {
   const gfx::Size old_size = GetPreferredSize();
   preferred_size_ = pref_size;
   OnPreferredSizeChanged(old_size);
 }
 
 void WebContentsImpl::ResizeDueToAutoResize(const gfx::Size& new_size) {
@@ skipping 2183 matching lines @@
   // Ignore renderer unresponsive event if debugger is attached to the tab
   // since the event may be a result of the renderer sitting on a breakpoint.
   // See http://crbug.com/65458
   if (DevToolsAgentHost::IsDebuggerAttached(this))
     return;
 
   if (rfhi->IsWaitingForBeforeUnloadACK() ||
       rfhi->IsWaitingForUnloadACK()) {
     // Hang occurred while firing the beforeunload/unload handler.
     // Pretend the handler fired so tab closing continues as if it had.
-    frame_tree_.ForEach(base::Bind(
-          &EnableSuddenTermination, rvhi->GetSiteInstance()->GetId()));
+    rvhi->set_sudden_termination_allowed(true);
 
     if (!GetRenderManager()->ShouldCloseTabOnUnresponsiveRenderer())
       return;
 
     // If the tab hangs in the beforeunload/unload handler there's really
     // nothing we can do to recover. If the hang is in the beforeunload handler,
     // pretend the beforeunload listeners have all fired and allow the delegate
     // to continue closing; the user will not have the option of cancelling the
     // close. Otherwise, pretend the unload listeners have all fired and close
     // the tab.
@@ skipping 424 matching lines @@
   node->render_manager()->ResumeResponseDeferredAtStart();
 }
 
 void WebContentsImpl::SetForceDisableOverscrollContent(bool force_disable) {
   force_disable_overscroll_content_ = force_disable;
   if (view_)
     view_->SetOverscrollControllerEnabled(CanOverscrollContent());
 }
 
 }  // namespace content