Fix a logic error in the handling the response to an HTTP...

net/url_request/url_request_unittest.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 "net/url_request/url_request_unittest.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 37 matching lines @@
   }
 
   virtual ~URLRequestHttpCacheContext() {
     delete http_transaction_factory_;
     delete proxy_service_;
   }
 };
 
 class TestURLRequest : public URLRequest {
  public:
-   TestURLRequest(const GURL& url, Delegate* delegate)
-       : URLRequest(url, delegate) {
-     set_context(new URLRequestHttpCacheContext());
-   }
+  TestURLRequest(const GURL& url, Delegate* delegate)
+      : URLRequest(url, delegate) {
+    set_context(new URLRequestHttpCacheContext());
+  }
 };
 
 StringPiece TestNetResourceProvider(int key) {
   return "header";
 }
 
 // Do a case-insensitive search through |haystack| for |needle|.
 bool ContainsString(const std::string& haystack, const char* needle) {
   std::string::const_iterator it =
       std::search(haystack.begin(),
                   haystack.end(),
                   needle,
                   needle + strlen(needle),
                   CaseInsensitiveCompare<char>());
   return it != haystack.end();
 }
 
 }  // namespace
 
 // Inherit PlatformTest since we require the autorelease pool on Mac OS X.f
 class URLRequestTest : public PlatformTest {
 };
 
+TEST_F(URLRequestTest, ProxyTunnelRedirectTest) {
+  // In this unit test, we're using the HTTPTestServer as a proxy server and
+  // issue a CONNECT request with the magic host name "www.redirect.com" to
+  // it.  The HTTPTestServer will return a 302 response, which we should not
+  // follow.
+  scoped_refptr<HTTPTestServer> server =
+      HTTPTestServer::CreateServer(L"", NULL);
+  ASSERT_TRUE(NULL != server.get());
+  TestDelegate d;
+  {
+    URLRequest r(GURL("https://www.redirect.com/"), &d);
+    std::string proxy("localhost:");
+    proxy.append(IntToString(kHTTPDefaultPort));
+    r.set_context(new TestURLRequestContext(proxy));
+
+    r.Start();
+    EXPECT_TRUE(r.is_pending());
+
+    MessageLoop::current()->Run();
+
+    EXPECT_EQ(1, d.response_started_count());
+    // We should have rewritten the 302 response code as 500.
+    EXPECT_EQ(500, r.GetResponseCode());
+    // We should not have followed the redirect.
+    EXPECT_EQ(0, d.received_redirect_count());
+  }
+}
+
 TEST_F(URLRequestTest, GetTest_NoCache) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"", NULL);
   ASSERT_TRUE(NULL != server.get());
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage(""), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, GetTest) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"", NULL);
   ASSERT_TRUE(NULL != server.get());
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage(""), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 class HTTPSRequestTest : public testing::Test {
  protected:
-   HTTPSRequestTest() : util_() {};
+  HTTPSRequestTest() : util_() {}
 
-   SSLTestUtil util_;
+  SSLTestUtil util_;
 };
 
 #if defined(OS_MACOSX)
 // TODO(port): support temporary root cert on mac
 #define MAYBE_HTTPSGetTest DISABLED_HTTPSGetTest
 #else
 #define MAYBE_HTTPSGetTest HTTPSGetTest
 #endif
 
 TEST_F(HTTPSRequestTest, MAYBE_HTTPSGetTest) {
@@ skipping 14 matching lines @@
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_NE(0, d.bytes_received());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, CancelTest) {
   TestDelegate d;
   {
     TestURLRequest r(GURL("http://www.google.com/"), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     r.Cancel();
 
     MessageLoop::current()->Run();
 
     // We expect to receive OnResponseStarted even though the request has been
     // cancelled.
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, CancelTest2) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"", NULL);
   ASSERT_TRUE(NULL != server.get());
 
   // error C2446: '!=' : no conversion from 'HTTPTestServer *const '
   // to 'const int'
 
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage(""), &d);
 
     d.set_cancel_in_response_started(true);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, CancelTest3) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"", NULL);
   ASSERT_TRUE(NULL != server.get());
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage(""), &d);
 
     d.set_cancel_in_received_data(true);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_EQ(1, d.response_started_count());
     // There is no guarantee about how much data was received
     // before the cancel was issued.  It could have been 0 bytes,
     // or it could have been all the bytes.
     // EXPECT_EQ(0, d.bytes_received());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(URLRequestStatus::CANCELED, r.status().status());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, CancelTest4) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"", NULL);
   ASSERT_TRUE(NULL != server.get());
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage(""), &d);
@@ skipping 54 matching lines @@
 
 TEST_F(URLRequestTest, PostTest) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"net/data", NULL);
   ASSERT_TRUE(NULL != server.get());
   const int kMsgSize = 20000;  // multiple of 10
   const int kIterations = 50;
   char *uploadBytes = new char[kMsgSize+1];
   char *ptr = uploadBytes;
   char marker = 'a';
