Get url_request_unittest.cc to build on Linux.

net/url_request/url_request_unittest.h

 // 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.
 
 #ifndef NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 #define NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_
 
 #include <sstream>
 #include <string>
 
 #include "base/file_util.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/platform_thread.h"
 #include "base/process_util.h"
 #include "base/string_util.h"
 #include "base/thread.h"
+#include "base/time.h"
 #include "base/waitable_event.h"
 #include "net/base/net_errors.h"
 #include "net/http/http_network_layer.h"
 #include "net/url_request/url_request.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "googleurl/src/url_util.h"
 
 const int kDefaultPort = 1337;
 const std::string kDefaultHostName("localhost");
 
 // This URLRequestContext does not use a local cache.
 class TestURLRequestContext : public URLRequestContext {
  public:
   TestURLRequestContext() {
     http_transaction_factory_ = net::HttpNetworkLayer::CreateFactory(NULL);
   }
@@ skipping 162 matching lines @@
     Shutdown();
   }
 
   // Implementation of ProcessFilter
   virtual bool Includes(uint32 pid, uint32 parent_pid) const {
     // This function may be called after Shutdown(), in which process_handle_ is
     // set to NULL. Since no process handle is set, it can't be included in the
     // filter.
     if (!process_handle_)
       return false;
-    return pid == process_util::GetProcId(process_handle_);
+    // TODO(port): rationalize return value of GetProcId
+    return pid == (uint32)process_util::GetProcId(process_handle_);
   }
 
   GURL TestServerPage(const std::string& path) {
     return GURL(base_address_ + path);
   }
 
   GURL TestServerPageW(const std::wstring& path) {
-    return GURL(UTF8ToWide(base_address_) + path);
+    return GURL(base_address_ + WideToUTF8(path));
   }
 
   // A subclass may wish to send the request in a different manner
   virtual bool MakeGETRequest(const std::string& page_name) {
     const GURL& url = TestServerPage(page_name);
 
     // Spin up a background thread for this request so that we have access to
     // an IO message loop, and in cases where this thread already has an IO
     // message loop, we also want to avoid spinning a nested message loop.
     
@@ skipping 23 matching lines @@
 
   virtual std::string scheme() { return std::string("http"); }
 
   // This is in a separate function so that we can have assertions and so that
   // subclasses can call this later.
   void Init(const std::string& host_name, int port,
             const std::wstring& document_root,
             const std::wstring& cert_path) {
     std::stringstream ss;
     std::string port_str;
-    ss << port ? port : kDefaultPort;
+    ss << (port ? port : kDefaultPort);
     ss >> port_str;
     base_address_ = scheme() + "://" + host_name + ":" + port_str + "/";
 
     std::wstring testserver_path;
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &testserver_path));
     file_util::AppendToPath(&testserver_path, L"net");
     file_util::AppendToPath(&testserver_path, L"tools");
     file_util::AppendToPath(&testserver_path, L"testserver");
     file_util::AppendToPath(&testserver_path, L"testserver.py");
 
     ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &python_runtime_));
     file_util::AppendToPath(&python_runtime_, L"third_party");
     file_util::AppendToPath(&python_runtime_, L"python_24");
     file_util::AppendToPath(&python_runtime_, L"python.exe");
 
     std::wstring test_data_directory;
     PathService::Get(base::DIR_SOURCE_ROOT, &test_data_directory);
     std::wstring normalized_document_root = document_root;
     std::replace(normalized_document_root.begin(),
                  normalized_document_root.end(),
                  L'/', file_util::kPathSeparator);
     file_util::AppendToPath(&test_data_directory, normalized_document_root);
 
+#if defined(OS_WIN)
     std::wstring command_line =
         L"\"" + python_runtime_ + L"\" " + L"\"" + testserver_path +
         L"\" --port=" + UTF8ToWide(port_str) + L" --data-dir=\"" +
         test_data_directory + L"\"";
     if (!cert_path.empty()) {
       command_line.append(L" --https=\"");
       command_line.append(cert_path);
       command_line.append(L"\"");
     }
 
     ASSERT_TRUE(
         process_util::LaunchApp(command_line, false, true, &process_handle_)) <<
         "Failed to launch " << command_line;
