Convert use of int ms to TimeDelta in files owned by brettw.

chrome/browser/task_manager/task_manager.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/task_manager/task_manager.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/i18n/number_formatting.h"
 #include "base/i18n/rtl.h"
@@ skipping 29 matching lines @@
 #include "grit/ui_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/text/bytes_formatting.h"
 #include "unicode/coll.h"
 
 #if defined(OS_MACOSX)
 #include "content/browser/mach_broker_mac.h"
 #endif
 
+using base::TimeDelta;

[brettw, 2012/01/15 17:28:15]

It's not clear why you did this here when most of your uses use "base::". I'd
just convert the two places you don't use base:: and delete this.

 using content::BrowserThread;
 using content::OpenURLParams;
 using content::Referrer;
 
 namespace {
 
 // The delay between updates of the information (in ms).
 #if defined(OS_MACOSX)
 // Match Activity Monitor's default refresh rate.
 const int kUpdateTimeMs = 2000;
@@ skipping 560 matching lines @@
   update_requests_++;
   if (update_requests_ > 1)
     return;
   DCHECK_EQ(1, update_requests_);
   DCHECK_NE(TASK_PENDING, update_state_);
 
   // If update_state_ is STOPPING, it means a task is still pending.  Setting
   // it to TASK_PENDING ensures the tasks keep being posted (by Refresh()).
   if (update_state_ == IDLE) {
       MessageLoop::current()->PostDelayedTask(
-          FROM_HERE, base::Bind(&TaskManagerModel::Refresh, this),
-          kUpdateTimeMs);
+          FROM_HERE,
+          base::Bind(&TaskManagerModel::Refresh, this),
+          base::TimeDelta::FromMilliseconds(kUpdateTimeMs));
   }
   update_state_ = TASK_PENDING;
 
   // Notify resource providers that we are updating.
   for (ResourceProviderList::iterator iter = providers_.begin();
        iter != providers_.end(); ++iter) {
     (*iter)->StartUpdating();
   }
 }
 
@@ skipping 221 matching lines @@
     MetricsMap::iterator metrics_iter = metrics_map_.find(process);
     DCHECK(metrics_iter != metrics_map_.end());
     cpu_usage_map_[process] = metrics_iter->second->GetCPUUsage();
   }
 
   // Clear the memory values so they can be querried lazily.
   memory_usage_map_.clear();
 
   // Compute the new network usage values.
   displayed_network_usage_map_.clear();
+  TimeDelta update_time = base::TimeDelta::FromMilliseconds(kUpdateTimeMs);
   for (ResourceValueMap::iterator iter = current_byte_count_map_.begin();
        iter != current_byte_count_map_.end(); ++iter) {
-    if (kUpdateTimeMs > 1000) {
-      int divider = (kUpdateTimeMs / 1000);
+    if (update_time > TimeDelta::FromSeconds(1)) {
+      int divider = update_time.InSeconds();
       displayed_network_usage_map_[iter->first] = iter->second / divider;
     } else {
       displayed_network_usage_map_[iter->first] = iter->second *
-          (1000 / kUpdateTimeMs);
+          (1 / update_time.InSeconds());
     }
 
     // Then we reset the current byte count.
     iter->second = 0;
   }
 
   // Let resources update themselves if they need to.
   for (ResourceList::iterator iter = resources_.begin();
        iter != resources_.end(); ++iter) {
      (*iter)->Refresh();
   }
 
   if (!resources_.empty()) {
     FOR_EACH_OBSERVER(TaskManagerModelObserver, observer_list_,
                       OnItemsChanged(0, ResourceCount()));
   }
 
   // Schedule the next update.
   MessageLoop::current()->PostDelayedTask(
-      FROM_HERE, base::Bind(&TaskManagerModel::Refresh, this), kUpdateTimeMs);
+      FROM_HERE,
+      base::Bind(&TaskManagerModel::Refresh, this),
+      base::TimeDelta::FromMilliseconds(kUpdateTimeMs));
 }
 
 int64 TaskManagerModel::GetNetworkUsageForResource(
     TaskManager::Resource* resource) const {
   ResourceValueMap::const_iterator iter =
       displayed_network_usage_map_.find(resource);
   if (iter == displayed_network_usage_map_.end())
     return 0;
   return iter->second;
 }
@@ skipping 241 matching lines @@
     // Count the number of extensions with background pages (including
     // incognito).
     count += CountExtensionBackgroundPagesForProfile(profile);
     if (profile->HasOffTheRecordProfile()) {
       count += CountExtensionBackgroundPagesForProfile(
           profile->GetOffTheRecordProfile());
     }
   }
   return count;
 }