Modify tests to ensure URLRequestJob::DoneReading is always called.

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 19 matching lines @@
  public:
   // |seek_position| will be set to the value passed in to OnSeekComplete.
   // |observed_content| will be set to the concatenated data from all calls to
   // OnReadComplete.
   TestURLRequestFileJob(URLRequest* request,
                         NetworkDelegate* network_delegate,
                         const base::FilePath& file_path,
                         const scoped_refptr<base::TaskRunner>& file_task_runner,
                         int* open_result,
                         int64_t* seek_position,
+                        bool* done_reading,
                         std::string* observed_content)
       : URLRequestFileJob(request,
                           network_delegate,
                           file_path,
                           file_task_runner),
         open_result_(open_result),
         seek_position_(seek_position),
+        done_reading_(done_reading),
         observed_content_(observed_content) {
     *open_result_ = ERR_IO_PENDING;
     *seek_position_ = ERR_IO_PENDING;
+    *done_reading_ = false;
     observed_content_->clear();
   }
 
   ~TestURLRequestFileJob() override {}
 
  protected:
   void OnOpenComplete(int result) override {
     // Should only be called once.
     ASSERT_EQ(ERR_IO_PENDING, *open_result_);
     *open_result_ = result;
   }
 
   void OnSeekComplete(int64_t result) override {
     // 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 {
     // Should only call this if seek succeeded.
     EXPECT_GE(*seek_position_, 0);
     observed_content_->append(std::string(buf->data(), result));
   }
 
+  void DoneReading() override { *done_reading_ = true; }
+
   int* const open_result_;
   int64_t* const seek_position_;
+  bool* done_reading_;
   std::string* const observed_content_;
 };
 
 // A URLRequestJobFactory that will return TestURLRequestFileJob instances for
 // file:// scheme URLs.  Can only be used to create a single job.
 class TestJobFactory : public URLRequestJobFactory {
  public:
   TestJobFactory(const base::FilePath& path,
                  int* open_result,
                  int64_t* seek_position,
+                 bool* done_reading,
                  std::string* observed_content)
       : path_(path),
         open_result_(open_result),
         seek_position_(seek_position),
+        done_reading_(done_reading),
         observed_content_(observed_content) {
     CHECK(open_result_);
     CHECK(seek_position_);
+    CHECK(done_reading_);
     CHECK(observed_content_);
   }
 
   ~TestJobFactory() override {}
 
   URLRequestJob* MaybeCreateJobWithProtocolHandler(
       const std::string& scheme,
       URLRequest* request,
       NetworkDelegate* network_delegate) const override {
     CHECK(open_result_);
     CHECK(seek_position_);
+    CHECK(done_reading_);
     CHECK(observed_content_);
     URLRequestJob* job = new TestURLRequestFileJob(
         request, network_delegate, path_, base::ThreadTaskRunnerHandle::Get(),
-        open_result_, seek_position_, observed_content_);
+        open_result_, seek_position_, done_reading_, observed_content_);
     open_result_ = nullptr;
     seek_position_ = nullptr;
+    done_reading_ = nullptr;
     observed_content_ = nullptr;
     return job;
   }
 
   URLRequestJob* MaybeInterceptRedirect(URLRequest* request,
                                         NetworkDelegate* network_delegate,
                                         const GURL& location) const override {
     return nullptr;
   }
 
@@ skipping 14 matching lines @@
   bool IsSafeRedirectTarget(const GURL& location) const override {
     return false;
   }
 
  private:
   const base::FilePath path_;
 
   // These are mutable because MaybeCreateJobWithProtocolHandler is const.
   mutable int* open_result_;
   mutable int64_t* seek_position_;
+  mutable bool* done_reading_;
   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 32 matching lines @@
       const base::FilePath::StringPieceType& file_extension,
       const Range* range);
 
   // Creates and runs a TestURLRequestFileJob job to read from file provided by
   // |path|. If |range| value is provided, it will be passed in the range
   // header.
   void RunRequestWithPath(const base::FilePath& path,
                           const std::string& range,
                           int* open_result,
                           int64_t* seek_position,
+                          bool* done_reading,
                           std::string* observed_content);
 
   TestURLRequestContext context_;
   TestDelegate delegate_;
 };
 
 URLRequestFileJobEventsTest::URLRequestFileJobEventsTest() {}
 
 void URLRequestFileJobEventsTest::TearDown() {
   // Gives a chance to close the opening file.
@@ skipping 24 matching lines @@
     ASSERT_GE(range->start, 0);
     ASSERT_GE(range->end, 0);
     ASSERT_LE(range->start, range->end);
     ASSERT_LT(static_cast<unsigned int>(range->end), expected_content.length());
     range_value = base::StringPrintf("bytes=%d-%d", range->start, range->end);
   }
 
   {
     int open_result;
     int64_t seek_position;
+    bool done_reading;
     std::string observed_content;
     RunRequestWithPath(path, range_value, &open_result, &seek_position,
-                       &observed_content);
+                       &done_reading, &observed_content);
 
     EXPECT_EQ(OK, open_result);
     EXPECT_FALSE(delegate_.request_failed());
     int expected_length =
         range ? (range->end - range->start + 1) : expected_content.length();
     EXPECT_EQ(delegate_.bytes_received(), expected_length);
 
     std::string expected_data_received;
     if (range) {
       expected_data_received.insert(0, expected_content, range->start,
                                     expected_length);
       EXPECT_EQ(expected_data_received, observed_content);
     } else {
       expected_data_received = expected_content;
       EXPECT_EQ(raw_content, observed_content);
     }
 
     EXPECT_EQ(expected_data_received, delegate_.data_received());
     EXPECT_EQ(seek_position, range ? range->start : 0);
