net/filter/sdch_filter.cc - Issue 1662763002: [ON HOLD] Implement pull-based design for content decoding

Unified Diff: net/filter/sdch_filter.cc

Issue 1662763002: [ON HOLD] Implement pull-based design for content decoding (Closed) Base URL: https://chromium.googlesource.com/chromium/src.git@master

Patch Set: add filter_source_stream_unittest.cc and address other comments Created 4 years, 4 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View side-by-side diff with in-line comments

Download patch

Index: net/filter/sdch_filter.cc

diff --git a/net/filter/sdch_filter.cc b/net/filter/sdch_filter.cc

deleted file mode 100644

index 85be8905fa76cb179dbbcfb3b629a9b6e48b381a..0000000000000000000000000000000000000000

--- a/net/filter/sdch_filter.cc

+++ /dev/null

@@ -1,568 +0,0 @@

-// Use of this source code is governed by a BSD-style license that can be

-// found in the LICENSE file.

-#include "net/filter/sdch_filter.h"

-#include <ctype.h>

-#include <limits.h>

-#include <algorithm>

-#include <utility>

-#include "base/logging.h"

-#include "base/metrics/histogram_macros.h"

-#include "base/values.h"

-#include "net/base/sdch_manager.h"

-#include "net/base/sdch_net_log_params.h"

-#include "net/base/sdch_problem_codes.h"

-#include "net/url_request/url_request_context.h"

-#include "sdch/open-vcdiff/src/google/vcdecoder.h"

