set content length limit if half open range request fails

content/browser/download/download_file_impl.h

 // 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.
 
 #ifndef CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_FILE_IMPL_H_
 #define CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_FILE_IMPL_H_
 
 #include "content/browser/download/download_file.h"
 
 #include <stddef.h>
@@ skipping 51 matching lines @@
 
   void RenameAndUniquify(const base::FilePath& full_path,
                          const RenameCompletionCallback& callback) override;
   void RenameAndAnnotate(const base::FilePath& full_path,
                          const std::string& client_guid,
                          const GURL& source_url,
                          const GURL& referrer_url,
                          const RenameCompletionCallback& callback) override;
   void Detach() override;
   void Cancel() override;
+  void SetPotentialFileLength(int64_t length) override;
   const base::FilePath& FullPath() const override;
   bool InProgress() const override;
   void WasPaused() override;
 
  protected:
   // For test class overrides.
   // Write data from the offset to the file.
   // On OS level, it will seek to the |offset| and write from there.
   virtual DownloadInterruptReason WriteDataToFile(int64_t offset,
                                                   const char* data,
@@ skipping 162 matching lines @@
   // The default directory for creating the download file.
   base::FilePath default_download_directory_;
 
   // Map of the offset and the source stream that represents the slice
   // starting from offset.
   SourceStreams source_streams_;
 
   // Used to trigger progress updates.
   std::unique_ptr<base::RepeatingTimer> update_timer_;
 
+  // Potential file length. A range request with an offset larger than this
+  // value will fail. The actual file length should not be larger than this.

[David Trainor- moved to gerrit, 2017/04/03 17:47:31]

When would the file length be less than this if we set it once we're done the
half open request?

[qinmin, 2017/04/03 18:33:11]

If the length is determined upon completion of a half open request, the file
length should be equal to potential_file_length_.
However, there might not be any successful half open requests. For example, a
file is divided into 2 slices, and the slice at the end of the file finishes
first. If the browser crashes, we don't know whether the 2nd slices has
finished. So a new range request will be issued. That range request will fail
and setPotentialFileLength() will be called. So we can know that the 2nd slice
has already finished.

The issue now becomes whether the parallel request are always issued in a valid
range. If content-length is reliable, then we are ok. If somehow the file
changes, or the content-length is wrong, then the failing range request's offset
will give a larger value than the file length.

+  int64_t potential_file_length_;
+
   // Statistics
   size_t bytes_seen_;
   base::TimeDelta disk_writes_time_;
   base::TimeTicks download_start_;
   RateEstimator rate_estimator_;
   int num_active_streams_;
   bool record_stream_bandwidth_;
   base::TimeTicks last_update_time_;
   size_t bytes_seen_with_parallel_streams_;
   size_t bytes_seen_without_parallel_streams_;
   base::TimeDelta download_time_with_parallel_streams_;
   base::TimeDelta download_time_without_parallel_streams_;
 
   std::vector<DownloadItem::ReceivedSlice> received_slices_;
 
   base::WeakPtr<DownloadDestinationObserver> observer_;
   base::WeakPtrFactory<DownloadFileImpl> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DownloadFileImpl);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_DOWNLOAD_DOWNLOAD_FILE_IMPL_H_