Refactor sudden termination

content/browser/renderer_host/render_process_host_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.
 
 // Represents the browser side of the browser <--> renderer communication
 // channel. There will be one RenderProcessHost per renderer process.
 
 #include "content/browser/renderer_host/render_process_host_impl.h"
 
 #include <algorithm>
@@ skipping 433 matching lines @@
       is_self_deleted_(false),
 #endif
       pending_views_(0),
       mojo_application_host_(new MojoApplicationHost),
       visible_widgets_(0),
       backgrounded_(true),
       is_initialized_(false),
       id_(ChildProcessHostImpl::GenerateChildProcessUniqueId()),
       browser_context_(browser_context),
       storage_partition_impl_(storage_partition_impl),
-      sudden_termination_allowed_(true),
+      sudden_termination_enabled_(true),
       ignore_input_events_(false),
       is_isolated_guest_(is_isolated_guest),
       gpu_observer_registered_(false),
       delayed_cleanup_needed_(false),
       within_process_died_observer_(false),
       power_monitor_broadcaster_(this),
       worker_ref_count_(0),
       permission_service_context_(new PermissionServiceContext(this)),
       pending_valuebuffer_state_(new gpu::ValueStateMap()),
       subscribe_uniform_enabled_(false),
@@ skipping 954 matching lines @@
   if (!child_process_launcher_.get() ||
       child_process_launcher_->IsStarting() ||
       !GetHandle())
     return false;  // Render process hasn't started or is probably crashed.
 
   // Test if there's an unload listener.
   // NOTE: It's possible that an onunload listener may be installed
   // while we're shutting down, so there's a small race here.  Given that
   // the window is small, it's unlikely that the web page has much
   // state that will be lost by not calling its unload handlers properly.
   if (!SuddenTerminationAllowed())

[Charlie Reis, 2015/01/29 23:20:41]

This confused me at first, but I think I follow it now.

This is the only call of RPH::SuddenTerminationAllowed.  At first I thought it
only tracked the DOM storage callback status, but it actually tracks whether
*any* reason is present (beforeunload, unload, DOM storage callback).  The count
is in RendererBlinkPlatformImpl.

This means that RPHI always has a global view of the conditions for the process.
 sudden_termination_allowed_ is true if there are any reasons not to exit (in
any frame or otherwise), and false otherwise.

Thus, it does not need to ask frames individually.

[clamy, 2015/02/02 16:16:27]

As I explained in the other comment, I was planing to remove the calls to
RendererBlinkPlatformImpl::enableSuddenTermination in LocalDOMWindow in order to
not duplicate the tracking of BeforeUnload/Unload handlers (but that has to go
in another blink patch after this one lands). In that case RPHI does not know
about unload and before unload handlers and needs to ask the frames
individually.

Now we may decide that this is too complex, or that tracking the handlers twice
is fine.

[Charlie Reis, 2015/02/02 20:14:50]

I think tracking the handlers twice is fine.  It's a smaller delta from what we
have today and it avoids a reason for RPHI to know about and loop through all
frames in the process.  Given that these handlers are rare, I'd rather notify
both RFH and RPHI when they're present than always require RPHI to iterate when
trying to exit.

[clamy, 2015/02/03 12:54:02]

Acknowledged.

     return false;
 
   if (worker_ref_count_ != 0) {
     if (survive_for_worker_start_time_.is_null())
       survive_for_worker_start_time_ = base::TimeTicks::Now();
     return false;
   }
 
   // Set this before ProcessDied() so observers can tell if the render process
   // died due to fast shutdown versus another cause.
@@ skipping 40 matching lines @@
 
   mark_child_process_activity_time();
   if (msg.routing_id() == MSG_ROUTING_CONTROL) {
     // Dispatch control messages.
     IPC_BEGIN_MESSAGE_MAP(RenderProcessHostImpl, msg)
       IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ShutdownRequest,
                           OnShutdownRequest)
       IPC_MESSAGE_HANDLER(ChildProcessHostMsg_DumpHandlesDone,
                           OnDumpHandlesDone)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SuddenTerminationChanged,
-                          SuddenTerminationChanged)
+                          OnSuddenTerminationChanged)
       IPC_MESSAGE_HANDLER(ViewHostMsg_UserMetricsRecordAction,
                           OnUserMetricsRecordAction)
       IPC_MESSAGE_HANDLER(ViewHostMsg_SavedPageAsMHTML, OnSavedPageAsMHTML)
       IPC_MESSAGE_HANDLER(ViewHostMsg_Close_ACK, OnCloseACK)
 #if defined(ENABLE_WEBRTC)
       IPC_MESSAGE_HANDLER(AecDumpMsg_RegisterAecDumpConsumer,
                           OnRegisterAecDumpConsumer)
       IPC_MESSAGE_HANDLER(AecDumpMsg_UnregisterAecDumpConsumer,
                           OnUnregisterAecDumpConsumer)
 #endif
@@ skipping 136 matching lines @@
 
 void RenderProcessHostImpl::AddPendingView() {
   pending_views_++;
 }
 
 void RenderProcessHostImpl::RemovePendingView() {
   DCHECK(pending_views_);
   pending_views_--;
 }
 
-void RenderProcessHostImpl::SetSuddenTerminationAllowed(bool enabled) {
-  sudden_termination_allowed_ = enabled;
-}
-
 bool RenderProcessHostImpl::SuddenTerminationAllowed() const {
-  return sudden_termination_allowed_;
+  return sudden_termination_enabled_;
 }
 
 base::TimeDelta RenderProcessHostImpl::GetChildProcessIdleTime() const {
   return base::TimeTicks::Now() - child_process_activity_time_;
 }
 
 void RenderProcessHostImpl::ResumeRequestsForView(int route_id) {
   widget_helper_->ResumeRequestsForView(route_id);
 }
 
@@ skipping 480 matching lines @@
   NotificationService::current()->Notify(
       NOTIFICATION_RENDERER_PROCESS_CLOSING,
       Source<RenderProcessHost>(this),
       NotificationService::NoDetails());
 
   mojo_application_host_->WillDestroySoon();
 
   Send(new ChildProcessMsg_Shutdown());
 }
 
-void RenderProcessHostImpl::SuddenTerminationChanged(bool enabled) {
-  SetSuddenTerminationAllowed(enabled);
+void RenderProcessHostImpl::OnSuddenTerminationChanged(bool enabled) {
+  sudden_termination_enabled_ = enabled;
 }
 
 void RenderProcessHostImpl::OnDumpHandlesDone() {
   Cleanup();
 }
 
 void RenderProcessHostImpl::SetBackgrounded(bool backgrounded) {
   // Note: we always set the backgrounded_ value.  If the process is NULL
   // (and hence hasn't been created yet), we will set the process priority
   // later when we create the process.
@@ skipping 195 matching lines @@
 
 void RenderProcessHostImpl::DecrementWorkerRefCount() {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   DCHECK_GT(worker_ref_count_, 0);
   --worker_ref_count_;
   if (worker_ref_count_ == 0)
     Cleanup();
 }
 
 }  // namespace content