HTTP retry support.

net/http/http_stream_parser.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 NET_HTTP_HTTP_STREAM_PARSER_H_
 #define NET_HTTP_HTTP_STREAM_PARSER_H_
 
 #include <string>
 
 #include "base/basictypes.h"
@@ skipping 57 matching lines @@
   bool CanFindEndOfResponse() const;
 
   bool IsMoreDataBuffered() const;
 
   bool IsConnectionReused() const;
 
   void SetConnectionReused();
 
   bool IsConnectionReusable() const;
 
+  void SetRestartInfo(int64 read_offset, const void* hash, size_t hash_length);
+
+  void GetHash(void* output, size_t hash_length);
+
+  int64 GetReceivedBodyLength() const { return response_body_read_; }
+
   int64 received_bytes() const { return received_bytes_; }
 
   void GetSSLInfo(SSLInfo* ssl_info);
 
   void GetSSLCertRequestInfo(SSLCertRequestInfo* cert_request_info);
 
   // Encodes the given |payload| in the chunked format to |output|.
   // Returns the number of bytes written to |output|. |output_size| should
   // be large enough to store the encoded chunk, which is payload.size() +
   // kChunkHeaderFooterSize. Returns ERR_INVALID_ARGUMENT if |output_size|
   // is not large enough.
   //
   // The output will look like: "HEX\r\n[payload]\r\n"
   // where HEX is a length in hexdecimal (without the "0x" prefix).
   static int EncodeChunk(const base::StringPiece& payload,
                          char* output,
                          size_t output_size);
 
   // Returns true if request headers and body should be merged (i.e. the
   // sum is small enough and the body is in memory, and not chunked).
   static bool ShouldMergeRequestHeadersAndBody(
       const std::string& request_headers,
       const UploadDataStream* request_body);
 
   // The number of extra bytes required to encode a chunk.
   static const size_t kChunkHeaderFooterSize;
 
  private:
   class SeekableIOBuffer;
+  class HttpStreamHash;
 
   // FOO_COMPLETE states implement the second half of potentially asynchronous
   // operations and don't necessarily mean that FOO is complete.
   enum State {
     // STATE_NONE indicates that this is waiting on an external call before
     // continuing.
     STATE_NONE,
     STATE_SEND_HEADERS,
     STATE_SEND_HEADERS_COMPLETE,
     STATE_SEND_BODY,
@@ skipping 85 matching lines @@
   // cannot be safely accessed after reading the final set of headers, as the
   // caller of SendRequest may have been destroyed - this happens in the case an
   // HttpResponseBodyDrainer is used.
   HttpResponseInfo* response_;
 
   // Indicates the content length.  If this value is less than zero
   // (and chunked_decoder_ is null), then we must read until the server
   // closes the connection.
   int64 response_body_length_;
 
+  // Indicates the amount of body data that should be skipped when reading from
+  // a retried request we have already read data from.
+  int64 read_offset_;
+
+  // Hash of content as it is retrieved.
+  scoped_ptr<HttpStreamHash> stream_hash_;
+
   // Keep track of the number of response body bytes read so far.
   int64 response_body_read_;
 
   // Helper if the data is chunked.
   scoped_ptr<HttpChunkedDecoder> chunked_decoder_;
 
   // Where the caller wants the body data.
   scoped_refptr<IOBuffer> user_read_buf_;
   int user_read_buf_len_;
 
@@ skipping 26 matching lines @@
   int upload_error_;
 
   base::WeakPtrFactory<HttpStreamParser> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpStreamParser);
 };
 
 }  // namespace net
 
 #endif  // NET_HTTP_HTTP_STREAM_PARSER_H_