Fixes the cache lock issue.

net/url_request/url_request_http_job_unittest.cc

 // Copyright (c) 2013 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_http_job.h"
 
 #include <stdint.h>
 
 #include <cstddef>
 #include <memory>
@@ skipping 341 matching lines @@
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             request->GetTotalSentBytes());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             request->GetTotalReceivedBytes());
   EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
             network_delegate_.total_network_bytes_sent());
   EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
             network_delegate_.total_network_bytes_received());
 }
 
+// Similar to the test above except it creates multiple URL Requests so that
+// when one fails, the other is in the validation stage due to Shared Writing.
+TEST_F(URLRequestHttpJobWithMockSocketsTest, TestContentLengthFailedRequest2) {
+  MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
+  MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
+                               "Content-Length: 20\r\n\r\n"),
+                      MockRead("Test Content"),
+                      MockRead(net::SYNCHRONOUS, net::ERR_FAILED)};
+
+  int kNumRequests = 3;
+
+  StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
+                                       arraysize(writes));
+  StaticSocketDataProvider socket_data1(reads, arraysize(reads), writes,
+                                        arraysize(writes));
+
+  StaticSocketDataProvider socket_data2(reads, arraysize(reads), writes,
+                                        arraysize(writes));
+
+  socket_factory_.AddSocketDataProvider(&socket_data);
+  socket_factory_.AddSocketDataProvider(&socket_data1);
+  socket_factory_.AddSocketDataProvider(&socket_data2);
+
+  std::vector<TestDelegate> delegates(kNumRequests);
+  std::vector<std::unique_ptr<URLRequest>> requests(kNumRequests);
+
+  for (int i = 0; i < kNumRequests; i++) {
+    requests[i] = context_->CreateRequest(GURL("http://www.example.com"),
+                                          DEFAULT_PRIORITY, &delegates[i]);
+    requests[i]->Start();
+    ASSERT_TRUE(requests[i]->is_pending());
+  }
+
+  base::RunLoop().Run();
+
+  EXPECT_THAT(delegates[0].request_status(), IsError(ERR_FAILED));
+  EXPECT_EQ(12, requests[0]->received_response_content_length());
+  EXPECT_EQ(CountWriteBytes(writes, arraysize(writes)),
+            requests[0]->GetTotalSentBytes());
+  EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
+            requests[0]->GetTotalReceivedBytes());
+  // [1] request does not read the response body since its failed when current
+  // writer transaction receives a network failure. [2] has not yet started so
+  // it goes ahead and reads the response body.
+  EXPECT_EQ(CountReadBytes(reads, arraysize(reads)),
+            requests[2]->GetTotalReceivedBytes());
+  EXPECT_EQ(3 * CountWriteBytes(writes, arraysize(writes)),
+            network_delegate_.total_network_bytes_sent());
+  // Hardcoding this number since [1] only receives the headers.
+  EXPECT_EQ(2 * CountReadBytes(reads, arraysize(reads)) + 39,
+            network_delegate_.total_network_bytes_received());
+}
+
 TEST_F(URLRequestHttpJobWithMockSocketsTest,
        TestContentLengthCancelledRequest) {
   MockWrite writes[] = {MockWrite(kSimpleGetMockWrite)};
   MockRead reads[] = {MockRead("HTTP/1.1 200 OK\r\n"
                                "Content-Length: 20\r\n\r\n"),
                       MockRead("Test Content"),
                       MockRead(net::SYNCHRONOUS, net::ERR_IO_PENDING)};
 
   StaticSocketDataProvider socket_data(reads, arraysize(reads), writes,
                                        arraysize(writes));
@@ skipping 770 matching lines @@
   base::RunLoop().RunUntilIdle();
   EXPECT_THAT(delegate_.request_status(), IsError(ERR_IO_PENDING));
   EXPECT_TRUE(fake_handshake_stream->initialize_stream_was_called());
 }
 
 #endif  // BUILDFLAG(ENABLE_WEBSOCKETS)
 
 }  // namespace
 
 }  // namespace net