[wip] Introduce SiteInstanceKeepAlive.

content/browser/web_contents/web_contents_view_aura_browsertest.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_view_aura.h"
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/test/test_timeouts.h"
@@ skipping 14 matching lines @@
 #include "content/shell/browser/shell.h"
 #include "content/test/content_browser_test.h"
 #include "content/test/content_browser_test_utils.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/scoped_animation_duration_scale_mode.h"
 
 namespace content {
 
+// Keeps track of whether a RenderProcessHost is alive or not.
+class RenderProcessHostTracker : public RenderProcessHostObserver {
+ public:
+  explicit RenderProcessHostTracker(RenderProcessHost* host)
+      : host_(host) {
+    host_->AddObserver(this);
+  }
+
+  virtual ~RenderProcessHostTracker() {
+    if (host_)
+      host_->RemoveObserver(this);
+  }
+
+  bool alive() const { return host_; }
+
+ private:
+  // RenderProcessHostObserver:
+  virtual void RenderProcessHostDestroyed(RenderProcessHost* host) OVERRIDE {
+    CHECK_EQ(host_, host);
+    host_ = NULL;
+  }
+
+  RenderProcessHost* host_;
+
+  DISALLOW_COPY_AND_ASSIGN(RenderProcessHostTracker);
+};
+
 // This class keeps track of the RenderViewHost whose screenshot was captured.
 class ScreenshotTracker : public NavigationEntryScreenshotManager {
  public:
   explicit ScreenshotTracker(NavigationControllerImpl* controller)
       : NavigationEntryScreenshotManager(controller),
         screenshot_taken_for_(NULL),
         waiting_for_screenshots_(0) {
   }
 
   virtual ~ScreenshotTracker() {
@@ skipping 21 matching lines @@
     return screenshot_set_.count(entry) > 0;
   }
 
  private:
   // Overridden from NavigationEntryScreenshotManager:
   virtual void TakeScreenshotImpl(RenderViewHost* host,
                                   NavigationEntryImpl* entry) OVERRIDE {
     ++waiting_for_screenshots_;
     screenshot_taken_for_ = host;
     NavigationEntryScreenshotManager::TakeScreenshotImpl(host, entry);
+
+    // The screenshot-manager should start observing the lifetime of the
+    // WebContents, to make sure that it can cancel the screenshot requests if
+    // the WebContents is destroyed before the screenshot-capture completes.
+    EXPECT_TRUE(web_contents());
   }
 
   virtual void OnScreenshotSet(NavigationEntryImpl* entry) OVERRIDE {
     --waiting_for_screenshots_;
     screenshot_set_[entry] = true;
     NavigationEntryScreenshotManager::OnScreenshotSet(entry);
+    if (waiting_for_screenshots_ == 0) {
+      // If the screenshot manager is not waiting for any pending screenshot
+      // capture requests, then it shouldn't be observing the WebContents.
+      EXPECT_FALSE(web_contents());
+    }
     if (waiting_for_screenshots_ == 0 && message_loop_runner_.get())
       message_loop_runner_->Quit();
   }
 
   RenderViewHost* screenshot_taken_for_;
   scoped_refptr<content::MessageLoopRunner> message_loop_runner_;
   int waiting_for_screenshots_;
   std::map<NavigationEntryImpl*, bool> screenshot_set_;
 
   DISALLOW_COPY_AND_ASSIGN(ScreenshotTracker);
@@ skipping 419 matching lines @@
     { GURL(), 0 }
   };
 
   screenshot_manager()->Reset();
   for (int i = 0; !navigations[i].url.is_empty(); ++i) {
     // Navigate via the user initiating a navigation from the UI.
     NavigationController::LoadURLParams params(navigations[i].url);
     params.transition_type = PageTransitionFromInt(navigations[i].transition);
 
     RenderViewHost* old_host = web_contents->GetRenderViewHost();
+    scoped_ptr<RenderProcessHostTracker> process_tracker(
+        new RenderProcessHostTracker(old_host->GetProcess()));
+    EXPECT_TRUE(process_tracker->alive());
+
     web_contents->GetController().LoadURLWithParams(params);
     WaitForLoadStop(web_contents);
     screenshot_manager()->WaitUntilScreenshotIsReady();
+    // The RenderProcessHost should be destroyed, since this is a cross-process
+    // navigation.
+    EXPECT_FALSE(process_tracker->alive());
 
     EXPECT_NE(old_host, web_contents->GetRenderViewHost())
         << navigations[i].url.spec();
     EXPECT_EQ(old_host, screenshot_manager()->screenshot_taken_for());
 
     NavigationEntryImpl* entry = NavigationEntryImpl::FromNavigationEntry(
         web_contents->GetController().GetEntryAtOffset(-1));
     EXPECT_TRUE(screenshot_manager()->ScreenshotSetForEntry(entry));
 
     entry = NavigationEntryImpl::FromNavigationEntry(
@@ skipping 124 matching lines @@
       10);
   base::string16 actual_title = title_watcher.WaitAndGetTitle();
   EXPECT_EQ(expected_title, actual_title);
 
   EXPECT_EQ(2, GetCurrentIndex());
   EXPECT_TRUE(controller.CanGoBack());
   EXPECT_FALSE(controller.CanGoForward());
 }
 
 }  // namespace content