Switch to standard integer types in extensions/browser/.

extensions/browser/process_manager.h

 // 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.
 
 #ifndef EXTENSIONS_BROWSER_PROCESS_MANAGER_H_
 #define EXTENSIONS_BROWSER_PROCESS_MANAGER_H_
 
+#include <stdint.h>
+
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "components/keyed_service/core/keyed_service.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "extensions/browser/event_page_tracker.h"
 #include "extensions/browser/extension_registry_observer.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/view_type.h"
@@ skipping 97 matching lines @@
   // called regularly.
   void KeepaliveImpulse(const Extension* extension);
 
   // Triggers a keepalive impulse for a plugin (e.g NaCl).
   static void OnKeepaliveFromPlugin(int render_process_id,
                                     int render_frame_id,
                                     const std::string& extension_id);
 
   // Handles a response to the ShouldSuspend message, used for lazy background
   // pages.
-  void OnShouldSuspendAck(const std::string& extension_id, uint64 sequence_id);
+  void OnShouldSuspendAck(const std::string& extension_id,
+                          uint64_t sequence_id);
 
   // Same as above, for the Suspend message.
   void OnSuspendAck(const std::string& extension_id);
 
   // Tracks network requests for a given RenderFrameHost, used to know
   // when network activity is idle for lazy background pages.
   void OnNetworkRequestStarted(content::RenderFrameHost* render_frame_host,
-                               uint64 request_id);
+                               uint64_t request_id);
   void OnNetworkRequestDone(content::RenderFrameHost* render_frame_host,
-                            uint64 request_id);
+                            uint64_t request_id);
 
   // Prevents |extension|'s background page from being closed and sends the
   // onSuspendCanceled() event to it.
   void CancelSuspend(const Extension* extension);
 
   // Called on shutdown to close our extension hosts.
   void CloseBackgroundHosts();
 
   // Sets callbacks for testing keepalive impulse behavior.
   using ImpulseCallbackForTesting =
@@ skipping 99 matching lines @@
   // Internal implementation of DecrementLazyKeepaliveCount with an
   // |extension_id| known to have a lazy background page.
   void DecrementLazyKeepaliveCount(const std::string& extension_id);
 
   // Checks if keepalive impulses have occured, and adjusts keep alive count.
   void OnKeepaliveImpulseCheck();
 
   // These are called when the extension transitions between idle and active.
   // They control the process of closing the background page when idle.
   void OnLazyBackgroundPageIdle(const std::string& extension_id,
-                                uint64 sequence_id);
+                                uint64_t sequence_id);
   void OnLazyBackgroundPageActive(const std::string& extension_id);
   void CloseLazyBackgroundPageNow(const std::string& extension_id,
-                                  uint64 sequence_id);
+                                  uint64_t sequence_id);
 
   void OnDevToolsStateChanged(content::DevToolsAgentHost*, bool attached);
 
   // Unregister RenderFrameHosts and clear background page data for an extension
   // which has been unloaded.
   void UnregisterExtension(const std::string& extension_id);
 
   // Clears background page data for this extension.
   void ClearBackgroundPageData(const std::string& extension_id);
 
@@ skipping 33 matching lines @@
   // lazy background process.
   //
   // Any interruption obtains a new ID by incrementing
   // last_background_close_sequence_id_ and storing it in background_page_data_
   // for a particular extension. Callbacks and round-trip IPC messages store the
   // value of the extension's close_sequence_id at the beginning of the process.
   // Thus comparisons can be done to halt when IDs no longer match.
   //
   // This counter provides unique IDs even when BackgroundPageData objects are
   // reset.
-  uint64 last_background_close_sequence_id_;
+  uint64_t last_background_close_sequence_id_;
 
   // Tracks pending network requests by opaque ID. This is used to ensure proper
   // keepalive counting in response to request status updates; e.g., if an
   // extension URLRequest is constructed and then destroyed without ever
   // starting, we can receive a completion notification without a corresponding
   // start notification. In that case we want to avoid decrementing keepalive.
   std::set<int> pending_network_requests_;
 
   // Must be last member, see doc on WeakPtrFactory.
   base::WeakPtrFactory<ProcessManager> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ProcessManager);
 };
 
 }  // namespace extensions
 
 #endif  // EXTENSIONS_BROWSER_PROCESS_MANAGER_H_