tabs: Make the vector in MockTabStripModelObserver own values instead of pointers.

chrome/browser/ui/tabs/tab_strip_model_unittest.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 <map>
 #include <string>
 
 #include "base/file_path.h"
@@ skipping 249 matching lines @@
 };
 
 class MockTabStripModelObserver : public TabStripModelObserver {
  public:
   MockTabStripModelObserver()
       : empty_(true),
         model_(NULL) {}
   explicit MockTabStripModelObserver(TabStripModel* model)
       : empty_(true),
         model_(model) {}
-  virtual ~MockTabStripModelObserver() {
-    STLDeleteContainerPointers(states_.begin(), states_.end());
-  }
+  virtual ~MockTabStripModelObserver() {}
 
   enum TabStripModelObserverAction {
     INSERT,
     CLOSE,
     DETACH,
     ACTIVATE,
     DEACTIVATE,
     SELECT,
     MOVE,
     CHANGE,
@@ skipping 20 matching lines @@
     int dst_index;
     bool user_gesture;
     bool foreground;
     TabStripModelObserverAction action;
   };
 
   int GetStateCount() const {
     return static_cast<int>(states_.size());
   }
 
-  State* GetStateAt(int index) const {
+  State GetStateAt(int index) const {
     DCHECK(index >= 0 && index < GetStateCount());
     return states_[index];
   }
 
   bool StateEquals(int index, const State& state) {
-    State* s = GetStateAt(index);
-    EXPECT_EQ(state.src_contents, s->src_contents);
-    EXPECT_EQ(state.dst_contents, s->dst_contents);
-    EXPECT_EQ(state.src_index, s->src_index);
-    EXPECT_EQ(state.dst_index, s->dst_index);
-    EXPECT_EQ(state.user_gesture, s->user_gesture);
-    EXPECT_EQ(state.foreground, s->foreground);
-    EXPECT_EQ(state.action, s->action);
-    return (s->src_contents == state.src_contents &&
-            s->dst_contents == state.dst_contents &&
-            s->src_index == state.src_index &&
-            s->dst_index == state.dst_index &&
-            s->user_gesture == state.user_gesture &&
-            s->foreground == state.foreground &&
-            s->action == state.action);
+    State s = GetStateAt(index);
+    return (s.src_contents == state.src_contents &&
+            s.dst_contents == state.dst_contents &&
+            s.src_index == state.src_index &&
+            s.dst_index == state.dst_index &&
+            s.user_gesture == state.user_gesture &&
+            s.foreground == state.foreground &&
+            s.action == state.action);
   }
 
   // TabStripModelObserver implementation:
   virtual void TabInsertedAt(TabContents* contents,
                              int index,
                              bool foreground) {
     empty_ = false;
-    State* s = new State(contents, index, INSERT);
-    s->foreground = foreground;
+    State s(contents, index, INSERT);
+    s.foreground = foreground;
     states_.push_back(s);
   }
   virtual void ActiveTabChanged(TabContents* old_contents,
                                 TabContents* new_contents,
                                 int index,
                                 bool user_gesture) {
-    State* s = new State(new_contents, index, ACTIVATE);
-    s->src_contents = old_contents;
-    s->user_gesture = user_gesture;
+    State s(new_contents, index, ACTIVATE);
+    s.src_contents = old_contents;
+    s.user_gesture = user_gesture;
     states_.push_back(s);
   }
   virtual void TabSelectionChanged(TabStripModel* tab_strip_model,
                                    const TabStripSelectionModel& old_model) {
-    State* s = new State(model()->GetActiveTabContents(),
-                         model()->active_index(),
-                         SELECT);
-    s->src_contents = model()->GetTabContentsAt(old_model.active());
-    s->src_index = old_model.active();
+    State s(model()->GetActiveTabContents(), model()->active_index(), SELECT);
+    s.src_contents = model()->GetTabContentsAt(old_model.active());
+    s.src_index = old_model.active();
     states_.push_back(s);
   }
   virtual void TabMoved(TabContents* contents, int from_index, int to_index) {
-    State* s = new State(contents, to_index, MOVE);
-    s->src_index = from_index;
+    State s(contents, to_index, MOVE);
+    s.src_index = from_index;
     states_.push_back(s);
   }
 
   virtual void TabClosingAt(TabStripModel* tab_strip_model,
                             TabContents* contents,
                             int index) {
-    states_.push_back(new State(contents, index, CLOSE));
+    states_.push_back(State(contents, index, CLOSE));
   }
   virtual void TabDetachedAt(TabContents* contents, int index) {
-    states_.push_back(new State(contents, index, DETACH));
+    states_.push_back(State(contents, index, DETACH));
   }
   virtual void TabDeactivated(TabContents* contents) {
-    states_.push_back(new State(contents, model()->active_index(), DEACTIVATE));
+    states_.push_back(State(contents, model()->active_index(), DEACTIVATE));
   }
   virtual void TabChangedAt(TabContents* contents, int index,
                             TabChangeType change_type) {
-    states_.push_back(new State(contents, index, CHANGE));
+    states_.push_back(State(contents, index, CHANGE));
   }
   virtual void TabReplacedAt(TabStripModel* tab_strip_model,
                              TabContents* old_contents,
                              TabContents* new_contents,
                              int index) {
-    State* s = new State(new_contents, index, REPLACED);
-    s ->src_contents = old_contents;
+    State s(new_contents, index, REPLACED);
+    s.src_contents = old_contents;
     states_.push_back(s);
   }
   virtual void TabPinnedStateChanged(TabContents* contents, int index) {
-    states_.push_back(new State(contents, index, PINNED));
+    states_.push_back(State(contents, index, PINNED));
   }
   virtual void TabStripEmpty() {
     empty_ = true;
   }
 
   void ClearStates() {
-    STLDeleteContainerPointers(states_.begin(), states_.end());
     states_.clear();
   }
 
   bool empty() const { return empty_; }
   TabStripModel* model() { return model_; }
 
  private:
-  std::vector<State*> states_;
+  std::vector<State> states_;
 
   bool empty_;
   TabStripModel* model_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTabStripModelObserver);
 };
 
 TEST_F(TabStripModelTest, TestBasicAPI) {
   TabStripDummyDelegate delegate(NULL);
   TabStripModel tabstrip(&delegate, profile());
@@ skipping 1900 matching lines @@
   TabContents* contents3 = CreateTabContents();
   strip.AppendTabContents(contents0, false);
   strip.AppendTabContents(contents1, false);
   strip.AppendTabContents(contents2, false);
   strip.AppendTabContents(contents3, false);
   strip.AddObserver(&observer);
 
   // Selection and active tab change.
   strip.ActivateTabAt(3, true);
   ASSERT_EQ(2, observer.GetStateCount());
-  ASSERT_EQ(observer.GetStateAt(0)->action,
+  ASSERT_EQ(observer.GetStateAt(0).action,
             MockTabStripModelObserver::ACTIVATE);
   MockTabStripModelObserver::State s1(contents3, 3,
       MockTabStripModelObserver::SELECT);
   EXPECT_TRUE(observer.StateEquals(1, s1));
   observer.ClearStates();
 
   // Adding all tabs to selection, active tab is now at 0.
   strip.ExtendSelectionTo(0);
   ASSERT_EQ(3, observer.GetStateCount());
-  ASSERT_EQ(observer.GetStateAt(0)->action,
+  ASSERT_EQ(observer.GetStateAt(0).action,
             MockTabStripModelObserver::DEACTIVATE);
-  ASSERT_EQ(observer.GetStateAt(1)->action,
+  ASSERT_EQ(observer.GetStateAt(1).action,
             MockTabStripModelObserver::ACTIVATE);
   MockTabStripModelObserver::State s2(contents0, 0,
       MockTabStripModelObserver::SELECT);
   s2.src_contents = contents3;
   s2.src_index = 3;
   EXPECT_TRUE(observer.StateEquals(2, s2));
   observer.ClearStates();
 
   // Toggle the active tab, should make the next index active.
   strip.ToggleSelectionAt(0);
   EXPECT_EQ(1, strip.active_index());
   EXPECT_EQ(3U, strip.selection_model().size());
   EXPECT_EQ(4, strip.count());
   ASSERT_EQ(3, observer.GetStateCount());
-  ASSERT_EQ(observer.GetStateAt(0)->action,
+  ASSERT_EQ(observer.GetStateAt(0).action,
             MockTabStripModelObserver::DEACTIVATE);
-  ASSERT_EQ(observer.GetStateAt(1)->action,
+  ASSERT_EQ(observer.GetStateAt(1).action,
             MockTabStripModelObserver::ACTIVATE);
-  ASSERT_EQ(observer.GetStateAt(2)->action,
+  ASSERT_EQ(observer.GetStateAt(2).action,
             MockTabStripModelObserver::SELECT);
   observer.ClearStates();
 
   // Toggle the first tab back to selected and active.
   strip.ToggleSelectionAt(0);
   EXPECT_EQ(0, strip.active_index());
   EXPECT_EQ(4U, strip.selection_model().size());
   EXPECT_EQ(4, strip.count());
   ASSERT_EQ(3, observer.GetStateCount());
-  ASSERT_EQ(observer.GetStateAt(0)->action,
+  ASSERT_EQ(observer.GetStateAt(0).action,
             MockTabStripModelObserver::DEACTIVATE);
-  ASSERT_EQ(observer.GetStateAt(1)->action,
+  ASSERT_EQ(observer.GetStateAt(1).action,
             MockTabStripModelObserver::ACTIVATE);
-  ASSERT_EQ(observer.GetStateAt(2)->action,
+  ASSERT_EQ(observer.GetStateAt(2).action,
             MockTabStripModelObserver::SELECT);
   observer.ClearStates();
 
   // Closing one of the selected tabs, not the active one.
   strip.CloseTabContentsAt(1, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(3, strip.count());
   ASSERT_EQ(3, observer.GetStateCount());
-  ASSERT_EQ(observer.GetStateAt(0)->action,
+  ASSERT_EQ(observer.GetStateAt(0).action,
             MockTabStripModelObserver::CLOSE);
-  ASSERT_EQ(observer.GetStateAt(1)->action,
+  ASSERT_EQ(observer.GetStateAt(1).action,
             MockTabStripModelObserver::DETACH);
-  ASSERT_EQ(observer.GetStateAt(2)->action,
+  ASSERT_EQ(observer.GetStateAt(2).action,
             MockTabStripModelObserver::SELECT);
   observer.ClearStates();
 
   // Closing the active tab, while there are others tabs selected.
   strip.CloseTabContentsAt(0, TabStripModel::CLOSE_NONE);
   EXPECT_EQ(2, strip.count());
   ASSERT_EQ(5, observer.GetStateCount());
-  ASSERT_EQ(observer.GetStateAt(0)->action,
+  ASSERT_EQ(observer.GetStateAt(0).action,
             MockTabStripModelObserver::CLOSE);
-  ASSERT_EQ(observer.GetStateAt(1)->action,
+  ASSERT_EQ(observer.GetStateAt(1).action,
             MockTabStripModelObserver::DETACH);
-  ASSERT_EQ(observer.GetStateAt(2)->action,
+  ASSERT_EQ(observer.GetStateAt(2).action,
             MockTabStripModelObserver::DEACTIVATE);
-  ASSERT_EQ(observer.GetStateAt(3)->action,
+  ASSERT_EQ(observer.GetStateAt(3).action,
             MockTabStripModelObserver::ACTIVATE);
-  ASSERT_EQ(observer.GetStateAt(4)->action,
+  ASSERT_EQ(observer.GetStateAt(4).action,
             MockTabStripModelObserver::SELECT);
   observer.ClearStates();
 
   // Active tab is at 0, deselecting all but the active tab.
   strip.ToggleSelectionAt(1);
   ASSERT_EQ(1, observer.GetStateCount());
-  ASSERT_EQ(observer.GetStateAt(0)->action,
+  ASSERT_EQ(observer.GetStateAt(0).action,
             MockTabStripModelObserver::SELECT);
   observer.ClearStates();
 
   // Attempting to deselect the only selected and therefore active tab,
   // it is ignored (no notifications being sent) and tab at 0 remains selected
   // and active.
   strip.ToggleSelectionAt(0);
   ASSERT_EQ(0, observer.GetStateCount());
 
   strip.RemoveObserver(&observer);
@@ skipping 21 matching lines @@
   ASSERT_EQ(1, observer.GetStateCount());
   MockTabStripModelObserver::State s(
       contents2, 1, MockTabStripModelObserver::SELECT);
   s.src_contents = contents2;
   s.src_index = 1;
   s.user_gesture = false;
   EXPECT_TRUE(observer.StateEquals(0, s));
   strip.RemoveObserver(&observer);
   strip.CloseAllTabs();
 }