+#elif defined(OS_LINUX)
+    bool tlslite_installed = !access("/usr/bin/tls.py", X_OK);
+    ASSERT_TRUE(tlslite_installed) << "tlslite not installed?  Please run 'python setup.py install' in third_party/tlslite.";
+
+    std::vector<std::string> command_line;
+    command_line.push_back("python");
+    command_line.push_back(WideToUTF8(testserver_path));
+    command_line.push_back("--port=" + port_str);
+    command_line.push_back("--data-dir=" + WideToUTF8(test_data_directory));
+    if (!cert_path.empty()) 
+      command_line.push_back("--https=" + WideToUTF8(cert_path));
+
+    ASSERT_TRUE(
+        process_util::LaunchApp(command_line, false, &process_handle_)) <<
+        "Failed to launch " << command_line[0] << " ...";
+#endif
 
     // Verify that the webserver is actually started.
     // Otherwise tests can fail if they run faster than Python can start.
     int retries = 10;
     bool success;
     while ((success = MakeGETRequest("hello.html")) == false && retries > 0) {
       retries--;
       PlatformThread::Sleep(500);
     }
-    ASSERT_TRUE(success) << "Webserver not starting properly.";
+    ASSERT_TRUE(success) << "Webserver not starting properly.  (On Linux, you need to install third_party/tlslite.)";
 
     is_shutdown_ = false;
   }
 
   void Shutdown() {
     if (is_shutdown_)
       return;
 
     // here we append the time to avoid problems where the kill page
     // is being cached rather than being executed on the server
     std::ostringstream page_name;
-    page_name << "kill?" << GetTickCount();
+    page_name << "kill?" << (unsigned int)(base::Time::Now().ToInternalValue());
     int retry_count = 5;
     while (retry_count > 0) {
       bool r = MakeGETRequest(page_name.str());
       // BUG #1048625 causes the kill GET to fail.  For now we just retry.
       // Once the bug is fixed, we should remove the while loop and put back
       // the following DCHECK.
       // DCHECK(r);
       if (r)
         break;
       retry_count--;
     }
     // Make sure we were successfull in stopping the testserver.
     DCHECK(retry_count > 0);
 
     if (process_handle_) {
+#if defined(OS_WIN)
       CloseHandle(process_handle_);
+#endif
       process_handle_ = NULL;
     }
 
     // Make sure we don't leave any stray testserver processes laying around.
     std::wstring testserver_name =
         file_util::GetFilenameFromPath(python_runtime_);
     process_util::CleanupProcesses(testserver_name, 10000, 1, this);
     EXPECT_EQ(0, process_util::GetProcessCount(testserver_name, this));
 
     is_shutdown_ = true;
@@ skipping 20 matching lines @@
   static void StartGETRequest(const GURL& url, URLRequest::Delegate* delegate) {
     URLRequest* request = new URLRequest(url, delegate);
     request->set_context(new TestURLRequestContext());
     request->set_method("GET");
     request->Start();
     EXPECT_TRUE(request->is_pending());
   }
 
   std::string base_address_;
   std::wstring python_runtime_;
-  HANDLE process_handle_;
+  ProcessHandle process_handle_;
   bool is_shutdown_;
 };
 
 class HTTPSTestServer : public TestServer {
  public:
    HTTPSTestServer(const std::string& host_name, int port,
                    const std::wstring& document_root,
                    const std::wstring& cert_path) : TestServer(ManualInit()) {
     Init(host_name, port, document_root, cert_path);
   }
 
   virtual std::string scheme() { return std::string("https"); }
 };
 
 #endif  // NET_URL_REQUEST_URL_REQUEST_UNITTEST_H_