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> |
11 | 11 |
12 #include "base/logging.h" | 12 #include "base/logging.h" |
13 #include "base/metrics/histogram.h" | 13 #include "base/metrics/histogram.h" |
14 #include "net/base/sdch_manager.h" | 14 #include "net/base/sdch_manager.h" |
15 #include "net/base/sdch_net_log_params.h" | |
15 #include "net/url_request/url_request_context.h" | 16 #include "net/url_request/url_request_context.h" |
16 | 17 |
17 #include "sdch/open-vcdiff/src/google/vcdecoder.h" | 18 #include "sdch/open-vcdiff/src/google/vcdecoder.h" |
18 | 19 |
19 namespace net { | 20 namespace net { |
20 | 21 |
21 namespace { | 22 namespace { |
22 | 23 |
23 // Disambiguate various types of responses that trigger a meta-refresh, | 24 // Disambiguate various types of responses that trigger a meta-refresh, |
24 // failure, or fallback to pass-through. | 25 // failure, or fallback to pass-through. |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
77 | 78 |
78 static int filter_use_count = 0; | 79 static int filter_use_count = 0; |
79 ++filter_use_count; | 80 ++filter_use_count; |
80 if (META_REFRESH_RECOVERY == decoding_status_) { | 81 if (META_REFRESH_RECOVERY == decoding_status_) { |
81 UMA_HISTOGRAM_COUNTS("Sdch3.FilterUseBeforeDisabling", filter_use_count); | 82 UMA_HISTOGRAM_COUNTS("Sdch3.FilterUseBeforeDisabling", filter_use_count); |
82 } | 83 } |
83 | 84 |
84 if (vcdiff_streaming_decoder_.get()) { | 85 if (vcdiff_streaming_decoder_.get()) { |
85 if (!vcdiff_streaming_decoder_->FinishDecoding()) { | 86 if (!vcdiff_streaming_decoder_->FinishDecoding()) { |
86 decoding_status_ = DECODING_ERROR; | 87 decoding_status_ = DECODING_ERROR; |
87 SdchManager::SdchErrorRecovery(SdchManager::INCOMPLETE_SDCH_CONTENT); | 88 LogSdchProblem(SDCH_INCOMPLETE_SDCH_CONTENT); |
88 // Make it possible for the user to hit reload, and get non-sdch content. | 89 // Make it possible for the user to hit reload, and get non-sdch content. |
89 // Note this will "wear off" quickly enough, and is just meant to assure | 90 // Note this will "wear off" quickly enough, and is just meant to assure |
90 // in some rare case that the user is not stuck. | 91 // in some rare case that the user is not stuck. |
91 url_request_context_->sdch_manager()->BlacklistDomain( | 92 url_request_context_->sdch_manager()->BlacklistDomain( |
92 url_, SdchManager::INCOMPLETE_SDCH_CONTENT); | 93 url_, SDCH_INCOMPLETE_SDCH_CONTENT); |
93 UMA_HISTOGRAM_COUNTS("Sdch3.PartialBytesIn", | 94 UMA_HISTOGRAM_COUNTS("Sdch3.PartialBytesIn", |
94 static_cast<int>(filter_context_.GetByteReadCount())); | 95 static_cast<int>(filter_context_.GetByteReadCount())); |
95 UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffIn", source_bytes_); | 96 UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffIn", source_bytes_); |
96 UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffOut", output_bytes_); | 97 UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffOut", output_bytes_); |
97 } | 98 } |
98 } | 99 } |
99 | 100 |
100 if (!dest_buffer_excess_.empty()) { | 101 if (!dest_buffer_excess_.empty()) { |
101 // Filter chaining error, or premature teardown. | 102 // Filter chaining error, or premature teardown. |
102 SdchManager::SdchErrorRecovery(SdchManager::UNFLUSHED_CONTENT); | 103 LogSdchProblem(SDCH_UNFLUSHED_CONTENT); |
103 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBytesIn", | 104 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBytesIn", |
104 static_cast<int>(filter_context_.GetByteReadCount())); | 105 static_cast<int>(filter_context_.GetByteReadCount())); |
105 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBufferSize", | 106 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBufferSize", |
106 dest_buffer_excess_.size()); | 107 dest_buffer_excess_.size()); |
107 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffIn", source_bytes_); | 108 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffIn", source_bytes_); |
108 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffOut", output_bytes_); | 109 UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffOut", output_bytes_); |
109 } | 110 } |
110 | 111 |
111 if (filter_context_.IsCachedContent()) { | 112 if (filter_context_.IsCachedContent()) { |
112 // Not a real error, but it is useful to have this tally. | 113 // Not a real error, but it is useful to have this tally. |
113 // TODO(jar): Remove this stat after SDCH stability is validated. | 114 // TODO(jar): Remove this stat after SDCH stability is validated. |
114 SdchManager::SdchErrorRecovery(SdchManager::CACHE_DECODED); | 115 LogSdchProblem(SDCH_CACHE_DECODED); |
115 return; // We don't need timing stats, and we aready got ratios. | 116 return; // We don't need timing stats, and we aready got ratios. |
116 } | 117 } |
117 | 118 |
118 switch (decoding_status_) { | 119 switch (decoding_status_) { |
119 case DECODING_IN_PROGRESS: { | 120 case DECODING_IN_PROGRESS: { |
120 if (output_bytes_) | 121 if (output_bytes_) |
121 UMA_HISTOGRAM_PERCENTAGE("Sdch3.Network_Decode_Ratio_a", | 122 UMA_HISTOGRAM_PERCENTAGE("Sdch3.Network_Decode_Ratio_a", |
122 static_cast<int>( | 123 static_cast<int>( |
123 (filter_context_.GetByteReadCount() * 100) / output_bytes_)); | 124 (filter_context_.GetByteReadCount() * 100) / output_bytes_)); |
124 UMA_HISTOGRAM_COUNTS("Sdch3.Network_Decode_Bytes_VcdiffOut_a", | 125 UMA_HISTOGRAM_COUNTS("Sdch3.Network_Decode_Bytes_VcdiffOut_a", |
125 output_bytes_); | 126 output_bytes_); |
126 filter_context_.RecordPacketStats(FilterContext::SDCH_DECODE); | 127 filter_context_.RecordPacketStats(FilterContext::SDCH_DECODE); |
127 | 128 |
128 // Allow latency experiments to proceed. | 129 // Allow latency experiments to proceed. |
129 url_request_context_->sdch_manager()->SetAllowLatencyExperiment( | 130 url_request_context_->sdch_manager()->SetAllowLatencyExperiment( |
130 url_, true); | 131 url_, true); |
131 return; | 132 return; |
132 } | 133 } |
133 case PASS_THROUGH: { | 134 case PASS_THROUGH: { |
134 filter_context_.RecordPacketStats(FilterContext::SDCH_PASSTHROUGH); | 135 filter_context_.RecordPacketStats(FilterContext::SDCH_PASSTHROUGH); |
135 return; | 136 return; |
136 } | 137 } |
137 case DECODING_UNINITIALIZED: { | 138 case DECODING_UNINITIALIZED: { |
138 SdchManager::SdchErrorRecovery(SdchManager::UNINITIALIZED); | 139 LogSdchProblem(SDCH_UNINITIALIZED); |
139 return; | 140 return; |
140 } | 141 } |
141 case WAITING_FOR_DICTIONARY_SELECTION: { | 142 case WAITING_FOR_DICTIONARY_SELECTION: { |
142 SdchManager::SdchErrorRecovery(SdchManager::PRIOR_TO_DICTIONARY); | 143 LogSdchProblem(SDCH_PRIOR_TO_DICTIONARY); |
143 return; | 144 return; |
144 } | 145 } |
145 case DECODING_ERROR: { | 146 case DECODING_ERROR: { |
146 SdchManager::SdchErrorRecovery(SdchManager::DECODE_ERROR); | 147 LogSdchProblem(SDCH_DECODE_ERROR); |
147 return; | 148 return; |
148 } | 149 } |
149 case META_REFRESH_RECOVERY: { | 150 case META_REFRESH_RECOVERY: { |
150 // Already accounted for when set. | 151 // Already accounted for when set. |
151 return; | 152 return; |
152 } | 153 } |
153 } // end of switch. | 154 } // end of switch. |
154 } | 155 } |
155 | 156 |
156 bool SdchFilter::InitDecoding(Filter::FilterType filter_type) { | 157 bool SdchFilter::InitDecoding(Filter::FilterType filter_type) { |
(...skipping 46 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
203 // advertisement (so that we are sure we're not hurting anything). | 204 // advertisement (so that we are sure we're not hurting anything). |
204 // | 205 // |
205 // Watch out for an error page inserted by the proxy as part of a 40x | 206 // Watch out for an error page inserted by the proxy as part of a 40x |
206 // error response. When we see such content molestation, we certainly | 207 // error response. When we see such content molestation, we certainly |
207 // need to fall into the meta-refresh case. | 208 // need to fall into the meta-refresh case. |
208 ResponseCorruptionDetectionCause cause = RESPONSE_NONE; | 209 ResponseCorruptionDetectionCause cause = RESPONSE_NONE; |
209 if (filter_context_.GetResponseCode() == 404) { | 210 if (filter_context_.GetResponseCode() == 404) { |
210 // We could be more generous, but for now, only a "NOT FOUND" code will | 211 // We could be more generous, but for now, only a "NOT FOUND" code will |
211 // cause a pass through. All other bad codes will fall into a | 212 // cause a pass through. All other bad codes will fall into a |
212 // meta-refresh. | 213 // meta-refresh. |
213 SdchManager::SdchErrorRecovery(SdchManager::PASS_THROUGH_404_CODE); | 214 LogSdchProblem(SDCH_PASS_THROUGH_404_CODE); |
214 cause = RESPONSE_404; | 215 cause = RESPONSE_404; |
215 decoding_status_ = PASS_THROUGH; | 216 decoding_status_ = PASS_THROUGH; |
216 } else if (filter_context_.GetResponseCode() != 200) { | 217 } else if (filter_context_.GetResponseCode() != 200) { |
217 // We need to meta-refresh, with SDCH disabled. | 218 // We need to meta-refresh, with SDCH disabled. |
218 cause = RESPONSE_NOT_200; | 219 cause = RESPONSE_NOT_200; |
219 } else if (filter_context_.IsCachedContent() | 220 } else if (filter_context_.IsCachedContent() |
220 && !dictionary_hash_is_plausible_) { | 221 && !dictionary_hash_is_plausible_) { |
221 // We must have hit the back button, and gotten content that was fetched | 222 // We must have hit the back button, and gotten content that was fetched |
222 // before we *really* advertised SDCH and a dictionary. | 223 // before we *really* advertised SDCH and a dictionary. |
223 SdchManager::SdchErrorRecovery(SdchManager::PASS_THROUGH_OLD_CACHED); | 224 LogSdchProblem(SDCH_PASS_THROUGH_OLD_CACHED); |
224 decoding_status_ = PASS_THROUGH; | 225 decoding_status_ = PASS_THROUGH; |
225 cause = RESPONSE_OLD_UNENCODED; | 226 cause = RESPONSE_OLD_UNENCODED; |
226 } else if (possible_pass_through_) { | 227 } else if (possible_pass_through_) { |
227 // This is the potentially most graceful response. There really was no | 228 // This is the potentially most graceful response. There really was no |
228 // error. We were just overly cautious when we added a TENTATIVE_SDCH. | 229 // error. We were just overly cautious when we added a TENTATIVE_SDCH. |
229 // We added the sdch coding tag, and it should not have been added. | 230 // We added the sdch coding tag, and it should not have been added. |
230 // This can happen in server experiments, where the server decides | 231 // This can happen in server experiments, where the server decides |
231 // not to use sdch, even though there is a dictionary. To be | 232 // not to use sdch, even though there is a dictionary. To be |
232 // conservative, we locally added the tentative sdch (fearing that a | 233 // conservative, we locally added the tentative sdch (fearing that a |
233 // proxy stripped it!) and we must now recant (pass through). | 234 // proxy stripped it!) and we must now recant (pass through). |
(...skipping 15 matching lines...) Expand all Loading... | |
249 // We'll use a meta-refresh, and get content without asking for SDCH. | 250 // We'll use a meta-refresh, and get content without asking for SDCH. |
250 // This will also progressively disable SDCH for this domain. | 251 // This will also progressively disable SDCH for this domain. |
251 cause = RESPONSE_CORRUPT_SDCH; | 252 cause = RESPONSE_CORRUPT_SDCH; |
252 } else { | 253 } else { |
253 // One of the first 9 bytes precluded consideration as a hash. | 254 // One of the first 9 bytes precluded consideration as a hash. |
254 // This can't be an SDCH payload, even though the server said it was. | 255 // This can't be an SDCH payload, even though the server said it was. |
255 // This is a major error, as the server or proxy tagged this SDCH even | 256 // This is a major error, as the server or proxy tagged this SDCH even |
256 // though it is not! | 257 // though it is not! |
257 // Meta-refresh won't help, as we didn't advertise an SDCH dictionary!! | 258 // Meta-refresh won't help, as we didn't advertise an SDCH dictionary!! |
258 // Worse yet, meta-refresh could lead to an infinite refresh loop. | 259 // Worse yet, meta-refresh could lead to an infinite refresh loop. |
259 SdchManager::SdchErrorRecovery(SdchManager::PASSING_THROUGH_NON_SDCH); | 260 LogSdchProblem(SDCH_PASSING_THROUGH_NON_SDCH); |
260 decoding_status_ = PASS_THROUGH; | 261 decoding_status_ = PASS_THROUGH; |
261 // ... but further back-off on advertising SDCH support. | 262 // ... but further back-off on advertising SDCH support. |
262 url_request_context_->sdch_manager()->BlacklistDomain( | 263 url_request_context_->sdch_manager()->BlacklistDomain( |
263 url_, SdchManager::PASSING_THROUGH_NON_SDCH); | 264 url_, SDCH_PASSING_THROUGH_NON_SDCH); |
264 cause = RESPONSE_ENCODING_LIE; | 265 cause = RESPONSE_ENCODING_LIE; |
265 } | 266 } |
266 DCHECK_NE(RESPONSE_NONE, cause); | 267 DCHECK_NE(RESPONSE_NONE, cause); |
267 | 268 |
268 // Use if statement rather than ?: because UMA_HISTOGRAM_ENUMERATION | 269 // Use if statement rather than ?: because UMA_HISTOGRAM_ENUMERATION |
269 // caches the histogram name based on the call site. | 270 // caches the histogram name based on the call site. |
270 if (filter_context_.IsCachedContent()) { | 271 if (filter_context_.IsCachedContent()) { |
271 UMA_HISTOGRAM_ENUMERATION( | 272 UMA_HISTOGRAM_ENUMERATION( |
272 "Sdch3.ResponseCorruptionDetection.Cached", cause, RESPONSE_MAX); | 273 "Sdch3.ResponseCorruptionDetection.Cached", cause, RESPONSE_MAX); |
273 } else { | 274 } else { |
274 UMA_HISTOGRAM_ENUMERATION( | 275 UMA_HISTOGRAM_ENUMERATION( |
275 "Sdch3.ResponseCorruptionDetection.Uncached", cause, RESPONSE_MAX); | 276 "Sdch3.ResponseCorruptionDetection.Uncached", cause, RESPONSE_MAX); |
276 } | 277 } |
277 | 278 |
278 if (decoding_status_ == PASS_THROUGH) { | 279 if (decoding_status_ == PASS_THROUGH) { |
279 dest_buffer_excess_ = dictionary_hash_; // Send what we scanned. | 280 dest_buffer_excess_ = dictionary_hash_; // Send what we scanned. |
280 } else { | 281 } else { |
281 // This is where we try to do the expensive meta-refresh. | 282 // This is where we try to do the expensive meta-refresh. |
282 if (std::string::npos == mime_type_.find("text/html")) { | 283 if (std::string::npos == mime_type_.find("text/html")) { |
283 // Since we can't do a meta-refresh (along with an exponential | 284 // Since we can't do a meta-refresh (along with an exponential |
284 // backoff), we'll just make sure this NEVER happens again. | 285 // backoff), we'll just make sure this NEVER happens again. |
285 SdchManager::ProblemCodes problem = | 286 SdchProblemCode problem = (filter_context_.IsCachedContent() |
286 (filter_context_.IsCachedContent() ? | 287 ? SDCH_CACHED_META_REFRESH_UNSUPPORTED |
287 SdchManager::CACHED_META_REFRESH_UNSUPPORTED : | 288 : SDCH_META_REFRESH_UNSUPPORTED); |
288 SdchManager::META_REFRESH_UNSUPPORTED); | |
289 url_request_context_->sdch_manager()->BlacklistDomainForever( | 289 url_request_context_->sdch_manager()->BlacklistDomainForever( |
290 url_, problem); | 290 url_, problem); |
291 SdchManager::SdchErrorRecovery(problem); | 291 LogSdchProblem(problem); |
292 return FILTER_ERROR; | 292 return FILTER_ERROR; |
293 } | 293 } |
294 // HTML content means we can issue a meta-refresh, and get the content | 294 // HTML content means we can issue a meta-refresh, and get the content |
295 // again, perhaps without SDCH (to be safe). | 295 // again, perhaps without SDCH (to be safe). |
296 if (filter_context_.IsCachedContent()) { | 296 if (filter_context_.IsCachedContent()) { |
297 // Cached content is probably a startup tab, so we'll just get fresh | 297 // Cached content is probably a startup tab, so we'll just get fresh |
298 // content and try again, without disabling sdch. | 298 // content and try again, without disabling sdch. |
299 SdchManager::SdchErrorRecovery( | 299 LogSdchProblem(SDCH_META_REFRESH_CACHED_RECOVERY); |
300 SdchManager::META_REFRESH_CACHED_RECOVERY); | |
301 } else { | 300 } else { |
302 // Since it wasn't in the cache, we definately need at least some | 301 // Since it wasn't in the cache, we definately need at least some |
303 // period of blacklisting to get the correct content. | 302 // period of blacklisting to get the correct content. |
304 url_request_context_->sdch_manager()->BlacklistDomain( | 303 url_request_context_->sdch_manager()->BlacklistDomain( |
305 url_, SdchManager::META_REFRESH_RECOVERY); | 304 url_, SDCH_META_REFRESH_RECOVERY); |
306 SdchManager::SdchErrorRecovery(SdchManager::META_REFRESH_RECOVERY); | 305 LogSdchProblem(SDCH_META_REFRESH_RECOVERY); |
307 } | 306 } |
308 decoding_status_ = META_REFRESH_RECOVERY; | 307 decoding_status_ = META_REFRESH_RECOVERY; |
309 // Issue a meta redirect with SDCH disabled. | 308 // Issue a meta redirect with SDCH disabled. |
310 dest_buffer_excess_ = kDecompressionErrorHtml; | 309 dest_buffer_excess_ = kDecompressionErrorHtml; |
311 } | 310 } |
312 } else { | 311 } else { |
313 DCHECK_EQ(DECODING_IN_PROGRESS, decoding_status_); | 312 DCHECK_EQ(DECODING_IN_PROGRESS, decoding_status_); |
314 } | 313 } |
315 } | 314 } |
316 | 315 |
(...skipping 33 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
350 bool ret = vcdiff_streaming_decoder_->DecodeChunk( | 349 bool ret = vcdiff_streaming_decoder_->DecodeChunk( |
351 next_stream_data_, stream_data_len_, &dest_buffer_excess_); | 350 next_stream_data_, stream_data_len_, &dest_buffer_excess_); |
352 // Assume all data was used in decoding. | 351 // Assume all data was used in decoding. |
353 next_stream_data_ = NULL; | 352 next_stream_data_ = NULL; |
354 source_bytes_ += stream_data_len_; | 353 source_bytes_ += stream_data_len_; |
355 stream_data_len_ = 0; | 354 stream_data_len_ = 0; |
356 output_bytes_ += dest_buffer_excess_.size(); | 355 output_bytes_ += dest_buffer_excess_.size(); |
357 if (!ret) { | 356 if (!ret) { |
358 vcdiff_streaming_decoder_.reset(NULL); // Don't call it again. | 357 vcdiff_streaming_decoder_.reset(NULL); // Don't call it again. |
359 decoding_status_ = DECODING_ERROR; | 358 decoding_status_ = DECODING_ERROR; |
360 SdchManager::SdchErrorRecovery(SdchManager::DECODE_BODY_ERROR); | 359 LogSdchProblem(SDCH_DECODE_BODY_ERROR); |
361 return FILTER_ERROR; | 360 return FILTER_ERROR; |
362 } | 361 } |
363 | 362 |
364 amount = OutputBufferExcess(dest_buffer, available_space); | 363 amount = OutputBufferExcess(dest_buffer, available_space); |
365 *dest_len += amount; | 364 *dest_len += amount; |
366 dest_buffer += amount; | 365 dest_buffer += amount; |
367 available_space -= amount; | 366 available_space -= amount; |
368 if (0 == available_space && !dest_buffer_excess_.empty()) | 367 if (0 == available_space && !dest_buffer_excess_.empty()) |
369 return FILTER_OK; | 368 return FILTER_OK; |
370 return FILTER_NEED_MORE_DATA; | 369 return FILTER_NEED_MORE_DATA; |
(...skipping 16 matching lines...) Expand all Loading... | |
387 stream_data_len_ -= bytes_needed; | 386 stream_data_len_ -= bytes_needed; |
388 DCHECK_LE(0, stream_data_len_); | 387 DCHECK_LE(0, stream_data_len_); |
389 if (stream_data_len_ > 0) | 388 if (stream_data_len_ > 0) |
390 next_stream_data_ += bytes_needed; | 389 next_stream_data_ += bytes_needed; |
391 else | 390 else |
392 next_stream_data_ = NULL; | 391 next_stream_data_ = NULL; |
393 | 392 |
394 DCHECK(!dictionary_.get()); | 393 DCHECK(!dictionary_.get()); |
395 dictionary_hash_is_plausible_ = true; // Assume plausible, but check. | 394 dictionary_hash_is_plausible_ = true; // Assume plausible, but check. |
396 | 395 |
396 SdchProblemCode rv = SDCH_OK; | |
397 if ('\0' == dictionary_hash_[kServerIdLength - 1]) { | 397 if ('\0' == dictionary_hash_[kServerIdLength - 1]) { |
398 SdchManager* manager(url_request_context_->sdch_manager()); | 398 SdchManager* manager(url_request_context_->sdch_manager()); |
399 manager->GetVcdiffDictionary( | 399 rv = manager->GetVcdiffDictionary( |
400 std::string(dictionary_hash_, 0, kServerIdLength - 1), | 400 std::string(dictionary_hash_, 0, kServerIdLength - 1), |
401 url_, &dictionary_); | 401 url_, |
402 &dictionary_); | |
403 if (rv != SDCH_OK) { | |
Randy Smith (Not in Mondays)
2014/10/31 19:05:35
I think you can skip this check; if rv == SDCH_DIC
baranovich
2014/10/31 19:55:33
True, but it may also be SDCH_DISABLED, SDCH_*_BLA
Randy Smith (Not in Mondays)
2014/11/03 21:01:27
Sorry, I may be being dense, but how does the effe
baranovich
2014/11/03 22:34:23
Got it finally, sorry for being so slow:) Done.
| |
404 if (rv == SDCH_DICTIONARY_HASH_NOT_FOUND) { | |
405 DCHECK(dictionary_hash_.size() == kServerIdLength); | |
406 // Since dictionary was not found, check to see if hash was even | |
407 // plausible. | |
408 for (size_t i = 0; i < kServerIdLength - 1; ++i) { | |
409 char base64_char = dictionary_hash_[i]; | |
410 if (!isalnum(base64_char) && '-' != base64_char && | |
411 '_' != base64_char) { | |
412 rv = SDCH_DICTIONARY_HASH_MALFORMED; | |
413 dictionary_hash_is_plausible_ = false; | |
414 break; | |
415 } | |
416 } | |
417 } | |
418 } | |
402 } else { | 419 } else { |
403 dictionary_hash_is_plausible_ = false; | 420 dictionary_hash_is_plausible_ = false; |
421 rv = SDCH_DICTIONARY_HASH_MALFORMED; | |
404 } | 422 } |
405 | 423 if (rv != SDCH_OK) { |
406 if (!dictionary_.get()) { | 424 LogSdchProblem(rv); |
407 DCHECK(dictionary_hash_.size() == kServerIdLength); | |
408 // Since dictionary was not found, check to see if hash was even plausible. | |
409 for (size_t i = 0; i < kServerIdLength - 1; ++i) { | |
410 char base64_char = dictionary_hash_[i]; | |
411 if (!isalnum(base64_char) && '-' != base64_char && '_' != base64_char) { | |
412 dictionary_hash_is_plausible_ = false; | |
413 break; | |
414 } | |
415 } | |
416 if (dictionary_hash_is_plausible_) | |
417 SdchManager::SdchErrorRecovery(SdchManager::DICTIONARY_HASH_NOT_FOUND); | |
418 else | |
419 SdchManager::SdchErrorRecovery(SdchManager::DICTIONARY_HASH_MALFORMED); | |
420 decoding_status_ = DECODING_ERROR; | 425 decoding_status_ = DECODING_ERROR; |
421 return FILTER_ERROR; | 426 return FILTER_ERROR; |
422 } | 427 } |
428 DCHECK(dictionary_.get()); | |
423 vcdiff_streaming_decoder_.reset(new open_vcdiff::VCDiffStreamingDecoder); | 429 vcdiff_streaming_decoder_.reset(new open_vcdiff::VCDiffStreamingDecoder); |
424 vcdiff_streaming_decoder_->SetAllowVcdTarget(false); | 430 vcdiff_streaming_decoder_->SetAllowVcdTarget(false); |
425 vcdiff_streaming_decoder_->StartDecoding(dictionary_->text().data(), | 431 vcdiff_streaming_decoder_->StartDecoding(dictionary_->text().data(), |
426 dictionary_->text().size()); | 432 dictionary_->text().size()); |
427 decoding_status_ = DECODING_IN_PROGRESS; | 433 decoding_status_ = DECODING_IN_PROGRESS; |
428 return FILTER_OK; | 434 return FILTER_OK; |
429 } | 435 } |
430 | 436 |
431 int SdchFilter::OutputBufferExcess(char* const dest_buffer, | 437 int SdchFilter::OutputBufferExcess(char* const dest_buffer, |
432 size_t available_space) { | 438 size_t available_space) { |
433 if (dest_buffer_excess_.empty()) | 439 if (dest_buffer_excess_.empty()) |
434 return 0; | 440 return 0; |
435 DCHECK(dest_buffer_excess_.size() > dest_buffer_excess_index_); | 441 DCHECK(dest_buffer_excess_.size() > dest_buffer_excess_index_); |
436 size_t amount = std::min(available_space, | 442 size_t amount = std::min(available_space, |
437 dest_buffer_excess_.size() - dest_buffer_excess_index_); | 443 dest_buffer_excess_.size() - dest_buffer_excess_index_); |
438 memcpy(dest_buffer, dest_buffer_excess_.data() + dest_buffer_excess_index_, | 444 memcpy(dest_buffer, dest_buffer_excess_.data() + dest_buffer_excess_index_, |
439 amount); | 445 amount); |
440 dest_buffer_excess_index_ += amount; | 446 dest_buffer_excess_index_ += amount; |
441 if (dest_buffer_excess_.size() <= dest_buffer_excess_index_) { | 447 if (dest_buffer_excess_.size() <= dest_buffer_excess_index_) { |
442 DCHECK(dest_buffer_excess_.size() == dest_buffer_excess_index_); | 448 DCHECK(dest_buffer_excess_.size() == dest_buffer_excess_index_); |
443 dest_buffer_excess_.clear(); | 449 dest_buffer_excess_.clear(); |
444 dest_buffer_excess_index_ = 0; | 450 dest_buffer_excess_index_ = 0; |
445 } | 451 } |
446 return amount; | 452 return amount; |
447 } | 453 } |
448 | 454 |
455 void SdchFilter::LogSdchProblem(SdchProblemCode problem) { | |
456 SdchManager::SdchErrorRecovery(problem); | |
457 filter_context_.GetNetLog().AddEvent( | |
458 NetLog::TYPE_SDCH_DECODING_ERROR, | |
459 base::Bind(&NetLogSdchResourceProblemCallback, problem)); | |
460 } | |
461 | |
449 } // namespace net | 462 } // namespace net |
OLD | NEW |