-namespace net {

-namespace {

-const size_t kServerIdLength = 9; // Dictionary hash plus null from server.

-// Disambiguate various types of responses that trigger a meta-refresh,

-// failure, or fallback to pass-through.

-enum ResponseCorruptionDetectionCause {

- RESPONSE_NONE,

- // 404 Http Response Code

- RESPONSE_404 = 1,

- // Not a 200 Http Response Code

- RESPONSE_NOT_200 = 2,

- // Cached before dictionary retrieved.

- RESPONSE_OLD_UNENCODED = 3,

- // Speculative but incorrect SDCH filtering was added added.

- RESPONSE_TENTATIVE_SDCH = 4,

- // Missing correct dict for decoding.

- RESPONSE_NO_DICTIONARY = 5,

- // Not an SDCH response but should be.

- RESPONSE_CORRUPT_SDCH = 6,

- // No dictionary was advertised with the request, the server claims

- // to have encoded with SDCH anyway, but it isn't an SDCH response.

- RESPONSE_ENCODING_LIE = 7,

- RESPONSE_MAX,

-};

-const char* ResponseCorruptionDetectionCauseToString(

- ResponseCorruptionDetectionCause cause) {

- const char* cause_string = "<unknown>";

- switch (cause) {

- case RESPONSE_NONE:

- cause_string = "NONE";

- break;

- case RESPONSE_404:

- cause_string = "404";

- break;

- case RESPONSE_NOT_200:

- cause_string = "NOT_200";

- break;

- case RESPONSE_OLD_UNENCODED:

- cause_string = "OLD_UNENCODED";

- break;

- case RESPONSE_TENTATIVE_SDCH:

- cause_string = "TENTATIVE_SDCH";

- break;

- case RESPONSE_NO_DICTIONARY:

- cause_string = "NO_DICTIONARY";

- break;

- case RESPONSE_CORRUPT_SDCH:

- cause_string = "CORRUPT_SDCH";

- break;

- case RESPONSE_ENCODING_LIE:

- cause_string = "ENCODING_LIE";

- break;

- case RESPONSE_MAX:

- cause_string = "<Error: max enum value>";

- break;

- }

- return cause_string;

-std::unique_ptr<base::Value> NetLogSdchResponseCorruptionDetectionCallback(

- ResponseCorruptionDetectionCause cause,

- bool cached,

- NetLogCaptureMode capture_mode) {

- std::unique_ptr<base::DictionaryValue> dict(new base::DictionaryValue());

- dict->SetString("cause", ResponseCorruptionDetectionCauseToString(cause));

- dict->SetBoolean("cached", cached);

- return std::move(dict);

-} // namespace

-SdchFilter::SdchFilter(FilterType type, const FilterContext& filter_context)

- : Filter(type),

- filter_context_(filter_context),

- decoding_status_(DECODING_UNINITIALIZED),

- dictionary_hash_(),

- dictionary_hash_is_plausible_(false),

- url_request_context_(filter_context.GetURLRequestContext()),

- dest_buffer_excess_(),

- dest_buffer_excess_index_(0),

- source_bytes_(0),

- output_bytes_(0),

- possible_pass_through_(false) {

- bool success = filter_context.GetMimeType(&mime_type_);

- DCHECK(success);

- success = filter_context.GetURL(&url_);

- DCHECK(success);

- DCHECK(url_request_context_->sdch_manager());

-SdchFilter::~SdchFilter() {

- // All code here is for gathering stats, and can be removed when SDCH is

- // considered stable.

- // References to filter_context_ and vcdiff_streaming_decoder_ (which

- // contains a reference to the dictionary text) are safe because

- // ~URLRequestHttpJob calls URLRequestJob::DestroyFilters, destroying

- // this object before the filter context in URLRequestHttpJob and its

- // members go out of scope.

- static int filter_use_count = 0;

- ++filter_use_count;

- if (META_REFRESH_RECOVERY == decoding_status_) {

- UMA_HISTOGRAM_COUNTS("Sdch3.FilterUseBeforeDisabling", filter_use_count);

- }

- if (vcdiff_streaming_decoder_.get()) {

- if (!vcdiff_streaming_decoder_->FinishDecoding()) {

- decoding_status_ = DECODING_ERROR;

- LogSdchProblem(SDCH_INCOMPLETE_SDCH_CONTENT);

- // Make it possible for the user to hit reload, and get non-sdch content.

- // Note this will "wear off" quickly enough, and is just meant to assure

- // in some rare case that the user is not stuck.

- url_request_context_->sdch_manager()->BlacklistDomain(

- url_, SDCH_INCOMPLETE_SDCH_CONTENT);

- UMA_HISTOGRAM_COUNTS("Sdch3.PartialBytesIn",

- static_cast<int>(filter_context_.GetByteReadCount()));

- UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffIn", source_bytes_);

- UMA_HISTOGRAM_COUNTS("Sdch3.PartialVcdiffOut", output_bytes_);

- }

- if (!dest_buffer_excess_.empty()) {

- // Filter chaining error, or premature teardown.

- LogSdchProblem(SDCH_UNFLUSHED_CONTENT);

- UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBytesIn",

- static_cast<int>(filter_context_.GetByteReadCount()));

- UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBufferSize",

- dest_buffer_excess_.size());

- UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffIn", source_bytes_);

- UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedVcdiffOut", output_bytes_);

- }

- if (filter_context_.IsCachedContent()) {

- // Not a real error, but it is useful to have this tally.

- // TODO(jar): Remove this stat after SDCH stability is validated.

- LogSdchProblem(SDCH_CACHE_DECODED);

- return; // We don't need timing stats, and we aready got ratios.

- }

- switch (decoding_status_) {

- case DECODING_IN_PROGRESS: {

- if (output_bytes_) {

- UMA_HISTOGRAM_PERCENTAGE("Sdch3.Network_Decode_Ratio_a",

- static_cast<int>(

- (filter_context_.GetByteReadCount() * 100) / output_bytes_));

- UMA_HISTOGRAM_COUNTS("Sdch3.NetworkBytesSavedByCompression",

- output_bytes_ - source_bytes_);

- }

- UMA_HISTOGRAM_COUNTS("Sdch3.Network_Decode_Bytes_VcdiffOut_a",

- output_bytes_);

- filter_context_.RecordPacketStats(FilterContext::SDCH_DECODE);

- // Allow latency experiments to proceed.

- url_request_context_->sdch_manager()->SetAllowLatencyExperiment(

- url_, true);

- // Notify successful dictionary usage.

- url_request_context_->sdch_manager()->OnDictionaryUsed(

- std::string(dictionary_hash_, 0, kServerIdLength - 1));

- return;

- }

- case PASS_THROUGH: {

- filter_context_.RecordPacketStats(FilterContext::SDCH_PASSTHROUGH);

- return;

- }

- case DECODING_UNINITIALIZED: {

- LogSdchProblem(SDCH_UNINITIALIZED);

- return;

- }

- case WAITING_FOR_DICTIONARY_SELECTION: {

- LogSdchProblem(SDCH_PRIOR_TO_DICTIONARY);

- return;

- }

- case DECODING_ERROR: {

- LogSdchProblem(SDCH_DECODE_ERROR);

- return;

- }

- case META_REFRESH_RECOVERY: {

- // Already accounted for when set.

- return;

- }

- } // end of switch.

-bool SdchFilter::InitDecoding(Filter::FilterType filter_type) {

- if (decoding_status_ != DECODING_UNINITIALIZED)

- return false;

- // Handle case where sdch filter is guessed, but not required.

- if (FILTER_TYPE_SDCH_POSSIBLE == filter_type)

- possible_pass_through_ = true;

- // Initialize decoder only after we have a dictionary in hand.

- decoding_status_ = WAITING_FOR_DICTIONARY_SELECTION;

- return true;

-#ifndef NDEBUG

-static const char* kDecompressionErrorHtml =

- "<head><META HTTP-EQUIV=\"Refresh\" CONTENT=\"0\"></head>"

- "<div style=\"position:fixed;top:0;left:0;width:100%;border-width:thin;"

- "border-color:black;border-style:solid;text-align:left;font-family:arial;"

- "font-size:10pt;foreground-color:black;background-color:white\">"

- "An error occurred. This page will be reloaded shortly. "

- "Or press the \"reload\" button now to reload it immediately."

- "</div>";

-#else

-static const char* kDecompressionErrorHtml =

- "<head><META HTTP-EQUIV=\"Refresh\" CONTENT=\"0\"></head>";

-#endif

-Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,

- int* dest_len) {

- int available_space = *dest_len;

- *dest_len = 0; // Nothing output yet.

- if (!dest_buffer || available_space <= 0)

- return FILTER_ERROR;

- if (WAITING_FOR_DICTIONARY_SELECTION == decoding_status_) {

- FilterStatus status = InitializeDictionary();

- if (FILTER_NEED_MORE_DATA == status)

- return FILTER_NEED_MORE_DATA;

- if (FILTER_ERROR == status) {

- DCHECK_EQ(DECODING_ERROR, decoding_status_);

- DCHECK_EQ(0u, dest_buffer_excess_index_);

- DCHECK(dest_buffer_excess_.empty());

- // This is where we try very hard to do error recovery, and make this

- // protocol robust in the face of proxies that do many different things.

- // If we decide that things are looking very bad (too hard to recover),

- // we may even issue a "meta-refresh" to reload the page without an SDCH

- // advertisement (so that we are sure we're not hurting anything).

- //

- // Watch out for an error page inserted by the proxy as part of a 40x

- // error response. When we see such content molestation, we certainly

- // need to fall into the meta-refresh case.

- ResponseCorruptionDetectionCause cause = RESPONSE_NONE;

- if (filter_context_.GetResponseCode() == 404) {

- // We could be more generous, but for now, only a "NOT FOUND" code will

- // cause a pass through. All other bad codes will fall into a

- // meta-refresh.

- LogSdchProblem(SDCH_PASS_THROUGH_404_CODE);

- cause = RESPONSE_404;

- decoding_status_ = PASS_THROUGH;

- } else if (filter_context_.GetResponseCode() != 200) {

- // We need to meta-refresh, with SDCH disabled.

- cause = RESPONSE_NOT_200;

- } else if (filter_context_.IsCachedContent()

- && !dictionary_hash_is_plausible_) {

- // We must have hit the back button, and gotten content that was fetched

- // before we *really* advertised SDCH and a dictionary.

- LogSdchProblem(SDCH_PASS_THROUGH_OLD_CACHED);

- decoding_status_ = PASS_THROUGH;

- cause = RESPONSE_OLD_UNENCODED;

- } else if (possible_pass_through_) {

- // This is the potentially most graceful response. There really was no

- // error. We were just overly cautious when we added a TENTATIVE_SDCH.

- // We added the sdch coding tag, and it should not have been added.

- // This can happen in server experiments, where the server decides

- // not to use sdch, even though there is a dictionary. To be

- // conservative, we locally added the tentative sdch (fearing that a

- // proxy stripped it!) and we must now recant (pass through).

- //

- // However.... just to be sure we don't get burned by proxies that

- // re-compress with gzip or other system, we can sniff to see if this

- // is compressed data etc. For now, we do nothing, which gets us into

- // the meta-refresh result.

- // TODO(jar): Improve robustness by sniffing for valid text that we can

- // actual use re: decoding_status_ = PASS_THROUGH;

- cause = RESPONSE_TENTATIVE_SDCH;

- } else if (dictionary_hash_is_plausible_) {

- // We need a meta-refresh since we don't have the dictionary.

- // The common cause is a restart of the browser, where we try to render

- // cached content that was saved when we had a dictionary.

- cause = RESPONSE_NO_DICTIONARY;

- } else if (filter_context_.SdchDictionariesAdvertised()) {

- // This is a very corrupt SDCH request response. We can't decode it.

- // We'll use a meta-refresh, and get content without asking for SDCH.

- // This will also progressively disable SDCH for this domain.

- cause = RESPONSE_CORRUPT_SDCH;

- } else {

- // One of the first 9 bytes precluded consideration as a hash.

- // This can't be an SDCH payload, even though the server said it was.

- // This is a major error, as the server or proxy tagged this SDCH even

- // though it is not!

- // Meta-refresh won't help, as we didn't advertise an SDCH dictionary!!

- // Worse yet, meta-refresh could lead to an infinite refresh loop.

- LogSdchProblem(SDCH_PASSING_THROUGH_NON_SDCH);

- decoding_status_ = PASS_THROUGH;

- // ... but further back-off on advertising SDCH support.

- url_request_context_->sdch_manager()->BlacklistDomain(

- url_, SDCH_PASSING_THROUGH_NON_SDCH);

- cause = RESPONSE_ENCODING_LIE;

- }

- DCHECK_NE(RESPONSE_NONE, cause);

- // Use if statement rather than ?: because UMA_HISTOGRAM_ENUMERATION

- // caches the histogram name based on the call site.

- if (filter_context_.IsCachedContent()) {

- UMA_HISTOGRAM_ENUMERATION(

- "Sdch3.ResponseCorruptionDetection.Cached", cause, RESPONSE_MAX);

- } else {

- UMA_HISTOGRAM_ENUMERATION(

- "Sdch3.ResponseCorruptionDetection.Uncached", cause, RESPONSE_MAX);

- }

- filter_context_.GetNetLog().AddEvent(

- NetLog::TYPE_SDCH_RESPONSE_CORRUPTION_DETECTION,

- base::Bind(&NetLogSdchResponseCorruptionDetectionCallback, cause,

- filter_context_.IsCachedContent()));

- if (decoding_status_ == PASS_THROUGH) {

- dest_buffer_excess_ = dictionary_hash_; // Send what we scanned.

- } else {

- // This is where we try to do the expensive meta-refresh.

- if (std::string::npos == mime_type_.find("text/html")) {

- // Since we can't do a meta-refresh (along with an exponential

- // backoff), we'll just make sure this NEVER happens again.

- SdchProblemCode problem = (filter_context_.IsCachedContent()

- ? SDCH_CACHED_META_REFRESH_UNSUPPORTED

- : SDCH_META_REFRESH_UNSUPPORTED);

- url_request_context_->sdch_manager()->BlacklistDomainForever(

- url_, problem);

- LogSdchProblem(problem);

- return FILTER_ERROR;

- }

- // HTML content means we can issue a meta-refresh, and get the content

- // again, perhaps without SDCH (to be safe).

- if (filter_context_.IsCachedContent()) {

- // Cached content is probably a startup tab, so we'll just get fresh

- // content and try again, without disabling sdch.

- LogSdchProblem(SDCH_META_REFRESH_CACHED_RECOVERY);

- } else {

- // Since it wasn't in the cache, we definately need at least some

- // period of blacklisting to get the correct content.

- url_request_context_->sdch_manager()->BlacklistDomain(

- url_, SDCH_META_REFRESH_RECOVERY);

- LogSdchProblem(SDCH_META_REFRESH_RECOVERY);

- }

- decoding_status_ = META_REFRESH_RECOVERY;

- // Issue a meta redirect with SDCH disabled.

- dest_buffer_excess_ = kDecompressionErrorHtml;

- }

- } else {

- DCHECK_EQ(DECODING_IN_PROGRESS, decoding_status_);

- }

- int amount = OutputBufferExcess(dest_buffer, available_space);

- *dest_len += amount;

- dest_buffer += amount;

- available_space -= amount;

- DCHECK_GE(available_space, 0);

- if (available_space <= 0)

- return FILTER_OK;

- DCHECK(dest_buffer_excess_.empty());

- DCHECK_EQ(0u, dest_buffer_excess_index_);

- if (decoding_status_ != DECODING_IN_PROGRESS) {

- if (META_REFRESH_RECOVERY == decoding_status_) {

- // Absorb all input data. We've already output page reload HTML.

- next_stream_data_ = NULL;

- stream_data_len_ = 0;

- return FILTER_NEED_MORE_DATA;

- }

- if (PASS_THROUGH == decoding_status_) {

- // We must pass in available_space, but it will be changed to bytes_used.

- FilterStatus result = CopyOut(dest_buffer, &available_space);

- // Accumulate the returned count of bytes_used (a.k.a., available_space).

- *dest_len += available_space;

- return result;

- }

- DCHECK(false);

- decoding_status_ = DECODING_ERROR;

- return FILTER_ERROR;

- }

- if (!next_stream_data_ || stream_data_len_ <= 0)

- return FILTER_NEED_MORE_DATA;

- // A note on accounting: DecodeChunk() appends to its output buffer, so any

- // preexisting data in |dest_buffer_excess_| could skew the value of

- // |output_bytes_|. However, OutputBufferExcess guarantees that it will

- // consume all of |dest_buffer_excess_| when called above unless the

- // destination buffer runs out of space, and if the destination buffer runs

- // out of space, this code returns FILTER_OK early above. Therefore, if

- // execution reaches this point, |dest_buffer_excess_| is empty, which is

- // DCHECKed above.

- bool ret = vcdiff_streaming_decoder_->DecodeChunk(

- next_stream_data_, stream_data_len_, &dest_buffer_excess_);

- // Assume all data was used in decoding.

- next_stream_data_ = NULL;

- source_bytes_ += stream_data_len_;

- stream_data_len_ = 0;

- output_bytes_ += dest_buffer_excess_.size();

- if (!ret) {

- vcdiff_streaming_decoder_.reset(NULL); // Don't call it again.

- decoding_status_ = DECODING_ERROR;

- LogSdchProblem(SDCH_DECODE_BODY_ERROR);

- return FILTER_ERROR;

- }

- amount = OutputBufferExcess(dest_buffer, available_space);

- *dest_len += amount;

- dest_buffer += amount;

- available_space -= amount;

- if (0 == available_space && !dest_buffer_excess_.empty())

- return FILTER_OK;

- return FILTER_NEED_MORE_DATA;

-Filter::FilterStatus SdchFilter::InitializeDictionary() {

- size_t bytes_needed = kServerIdLength - dictionary_hash_.size();

- DCHECK_GT(bytes_needed, 0u);

- if (!next_stream_data_)

- return FILTER_NEED_MORE_DATA;

- if (static_cast<size_t>(stream_data_len_) < bytes_needed) {

- dictionary_hash_.append(next_stream_data_, stream_data_len_);

- next_stream_data_ = NULL;

- stream_data_len_ = 0;

- return FILTER_NEED_MORE_DATA;

- }

- dictionary_hash_.append(next_stream_data_, bytes_needed);

- DCHECK(kServerIdLength == dictionary_hash_.size());

- stream_data_len_ -= bytes_needed;

- DCHECK_LE(0, stream_data_len_);

- if (stream_data_len_ > 0)

- next_stream_data_ += bytes_needed;

- else

- next_stream_data_ = NULL;

- const std::string* dictionary_text = nullptr;

- dictionary_hash_is_plausible_ = true; // Assume plausible, but check.

- SdchProblemCode rv = SDCH_OK;

- if ('\0' == dictionary_hash_[kServerIdLength - 1]) {

- std::string server_hash(dictionary_hash_, 0, kServerIdLength - 1);

- SdchManager::DictionarySet* handle =

- filter_context_.SdchDictionariesAdvertised();

- if (handle)

- dictionary_text = handle->GetDictionaryText(server_hash);

- if (!dictionary_text) {

- // This is a hack. Naively, the dictionaries available for

- // decoding should be only the ones advertised. However, there are

- // cases, specifically resources encoded with old dictionaries living

- // in the cache, that mean the full set of dictionaries should be made

- // available for decoding. It's not known how often this happens;

- // if it happens rarely enough, this code can be removed.

- //

- // TODO(rdsmith): Long-term, a better solution is necessary, since

- // an entry in the cache being encoded with the dictionary doesn't

- // guarantee that the dictionary is present. That solution probably

- // involves storing unencoded resources in the cache, but might

- // involve evicting encoded resources on dictionary removal.

- // See http://crbug.com/383405.

- unexpected_dictionary_handle_ =

- url_request_context_->sdch_manager()->GetDictionarySetByHash(

- url_, server_hash, &rv);

- if (unexpected_dictionary_handle_) {

- dictionary_text =

- unexpected_dictionary_handle_->GetDictionaryText(server_hash);

- // Override SDCH_OK rv; this is still worth logging.

- rv = (filter_context_.IsCachedContent() ?

- SDCH_UNADVERTISED_DICTIONARY_USED_CACHED :

- SDCH_UNADVERTISED_DICTIONARY_USED);

- } else {

- // Since dictionary was not found, check to see if hash was

- // even plausible.

- DCHECK(dictionary_hash_.size() == kServerIdLength);

- rv = SDCH_DICTIONARY_HASH_NOT_FOUND;

- for (size_t i = 0; i < kServerIdLength - 1; ++i) {

- char base64_char = dictionary_hash_[i];

- if (!isalnum(base64_char) &&

- '-' != base64_char && '_' != base64_char) {

- dictionary_hash_is_plausible_ = false;

- rv = SDCH_DICTIONARY_HASH_MALFORMED;

- break;

- }

- } else {

- dictionary_hash_is_plausible_ = false;

- rv = SDCH_DICTIONARY_HASH_MALFORMED;

- }

- if (rv != SDCH_OK)

- LogSdchProblem(rv);

- if (!dictionary_text) {

- decoding_status_ = DECODING_ERROR;

- return FILTER_ERROR;

- }

- vcdiff_streaming_decoder_.reset(new open_vcdiff::VCDiffStreamingDecoder);

- vcdiff_streaming_decoder_->SetAllowVcdTarget(false);

- // The validity of the dictionary_text pointer is guaranteed for the

- // lifetime of the SdchFilter by the ownership of the DictionarySet by

- // the FilterContext/URLRequestHttpJob. All URLRequestJob filters are

- // torn down in ~URLRequestHttpJob by a call to

- // URLRequestJob::DestroyFilters.

- vcdiff_streaming_decoder_->StartDecoding(dictionary_text->data(),

- dictionary_text->size());

- decoding_status_ = DECODING_IN_PROGRESS;

- return FILTER_OK;

-int SdchFilter::OutputBufferExcess(char* const dest_buffer,

- size_t available_space) {

- if (dest_buffer_excess_.empty())

- return 0;

- DCHECK(dest_buffer_excess_.size() > dest_buffer_excess_index_);

- size_t amount = std::min(available_space,

- dest_buffer_excess_.size() - dest_buffer_excess_index_);

- memcpy(dest_buffer, dest_buffer_excess_.data() + dest_buffer_excess_index_,

- amount);

- dest_buffer_excess_index_ += amount;

- if (dest_buffer_excess_.size() <= dest_buffer_excess_index_) {

- DCHECK(dest_buffer_excess_.size() == dest_buffer_excess_index_);

- dest_buffer_excess_.clear();

- dest_buffer_excess_index_ = 0;

- }

- return amount;

-void SdchFilter::LogSdchProblem(SdchProblemCode problem) {

- SdchManager::SdchErrorRecovery(problem);

- filter_context_.GetNetLog().AddEvent(

- NetLog::TYPE_SDCH_DECODING_ERROR,

- base::Bind(&NetLogSdchResourceProblemCallback, problem));

-} // namespace net

« net/filter/filter_source_stream.cc ('K') | « net/filter/sdch_filter.h ('k') | net/filter/sdch_filter_unittest.cc » ('j') | net/filter/source_stream.h » ('J')