Report invalid URLs as ERR_INVALID_URL rather than ERR_ABORTED

content/browser/loader/resource_dispatcher_host_unittest.cc

 // Copyright (c) 2012 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 <stddef.h>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/feature_list.h"
@@ skipping 1409 matching lines @@
                              const std::string& reference_data) {
   ASSERT_EQ(5U, messages.size());
   ASSERT_EQ(ResourceMsg_ReceivedRedirect::ID, messages[0].type());
 
   const std::vector<IPC::Message> second_req_msgs =
       std::vector<IPC::Message>(messages.begin() + 1, messages.end());
   CheckSuccessfulRequest(second_req_msgs, reference_data);
 }
 
 void CheckFailedRequest(const std::vector<IPC::Message>& messages,
-                        const std::string& reference_data,
                         int expected_error) {
   ASSERT_LT(0U, messages.size());
   ASSERT_GE(2U, messages.size());
   size_t failure_index = messages.size() - 1;
 
   if (messages.size() == 2) {
     EXPECT_EQ(ResourceMsg_ReceivedResponse::ID, messages[0].type());
   }
 
   CheckRequestCompleteErrorCode(messages[failure_index], expected_error);
@@ skipping 79 matching lines @@
   ASSERT_EQ(ResourceMsg_ReceivedResponse::ID, msgs[3][0].type());
   CheckRequestCompleteErrorCode(msgs[3][1], net::ERR_ABORTED);
 
   // However, request 4 should have actually gone to completion. (Only request 2
   // was canceled.)
   EXPECT_EQ(4, network_delegate()->completed_requests());
   EXPECT_EQ(1, network_delegate()->canceled_requests());
   EXPECT_EQ(0, network_delegate()->error_count());
 }
 
+// Tests that invalid URLs fail with net::ERR_INVALID_URL.
+TEST_P(ResourceDispatcherHostTest, InvalidURL) {
+  MakeTestRequest(0, 1, GURL("https:///"));
+
+  // Sort out all the messages we saw by request.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  ASSERT_EQ(1U, msgs.size());
+  CheckFailedRequest(msgs[0], net::ERR_INVALID_URL);
+}
+
+// Tests that redirects to invalid URLs fail with net::ERR_INVALID_URL.
+TEST_P(ResourceDispatcherHostTest, InvalidURLRedirect) {
+  static const char kHeaders[] =
+      "HTTP/1.1 302 Moved\n"
+      "Location: http:///\n"
+      "\n";
+  SetResponse(kHeaders);
+  HandleScheme("http");
+
+  MakeTestRequest(0, 1, GURL("http://example.com"));
+
+  // Finish the redirect.
+  ResourceHostMsg_FollowRedirect redirect_msg(1);
+  host_.OnMessageReceived(redirect_msg, filter_.get());
+  base::MessageLoop::current()->RunUntilIdle();
+
+  // Sort out all the messages we saw by request.
+  ResourceIPCAccumulator::ClassifiedMessages msgs;
+  accum_.GetClassifiedMessages(&msgs);
+
+  ASSERT_EQ(1U, msgs.size());
+  CheckFailedRequest(msgs[0], net::ERR_INVALID_URL);
+}
+
 // Shows that detachable requests will timeout if the request takes too long to
 // complete.
 TEST_P(ResourceDispatcherHostTest, DetachedResourceTimesOut) {
   MakeTestRequestWithResourceType(filter_.get(), 0, 1,
                                   net::URLRequestTestJob::test_url_2(),
                                   RESOURCE_TYPE_PREFETCH);  // detachable type
   GlobalRequestID global_request_id(filter_->child_id(), 1);
   ResourceRequestInfoImpl* info = ResourceRequestInfoImpl::ForRequest(
       host_.GetURLRequest(global_request_id));
   ASSERT_TRUE(info->detachable_handler());
@@ skipping 783 matching lines @@
 
   // Check that the first kMaxRequests succeeded.
   for (size_t i = 0; i < kMaxRequests; ++i)
     CheckSuccessfulRequest(msgs[i], net::URLRequestTestJob::test_data_2());
 
   // Check that the subsequent two requests (kMaxRequests + 1) and
   // (kMaxRequests + 2) were failed, since the per-process bound was reached.
   for (int i = 0; i < 2; ++i) {
     // Should have sent a single RequestComplete message.
     int index = kMaxRequests + i;
-    CheckFailedRequest(msgs[index], net::URLRequestTestJob::test_data_2(),
-                       net::ERR_INSUFFICIENT_RESOURCES);
+    CheckFailedRequest(msgs[index], net::ERR_INSUFFICIENT_RESOURCES);
   }
 
   // The final 2 requests should have succeeded.
   CheckSuccessfulRequest(msgs[kMaxRequests + 2],
                          net::URLRequestTestJob::test_data_2());
   CheckSuccessfulRequest(msgs[kMaxRequests + 3],
                          net::URLRequestTestJob::test_data_2());
 }
 
 // Test that when too many requests are outstanding for a particular
@@ skipping 45 matching lines @@
   // The processes issued the following requests:
   // #1 issued kMaxRequestsPerProcess that passed + 1 that failed
   // #2 issued 1 request that passed
   // #3 issued 1 request that failed
   ASSERT_EQ((kMaxRequestsPerProcess + 1) + 1 + 1, msgs.size());
 
   for (size_t i = 0; i < kMaxRequestsPerProcess; ++i)
     CheckSuccessfulRequest(msgs[i], net::URLRequestTestJob::test_data_2());
 
   CheckFailedRequest(msgs[kMaxRequestsPerProcess + 0],
-                     net::URLRequestTestJob::test_data_2(),
                      net::ERR_INSUFFICIENT_RESOURCES);
   CheckSuccessfulRequest(msgs[kMaxRequestsPerProcess + 1],
                          net::URLRequestTestJob::test_data_2());
   CheckFailedRequest(msgs[kMaxRequestsPerProcess + 2],
-                     net::URLRequestTestJob::test_data_2(),
                      net::ERR_INSUFFICIENT_RESOURCES);
 }
 
 // Tests that we sniff the mime type for a simple request.
 TEST_P(ResourceDispatcherHostTest, MimeSniffed) {
   std::string raw_headers("HTTP/1.1 200 OK\n\n");
   std::string response_data("<html><title>Test One</title></html>");
   SetResponse(raw_headers, response_data);
 
   HandleScheme("http");
@@ skipping 1482 matching lines @@
   return nullptr;
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceDispatcherHostTests,
     ResourceDispatcherHostTest,
     testing::Values(TestConfig::kDefault,
                     TestConfig::kOptimizeIPCForSmallResourceEnabled));
 
 }  // namespace content