[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 194 matching lines @@
       enabled_bindings_(0),
       navigations_suspended_(false),
       has_accessed_initial_document_(false),
       main_frame_routing_id_(main_frame_routing_id),
       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 476 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) {
     SetState(STATE_PENDING_SWAP_OUT);
-    if (!instance_->active_view_count())
+    if (!instance_->active_view_count() ||
+        (instance_->active_view_count() - copy_requests_) == 0) {
       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
     // cause WasSwappedOut to be called directly on the live old RVH.
     DCHECK(!IsRenderViewLive());
     SetState(STATE_SWAPPED_OUT);
   } else {
     NOTREACHED();
@@ skipping 1052 matching lines @@
     const GetAudioOutputControllersCallback& callback) const {
   AudioRendererHost* audio_host =
       static_cast<RenderProcessHostImpl*>(GetProcess())->audio_renderer_host();
   audio_host->GetOutputControllers(GetRoutingID(), callback);
 }
 
 void RenderViewHostImpl::ClearFocusedElement() {
   Send(new ViewMsg_ClearFocusedElement(GetRoutingID()));
 }
 
+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());
+      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
+                              pending_shutdown_on_swap_out_);
+    }
+  }
+}
+
+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::Zoom(PageZoom zoom) {
   Send(new ViewMsg_Zoom(GetRoutingID(), zoom));
 }
 
 void RenderViewHostImpl::ReloadFrame() {
   Send(new ViewMsg_ReloadFrame(GetRoutingID()));
 }
 
 void RenderViewHostImpl::InsertCSS(const base::string16& frame_xpath,
                                    const std::string& css) {
@@ skipping 166 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)
     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