Switch to standard integer types in extensions/browser/.

extensions/browser/process_manager.cc

 // Copyright 2013 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/process_manager.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/stl_util.h"
 #include "base/time/time.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/render_view_host.h"
@@ skipping 108 matching lines @@
   // dispatching the suspend event. During this time any events that arrive will
   // cancel the suspend process and an onSuspendCanceled event will be
   // dispatched to the page.
   bool is_closing;
 
   // Stores the value of the incremented
   // ProcessManager::last_background_close_sequence_id_ whenever the extension
   // is active. A copy of the ID is also passed in the callbacks and IPC
   // messages leading up to CloseLazyBackgroundPageNow. The process is aborted
   // if the IDs ever differ due to new activity.
-  uint64 close_sequence_id;
+  uint64_t close_sequence_id;
 
   // Keeps track of when this page was last suspended. Used for perf metrics.
   linked_ptr<base::ElapsedTimer> since_suspended;
 
   BackgroundPageData()
       : lazy_keepalive_count(0),
         keepalive_impulse(false),
         previous_keepalive_impulse(false),
         is_closing(false),
         close_sequence_id(0) {}
@@ skipping 386 matching lines @@
   const Extension* extension =
       ExtensionRegistry::Get(browser_context)->enabled_extensions().GetByID(
           extension_id);
   if (!extension)
     return;
 
   ProcessManager::Get(browser_context)->KeepaliveImpulse(extension);
 }
 
 void ProcessManager::OnShouldSuspendAck(const std::string& extension_id,
-                                        uint64 sequence_id) {
+                                        uint64_t sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     host->render_process_host()->Send(new ExtensionMsg_Suspend(extension_id));
   }
 }
 
 void ProcessManager::OnSuspendAck(const std::string& extension_id) {
   background_page_data_[extension_id].is_closing = true;
-  uint64 sequence_id = background_page_data_[extension_id].close_sequence_id;
+  uint64_t sequence_id = background_page_data_[extension_id].close_sequence_id;
   base::MessageLoop::current()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&ProcessManager::CloseLazyBackgroundPageNow,
                  weak_ptr_factory_.GetWeakPtr(),
                  extension_id,
                  sequence_id),
       base::TimeDelta::FromMilliseconds(g_event_page_suspending_time_msec));
 }
 
 void ProcessManager::OnNetworkRequestStarted(
     content::RenderFrameHost* render_frame_host,
-    uint64 request_id) {
+    uint64_t request_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(
       GetExtensionID(render_frame_host));
   auto result = pending_network_requests_.insert(request_id);
   DCHECK(result.second) << "Duplicate network request IDs.";
   if (host && IsFrameInExtensionHost(host, render_frame_host)) {
     IncrementLazyKeepaliveCount(host->extension());
     host->OnNetworkRequestStarted(request_id);
   }
 }
 
 void ProcessManager::OnNetworkRequestDone(
     content::RenderFrameHost* render_frame_host,
-    uint64 request_id) {
+    uint64_t request_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(
       GetExtensionID(render_frame_host));
   if (host && IsFrameInExtensionHost(host, render_frame_host)) {
     host->OnNetworkRequestDone(request_id);
     if (pending_network_requests_.erase(request_id))
       DecrementLazyKeepaliveCount(host->extension());
   }
 }
 
 void ProcessManager::CancelSuspend(const Extension* extension) {
@@ skipping 220 matching lines @@
   if (base::MessageLoop::current()) {
     base::MessageLoop::current()->PostDelayedTask(
         FROM_HERE,
         base::Bind(&ProcessManager::OnKeepaliveImpulseCheck,
                    weak_ptr_factory_.GetWeakPtr()),
         base::TimeDelta::FromMilliseconds(g_event_page_idle_time_msec));
   }
 }
 
 void ProcessManager::OnLazyBackgroundPageIdle(const std::string& extension_id,
-                                              uint64 sequence_id) {
+                                              uint64_t sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host && !background_page_data_[extension_id].is_closing &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     // Tell the renderer we are about to close. This is a simple ping that the
     // renderer will respond to. The purpose is to control sequencing: if the
     // extension remains idle until the renderer responds with an ACK, then we
     // know that the extension process is ready to shut down. If our
     // close_sequence_id has already changed, then we would ignore the
     // ShouldSuspendAck, so we don't send the ping.
     host->render_process_host()->Send(new ExtensionMsg_ShouldSuspend(
         extension_id, sequence_id));
   }
 }
 
 void ProcessManager::OnLazyBackgroundPageActive(
     const std::string& extension_id) {
   if (!background_page_data_[extension_id].is_closing) {
     // Cancel the current close sequence by changing the close_sequence_id,
     // which causes us to ignore the next ShouldSuspendAck.
     background_page_data_[extension_id].close_sequence_id =
         ++last_background_close_sequence_id_;
   }
 }
 
 void ProcessManager::CloseLazyBackgroundPageNow(const std::string& extension_id,
-                                                uint64 sequence_id) {
+                                                uint64_t sequence_id) {
   ExtensionHost* host = GetBackgroundHostForExtension(extension_id);
   if (host &&
       sequence_id == background_page_data_[extension_id].close_sequence_id) {
     // Handle the case where the keepalive count was increased after the
     // OnSuspend event was sent.
     if (background_page_data_[extension_id].lazy_keepalive_count > 0) {
       CancelSuspend(host->extension());
       return;
     }
 
@@ skipping 117 matching lines @@
   if (extension && !IncognitoInfo::IsSplitMode(extension)) {
     BrowserContext* original_context =
         ExtensionsBrowserClient::Get()->GetOriginalContext(browser_context());
     return ProcessManager::Get(original_context)->GetSiteInstanceForURL(url);
   }
 
   return ProcessManager::GetSiteInstanceForURL(url);
 }
 
 }  // namespace extensions