Clean up filter and content encoding handling ...

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"
 #include "net/base/registry_controlled_domain.h"
 #include "net/base/sdch_manager.h"
 #include "net/url_request/url_request_http_job.h"
 
 
 //------------------------------------------------------------------------------
 // static
 SdchManager* SdchManager::global_;
 
 // static
 SdchManager* SdchManager::Global() {
   return global_;
 }
 
 // static
 void SdchManager::SdchErrorRecovery(ProblemCodes problem) {
   static LinearHistogram histogram(L"Sdch.ProblemCodes", MIN_PROBLEM_CODE,
                                    MAX_PROBLEM_CODE - 1, MAX_PROBLEM_CODE);
-  // TODO(jar): Set UMA flag for uploading.
+  histogram.SetFlags(kUmaTargetedHistogramFlag);
   histogram.Add(problem);
 }
 
 // static
 void SdchManager::ClearBlacklistings() {
   Global()->blacklisted_domains_.clear();
 }
 
 
 //------------------------------------------------------------------------------
 SdchManager::SdchManager() : sdch_enabled_(false) {
   DCHECK(!global_);
   global_ = this;
 }
 
 SdchManager::~SdchManager() {
   DCHECK(global_ == this);
   while (!dictionaries_.empty()) {
     DictionaryMap::iterator it = dictionaries_.begin();
     it->second->Release();
     dictionaries_.erase(it->first);
   }
   global_ = NULL;
 }
 
-// static 
+// static
 bool SdchManager::BlacklistDomain(const GURL& url) {
   if (!global_ )
     return false;
   std::string domain(url.host());
+  UMA_HISTOGRAM_TIMES(L"Sdch.UptimeBeforeBlacklisting",
+       Time::Now() - FieldTrialList::application_start_time());
   global_->blacklisted_domains_.insert(url.host());
   return true;
 }
 
 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 95 matching lines @@
     }
 
     if (line_end >= header_end)
       break;
     line_start = line_end + 1;
   }
 
   if (!Dictionary::CanSet(domain, path, ports, dictionary_url))
     return false;
 
-  HISTOGRAM_COUNTS(L"Sdch.Dictionary size loaded", dictionary_text.size());
+  UMA_HISTOGRAM_COUNTS(L"Sdch.Dictionary size loaded", dictionary_text.size());
   DLOG(INFO) << "Loaded dictionary with client hash " << client_hash <<
       " and server hash " << server_hash;
   Dictionary* dictionary =
       new Dictionary(dictionary_text, header_end + 2, client_hash,
                      dictionary_url, domain, path, expiration, ports);
   dictionary->AddRef();
   dictionaries_[server_hash] = dictionary;
   return true;
 }
 
 void SdchManager::GetVcdiffDictionary(const std::string& server_hash,
     const GURL& referring_url, Dictionary** dictionary) {
   *dictionary = NULL;
   DictionaryMap::iterator it = dictionaries_.find(server_hash);
   if (it == dictionaries_.end()) {
-    SdchErrorRecovery(DICTIONARY_NOT_FOUND_FOR_HASH);
     return;
   }
   Dictionary* matching_dictionary = it->second;
   if (!matching_dictionary->CanUse(referring_url))
     return;
   *dictionary = matching_dictionary;
 }
 
 // TODO(jar): If we have evictions from the dictionaries_, then we need to
 // change this interface to return a list of reference counted Dictionary
@@ skipping 179 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());
 }