Clear DNS cache and passive log collected on incognito close.

chrome/browser/ui/webui/net_internals_ui_browsertest.cc

 // Copyright (c) 2011 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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
@@ skipping 55 matching lines @@
     ASSERT_TRUE(ip_literal.empty());
   }
 
   // Add entry to the cache.
   cache->Set(net::HostCache::Key(hostname, net::ADDRESS_FAMILY_UNSPECIFIED, 0),
              net_error,
              address_list,
              expires);
 }
 
-// Class to handle messages from the renderer needed by certain tests.
-class NetInternalsTestMessageHandler : public WebUIMessageHandler {
- public:
-  NetInternalsTestMessageHandler();
-
-  void set_browser(Browser* browser) {
-    ASSERT_TRUE(browser);
-    browser_ = browser;
-  }
-
- private:
-  virtual void RegisterMessages() OVERRIDE;
-
-  // Opens the given URL in a new background tab.
-  void OpenNewTab(const ListValue* list_value);
-
-  // Adds a new entry to the host cache.  Takes in hostname, ip address,
-  // net error code, and expiration time (as number of days from now).
-  void AddCacheEntry(const ListValue* list_value);
-
-  // Navigates to the prerender in the background tab. This assumes that
-  // there is a "Click()" function in the background tab which will navigate
-  // there, and that the background tab exists at slot 1.
-  void NavigateToPrerender(const ListValue* list_value);
-
-  Browser* browser_;
-
-  DISALLOW_COPY_AND_ASSIGN(NetInternalsTestMessageHandler);
-};
-
-NetInternalsTestMessageHandler::NetInternalsTestMessageHandler()
-    : browser_(NULL) {
-}
-
-void NetInternalsTestMessageHandler::RegisterMessages() {
-  web_ui_->RegisterMessageCallback(
-      "openNewTab",
-      base::Bind(&NetInternalsTestMessageHandler::OpenNewTab,
-                 base::Unretained(this)));
-  web_ui_->RegisterMessageCallback(
-      "addCacheEntry",
-      base::Bind(&NetInternalsTestMessageHandler::AddCacheEntry,
-                 base::Unretained(this)));
-  web_ui_->RegisterMessageCallback("navigateToPrerender",
-       base::Bind(&NetInternalsTestMessageHandler::NavigateToPrerender,
-                  base::Unretained(this)));
-}
-
-void NetInternalsTestMessageHandler::OpenNewTab(const ListValue* list_value) {
-  std::string url;
-  ASSERT_TRUE(list_value->GetString(0, &url));
-  ASSERT_TRUE(browser_);
-  ui_test_utils::NavigateToURLWithDisposition(
-      browser_,
-      GURL(url),
-      NEW_BACKGROUND_TAB,
-      ui_test_utils::BROWSER_TEST_NONE);
-}
-
-// Called on UI thread.  Adds an entry to the cache for the specified hostname
-// by posting a task to the IO thread.  Takes the host name, ip address, net
-// error code, and expiration time in days from now as parameters.  If the error
-// code indicates failure, the ip address must be an empty string.
-void NetInternalsTestMessageHandler::AddCacheEntry(
-    const ListValue* list_value) {
-  std::string hostname;
-  std::string ip_literal;
-  double net_error;
-  double expire_days_from_now;
-  ASSERT_TRUE(list_value->GetString(0, &hostname));
-  ASSERT_TRUE(list_value->GetString(1, &ip_literal));
-  ASSERT_TRUE(list_value->GetDouble(2, &net_error));
-  ASSERT_TRUE(list_value->GetDouble(3, &expire_days_from_now));
-  ASSERT_TRUE(browser_);
-
-  BrowserThread::PostTask(
-      BrowserThread::IO, FROM_HERE,
-      base::Bind(&AddCacheEntryOnIOThread,
-                 make_scoped_refptr(browser_->profile()->GetRequestContext()),
-                 hostname,
-                 ip_literal,
-                 static_cast<int>(net_error),
-                 static_cast<int>(expire_days_from_now)));
-}
-
-void NetInternalsTestMessageHandler::NavigateToPrerender(
-    const ListValue* list_value) {
-  RenderViewHost* host = browser_->GetTabContentsAt(1)->render_view_host();
-  host->ExecuteJavascriptInWebFrame(string16(), ASCIIToUTF16("Click()"));
-}
-
 class NetInternalsTest : public WebUIBrowserTest {
  public:
   NetInternalsTest();
   virtual ~NetInternalsTest();
 
   // InProcessBrowserTest overrides.
   virtual void SetUpCommandLine(CommandLine* command_line) OVERRIDE;
   virtual void SetUpInProcessBrowserTestFixture() OVERRIDE;
   virtual void SetUpOnMainThread() OVERRIDE;
 
  protected:
   GURL CreatePrerenderLoaderUrl(const GURL& prerender_url) {
     std::vector<net::TestServer::StringPair> replacement_text;
     replacement_text.push_back(
         make_pair("REPLACE_WITH_PRERENDER_URL", prerender_url.spec()));
     std::string replacement_path;
     EXPECT_TRUE(net::TestServer::GetFilePathWithReplacements(
         "files/prerender/prerender_loader.html",
         replacement_text,
         &replacement_path));
     GURL url_loader = test_server()->GetURL(replacement_path);
     return url_loader;
   }
 
  private:
+  // Class to handle messages from the renderer needed by certain tests.
+  class MessageHandler : public WebUIMessageHandler {
+   public:
+    explicit MessageHandler(NetInternalsTest* net_internals_test);
+
+   private:
+    virtual void RegisterMessages() OVERRIDE;
+
+    // Opens the given URL in a new background tab.
+    void OpenNewTab(const ListValue* list_value);
+
+    // Called on UI thread.  Adds an entry to the cache for the specified
+    // hostname by posting a task to the IO thread.  Takes the host name,
+    // ip address, net error code, and expiration time in days from now
+    // as parameters.  If the error code indicates failure, the ip address
+    // must be an empty string.
+    void AddCacheEntry(const ListValue* list_value);
+
+    // Navigates to the prerender in the background tab. This assumes that
+    // there is a "Click()" function in the background tab which will navigate
+    // there, and that the background tab exists at slot 1.
+    void NavigateToPrerender(const ListValue* list_value);
+
+    // Creates an incognito browser.
+    void CreateIncognitoBrowser(const ListValue* list_value);
+
+    // Closes an incognito browser created with CreateIncognitoBrowser.
+    void CloseIncognitoBrowser(const ListValue* list_value);
+
+    Browser* browser() {
+      return net_internals_test_->browser();
+    }
+
+    NetInternalsTest* net_internals_test_;
+    Browser* incognito_browser_;
+
+    DISALLOW_COPY_AND_ASSIGN(MessageHandler);
+  };
+
   virtual WebUIMessageHandler* GetMockMessageHandler() OVERRIDE {
-    message_handler_.set_browser(browser());
     return &message_handler_;
   }
 
-  NetInternalsTestMessageHandler message_handler_;
+  MessageHandler message_handler_;
 
   DISALLOW_COPY_AND_ASSIGN(NetInternalsTest);
 };
 
