GTTF: test server cleanup:

net/url_request/url_request_unittest.cc

 // Copyright (c) 2006-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/url_request/url_request_unittest.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 78 matching lines @@
 
 }  // namespace
 
 // Inherit PlatformTest since we require the autorelease pool on Mac OS X.f
 class URLRequestTest : public PlatformTest {
 };
 
 class URLRequestTestHTTP : public URLRequestTest {
  protected:
   static void SetUpTestCase() {
-    server_ = HTTPTestServer::CreateForkingServer(
-        L"net/data/url_request_unittest/");
+    server_ = HTTPTestServer::CreateServer(L"net/data/url_request_unittest/");
   }
 
   static void TearDownTestCase() {
     server_ = NULL;
   }
 
   void HTTPUploadDataOperationTest(const std::string& method) {
     ASSERT_TRUE(NULL != server_.get());
     const int kMsgSize = 20000;  // multiple of 10
     const int kIterations = 50;
@@ skipping 144 matching lines @@
   req.set_referrer("https://www.referrer.com/");
   req.Start();
   MessageLoop::current()->Run();
 
   EXPECT_EQ(1, d.response_started_count());
   EXPECT_EQ(1, d.received_redirect_count());
   EXPECT_EQ(http_destination, req.url());
   EXPECT_EQ(std::string(), req.referrer());
 }
 
+namespace {
+
+// Used by MakeGETRequest to implement sync load behavior.
+class SyncTestDelegate : public TestDelegate {
+ public:
+  SyncTestDelegate() : event_(false, false), success_(false) {
+  }
+  virtual void OnResponseCompleted(URLRequest* request) {
+    MessageLoop::current()->DeleteSoon(FROM_HERE, request);
+    success_ = request->status().is_success();
+    event_.Signal();
+  }
+  bool Wait(int64 secs) {
+    return event_.TimedWait(TimeDelta::FromSeconds(secs));
+  }
+  bool did_succeed() const { return success_; }
+ private:
+  base::WaitableEvent event_;
+  bool success_;
+  DISALLOW_COPY_AND_ASSIGN(SyncTestDelegate);
+};
+
+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());
+}
+
+bool MakeGETRequest(const GURL& url) {
+  // 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.
+  SyncTestDelegate d;
+  {
+    base::Thread io_thread("MakeGETRequest");
+    base::Thread::Options options;
+    options.message_loop_type = MessageLoop::TYPE_IO;
+    io_thread.StartWithOptions(options);
+    io_thread.message_loop()->PostTask(FROM_HERE, NewRunnableFunction(
+        &StartGETRequest, url, &d));
+
+    const int kWaitSeconds = 30;
+    if (!d.Wait(kWaitSeconds))
+      return false;
+  }
+  return d.did_succeed();
+}
+
+}  // namespace
+
+// Some tests use browser javascript to fetch a 'kill' url that causes
+// the server to exit by itself (rather than letting TestServerLauncher's
+// destructor kill it). We now unit test this mechanism.
 TEST_F(URLRequestTest, QuitTest) {
-  // Don't use shared server here because we order it to quit.
-  // It would impact other tests.
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
-  server->SendQuit();
+  // Append the time to avoid problems where the kill page
+  // is being cached rather than being executed on the server
+  std::string page_name = StringPrintf("kill?%u",
+      static_cast<int>(base::Time::Now().ToInternalValue()));
+  int retry_count = 5;
+  while (retry_count > 0) {
+    bool r = MakeGETRequest(server->TestServerPage(page_name));
+    // 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 successful in stopping the testserver.
+  EXPECT_LT(0, retry_count);
   EXPECT_TRUE(server->WaitToFinish(20000));
 }
 
 class HTTPSRequestTest : public testing::Test {
 };
 
 
 TEST_F(HTTPSRequestTest, HTTPSGetTest) {
   // Note: tools/testserver/testserver.py does not need
   // a working document root to server the pages / and /hello.html,
@@ skipping 900 matching lines @@
 
     EXPECT_TRUE(d.data_received().find("user2/secret") != std::string::npos);
 
     // Make sure we sent the cookie in the restarted transaction.
     EXPECT_TRUE(d.data_received().find("Cookie: got_challenged=true")
         != std::string::npos);
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<URLRequestContext> context = new TestURLRequestContext();
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
@@ skipping 27 matching lines @@
     EXPECT_TRUE(d.data_received().find("Cookie: CookieToNotSend=1")
                 == std::string::npos);
 
     // LOAD_DO_NOT_SEND_COOKIES does not trigger OnGetCookies.
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<URLRequestContext> context = new TestURLRequestContext();
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage("set-cookie?CookieToNotUpdate=2"),
                    &d);
     req.set_context(context);
     req.Start();
@@ skipping 34 matching lines @@
     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
                 != std::string::npos);
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
     EXPECT_EQ(0, d.set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<TestURLRequestContext> context = new TestURLRequestContext();
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
@@ skipping 32 matching lines @@
                 == std::string::npos);
 
     context->set_cookie_policy(NULL);
 
     EXPECT_EQ(1, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<TestURLRequestContext> context = new TestURLRequestContext();
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage("set-cookie?CookieToNotUpdate=2"),
                    &d);
     req.set_context(context);
     req.Start();
