Make automation proxy objects to ref_counted. That allows to process async no...

chrome/browser/ssl/ssl_uitest.cc

 // Copyright (c) 2006-2008 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 <Windows.h>
 #include <Wincrypt.h>
 
 #include <string>
 
 #include "chrome/common/filter_policy.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/automation/browser_proxy.h"
 #include "chrome/test/automation/tab_proxy.h"
 #include "chrome/test/ui/ui_test.h"
 #include "net/base/ssl_test_util.h"
 #include "net/url_request/url_request_unittest.h"
 
 namespace {
 
 const wchar_t kDocRoot[] = L"chrome/test/data";
 
 class SSLUITest : public UITest {
  protected:
   SSLUITest() {
     dom_automation_enabled_ = true;
   }
 
-  TabProxy* GetActiveTabProxy() {
-    scoped_ptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
+  scoped_refptr<TabProxy> GetActiveTabProxy() {
+    scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
     EXPECT_TRUE(browser_proxy.get());
     return browser_proxy->GetActiveTab();
   }
 
   void NavigateTab(TabProxy* tab_proxy, const GURL& url) {
     ASSERT_TRUE(tab_proxy->NavigateToURL(url));
   }
 
   void AppendTab(const GURL& url) {
-    scoped_ptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
+    scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
     EXPECT_TRUE(browser_proxy.get());
     EXPECT_TRUE(browser_proxy->AppendTab(url));
   }
 
   // Before using returned value you should check that the assertion below
   // didn't fail. To do so, use HasFailure().
   scoped_refptr<HTTPTestServer> PlainServer() {
     scoped_refptr<HTTPTestServer> server(
         HTTPTestServer::CreateServer(kDocRoot, NULL));
     EXPECT_TRUE(server.get());
@@ skipping 23 matching lines @@
 };
 
 }  // namespace
 
 // Visits a regular page over http.
 TEST_F(SSLUITest, TestHTTP) {
   scoped_refptr<HTTPTestServer> server = PlainServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(), server->TestServerPageW(L"files/ssl/google.html"));
 
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_UNAUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // Visits a page over http which includes broken https resources (status should
 // be OK).
 TEST_F(SSLUITest, TestHTTPWithBrokenHTTPSResource) {
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
 
   NavigateTab(
       tab.get(),
       http_server->TestServerPageW(
           L"files/ssl/page_with_unsafe_contents.html"));
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_UNAUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // Visits a page over OK https:
 TEST_F(SSLUITest, TestOKHTTPS) {
   scoped_refptr<HTTPSTestServer> https_server = GoodCertServer();
   if (HasFailure())
     return;
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(),
               https_server->TestServerPageW(L"files/ssl/google.html"));
 
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // Visits a page with https error and proceed:
 TEST_F(SSLUITest, TestHTTPSExpiredCertAndProceed) {
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(),
               bad_https_server->TestServerPageW(L"files/ssl/google.html"));
 
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::INTERSTITIAL_PAGE, page_type);
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
@@ skipping 16 matching lines @@
 }
 
 // Visits a page with https error and don't proceed (and ensure we can still
 // navigate at that point):
 TEST_F(SSLUITest, TestHTTPSExpiredCertAndDontProceed) {
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   scoped_refptr<HTTPSTestServer> good_https_server = GoodCertServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
 
   // First navigate to an OK page.
   NavigateTab(tab.get(),
               good_https_server->TestServerPageW(L"files/ssl/google.html"));
 
   GURL cross_site_url =
       bad_https_server->TestServerPageW(L"files/ssl/google.html");
   // Change the host name from 127.0.0.1 to localhost so it triggers a
   // cross-site navigation so we can test http://crbug.com/5800 is gone.
   ASSERT_EQ("127.0.0.1", cross_site_url.host());
@@ skipping 44 matching lines @@
 
 // Visits a page with mixed content.
 TEST_F(SSLUITest, TestMixedContents) {
   scoped_refptr<HTTPSTestServer> https_server = GoodCertServer();
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   if (HasFailure())
     return;
 
   // Load a page with mixed-content, the default behavior is to show the mixed
   // content.
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(
       tab.get(),
       https_server->TestServerPageW(
           L"files/ssl/page_with_mixed_contents.html"));
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATED, security_style);
   EXPECT_EQ(0,
             cert_status & net::CERT_STATUS_ALL_ERRORS);  // No errors expected.
   EXPECT_EQ(NavigationEntry::SSLStatus::MIXED_CONTENT, mixed_content_state);
 }
 
 // Visits a page with mixed content.
 TEST_F(SSLUITest, TestMixedContentsFilterAll) {
   scoped_refptr<HTTPSTestServer> https_server = GoodCertServer();
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   if (HasFailure())
     return;
 
   // Now select the block mixed-content pref and reload the page.
-  scoped_ptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
+  scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   EXPECT_TRUE(browser_proxy.get());
   EXPECT_TRUE(browser_proxy->SetIntPreference(prefs::kMixedContentFiltering,
                                               FilterPolicy::FILTER_ALL));
 
   // Load a page with mixed-content, we've overridden our filtering policy so
   // we won't load the mixed content by default.
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(
       tab.get(),
       https_server->TestServerPageW(
           L"files/ssl/page_with_mixed_contents.html"));
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   // The image should be filtered.
   int img_width;
@@ skipping 39 matching lines @@
 
 // Visits a page with an http script that tries to suppress our mixed content
 // warnings by randomize location.hash.
 // Based on http://crbug.com/8706
 TEST_F(SSLUITest, TestMixedContentsRandomizeHash) {
   scoped_refptr<HTTPSTestServer> https_server = GoodCertServer();
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(
       tab.get(),
       https_server->TestServerPageW(
           L"files/ssl/page_with_http_script.html"));
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::MIXED_CONTENT, mixed_content_state);
 }
 
 // Visits a page with unsafe content and make sure that:
 // - frames content is replaced with warning
 // - images and scripts are filtered out entirely
 TEST_F(SSLUITest, TestUnsafeContents) {
   scoped_refptr<HTTPSTestServer> good_https_server = GoodCertServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(),
       good_https_server->TestServerPageW(
           L"files/ssl/page_with_unsafe_contents.html"));
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
@@ skipping 31 matching lines @@
   EXPECT_FALSE(js_result);
 }
 
 // Visits a page with mixed content loaded by JS (after the initial page load).
 TEST_F(SSLUITest, TestMixedContentsLoadedFromJS) {
   scoped_refptr<HTTPSTestServer> https_server = GoodCertServer();
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(), https_server->TestServerPageW(
       L"files/ssl/page_with_dynamic_mixed_contents.html"));
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
@@ skipping 21 matching lines @@
 // Visits two pages from the same origin: one with mixed content and one
 // without.  The test checks that we don't propagate the mixed content state
 // from one process to another process.  This test is expected to fail in
 // single process mode.
 TEST_F(SSLUITest, TestMixedContentsTwoTabs) {
   scoped_refptr<HTTPSTestServer> https_server = GoodCertServer();
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab1(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab1(GetActiveTabProxy());
   NavigateTab(
       tab1.get(),
       https_server->TestServerPageW(
           L"files/ssl/blank_page.html"));
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab1->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   // This tab should be fine.
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab1->GetSecurityState(&security_style, &cert_status,
                                      &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 
-  scoped_ptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
+  scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   EXPECT_TRUE(browser_proxy.get());
   EXPECT_TRUE(browser_proxy->AppendTab(
       https_server->TestServerPageW(L"files/ssl/page_with_http_script.html")));
 
-  scoped_ptr<TabProxy> tab2(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab2(GetActiveTabProxy());
   EXPECT_TRUE(tab2->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   // The new tab has mixed content.
   EXPECT_TRUE(tab2->GetSecurityState(&security_style, &cert_status,
                                      &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::MIXED_CONTENT, mixed_content_state);
 
   // The origin for the first tab has not been contaminated with
   // mixed content because its in a separate process.
   EXPECT_TRUE(tab1->GetSecurityState(&security_style, &cert_status,
                                      &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // Visits a page with an image over http.  Visits another page over https
 // referencing that same image over http (hoping it is coming from the webcore
 // memory cache).
 TEST_F(SSLUITest, TestCachedMixedContents) {
   scoped_refptr<HTTPSTestServer> https_server = GoodCertServer();
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(), http_server->TestServerPageW(
       L"files/ssl/page_with_mixed_contents.html"));
 
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
@@ skipping 22 matching lines @@
 // (see bug #1044942) and that it depends on the host-name.
 // TODO(jcampan): this test is flacky and fails sometimes (bug #1065095)
 TEST_F(SSLUITest, DISABLED_TestCNInvalidStickiness) {
   const std::string kLocalHost = "localhost";
   scoped_refptr<HTTPSTestServer> https_server =
       HTTPSTestServer::CreateMismatchedServer(kDocRoot);
   ASSERT_TRUE(NULL != https_server.get());
 
   // First we hit the server with hostname, this generates an invalid policy
   // error.
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(), https_server->TestServerPageW(
       L"files/ssl/google.html"));
 
   // We get an interstitial page as a result.
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(NavigationEntry::INTERSTITIAL_PAGE, page_type);
 
   SecurityStyle security_style;
   int cert_status;
@@ skipping 44 matching lines @@
   EXPECT_EQ(net::CERT_STATUS_COMMON_NAME_INVALID,
             cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // Test that navigating to a #ref does not change a bad security state.
 TEST_F(SSLUITest, TestRefNavigation) {
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(
       tab.get(),
       bad_https_server->TestServerPageW(L"files/ssl/page_with_refs.html"));
 
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(page_type, NavigationEntry::INTERSTITIAL_PAGE);
 
   SecurityStyle security_style;
   int cert_status;
@@ skipping 27 matching lines @@
 
 // Tests that closing a page that has a unsafe pop-up does not crash the browser
 // (bug #1966).
 // Disabled because flaky (bug #2136).
 TEST_F(SSLUITest, DISABLED_TestCloseTabWithUnsafePopup) {
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(),
               http_server->TestServerPageW(
                   L"files/ssl/page_with_unsafe_popup.html"));
 
   int popup_count = 0;
   EXPECT_TRUE(tab->GetConstrainedWindowCount(&popup_count));
   EXPECT_EQ(1, popup_count);
 
   // Let's add another tab to make sure the browser does not exit when we close
   // the first tab.
-  scoped_ptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
+  scoped_refptr<BrowserProxy> browser_proxy(automation()->GetBrowserWindow(0));
   EXPECT_TRUE(browser_proxy.get());
   browser_proxy->AppendTab(
       http_server->TestServerPageW(L"files/ssl/google.html"));
 
   // Close the first tab.
   tab->Close();
 }
 
 // Visit a page over bad https that is a redirect to a page with good https.
 TEST_F(SSLUITest, TestRedirectBadToGoodHTTPS) {
   scoped_refptr<HTTPSTestServer> good_https_server = GoodCertServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   GURL url1 = bad_https_server->TestServerPageW(L"server-redirect?");
   GURL url2 = good_https_server->TestServerPageW(L"files/ssl/google.html");
   NavigateTab(tab.get(), GURL(url1.spec() + url2.spec()));
 
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(page_type, NavigationEntry::INTERSTITIAL_PAGE);
 
   SecurityStyle security_style;
   int cert_status;
@@ skipping 14 matching lines @@
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // Visit a page over good https that is a redirect to a page with bad https.
 TEST_F(SSLUITest, TestRedirectGoodToBadHTTPS) {
   scoped_refptr<HTTPSTestServer> good_https_server = GoodCertServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   GURL url1 = good_https_server->TestServerPageW(L"server-redirect?");
   GURL url2 = bad_https_server->TestServerPageW(L"files/ssl/google.html");
   NavigateTab(tab.get(), GURL(url1.spec() + url2.spec()));
 
   NavigationEntry::PageType page_type;
   EXPECT_TRUE(tab->GetPageType(&page_type));
   EXPECT_EQ(page_type, NavigationEntry::INTERSTITIAL_PAGE);
 
   EXPECT_TRUE(tab->TakeActionOnSSLBlockingPage(true));
 
@@ skipping 11 matching lines @@
 // Visit a page over http that is a redirect to a page with https (good and
 // bad).
 TEST_F(SSLUITest, TestRedirectHTTPToHTTPS) {
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   scoped_refptr<HTTPSTestServer> good_https_server = GoodCertServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
 
   // HTTP redirects to good HTTPS.
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   GURL http_url = http_server->TestServerPageW(L"server-redirect?");
   GURL good_https_url =
       good_https_server->TestServerPageW(L"files/ssl/google.html");
   NavigateTab(tab.get(), GURL(http_url.spec() + good_https_url.spec()));
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
@@ skipping 22 matching lines @@
 }
 
 // Visit a page over https that is a redirect to a page with http (to make sure
 // we don't keep the secure state).
 TEST_F(SSLUITest, TestRedirectHTTPSToHTTP) {
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   scoped_refptr<HTTPSTestServer> https_server = GoodCertServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   GURL https_url = https_server->TestServerPageW(L"server-redirect?");
   GURL http_url = http_server->TestServerPageW(L"files/ssl/google.html");
   NavigateTab(tab.get(), GURL(https_url.spec() + http_url.spec()));
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_UNAUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // Visits a page to which we could not connect (bad port) over http and https
 // and make sure the security style is correct.
 TEST_F(SSLUITest, TestConnectToBadPort) {
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
 
   GURL http_url("http://localhost:17");
   NavigateTab(tab.get(), http_url);
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_UNAUTHENTICATED, security_style);
@@ skipping 20 matching lines @@
 // - navigate to a bad HTTPS (expect unsafe content and filtered frame), then
 //   back
 // - navigate to HTTP (expect mixed content), then back
 TEST_F(SSLUITest, TestGoodFrameNavigation) {
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   scoped_refptr<HTTPSTestServer> good_https_server = GoodCertServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(),
               good_https_server->TestServerPageW(L"files/ssl/top_frame.html"));
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status & net::CERT_STATUS_ALL_ERRORS);
@@ skipping 76 matching lines @@
 }
 
 // From a bad HTTPS top frame:
 // - navigate to an OK HTTPS frame (expected to be still authentication broken).
 TEST_F(SSLUITest, TestBadFrameNavigation) {
   scoped_refptr<HTTPSTestServer> good_https_server = GoodCertServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(),
               bad_https_server->TestServerPageW(L"files/ssl/top_frame.html"));
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATION_BROKEN, security_style);
   EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
@@ skipping 24 matching lines @@
 
 // From an HTTP top frame, navigate to good and bad HTTPS (security state should
 // stay unauthenticated).
 TEST_F(SSLUITest, TestUnauthenticatedFrameNavigation) {
   scoped_refptr<HTTPTestServer> http_server = PlainServer();
   scoped_refptr<HTTPSTestServer> good_https_server = GoodCertServer();
   scoped_refptr<HTTPSTestServer> bad_https_server = BadCertServer();
   if (HasFailure())
     return;
 
-  scoped_ptr<TabProxy> tab(GetActiveTabProxy());
+  scoped_refptr<TabProxy> tab(GetActiveTabProxy());
   NavigateTab(tab.get(),
               http_server->TestServerPageW(L"files/ssl/top_frame.html"));
 
   SecurityStyle security_style;
   int cert_status;
   int mixed_content_state;
   EXPECT_TRUE(tab->GetSecurityState(&security_style, &cert_status,
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_UNAUTHENTICATED, security_style);
   EXPECT_EQ(0, cert_status & net::CERT_STATUS_ALL_ERRORS);
@@ skipping 48 matching lines @@
 
 // Visit a page over https that contains a frame with a redirect.
 
 // XMLHttpRequest mixed in synchronous mode.
 
 // XMLHttpRequest mixed in asynchronous mode.
 
 // XMLHttpRequest over bad ssl in synchronous mode.
 
 // XMLHttpRequest over OK ssl in synchronous mode.