GTTF: test server cleanup:

net/test/test_server.cc

 // Copyright (c) 2010 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 "net/test/test_server.h"
 
 #include <algorithm>
 #include <string>
 #include <vector>
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <wincrypt.h>
 #elif defined(OS_MACOSX)
 #include "net/base/x509_certificate.h"
 #endif
 
 #include "base/file_util.h"
 #include "base/leak_annotations.h"
 #include "base/logging.h"
 #include "base/path_service.h"
 #include "base/utf_string_conversions.h"
 #include "net/base/cert_test_util.h"
 #include "net/base/host_resolver.h"
-#include "net/base/net_test_constants.h"
 #include "net/base/test_completion_callback.h"
 #include "net/socket/tcp_client_socket.h"
 #include "net/socket/tcp_pinger.h"
 #include "testing/platform_test.h"
 
 #if defined(OS_WIN)
 #pragma comment(lib, "crypt32.lib")
 #endif
 
+namespace {
+
+// Number of connection attempts for tests.
+const int kServerConnectionAttempts = 10;
+
+// Connection timeout in milliseconds for tests.
+const int kServerConnectionTimeoutMs = 1000;
+
+}  // namespace
+
 namespace net {
 
 #if defined(OS_MACOSX)
 void SetMacTestCertificate(X509Certificate* cert);
 #endif
 
 // static
 const char TestServerLauncher::kHostName[] = "127.0.0.1";
 const char TestServerLauncher::kMismatchedHostName[] = "localhost";
 const int TestServerLauncher::kOKHTTPSPort = 9443;
 const int TestServerLauncher::kBadHTTPSPort = 9666;
 
 // The issuer name of the cert that should be trusted for the test to work.
 const wchar_t TestServerLauncher::kCertIssuerName[] = L"Test CA";
 
-TestServerLauncher::TestServerLauncher() : process_handle_(
-    base::kNullProcessHandle),
-    forking_(false),
-    connection_attempts_(kDefaultTestConnectionAttempts),
-    connection_timeout_(kDefaultTestConnectionTimeout)
-{
+TestServerLauncher::TestServerLauncher()
+    : process_handle_(base::kNullProcessHandle) {
   InitCertPath();
 }
 
-TestServerLauncher::TestServerLauncher(int connection_attempts,
-                                       int connection_timeout)
-                        : process_handle_(base::kNullProcessHandle),
-                          forking_(false),
-                          connection_attempts_(connection_attempts),
-                          connection_timeout_(connection_timeout)
-{
-  InitCertPath();
-}
-
 void TestServerLauncher::InitCertPath() {
   PathService::Get(base::DIR_SOURCE_ROOT, &cert_dir_);
   cert_dir_ = cert_dir_.Append(FILE_PATH_LITERAL("net"))
                        .Append(FILE_PATH_LITERAL("data"))
                        .Append(FILE_PATH_LITERAL("ssl"))
                        .Append(FILE_PATH_LITERAL("certificates"));
 }
 
 namespace {
 
@@ skipping 69 matching lines @@
       .Append(FILE_PATH_LITERAL("testserver"))
       .Append(FILE_PATH_LITERAL("testserver.py"));
 
   PathService::Get(base::DIR_SOURCE_ROOT, &document_root_dir_);
   document_root_dir_ = document_root_dir_.Append(document_root);
 
   SetPythonPath();
 
 #if defined(OS_WIN)
   // Get path to python interpreter
-  if (!PathService::Get(base::DIR_SOURCE_ROOT, &python_runtime_))
+  FilePath python_exe;
+  if (!PathService::Get(base::DIR_SOURCE_ROOT, &python_exe))
     return false;
-  python_runtime_ = python_runtime_
+  python_exe = python_exe
       .Append(FILE_PATH_LITERAL("third_party"))
       .Append(FILE_PATH_LITERAL("python_24"))
       .Append(FILE_PATH_LITERAL("python.exe"));
 
   std::wstring command_line =
-      L"\"" + python_runtime_.ToWStringHack() + L"\" " +
+      L"\"" + python_exe.ToWStringHack() + L"\" " +
       L"\"" + testserver_path.ToWStringHack() +
       L"\" --port=" + UTF8ToWide(port_str) +
       L" --data-dir=\"" + document_root_dir_.ToWStringHack() + L"\"";
   if (protocol == ProtoFTP)
     command_line.append(L" -f");
   if (!cert_path.value().empty()) {
     command_line.append(L" --https=\"");
     command_line.append(cert_path.ToWStringHack());
     command_line.append(L"\"");
   }
   if (!file_root_url.empty()) {
     command_line.append(L" --file-root-url=\"");
     command_line.append(file_root_url);
     command_line.append(L"\"");
   }
-  // Deliberately do not pass the --forking flag. It breaks the tests
-  // on Windows.
 
   if (!LaunchTestServerAsJob(command_line,
                              true,
                              &process_handle_,
                              &job_handle_)) {
     LOG(ERROR) << "Failed to launch " << command_line;
     return false;
   }
 #elif defined(OS_POSIX)
   std::vector<std::string> command_line;
   command_line.push_back("python");
   command_line.push_back(testserver_path.value());
   command_line.push_back("--port=" + port_str);
   command_line.push_back("--data-dir=" + document_root_dir_.value());
   if (protocol == ProtoFTP)
     command_line.push_back("-f");
   if (!cert_path.value().empty())
     command_line.push_back("--https=" + cert_path.value());
-  if (forking_)
-    command_line.push_back("--forking");
 
   base::file_handle_mapping_vector no_mappings;
   LOG(INFO) << "Trying to launch " << command_line[0] << " ...";
   if (!base::LaunchApp(command_line, no_mappings, false, &process_handle_)) {
     LOG(ERROR) << "Failed to launch " << command_line[0] << " ...";
     return false;
   }
 #endif
 
   // Let the server start, then verify that it's up.
@@ skipping 14 matching lines @@
   // Otherwise tests can fail if they run faster than Python can start.
   net::AddressList addr;
   scoped_refptr<net::HostResolver> resolver(
       net::CreateSystemHostResolver(net::HostResolver::kDefaultParallelism));
   net::HostResolver::RequestInfo info(host_name, port);
   int rv = resolver->Resolve(info, &addr, NULL, NULL, BoundNetLog());
   if (rv != net::OK)
     return false;
 
   net::TCPPinger pinger(addr);
-  rv = pinger.Ping(base::TimeDelta::FromMilliseconds(connection_timeout_),
-                   connection_attempts_);
+  rv = pinger.Ping(
+      base::TimeDelta::FromMilliseconds(kServerConnectionTimeoutMs),
+      kServerConnectionAttempts);
   return rv == net::OK;
 }
 
 bool TestServerLauncher::WaitToFinish(int timeout_ms) {
   if (!process_handle_)
     return true;
 
   bool ret = base::WaitForSingleProcess(process_handle_, timeout_ms);
   if (ret) {
     base::CloseProcessHandle(process_handle_);
@@ skipping 153 matching lines @@
                                       process_info.hProcess)) {
       LOG(ERROR) << "Could not AssignProcessToObject.";
       return false;
     }
   }
   return true;
 }
 #endif
 
 }  // namespace net