[Net] Fix error handling on wrong file in UploadData

net/spdy/spdy_network_transaction_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 <string>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/stl_util.h"
+#include "base/test/test_file_util.h"
 #include "net/base/auth.h"
 #include "net/base/net_log_unittest.h"
 #include "net/base/request_priority.h"
 #include "net/base/upload_bytes_element_reader.h"
 #include "net/base/upload_data_stream.h"
 #include "net/base/upload_file_element_reader.h"
 #include "net/http/http_network_session_peer.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_server_properties.h"
 #include "net/http/http_transaction_unittest.h"
@@ skipping 427 matching lines @@
           new UploadDataStream(element_readers.Pass(), 0));
 
       google_post_request_.method = "POST";
       google_post_request_.url = GURL(kDefaultURL);
       google_post_request_.upload_data_stream = upload_data_stream_.get();
       google_post_request_initialized_ = true;
     }
     return google_post_request_;
   }
 
+  const HttpRequestInfo& CreateUnreadableFilePostRequest() {
+    if (google_post_request_initialized_)
+      return google_post_request_;
+
+    base::FilePath file_path;
+    CHECK(file_util::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
+    CHECK_EQ(static_cast<int>(kUploadDataSize),
+             file_util::WriteFile(file_path, kUploadData, kUploadDataSize));
+    CHECK(file_util::MakeFileUnreadable(file_path));
+
+    ScopedVector<UploadElementReader> element_readers;
+    element_readers.push_back(
+        new UploadFileElementReader(base::MessageLoopProxy::current().get(),
+                                    file_path,
+                                    0,
+                                    kUploadDataSize,
+                                    base::Time()));
+    upload_data_stream_.reset(
+        new UploadDataStream(element_readers.Pass(), 0));
+
+    google_post_request_.method = "POST";
+    google_post_request_.url = GURL(kDefaultURL);
+    google_post_request_.upload_data_stream = upload_data_stream_.get();
+    google_post_request_initialized_ = true;
+    return google_post_request_;
+  }
+
   const HttpRequestInfo& CreateComplexPostRequest() {
     if (!google_post_request_initialized_) {
       const int kFileRangeOffset = 1;
       const int kFileRangeLength = 3;
       CHECK_LT(kFileRangeOffset + kFileRangeLength, kUploadDataSize);
 
       base::FilePath file_path;
       CHECK(file_util::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
       CHECK_EQ(static_cast<int>(kUploadDataSize),
                file_util::WriteFile(file_path, kUploadData, kUploadDataSize));
@@ skipping 1306 matching lines @@
                          writes, arraysize(writes));
   NormalSpdyTransactionHelper helper(CreateFilePostRequest(), DEFAULT_PRIORITY,
                                      BoundNetLog(), GetParam(), NULL);
   helper.RunToCompletion(&data);
   TransactionHelperResult out = helper.output();
   EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
   EXPECT_EQ("hello!", out.response_data);
 }
 
+// Test that a POST with a unreadable file fails.
+TEST_P(SpdyNetworkTransactionTest, UnreadableFilePost) {
+  scoped_ptr<SpdyFrame> req(
+      spdy_util_.ConstructSpdyPost(
+          kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
+  scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
+  MockWrite writes[] = {
+    CreateMockWrite(*req),
+  };
+  MockRead reads[] = {
+    CreateMockRead(*resp),
+  };
+
+  DelayedSocketData data(2, reads, arraysize(reads), writes, arraysize(writes));
+  NormalSpdyTransactionHelper helper(CreateUnreadableFilePostRequest(),
+                                     DEFAULT_PRIORITY,
+                                     BoundNetLog(), GetParam(), NULL);
+  helper.RunPreTestSetup();
+  helper.AddData(&data);
+  helper.RunDefaultTest();
+
+  base::RunLoop().RunUntilIdle();
+  helper.VerifyDataNotConsumed();
+  EXPECT_EQ(ERR_ACCESS_DENIED, helper.output().rv);
+}
+
 // Test that a complex POST works.
 TEST_P(SpdyNetworkTransactionTest, ComplexPost) {
   scoped_ptr<SpdyFrame> req(
       spdy_util_.ConstructSpdyPost(
           kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
   MockWrite writes[] = {
     CreateMockWrite(*req),
     CreateMockWrite(*body),  // POST upload frame
   };
@@ skipping 4612 matching lines @@
   // since we're send-stalled.
   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
 
   // Read in WINDOW_UPDATE or SETTINGS frame.
   data.RunFor((GetParam().protocol >= kProtoSPDY31) ? 8 : 7);
   rv = callback.WaitForResult();
   helper.VerifyDataConsumed();
 }
 
 }  // namespace net