+    EXPECT_TRUE(done_reading);
   }
 }
 
 void URLRequestFileJobEventsTest::RunRequestWithPath(
     const base::FilePath& path,
     const std::string& range,
     int* open_result,
     int64_t* seek_position,
+    bool* done_reading,
     std::string* observed_content) {
-  TestJobFactory factory(path, open_result, seek_position, observed_content);
+  TestJobFactory factory(path, open_result, seek_position, done_reading,
+                         observed_content);
   context_.set_job_factory(&factory);
 
   std::unique_ptr<URLRequest> request(context_.CreateRequest(
       FilePathToFileURL(path), DEFAULT_PRIORITY, &delegate_));
   if (!range.empty()) {
     request->SetExtraRequestHeaderByName(HttpRequestHeaders::kRange, range,
                                          true /*overwrite*/);
   }
   request->Start();
 
   base::RunLoop().Run();
 }
 
 // Helper function to make a character array filled with |size| bytes of
 // test content.
 std::string MakeContentOfSize(int size) {
   EXPECT_GE(size, 0);
   std::string result;
   result.reserve(size);
   for (int i = 0; i < size; i++) {
     result.append(1, static_cast<char>(i % 256));
   }
   return result;
 }
 
+TEST_F(URLRequestFileJobEventsTest, ZeroByteFile) {
+  RunSuccessfulRequestWithString(std::string(""), nullptr);
+}
+
 TEST_F(URLRequestFileJobEventsTest, TinyFile) {
   RunSuccessfulRequestWithString(std::string("hello world"), NULL);
 }
 
 TEST_F(URLRequestFileJobEventsTest, SmallFile) {
   RunSuccessfulRequestWithString(MakeContentOfSize(17 * 1024), NULL);
 }
 
 TEST_F(URLRequestFileJobEventsTest, BigFile) {
   RunSuccessfulRequestWithString(MakeContentOfSize(3 * 1024 * 1024), NULL);
@@ skipping 21 matching lines @@
 }
 
 TEST_F(URLRequestFileJobEventsTest, OpenNonExistentFile) {
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.Append(
       FILE_PATH_LITERAL("net/data/url_request_unittest/non-existent.txt"));
 
   int open_result;
   int64_t seek_position;
+  bool done_reading;
   std::string observed_content;
   RunRequestWithPath(path, std::string(), &open_result, &seek_position,
-                     &observed_content);
+                     &done_reading, &observed_content);
 
   EXPECT_EQ(ERR_FILE_NOT_FOUND, open_result);
+  EXPECT_FALSE(done_reading);
   EXPECT_TRUE(delegate_.request_failed());
 }
 
 TEST_F(URLRequestFileJobEventsTest, MultiRangeRequestNotSupported) {
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.Append(
       FILE_PATH_LITERAL("net/data/url_request_unittest/BullRunSpeech.txt"));
 
   int open_result;
   int64_t seek_position;
+  bool done_reading;
   std::string observed_content;
   RunRequestWithPath(path, "bytes=1-5,20-30", &open_result, &seek_position,
-                     &observed_content);
+                     &done_reading, &observed_content);
 
   EXPECT_EQ(OK, open_result);
   EXPECT_EQ(ERR_REQUEST_RANGE_NOT_SATISFIABLE, seek_position);
+  EXPECT_FALSE(done_reading);
   EXPECT_TRUE(delegate_.request_failed());
 }
 
 TEST_F(URLRequestFileJobEventsTest, RangeExceedingFileSize) {
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.Append(
       FILE_PATH_LITERAL("net/data/url_request_unittest/BullRunSpeech.txt"));
 
   int open_result;
   int64_t seek_position;
+  bool done_reading;
   std::string observed_content;
   RunRequestWithPath(path, "bytes=50000-", &open_result, &seek_position,
-                     &observed_content);
+                     &done_reading, &observed_content);
 
   EXPECT_EQ(OK, open_result);
   EXPECT_EQ(ERR_REQUEST_RANGE_NOT_SATISFIABLE, seek_position);
+  EXPECT_FALSE(done_reading);
   EXPECT_TRUE(delegate_.request_failed());
 }
 
 TEST_F(URLRequestFileJobEventsTest, IgnoreRangeParsingError) {
   base::FilePath path;
   PathService::Get(base::DIR_SOURCE_ROOT, &path);
   path = path.Append(
       FILE_PATH_LITERAL("net/data/url_request_unittest/simple.html"));
 
   int open_result;
   int64_t seek_position;
+  bool done_reading;
   std::string observed_content;
   RunRequestWithPath(path, "bytes=3-z", &open_result, &seek_position,
-                     &observed_content);
+                     &done_reading, &observed_content);
 
   EXPECT_EQ(OK, open_result);
   EXPECT_EQ(0, seek_position);
   EXPECT_EQ("hello\n", observed_content);
+  EXPECT_TRUE(done_reading);
   EXPECT_FALSE(delegate_.request_failed());
 }
 
 }  // namespace
 
 }  // namespace net