-NetInternalsTest::NetInternalsTest() {
+NetInternalsTest::NetInternalsTest()
+    : ALLOW_THIS_IN_INITIALIZER_LIST(message_handler_(this)) {
 }
 
 NetInternalsTest::~NetInternalsTest() {
 }
 
 void NetInternalsTest::SetUpCommandLine(CommandLine* command_line) {
   WebUIBrowserTest::SetUpCommandLine(command_line);
   // Needed to test the prerender view.
   command_line->AppendSwitchASCII(switches::kPrerenderMode,
                                   switches::kPrerenderModeSwitchValueEnabled);
@@ skipping 24 matching lines @@
                                GURL(chrome::kChromeUINetInternalsURL));
   // Increase the memory allowed in a prerendered page above normal settings,
   // as debug builds use more memory and often go over the usual limit.
   Profile* profile = browser()->GetSelectedTabContentsWrapper()->profile();
   prerender::PrerenderManager* prerender_manager =
       prerender::PrerenderManagerFactory::GetForProfile(profile);
   prerender_manager->mutable_config().max_bytes = 1000 * 1024 * 1024;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
+// NetInternalsTest::MessageHandler
+////////////////////////////////////////////////////////////////////////////////
+
+NetInternalsTest::MessageHandler::MessageHandler(
+    NetInternalsTest* net_internals_test)
+    : net_internals_test_(net_internals_test),
+      incognito_browser_(NULL) {
+}
+
+void NetInternalsTest::MessageHandler::RegisterMessages() {
+  web_ui_->RegisterMessageCallback(
+      "openNewTab",
+      base::Bind(&NetInternalsTest::MessageHandler::OpenNewTab,
+                 base::Unretained(this)));
+  web_ui_->RegisterMessageCallback(
+      "addCacheEntry",
+      base::Bind(&NetInternalsTest::MessageHandler::AddCacheEntry,
+                 base::Unretained(this)));
+  web_ui_->RegisterMessageCallback("navigateToPrerender",
+       base::Bind(&NetInternalsTest::MessageHandler::NavigateToPrerender,
+                  base::Unretained(this)));
+  web_ui_->RegisterMessageCallback("createIncognitoBrowser",
+       base::Bind(&NetInternalsTest::MessageHandler::CreateIncognitoBrowser,
+                  base::Unretained(this)));
+  web_ui_->RegisterMessageCallback("closeIncognitoBrowser",
+       base::Bind(&NetInternalsTest::MessageHandler::CloseIncognitoBrowser,
+                  base::Unretained(this)));
+}
+
+void NetInternalsTest::MessageHandler::OpenNewTab(
+    const ListValue* list_value) {
+  std::string url;
+  ASSERT_TRUE(list_value->GetString(0, &url));
+  ui_test_utils::NavigateToURLWithDisposition(
+      browser(),
+      GURL(url),
+      NEW_BACKGROUND_TAB,
+      ui_test_utils::BROWSER_TEST_NONE);
+}
+
+void NetInternalsTest::MessageHandler::AddCacheEntry(
+    const ListValue* list_value) {
+  std::string hostname;
+  std::string ip_literal;
+  double net_error;
+  double expire_days_from_now;
+  ASSERT_TRUE(list_value->GetString(0, &hostname));
+  ASSERT_TRUE(list_value->GetString(1, &ip_literal));
+  ASSERT_TRUE(list_value->GetDouble(2, &net_error));
+  ASSERT_TRUE(list_value->GetDouble(3, &expire_days_from_now));
+  ASSERT_TRUE(browser());
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&AddCacheEntryOnIOThread,
+                 make_scoped_refptr(browser()->profile()->GetRequestContext()),
+                 hostname,
+                 ip_literal,
+                 static_cast<int>(net_error),
+                 static_cast<int>(expire_days_from_now)));
+}
+
+void NetInternalsTest::MessageHandler::NavigateToPrerender(
+    const ListValue* list_value) {
+  RenderViewHost* host = browser()->GetTabContentsAt(1)->render_view_host();
+  host->ExecuteJavascriptInWebFrame(string16(), ASCIIToUTF16("Click()"));
+}
+
+void NetInternalsTest::MessageHandler::CreateIncognitoBrowser(
+    const ListValue* list_value) {
+  ASSERT_FALSE(incognito_browser_);
+  incognito_browser_ = net_internals_test_->CreateIncognitoBrowser();
+}
+
+void NetInternalsTest::MessageHandler::CloseIncognitoBrowser(
+    const ListValue* list_value) {
+  ASSERT_TRUE(incognito_browser_);
+  incognito_browser_->CloseAllTabs();
+  incognito_browser_ = NULL;

[eroman, 2011/12/05 21:10:49]

What code is responsible for freeing the Browser* object? does CloseAllTabs() do
that?

[mmenke, 2011/12/05 22:28:00]

Browser objects are automatically destroyed once their last tab has been closed,
though the destruction will happen asynchronously.  Added a comment to that
effect.

+}
+
+////////////////////////////////////////////////////////////////////////////////
 // net_internals_ui.js
 ////////////////////////////////////////////////////////////////////////////////
 
 // Checks testDone.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsDone) {
   EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsDone"));
 }
 
 // Checks a failed expect statement.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsExpectFail) {
