Make SdchManager per-profile.

net/filter/sdch_filter.cc

 // Copyright 2014 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/filter/sdch_filter.h"
 
 #include <ctype.h>
 #include <limits.h>
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "net/base/sdch_manager.h"
+#include "net/url_request/url_request_context.h"
 
 #include "sdch/open-vcdiff/src/google/vcdecoder.h"
 
 namespace net {
 
 SdchFilter::SdchFilter(const FilterContext& filter_context)
     : filter_context_(filter_context),
       decoding_status_(DECODING_UNINITIALIZED),
       dictionary_hash_(),
       dictionary_hash_is_plausible_(false),
       dictionary_(NULL),
       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(filter_context_.GetURLRequestContext()->sdch_manager());
 }
 
 SdchFilter::~SdchFilter() {
   // All code here is for gathering stats, and can be removed when SDCH is
   // considered stable.
 
   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;
       SdchManager::SdchErrorRecovery(SdchManager::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.
-      SdchManager::BlacklistDomain(url_);
+      filter_context_.GetURLRequestContext()->sdch_manager()->BlacklistDomain(
+          url_);
       UMA_HISTOGRAM_COUNTS("Sdch3.PartialBytesIn",

[jar (doing other things), 2014/06/09 23:03:01]

nit: I went and looked at these histogtrams.  The dashboard indicated that they
are unowned.... but you *might* want to take ownership of some/all of these. 
Especially interesting is the: Sdch3.ProblemCodes_4 

This will be a place where you can see how your code is working in the field (
:-/.... assuming you don't get direction from crash reports).

[Randy Smith (Not in Mondays), 2014/06/10 20:38:41]

Will do, but in a separate CL.  Confirming: I do that by adding an "<owner>"
field in histograms.xml?  Also, I'm not seeing the histogram in
tools/metrics/histograms.xml; does that mean they're internal and should be
moved external?
Yes, I need to engage with how to evaluate this stuff in the field; I haven't
done that yet.

[jar (doing other things), 2014/06/11 20:04:43]

+1 with your plan, inluding <owner> field.

On 2014/06/10 20:38:41, rdsmith wrote:

            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.
     SdchManager::SdchErrorRecovery(SdchManager::UNFLUSHED_CONTENT);
     UMA_HISTOGRAM_COUNTS("Sdch3.UnflushedBytesIn",
@@ skipping 15 matching lines @@
     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.Network_Decode_Bytes_VcdiffOut_a",
                            output_bytes_);
       filter_context_.RecordPacketStats(FilterContext::SDCH_DECODE);
 
       // Allow latency experiments to proceed.
-      SdchManager::Global()->SetAllowLatencyExperiment(url_, true);
+      filter_context_.GetURLRequestContext()->sdch_manager()->
+          SetAllowLatencyExperiment(url_, true);
       return;
     }
     case PASS_THROUGH: {
       filter_context_.RecordPacketStats(FilterContext::SDCH_PASSTHROUGH);
       return;
     }
     case DECODING_UNINITIALIZED: {
       SdchManager::SdchErrorRecovery(SdchManager::UNINITIALIZED);
       return;
     }
@@ skipping 104 matching lines @@
       } 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.
         SdchManager::SdchErrorRecovery(SdchManager::PASSING_THROUGH_NON_SDCH);
         decoding_status_ = PASS_THROUGH;
         // ... but further back-off on advertising SDCH support.
-        SdchManager::BlacklistDomain(url_);
+        filter_context_.GetURLRequestContext()->sdch_manager()->BlacklistDomain(
+            url_);
       }
 
       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.
-          SdchManager::BlacklistDomainForever(url_);
+          filter_context_.GetURLRequestContext()->sdch_manager()->
+              BlacklistDomainForever(url_);
           if (filter_context_.IsCachedContent())
             SdchManager::SdchErrorRecovery(
                 SdchManager::CACHED_META_REFRESH_UNSUPPORTED);
           else
             SdchManager::SdchErrorRecovery(
                 SdchManager::META_REFRESH_UNSUPPORTED);
           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.
           SdchManager::SdchErrorRecovery(
               SdchManager::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.
-          SdchManager::BlacklistDomain(url_);
+          filter_context_.GetURLRequestContext()->sdch_manager()->
+              BlacklistDomain(url_);
           SdchManager::SdchErrorRecovery(SdchManager::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_);
     }
   }
@@ skipping 72 matching lines @@
   DCHECK_LE(0, stream_data_len_);
   if (stream_data_len_ > 0)
     next_stream_data_ += bytes_needed;
   else
     next_stream_data_ = NULL;
 
   DCHECK(!dictionary_.get());
   dictionary_hash_is_plausible_ = true;  // Assume plausible, but check.
 
   SdchManager::Dictionary* dictionary = NULL;
-  if ('\0' == dictionary_hash_[kServerIdLength - 1])
-    SdchManager::Global()->GetVcdiffDictionary(std::string(dictionary_hash_, 0,
-                                                           kServerIdLength - 1),
-                                               url_, &dictionary);
-  else
+  if ('\0' == dictionary_hash_[kServerIdLength - 1]) {
+    SdchManager* manager(
+        filter_context_.GetURLRequestContext()->sdch_manager());
+    manager->GetVcdiffDictionary(
+        std::string(dictionary_hash_, 0, kServerIdLength - 1),
+        url_, &dictionary);
+  } else {
     dictionary_hash_is_plausible_ = false;
+  }
 
   if (!dictionary) {
     DCHECK(dictionary_hash_.size() == kServerIdLength);
     // Since dictionary was not found, check to see if hash was even plausible.
     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;
         break;
       }
@@ skipping 26 matching lines @@
   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;
 }
 
 }  // namespace net