Convert //components/[u-z]* from scoped_ptr to std::unique_ptr

components/undo/undo_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 "components/undo/undo_manager.h"
 
 #include <utility>
 
 #include "base/auto_reset.h"
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 // UndoGroup ------------------------------------------------------------------
 
 UndoGroup::UndoGroup()
     : undo_label_id_(IDS_BOOKMARK_BAR_UNDO),
       redo_label_id_(IDS_BOOKMARK_BAR_REDO) {
 }
 
 UndoGroup::~UndoGroup() {
 }
 
-void UndoGroup::AddOperation(scoped_ptr<UndoOperation> operation) {
+void UndoGroup::AddOperation(std::unique_ptr<UndoOperation> operation) {
   if (operations_.empty()) {
     set_undo_label_id(operation->GetUndoLabelId());
     set_redo_label_id(operation->GetRedoLabelId());
   }
   operations_.push_back(operation.release());
 }
 
 void UndoGroup::Undo() {
   for (ScopedVector<UndoOperation>::reverse_iterator ri = operations_.rbegin();
        ri != operations_.rend(); ++ri) {
@@ skipping 31 matching lines @@
       undo_actions_.empty() ? IDS_BOOKMARK_BAR_UNDO
                             : undo_actions_.back()->get_undo_label_id());
 }
 
 base::string16 UndoManager::GetRedoLabel() const {
   return l10n_util::GetStringUTF16(
       redo_actions_.empty() ? IDS_BOOKMARK_BAR_REDO
                             : redo_actions_.back()->get_redo_label_id());
 }
 
-void UndoManager::AddUndoOperation(scoped_ptr<UndoOperation> operation) {
+void UndoManager::AddUndoOperation(std::unique_ptr<UndoOperation> operation) {
   if (IsUndoTrakingSuspended()) {
     RemoveAllOperations();
     operation.reset();
     return;
   }
 
   if (group_actions_count_) {
     pending_grouped_action_->AddOperation(std::move(operation));
   } else {
     UndoGroup* new_action = new UndoGroup();
@@ skipping 86 matching lines @@
 
 void UndoManager::Undo(bool* performing_indicator,
                        ScopedVector<UndoGroup>* active_undo_group) {
   // Check that action grouping has been correctly ended.
   DCHECK(!group_actions_count_);
 
   if (active_undo_group->empty())
     return;
 
   base::AutoReset<bool> incoming_changes(performing_indicator, true);
-  scoped_ptr<UndoGroup> action(active_undo_group->back());
+  std::unique_ptr<UndoGroup> action(active_undo_group->back());
   base::AutoReset<UndoGroup*> action_context(&undo_in_progress_action_,
       action.get());
   active_undo_group->weak_erase(
       active_undo_group->begin() + active_undo_group->size() - 1);
 
   StartGroupingActions();
   action->Undo();
   EndGroupingActions();
 
   NotifyOnUndoManagerStateChange();
@@ skipping 14 matching lines @@
   // Limit the number of undo levels so the undo stack does not grow unbounded.
   if (GetActiveUndoGroup()->size() > kMaxUndoGroups)
     GetActiveUndoGroup()->erase(GetActiveUndoGroup()->begin());
 
   NotifyOnUndoManagerStateChange();
 }
 
 ScopedVector<UndoGroup>* UndoManager::GetActiveUndoGroup() {
   return performing_undo_ ? &redo_actions_ : &undo_actions_;
 }