@@ skipping 35 matching lines @@
                 == std::string::npos);
     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
                 != std::string::npos);
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSendCookies_ViaPolicy_Async) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<TestURLRequestContext> context = new TestURLRequestContext();
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage("set-cookie?CookieToNotSend=1"), &d);
     req.set_context(context);
     req.Start();
     MessageLoop::current()->Run();
@@ skipping 33 matching lines @@
                 == std::string::npos);
 
     context->set_cookie_policy(NULL);
 
     EXPECT_EQ(1, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, DoNotSaveCookies_ViaPolicy_Async) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<TestURLRequestContext> context = new TestURLRequestContext();
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage("set-cookie?CookieToNotUpdate=2"),
                    &d);
     req.set_context(context);
     req.Start();
@@ skipping 35 matching lines @@
                 == std::string::npos);
     EXPECT_TRUE(d.data_received().find("CookieToNotUpdate=2")
                 != std::string::npos);
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 }
 
 TEST_F(URLRequestTest, CancelTest_During_CookiePolicy) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<TestURLRequestContext> context = new TestURLRequestContext();
 
   TestCookiePolicy cookie_policy(TestCookiePolicy::ASYNC);
   context->set_cookie_policy(&cookie_policy);
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage("set-cookie?A=1&B=2&C=3"),
                    &d);
     req.set_context(context);
     req.Start();  // Triggers an asynchronous cookie policy check.
 
     // But, now we cancel the request by letting it go out of scope.  This
     // should not cause a crash.
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   context->set_cookie_policy(NULL);
 
   // Let the cookie policy complete.  Make sure it handles the destruction of
   // the URLRequest properly.
   MessageLoop::current()->RunAllPending();
 }
 
 TEST_F(URLRequestTest, CancelTest_During_OnGetCookies) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<TestURLRequestContext> context = new TestURLRequestContext();
 
   TestCookiePolicy cookie_policy(TestCookiePolicy::NO_GET_COOKIES);
   context->set_cookie_policy(&cookie_policy);
 
   // Set up a cookie.
   {
     TestDelegate d;
     d.set_cancel_in_get_cookies_blocked(true);
     URLRequest req(server->TestServerPage("set-cookie?A=1&B=2&C=3"),
                    &d);
     req.set_context(context);
     req.Start();  // Triggers an asynchronous cookie policy check.
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(URLRequestStatus::CANCELED, req.status().status());
 
     EXPECT_EQ(1, d.blocked_get_cookies_count());
     EXPECT_EQ(0, d.blocked_set_cookie_count());
   }
 
   context->set_cookie_policy(NULL);
 }
 
 TEST_F(URLRequestTest, CancelTest_During_OnSetCookie) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<TestURLRequestContext> context = new TestURLRequestContext();
 
   TestCookiePolicy cookie_policy(TestCookiePolicy::NO_SET_COOKIE);
   context->set_cookie_policy(&cookie_policy);
 
   // Set up a cookie.
   {
     TestDelegate d;
     d.set_cancel_in_set_cookie_blocked(true);
@@ skipping 12 matching lines @@
     // attempt to set further cookies.
 
     EXPECT_EQ(0, d.blocked_get_cookies_count());
     EXPECT_EQ(1, d.blocked_set_cookie_count());
   }
 
   context->set_cookie_policy(NULL);
 }
 
 TEST_F(URLRequestTest, CookiePolicy_ForceSession) {
-  scoped_refptr<HTTPTestServer> server =
-      HTTPTestServer::CreateServer(L"", NULL);
+  scoped_refptr<HTTPTestServer> server(HTTPTestServer::CreateServer(L""));
   ASSERT_TRUE(NULL != server.get());
   scoped_refptr<TestURLRequestContext> context = new TestURLRequestContext();
 
   TestCookiePolicy cookie_policy(TestCookiePolicy::FORCE_SESSION);
   context->set_cookie_policy(&cookie_policy);
 
   // Set up a cookie.
   {
     TestDelegate d;
     URLRequest req(server->TestServerPage(
@@ skipping 869 matching lines @@
   TestURLRequest
       req(server_->TestServerPage("echoheaderoverride?Accept-Charset"), &d);
   req.set_context(new TestURLRequestContext());
   net::HttpRequestHeaders headers;
   headers.SetHeader(net::HttpRequestHeaders::kAcceptCharset, "koi-8r");
   req.SetExtraRequestHeaders(headers);
   req.Start();
   MessageLoop::current()->Run();
   EXPECT_EQ(std::string("koi-8r"), d.data_received());
 }