Add FTP unit test in preparation for portable FTP implementation....

chrome/browser/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/pref_names.h"
@@ skipping 23 matching lines @@
   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));
     EXPECT_TRUE(browser_proxy.get());
     EXPECT_TRUE(browser_proxy->AppendTab(url));
   }
 
-  TestServer* PlainServer() {
-    return new TestServer(kDocRoot);
+  HTTPTestServer* PlainServer() {
+    return HTTPTestServer::CreateServer(kDocRoot);
   }
 
   HTTPSTestServer* GoodCertServer() {
-    return new HTTPSTestServer(util_.kHostName, util_.kOKHTTPSPort,
+    return HTTPSTestServer::CreateServer(util_.kHostName, util_.kOKHTTPSPort,
         kDocRoot, util_.GetOKCertPath().ToWStringHack());
   }
 
   HTTPSTestServer* BadCertServer() {
-    return new HTTPSTestServer(util_.kHostName, util_.kBadHTTPSPort,
+    return HTTPSTestServer::CreateServer(util_.kHostName, util_.kBadHTTPSPort,
         kDocRoot, util_.GetExpiredCertPath().ToWStringHack());
   }
 
  protected:
   SSLTestUtil util_;
 
   DISALLOW_COPY_AND_ASSIGN(SSLUITest);
 };
 
 }  // namespace
 
 // Visits a regular page over http.
 TEST_F(SSLUITest, TestHTTP) {
-  scoped_ptr<TestServer> server(PlainServer());
+  scoped_ptr<HTTPTestServer> server(PlainServer());
 
   scoped_ptr<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_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
   scoped_ptr<HTTPSTestServer> bad_https_server(BadCertServer());
   scoped_ptr<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,
@@ skipping 56 matching lines @@
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 //
 // Mixed contents
 //
 
 // Visits a page with mixed content.
 TEST_F(SSLUITest, TestMixedContents) {
   scoped_ptr<HTTPSTestServer> https_server(GoodCertServer());
-  scoped_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
 
   // Load a page with mixed-content, the default behavior is to show the mixed
   // content.
   scoped_ptr<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);
 
@@ skipping 101 matching lines @@
   bool js_result = false;
   EXPECT_TRUE(tab->ExecuteAndExtractBool(L"",
       L"window.domAutomationController.send(IsFooSet());",
       &js_result));
   EXPECT_FALSE(js_result);
 }
 
 // Visits a page with mixed content loaded by JS (after the initial page load).
 TEST_F(SSLUITest, TestMixedContentsLoadedFromJS) {
   scoped_ptr<HTTPSTestServer> https_server(GoodCertServer());
-  scoped_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
 
   scoped_ptr<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;
@@ skipping 18 matching lines @@
   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 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_ptr<HTTPSTestServer> https_server(GoodCertServer());
-  scoped_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
 
   scoped_ptr<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;
@@ skipping 18 matching lines @@
   EXPECT_EQ(0,
             cert_status & net::CERT_STATUS_ALL_ERRORS);  // No errors expected.
   EXPECT_EQ(NavigationEntry::SSLStatus::MIXED_CONTENT, mixed_content_state);
 }
 
 // This test ensures the CN invalid status does not 'stick' to a certificate
 // (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_ptr<HTTPSTestServer> https_server(
-    new HTTPSTestServer(kLocalHost, util_.kOKHTTPSPort,
-    kDocRoot, util_.GetOKCertPath().ToWStringHack()));
+  scoped_refptr<HTTPSTestServer> https_server =
+      HTTPSTestServer::CreateServer(kLocalHost, util_.kOKHTTPSPort,
+      kDocRoot, util_.GetOKCertPath().ToWStringHack());
+  ASSERT_TRUE(NULL != https_server.get());
 
   // First we hit the server with hostname, this generates an invalid policy
   // error.
   scoped_ptr<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));
@@ skipping 88 matching lines @@
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATION_BROKEN, security_style);
   EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
             cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // 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_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
   scoped_ptr<HTTPSTestServer> bad_https_server(BadCertServer());
 
   scoped_ptr<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);
@@ skipping 65 matching lines @@
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATION_BROKEN, security_style);
   EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
             cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // Visit a page over http that is a redirect to a page with https (good and
 // bad).
 TEST_F(SSLUITest, TestRedirectHTTPToHTTPS) {
-  scoped_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
   scoped_ptr<HTTPSTestServer> good_https_server(GoodCertServer());
   scoped_ptr<HTTPSTestServer> bad_https_server(BadCertServer());
 
   // HTTP redirects to good HTTPS.
   scoped_ptr<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()));
 
@@ skipping 22 matching lines @@
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATION_BROKEN, security_style);
   EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
             cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // 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_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
   scoped_ptr<HTTPSTestServer> https_server(GoodCertServer());
 
   scoped_ptr<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;
@@ skipping 35 matching lines @@
 //
 // Frame navigation
 //
 
 // From a good HTTPS top frame:
 // - navigate to an OK HTTPS frame
 // - 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_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
   scoped_ptr<HTTPSTestServer> good_https_server(GoodCertServer());
   scoped_ptr<HTTPSTestServer> bad_https_server(BadCertServer());
 
   scoped_ptr<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;
@@ skipping 117 matching lines @@
                                     &mixed_content_state));
   EXPECT_EQ(SECURITY_STYLE_AUTHENTICATION_BROKEN, security_style);
   EXPECT_EQ(net::CERT_STATUS_DATE_INVALID,
             cert_status & net::CERT_STATUS_ALL_ERRORS);
   EXPECT_EQ(NavigationEntry::SSLStatus::NORMAL_CONTENT, mixed_content_state);
 }
 
 // From an HTTP top frame, navigate to good and bad HTTPS (security state should
 // stay unauthenticated).
 TEST_F(SSLUITest, TestUnauthenticatedFrameNavigation) {
-  scoped_ptr<TestServer> http_server(PlainServer());
+  scoped_ptr<HTTPTestServer> http_server(PlainServer());
   scoped_ptr<HTTPSTestServer> good_https_server(GoodCertServer());
   scoped_ptr<HTTPSTestServer> bad_https_server(BadCertServer());
 
   scoped_ptr<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;
@@ skipping 52 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.