Histogram size of "final" block of SDCH compressed data....

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"
 #include "net/base/sdch_filter.h"
 #include "net/base/sdch_manager.h"
 
 #include "sdch/open-vcdiff/src/google/vcdecoder.h"
 
 SdchFilter::SdchFilter()
     : decoding_status_(DECODING_UNINITIALIZED),
       vcdiff_streaming_decoder_(NULL),
       dictionary_hash_(),
       dictionary_hash_is_plausible_(false),
       dictionary_(NULL),
       dest_buffer_excess_(),
       dest_buffer_excess_index_(0),
       source_bytes_(0),
       output_bytes_(0),
-      time_of_last_read_() {
+      time_of_last_read_(),
+      size_of_last_read_(0) {
 }
 
 SdchFilter::~SdchFilter() {
   static int filter_use_count = 0;
   ++filter_use_count;
   if (META_REFRESH_RECOVERY == decoding_status_) {
     UMA_HISTOGRAM_COUNTS(L"Sdch.FilterUseBeforeDisabling", filter_use_count);
   }
 
   if (vcdiff_streaming_decoder_.get()) {
@@ skipping 10 matching lines @@
     // 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 (180 >= duration.InSeconds()) {
       if (DECODING_IN_PROGRESS == decoding_status_)
         UMA_HISTOGRAM_MEDIUM_TIMES(L"Sdch.Transit_Latency_M", duration);
       if (PASS_THROUGH == decoding_status_)
         UMA_HISTOGRAM_MEDIUM_TIMES(L"Sdch.Transit_Pass-through_Latency_M",
                                    duration);
+      // Look at sizes of the 20% of blocks that arrive with large latency.
+      if (15 < duration.InSeconds())
+        UMA_HISTOGRAM_COUNTS(L"Sdch.Transit_Belated_Final_Block_Size",
+                             size_of_last_read_);
     }
   }
 
   UMA_HISTOGRAM_COUNTS(L"Sdch.Bytes read", source_bytes_);
   UMA_HISTOGRAM_COUNTS(L"Sdch.Bytes output", output_bytes_);
 
   if (dictionary_)
     dictionary_->Release();
 }
 
@@ skipping 18 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;
 
   // Don't update when we're called to just flush out our internal buffers.
-  if (next_stream_data_ && stream_data_len_ > 0)
+  if (next_stream_data_ && stream_data_len_ > 0) {
     time_of_last_read_ = base::Time::Now();
+    size_of_last_read_ = stream_data_len_;
+  }
 
   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 139 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;
 }