Fix bug in percentage increase computation for cache sensitivity analysis,

net/http/http_cache_transaction.cc

 // Copyright (c) 2012 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 "net/http/http_cache_transaction.h"
 
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
 #include <unistd.h>
@@ skipping 132 matching lines @@
       ALLOW_THIS_IN_INITIALIZER_LIST(io_callback_(
           base::Bind(&Transaction::OnIOComplete,
                      weak_factory_.GetWeakPtr()))),
       transaction_pattern_(PATTERN_UNDEFINED),
       bytes_read_from_cache_(0),
       bytes_read_from_network_(0),
       transaction_delegate_(transaction_delegate) {
   COMPILE_ASSERT(HttpCache::Transaction::kNumValidationHeaders ==
                  arraysize(kValidationHeaders),
                  Invalid_number_of_validation_headers);
-  if (!base::StringToInt(
-          base::FieldTrialList::FindFullName("CacheSensitivityAnalysis"),
-          &sensitivity_analysis_percent_increase_)) {
-    sensitivity_analysis_percent_increase_ = 0;
-  }
+  base::StringToInt(

[rvargas (doing something else), 2012/10/03 02:01:09]

Sorry, I'm confused now. What was the bug?. Why two groups for every value?

[tburkard, 2012/10/03 16:47:21]

This change here is to make the two groups work for each value.  The reason why
we have two groups is to easily be able to spot the variance (if the
averages/percentile cutoffs for the two groups are close, low variance, if they
are far apart, high variance).  The bug was the "+ 100" below, I fixed that.

[rvargas (doing something else), 2012/10/03 22:19:05]

I thought the original behavior is what you wanted at that time... Anyway, OK,
if we have different results from both groups that's a strong signal that
something is not working :)

+      base::FieldTrialList::FindFullName("CacheSensitivityAnalysis"),
+      &sensitivity_analysis_percent_increase_);
 }
 
 HttpCache::Transaction::~Transaction() {
   // We may have to issue another IO, but we should never invoke the callback_
   // after this point.
   callback_.Reset();
 
   transaction_delegate_ = NULL;
 
   if (cache_) {
@@ skipping 2110 matching lines @@
   }
 
   return true;
 }
 
 void HttpCache::Transaction::OnIOComplete(int result) {
   if (!cache_io_start_.is_null()) {
     base::TimeDelta cache_time = base::TimeTicks::Now() - cache_io_start_;
     cache_io_start_ = base::TimeTicks();
     if (sensitivity_analysis_percent_increase_ > 0) {
-      cache_time *= 100 + sensitivity_analysis_percent_increase_;
+      cache_time *= sensitivity_analysis_percent_increase_;
       cache_time /= 100;
       MessageLoop::current()->PostDelayedTask(
           FROM_HERE,
           base::Bind(&HttpCache::Transaction::RunDelayedLoop,
                      weak_factory_.GetWeakPtr(),
                      base::TimeTicks::Now(),
                      cache_time,
                      result),
           cache_time);
       return;
@@ skipping 186 matching lines @@
 }
 
 int HttpCache::Transaction::ResetCacheIOStart(int return_value) {
   DCHECK(cache_io_start_.is_null());
   if (return_value == ERR_IO_PENDING)
     cache_io_start_ = base::TimeTicks::Now();
   return return_value;
 }
 
 }  // namespace net