@@ skipping 104 matching lines @@
 // Adds an expired successful lookup to the DNS cache, then clears the cache.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsDnsViewExpired) {
   EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsDnsViewExpired"));
 }
 
 // Adds two entries to the DNS cache, clears the cache, and then repeats.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsDnsViewAddTwoTwice) {
   EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsDnsViewAddTwoTwice"));
 }
 
+// Makes sure that openning and then closing an incognito window clears the
+// DNS cache.  To keep things simple, we add a fake cache entry ourselves,
+// rather than having the incognito browser create one.
+IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsDnsViewIncognitoClears) {
+  EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsDnsViewIncognitoClears"));
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // test_view.js
 ////////////////////////////////////////////////////////////////////////////////
 
 // Runs the test suite twice, expecting a passing result the first time.  Checks
 // the first result, the order of events that occur, and the number of rows in
 // the table.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest, NetInternalsTestViewPassTwice) {
   ASSERT_TRUE(test_server()->Start());
   EXPECT_TRUE(RunJavascriptAsyncTest(
@@ skipping 111 matching lines @@
 // log_view_painter.js
 ////////////////////////////////////////////////////////////////////////////////
 
 // Check that we correctly remove cookies and login information.
 IN_PROC_BROWSER_TEST_F(NetInternalsTest,
                        NetInternalsLogViewPainterStripInfo) {
   EXPECT_TRUE(RunJavascriptAsyncTest("netInternalsLogViewPainterStripInfo"));
 }
 
 }  // namespace