Switch to standard integer types in content/browser/.

content/browser/appcache/appcache.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 "content/browser/appcache/appcache.h"
 
+#include <stddef.h>
+
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "content/browser/appcache/appcache_executable_handler.h"
 #include "content/browser/appcache/appcache_group.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_storage.h"
 #include "content/common/appcache_interfaces.h"
 
 namespace content {
 
-AppCache::AppCache(AppCacheStorage* storage, int64 cache_id)
+AppCache::AppCache(AppCacheStorage* storage, int64_t cache_id)
     : cache_id_(cache_id),
       owning_group_(NULL),
       online_whitelist_all_(false),
       is_complete_(false),
       cache_size_(0),
       storage_(storage) {
   storage_->working_set()->AddCache(this);
 }
 
 AppCache::~AppCache() {
@@ skipping 36 matching lines @@
   cache_size_ -= found->second.response_size();
   entries_.erase(found);
 }
 
 AppCacheEntry* AppCache::GetEntry(const GURL& url) {
   EntryMap::iterator it = entries_.find(url);
   return (it != entries_.end()) ? &(it->second) : NULL;
 }
 
 const AppCacheEntry* AppCache::GetEntryAndUrlWithResponseId(
-    int64 response_id, GURL* optional_url_out) {
+    int64_t response_id,
+    GURL* optional_url_out) {
   for (EntryMap::const_iterator iter = entries_.begin();
        iter !=  entries_.end(); ++iter) {
     if (iter->second.response_id() == response_id) {
       if (optional_url_out)
         *optional_url_out = iter->first;
       return &iter->second;
     }
   }
   return NULL;
 }
 
-AppCacheExecutableHandler* AppCache::GetExecutableHandler(int64 response_id) {
+AppCacheExecutableHandler* AppCache::GetExecutableHandler(int64_t response_id) {
   HandlerMap::const_iterator found = executable_handlers_.find(response_id);
   if (found != executable_handlers_.end())
     return found->second;
   return NULL;
 }
 
 AppCacheExecutableHandler* AppCache::GetOrCreateExecutableHandler(
-    int64 response_id, net::IOBuffer* handler_source) {
+    int64_t response_id,
+    net::IOBuffer* handler_source) {
   AppCacheExecutableHandler* handler = GetExecutableHandler(response_id);
   if (handler)
     return handler;
 
   GURL handler_url;
   const AppCacheEntry* entry = GetEntryAndUrlWithResponseId(
       response_id, &handler_url);
   if (!entry || !entry->IsExecutable())
     return NULL;
 
@@ skipping 211 matching lines @@
     const GURL& url) {
   size_t count = namespaces.size();
   for (size_t i = 0; i < count; ++i) {
     if (namespaces[i].IsMatch(url))
       return &namespaces[i];
   }
   return NULL;
 }
 
 }  // namespace content