Remove stl_util's deletion functions from tab_strip_model, and do other modernization.

chrome/browser/ui/tabs/tab_strip_model.cc

 // Copyright (c) 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 "chrome/browser/ui/tabs/tab_strip_model.h"
 
 #include <algorithm>
 #include <map>
 #include <set>
 #include <string>
 
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram_macros.h"
-#include "base/stl_util.h"
 #include "chrome/app/chrome_command_ids.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/tab_helper.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper.h"
 #include "chrome/browser/ui/tab_contents/core_tab_helper_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/ui/tabs/tab_strip_model_order_controller.h"
 #include "chrome/browser/ui/tabs/tab_utils.h"
@@ skipping 77 matching lines @@
 CloseTracker::~CloseTracker() {
   DCHECK(observers_.empty());
 }
 
 bool CloseTracker::HasNext() const {
   return !observers_.empty();
 }
 
 WebContents* CloseTracker::Next() {
   if (observers_.empty())
-    return NULL;
+    return nullptr;
 
   DeletionObserver* observer = observers_[0];
   WebContents* web_contents = observer->web_contents();
   observers_.erase(observers_.begin());
   delete observer;
   return web_contents;
 }
 
 void CloseTracker::OnWebContentsDestroyed(DeletionObserver* observer) {
   Observers::iterator i =
@@ skipping 80 matching lines @@
   bool blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(WebContentsData);
 };
 
 TabStripModel::WebContentsData::WebContentsData(TabStripModel* tab_strip_model,
                                                 WebContents* contents)
     : content::WebContentsObserver(contents),
       contents_(contents),
       tab_strip_model_(tab_strip_model),
