OLD | NEW |
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "net/filter/sdch_filter.h" | 5 #include "net/filter/sdch_filter.h" |
6 | 6 |
7 #include <ctype.h> | 7 #include <ctype.h> |
8 #include <limits.h> | 8 #include <limits.h> |
9 | 9 |
10 #include <algorithm> | 10 #include <algorithm> |
(...skipping 32 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
43 | 43 |
44 static int filter_use_count = 0; | 44 static int filter_use_count = 0; |
45 ++filter_use_count; | 45 ++filter_use_count; |
46 if (META_REFRESH_RECOVERY == decoding_status_) { | 46 if (META_REFRESH_RECOVERY == decoding_status_) { |
47 UMA_HISTOGRAM_COUNTS("Sdch3.FilterUseBeforeDisabling", filter_use_count); | 47 UMA_HISTOGRAM_COUNTS("Sdch3.FilterUseBeforeDisabling", filter_use_count); |
48 } | 48 } |
49 | 49 |
50 if (vcdiff_streaming_decoder_.get()) { | 50 if (vcdiff_streaming_decoder_.get()) { |
51 if (!vcdiff_streaming_decoder_->FinishDecoding()) { | 51 if (!vcdiff_streaming_decoder_->FinishDecoding()) { |
52 decoding_status_ = DECODING_ERROR; | 52 decoding_status_ = DECODING_ERROR; |
53 SdchManager::SdchErrorRecovery(SdchManager::INCOMPLETE_SDCH_CONTENT); | 53 filter_context_.LogSdchProblem(SdchManager::INCOMPLETE_SDCH_CONTENT); |
54 // Make it possible for the user to hit reload, and get non-sdch content. | 54 // Make it possible for the user to hit reload, and get non-sdch content. |
55 // Note this will "wear off" quickly enough, and is just meant to assure | 55 // Note this will "wear off" quickly enough, and is just meant to assure |
56 // in some rare case that the user is not stuck. | 56 // in some rare case that the user is not stuck. |
57 url_request_context_->sdch_manager()->BlacklistDomain( | 57 url_request_context_->sdch_manager()->BlacklistDomain( |
58 url_); | 58 url_); |
59 UMA_HISTOGRAM_COUNTS("Sdch3.PartialBytesIn", | 59 UMA_HISTOGRAM_COUNTS("Sdch3.PartialBytesIn", |
60 static_cast<int>(filter_context_.GetByteReadCount())); | 60 static_cast<int>(filter_context_.GetByteReadCount())); |
61 UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffIn", source_bytes_); | 61 UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffIn", source_bytes_); |
62 UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffOut", output_bytes_); | 62 UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffOut", output_bytes_); |
63 } | 63 } |
64 } | 64 } |
65 | 65 |
66 if (!dest_buffer_excess_.empty()) { | 66 if (!dest_buffer_excess_.empty()) { |
67 // Filter chaining error, or premature teardown. | 67 // Filter chaining error, or premature teardown. |
68 SdchManager::SdchErrorRecovery(SdchManager::UNFLUSHED_CONTENT); | 68 filter_context_.LogSdchProblem(SdchManager::UNFLUSHED_CONTENT); |
69 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBytesIn", | 69 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBytesIn", |
70 static_cast<int>(filter_context_.GetByteReadCount())); | 70 static_cast<int>(filter_context_.GetByteReadCount())); |
71 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBufferSize", | 71 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBufferSize", |
72 dest_buffer_excess_.size()); | 72 dest_buffer_excess_.size()); |
73 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffIn", source_bytes_); | 73 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffIn", source_bytes_); |
74 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffOut", output_bytes_); | 74 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffOut", output_bytes_); |
75 } | 75 } |
76 | 76 |
77 if (filter_context_.IsCachedContent()) { | 77 if (filter_context_.IsCachedContent()) { |
78 // Not a real error, but it is useful to have this tally. | 78 // Not a real error, but it is useful to have this tally. |
79 // TODO(jar): Remove this stat after SDCH stability is validated. | 79 // TODO(jar): Remove this stat after SDCH stability is validated. |
80 SdchManager::SdchErrorRecovery(SdchManager::CACHE_DECODED); | 80 filter_context_.LogSdchProblem(SdchManager::CACHE_DECODED); |
81 return; // We don't need timing stats, and we aready got ratios. | 81 return; // We don't need timing stats, and we aready got ratios. |
82 } | 82 } |
83 | 83 |
84 switch (decoding_status_) { | 84 switch (decoding_status_) { |
85 case DECODING_IN_PROGRESS: { | 85 case DECODING_IN_PROGRESS: { |
86 if (output_bytes_) | 86 if (output_bytes_) |
87 UMA_HISTOGRAM_PERCENTAGE("Sdch3.Network_Decode_Ratio_a", | 87 UMA_HISTOGRAM_PERCENTAGE("Sdch3.Network_Decode_Ratio_a", |
88 static_cast<int>( | 88 static_cast<int>( |
89 (filter_context_.GetByteReadCount() * 100) / output_bytes_)); | 89 (filter_context_.GetByteReadCount() * 100) / output_bytes_)); |
90 UMA_HISTOGRAM_COUNTS("Sdch3.Network_Decode_Bytes_VcdiffOut_a", | 90 UMA_HISTOGRAM_COUNTS("Sdch3.Network_Decode_Bytes_VcdiffOut_a", |
91 output_bytes_); | 91 output_bytes_); |
92 filter_context_.RecordPacketStats(FilterContext::SDCH_DECODE); | 92 filter_context_.RecordPacketStats(FilterContext::SDCH_DECODE); |
93 | 93 |
94 // Allow latency experiments to proceed. | 94 // Allow latency experiments to proceed. |
95 url_request_context_->sdch_manager()->SetAllowLatencyExperiment( | 95 GetSdchManager()->SetAllowLatencyExperiment(url_, true); |
96 url_, true); | |
97 return; | 96 return; |
98 } | 97 } |
99 case PASS_THROUGH: { | 98 case PASS_THROUGH: { |
100 filter_context_.RecordPacketStats(FilterContext::SDCH_PASSTHROUGH); | 99 filter_context_.RecordPacketStats(FilterContext::SDCH_PASSTHROUGH); |
101 return; | 100 return; |
102 } | 101 } |
103 case DECODING_UNINITIALIZED: { | 102 case DECODING_UNINITIALIZED: { |
104 SdchManager::SdchErrorRecovery(SdchManager::UNINITIALIZED); | 103 filter_context_.LogSdchProblem(SdchManager::UNINITIALIZED); |
105 return; | 104 return; |
106 } | 105 } |
107 case WAITING_FOR_DICTIONARY_SELECTION: { | 106 case WAITING_FOR_DICTIONARY_SELECTION: { |
108 SdchManager::SdchErrorRecovery(SdchManager::PRIOR_TO_DICTIONARY); | 107 filter_context_.LogSdchProblem(SdchManager::PRIOR_TO_DICTIONARY); |
109 return; | 108 return; |
110 } | 109 } |
111 case DECODING_ERROR: { | 110 case DECODING_ERROR: { |
112 SdchManager::SdchErrorRecovery(SdchManager::DECODE_ERROR); | 111 filter_context_.LogSdchProblem(SdchManager::DECODE_ERROR); |
113 return; | 112 return; |
114 } | 113 } |
115 case META_REFRESH_RECOVERY: { | 114 case META_REFRESH_RECOVERY: { |
116 // Already accounted for when set. | 115 // Already accounted for when set. |
117 return; | 116 return; |
118 } | 117 } |
119 } // end of switch. | 118 } // end of switch. |
120 } | 119 } |
121 | 120 |
122 bool SdchFilter::InitDecoding(Filter::FilterType filter_type) { | 121 bool SdchFilter::InitDecoding(Filter::FilterType filter_type) { |
(...skipping 45 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
168 // we may even issue a "meta-refresh" to reload the page without an SDCH | 167 // we may even issue a "meta-refresh" to reload the page without an SDCH |
169 // advertisement (so that we are sure we're not hurting anything). | 168 // advertisement (so that we are sure we're not hurting anything). |
170 // | 169 // |
171 // Watch out for an error page inserted by the proxy as part of a 40x | 170 // Watch out for an error page inserted by the proxy as part of a 40x |
172 // error response. When we see such content molestation, we certainly | 171 // error response. When we see such content molestation, we certainly |
173 // need to fall into the meta-refresh case. | 172 // need to fall into the meta-refresh case. |
174 if (filter_context_.GetResponseCode() == 404) { | 173 if (filter_context_.GetResponseCode() == 404) { |
175 // We could be more generous, but for now, only a "NOT FOUND" code will | 174 // We could be more generous, but for now, only a "NOT FOUND" code will |
176 // cause a pass through. All other bad codes will fall into a | 175 // cause a pass through. All other bad codes will fall into a |
177 // meta-refresh. | 176 // meta-refresh. |
178 SdchManager::SdchErrorRecovery(SdchManager::PASS_THROUGH_404_CODE); | 177 filter_context_.LogSdchProblem(SdchManager::PASS_THROUGH_404_CODE); |
179 decoding_status_ = PASS_THROUGH; | 178 decoding_status_ = PASS_THROUGH; |
180 } else if (filter_context_.GetResponseCode() != 200) { | 179 } else if (filter_context_.GetResponseCode() != 200) { |
181 // We need to meta-refresh, with SDCH disabled. | 180 // We need to meta-refresh, with SDCH disabled. |
182 } else if (filter_context_.IsCachedContent() | 181 } else if (filter_context_.IsCachedContent() |
183 && !dictionary_hash_is_plausible_) { | 182 && !dictionary_hash_is_plausible_) { |
184 // We must have hit the back button, and gotten content that was fetched | 183 // We must have hit the back button, and gotten content that was fetched |
185 // before we *really* advertised SDCH and a dictionary. | 184 // before we *really* advertised SDCH and a dictionary. |
186 SdchManager::SdchErrorRecovery(SdchManager::PASS_THROUGH_OLD_CACHED); | 185 filter_context_.LogSdchProblem(SdchManager::PASS_THROUGH_OLD_CACHED); |
187 decoding_status_ = PASS_THROUGH; | 186 decoding_status_ = PASS_THROUGH; |
188 } else if (possible_pass_through_) { | 187 } else if (possible_pass_through_) { |
189 // This is the potentially most graceful response. There really was no | 188 // This is the potentially most graceful response. There really was no |
190 // error. We were just overly cautious when we added a TENTATIVE_SDCH. | 189 // error. We were just overly cautious when we added a TENTATIVE_SDCH. |
191 // We added the sdch coding tag, and it should not have been added. | 190 // We added the sdch coding tag, and it should not have been added. |
192 // This can happen in server experiments, where the server decides | 191 // This can happen in server experiments, where the server decides |
193 // not to use sdch, even though there is a dictionary. To be | 192 // not to use sdch, even though there is a dictionary. To be |
194 // conservative, we locally added the tentative sdch (fearing that a | 193 // conservative, we locally added the tentative sdch (fearing that a |
195 // proxy stripped it!) and we must now recant (pass through). | 194 // proxy stripped it!) and we must now recant (pass through). |
196 SdchManager::SdchErrorRecovery(SdchManager::DISCARD_TENTATIVE_SDCH); | 195 filter_context_.LogSdchProblem(SdchManager::DISCARD_TENTATIVE_SDCH); |
197 // However.... just to be sure we don't get burned by proxies that | 196 // However.... just to be sure we don't get burned by proxies that |
198 // re-compress with gzip or other system, we can sniff to see if this | 197 // re-compress with gzip or other system, we can sniff to see if this |
199 // is compressed data etc. For now, we do nothing, which gets us into | 198 // is compressed data etc. For now, we do nothing, which gets us into |
200 // the meta-refresh result. | 199 // the meta-refresh result. |
201 // TODO(jar): Improve robustness by sniffing for valid text that we can | 200 // TODO(jar): Improve robustness by sniffing for valid text that we can |
202 // actual use re: decoding_status_ = PASS_THROUGH; | 201 // actual use re: decoding_status_ = PASS_THROUGH; |
203 } else if (dictionary_hash_is_plausible_) { | 202 } else if (dictionary_hash_is_plausible_) { |
204 // We need a meta-refresh since we don't have the dictionary. | 203 // We need a meta-refresh since we don't have the dictionary. |
205 // The common cause is a restart of the browser, where we try to render | 204 // The common cause is a restart of the browser, where we try to render |
206 // cached content that was saved when we had a dictionary. | 205 // cached content that was saved when we had a dictionary. |
207 } else if (filter_context_.IsSdchResponse()) { | 206 } else if (filter_context_.IsSdchResponse()) { |
208 // This is a very corrupt SDCH request response. We can't decode it. | 207 // This is a very corrupt SDCH request response. We can't decode it. |
209 // We'll use a meta-refresh, and get content without asking for SDCH. | 208 // We'll use a meta-refresh, and get content without asking for SDCH. |
210 // This will also progressively disable SDCH for this domain. | 209 // This will also progressively disable SDCH for this domain. |
211 } else { | 210 } else { |
212 // One of the first 9 bytes precluded consideration as a hash. | 211 // One of the first 9 bytes precluded consideration as a hash. |
213 // This can't be an SDCH payload, even though the server said it was. | 212 // This can't be an SDCH payload, even though the server said it was. |
214 // This is a major error, as the server or proxy tagged this SDCH even | 213 // This is a major error, as the server or proxy tagged this SDCH even |
215 // though it is not! | 214 // though it is not! |
216 // Meta-refresh won't help, as we didn't advertise an SDCH dictionary!! | 215 // Meta-refresh won't help, as we didn't advertise an SDCH dictionary!! |
217 // Worse yet, meta-refresh could lead to an infinite refresh loop. | 216 // Worse yet, meta-refresh could lead to an infinite refresh loop. |
218 SdchManager::SdchErrorRecovery(SdchManager::PASSING_THROUGH_NON_SDCH); | 217 filter_context_.LogSdchProblem(SdchManager::PASSING_THROUGH_NON_SDCH); |
219 decoding_status_ = PASS_THROUGH; | 218 decoding_status_ = PASS_THROUGH; |
220 // ... but further back-off on advertising SDCH support. | 219 // ... but further back-off on advertising SDCH support. |
221 url_request_context_->sdch_manager()->BlacklistDomain(url_); | 220 url_request_context_->sdch_manager()->BlacklistDomain(url_); |
222 } | 221 } |
223 | 222 |
224 if (decoding_status_ == PASS_THROUGH) { | 223 if (decoding_status_ == PASS_THROUGH) { |
225 dest_buffer_excess_ = dictionary_hash_; // Send what we scanned. | 224 dest_buffer_excess_ = dictionary_hash_; // Send what we scanned. |
226 } else { | 225 } else { |
227 // This is where we try to do the expensive meta-refresh. | 226 // This is where we try to do the expensive meta-refresh. |
228 if (std::string::npos == mime_type_.find("text/html")) { | 227 if (std::string::npos == mime_type_.find("text/html")) { |
229 // Since we can't do a meta-refresh (along with an exponential | 228 // Since we can't do a meta-refresh (along with an exponential |
230 // backoff), we'll just make sure this NEVER happens again. | 229 // backoff), we'll just make sure this NEVER happens again. |
231 url_request_context_->sdch_manager()->BlacklistDomainForever(url_); | 230 url_request_context_->sdch_manager()->BlacklistDomainForever(url_); |
232 if (filter_context_.IsCachedContent()) | 231 if (filter_context_.IsCachedContent()) |
233 SdchManager::SdchErrorRecovery( | 232 filter_context_.LogSdchProblem( |
234 SdchManager::CACHED_META_REFRESH_UNSUPPORTED); | 233 SdchManager::CACHED_META_REFRESH_UNSUPPORTED); |
235 else | 234 else |
236 SdchManager::SdchErrorRecovery( | 235 filter_context_.LogSdchProblem( |
237 SdchManager::META_REFRESH_UNSUPPORTED); | 236 SdchManager::META_REFRESH_UNSUPPORTED); |
238 return FILTER_ERROR; | 237 return FILTER_ERROR; |
239 } | 238 } |
240 // HTML content means we can issue a meta-refresh, and get the content | 239 // HTML content means we can issue a meta-refresh, and get the content |
241 // again, perhaps without SDCH (to be safe). | 240 // again, perhaps without SDCH (to be safe). |
242 if (filter_context_.IsCachedContent()) { | 241 if (filter_context_.IsCachedContent()) { |
243 // Cached content is probably a startup tab, so we'll just get fresh | 242 // Cached content is probably a startup tab, so we'll just get fresh |
244 // content and try again, without disabling sdch. | 243 // content and try again, without disabling sdch. |
245 SdchManager::SdchErrorRecovery( | 244 filter_context_.LogSdchProblem( |
246 SdchManager::META_REFRESH_CACHED_RECOVERY); | 245 SdchManager::META_REFRESH_CACHED_RECOVERY); |
247 } else { | 246 } else { |
248 // Since it wasn't in the cache, we definately need at least some | 247 // Since it wasn't in the cache, we definately need at least some |
249 // period of blacklisting to get the correct content. | 248 // period of blacklisting to get the correct content. |
250 url_request_context_->sdch_manager()->BlacklistDomain(url_); | 249 url_request_context_->sdch_manager()->BlacklistDomain(url_); |
251 SdchManager::SdchErrorRecovery(SdchManager::META_REFRESH_RECOVERY); | 250 filter_context_.LogSdchProblem(SdchManager::META_REFRESH_RECOVERY); |
252 } | 251 } |
253 decoding_status_ = META_REFRESH_RECOVERY; | 252 decoding_status_ = META_REFRESH_RECOVERY; |
254 // Issue a meta redirect with SDCH disabled. | 253 // Issue a meta redirect with SDCH disabled. |
255 dest_buffer_excess_ = kDecompressionErrorHtml; | 254 dest_buffer_excess_ = kDecompressionErrorHtml; |
256 } | 255 } |
257 } else { | 256 } else { |
258 DCHECK_EQ(DECODING_IN_PROGRESS, decoding_status_); | 257 DCHECK_EQ(DECODING_IN_PROGRESS, decoding_status_); |
259 } | 258 } |
260 } | 259 } |
261 | 260 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
295 bool ret = vcdiff_streaming_decoder_->DecodeChunk( | 294 bool ret = vcdiff_streaming_decoder_->DecodeChunk( |
296 next_stream_data_, stream_data_len_, &dest_buffer_excess_); | 295 next_stream_data_, stream_data_len_, &dest_buffer_excess_); |
297 // Assume all data was used in decoding. | 296 // Assume all data was used in decoding. |
298 next_stream_data_ = NULL; | 297 next_stream_data_ = NULL; |
299 source_bytes_ += stream_data_len_; | 298 source_bytes_ += stream_data_len_; |
300 stream_data_len_ = 0; | 299 stream_data_len_ = 0; |
301 output_bytes_ += dest_buffer_excess_.size(); | 300 output_bytes_ += dest_buffer_excess_.size(); |
302 if (!ret) { | 301 if (!ret) { |
303 vcdiff_streaming_decoder_.reset(NULL); // Don't call it again. | 302 vcdiff_streaming_decoder_.reset(NULL); // Don't call it again. |
304 decoding_status_ = DECODING_ERROR; | 303 decoding_status_ = DECODING_ERROR; |
305 SdchManager::SdchErrorRecovery(SdchManager::DECODE_BODY_ERROR); | 304 filter_context_.LogSdchProblem(SdchManager::DECODE_BODY_ERROR); |
306 return FILTER_ERROR; | 305 return FILTER_ERROR; |
307 } | 306 } |
308 | 307 |
309 amount = OutputBufferExcess(dest_buffer, available_space); | 308 amount = OutputBufferExcess(dest_buffer, available_space); |
310 *dest_len += amount; | 309 *dest_len += amount; |
311 dest_buffer += amount; | 310 dest_buffer += amount; |
312 available_space -= amount; | 311 available_space -= amount; |
313 if (0 == available_space && !dest_buffer_excess_.empty()) | 312 if (0 == available_space && !dest_buffer_excess_.empty()) |
314 return FILTER_OK; | 313 return FILTER_OK; |
315 return FILTER_NEED_MORE_DATA; | 314 return FILTER_NEED_MORE_DATA; |
(...skipping 18 matching lines...) Expand all Loading... |
334 if (stream_data_len_ > 0) | 333 if (stream_data_len_ > 0) |
335 next_stream_data_ += bytes_needed; | 334 next_stream_data_ += bytes_needed; |
336 else | 335 else |
337 next_stream_data_ = NULL; | 336 next_stream_data_ = NULL; |
338 | 337 |
339 DCHECK(!dictionary_); | 338 DCHECK(!dictionary_); |
340 dictionary_hash_is_plausible_ = true; // Assume plausible, but check. | 339 dictionary_hash_is_plausible_ = true; // Assume plausible, but check. |
341 | 340 |
342 if ('\0' == dictionary_hash_[kServerIdLength - 1]) { | 341 if ('\0' == dictionary_hash_[kServerIdLength - 1]) { |
343 SdchManager* manager(url_request_context_->sdch_manager()); | 342 SdchManager* manager(url_request_context_->sdch_manager()); |
344 manager->GetVcdiffDictionary( | 343 SdchManager::ProblemCodes rv = manager->GetVcdiffDictionary( |
345 std::string(dictionary_hash_, 0, kServerIdLength - 1), | 344 std::string(dictionary_hash_, 0, kServerIdLength - 1), |
346 url_, &dictionary_); | 345 url_, |
| 346 &dictionary_); |
| 347 if (rv != SdchManager::PROBLEM_CODE_OK) |
| 348 filter_context_.LogSdchProblem(rv); |
347 } else { | 349 } else { |
348 dictionary_hash_is_plausible_ = false; | 350 dictionary_hash_is_plausible_ = false; |
349 } | 351 } |
350 | 352 |
351 if (!dictionary_) { | 353 if (!dictionary_) { |
352 DCHECK(dictionary_hash_.size() == kServerIdLength); | 354 DCHECK(dictionary_hash_.size() == kServerIdLength); |
353 // Since dictionary was not found, check to see if hash was even plausible. | 355 // Since dictionary was not found, check to see if hash was even plausible. |
354 for (size_t i = 0; i < kServerIdLength - 1; ++i) { | 356 for (size_t i = 0; i < kServerIdLength - 1; ++i) { |
355 char base64_char = dictionary_hash_[i]; | 357 char base64_char = dictionary_hash_[i]; |
356 if (!isalnum(base64_char) && '-' != base64_char && '_' != base64_char) { | 358 if (!isalnum(base64_char) && '-' != base64_char && '_' != base64_char) { |
357 dictionary_hash_is_plausible_ = false; | 359 dictionary_hash_is_plausible_ = false; |
358 break; | 360 break; |
359 } | 361 } |
360 } | 362 } |
361 if (dictionary_hash_is_plausible_) | 363 if (dictionary_hash_is_plausible_) |
362 SdchManager::SdchErrorRecovery(SdchManager::DICTIONARY_HASH_NOT_FOUND); | 364 filter_context_.LogSdchProblem(SdchManager::DICTIONARY_HASH_NOT_FOUND); |
363 else | 365 else |
364 SdchManager::SdchErrorRecovery(SdchManager::DICTIONARY_HASH_MALFORMED); | 366 filter_context_.LogSdchProblem(SdchManager::DICTIONARY_HASH_MALFORMED); |
365 decoding_status_ = DECODING_ERROR; | 367 decoding_status_ = DECODING_ERROR; |
366 return FILTER_ERROR; | 368 return FILTER_ERROR; |
367 } | 369 } |
368 vcdiff_streaming_decoder_.reset(new open_vcdiff::VCDiffStreamingDecoder); | 370 vcdiff_streaming_decoder_.reset(new open_vcdiff::VCDiffStreamingDecoder); |
369 vcdiff_streaming_decoder_->SetAllowVcdTarget(false); | 371 vcdiff_streaming_decoder_->SetAllowVcdTarget(false); |
370 vcdiff_streaming_decoder_->StartDecoding(dictionary_->text().data(), | 372 vcdiff_streaming_decoder_->StartDecoding(dictionary_->text().data(), |
371 dictionary_->text().size()); | 373 dictionary_->text().size()); |
372 decoding_status_ = DECODING_IN_PROGRESS; | 374 decoding_status_ = DECODING_IN_PROGRESS; |
373 return FILTER_OK; | 375 return FILTER_OK; |
374 } | 376 } |
375 | 377 |
376 int SdchFilter::OutputBufferExcess(char* const dest_buffer, | 378 int SdchFilter::OutputBufferExcess(char* const dest_buffer, |
377 size_t available_space) { | 379 size_t available_space) { |
378 if (dest_buffer_excess_.empty()) | 380 if (dest_buffer_excess_.empty()) |
379 return 0; | 381 return 0; |
380 DCHECK(dest_buffer_excess_.size() > dest_buffer_excess_index_); | 382 DCHECK(dest_buffer_excess_.size() > dest_buffer_excess_index_); |
381 size_t amount = std::min(available_space, | 383 size_t amount = std::min(available_space, |
382 dest_buffer_excess_.size() - dest_buffer_excess_index_); | 384 dest_buffer_excess_.size() - dest_buffer_excess_index_); |
383 memcpy(dest_buffer, dest_buffer_excess_.data() + dest_buffer_excess_index_, | 385 memcpy(dest_buffer, dest_buffer_excess_.data() + dest_buffer_excess_index_, |
384 amount); | 386 amount); |
385 dest_buffer_excess_index_ += amount; | 387 dest_buffer_excess_index_ += amount; |
386 if (dest_buffer_excess_.size() <= dest_buffer_excess_index_) { | 388 if (dest_buffer_excess_.size() <= dest_buffer_excess_index_) { |
387 DCHECK(dest_buffer_excess_.size() == dest_buffer_excess_index_); | 389 DCHECK(dest_buffer_excess_.size() == dest_buffer_excess_index_); |
388 dest_buffer_excess_.clear(); | 390 dest_buffer_excess_.clear(); |
389 dest_buffer_excess_index_ = 0; | 391 dest_buffer_excess_index_ = 0; |
390 } | 392 } |
391 return amount; | 393 return amount; |
392 } | 394 } |
393 | 395 |
| 396 SdchManager* SdchFilter::GetSdchManager() const { |
| 397 return url_request_context_->sdch_manager(); |
| 398 } |
| 399 |
394 } // namespace net | 400 } // namespace net |
OLD | NEW |