Open up SDCH for all sites, in preparation for latency tests...

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 24 matching lines @@
 
   if (vcdiff_streaming_decoder_.get()) {
     if (!vcdiff_streaming_decoder_->FinishDecoding())
       decoding_status_ = DECODING_ERROR;
   }
 
   if (base::Time() != connect_time() && base::Time() != time_of_last_read_) {
     base::TimeDelta duration = time_of_last_read_ - connect_time();
     // Note: connect_time may be somewhat incorrect if this is cached data, as
     // it will reflect the time the connect was done for the original read :-(.
-    // To avoid any chances of overflow (and since SDCH is meant to primarilly
+    // To avoid any chances of overflow, and since SDCH is meant to primarilly
     // handle short downloads, we'll restrict what results we log to effectively
     // discard bogus large numbers.  Note that IF the number is large enough, it
     // would DCHECK in histogram as the square of the value is summed.  The
     // relatively precise histogram only properly covers the range 1ms to 10
     // seconds, so the discarded data would not be that readable anyway.
     if (30 >= duration.InSeconds()) {
       if (DECODING_IN_PROGRESS == decoding_status_)
-        UMA_HISTOGRAM_TIMES(L"Sdch.Transit_Latency", duration);
+        UMA_HISTOGRAM_TIMES(L"Sdch.Transit_Latency_2", duration);
       if (PASS_THROUGH == decoding_status_)
-        UMA_HISTOGRAM_TIMES(L"Sdch.Transit_Pass-through_Latency", duration);
+        UMA_HISTOGRAM_TIMES(L"Sdch.Transit_Pass-through_Latency_2", duration);
     }
   }
 
   UMA_HISTOGRAM_COUNTS(L"Sdch.Bytes read", source_bytes_);
   UMA_HISTOGRAM_COUNTS(L"Sdch.Bytes output", output_bytes_);
 
   if (dictionary_)
     dictionary_->Release();
 }
 
@@ skipping 17 matching lines @@
 
 
 Filter::FilterStatus SdchFilter::ReadFilteredData(char* dest_buffer,
                                                   int* dest_len) {
   int available_space = *dest_len;
   *dest_len = 0;  // Nothing output yet.
 
   if (!dest_buffer || available_space <= 0)
     return FILTER_ERROR;
 
-  time_of_last_read_ = base::Time::Now();
+  // Don't update when we're called to just flush out our internal buffers.
+  if (next_stream_data_ && stream_data_len_ > 0)
+    time_of_last_read_ = base::Time::Now();
 
   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_) {
@@ skipping 135 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;
 }