Move undo files into //components/undo

chrome/browser/undo/undo_manager.cc

Index: chrome/browser/undo/undo_manager.cc
diff --git a/chrome/browser/undo/undo_manager.cc b/chrome/browser/undo/undo_manager.cc
deleted file mode 100644
index 3caa709600a36eaf520e482412c2d1004656cfc1..0000000000000000000000000000000000000000
--- a/chrome/browser/undo/undo_manager.cc
+++ /dev/null
@@ -1,224 +0,0 @@
-// 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 "chrome/browser/undo/undo_manager.h"
-
-#include "base/auto_reset.h"
-#include "base/logging.h"
-#include "chrome/browser/undo/undo_manager_observer.h"
-#include "chrome/browser/undo/undo_operation.h"
-#include "grit/components_strings.h"
-#include "ui/base/l10n/l10n_util.h"
-
-namespace {
-
-// Maximum number of changes that can be undone.
-const size_t kMaxUndoGroups = 100;
-
-}  // namespace
-
-// 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) {
-  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) {
-    (*ri)->Undo();
-  }
-}
-
-// UndoManager ----------------------------------------------------------------
-
-UndoManager::UndoManager()
-    : group_actions_count_(0),
-      undo_in_progress_action_(NULL),
-      undo_suspended_count_(0),
-      performing_undo_(false),
-      performing_redo_(false) {
-}
-
-UndoManager::~UndoManager() {
-  DCHECK_EQ(0, group_actions_count_);
-  DCHECK_EQ(0, undo_suspended_count_);
-  DCHECK(!performing_undo_);
-  DCHECK(!performing_redo_);
-}
-
-void UndoManager::Undo() {
-  Undo(&performing_undo_, &undo_actions_);
-}
-
-void UndoManager::Redo() {
-  Undo(&performing_redo_, &redo_actions_);
-}
-
-base::string16 UndoManager::GetUndoLabel() const {
-  return l10n_util::GetStringUTF16(
-      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) {
-  if (IsUndoTrakingSuspended()) {
-    RemoveAllOperations();
-    operation.reset();
-    return;
-  }
-
-  if (group_actions_count_) {
-    pending_grouped_action_->AddOperation(operation.Pass());
-  } else {
-    UndoGroup* new_action = new UndoGroup();
-    new_action->AddOperation(operation.Pass());
-    AddUndoGroup(new_action);
-  }
-}
-
-void UndoManager::StartGroupingActions() {
-  if (!group_actions_count_)
-    pending_grouped_action_.reset(new UndoGroup());
-  ++group_actions_count_;
-}
-
-void UndoManager::EndGroupingActions() {
-  --group_actions_count_;
-  if (group_actions_count_ > 0)
-    return;
-
-  // Check that StartGroupingActions and EndGroupingActions are paired.
-  DCHECK_GE(group_actions_count_, 0);
-
-  bool is_user_action = !performing_undo_ && !performing_redo_;
-  if (!pending_grouped_action_->undo_operations().empty()) {
-    AddUndoGroup(pending_grouped_action_.release());
-  } else {
-    // No changes were executed since we started grouping actions, so the
-    // pending UndoGroup should be discarded.
-    pending_grouped_action_.reset();
-
-    // This situation is only expected when it is a user initiated action.
-    // Undo/Redo should have at least one operation performed.
-    DCHECK(is_user_action);
-  }
-}
-
-void UndoManager::SuspendUndoTracking() {
-  ++undo_suspended_count_;
-}
-
-void UndoManager::ResumeUndoTracking() {
-  DCHECK_GT(undo_suspended_count_, 0);
-  --undo_suspended_count_;
-}
-
-bool UndoManager::IsUndoTrakingSuspended() const {
-  return undo_suspended_count_ > 0;
-}
-
-std::vector<UndoOperation*> UndoManager::GetAllUndoOperations() const {
-  std::vector<UndoOperation*> result;
-  for (size_t i = 0; i < undo_actions_.size(); ++i) {
-    const std::vector<UndoOperation*>& operations =
-        undo_actions_[i]->undo_operations();
-    result.insert(result.end(), operations.begin(), operations.end());
-  }
-  for (size_t i = 0; i < redo_actions_.size(); ++i) {
-    const std::vector<UndoOperation*>& operations =
-        redo_actions_[i]->undo_operations();
-    result.insert(result.end(), operations.begin(), operations.end());
-  }
-  // Ensure that if an Undo is in progress the UndoOperations part of that
-  // UndoGroup are included in the returned set. This will ensure that any
-  // changes (such as renumbering) will be applied to any potentially
-  // unprocessed UndoOperations.
-  if (undo_in_progress_action_) {
-    const std::vector<UndoOperation*>& operations =
-        undo_in_progress_action_->undo_operations();
-    result.insert(result.end(), operations.begin(), operations.end());
-  }
-
-  return result;
-}
-
-void UndoManager::RemoveAllOperations() {
-  DCHECK(!group_actions_count_);
-  undo_actions_.clear();
-  redo_actions_.clear();
-
-  NotifyOnUndoManagerStateChange();
-}
-
-void UndoManager::AddObserver(UndoManagerObserver* observer) {
-  observers_.AddObserver(observer);
-}
-
-void UndoManager::RemoveObserver(UndoManagerObserver* observer) {
-  observers_.RemoveObserver(observer);
-}
-
-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());
-  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();
-}
-
-void UndoManager::NotifyOnUndoManagerStateChange() {
-  FOR_EACH_OBSERVER(
-      UndoManagerObserver, observers_, OnUndoManagerStateChange());
-}
-
-void UndoManager::AddUndoGroup(UndoGroup* new_undo_group) {
-  GetActiveUndoGroup()->push_back(new_undo_group);
-
-  // User actions invalidate any available redo actions.
-  if (is_user_action())
-    redo_actions_.clear();
-
-  // 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_;
-}