[wip] Add some more state to RenderViewHost's lifetime.

content/browser/renderer_host/render_view_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.
 
 #include "content/browser/renderer_host/render_view_host_impl.h"
 
 #include <set>
 #include <string>
 #include <utility>
 #include <vector>
@@ skipping 196 matching lines @@
       has_accessed_initial_document_(false),
       main_frame_routing_id_(main_frame_routing_id),
       run_modal_reply_msg_(NULL),
       run_modal_opener_id_(MSG_ROUTING_NONE),
       is_waiting_for_beforeunload_ack_(false),
       unload_ack_is_for_cross_site_transition_(false),
       are_javascript_messages_suppressed_(false),
       sudden_termination_allowed_(false),
       render_view_termination_status_(base::TERMINATION_STATUS_STILL_RUNNING),
       virtual_keyboard_requested_(false),
+      copy_requests_(0),
       weak_factory_(this) {
   DCHECK(instance_.get());
   CHECK(delegate_);  // http://crbug.com/82827
 
   GetProcess()->EnableSendQueue();
 
   if (swapped_out) {
     rvh_state_ = STATE_SWAPPED_OUT;
   } else {
     rvh_state_ = STATE_DEFAULT;
@@ skipping 502 matching lines @@
 
   switch (rvh_state_) {
     case STATE_WAITING_FOR_UNLOAD_ACK:
       SetState(STATE_WAITING_FOR_COMMIT);
       break;
     case STATE_PENDING_SWAP_OUT:
       SetState(STATE_SWAPPED_OUT);
       break;
     case STATE_PENDING_SHUTDOWN:
       DCHECK(!pending_shutdown_on_swap_out_.is_null());
-      pending_shutdown_on_swap_out_.Run();
+      if (copy_requests_ == 0)
+        pending_shutdown_on_swap_out_.Run();
       break;
     default:
       NOTREACHED();
   }
 }
 
 void RenderViewHostImpl::WasSwappedOut(
     const base::Closure& pending_delete_on_swap_out) {
-  Send(new ViewMsg_WasSwappedOut(GetRoutingID()));
+  if (copy_requests_ == 0)
+    Send(new ViewMsg_WasSwappedOut(GetRoutingID()));
   if (rvh_state_ == STATE_WAITING_FOR_UNLOAD_ACK) {
     if (instance_->active_view_count())
       SetState(STATE_PENDING_SWAP_OUT);
     else
       SetPendingShutdown(pending_delete_on_swap_out);
   } else if (rvh_state_ == STATE_WAITING_FOR_COMMIT) {
     SetState(STATE_SWAPPED_OUT);
   } else if (rvh_state_ == STATE_DEFAULT) {
     // When the RenderView is not live, the RenderFrameHostManager will call
     // CommitPending directly, without calling SwapOut on the old RVH. This will
@@ skipping 1093 matching lines @@
   Send(new ViewMsg_TimezoneChange(GetRoutingID()));
 }
 
 void RenderViewHostImpl::GetAudioOutputControllers(
     const GetAudioOutputControllersCallback& callback) const {
   AudioRendererHost* audio_host =
       static_cast<RenderProcessHostImpl*>(GetProcess())->audio_renderer_host();
   audio_host->GetOutputControllers(GetRoutingID(), callback);
 }
 
+void RenderViewHostImpl::CopyFromBackingStoreCallback(
+    const base::Callback<void(bool, const SkBitmap&)>& callback,
+    bool success,
+    const SkBitmap& bitmap) {
+  --copy_requests_;
+  LOG(ERROR) << "Done with a request: " << copy_requests_;
+  callback.Run(success, bitmap);
+  if (copy_requests_ == 0) {
+    if (!IsRVHStateActive(rvh_state_)) {
+      Send(new ViewMsg_WasSwappedOut(GetRoutingID()));
+      instance_->decrement_active_view_count();
+    }
+
+    if (rvh_state_ == STATE_PENDING_SHUTDOWN) {
+      DCHECK(!pending_shutdown_on_swap_out_.is_null());
+      pending_shutdown_on_swap_out_.Run();

[mfomitchev, 2014/03/24 18:49:10]

Can't we have a situation where this gets executed before
RenderViewHostImpl::OnSwappedOut()? If that happens,
pending_shutdown_on_swap_out_ will be executed twice..

+    }
+  }
+}
+
+void RenderViewHostImpl::CopyFromBackingStore(
+    const gfx::Rect& src_rect,
+    const gfx::Size& accelerated_dst_size,
+    const base::Callback<void(bool, const SkBitmap&)>& callback) {
+  DCHECK(IsRVHStateActive(rvh_state_));
+  if (!IsRVHStateActive(rvh_state_)) {
+    callback.Run(false, SkBitmap());
+    return;
+  }
+  ++copy_requests_;
+  LOG(ERROR) << "Starting a request: " << copy_requests_;
+  RenderWidgetHostImpl::CopyFromBackingStore(src_rect, accelerated_dst_size,
+      base::Bind(&RenderViewHostImpl::CopyFromBackingStoreCallback,
+                 weak_factory_.GetWeakPtr(),
+                 callback));
+}
+
 void RenderViewHostImpl::ClearFocusedNode() {
   Send(new ViewMsg_ClearFocusedNode(GetRoutingID()));
 }
 
 void RenderViewHostImpl::Zoom(PageZoom zoom) {
   Send(new ViewMsg_Zoom(GetRoutingID(), zoom));
 }
 
 void RenderViewHostImpl::ReloadFrame() {
   Send(new ViewMsg_ReloadFrame(GetRoutingID()));
@@ skipping 170 matching lines @@
                         params.allow_multiple_selection);
   }
 }
 #endif
 
 void RenderViewHostImpl::SetState(RenderViewHostImplState rvh_state) {
   // We update the number of RenderViews in a SiteInstance when the
   // swapped out status of this RenderView gets flipped to/from live.
   if (!IsRVHStateActive(rvh_state_) && IsRVHStateActive(rvh_state))
     instance_->increment_active_view_count();
-  else if (IsRVHStateActive(rvh_state_) && !IsRVHStateActive(rvh_state))
+  else if (IsRVHStateActive(rvh_state_) && !IsRVHStateActive(rvh_state) &&
+           copy_requests_ == 0)

[clamy, 2014/02/26 16:50:56]

If the site instance is not decremented when the new page commits (ie when
WasSwappedOut is called), then the RVH will not go into state PENDING_SHUTDOWN.
Its associated RFH will be stored in the map of swapped out hosts in the
RenderFrameHostManager. When the swap out ack is received, the state will just
be set to SWAPPED_OUT, and the RFH and RVH will not be deleted as they should
be.

     instance_->decrement_active_view_count();
 
   // Whenever we change the RVH state to and from live or swapped out state, we
   // should not be waiting for beforeunload or unload acks.  We clear them here
   // to be safe, since they can cause navigations to be ignored in OnNavigate.
   if (rvh_state == STATE_DEFAULT ||
       rvh_state == STATE_SWAPPED_OUT ||
       rvh_state_ == STATE_DEFAULT ||
       rvh_state_ == STATE_SWAPPED_OUT) {
     is_waiting_for_beforeunload_ack_ = false;
@@ skipping 16 matching lines @@
   return true;
 }
 
 void RenderViewHostImpl::AttachToFrameTree() {
   FrameTree* frame_tree = delegate_->GetFrameTree();
 
   frame_tree->ResetForMainFrameSwap();
 }
 
 }  // namespace content