Use filter context to track stats better in SDCH filtering

net/base/filter.cc

 // Copyright (c) 2006-2008 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.
 
 #include "net/base/filter.h"
 
 #include "base/string_util.h"
 #include "net/base/gzip_filter.h"
 #include "net/base/bzip2_filter.h"
 #include "net/base/sdch_filter.h"
@@ skipping 20 matching lines @@
 const char kApplicationGzip[]      = "application/gzip";
 const char kApplicationXGunzip[]   = "application/x-gunzip";
 const char kApplicationXCompress[] = "application/x-compress";
 const char kApplicationCompress[]  = "application/compress";
 const char kTextHtml[]             = "text/html";
 
 }  // namespace
 
 Filter* Filter::Factory(const std::vector<FilterType>& filter_types,
                         const FilterContext& filter_context) {
-  DCHECK(filter_context.GetInputStreambufferSize() > 0);
-  if (filter_types.empty() || filter_context.GetInputStreambufferSize() <= 0)
+  DCHECK(filter_context.GetInputStreamBufferSize() > 0);
+  if (filter_types.empty() || filter_context.GetInputStreamBufferSize() <= 0)
     return NULL;
 
 
   Filter* filter_list = NULL;  // Linked list of filters.
   for (size_t i = 0; i < filter_types.size(); i++) {
     filter_list = PrependNewFilter(filter_types[i], filter_context,
                                    filter_list);
     if (!filter_list)
       return NULL;
   }
-
-  // TODO(jar): These settings should go into the derived classes, on an as-needed basis.
-  std::string mime_type;
-  bool success = filter_context.GetMimeType(&mime_type);
-  DCHECK(success);
-  GURL gurl;
-  success = filter_context.GetURL(&gurl);
-  DCHECK(success);
-  base::Time request_time = filter_context.GetRequestTime();
-  bool is_cached_content = filter_context.IsCachedContent();
-
-  filter_list->SetMimeType(mime_type);
-  filter_list->SetURL(gurl);
-  // Approximate connect time with request_time. If it is not cached, then
-  // this is a good approximation for when the first bytes went on the
-  // wire.
-  filter_list->SetConnectTime(request_time, is_cached_content);
-
   return filter_list;
 }
 
 // static
 Filter::FilterType Filter::ConvertEncodingToType(
     const std::string& filter_type) {
   FilterType type_id;
   if (LowerCaseEqualsASCII(filter_type, kDeflate)) {
     type_id = FILTER_TYPE_DEFLATE;
   } else if (LowerCaseEqualsASCII(filter_type, kGZip) ||
              LowerCaseEqualsASCII(filter_type, kXGZip)) {
     type_id = FILTER_TYPE_GZIP;
   } else if (LowerCaseEqualsASCII(filter_type, kBZip2) ||
              LowerCaseEqualsASCII(filter_type, kXBZip2)) {
     type_id = FILTER_TYPE_BZIP2;
   } else if (LowerCaseEqualsASCII(filter_type, kSdch)) {
     type_id = FILTER_TYPE_SDCH;
   } else {
     // Note we also consider "identity" and "uncompressed" UNSUPPORTED as
     // filter should be disabled in such cases.
     type_id = FILTER_TYPE_UNSUPPORTED;
   }
   return type_id;
 }
 
 // static
 void Filter::FixupEncodingTypes(
-    bool is_sdch_response,
-    const std::string& mime_type,
+    const FilterContext& filter_context,
     std::vector<FilterType>* encoding_types) {
+  std::string mime_type;
+  bool success = filter_context.GetMimeType(&mime_type);
+  DCHECK(success);
 
   if ((1 == encoding_types->size()) &&
       (FILTER_TYPE_GZIP == encoding_types->front())) {
     if (LowerCaseEqualsASCII(mime_type, kApplicationXGzip) ||
         LowerCaseEqualsASCII(mime_type, kApplicationGzip) ||
         LowerCaseEqualsASCII(mime_type, kApplicationXGunzip))
       // The server has told us that it sent us gziped content with a gzip
       // content encoding.  Sadly, Apache mistakenly sets these headers for all
       // .gz files.  We match Firefox's nsHttpChannel::ProcessNormal and ignore
       // the Content-Encoding here.
       encoding_types->clear();
   }
 
-  if (!is_sdch_response) {
+  if (!filter_context.IsSdchResponse()) {
     if (1 < encoding_types->size()) {
       // Multiple filters were intended to only be used for SDCH (thus far!)
       SdchManager::SdchErrorRecovery(
           SdchManager::MULTIENCODING_FOR_NON_SDCH_REQUEST);
     }
     if ((1 == encoding_types->size()) &&
         (FILTER_TYPE_SDCH == encoding_types->front())) {
         SdchManager::SdchErrorRecovery(
             SdchManager::SDCH_CONTENT_ENCODE_FOR_NON_SDCH_REQUEST);
     }
@@ skipping 117 matching lines @@
 
   first_filter->next_filter_.reset(filter_list);
   return first_filter;
 }
 
 Filter::Filter(const FilterContext& filter_context)
     : stream_buffer_(NULL),
       stream_buffer_size_(0),
       next_stream_data_(NULL),
       stream_data_len_(0),
-      url_(),
-      connect_time_(),
-      was_cached_(false),
-      mime_type_(),
       next_filter_(NULL),
       last_status_(FILTER_NEED_MORE_DATA),
       filter_context_(filter_context) {
 }
 
 Filter::~Filter() {}
 
 bool Filter::InitBuffer() {
-  int buffer_size = filter_context_.GetInputStreambufferSize();
+  int buffer_size = filter_context_.GetInputStreamBufferSize();
   DCHECK(buffer_size > 0);
   if (buffer_size <= 0 || stream_buffer())
     return false;
 
   stream_buffer_ = new net::IOBuffer(buffer_size);
 
   if (stream_buffer()) {
     stream_buffer_size_ = buffer_size;
     return true;
   }
@@ skipping 83 matching lines @@
 
   DCHECK(stream_buffer());
   // Bail out if there is more data in the stream buffer to be filtered.
   if (!stream_buffer() || stream_data_len_)
     return false;
 
   next_stream_data_ = stream_buffer()->data();
   stream_data_len_ = stream_data_len;
   return true;
 }
-
-void Filter::SetURL(const GURL& url) {
-  url_ = url;
-  if (next_filter_.get())
-    next_filter_->SetURL(url);
-}
-
-void Filter::SetMimeType(const std::string& mime_type) {
-  mime_type_ = mime_type;
-  if (next_filter_.get())
-    next_filter_->SetMimeType(mime_type);
-}
-
-void Filter::SetConnectTime(const base::Time& time, bool was_cached) {
-  connect_time_ = time;
-  was_cached_ = was_cached;
-  if (next_filter_.get())
-    next_filter_->SetConnectTime(time, was_cached_);
-}