-  for(int idx=0; idx<kMsgSize/10; idx++) {
+  for (int idx = 0; idx < kMsgSize/10; idx++) {
     memcpy(ptr, "----------", 10);
     ptr += 10;
     if (idx % 100 == 0) {
       ptr--;
       *ptr++ = marker;
       if (++marker > 'z')
         marker = 'a';
     }
-
   }
   uploadBytes[kMsgSize] = '\0';
 
   scoped_refptr<URLRequestContext> context =
       new URLRequestHttpCacheContext();
 
   for (int i = 0; i < kIterations; ++i) {
     TestDelegate d;
     URLRequest r(server->TestServerPage("echo"), &d);
     r.set_context(context);
     r.set_method("POST");
 
     r.AppendBytesToUpload(uploadBytes, kMsgSize);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
         (int) r.status().status() << ", os error: " << r.status().os_error();
 
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(uploadBytes, d.data_received());
-    EXPECT_EQ(memcmp(uploadBytes, d.data_received().c_str(), kMsgSize),0);
+    EXPECT_EQ(memcmp(uploadBytes, d.data_received().c_str(), kMsgSize), 0);
     EXPECT_EQ(d.data_received().compare(uploadBytes), 0);
   }
   delete[] uploadBytes;
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, PostEmptyTest) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"net/data", NULL);
   ASSERT_TRUE(NULL != server.get());
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage("echo"), &d);
     r.set_method("POST");
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
         (int) r.status().status() << ", os error: " << r.status().os_error();
 
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_TRUE(d.data_received().empty());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, PostFileTest) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"net/data", NULL);
   ASSERT_TRUE(NULL != server.get());
   TestDelegate d;
   {
     TestURLRequest r(server->TestServerPage("echo"), &d);
@@ skipping 30 matching lines @@
 
     ASSERT_EQ(1, d.response_started_count()) << "request failed: " <<
         (int) r.status().status() << ", os error: " << r.status().os_error();
 
     EXPECT_FALSE(d.received_data_before_response());
 
     ASSERT_EQ(size, d.bytes_received());
     EXPECT_EQ(0, memcmp(d.data_received().c_str(), buf.get(), size));
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, AboutBlankTest) {
   TestDelegate d;
   {
     TestURLRequest r(GURL("about:blank"), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     EXPECT_TRUE(!r.is_pending());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), 0);
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, FileTest) {
   FilePath app_path;
   PathService::Get(base::FILE_EXE, &app_path);
   GURL app_url = net::FilePathToFileURL(app_path.ToWStringHack());
 
   TestDelegate d;
   {
     TestURLRequest r(app_url, &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
 
     int64 file_size;
     file_util::GetFileSize(app_path, &file_size);
 
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), static_cast<int>(file_size));
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, InvalidUrlTest) {
   TestDelegate d;
   {
     TestURLRequest r(GURL("invalid url"), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
     EXPECT_TRUE(d.request_failed());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 // This test is disabled because it fails on some computers due to proxies
 // returning a page in response to this request rather than reporting failure.
 TEST_F(URLRequestTest, DISABLED_DnsFailureTest) {
   TestDelegate d;
   {
     URLRequest r(GURL("http://thisisnotavalidurl0123456789foo.com/"), &d);
 
     r.Start();
     EXPECT_TRUE(r.is_pending());
 
     MessageLoop::current()->Run();
     EXPECT_TRUE(d.request_failed());
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 
 TEST_F(URLRequestTest, ResponseHeadersTest) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"net/data/url_request_unittest", NULL);
   ASSERT_TRUE(NULL != server.get());
   TestDelegate d;
   TestURLRequest req(server->TestServerPage("files/with-headers.html"), &d);
   req.Start();
@@ skipping 130 matching lines @@
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.received_redirect_count());
     EXPECT_EQ(content, d.data_received());
   }
 
   // Clean the shortcut
   DeleteFile(lnk_path.c_str());
   CoUninitialize();
 
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 }
 #endif  // defined(OS_WIN)
 
 TEST_F(URLRequestTest, ContentTypeNormalizationTest) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"net/data/url_request_unittest", NULL);
   ASSERT_TRUE(NULL != server.get());
 
   TestDelegate d;
@@ skipping 26 matching lines @@
 
     TestURLRequest req(net::FilePathToFileURL(file_path), &d);
     req.Start();
     EXPECT_TRUE(req.is_pending());
 
     d.set_cancel_in_received_data_pending(true);
 
     MessageLoop::current()->Run();
   }
 #ifndef NDEBUG
-  DCHECK_EQ(url_request_metrics.object_count,0);
+  DCHECK_EQ(url_request_metrics.object_count, 0);
 #endif
 
   // Take out mock resource provider.
   net::NetModule::SetResourceProvider(NULL);
 }
 
 TEST_F(URLRequestTest, RestrictRedirects) {
   scoped_refptr<HTTPTestServer> server =
       HTTPTestServer::CreateServer(L"net/data/url_request_unittest", NULL);
   ASSERT_TRUE(NULL != server.get());
@@ skipping 305 matching lines @@
     int64 file_size = 0;
     file_util::GetFileSize(app_path, &file_size);
 
     EXPECT_TRUE(!r.is_pending());
     EXPECT_EQ(1, d.response_started_count());
     EXPECT_FALSE(d.received_data_before_response());
     EXPECT_EQ(d.bytes_received(), 0);
   }
 }