-      group_(NULL),
-      opener_(NULL),
+      group_(nullptr),
+      opener_(nullptr),
       reset_group_on_select_(false),
       pinned_(false),
       blocked_(false) {}
 
 void TabStripModel::WebContentsData::SetWebContents(WebContents* contents) {
   contents_ = contents;
   Observe(contents);
 }
 
 void TabStripModel::WebContentsData::WebContentsDestroyed() {
@@ skipping 13 matching lines @@
     : delegate_(delegate),
       profile_(profile),
       closing_all_(false),
       in_notify_(false),
       weak_factory_(this) {
   DCHECK(delegate_);
   order_controller_.reset(new TabStripModelOrderController(this));
 }
 
 TabStripModel::~TabStripModel() {
-  base::STLDeleteElements(&contents_data_);
+  contents_data_.clear();
   order_controller_.reset();
 }
 
 void TabStripModel::AddObserver(TabStripModelObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void TabStripModel::RemoveObserver(TabStripModelObserver* observer) {
   observers_.RemoveObserver(observer);
 }
@@ skipping 21 matching lines @@
   // In tab dragging situations, if the last tab in the window was detached
   // then the user aborted the drag, we will have the |closing_all_| member
   // set (see DetachWebContentsAt) which will mess with our mojo here. We need
   // to clear this bit.
   closing_all_ = false;
 
   // Have to get the active contents before we monkey with the contents
   // otherwise we run into problems when we try to change the active contents
   // since the old contents and the new contents will be the same...
   WebContents* active_contents = GetActiveWebContents();
-  WebContentsData* data = new WebContentsData(this, contents);
+  std::unique_ptr<WebContentsData> data =
+      base::MakeUnique<WebContentsData>(this, contents);
   data->set_pinned(pin);
   if ((add_types & ADD_INHERIT_GROUP) && active_contents) {
     if (active) {
       // Forget any existing relationships, we don't want to make things too
       // confusing by having multiple groups active at the same time.
       ForgetAllOpeners();
     }
     // Anything opened by a link we deem to have an opener.
     data->set_group(active_contents);
     data->set_opener(active_contents);
   } else if ((add_types & ADD_INHERIT_OPENER) && active_contents) {
     if (active) {
       // Forget any existing relationships, we don't want to make things too
       // confusing by having multiple groups active at the same time.
       ForgetAllOpeners();
     }
     data->set_opener(active_contents);
   }
 
   // TODO(gbillock): Ask the modal dialog manager whether the WebContents should
   // be blocked, or just let the modal dialog manager make the blocking call
   // directly and not use this at all.
   const web_modal::WebContentsModalDialogManager* manager =
       web_modal::WebContentsModalDialogManager::FromWebContents(contents);
   if (manager)
     data->set_blocked(manager->IsDialogActive());
 
-  contents_data_.insert(contents_data_.begin() + index, data);
+  contents_data_.insert(contents_data_.begin() + index, std::move(data));
 
   selection_model_.IncrementFrom(index);
 
-  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                    TabInsertedAt(this, contents, index, active));
+  for (auto& observer : observers_)
+    observer.TabInsertedAt(this, contents, index, active);
+
   if (active) {
     ui::ListSelectionModel new_model;
     new_model.Copy(selection_model_);
     new_model.SetSelectedIndex(index);
     SetSelection(new_model, NOTIFY_DEFAULT);
   }
 }
 
 WebContents* TabStripModel::ReplaceWebContentsAt(int index,
                                                  WebContents* new_contents) {
   delegate_->WillAddWebContents(new_contents);
 
   DCHECK(ContainsIndex(index));
   WebContents* old_contents = GetWebContentsAtImpl(index);
 
   FixOpenersAndGroupsReferencing(index);
 
   contents_data_[index]->SetWebContents(new_contents);
 
-  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                    TabReplacedAt(this, old_contents, new_contents, index));
+  for (auto& observer : observers_)
+    observer.TabReplacedAt(this, old_contents, new_contents, index);
 
   // When the active WebContents is replaced send out a selection notification
   // too. We do this as nearly all observers need to treat a replacement of the
   // selected contents as the selection changing.
   if (active_index() == index) {
-    FOR_EACH_OBSERVER(
-        TabStripModelObserver,
-        observers_,
-        ActiveTabChanged(old_contents,
-                         new_contents,
-                         active_index(),
-                         TabStripModelObserver::CHANGE_REASON_REPLACED));
+    for (auto& observer : observers_)
+      observer.ActiveTabChanged(old_contents, new_contents, active_index(),
+                                TabStripModelObserver::CHANGE_REASON_REPLACED);
   }
   return old_contents;
 }
 
 WebContents* TabStripModel::DetachWebContentsAt(int index) {
   CHECK(!in_notify_);
   if (contents_data_.empty())
-    return NULL;
+    return nullptr;
   DCHECK(ContainsIndex(index));
 
   FixOpenersAndGroupsReferencing(index);
 
   WebContents* removed_contents = GetWebContentsAtImpl(index);
   bool was_selected = IsTabSelected(index);
   int next_selected_index = order_controller_->DetermineNewSelectedIndex(index);
-  delete contents_data_[index];
   contents_data_.erase(contents_data_.begin() + index);
   if (empty())
     closing_all_ = true;
-  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                    TabDetachedAt(removed_contents, index));
+  for (auto& observer : observers_)
+    observer.TabDetachedAt(removed_contents, index);
   if (empty()) {
     selection_model_.Clear();
     // TabDetachedAt() might unregister observers, so send |TabStripEmpty()| in
     // a second pass.
-    FOR_EACH_OBSERVER(TabStripModelObserver, observers_, TabStripEmpty());
+    for (auto& observer : observers_)
+      observer.TabStripEmpty();
   } else {
     int old_active = active_index();
     selection_model_.DecrementFrom(index);
     ui::ListSelectionModel old_model;
     old_model.Copy(selection_model_);
     if (index == old_active) {
       NotifyIfTabDeactivated(removed_contents);
       if (!selection_model_.empty()) {
         // The active tab was removed, but there is still something selected.
         // Move the active and anchor to the first selected index.
         selection_model_.set_active(selection_model_.selected_indices()[0]);
         selection_model_.set_anchor(selection_model_.active());
       } else {
         // The active tab was removed and nothing is selected. Reset the
         // selection and send out notification.
         selection_model_.SetSelectedIndex(next_selected_index);
       }
       NotifyIfActiveTabChanged(removed_contents, NOTIFY_DEFAULT);
     }
 
     // Sending notification in case the detached tab was selected. Using
     // NotifyIfActiveOrSelectionChanged() here would not guarantee that a
     // notification is sent even though the tab selection has changed because
     // |old_model| is stored after calling DecrementFrom().
     if (was_selected) {
-      FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                        TabSelectionChanged(this, old_model));
+      for (auto& observer : observers_)
+        observer.TabSelectionChanged(this, old_model);
     }
   }
   return removed_contents;
 }
 
 void TabStripModel::ActivateTabAt(int index, bool user_gesture) {
   DCHECK(ContainsIndex(index));
   ui::ListSelectionModel new_model;
   new_model.Copy(selection_model_);
   new_model.SetSelectedIndex(index);
@@ skipping 59 matching lines @@
                          selected_count - selected_pinned_count);
 }
 
 WebContents* TabStripModel::GetActiveWebContents() const {
   return GetWebContentsAt(active_index());
 }
 
 WebContents* TabStripModel::GetWebContentsAt(int index) const {
   if (ContainsIndex(index))
     return GetWebContentsAtImpl(index);
-  return NULL;
+  return nullptr;
 }
 
 int TabStripModel::GetIndexOfWebContents(const WebContents* contents) const {
   for (size_t i = 0; i < contents_data_.size(); ++i) {
     if (contents_data_[i]->web_contents() == contents)
       return i;
   }
   return kNoTab;
 }
 
 void TabStripModel::UpdateWebContentsStateAt(int index,
     TabStripModelObserver::TabChangeType change_type) {
   DCHECK(ContainsIndex(index));
 
-  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-      TabChangedAt(GetWebContentsAtImpl(index), index, change_type));
+  for (auto& observer : observers_)
+    observer.TabChangedAt(GetWebContentsAtImpl(index), index, change_type);
 }
 
 void TabStripModel::CloseAllTabs() {
   // Set state so that observers can adjust their behavior to suit this
   // specific condition when CloseWebContentsAt causes a flurry of
   // Close/Detach/Select notifications to be sent.
   closing_all_ = true;
   std::vector<int> closing_tabs;
   for (int i = count() - 1; i >= 0; --i)
     closing_tabs.push_back(i);
   InternalCloseTabs(closing_tabs, CLOSE_CREATE_HISTORICAL_TAB);
 }
 
 bool TabStripModel::CloseWebContentsAt(int index, uint32_t close_types) {
   DCHECK(ContainsIndex(index));
   std::vector<int> closing_tabs;
   closing_tabs.push_back(index);
   return InternalCloseTabs(closing_tabs, close_types);
 }
 
 bool TabStripModel::TabsAreLoading() const {
-  for (WebContentsDataVector::const_iterator iter = contents_data_.begin();
-       iter != contents_data_.end(); ++iter) {
-    if ((*iter)->web_contents()->IsLoading())
+  for (const auto& data : contents_data_) {
+    if (data->web_contents()->IsLoading())
       return true;
   }
+
   return false;
 }
 
 WebContents* TabStripModel::GetOpenerOfWebContentsAt(int index) {
   DCHECK(ContainsIndex(index));
   return contents_data_[index]->opener();
 }
 
 void TabStripModel::SetOpenerOfWebContentsAt(int index,
                                              WebContents* opener) {
@@ skipping 63 matching lines @@
       // In this specific case we also want to reset the group relationship,
       // since it is now technically invalid.
       ForgetGroup(contents);
     }
   }
 }
 
 void TabStripModel::ForgetAllOpeners() {
   // Forget all opener memories so we don't do anything weird with tab
   // re-selection ordering.
-  for (WebContentsDataVector::const_iterator iter = contents_data_.begin();
-       iter != contents_data_.end(); ++iter)
-    (*iter)->set_opener(NULL);
+  for (const auto& data : contents_data_)
+    data->set_opener(nullptr);
 }
 
 void TabStripModel::ForgetGroup(WebContents* contents) {
   int index = GetIndexOfWebContents(contents);
   DCHECK(ContainsIndex(index));
-  contents_data_[index]->set_group(NULL);
-  contents_data_[index]->set_opener(NULL);
+  contents_data_[index]->set_group(nullptr);
+  contents_data_[index]->set_opener(nullptr);
 }
 
 bool TabStripModel::ShouldResetGroupOnSelect(WebContents* contents) const {
   int index = GetIndexOfWebContents(contents);
   DCHECK(ContainsIndex(index));
   return contents_data_[index]->reset_group_on_select();
 }
 
 void TabStripModel::SetTabBlocked(int index, bool blocked) {
   DCHECK(ContainsIndex(index));
   if (contents_data_[index]->blocked() == blocked)
     return;
   contents_data_[index]->set_blocked(blocked);
-  FOR_EACH_OBSERVER(
-      TabStripModelObserver, observers_,
-      TabBlockedStateChanged(contents_data_[index]->web_contents(),
-                             index));
+  for (auto& observer : observers_)
+    observer.TabBlockedStateChanged(contents_data_[index]->web_contents(),
+                                    index);
 }
 
 void TabStripModel::SetTabPinned(int index, bool pinned) {
   DCHECK(ContainsIndex(index));
   if (contents_data_[index]->pinned() == pinned)
     return;
 
   // The tab's position may have to change as the pinned tab state is changing.
   int non_pinned_tab_index = IndexOfFirstNonPinnedTab();
   contents_data_[index]->set_pinned(pinned);
   if (pinned && index != non_pinned_tab_index) {
     MoveWebContentsAtImpl(index, non_pinned_tab_index, false);
     index = non_pinned_tab_index;
   } else if (!pinned && index + 1 != non_pinned_tab_index) {
     MoveWebContentsAtImpl(index, non_pinned_tab_index - 1, false);
     index = non_pinned_tab_index - 1;
   }
 
-  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                    TabPinnedStateChanged(
-                        this, contents_data_[index]->web_contents(), index));
+  for (auto& observer : observers_)
+    observer.TabPinnedStateChanged(this, contents_data_[index]->web_contents(),
+                                   index);
 }
 
 bool TabStripModel::IsTabPinned(int index) const {
   DCHECK(ContainsIndex(index));
   return contents_data_[index]->pinned();
 }
 
 bool TabStripModel::IsTabBlocked(int index) const {
   return contents_data_[index]->blocked();
 }
