Support restriction the TLS cipher selection in test_server.py

net/test/test_server_win.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 <windows.h>
 #include <wincrypt.h>
 
 #include "base/base_paths.h"
+#include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 #pragma comment(lib, "crypt32.lib")
 
 namespace {
 
-bool LaunchTestServerAsJob(const std::wstring& cmdline,
+bool LaunchTestServerAsJob(const CommandLine& cmdline,
                            bool start_hidden,
                            base::ProcessHandle* process_handle,
                            ScopedHandle* job_handle) {
   // Launch test server process.
   STARTUPINFO startup_info = {0};
   startup_info.cb = sizeof(startup_info);
   startup_info.dwFlags = STARTF_USESHOWWINDOW;
   startup_info.wShowWindow = start_hidden ? SW_HIDE : SW_SHOW;
   PROCESS_INFORMATION process_info;
 
   // If this code is run under a debugger, the test server process is
   // automatically associated with a job object created by the debugger.
   // The CREATE_BREAKAWAY_FROM_JOB flag is used to prevent this.
-  if (!CreateProcess(NULL,
-                     const_cast<wchar_t*>(cmdline.c_str()), NULL, NULL,
-                     TRUE, CREATE_BREAKAWAY_FROM_JOB, NULL, NULL,
-                     &startup_info, &process_info)) {
+  if (!CreateProcess(
+      NULL, const_cast<wchar_t*>(cmdline.command_line_string().c_str()),
+      NULL, NULL, TRUE, CREATE_BREAKAWAY_FROM_JOB, NULL, NULL,
+      &startup_info, &process_info)) {
     LOG(ERROR) << "Could not create process.";
     return false;
   }
   CloseHandle(process_info.hThread);
 
   // If the caller wants the process handle, we won't close it.
   if (process_handle) {
     *process_handle = process_info.hProcess;
   } else {
     CloseHandle(process_info.hProcess);
@@ skipping 18 matching lines @@
       LOG(ERROR) << "Could not AssignProcessToObject.";
       return false;
     }
   }
   return true;
 }
 
 }  // namespace
 
 namespace net {
+
 bool TestServer::LaunchPython(const FilePath& testserver_path) {
   FilePath python_exe;
   if (!PathService::Get(base::DIR_SOURCE_ROOT, &python_exe))
     return false;
   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_exe.value() + L"\" " +
-      L"\"" + testserver_path.value() +
-      L"\" --port=" + ASCIIToWide(base::IntToString(host_port_pair_.port())) +
-      L" --data-dir=\"" + document_root_.value() + L"\"";
-
-  if (type_ == TYPE_FTP)
-    command_line.append(L" -f");
-
-  FilePath certificate_path(GetCertificatePath());
-  if (!certificate_path.value().empty()) {
-    if (!file_util::PathExists(certificate_path)) {
-      LOG(ERROR) << "Certificate path " << certificate_path.value()
-                 << " doesn't exist. Can't launch https server.";
-      return false;
-    }
-    command_line.append(L" --https=\"");
-    command_line.append(certificate_path.value());
-    command_line.append(L"\"");
-  }
-
-  if (type_ == TYPE_HTTPS_CLIENT_AUTH)
-    command_line.append(L" --ssl-client-auth");
+  CommandLine python_command(python_exe);
+  python_command.AppendArgPath(testserver_path);
+  if (!AddCommandLineArguments(&python_command))
+    return false;
 
   HANDLE child_read = NULL;
   HANDLE child_write = NULL;
   if (!CreatePipe(&child_read, &child_write, NULL, 0)) {
     PLOG(ERROR) << "Failed to create pipe";
     return false;
   }
   child_fd_.Set(child_read);
   ScopedHandle scoped_child_write(child_write);
 
   // Have the child inherit the write half.
   if (!SetHandleInformation(child_write, HANDLE_FLAG_INHERIT,
                             HANDLE_FLAG_INHERIT)) {
     PLOG(ERROR) << "Failed to enable pipe inheritance";
     return false;
   }
 
   // Pass the handle on the command-line. Although HANDLE is a
   // pointer, truncating it on 64-bit machines is okay. See
   // http://msdn.microsoft.com/en-us/library/aa384203.aspx
   //
   // "64-bit versions of Windows use 32-bit handles for
   // interoperability. When sharing a handle between 32-bit and 64-bit
   // applications, only the lower 32 bits are significant, so it is
   // safe to truncate the handle (when passing it from 64-bit to
   // 32-bit) or sign-extend the handle (when passing it from 32-bit to
   // 64-bit)."
-  command_line.append(
-      L" --startup-pipe=" +
-      ASCIIToWide(base::IntToString(reinterpret_cast<uintptr_t>(child_write))));
+  python_command.AppendSwitchASCII(
+      "startup-pipe",
+      base::IntToString(reinterpret_cast<uintptr_t>(child_write)));
 
-  if (!LaunchTestServerAsJob(command_line,
+  if (!LaunchTestServerAsJob(python_command,
                              true,
                              &process_handle_,
                              &job_handle_)) {
-    LOG(ERROR) << "Failed to launch " << command_line;
+    LOG(ERROR) << "Failed to launch " << python_command.command_line_string();
     return false;
   }
 
   return true;
 }
 
 bool TestServer::WaitToStart() {
   char buf[8];
   DWORD bytes_read;
   BOOL result = ReadFile(child_fd_, buf, sizeof(buf), &bytes_read, NULL);
@@ skipping 23 matching lines @@
                   "certificate to your trusted roots for this test to work. "
                   "For more info visit:\n"
                   "http://dev.chromium.org/developers/testing\n";
     return false;
   }
 
   return true;
 }
 
 }  // namespace net