Makes TabStripModel deal handle the case of the TabStripModel

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 <string>
 
@@ skipping 27 matching lines @@
 // any navigation that can be considered to be the start of a new task distinct
 // from what had previously occurred in that tab).
 bool ShouldForgetOpenersForTransition(content::PageTransition transition) {
   return transition == content::PAGE_TRANSITION_TYPED ||
       transition == content::PAGE_TRANSITION_AUTO_BOOKMARK ||
       transition == content::PAGE_TRANSITION_GENERATED ||
       transition == content::PAGE_TRANSITION_KEYWORD ||
       transition == content::PAGE_TRANSITION_AUTO_TOPLEVEL;
 }
 
+// CloseTracker is used when closing a set of WebContents. It listens for
+// deletions of the WebContents and removes from the internal set any time one
+// is deleted.
+class CloseTracker : public content::NotificationObserver {
+ public:
+  typedef std::vector<content::WebContents*> Contents;

[Avi (use Gerrit), 2013/06/03 18:41:35]

Note that we have "using content::WebContents" above. You don't need to qualify
WebContents anywhere in this file.

+
+  explicit CloseTracker(const Contents& contents);
+  virtual ~CloseTracker();
+
+  // Returns true if there is another WebContents in the Tracker.
+  bool HasNext() const;
+
+  // Returns the next WebContents, or NULL if there are no more.
+  content::WebContents* Next();
+
+ private:
+  // NotificationObserver:
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+  Contents contents_;
+
+  content::NotificationRegistrar registrar_;
+
+  DISALLOW_COPY_AND_ASSIGN(CloseTracker);
+};
+
+CloseTracker::CloseTracker(const Contents& contents)
+    : contents_(contents) {
+  registrar_.Add(this, content::NOTIFICATION_WEB_CONTENTS_DESTROYED,
+                 content::NotificationService::AllBrowserContextsAndSources());
+}
+
+CloseTracker::~CloseTracker() {
+}
+
+bool CloseTracker::HasNext() const {
+  return !contents_.empty();
+}
+
+content::WebContents* CloseTracker::Next() {
+  if (contents_.empty())
+    return NULL;
+
+  content::WebContents* web_contents = contents_[0];
+  contents_.erase(contents_.begin());
+  return web_contents;
+}
+
+void CloseTracker::Observe(int type,
+                           const content::NotificationSource& source,
+                           const content::NotificationDetails& details) {
+  content::WebContents* web_contents =
+      content::Source<WebContents>(source).ptr();
+  Contents::iterator i =
+      std::find(contents_.begin(), contents_.end(), web_contents);
+  if (i != contents_.end())
+    contents_.erase(i);
+}
+
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripModel, public:
 
 TabStripModel::TabStripModel(TabStripModelDelegate* delegate, Profile* profile)
     : delegate_(delegate),
       profile_(profile),
       closing_all_(false) {
   DCHECK(delegate_);
@@ skipping 895 matching lines @@
       *browser_cmd = 0;
       return false;
   }
 
   return true;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripModel, private:
 
+std::vector<content::WebContents*> TabStripModel::GetWebContentsFromIndicies(
+    const std::vector<int>& indices) const {
+  std::vector<WebContents*> contents;
+  for (size_t i = 0; i < indices.size(); ++i)
+    contents.push_back(GetWebContentsAtImpl(indices[i]));
+  return contents;
+}
+
 void TabStripModel::GetIndicesWithSameDomain(int index,
                                              std::vector<int>* indices) {
   std::string domain = GetWebContentsAt(index)->GetURL().host();
   if (domain.empty())
     return;
   for (int i = 0; i < count(); ++i) {
     if (i == index)
       continue;
     if (GetWebContentsAt(i)->GetURL().host() == domain)
       indices->push_back(i);
@@ skipping 34 matching lines @@
          url.host() == chrome::kChromeUINewTabHost &&
          contents == GetWebContentsAtImpl(count() - 1) &&
          contents->GetController().GetEntryCount() == 1;
 }
 
 bool TabStripModel::InternalCloseTabs(const std::vector<int>& indices,
                                       uint32 close_types) {
   if (indices.empty())
     return true;
 
-  // Map the indices to WebContentses, that way if deleting a tab deletes
-  // other tabs we're ok. Crashes seem to indicate during tab deletion other
-  // tabs are getting removed.
-  std::vector<WebContents*> closing_contentses;
-  for (size_t i = 0; i < indices.size(); ++i)
-    closing_contentses.push_back(GetWebContentsAtImpl(indices[i]));
+  CloseTracker close_tracker(GetWebContentsFromIndicies(indices));
 
   // We only try the fast shutdown path if the whole browser process is *not*
   // shutting down. Fast shutdown during browser termination is handled in
   // BrowserShutdown.
   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]);
       content::RenderProcessHost* process =
           closing_contents->GetRenderProcessHost();
       ++processes[process];
     }
 
     // Try to fast shutdown the tabs that can close.
     for (std::map<content::RenderProcessHost*, size_t>::iterator iter =
          processes.begin(); iter != processes.end(); ++iter) {
       iter->first->FastShutdownForPageCount(iter->second);
     }
   }
 
   // We now return to our regularly scheduled shutdown procedure.
   bool retval = true;
-  for (size_t i = 0; i < closing_contentses.size(); ++i) {
-    WebContents* closing_contents = closing_contentses[i];
+  while (close_tracker.HasNext()) {
+    WebContents* closing_contents = close_tracker.Next();
     int index = GetIndexOfWebContents(closing_contents);
     // Make sure we still contain the tab.
     if (index == kNoTab)
       continue;
 
     closing_contents->OnCloseStarted();
 
     // Update the explicitly closed state. If the unload handlers cancel the
     // close the state is reset in Browser. We don't update the explicitly
     // closed state if already marked as explicitly closed as unload handlers
@@ skipping 160 matching lines @@
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
     const WebContents* tab) {
   for (WebContentsDataVector::const_iterator i = contents_data_.begin();
        i != contents_data_.end(); ++i) {
     if ((*i)->group == tab)
       (*i)->group = NULL;
     if ((*i)->opener == tab)
       (*i)->opener = NULL;
   }
 }