• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #ifndef NET_HTTP_PARTIAL_DATA_H_
6 #define NET_HTTP_PARTIAL_DATA_H_
7 
8 #include "base/basictypes.h"
9 #include "net/base/completion_callback.h"
10 #include "net/http/http_byte_range.h"
11 #include "net/http/http_request_headers.h"
12 
13 namespace disk_cache {
14 class Entry;
15 }
16 
17 namespace net {
18 
19 class HttpResponseHeaders;
20 class IOBuffer;
21 
22 // This class provides support for dealing with range requests and the
23 // subsequent partial-content responses. We use sparse cache entries to store
24 // these requests. This class is tightly integrated with HttpCache::Transaction
25 // and it is intended to allow a cleaner implementation of that class.
26 //
27 // In order to fulfill range requests, we may have to perform a sequence of
28 // reads from the cache, interleaved with reads from the network / writes to the
29 // cache. This class basically keeps track of the data required to perform each
30 // of those individual network / cache requests.
31 class PartialData {
32  public:
33   PartialData();
34   ~PartialData();
35 
36   // Performs initialization of the object by examining the request |headers|
37   // and verifying that we can process the requested range. Returns true if
38   // we can process the requested range, and false otherwise.
39   bool Init(const HttpRequestHeaders& headers);
40 
41   // Sets the headers that we should use to make byte range requests. This is a
42   // subset of the request extra headers, with byte-range related headers
43   // removed.
44   void SetHeaders(const HttpRequestHeaders& headers);
45 
46   // Restores the byte-range headers, by appending the byte range to the headers
47   // provided to SetHeaders().
48   void RestoreHeaders(HttpRequestHeaders* headers) const;
49 
50   // Starts the checks to perform a cache validation. Returns 0 when there is no
51   // need to perform more operations because we reached the end of the request
52   // (so 0 bytes should be actually returned to the user), a positive number to
53   // indicate that PrepareCacheValidation should be called, or an appropriate
54   // error code. If this method returns ERR_IO_PENDING, the |callback| will be
55   // notified when the result is ready.
56   int ShouldValidateCache(disk_cache::Entry* entry,
57                           const CompletionCallback& callback);
58 
59   // Builds the required |headers| to perform the proper cache validation for
60   // the next range to be fetched.
61   void PrepareCacheValidation(disk_cache::Entry* entry,
62                               HttpRequestHeaders* headers);
63 
64   // Returns true if the current range is stored in the cache.
65   bool IsCurrentRangeCached() const;
66 
67   // Returns true if the current range is the last one needed to fulfill the
68   // user's request.
69   bool IsLastRange() const;
70 
71   // Extracts info from headers already stored in the cache. Returns false if
72   // there is any problem with the headers. |truncated| should be true if we
73   // have an incomplete 200 entry.
74   bool UpdateFromStoredHeaders(const HttpResponseHeaders* headers,
75                                disk_cache::Entry* entry, bool truncated);
76 
77   // Sets the byte current range to start again at zero (for a truncated entry).
78   void SetRangeToStartDownload();
79 
80   // Returns true if the requested range is valid given the stored data.
81   bool IsRequestedRangeOK();
82 
83   // Returns true if the response headers match what we expect, false otherwise.
84   bool ResponseHeadersOK(const HttpResponseHeaders* headers);
85 
86   // Fixes the response headers to include the right content length and range.
87   // |success| is the result of the whole request so if it's false, we'll change
88   // the result code to be 416.
89   void FixResponseHeaders(HttpResponseHeaders* headers, bool success);
90 
91   // Fixes the content length that we want to store in the cache.
92   void FixContentLength(HttpResponseHeaders* headers);
93 
94   // Reads up to |data_len| bytes from the cache and stores them in the provided
95   // buffer (|data|). Basically, this is just a wrapper around the API of the
96   // cache that provides the right arguments for the current range. When the IO
97   // operation completes, OnCacheReadCompleted() must be called with the result
98   // of the operation.
99   int CacheRead(disk_cache::Entry* entry, IOBuffer* data, int data_len,
100                 const net::CompletionCallback& callback);
101 
102   // Writes |data_len| bytes to cache. This is basically a wrapper around the
103   // API of the cache that provides the right arguments for the current range.
104   int CacheWrite(disk_cache::Entry* entry, IOBuffer* data, int data_len,
105                  const net::CompletionCallback& callback);
106 
107   // This method should be called when CacheRead() finishes the read, to update
108   // the internal state about the current range.
109   void OnCacheReadCompleted(int result);
110 
111   // This method should be called after receiving data from the network, to
112   // update the internal state about the current range.
113   void OnNetworkReadCompleted(int result);
114 
initial_validation()115   bool initial_validation() const { return initial_validation_; }
116 
117  private:
118   class Core;
119   // Returns the length to use when scanning the cache.
120   int GetNextRangeLen();
121 
122   // Completion routine for our callback.
123   void GetAvailableRangeCompleted(int result, int64 start);
124 
125   int64 current_range_start_;
126   int64 cached_start_;
127   int64 resource_size_;
128   int cached_min_len_;
129   HttpByteRange byte_range_;  // The range requested by the user.
130   // The clean set of extra headers (no ranges).
131   HttpRequestHeaders extra_headers_;
132   bool range_present_;  // True if next range entry is already stored.
133   bool final_range_;
134   bool sparse_entry_;
135   bool truncated_;  // We have an incomplete 200 stored.
136   bool initial_validation_;  // Only used for truncated entries.
137   Core* core_;
138   CompletionCallback callback_;
139 
140   DISALLOW_COPY_AND_ASSIGN(PartialData);
141 };
142 
143 }  // namespace net
144 
145 #endif  // NET_HTTP_PARTIAL_DATA_H_
146