Switch to standard integer types in extensions/browser/.

extensions/browser/api/web_request/web_request_time_tracker.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 "extensions/browser/api/web_request/web_request_time_tracker.h"
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/metrics/histogram.h"
 #include "extensions/browser/warning_set.h"
@@ skipping 82 matching lines @@
 }
 
 ExtensionWebRequestTimeTracker::ExtensionWebRequestTimeTracker()
     : delegate_(new DefaultDelegate) {
 }
 
 ExtensionWebRequestTimeTracker::~ExtensionWebRequestTimeTracker() {
 }
 
 void ExtensionWebRequestTimeTracker::LogRequestStartTime(
-    int64 request_id,
+    int64_t request_id,
     const base::Time& start_time,
     const GURL& url,
     void* profile) {
   // Trim old completed request logs.
   while (request_ids_.size() > kMaxRequestsLogged) {
-    int64 to_remove = request_ids_.front();
+    int64_t to_remove = request_ids_.front();
     request_ids_.pop();
-    std::map<int64, RequestTimeLog>::iterator iter =
+    std::map<int64_t, RequestTimeLog>::iterator iter =
         request_time_logs_.find(to_remove);
     if (iter != request_time_logs_.end() && iter->second.completed) {
       request_time_logs_.erase(iter);
       moderate_delays_.erase(to_remove);
       excessive_delays_.erase(to_remove);
     }
   }
   request_ids_.push(request_id);
 
   if (request_time_logs_.find(request_id) != request_time_logs_.end()) {
     RequestTimeLog& log = request_time_logs_[request_id];
     DCHECK(!log.completed);
     return;
   }
   RequestTimeLog& log = request_time_logs_[request_id];
   log.request_start_time = start_time;
   log.url = url;
   log.profile = profile;
 }
 
 void ExtensionWebRequestTimeTracker::LogRequestEndTime(
-    int64 request_id, const base::Time& end_time) {
+    int64_t request_id,
+    const base::Time& end_time) {
   if (request_time_logs_.find(request_id) == request_time_logs_.end())
     return;
 
   RequestTimeLog& log = request_time_logs_[request_id];
   if (log.completed)
     return;
 
   log.request_duration = end_time - log.request_start_time;
   log.completed = true;
 
@@ skipping 10 matching lines @@
   std::set<std::string> result;
   for (std::map<std::string, base::TimeDelta>::const_iterator i =
            log.extension_block_durations.begin();
        i != log.extension_block_durations.end();
        ++i) {
     result.insert(i->first);
   }
   return result;
 }
 
-void ExtensionWebRequestTimeTracker::Analyze(int64 request_id) {
+void ExtensionWebRequestTimeTracker::Analyze(int64_t request_id) {
   RequestTimeLog& log = request_time_logs_[request_id];
 
   // Ignore really short requests. Time spent on these is negligible, and any
   // extra delay the extension adds is likely to be noise.
   if (log.request_duration.InMilliseconds() < kMinRequestTimeToCareMs)
     return;
 
   double percentage =
       log.block_duration.InMillisecondsF() /
       log.request_duration.InMillisecondsF();
@@ skipping 27 matching lines @@
             moderate_delays_.size() + excessive_delays_.size(),
             request_ids_.size(),
             GetExtensionIds(log));
       }
     }
   }
 }
 
 void ExtensionWebRequestTimeTracker::IncrementExtensionBlockTime(
     const std::string& extension_id,
-    int64 request_id,
+    int64_t request_id,
     const base::TimeDelta& block_time) {
   if (request_time_logs_.find(request_id) == request_time_logs_.end())
     return;
   RequestTimeLog& log = request_time_logs_[request_id];
   log.extension_block_durations[extension_id] += block_time;
 }
 
 void ExtensionWebRequestTimeTracker::IncrementTotalBlockTime(
-    int64 request_id,
+    int64_t request_id,
     const base::TimeDelta& block_time) {
   if (request_time_logs_.find(request_id) == request_time_logs_.end())
     return;
   RequestTimeLog& log = request_time_logs_[request_id];
   log.block_duration += block_time;
 }
 
-void ExtensionWebRequestTimeTracker::SetRequestCanceled(int64 request_id) {
+void ExtensionWebRequestTimeTracker::SetRequestCanceled(int64_t request_id) {
   // Canceled requests won't actually hit the network, so we can't compare
   // their request time to the time spent waiting on the extension. Just ignore
   // them.
   // TODO(mpcomplete): may want to count cancels as "bonuses" for an extension.
   // i.e. if it slows down 50% of requests but cancels 25% of the rest, that
   // might average out to only being "25% slow".
   request_time_logs_.erase(request_id);
 }
 
-void ExtensionWebRequestTimeTracker::SetRequestRedirected(int64 request_id) {
+void ExtensionWebRequestTimeTracker::SetRequestRedirected(int64_t request_id) {
   // When a request is redirected, we have no way of knowing how long the
   // request would have taken, so we can't say how much an extension slowed
   // down this request. Just ignore it.
   request_time_logs_.erase(request_id);
 }
 
 void ExtensionWebRequestTimeTracker::SetDelegate(
     ExtensionWebRequestTimeTrackerDelegate* delegate) {
   delegate_.reset(delegate);
 }