Miscellaneous cleanups from several months ago I never got around to landing.

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 51 matching lines @@
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripModel, public:
 
 TabStripModel::TabStripModel(TabStripModelDelegate* delegate, Profile* profile)
     : delegate_(delegate),
       profile_(profile),
       closing_all_(false),
       order_controller_(NULL) {
   DCHECK(delegate_);
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED,
+  registrar_.Add(this, chrome::NOTIFICATION_TAB_CONTENTS_DESTROYED,
                  content::NotificationService::AllBrowserContextsAndSources());
-  registrar_.Add(this,
-                 chrome::NOTIFICATION_EXTENSION_UNLOADED,
+  registrar_.Add(this, chrome::NOTIFICATION_EXTENSION_UNLOADED,
                  content::Source<Profile>(profile_));
   order_controller_ = new TabStripModelOrderController(this);
 }
 
 TabStripModel::~TabStripModel() {
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabStripModelDeleted());
   STLDeleteElements(&contents_data_);
   delete order_controller_;
 }
@@ skipping 266 matching lines @@
   return GetTabContentsAt(active_index());
 }
 
 TabContents* TabStripModel::GetTabContentsAt(int index) const {
   if (ContainsIndex(index))
     return GetContentsAt(index);
   return NULL;
 }
 
 int TabStripModel::GetIndexOfTabContents(const TabContents* contents) const {
-  int index = 0;
-  TabContentsDataVector::const_iterator iter = contents_data_.begin();
-  for (; iter != contents_data_.end(); ++iter, ++index) {
-    if ((*iter)->contents == contents)
-      return index;
+  for (size_t i = 0; i < contents_data_.size(); ++i) {
+    if (contents_data_[i]->contents == contents)
+      return i;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfWebContents(const WebContents* contents) const {
-  int index = 0;
-  TabContentsDataVector::const_iterator iter = contents_data_.begin();
-  for (; iter != contents_data_.end(); ++iter, ++index) {
-    if ((*iter)->contents->web_contents() == contents)
-      return index;
-  }
-  return kNoTab;
+  return contents ?
+      GetIndexOfTabContents(TabContents::FromWebContents(contents)) : kNoTab;
 }
 
 void TabStripModel::UpdateTabContentsStateAt(int index,
     TabStripModelObserver::TabChangeType change_type) {
   DCHECK(ContainsIndex(index));
 
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
       TabChangedAt(GetContentsAt(index), index, change_type));
 }
 
 void TabStripModel::CloseAllTabs() {
   // Set state so that observers can adjust their behavior to suit this
   // specific condition when CloseTabContentsAt 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::CloseTabContentsAt(int index, uint32 close_types) {
   std::vector<int> closing_tabs;
   closing_tabs.push_back(index);
   return InternalCloseTabs(closing_tabs, close_types);
 }
 
 bool TabStripModel::TabsAreLoading() const {
-  TabContentsDataVector::const_iterator iter = contents_data_.begin();
-  for (; iter != contents_data_.end(); ++iter) {
+  for (TabContentsDataVector::const_iterator iter = contents_data_.begin();
+       iter != contents_data_.end(); ++iter) {
     if ((*iter)->contents->web_contents()->IsLoading())
       return true;
   }
   return false;
 }
 
 NavigationController* TabStripModel::GetOpenerOfTabContentsAt(int index) {
   DCHECK(ContainsIndex(index));
   return contents_data_[index]->opener;
 }
@@ skipping 20 matching lines @@
   }
   // Then check tabs before start_index, iterating backwards.
   for (int i = start_index - 1; i >= 0; --i) {
     if (OpenerMatches(contents_data_[i], opener, use_group))
       return i;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfFirstTabContentsOpenedBy(
-    const NavigationController* opener, int start_index) const {
+    const NavigationController* opener,
+    int start_index) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
   for (int i = 0; i < start_index; ++i) {
     if (contents_data_[i]->opener == opener)
       return i;
   }
   return kNoTab;
 }
 
 int TabStripModel::GetIndexOfLastTabContentsOpenedBy(
-    const NavigationController* opener, int start_index) const {
+    const NavigationController* opener,
+    int start_index) const {
   DCHECK(opener);
   DCHECK(ContainsIndex(start_index));
 
-  TabContentsDataVector::const_iterator end =
-      contents_data_.begin() + start_index;
-  TabContentsDataVector::const_iterator iter = contents_data_.end();
-  TabContentsDataVector::const_iterator next;
-  for (; iter != end; --iter) {
-    next = iter - 1;
-    if (next == end)
-      break;
-    if ((*next)->opener == opener)
-      return static_cast<int>(next - contents_data_.begin());
+  for (int i = contents_data_.size() - 1; i > start_index; --i) {
+    if (contents_data_[i]->opener == opener)
+      return i;
   }
   return kNoTab;
 }
 
 void TabStripModel::TabNavigating(TabContents* contents,
                                   content::PageTransition transition) {
   if (ShouldForgetOpenersForTransition(transition)) {
     // Don't forget the openers if this tab is a New Tab page opened at the
     // end of the TabStrip (e.g. by pressing Ctrl+T). Give the user one
     // navigation of one of these transition types before resetting the
     // opener relationships (this allows for the use case of opening a new
     // tab to do a quick look-up of something while viewing a tab earlier in
     // the strip). We can make this heuristic more permissive if need be.
     if (!IsNewTabAtEndOfTabStrip(contents)) {
       // If the user navigates the current tab to another page in any way
       // other than by clicking a link, we want to pro-actively forget all
       // TabStrip opener relationships since we assume they're beginning a
       // different task by reusing the current tab.
       ForgetAllOpeners();
       // 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.
-  TabContentsDataVector::const_iterator iter = contents_data_.begin();
-  for (; iter != contents_data_.end(); ++iter)
+  for (TabContentsDataVector::const_iterator iter = contents_data_.begin();
+       iter != contents_data_.end(); ++iter)
     (*iter)->ForgetOpener();
 }
 
 void TabStripModel::ForgetGroup(TabContents* contents) {
   int index = GetIndexOfTabContents(contents);
   DCHECK(ContainsIndex(index));
   contents_data_[index]->SetGroup(NULL);
   contents_data_[index]->ForgetOpener();
 }
 
@@ skipping 623 matching lines @@
           processes.find(process);
       if (iter == processes.end()) {
         processes[process] = 1;
       } else {
         iter->second++;
       }
     }
 
     // Try to fast shutdown the tabs that can close.
     for (std::map<content::RenderProcessHost*, size_t>::iterator iter =
-            processes.begin();
-        iter != processes.end(); ++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 < tabs.size(); ++i) {
     TabContents* detached_contents = tabs[i];
     int index = GetIndexOfTabContents(detached_contents);
     // Make sure we still contain the tab.
@@ skipping 164 matching lines @@
 void TabStripModel::ForgetOpenersAndGroupsReferencing(
     const NavigationController* tab) {
   for (TabContentsDataVector::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;
   }
 }