Allow server to indicate a non-SDCH encoding

net/url_request/url_request_http_job.cc

 // Copyright (c) 2011 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/url_request/url_request_http_job.h"
 
 #include "base/base_switches.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/file_util.h"
@@ skipping 88 matching lines @@
   virtual bool GetMimeType(std::string* mime_type) const;
   virtual bool GetURL(GURL* gurl) const;
   virtual base::Time GetRequestTime() const;
   virtual bool IsCachedContent() const;
   virtual bool IsDownload() const;
   virtual bool IsSdchResponse() const;
   virtual int64 GetByteReadCount() const;
   virtual int GetResponseCode() const;
   virtual void RecordPacketStats(StatisticSelector statistic) const;
 
+  // Method to allow us to reset context to false when there is an update due
+  // to an explicit HTTP header.

[wtc, 2011/05/04 18:27:00]

Nit: this comment doesn't even mention SDCH.

[jar (doing other things), 2011/05/04 18:31:51]

Done.

+  void SetSdchResponse(bool active);
+
  private:
   URLRequestHttpJob* job_;
 
   DISALLOW_COPY_AND_ASSIGN(HttpFilterContext);
 };
 
 URLRequestHttpJob::HttpFilterContext::HttpFilterContext(URLRequestHttpJob* job)
     : job_(job) {
   DCHECK(job_);
 }
@@ skipping 18 matching lines @@
 }
 
 bool URLRequestHttpJob::HttpFilterContext::IsCachedContent() const {
   return job_->is_cached_content_;
 }
 
 bool URLRequestHttpJob::HttpFilterContext::IsDownload() const {
   return (job_->request_info_.load_flags & LOAD_IS_DOWNLOAD) != 0;
 }
 
+void URLRequestHttpJob::HttpFilterContext::SetSdchResponse(bool active) {
+  // Currently only for use to reset the context to false, after seeing an
+  // explicit HTTP header.
+  DCHECK(job_->sdch_dictionary_advertised_);
+  DCHECK(!active);

[wtc, 2011/05/04 18:27:00]

It's strange to assert that a function argument can only
take a particular value.  You should just provide a method
that sets job_->sdch_dictionary_advertised_ to false.

[jar (doing other things), 2011/05/04 18:31:51]

Done.

+  job_->sdch_dictionary_advertised_ = active;
+}
+
 bool URLRequestHttpJob::HttpFilterContext::IsSdchResponse() const {
   return job_->sdch_dictionary_advertised_;
 }
 
 int64 URLRequestHttpJob::HttpFilterContext::GetByteReadCount() const {
   return job_->filter_input_byte_count();
 }
 
 int URLRequestHttpJob::HttpFilterContext::GetResponseCode() const {
   return job_->GetResponseCode();
@@ skipping 223 matching lines @@
   } else {
     // Include SDCH in acceptable list.
     request_info_.extra_headers.SetHeader(
         HttpRequestHeaders::kAcceptEncoding, "gzip,deflate,sdch");
     if (!avail_dictionaries.empty()) {
       request_info_.extra_headers.SetHeader(
           kAvailDictionaryHeader,
           avail_dictionaries);
       sdch_dictionary_advertised_ = true;
       // Since we're tagging this transaction as advertising a dictionary, we'll
-      // definately employ an SDCH filter (or tentative sdch filter) when we get
+      // definitely employ an SDCH filter (or tentative sdch filter) when we get
       // a response.  When done, we'll record histograms via SDCH_DECODE or
       // SDCH_PASSTHROUGH.  Hence we need to record packet arrival times.
       packet_timing_enabled_ = true;
     }
   }
 
   URLRequestContext* context = request_->context();
   if (context) {
     // Only add default Accept-Language and Accept-Charset if the request
     // didn't have them specified.
@@ skipping 458 matching lines @@
     return NULL;
 
   std::vector<Filter::FilterType> encoding_types;
   std::string encoding_type;
   void* iter = NULL;
   while (response_info_->headers->EnumerateHeader(&iter, "Content-Encoding",
                                                   &encoding_type)) {
     encoding_types.push_back(Filter::ConvertEncodingToType(encoding_type));
   }
 
+  if (filter_context_->IsSdchResponse()) {
+    // We are wary of proxies that discard or damage SDCH encoding.  If a server
+    // explicitly states that this is not SDCH content, then we can correct our
+    // assumption that this is an SDCH response, and avoid the need to recover
+    // as though the content is corrupted (when we discover it is not SDCH
+    // encoded).
+    std::string sdch_response_status;
+    iter = NULL;
+    while (response_info_->headers->EnumerateHeader(&iter, "X-Sdch-Encode",
+                                                    &sdch_response_status)) {
+      if (sdch_response_status == "0") {
+        filter_context_->SetSdchResponse(false);
+        break;
+      }
+    }
+  }
+
   // Even if encoding types are empty, there is a chance that we need to add
   // some decoding, as some proxies strip encoding completely. In such cases,
   // we may need to add (for example) SDCH filtering (when the context suggests
   // it is appropriate).
   Filter::FixupEncodingTypes(*filter_context_, &encoding_types);
 
   return !encoding_types.empty()
       ? Filter::Factory(encoding_types, *filter_context_) : NULL;
 }
 
@@ skipping 490 matching lines @@
 }
 
 bool URLRequestHttpJob::IsCompressibleContent() const {
   std::string mime_type;
   return GetMimeType(&mime_type) &&
       (IsSupportedJavascriptMimeType(mime_type.c_str()) ||
        IsSupportedNonImageMimeType(mime_type.c_str()));
 }
 
 }  // namespace net