[Net] Fix error handling on wrong file in UploadData

net/http/http_network_transaction_unittest.cc

 // Copyright 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/http/http_network_transaction.h"
 
 #include <math.h>  // ceil
 #include <stdarg.h>
 #include <string>
 #include <vector>
@@ skipping 7706 matching lines @@
                                   kuint64max,
                                   base::Time()));
   UploadDataStream upload_data_stream(element_readers.Pass(), 0);
 
   HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.google.com/upload");
   request.upload_data_stream = &upload_data_stream;
   request.load_flags = 0;
 
-  // If we try to upload an unreadable file, the network stack should report
-  // the file size as zero and upload zero bytes for that file.
+  // If we try to upload an unreadable file, the transaction should fail.
   scoped_refptr<HttpNetworkSession> session(CreateSession(&session_deps_));
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(DEFAULT_PRIORITY, session));
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead(SYNCHRONOUS, OK),
   };
   MockWrite data_writes[] = {
     MockWrite("POST /upload HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n\r\n"),

[mmenke, 2013/10/29 15:29:31]

Do we need all this stuff?  I thought we ended up not writing anything to the
socket in this case?  If that's the case, can get rid of all this stuff and pass
in 0's and NULLs to the StaticSocketDataProvider (Still need it the
StaticSocketDataProvider , I believe, since we still establish a connection).

Same goes for the SPDY tests.

[tzik, 2013/11/07 04:42:55]

Done.

     MockWrite(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, callback.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_EQ(ERR_ACCESS_DENIED, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
-  ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->headers.get() != NULL);
-  EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
+  EXPECT_FALSE(response);
 
   base::DeleteFile(temp_file, false);
 }
 
 TEST_P(HttpNetworkTransactionTest, UnreadableUploadFileAfterAuthRestart) {
   base::FilePath temp_file;
   ASSERT_TRUE(file_util::CreateTemporaryFile(&temp_file));
   std::string temp_file_contents("Unreadable file.");
   std::string unreadable_contents(temp_file_contents.length(), '\0');
   ASSERT_TRUE(file_util::WriteFile(temp_file, temp_file_contents.c_str(),
@@ skipping 33 matching lines @@
               "Connection: keep-alive\r\n"
               "Content-Length: 16\r\n\r\n"),
     MockWrite(SYNCHRONOUS, temp_file_contents.c_str()),
 
     MockWrite("POST /upload HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     MockWrite(SYNCHRONOUS, unreadable_contents.c_str(),
               temp_file_contents.length()),

[mmenke, 2013/10/29 15:29:31]

Again, don't think we need the second block of data.  The socket should actually
be closed. Same goes for the reads.

[tzik, 2013/11/07 04:42:55]

Well, since the request should be aborted before sending any request to the
server, IMO, this test is no longer valid.
Let me drop this.

     MockWrite(SYNCHRONOUS, OK),
   };
   StaticSocketDataProvider data(data_reads, arraysize(data_reads), data_writes,
                                 arraysize(data_writes));
   session_deps_.socket_factory->AddSocketDataProvider(&data);
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, callback1.callback(), BoundNetLog());
   EXPECT_EQ(ERR_IO_PENDING, rv);
@@ skipping 10 matching lines @@
   // Now make the file unreadable and try again.
   ASSERT_TRUE(file_util::MakeFileUnreadable(temp_file));
 
   TestCompletionCallback callback2;
 
   rv = trans->RestartWithAuth(
       AuthCredentials(kFoo, kBar), callback2.callback());
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
-  EXPECT_EQ(OK, rv);
+  EXPECT_EQ(ERR_ACCESS_DENIED, rv);
 
   response = trans->GetResponseInfo();
-  ASSERT_TRUE(response != NULL);
-  EXPECT_TRUE(response->headers.get() != NULL);
-  EXPECT_TRUE(response->auth_challenge.get() == NULL);
-  EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
+  EXPECT_FALSE(response);
 
   base::DeleteFile(temp_file, false);
 }
 
 TEST_P(HttpNetworkTransactionTest, CancelDuringInitRequestBody) {
   class FakeUploadElementReader : public UploadElementReader {
    public:
     FakeUploadElementReader() {}
     virtual ~FakeUploadElementReader() {}
 
@@ skipping 4441 matching lines @@
   // established, to let the HTTP request start.
   ASSERT_EQ(OK, http_callback.WaitForResult());
   std::string response_data;
   ASSERT_EQ(OK, ReadTransaction(http_trans.get(), &response_data));
   EXPECT_EQ("falafel", response_data);
 
   EXPECT_EQ(1, GetIdleSocketCountInTransportSocketPool(session));
 }
 
 }  // namespace net