Convert uses of int ms to TimeDelta in chrome/browser and net.

chrome/browser/metrics/histogram_synchronizer.cc

 // Copyright (c) 2011 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 "chrome/browser/metrics/histogram_synchronizer.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/threading/thread.h"
@@ skipping 60 matching lines @@
                        unresponsive_renderer_count);
   if (!unresponsive_renderer_count)
     UMA_HISTOGRAM_TIMES("Histogram.FetchRendererHistogramsSynchronously",
                         TimeTicks::Now() - start);
 }
 
 // static
 void HistogramSynchronizer::FetchRendererHistogramsAsynchronously(
     MessageLoop* callback_thread,
     const base::Closure& callback,
     int wait_time) {

[jar (doing other things), 2012/03/03 22:54:43]

I *think* you should propagate the chage further back here... and avoid the
translation in the post.

WDYT?

   DCHECK(callback_thread != NULL);
   DCHECK(!callback.is_null());
 
   HistogramSynchronizer* current_synchronizer = CurrentSynchronizer();
 
   if (current_synchronizer == NULL) {
     // System teardown is happening.
     callback_thread->PostTask(FROM_HERE, callback);
     return;
   }
 
   current_synchronizer->SetCallbackTaskAndThread(callback_thread,
                                                  callback);
 
   int sequence_number =
       current_synchronizer->NotifyAllRenderers(ASYNC_HISTOGRAMS);
 
   // Post a task that would be called after waiting for wait_time.  This acts
   // as a watchdog, to ensure that a non-responsive renderer won't block us from
   // making the callback.
   BrowserThread::PostDelayedTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &HistogramSynchronizer::ForceHistogramSynchronizationDoneCallback,
           current_synchronizer,
           sequence_number),
-      wait_time);
+      base::TimeDelta::FromMilliseconds(wait_time));
 }
 
 // static
 void HistogramSynchronizer::DeserializeHistogramList(
     int sequence_number,
     const std::vector<std::string>& histograms) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   for (std::vector<std::string>::const_iterator it = histograms.begin();
        it < histograms.end();
        ++it) {
@@ skipping 134 matching lines @@
     async_renderers_pending_ = renderer_count;
   } else if (requester == SYNCHRONOUS_HISTOGRAMS) {
     synchronous_sequence_number_ = last_used_sequence_number_;
     synchronous_renderers_pending_ = renderer_count;
   }
   return last_used_sequence_number_;
 }
 
 // static
 HistogramSynchronizer* HistogramSynchronizer::histogram_synchronizer_ = NULL;