Switch to standard integer types in components/, part 3 of 4.

components/sessions/core/persistent_tab_restore_service.cc

 // Copyright 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 "components/sessions/core/persistent_tab_restore_service.h"
 
-#include <cstring>  // memcpy
+#include <stddef.h>
+#include <stdint.h>
+#include <string.h>
+
 #include <vector>
 
-#include "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
+#include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
 #include "base/task/cancelable_task_tracker.h"
 #include "base/time/time.h"
 #include "components/sessions/core/base_session_service.h"
 #include "components/sessions/core/base_session_service_commands.h"
 #include "components/sessions/core/base_session_service_delegate.h"
 #include "components/sessions/core/session_command.h"
 #include "components/sessions/core/session_constants.h"
 
 namespace sessions {
 
 namespace {
 
 // Only written if the tab is pinned.
 typedef bool PinnedStatePayload;
 
-typedef int32 RestoredEntryPayload;
+typedef int32_t RestoredEntryPayload;
 
 typedef std::map<SessionID::id_type, TabRestoreService::Entry*> IDToEntry;
 
 // Payload used for the start of a tab close. This is the old struct that is
 // used for backwards compat when it comes to reading the session files.
 struct SelectedNavigationInTabPayload {
   SessionID::id_type id;
-  int32 index;
+  int32_t index;
 };
 
 // Payload used for the start of a window close. This is the old struct that is
 // used for backwards compat when it comes to reading the session files. This
 // struct must be POD, because we memset the contents.
 struct WindowPayload {
   SessionID::id_type window_id;
-  int32 selected_tab_index;
-  int32 num_tabs;
+  int32_t selected_tab_index;
+  int32_t num_tabs;
 };
 
 // Payload used for the start of a window close.  This struct must be POD,
 // because we memset the contents.
 struct WindowPayload2 : WindowPayload {
-  int64 timestamp;
+  int64_t timestamp;
 };
 
 // Payload used for the start of a tab close.
 struct SelectedNavigationInTabPayload2 : SelectedNavigationInTabPayload {
-  int64 timestamp;
+  int64_t timestamp;
 };
 
 // Used to indicate what has loaded.
 enum LoadState {
   // Indicates we haven't loaded anything.
   NOT_LOADED           = 1 << 0,
 
   // Indicates we've asked for the last sessions and tabs but haven't gotten the
   // result back yet.
   LOADING              = 1 << 2,
@@ skipping 87 matching lines @@
 
   // Creates a window close command.
   static scoped_ptr<SessionCommand> CreateWindowCommand(SessionID::id_type id,
                                                         int selected_tab_index,
                                                         int num_tabs,
                                                         base::Time timestamp);
 
   // Creates a tab close command.
   static scoped_ptr<SessionCommand> CreateSelectedNavigationInTabCommand(
       SessionID::id_type tab_id,
-      int32 index,
+      int32_t index,
       base::Time timestamp);
 
   // Creates a restore command.
   static scoped_ptr<SessionCommand> CreateRestoredEntryCommand(
       SessionID::id_type entry_id);
 
   // Returns the index to persist as the selected index. This is the same as
   // |tab.current_navigation_index| unless the entry at
   // |tab.current_navigation_index| shouldn't be persisted. Returns -1 if no
   // valid navigation to persist.
@@ skipping 321 matching lines @@
   scoped_ptr<SessionCommand> command(
       new SessionCommand(kCommandWindow, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 // static
 scoped_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateSelectedNavigationInTabCommand(
     SessionID::id_type tab_id,
-    int32 index,
+    int32_t index,
     base::Time timestamp) {
   SelectedNavigationInTabPayload2 payload;
   payload.id = tab_id;
   payload.index = index;
   payload.timestamp = timestamp.ToInternalValue();
   scoped_ptr<SessionCommand> command(
       new SessionCommand(kCommandSelectedNavigationInTab, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
@@ skipping 469 matching lines @@
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 }  // namespace sessions