@@ skipping 474 matching lines @@
 bool TabStripModel::InternalCloseTabs(const std::vector<int>& indices,
                                       uint32_t close_types) {
   if (indices.empty())
     return true;
 
   CloseTracker close_tracker(GetWebContentsFromIndices(indices));
 
   base::WeakPtr<TabStripModel> ref(weak_factory_.GetWeakPtr());
   const bool closing_all = indices.size() == contents_data_.size();
   if (closing_all)
-    FOR_EACH_OBSERVER(TabStripModelObserver, observers_, WillCloseAllTabs());
+    for (auto& observer : observers_)
+      observer.WillCloseAllTabs();
 
   // We only try the fast shutdown path if the whole browser process is *not*
   // shutting down. Fast shutdown during browser termination is handled in
   // browser_shutdown::OnShutdownStarting.
   if (browser_shutdown::GetShutdownType() == browser_shutdown::NOT_VALID) {
     // Construct a map of processes to the number of associated tabs that are
     // closing.
     std::map<content::RenderProcessHost*, size_t> processes;
     for (size_t i = 0; i < indices.size(); ++i) {
       WebContents* closing_contents = GetWebContentsAtImpl(indices[i]);
@@ skipping 35 matching lines @@
 
     if (delegate_->RunUnloadListenerBeforeClosing(closing_contents)) {
       retval = false;
       continue;
     }
 
     InternalCloseTab(closing_contents, index,
                      (close_types & CLOSE_CREATE_HISTORICAL_TAB) != 0);
   }
 
-  if (ref && closing_all && !retval) {
-    FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                      CloseAllTabsCanceled());
-  }
+  if (ref && closing_all && !retval)
+    for (auto& observer : observers_)
+      observer.CloseAllTabsCanceled();
 
   return retval;
 }
 
 void TabStripModel::InternalCloseTab(WebContents* contents,
                                      int index,
                                      bool create_historical_tabs) {
-  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                    TabClosingAt(this, contents, index));
+  for (auto& observer : observers_)
+    observer.TabClosingAt(this, contents, index);
 
   // Ask the delegate to save an entry for this tab in the historical tab
   // database if applicable.
   if (create_historical_tabs)
     delegate_->CreateHistoricalTab(contents);
 
   // Deleting the WebContents will call back to us via
   // WebContentsData::WebContentsDestroyed and detach it.
   delete contents;
 }
 
 WebContents* TabStripModel::GetWebContentsAtImpl(int index) const {
   CHECK(ContainsIndex(index)) <<
       "Failed to find: " << index << " in: " << count() << " entries.";
   return contents_data_[index]->web_contents();
 }
 
 void TabStripModel::NotifyIfTabDeactivated(WebContents* contents) {
   if (contents) {
-    FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                      TabDeactivated(contents));
+    for (auto& observer : observers_)
+      observer.TabDeactivated(contents);
   }
 }
 
 void TabStripModel::NotifyIfActiveTabChanged(WebContents* old_contents,
                                              NotifyTypes notify_types) {
   WebContents* new_contents = GetWebContentsAtImpl(active_index());
   if (old_contents != new_contents) {
     int reason = notify_types == NOTIFY_USER_GESTURE
                  ? TabStripModelObserver::CHANGE_REASON_USER_GESTURE
                  : TabStripModelObserver::CHANGE_REASON_NONE;
     CHECK(!in_notify_);
     in_notify_ = true;
-    FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-        ActiveTabChanged(old_contents,
-                         new_contents,
-                         active_index(),
-                         reason));
+    for (auto& observer : observers_)
+      observer.ActiveTabChanged(old_contents, new_contents, active_index(),
+                                reason);
     in_notify_ = false;
   }
 }
 
 void TabStripModel::NotifyIfActiveOrSelectionChanged(
     WebContents* old_contents,
     NotifyTypes notify_types,
     const ui::ListSelectionModel& old_model) {
   NotifyIfActiveTabChanged(old_contents, notify_types);
 
   if (!selection_model().Equals(old_model)) {
-    FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                      TabSelectionChanged(this, old_model));
+    for (auto& observer : observers_)
+      observer.TabSelectionChanged(this, old_model);
   }
 }
 
 void TabStripModel::SetSelection(
     const ui::ListSelectionModel& new_model,
     NotifyTypes notify_types) {
   WebContents* old_contents = GetActiveWebContents();
   ui::ListSelectionModel old_model;
   old_model.Copy(selection_model_);
   if (new_model.active() != selection_model_.active())
@@ skipping 12 matching lines @@
   int delta = next ? 1 : -1;
   index = (index + count() + delta) % count();
   ActivateTabAt(index, true);
 }
 
 void TabStripModel::MoveWebContentsAtImpl(int index,
                                           int to_position,
                                           bool select_after_move) {
   FixOpenersAndGroupsReferencing(index);
 
-  WebContentsData* moved_data = contents_data_[index];
+  std::unique_ptr<WebContentsData> moved_data =
+      std::move(contents_data_[index]);
+  WebContents* web_contents = moved_data->web_contents();
   contents_data_.erase(contents_data_.begin() + index);
-  contents_data_.insert(contents_data_.begin() + to_position, moved_data);
+  contents_data_.insert(contents_data_.begin() + to_position,
+                        std::move(moved_data));
 
   selection_model_.Move(index, to_position);
   if (!selection_model_.IsSelected(to_position) && select_after_move) {
     // TODO(sky): why doesn't this code notify observers?
     selection_model_.SetSelectedIndex(to_position);
   }
 
-  FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
-                    TabMoved(moved_data->web_contents(), index, to_position));
+  for (auto& observer : observers_)
+    observer.TabMoved(web_contents, index, to_position);
 }
 
 void TabStripModel::MoveSelectedTabsToImpl(int index,
                                            size_t start,
                                            size_t length) {
   DCHECK(start < selection_model_.selected_indices().size() &&
          start + length <= selection_model_.selected_indices().size());
   size_t end = start + length;
   int count_before_index = 0;
   for (size_t i = start; i < end &&
@@ skipping 19 matching lines @@
     if (selection_model_.selected_indices()[tab_index] != target_index) {
       MoveWebContentsAt(selection_model_.selected_indices()[tab_index],
                         target_index, false);
     }
     tab_index++;
     target_index++;
   }
 }
 
 // static
-bool TabStripModel::OpenerMatches(const WebContentsData* data,
+bool TabStripModel::OpenerMatches(const std::unique_ptr<WebContentsData>& data,
                                   const WebContents* opener,
                                   bool use_group) {
   return data->opener() == opener || (use_group && data->group() == opener);
 }
 
 void TabStripModel::FixOpenersAndGroupsReferencing(int index) {
   WebContents* old_contents = GetWebContentsAtImpl(index);
-  for (WebContentsData* data : contents_data_) {
+  for (auto& data : contents_data_) {
     if (data->group() == old_contents)
       data->set_group(contents_data_[index]->group());
     if (data->opener() == old_contents)
       data->set_opener(contents_data_[index]->opener());
   }
 }