Switch to standard integer types in content/renderer/.

content/renderer/dom_storage/dom_storage_dispatcher.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/renderer/dom_storage/dom_storage_dispatcher.h"
 
 #include <list>
 #include <map>
 
 #include "base/strings/string_number_conversions.h"
@@ skipping 81 matching lines @@
 
 // ProxyImpl -----------------------------------------------------
 // An implementation of the DOMStorageProxy interface in terms of IPC.
 // This class also manages the collection of cached areas and pending
 // operations awaiting completion callbacks.
 class DomStorageDispatcher::ProxyImpl : public DOMStorageProxy {
  public:
   explicit ProxyImpl(RenderThreadImpl* sender);
 
   // Methods for use by DomStorageDispatcher directly.
-  DOMStorageCachedArea* OpenCachedArea(
-      int64 namespace_id, const GURL& origin);
+  DOMStorageCachedArea* OpenCachedArea(int64_t namespace_id,
+                                       const GURL& origin);
   void CloseCachedArea(DOMStorageCachedArea* area);
-  DOMStorageCachedArea* LookupCachedArea(
-      int64 namespace_id, const GURL& origin);
+  DOMStorageCachedArea* LookupCachedArea(int64_t namespace_id,
+                                         const GURL& origin);
   void CompleteOnePendingCallback(bool success);
   void Shutdown();
 
   // DOMStorageProxy interface for use by DOMStorageCachedArea.
   void LoadArea(int connection_id,
                 DOMStorageValuesMap* values,
                 const CompletionCallback& callback) override;
   void SetItem(int connection_id,
                const base::string16& key,
                const base::string16& value,
@@ skipping 31 matching lines @@
   }
 
   CompletionCallback PopPendingCallback() {
     CompletionCallback callback = pending_callbacks_.front();
     pending_callbacks_.pop_front();
     if (pending_callbacks_.empty())
       blink::Platform::current()->suddenTerminationChanged(true);
     return callback;
   }
 
-  std::string GetCachedAreaKey(int64 namespace_id, const GURL& origin) {
+  std::string GetCachedAreaKey(int64_t namespace_id, const GURL& origin) {
     return base::Int64ToString(namespace_id) + origin.spec();
   }
 
   CachedAreaHolder* GetAreaHolder(const std::string& key) {
     CachedAreaMap::iterator found = cached_areas_.find(key);
     if (found == cached_areas_.end())
       return NULL;
     return &(found->second);
   }
 
   RenderThreadImpl* sender_;
   CachedAreaMap cached_areas_;
   CallbackList pending_callbacks_;
   scoped_refptr<MessageThrottlingFilter> throttling_filter_;
 };
 
 DomStorageDispatcher::ProxyImpl::ProxyImpl(RenderThreadImpl* sender)
     : sender_(sender),
       throttling_filter_(new MessageThrottlingFilter(sender)) {
   sender_->AddFilter(throttling_filter_.get());
 }
 
 DOMStorageCachedArea* DomStorageDispatcher::ProxyImpl::OpenCachedArea(
-    int64 namespace_id, const GURL& origin) {
+    int64_t namespace_id,
+    const GURL& origin) {
   std::string key = GetCachedAreaKey(namespace_id, origin);
   if (CachedAreaHolder* holder = GetAreaHolder(key)) {
     ++(holder->open_count_);
     return holder->area_.get();
   }
   scoped_refptr<DOMStorageCachedArea> area =
       new DOMStorageCachedArea(namespace_id, origin, this);
   cached_areas_[key] = CachedAreaHolder(area.get(), 1);
   return area.get();
 }
 
 void DomStorageDispatcher::ProxyImpl::CloseCachedArea(
     DOMStorageCachedArea* area) {
   std::string key = GetCachedAreaKey(area->namespace_id(), area->origin());
   CachedAreaHolder* holder = GetAreaHolder(key);
   DCHECK(holder);
   DCHECK_EQ(holder->area_.get(), area);
   DCHECK_GT(holder->open_count_, 0);
   if (--(holder->open_count_) == 0) {
     cached_areas_.erase(key);
   }
 }
 
 DOMStorageCachedArea* DomStorageDispatcher::ProxyImpl::LookupCachedArea(
-    int64 namespace_id, const GURL& origin) {
+    int64_t namespace_id,
+    const GURL& origin) {
   std::string key = GetCachedAreaKey(namespace_id, origin);
   CachedAreaHolder* holder = GetAreaHolder(key);
   if (!holder)
     return NULL;
   return holder->area_.get();
 }
 
 void DomStorageDispatcher::ProxyImpl::CompleteOnePendingCallback(bool success) {
   PopPendingCallback().Run(success);
 }
@@ skipping 43 matching lines @@
 
 DomStorageDispatcher::DomStorageDispatcher()
     : proxy_(new ProxyImpl(RenderThreadImpl::current())) {
 }
 
 DomStorageDispatcher::~DomStorageDispatcher() {
   proxy_->Shutdown();
 }
 
 scoped_refptr<DOMStorageCachedArea> DomStorageDispatcher::OpenCachedArea(
-    int connection_id, int64 namespace_id, const GURL& origin) {
+    int connection_id,
+    int64_t namespace_id,
+    const GURL& origin) {
   RenderThreadImpl::current()->Send(
       new DOMStorageHostMsg_OpenStorageArea(
           connection_id, namespace_id, origin));
   return proxy_->OpenCachedArea(namespace_id, origin);
 }
 
 void DomStorageDispatcher::CloseCachedArea(
     int connection_id, DOMStorageCachedArea* area) {
   RenderThreadImpl::current()->Send(
       new DOMStorageHostMsg_CloseStorageArea(connection_id));
@@ skipping 49 matching lines @@
         originating_area,
         originated_in_process);
   }
 }
 
 void DomStorageDispatcher::OnAsyncOperationComplete(bool success) {
   proxy_->CompleteOnePendingCallback(success);
 }
 
 }  // namespace content