Convert Pass()→std::move() in //components/[n-z]*

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>
 #include <vector>
 
 #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"
@@ skipping 279 matching lines @@
   }
   if (base_session_service_->pending_reset())
     entries_written_ = 0;
 }
 
 void PersistentTabRestoreService::Delegate::OnClearEntries() {
   // Mark all the tabs as closed so that we don't attempt to restore them.
   const Entries& entries = tab_restore_service_helper_->entries();
   for (Entries::const_iterator i = entries.begin(); i != entries.end(); ++i)
     base_session_service_->ScheduleCommand(
-        CreateRestoredEntryCommand((*i)->id).Pass());
+        CreateRestoredEntryCommand((*i)->id));
 
   entries_to_write_ = 0;
 
   // Schedule a pending reset so that we nuke the file on next write.
   base_session_service_->set_pending_reset(true);
 
   // Schedule a command, otherwise if there are no pending commands Save does
   // nothing.
-  base_session_service_->ScheduleCommand(CreateRestoredEntryCommand(1).Pass());
+  base_session_service_->ScheduleCommand(CreateRestoredEntryCommand(1));
 }
 
 void PersistentTabRestoreService::Delegate::OnRestoreEntryById(
     SessionID::id_type id,
     Entries::const_iterator entry_iterator) {
   size_t index = 0;
   const Entries& entries = tab_restore_service_helper_->entries();
   for (Entries::const_iterator j = entries.begin();
        j != entry_iterator && j != entries.end();
        ++j, ++index) {}
   if (static_cast<int>(index) < entries_to_write_)
     entries_to_write_--;
 
-  base_session_service_->ScheduleCommand(CreateRestoredEntryCommand(id).Pass());
+  base_session_service_->ScheduleCommand(CreateRestoredEntryCommand(id));
 }
 
 void PersistentTabRestoreService::Delegate::OnAddEntry() {
   // Start the save timer, when it fires we'll generate the commands.
   base_session_service_->StartSaveTimer();
   entries_to_write_++;
 }
 
 void PersistentTabRestoreService::Delegate::LoadTabsFromLastSession() {
   if (load_state_ != NOT_LOADED)
@@ skipping 56 matching lines @@
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     if (GetSelectedNavigationIndexToPersist(window.tabs[i]) != -1) {
       valid_tab_count++;
     } else if (static_cast<int>(i) < selected_tab) {
       real_selected_tab--;
     }
   }
   if (valid_tab_count == 0)
     return;  // No tabs to persist.
 
-  base_session_service_->ScheduleCommand(
-      CreateWindowCommand(window.id,
-                          std::min(real_selected_tab, valid_tab_count - 1),
-                          valid_tab_count,
-                          window.timestamp).Pass());
+  base_session_service_->ScheduleCommand(CreateWindowCommand(
+      window.id, std::min(real_selected_tab, valid_tab_count - 1),
+      valid_tab_count, window.timestamp));
 
   if (!window.app_name.empty()) {
-    base_session_service_->ScheduleCommand(
-        CreateSetWindowAppNameCommand(kCommandSetWindowAppName, window.id,
-                                      window.app_name)
-            .Pass());
+    base_session_service_->ScheduleCommand(CreateSetWindowAppNameCommand(
+        kCommandSetWindowAppName, window.id, window.app_name));
   }
 
   for (size_t i = 0; i < window.tabs.size(); ++i) {
     int selected_index = GetSelectedNavigationIndexToPersist(window.tabs[i]);
     if (selected_index != -1)
       ScheduleCommandsForTab(window.tabs[i], selected_index);
   }
 }
 
 void PersistentTabRestoreService::Delegate::ScheduleCommandsForTab(
     const Tab& tab,
     int selected_index) {
   const std::vector<SerializedNavigationEntry>& navigations = tab.navigations;
   int max_index = static_cast<int>(navigations.size());
 
   // Determine the first navigation we'll persist.
   int valid_count_before_selected = 0;
   int first_index_to_persist = selected_index;
   for (int i = selected_index - 1;
        i >= 0 && valid_count_before_selected < gMaxPersistNavigationCount;
        --i) {
     if (client_->ShouldTrackURLForRestore(navigations[i].virtual_url())) {
       first_index_to_persist = i;
       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).Pass());
+  base_session_service_->ScheduleCommand(CreateSelectedNavigationInTabCommand(
+      tab.id, valid_count_before_selected, tab.timestamp));
 
   if (tab.pinned) {
     PinnedStatePayload payload = true;
     scoped_ptr<SessionCommand> command(
         new SessionCommand(kCommandPinnedState, sizeof(payload)));
     memcpy(command->contents(), &payload, sizeof(payload));
-    base_session_service_->ScheduleCommand(command.Pass());
+    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)
-            .Pass());
+    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)
-            .Pass());
+    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]));
@@ skipping 427 matching lines @@
       }
     }
   }
 }
 
 // PersistentTabRestoreService -------------------------------------------------
 
 PersistentTabRestoreService::PersistentTabRestoreService(
     scoped_ptr<TabRestoreServiceClient> client,
     TimeFactory* time_factory)
-    : client_(client.Pass()),
+    : 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(
     TabRestoreServiceObserver* observer) {
   helper_.AddObserver(observer);
@@ skipping 62 matching lines @@
 
 TabRestoreService::Entries* PersistentTabRestoreService::mutable_entries() {
   return &helper_.entries_;
 }
 
 void PersistentTabRestoreService::PruneEntries() {
   helper_.PruneEntries();
 }
 
 }  // namespace sessions