Clean up filter and content encoding handling ...

net/base/sdch_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 <ctype.h>
 #include <algorithm>
 
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
       dest_buffer_excess_(),
       dest_buffer_excess_index_(0),
       source_bytes_(0),
       output_bytes_(0) {
 }
 
 SdchFilter::~SdchFilter() {
   static int filter_use_count = 0;
   ++filter_use_count;
   if (META_REFRESH_RECOVERY == decoding_status_) {
-    HISTOGRAM_COUNTS(L"Sdch.FilterUseBeforeDisabling", filter_use_count);
+    UMA_HISTOGRAM_COUNTS(L"Sdch.FilterUseBeforeDisabling", filter_use_count);
   }
 
   if (vcdiff_streaming_decoder_.get()) {
     if (!vcdiff_streaming_decoder_->FinishDecoding())
       decoding_status_ = DECODING_ERROR;
   }
 
-  // TODO(jar): Use UMA_HISTOGRAM when we turn sdch on by default.
-  HISTOGRAM_COUNTS(L"Sdch.Bytes read", source_bytes_);
-  HISTOGRAM_COUNTS(L"Sdch.Bytes output", output_bytes_);
+  UMA_HISTOGRAM_COUNTS(L"Sdch.Bytes read", source_bytes_);
+  UMA_HISTOGRAM_COUNTS(L"Sdch.Bytes output", output_bytes_);
 
   if (dictionary_)
     dictionary_->Release();
 }
 
 bool SdchFilter::InitDecoding() {
   if (decoding_status_ != DECODING_UNINITIALIZED)
     return false;
 
   // Initialize decoder only after we have a dictionary in hand.
@@ skipping 22 matching lines @@
 
   if (WAITING_FOR_DICTIONARY_SELECTION == decoding_status_) {
     FilterStatus status = InitializeDictionary();
     if (FILTER_NEED_MORE_DATA == status)
       return FILTER_NEED_MORE_DATA;
     if (FILTER_ERROR == status) {
       DCHECK(DECODING_ERROR == decoding_status_);
       DCHECK(0 == dest_buffer_excess_index_);
       DCHECK(dest_buffer_excess_.empty());
       if (!dictionary_hash_is_plausible_) {
+        // One of the first 9 bytes precluded consideration as a hash.
+        // This can't be an SDCH payload.
         SdchManager::SdchErrorRecovery(SdchManager::PASSING_THROUGH_NON_SDCH);
         decoding_status_ = PASS_THROUGH;
         dest_buffer_excess_ = dictionary_hash_;  // Send what we scanned.
       } else {
         SdchManager::BlacklistDomain(url());
         if (std::string::npos == mime_type().find_first_of("text/html")) {
           SdchManager::SdchErrorRecovery(SdchManager::UNRECOVERABLE_ERROR);
           return FILTER_ERROR;
         }
         SdchManager::SdchErrorRecovery(SdchManager::META_REFRESH_RECOVERY);
@@ skipping 83 matching lines @@
   dictionary_hash_is_plausible_ = true;  // Assume plausible, but check.
   if ('\0' == dictionary_hash_[kServerIdLength - 1])
     SdchManager::Global()->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;
       }
     }
     if (dictionary_hash_is_plausible_)
       SdchManager::SdchErrorRecovery(SdchManager::DICTIONARY_HASH_NOT_FOUND);
     else
@@ skipping 19 matching lines @@
   memcpy(dest_buffer, dest_buffer_excess_.data() + dest_buffer_excess_index_,
          amount);
   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;
 }