[wip] Introduce SiteInstanceKeepAlive.

content/browser/frame_host/navigation_entry_screenshot_manager.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/browser/frame_host/navigation_entry_screenshot_manager.h"
 
 #include "base/command_line.h"
 #include "base/threading/worker_pool.h"
 #include "content/browser/frame_host/navigation_controller_impl.h"
 #include "content/browser/frame_host/navigation_entry_impl.h"
+#include "content/browser/frame_host/render_frame_host_manager.h"
 #include "content/browser/renderer_host/render_view_host_impl.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
+#include "content/public/browser/site_instance.h"
 #include "content/public/common/content_switches.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/effects/SkLumaColorFilter.h"
 #include "ui/gfx/codec/png_codec.h"
 
 namespace {
 
 // Minimum delay between taking screenshots.
 const int kMinScreenshotIntervalMS = 1000;
@@ skipping 44 matching lines @@
     // Encode the a8Bitmap to grayscale PNG treating alpha as color intensity
     if (gfx::PNGCodec::EncodeA8SkBitmap(a8Bitmap, &data))
       data_ = new base::RefCountedBytes(data);
   }
 
   scoped_refptr<base::RefCountedBytes> data_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenshotData);
 };
 
+// A temporary solution to keep a RenderViewHost and SiteInstanceImpl live
+// (after cross-process/cross-site navigation) for long enough to get the
+// screenshot.
+// TODO(sad): This can be removed when RenderFrameProxy replaces swappedout://
+class SiteInstanceKeepAlive {
+ public:
+  explicit SiteInstanceKeepAlive(scoped_refptr<SiteInstanceImpl> site_instance)
+      : site_instance_(site_instance) {
+    site_instance_->increment_active_view_count();
+    site_instance_->GetProcess()->AddPendingView();
+  }
+
+  ~SiteInstanceKeepAlive() {
+    site_instance_->GetProcess()->RemovePendingView();
+    site_instance_->decrement_active_view_count();
+    if (!site_instance_->active_view_count()) {
+      RenderFrameHostManager::ShutdownRenderFrameHostsInSiteInstance(
+        site_instance_->GetId());
+    }
+  }
+
+ private:
+  scoped_refptr<SiteInstanceImpl> site_instance_;
+
+  DISALLOW_COPY_AND_ASSIGN(SiteInstanceKeepAlive);
+};
+
 NavigationEntryScreenshotManager::NavigationEntryScreenshotManager(
     NavigationControllerImpl* owner)
     : owner_(owner),
       screenshot_factory_(this),
       min_screenshot_interval_ms_(kMinScreenshotIntervalMS) {
 }
 
 NavigationEntryScreenshotManager::~NavigationEntryScreenshotManager() {
 }
 
@@ skipping 39 matching lines @@
         owner_->GetEntryAtIndex(i)));
   }
   DCHECK_EQ(GetScreenshotCount(), 0);
 }
 
 void NavigationEntryScreenshotManager::TakeScreenshotImpl(
     RenderViewHost* host,
     NavigationEntryImpl* entry) {
   DCHECK(host && host->GetView());
   DCHECK(entry);
+  scoped_refptr<SiteInstanceImpl> site_instance(
+      static_cast<SiteInstanceImpl*>(host->GetSiteInstance()));
+  SiteInstanceKeepAlive* keep_alive = new SiteInstanceKeepAlive(site_instance);
+  keep_alives_.push_back(keep_alive);
+  if (!web_contents())
+    Observe(owner_->GetWebContents());
   host->CopyFromBackingStore(gfx::Rect(),
       host->GetView()->GetViewBounds().size(),
       base::Bind(&NavigationEntryScreenshotManager::OnScreenshotTaken,
                  screenshot_factory_.GetWeakPtr(),
-                 entry->GetUniqueID()));
+                 entry->GetUniqueID(),
+                 keep_alive));
 }
 
 void NavigationEntryScreenshotManager::SetMinScreenshotIntervalMS(
     int interval_ms) {
   DCHECK_GE(interval_ms, 0);
   min_screenshot_interval_ms_ = interval_ms;
 }
 
-void NavigationEntryScreenshotManager::OnScreenshotTaken(int unique_id,
-                                                     bool success,
-                                                     const SkBitmap& bitmap) {
+void NavigationEntryScreenshotManager::OnScreenshotTaken(
+    int unique_id,
+    SiteInstanceKeepAlive* keep_alive,
+    bool success,
+    const SkBitmap& bitmap) {
+  if (keep_alive) {
+    // |keep_alive| can be NULL in tests.
+    keep_alives_.erase(std::find(keep_alives_.begin(), keep_alives_.end(),
+                                 keep_alive));
+    keep_alive = NULL;
+    if (keep_alives_.empty())
+      Observe(NULL);
+  }
+
   NavigationEntryImpl* entry = NULL;
   int entry_count = owner_->GetEntryCount();
   for (int i = 0; i < entry_count; ++i) {
     NavigationEntry* iter = owner_->GetEntryAtIndex(i);
     if (iter->GetUniqueID() == unique_id) {
       entry = NavigationEntryImpl::FromNavigationEntry(iter);
       break;
     }
   }
 
   if (!entry) {
     LOG(ERROR) << "Invalid entry with unique id: " << unique_id;
     return;
   }
 
   if (!success || bitmap.empty() || bitmap.isNull()) {
-    if (!ClearScreenshot(entry))
-      OnScreenshotSet(entry);
+    ClearScreenshot(entry);
     return;
   }
 
   scoped_refptr<ScreenshotData> screenshot = new ScreenshotData();
   screenshot->EncodeScreenshot(
       bitmap,
       base::Bind(&NavigationEntryScreenshotManager::OnScreenshotEncodeComplete,
                  screenshot_factory_.GetWeakPtr(),
                  unique_id,
                  screenshot));
@@ skipping 24 matching lines @@
     }
   }
   if (!entry)
     return;
   entry->SetScreenshotPNGData(screenshot->data());
   OnScreenshotSet(entry);
 }
 
 void NavigationEntryScreenshotManager::OnScreenshotSet(
     NavigationEntryImpl* entry) {
-  if (entry->screenshot().get())
-    PurgeScreenshotsIfNecessary();
+  CHECK(entry->screenshot().get());
+  PurgeScreenshotsIfNecessary();
 }
 
 bool NavigationEntryScreenshotManager::ClearScreenshot(
     NavigationEntryImpl* entry) {
   if (!entry->screenshot().get())
     return false;
 
   entry->SetScreenshotPNGData(NULL);
   return true;
 }
@@ skipping 56 matching lines @@
     NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
         owner_->GetEntryAtIndex(forward));
     if (ClearScreenshot(entry))
       --screenshot_count;
     ++forward;
   }
   CHECK_GE(screenshot_count, 0);
   CHECK_LE(screenshot_count, kMaxScreenshots);
 }
 
+void NavigationEntryScreenshotManager::WebContentsDestroyed(
+    WebContents* contents) {
+  // The WebContents is going to be destroyed. So discard all pending screenshot
+  // requests and destroy all the SiteInstanceKeepAlives.
+  screenshot_factory_.InvalidateWeakPtrs();
+  keep_alives_.clear();
+}
+
 }  // namespace content