TEST ONLY: URLRequestFileJob::OnReadComplete doens't fire for 0 byte file.

net/url_request/url_request_file_job_unittest.cc

 // Copyright 2014 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_file_job.h"
 
 #include <memory>
 
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
@@ skipping 36 matching lines @@
         observed_content_(observed_content) {
     *open_result_ = ERR_IO_PENDING;
     *seek_position_ = ERR_IO_PENDING;
     observed_content_->clear();
   }
 
   ~TestURLRequestFileJob() override {}
 
  protected:
   void OnOpenComplete(int result) override {
+    printf("T: OnOpenComplete: %d\n", result);
     // Should only be called once.
     ASSERT_EQ(ERR_IO_PENDING, *open_result_);
     *open_result_ = result;
   }
 
   void OnSeekComplete(int64_t result) override {
+    printf("T: OnSeekComplete: %ld\n", result);
     // Should only call this if open succeeded.
     EXPECT_EQ(OK, *open_result_);
     // Should only be called once.
     ASSERT_EQ(ERR_IO_PENDING, *seek_position_);
     *seek_position_ = result;
   }
 
   void OnReadComplete(IOBuffer* buf, int result) override {
+    printf("T: OnReadComplete: %d\n", result);
     // Should only call this if seek succeeded.
     EXPECT_GE(*seek_position_, 0);
     observed_content_->append(std::string(buf->data(), result));
   }
 
   int* const open_result_;
   int64_t* const seek_position_;
   std::string* const observed_content_;
 };
 
@@ skipping 62 matching lines @@
   // These are mutable because MaybeCreateJobWithProtocolHandler is const.
   mutable int* open_result_;
   mutable int64_t* seek_position_;
   mutable std::string* observed_content_;
 };
 
 // Helper function to create a file at |path| filled with |content|.
 // Returns true on success.
 bool CreateFileWithContent(const std::string& content,
                            const base::FilePath& path) {
-  return base::WriteFile(path, content.c_str(), content.length());
+  return base::WriteFile(path, content.c_str(), content.length()) != -1;
 }
 
 // A simple holder for start/end used in http range requests.
 struct Range {
   int start;
   int end;
 
   Range() {
     start = 0;
     end = 0;
@@ skipping 137 matching lines @@
   for (int i = 0; i < size; i++) {
     result.append(1, static_cast<char>(i % 256));
   }
   return result;
 }
 
 TEST_F(URLRequestFileJobEventsTest, TinyFile) {
   RunSuccessfulRequestWithString(std::string("hello world"), NULL);
 }
 
+TEST_F(URLRequestFileJobEventsTest, ZeroFile) {
+  RunSuccessfulRequestWithString(std::string(""), NULL);
+}
+
 TEST_F(URLRequestFileJobEventsTest, SmallFile) {
   RunSuccessfulRequestWithString(MakeContentOfSize(17 * 1024), NULL);
 }
 
 TEST_F(URLRequestFileJobEventsTest, BigFile) {
   RunSuccessfulRequestWithString(MakeContentOfSize(3 * 1024 * 1024), NULL);
 }
 
 TEST_F(URLRequestFileJobEventsTest, Range) {
   // Use a 15KB content file and read a range chosen somewhat arbitrarily but
@@ skipping 80 matching lines @@
 
   EXPECT_EQ(OK, open_result);
   EXPECT_EQ(0, seek_position);
   EXPECT_EQ("hello\n", observed_content);
   EXPECT_FALSE(delegate_.request_failed());
 }
 
 }  // namespace
 
 }  // namespace net