Hand craft an A/B test of SDCH compression...

net/base/sdch_manager.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 "base/field_trial.h"
 #include "base/histogram.h"
 #include "base/logging.h"
 #include "base/sha2.h"
 #include "base/string_util.h"
 #include "net/base/base64.h"
@@ skipping 67 matching lines @@
     it->second->Release();
     dictionaries_.erase(it->first);
   }
   global_ = NULL;
 }
 
 // static
 void SdchManager::BlacklistDomain(const GURL& url) {
   if (!global_ )
     return;
+  global_->SetAllowLatencyExperiment(url, false);
 
   std::string domain(StringToLowerASCII(url.host()));
   int count = global_->blacklisted_domains_[domain];
   if (count > 0)
     return;  // Domain is already blacklisted.
 
   count = 1 + 2 * global_->exponential_blacklist_count[domain];
   if (count > 0)
     global_->exponential_blacklist_count[domain] = count;
   else
     count = INT_MAX;
 
   global_->blacklisted_domains_[domain] = count;
 }
 
 // static
 void SdchManager::BlacklistDomainForever(const GURL& url) {
   if (!global_ )
     return;
+  global_->SetAllowLatencyExperiment(url, false);
 
   std::string domain(StringToLowerASCII(url.host()));
   global_->exponential_blacklist_count[domain] = INT_MAX;
   global_->blacklisted_domains_[domain] = INT_MAX;
 }
 
 void SdchManager::EnableSdchSupport(const std::string& domain) {
   // We presume that there is a SDCH manager instance.
   global_->supported_domain_ = domain;
   global_->sdch_enabled_ = true;
@@ skipping 207 matching lines @@
 void SdchManager::GenerateHash(const std::string& dictionary_text,
     std::string* client_hash, std::string* server_hash) {
   char binary_hash[32];
   base::SHA256HashString(dictionary_text, binary_hash, sizeof(binary_hash));
 
   std::string first_48_bits(&binary_hash[0], 6);
   std::string second_48_bits(&binary_hash[6], 6);
   UrlSafeBase64Encode(first_48_bits, client_hash);
   UrlSafeBase64Encode(second_48_bits, server_hash);
 
-  DCHECK(server_hash->length() == 8);
-  DCHECK(client_hash->length() == 8);
+  DCHECK_EQ(server_hash->length(), 8u);
+  DCHECK_EQ(client_hash->length(), 8u);
 }
 
 // static
 void SdchManager::UrlSafeBase64Encode(const std::string& input,
                                       std::string* output) {
   // Since this is only done during a dictionary load, and hashes are only 8
   // characters, we just do the simple fixup, rather than rewriting the encoder.
   net::Base64Encode(input, output);
   for (size_t i = 0; i < output->size(); ++i) {
     switch (output->data()[i]) {
@@ skipping 154 matching lines @@
     return false;
   return restriction[prefix_length - 1] == '/' || path[prefix_length] == '/';
 }
 
 // static
 bool SdchManager::Dictionary::DomainMatch(const GURL& gurl,
                                           const std::string& restriction) {
   // TODO(jar): This is not precisely a domain match definition.
   return gurl.DomainIs(restriction.data(), restriction.size());
 }
+
+//------------------------------------------------------------------------------
+// Methods for supporting latency experiments.
+
+bool SdchManager::AllowLatencyExperiment(const GURL& url) const {
+  return allow_latency_experiment_.end() !=
+      allow_latency_experiment_.find(url.host());
+}
+
+void SdchManager::SetAllowLatencyExperiment(const GURL& url, bool enable) {
+  if (enable) {
+    allow_latency_experiment_.insert(url.host());
+    return;
+  }
+  ExperimentSet::iterator it = allow_latency_experiment_.find(url.host());
+  if (allow_latency_experiment_.end() == it)
+    return;  // It was already erased, or never allowed.
+  SdchErrorRecovery(LATENCY_TEST_DISALLOWED);
+  allow_latency_experiment_.erase(it);
+}