Makes TabStripModel deal handle the case of the TabStripModel

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/files/file_path.h"
@@ skipping 28 matching lines @@
 #include "content/public/test/test_browser_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using content::BrowserThread;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 
 namespace {
 
-// Class used to delete a WebContents when another WebContents is destroyed.
+// Class used to delete a WebContents and TabStripModel when another WebContents
+// is destroyed.
 class DeleteWebContentsOnDestroyedObserver
     : public content::NotificationObserver {
  public:
+  // When |source| is deleted both |tab_to_delete| and |tab_strip| are deleted.
+  // |tab_to_delete| and |tab_strip| may be NULL.
   DeleteWebContentsOnDestroyedObserver(WebContents* source,
-                                       WebContents* tab_to_delete)
+                                       WebContents* tab_to_delete,
+                                       TabStripModel* tab_strip)
       : source_(source),
-        tab_to_delete_(tab_to_delete) {
+        tab_to_delete_(tab_to_delete),
+        tab_strip_(tab_strip) {
     registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
                    content::Source<WebContents>(source));
   }
 
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE {
     WebContents* tab_to_delete = tab_to_delete_;
     tab_to_delete_ = NULL;
+    TabStripModel* tab_strip_to_delete = tab_strip_;
+    tab_strip_ = NULL;
     delete tab_to_delete;
+    delete tab_strip_to_delete;
   }
 
  private:
   WebContents* source_;
   WebContents* tab_to_delete_;
+  TabStripModel* tab_strip_;
   content::NotificationRegistrar registrar_;
 
   DISALLOW_COPY_AND_ASSIGN(DeleteWebContentsOnDestroyedObserver);
 };
 
 class TabStripDummyDelegate : public TestTabStripModelDelegate {
  public:
   TabStripDummyDelegate() : run_unload_(false) {}
   virtual ~TabStripDummyDelegate() {}
 
@@ skipping 117 matching lines @@
   }
 
  private:
   content::TestBrowserThread browser_thread_;
 };
 
 class MockTabStripModelObserver : public TabStripModelObserver {
  public:
   explicit MockTabStripModelObserver(TabStripModel* model)
       : empty_(true),
+        deleted_(false),
         model_(model) {}
   virtual ~MockTabStripModelObserver() {}
 
   enum TabStripModelObserverAction {
     INSERT,
     CLOSE,
     DETACH,
     ACTIVATE,
     DEACTIVATE,
     SELECT,
@@ skipping 103 matching lines @@
     s.src_contents = old_contents;
     states_.push_back(s);
   }
   virtual void TabPinnedStateChanged(WebContents* contents,
                                      int index) OVERRIDE {
     states_.push_back(State(contents, index, PINNED));
   }
   virtual void TabStripEmpty() OVERRIDE {
     empty_ = true;
   }
+  virtual void TabStripModelDeleted() OVERRIDE {
+    deleted_ = true;
+  }
 
   void ClearStates() {
     states_.clear();
   }
 
   bool empty() const { return empty_; }
+  bool deleted() const { return deleted_; }
   TabStripModel* model() { return model_; }
 
  private:
   std::vector<State> states_;
 
   bool empty_;
+  bool deleted_;
   TabStripModel* model_;
 
   DISALLOW_COPY_AND_ASSIGN(MockTabStripModelObserver);
 };
 
 TEST_F(TabStripModelTest, TestBasicAPI) {
   TabStripDummyDelegate delegate;
   TabStripModel tabstrip(&delegate, profile());
   MockTabStripModelObserver observer(&tabstrip);
   tabstrip.AddObserver(&observer);
@@ skipping 1755 matching lines @@
 // another tab.
 TEST_F(TabStripModelTest, DeleteFromDestroy) {
   TabStripDummyDelegate delegate;
   TabStripModel strip(&delegate, profile());
   WebContents* contents1 = CreateWebContents();
   WebContents* contents2 = CreateWebContents();
   strip.AppendWebContents(contents1, true);
   strip.AppendWebContents(contents2, true);
   // DeleteWebContentsOnDestroyedObserver deletes contents1 when contents2 sends
   // out notification that it is being destroyed.
-  DeleteWebContentsOnDestroyedObserver observer(contents2, contents1);
+  DeleteWebContentsOnDestroyedObserver observer(contents2, contents1, NULL);
   strip.CloseAllTabs();
 }
 
+// Makes sure TabStripModel handles the case of deleting another tab and the
+// TabStrip while removing another tab.
+TEST_F(TabStripModelTest, DeleteTabStripFromDestroy) {
+  TabStripDummyDelegate delegate;
+  TabStripModel* strip = new TabStripModel(&delegate, profile());
+  MockTabStripModelObserver tab_strip_model_observer(strip);
+  strip->AddObserver(&tab_strip_model_observer);
+  WebContents* contents1 = CreateWebContents();
+  WebContents* contents2 = CreateWebContents();
+  strip->AppendWebContents(contents1, true);
+  strip->AppendWebContents(contents2, true);
+  // DeleteWebContentsOnDestroyedObserver deletes |contents1| and |strip| when
+  // |contents2| sends out notification that it is being destroyed.
+  DeleteWebContentsOnDestroyedObserver observer(contents2, contents1, strip);
+  strip->CloseAllTabs();
+  EXPECT_TRUE(tab_strip_model_observer.empty());
+  EXPECT_TRUE(tab_strip_model_observer.deleted());
+}
+
 TEST_F(TabStripModelTest, MoveSelectedTabsTo) {
   struct TestData {
     // Number of tabs the tab strip should have.
     const int tab_count;
 
     // Number of pinned tabs.
     const int pinned_count;
 
     // Index of the tabs to select.
     const std::string selected_tabs;
@@ skipping 200 matching lines @@
   strip.ActivateTabAt(1, true);
   ASSERT_EQ(1, observer.GetStateCount());
   State s(contents2, 1, MockTabStripModelObserver::SELECT);
   s.src_contents = contents2;
   s.src_index = 1;
   s.change_reason = TabStripModelObserver::CHANGE_REASON_NONE;
   EXPECT_TRUE(observer.StateEquals(0, s));
   strip.RemoveObserver(&observer);
   strip.CloseAllTabs();
 }