Make ssl_client_socket_unittest use a local server

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;
-    EXPECT_TRUE(util_.CheckCATrusted());
   }
 
   TabProxy* GetActiveTabProxy() {
     scoped_ptr<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));
     EXPECT_TRUE(browser_proxy.get());
     EXPECT_TRUE(browser_proxy->AppendTab(url));
   }
 
   HTTPTestServer* PlainServer() {
     return HTTPTestServer::CreateServer(kDocRoot, NULL);
   }
 
   HTTPSTestServer* GoodCertServer() {
-    return HTTPSTestServer::CreateServer(util_.kHostName, util_.kOKHTTPSPort,
-        kDocRoot, util_.GetOKCertPath().ToWStringHack());
+    return HTTPSTestServer::CreateGoodServer(kDocRoot);
   }
 
   HTTPSTestServer* BadCertServer() {
-    return HTTPSTestServer::CreateServer(util_.kHostName, util_.kBadHTTPSPort,
-        kDocRoot, util_.GetExpiredCertPath().ToWStringHack());
+    return HTTPSTestServer::CreateExpiredServer(kDocRoot);
   }
 
  protected:
-  SSLTestUtil util_;
-
   DISALLOW_COPY_AND_ASSIGN(SSLUITest);
 };
 
 }  // namespace
 
 // Visits a regular page over http.
 TEST_F(SSLUITest, TestHTTP) {
   scoped_refptr<HTTPTestServer> server = PlainServer();
 
   scoped_ptr<TabProxy> tab(GetActiveTabProxy());
@@ skipping 345 matching lines @@
             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_refptr<HTTPSTestServer> https_server =
-      HTTPSTestServer::CreateServer(kLocalHost, util_.kOKHTTPSPort,
-      kDocRoot, util_.GetOKCertPath().ToWStringHack());
+      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());
   NavigateTab(tab.get(), https_server->TestServerPageW(
       L"files/ssl/google.html"));
 
   // We get an interstitial page as a result.
   NavigationEntry::PageType page_type;
@@ skipping 16 matching lines @@
   EXPECT_EQ(NavigationEntry::NORMAL_PAGE, page_type);
 
   // Now we try again with the right host name this time.
 
   // Let's change the host-name in the url.
   GURL url = https_server->TestServerPageW(L"files/ssl/google.html");
   std::string::size_type hostname_index = url.spec().find(kLocalHost);
   ASSERT_TRUE(hostname_index != std::string::npos);  // Test sanity check.
   std::string new_url;
   new_url.append(url.spec().substr(0, hostname_index));
-  new_url.append(util_.kHostName);
+  new_url.append(net::TestServerLauncher::kHostName);
   new_url.append(url.spec().substr(hostname_index + kLocalHost.size()));
 
   NavigateTab(tab.get(), GURL(new_url));
 
   // Security state should be OK.
   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.
@@ skipping 448 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.