Switch to standard integer types in content/browser/.

content/browser/dom_storage/dom_storage_context_impl.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/dom_storage/dom_storage_context_impl.h"
 
+#include <stddef.h>
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/guid.h"
 #include "base/location.h"
 #include "base/time/time.h"
 #include "content/browser/dom_storage/dom_storage_area.h"
@@ skipping 44 matching lines @@
     session_storage_database_ = NULL;
     task_runner_->PostShutdownBlockingTask(
         FROM_HERE,
         DOMStorageTaskRunner::COMMIT_SEQUENCE,
         base::Bind(&SessionStorageDatabase::Release,
                    base::Unretained(to_release)));
   }
 }
 
 DOMStorageNamespace* DOMStorageContextImpl::GetStorageNamespace(
-    int64 namespace_id) {
+    int64_t namespace_id) {
   if (is_shutdown_)
     return NULL;
   StorageNamespaceMap::iterator found = namespaces_.find(namespace_id);
   if (found == namespaces_.end()) {
     if (namespace_id == kLocalStorageNamespaceId) {
       if (!localstorage_directory_.empty()) {
         if (!base::CreateDirectory(localstorage_directory_)) {
           LOG(ERROR) << "Failed to create 'Local Storage' directory,"
                         " falling back to in-memory only.";
           localstorage_directory_ = base::FilePath();
@@ skipping 59 matching lines @@
   // renderers get emptied out too.
   DOMStorageArea* area = local->GetOpenStorageArea(origin);
   if (area)
     NotifyAreaCleared(area, origin);
 }
 
 void DOMStorageContextImpl::DeleteSessionStorage(
     const SessionStorageUsageInfo& usage_info) {
   DCHECK(!is_shutdown_);
   DOMStorageNamespace* dom_storage_namespace = NULL;
-  std::map<std::string, int64>::const_iterator it =
+  std::map<std::string, int64_t>::const_iterator it =
       persistent_namespace_id_to_namespace_id_.find(
           usage_info.persistent_namespace_id);
   if (it != persistent_namespace_id_to_namespace_id_.end()) {
     dom_storage_namespace = GetStorageNamespace(it->second);
   } else {
-    int64 namespace_id = AllocateSessionId();
+    int64_t namespace_id = AllocateSessionId();
     CreateSessionNamespace(namespace_id, usage_info.persistent_namespace_id);
     dom_storage_namespace = GetStorageNamespace(namespace_id);
   }
   dom_storage_namespace->DeleteSessionStorageOrigin(usage_info.origin);
   // Synthesize a 'cleared' event if the area is open so CachedAreas in
   // renderers get emptied out too.
   DOMStorageArea* area =
       dom_storage_namespace->GetOpenStorageArea(usage_info.origin);
   if (area)
     NotifyAreaCleared(area, usage_info.origin);
@@ skipping 64 matching lines @@
 }
 
 void DOMStorageContextImpl::NotifyAreaCleared(
     const DOMStorageArea* area,
     const GURL& page_url) {
   FOR_EACH_OBSERVER(
       EventObserver, event_observers_,
       OnDOMStorageAreaCleared(area, page_url));
 }
 
-int64 DOMStorageContextImpl::AllocateSessionId() {
+int64_t DOMStorageContextImpl::AllocateSessionId() {
   return session_id_sequence_.GetNext() + session_id_offset_;
 }
 
 std::string DOMStorageContextImpl::AllocatePersistentSessionId() {
   std::string guid = base::GenerateGUID();
   std::replace(guid.begin(), guid.end(), '-', '_');
   return guid;
 }
 
 void DOMStorageContextImpl::CreateSessionNamespace(
-    int64 namespace_id,
+    int64_t namespace_id,
     const std::string& persistent_namespace_id) {
   if (is_shutdown_)
     return;
   DCHECK(namespace_id != kLocalStorageNamespaceId);
   DCHECK(namespaces_.find(namespace_id) == namespaces_.end());
   namespaces_[namespace_id] = new DOMStorageNamespace(
       namespace_id, persistent_namespace_id, session_storage_database_.get(),
       task_runner_.get());
   persistent_namespace_id_to_namespace_id_[persistent_namespace_id] =
       namespace_id;
 }
 
-void DOMStorageContextImpl::DeleteSessionNamespace(
-    int64 namespace_id, bool should_persist_data) {
+void DOMStorageContextImpl::DeleteSessionNamespace(int64_t namespace_id,
+                                                   bool should_persist_data) {
   DCHECK_NE(kLocalStorageNamespaceId, namespace_id);
   StorageNamespaceMap::const_iterator it = namespaces_.find(namespace_id);
   if (it == namespaces_.end())
     return;
   std::string persistent_namespace_id =  it->second->persistent_namespace_id();
   if (session_storage_database_.get()) {
     if (!should_persist_data) {
       task_runner_->PostShutdownBlockingTask(
           FROM_HERE,
           DOMStorageTaskRunner::COMMIT_SEQUENCE,
           base::Bind(
               base::IgnoreResult(&SessionStorageDatabase::DeleteNamespace),
               session_storage_database_,
               persistent_namespace_id));
     } else {
       // Ensure that the data gets committed before we shut down.
       it->second->Shutdown();
       if (!scavenging_started_) {
         // Protect the persistent namespace ID from scavenging.
         protected_persistent_session_ids_.insert(persistent_namespace_id);
       }
     }
   }
   persistent_namespace_id_to_namespace_id_.erase(persistent_namespace_id);
   namespaces_.erase(namespace_id);
 }
 
 void DOMStorageContextImpl::CloneSessionNamespace(
-    int64 existing_id, int64 new_id,
+    int64_t existing_id,
+    int64_t new_id,
     const std::string& new_persistent_id) {
   if (is_shutdown_)
     return;
   DCHECK_NE(kLocalStorageNamespaceId, existing_id);
   DCHECK_NE(kLocalStorageNamespaceId, new_id);
   StorageNamespaceMap::iterator found = namespaces_.find(existing_id);
   if (found != namespaces_.end())
     namespaces_[new_id] = found->second->Clone(new_id, new_persistent_id);
   else
     CreateSessionNamespace(new_id, new_persistent_id);
@@ skipping 111 matching lines @@
   if (!deletable_persistent_namespace_ids_.empty()) {
     task_runner_->PostDelayedTask(
         FROM_HERE, base::Bind(
             &DOMStorageContextImpl::DeleteNextUnusedNamespace,
             this),
         base::TimeDelta::FromSeconds(kSessionStoraceScavengingSeconds));
   }
 }
 
 }  // namespace content