Convert //components/sessions from scoped_ptr to std::unique_ptr

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 <stddef.h>
 #include <stdint.h>
 #include <string.h>
 #include <utility>
@@ skipping 143 matching lines @@
   void Shutdown();
 
   // Schedules the commands for a window close.
   void ScheduleCommandsForWindow(const Window& window);
 
   // Schedules the commands for a tab close. |selected_index| gives the index of
   // the selected navigation.
   void ScheduleCommandsForTab(const Tab& tab, int selected_index);
 
   // Creates a window close command.
-  static scoped_ptr<SessionCommand> CreateWindowCommand(SessionID::id_type id,
-                                                        int selected_tab_index,
-                                                        int num_tabs,
-                                                        base::Time timestamp);
+  static std::unique_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(
+  static std::unique_ptr<SessionCommand> CreateSelectedNavigationInTabCommand(
       SessionID::id_type tab_id,
       int32_t index,
       base::Time timestamp);
 
   // Creates a restore command.
-  static scoped_ptr<SessionCommand> CreateRestoredEntryCommand(
+  static std::unique_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.
   int GetSelectedNavigationIndexToPersist(const Tab& tab);
 
   // Invoked when we've loaded the session commands that identify the previously
   // closed tabs. This creates entries, adds them to staging_entries_, and
@@ skipping 29 matching lines @@
   // deleted and removed from both |id_to_entry| and |entries|. This is used
   // when creating entries from the backend file.
   void RemoveEntryByID(SessionID::id_type id,
                        IDToEntry* id_to_entry,
                        std::vector<TabRestoreService::Entry*>* entries);
 
  private:
   // The associated client.
   TabRestoreServiceClient* client_;
 
-  scoped_ptr<BaseSessionService> base_session_service_;
+  std::unique_ptr<BaseSessionService> base_session_service_;
 
   TabRestoreServiceHelper* tab_restore_service_helper_;
 
   // The number of entries to write.
   int entries_to_write_;
 
   // Number of entries we've written.
   int entries_written_;
 
   // Whether we've loaded the last session.
@@ skipping 137 matching lines @@
 
 bool PersistentTabRestoreService::Delegate::IsLoaded() const {
   return !(load_state_ & (NOT_LOADED | LOADING));
 }
 
 // static
 void PersistentTabRestoreService::Delegate::CreateEntriesFromWindows(
     std::vector<SessionWindow*>* windows,
     std::vector<Entry*>* entries) {
   for (size_t i = 0; i < windows->size(); ++i) {
-    scoped_ptr<Window> window(new Window());
+    std::unique_ptr<Window> window(new Window());
     if (ConvertSessionWindowToWindow((*windows)[i], window.get()))
       entries->push_back(window.release());
   }
 }
 
 void PersistentTabRestoreService::Delegate::Shutdown() {
   base_session_service_->Save();
 }
 
 void PersistentTabRestoreService::Delegate::ScheduleCommandsForWindow(
@@ skipping 45 matching lines @@
       valid_count_before_selected++;
     }
   }
 
   // Write the command that identifies the selected tab.
   base_session_service_->ScheduleCommand(CreateSelectedNavigationInTabCommand(
       tab.id, valid_count_before_selected, tab.timestamp));
 
   if (tab.pinned) {
     PinnedStatePayload payload = true;
-    scoped_ptr<SessionCommand> command(
+    std::unique_ptr<SessionCommand> command(
         new SessionCommand(kCommandPinnedState, sizeof(payload)));
     memcpy(command->contents(), &payload, sizeof(payload));
     base_session_service_->ScheduleCommand(std::move(command));
   }
 
   if (!tab.extension_app_id.empty()) {
     base_session_service_->ScheduleCommand(CreateSetTabExtensionAppIDCommand(
         kCommandSetExtensionAppID, tab.id, tab.extension_app_id));
   }
 
   if (!tab.user_agent_override.empty()) {
     base_session_service_->ScheduleCommand(CreateSetTabUserAgentOverrideCommand(
         kCommandSetTabUserAgentOverride, tab.id, tab.user_agent_override));
   }
 
   // Then write the navigations.
   for (int i = first_index_to_persist, wrote_count = 0;
        wrote_count < 2 * gMaxPersistNavigationCount && i < max_index; ++i) {
     if (client_->ShouldTrackURLForRestore(navigations[i].virtual_url())) {
       base_session_service_->ScheduleCommand(
           CreateUpdateTabNavigationCommand(kCommandUpdateTabNavigation,
                                            tab.id,
                                            navigations[i]));
     }
   }
 }
 
 // static
-scoped_ptr<SessionCommand>
+std::unique_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateWindowCommand(
     SessionID::id_type id,
     int selected_tab_index,
     int num_tabs,
     base::Time timestamp) {
   WindowPayload2 payload;
   // |timestamp| is aligned on a 16 byte boundary, leaving 4 bytes of
   // uninitialized memory in the struct.
   memset(&payload, 0, sizeof(payload));
   payload.window_id = id;
   payload.selected_tab_index = selected_tab_index;
   payload.num_tabs = num_tabs;
   payload.timestamp = timestamp.ToInternalValue();
 
-  scoped_ptr<SessionCommand> command(
+  std::unique_ptr<SessionCommand> command(
       new SessionCommand(kCommandWindow, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 // static
-scoped_ptr<SessionCommand>
+std::unique_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateSelectedNavigationInTabCommand(
     SessionID::id_type tab_id,
     int32_t index,
     base::Time timestamp) {
   SelectedNavigationInTabPayload2 payload;
   payload.id = tab_id;
   payload.index = index;
   payload.timestamp = timestamp.ToInternalValue();
-  scoped_ptr<SessionCommand> command(
+  std::unique_ptr<SessionCommand> command(
       new SessionCommand(kCommandSelectedNavigationInTab, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 // static
-scoped_ptr<SessionCommand>
+std::unique_ptr<SessionCommand>
 PersistentTabRestoreService::Delegate::CreateRestoredEntryCommand(
     SessionID::id_type entry_id) {
   RestoredEntryPayload payload = entry_id;
-  scoped_ptr<SessionCommand> command(
+  std::unique_ptr<SessionCommand> command(
       new SessionCommand(kCommandRestoredEntry, sizeof(payload)));
   memcpy(command->contents(), &payload, sizeof(payload));
   return command;
 }
 
 int PersistentTabRestoreService::Delegate::GetSelectedNavigationIndexToPersist(
     const Tab& tab) {
   const std::vector<SerializedNavigationEntry>& navigations = tab.navigations;
   int selected_index = tab.current_navigation_index;
   int max_index = static_cast<int>(navigations.size());
@@ skipping 367 matching lines @@
           return;
         }
       }
     }
   }
 }
 
 // PersistentTabRestoreService -------------------------------------------------
 
 PersistentTabRestoreService::PersistentTabRestoreService(
-    scoped_ptr<TabRestoreServiceClient> client,
+    std::unique_ptr<TabRestoreServiceClient> client,
     TimeFactory* time_factory)
     : client_(std::move(client)),
       delegate_(new Delegate(client_.get())),
       helper_(this, delegate_.get(), client_.get(), time_factory) {
   delegate_->set_tab_restore_service_helper(&helper_);
 }
 
 PersistentTabRestoreService::~PersistentTabRestoreService() {}
 
 void PersistentTabRestoreService::AddObserver(
@@ skipping 62 matching lines @@
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 }  // namespace sessions