Make pink's TabContentsWrapper change compile on Windows....

chrome/browser/tabs/tab_strip_model.cc

 // Copyright (c) 2010 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/tabs/tab_strip_model.h"
 
 #include <algorithm>
 
 #include "base/command_line.h"
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "build/build_config.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_shutdown.h"
 #include "chrome/browser/defaults.h"
 #include "chrome/browser/extensions/extensions_service.h"
 #include "chrome/browser/metrics/user_metrics.h"
 #include "chrome/browser/profile.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/sessions/tab_restore_service.h"
 #include "chrome/browser/tabs/tab_strip_model_delegate.h"
 #include "chrome/browser/tabs/tab_strip_model_order_controller.h"
+#include "chrome/browser/tab_contents_wrapper.h"
 #include "chrome/browser/tab_contents/navigation_controller.h"
 #include "chrome/browser/tab_contents/tab_contents.h"
 #include "chrome/browser/tab_contents/tab_contents_delegate.h"
 #include "chrome/browser/tab_contents/tab_contents_view.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/url_constants.h"
 
 namespace {
@@ skipping 63 matching lines @@
 }
 
 bool TabStripModel::HasObserver(TabStripModelObserver* observer) {
   return observers_.HasObserver(observer);
 }
 
 bool TabStripModel::ContainsIndex(int index) const {
   return index >= 0 && index < count();
 }
 
-void TabStripModel::AppendTabContents(TabContents* contents, bool foreground) {
+void TabStripModel::AppendTabContents(TabContentsWrapper* contents,
+                                      bool foreground) {
   int index = order_controller_->DetermineInsertionIndexForAppending();
   InsertTabContentsAt(index, contents,
                       foreground ? (ADD_INHERIT_GROUP | ADD_SELECTED) :
                                    ADD_NONE);
 }
 
 void TabStripModel::InsertTabContentsAt(int index,
-                                        TabContents* contents,
+                                        TabContentsWrapper* contents,
                                         int add_types) {
   bool foreground = add_types & ADD_SELECTED;
   // Force app tabs to be pinned.
   bool pin = contents->is_app() || add_types & ADD_PINNED;
   index = ConstrainInsertionIndex(index, pin);
 
   // 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 DetachTabContentsAt) which will mess with our mojo here. We need
   // to clear this bit.
   closing_all_ = false;
 
   // Have to get the selected contents before we monkey with |contents_|
   // otherwise we run into problems when we try to change the selected contents
   // since the old contents and the new contents will be the same...
-  TabContents* selected_contents = GetSelectedTabContents();
+  TabContentsWrapper* selected_contents = GetSelectedTabContents();
   TabContentsData* data = new TabContentsData(contents);
   data->pinned = pin;
   if ((add_types & ADD_INHERIT_GROUP) && selected_contents) {
     if (foreground) {
       // 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->SetGroup(&selected_contents->controller());
@@ skipping 14 matching lines @@
     ++selected_index_;
   }
 
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
       TabInsertedAt(contents, index, foreground));
 
   if (foreground)
     ChangeSelectedContentsFrom(selected_contents, index, false);
 }
 
-void TabStripModel::ReplaceTabContentsAt(int index, TabContents* new_contents) {
+void TabStripModel::ReplaceTabContentsAt(int index,
+                                         TabContentsWrapper* new_contents) {
   // TODO: this should reset group/opener of any tabs that point at
   // old_contents.
   DCHECK(ContainsIndex(index));
-  scoped_ptr<TabContents> old_contents(GetContentsAt(index));
+  scoped_ptr<TabContentsWrapper> old_contents(GetContentsAt(index));
 
   contents_data_[index]->contents = new_contents;
 
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabReplacedAt(old_contents.get(), new_contents, index));
 
   // When the selected tab contents is replaced send out selected notification
   // too. We do this as nearly all observers need to treat a replace of the
   // selected contents as selection changing.
   if (selected_index_ == index) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       TabSelectedAt(old_contents.get(), new_contents,
                                     selected_index_, false));
   }
 }
 
 void TabStripModel::ReplaceNavigationControllerAt(
-    int index, NavigationController* controller) {
+    int index, TabContentsWrapper* contents) {
   // This appears to be OK with no flicker since no redraw event
   // occurs between the call to add an aditional tab and one to close
   // the previous tab.
   InsertTabContentsAt(
-      index + 1, controller->tab_contents(),
+      index + 1, contents,
       ADD_SELECTED | ADD_INHERIT_GROUP);
   std::vector<int> closing_tabs;
   closing_tabs.push_back(index);
   InternalCloseTabs(closing_tabs, CLOSE_NONE);
 }
 
-TabContents* TabStripModel::DetachTabContentsAt(int index) {
+TabContentsWrapper* TabStripModel::DetachTabContentsAt(int index) {
   if (contents_data_.empty())
     return NULL;
 
   DCHECK(ContainsIndex(index));
 
-  TabContents* removed_contents = GetContentsAt(index);
+  TabContentsWrapper* removed_contents = GetContentsAt(index);
   int next_selected_index = order_controller_->DetermineNewSelectedIndex(index);
   delete contents_data_.at(index);
   contents_data_.erase(contents_data_.begin() + index);
   if (empty())
     closing_all_ = true;
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
       TabDetachedAt(removed_contents, index));
   if (empty()) {
     // TabDetachedAt() might unregister observers, so send |TabStripEmtpy()| in
     // a second pass.
@@ skipping 25 matching lines @@
   if ((index < first_non_mini_tab && to_position >= first_non_mini_tab) ||
       (to_position < first_non_mini_tab && index >= first_non_mini_tab)) {
     // This would result in mini tabs mixed with non-mini tabs. We don't allow
     // that.
     return;
   }
 
   MoveTabContentsAtImpl(index, to_position, select_after_move);
 }
 
-TabContents* TabStripModel::GetSelectedTabContents() const {
+TabContentsWrapper* TabStripModel::GetSelectedTabContents() const {
   return GetTabContentsAt(selected_index_);
 }
 
-TabContents* TabStripModel::GetTabContentsAt(int index) const {
+TabContentsWrapper* TabStripModel::GetTabContentsAt(int index) const {
   if (ContainsIndex(index))
     return GetContentsAt(index);
   return NULL;
 }
 
-int TabStripModel::GetIndexOfTabContents(const TabContents* contents) const {
+int TabStripModel::GetIndexOfTabContents(
+    const TabContentsWrapper* 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;
   }
   return kNoTab;
 }
 
+int TabStripModel::GetWrapperIndex(const TabContents* contents) const {
+  int index = 0;
+  TabContentsDataVector::const_iterator iter = contents_data_.begin();
+  for (; iter != contents_data_.end(); ++iter, ++index) {
+    if ((*iter)->contents->tab_contents() == contents)
+      return index;
+  }
+  return kNoTab;
+}
+
 int TabStripModel::GetIndexOfController(
     const NavigationController* controller) const {
   int index = 0;
   TabContentsDataVector::const_iterator iter = contents_data_.begin();
   for (; iter != contents_data_.end(); ++iter, ++index) {
     if (&(*iter)->contents->controller() == controller)
       return index;
   }
   return kNoTab;
 }
@@ skipping 19 matching lines @@
 
 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) {
-    if ((*iter)->contents->is_loading())
+    if ((*iter)->contents->tab_contents()->is_loading())
       return true;
   }
   return false;
 }
 
 NavigationController* TabStripModel::GetOpenerOfTabContentsAt(int index) {
   DCHECK(ContainsIndex(index));
   return contents_data_.at(index)->opener;
 }
 
@@ skipping 40 matching lines @@
   for (; iter != end; --iter) {
     next = iter - 1;
     if (next == end)
       break;
     if ((*next)->opener == opener)
       return static_cast<int>(next - contents_data_.begin());
   }
   return kNoTab;
 }
 
-void TabStripModel::TabNavigating(TabContents* contents,
+void TabStripModel::TabNavigating(TabContentsWrapper* contents,
                                   PageTransition::Type 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)
     (*iter)->ForgetOpener();
 }
 
-void TabStripModel::ForgetGroup(TabContents* contents) {
+void TabStripModel::ForgetGroup(TabContentsWrapper* contents) {
   int index = GetIndexOfTabContents(contents);
   DCHECK(ContainsIndex(index));
   contents_data_.at(index)->SetGroup(NULL);
   contents_data_.at(index)->ForgetOpener();
 }
 
-bool TabStripModel::ShouldResetGroupOnSelect(TabContents* contents) const {
+bool TabStripModel::ShouldResetGroupOnSelect(
+    TabContentsWrapper* contents) const {
   int index = GetIndexOfTabContents(contents);
   DCHECK(ContainsIndex(index));
   return contents_data_.at(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]->blocked = blocked;
@@ skipping 43 matching lines @@
 
 bool TabStripModel::IsTabPinned(int index) const {
   return contents_data_[index]->pinned;
 }
 
 bool TabStripModel::IsMiniTab(int index) const {
   return IsTabPinned(index) || IsAppTab(index);
 }
 
 bool TabStripModel::IsAppTab(int index) const {
-  TabContents* contents = GetTabContentsAt(index);
+  TabContentsWrapper* contents = GetTabContentsAt(index);
   return contents && contents->is_app();
 }
 
 bool TabStripModel::IsTabBlocked(int index) const {
   return contents_data_[index]->blocked;
 }
 
 int TabStripModel::IndexOfFirstNonMiniTab() const {
   for (size_t i = 0; i < contents_data_.size(); ++i) {
     if (!IsMiniTab(static_cast<int>(i)))
       return static_cast<int>(i);
   }
   // No mini-tabs.
   return count();
 }
 
 int TabStripModel::ConstrainInsertionIndex(int index, bool mini_tab) {
   return mini_tab ? std::min(std::max(0, index), IndexOfFirstNonMiniTab()) :
       std::min(count(), std::max(index, IndexOfFirstNonMiniTab()));
 }
 
-void TabStripModel::AddTabContents(TabContents* contents,
+void TabStripModel::AddTabContents(TabContentsWrapper* contents,
                                    int index,
                                    PageTransition::Type transition,
                                    int add_types) {
   // If the newly-opened tab is part of the same task as the parent tab, we want
   // to inherit the parent's "group" attribute, so that if this tab is then
   // closed we'll jump back to the parent tab.
   bool inherit_group = (add_types & ADD_INHERIT_GROUP) == ADD_INHERIT_GROUP;
 
   if (transition == PageTransition::LINK &&
       (add_types & ADD_FORCE_INDEX) == 0) {
@@ skipping 33 matching lines @@
   // TODO(sky): figure out why this is here and not in InsertTabContentsAt. When
   // here we seem to get failures in startup perf tests.
   // Ensure that the new TabContentsView begins at the same size as the
   // previous TabContentsView if it existed.  Otherwise, the initial WebKit
   // layout will be performed based on a width of 0 pixels, causing a
   // very long, narrow, inaccurate layout.  Because some scripts on pages (as
   // well as WebKit's anchor link location calculation) are run on the
   // initial layout and not recalculated later, we need to ensure the first
   // layout is performed with sane view dimensions even when we're opening a
   // new background tab.
-  if (TabContents* old_contents = GetSelectedTabContents()) {
+  if (TabContentsWrapper* old_contents = GetSelectedTabContents()) {
     if ((add_types & ADD_SELECTED) == 0) {
-      contents->view()->SizeContents(old_contents->view()->GetContainerSize());
+      contents->tab_contents()->view()->
+          SizeContents(old_contents->tab_contents()->
+                          view()->GetContainerSize());
       // We need to hide the contents or else we get and execute paints for
       // background tabs. With enough background tabs they will steal the
       // backing store of the visible tab causing flashing. See bug 20831.
-      contents->HideContents();
+      contents->tab_contents()->HideContents();
     }
   }
 }
 
 void TabStripModel::CloseSelectedTab() {
   CloseTabContentsAt(selected_index_, CLOSE_CREATE_HISTORICAL_TAB);
 }
 
 void TabStripModel::SelectNextTab() {
   SelectRelativeTab(true);
@@ skipping 19 matching lines @@
 
 // Context menu functions.
 bool TabStripModel::IsContextMenuCommandEnabled(
     int context_index, ContextMenuCommand command_id) const {
   DCHECK(command_id > CommandFirst && command_id < CommandLast);
   switch (command_id) {
     case CommandNewTab:
     case CommandCloseTab:
       return delegate_->CanCloseTab();
     case CommandReload:
-      if (TabContents* contents = GetTabContentsAt(context_index)) {
-        return contents->delegate()->CanReloadContents(contents);
+      if (TabContentsWrapper* contents = GetTabContentsAt(context_index)) {
+        return contents->tab_contents()->
+            delegate()->CanReloadContents(contents->tab_contents());
       } else {
         return false;
       }
     case CommandCloseOtherTabs: {
       int mini_tab_count = IndexOfFirstNonMiniTab();
           int non_mini_tab_count = count() - mini_tab_count;
       // Close other doesn't effect mini-tabs.
       return non_mini_tab_count > 1 ||
           (non_mini_tab_count == 1 && context_index != mini_tab_count);
     }
@@ skipping 133 matching lines @@
 // TabStripModel, NotificationObserver implementation:
 
 void TabStripModel::Observe(NotificationType type,
                             const NotificationSource& source,
                             const NotificationDetails& details) {
   switch (type.value) {
     case NotificationType::TAB_CONTENTS_DESTROYED: {
       // Sometimes, on qemu, it seems like a TabContents object can be destroyed
       // while we still have a reference to it. We need to break this reference
       // here so we don't crash later.
-      int index = GetIndexOfTabContents(Source<TabContents>(source).ptr());
+      int index = GetWrapperIndex(Source<TabContents>(source).ptr());
       if (index != TabStripModel::kNoTab) {
         // Note that we only detach the contents here, not close it - it's
         // already been closed. We just want to undo our bookkeeping.
         DetachTabContentsAt(index);
       }
       break;
     }
 
     case NotificationType::EXTENSION_UNLOADED: {
       const Extension* extension = Details<const Extension>(details).ptr();
       // Iterate backwards as we may remove items while iterating.
       for (int i = count() - 1; i >= 0; i--) {
-        TabContents* contents = GetTabContentsAt(i);
+        TabContentsWrapper* contents = GetTabContentsAt(i);
         if (contents->extension_app() == extension) {
           // The extension an app tab was created from has been nuked. Delete
           // the TabContents. Deleting a TabContents results in a notification
           // of type TAB_CONTENTS_DESTROYED; we do the necessary cleanup in
           // handling that notification.
 
           InternalCloseTab(contents, i, false);
         }
       }
       break;
     }
 
     default:
       NOTREACHED();
   }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // TabStripModel, private:
 
-bool TabStripModel::IsNewTabAtEndOfTabStrip(TabContents* contents) const {
-  return LowerCaseEqualsASCII(contents->GetURL().spec(),
+bool TabStripModel::IsNewTabAtEndOfTabStrip(
+    TabContentsWrapper* contents) const {
+  return LowerCaseEqualsASCII(contents->tab_contents()->GetURL().spec(),
                               chrome::kChromeUINewTabURL) &&
       contents == GetContentsAt(count() - 1) &&
       contents->controller().entry_count() == 1;
 }
 
 bool TabStripModel::InternalCloseTabs(const std::vector<int>& indices,
                                       uint32 close_types) {
   if (indices.empty())
     return true;
 
   bool retval = true;
 
   // Map the indices to TabContents, 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<TabContents*> tabs;
+  std::vector<TabContentsWrapper*> tabs;
   for (size_t i = 0; i < indices.size(); ++i)
     tabs.push_back(GetContentsAt(indices[i]));
 
   // 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<RenderProcessHost*, size_t> processes;
     for (size_t i = 0; i < indices.size(); ++i) {
       if (!delegate_->CanCloseContentsAt(indices[i])) {
         retval = false;
         continue;
       }
 
-      TabContents* detached_contents = GetContentsAt(indices[i]);
-      RenderProcessHost* process = detached_contents->GetRenderProcessHost();
+      TabContentsWrapper* detached_contents = GetContentsAt(indices[i]);
+      RenderProcessHost* process =
+          detached_contents->tab_contents()->GetRenderProcessHost();
       std::map<RenderProcessHost*, size_t>::iterator iter =
           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<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.
   for (size_t i = 0; i < tabs.size(); ++i) {
-    TabContents* detached_contents = tabs[i];
+    TabContentsWrapper* detached_contents = tabs[i];
     int index = GetIndexOfTabContents(detached_contents);
     // Make sure we still contain the tab.
     if (index == kNoTab)
       continue;
 
-    detached_contents->OnCloseStarted();
+    detached_contents->tab_contents()->OnCloseStarted();
 
     if (!delegate_->CanCloseContentsAt(index)) {
       retval = false;
       continue;
     }
 
     // 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
     // call back to this if the close is allowed.
-    if (!detached_contents->closed_by_user_gesture()) {
-      detached_contents->set_closed_by_user_gesture(
+    if (!detached_contents->tab_contents()->closed_by_user_gesture()) {
+      detached_contents->tab_contents()->set_closed_by_user_gesture(
           close_types & CLOSE_USER_GESTURE);
     }
 
     if (delegate_->RunUnloadListenerBeforeClosing(detached_contents)) {
       retval = false;
       continue;
     }
 
     InternalCloseTab(detached_contents, index,
                      (close_types & CLOSE_CREATE_HISTORICAL_TAB) != 0);
   }
 
   return retval;
 }
 
-void TabStripModel::InternalCloseTab(TabContents* contents,
+void TabStripModel::InternalCloseTab(TabContentsWrapper* contents,
                                      int index,
                                      bool create_historical_tabs) {
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     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 TabContents will call back to us via NotificationObserver
   // and detach it.
   delete contents;
 }
 
-TabContents* TabStripModel::GetContentsAt(int index) const {
+TabContentsWrapper* TabStripModel::GetContentsAt(int index) const {
   CHECK(ContainsIndex(index)) <<
       "Failed to find: " << index << " in: " << count() << " entries.";
   return contents_data_.at(index)->contents;
 }
 
 void TabStripModel::ChangeSelectedContentsFrom(
-    TabContents* old_contents, int to_index, bool user_gesture) {
-  TabContents* new_contents = GetContentsAt(to_index);
+    TabContentsWrapper* old_contents, int to_index, bool user_gesture) {
+  TabContentsWrapper* new_contents = GetContentsAt(to_index);
   if (old_contents == new_contents)
     return;
 
-  TabContents* last_selected_contents = old_contents;
+  TabContentsWrapper* last_selected_contents = old_contents;
   if (last_selected_contents) {
     FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                       TabDeselectedAt(last_selected_contents, selected_index_));
   }
 
   selected_index_ = to_index;
+  ObserverListBase<TabStripModelObserver>::Iterator it(observers_);
+  TabStripModelObserver* obs;
+  while ((obs = it.GetNext()) != NULL)
+    obs->TabSelectedAt(last_selected_contents, new_contents, selected_index_, user_gesture);
+  /*
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
       TabSelectedAt(last_selected_contents, new_contents, selected_index_,
                     user_gesture));
+                    */
 }
 
 void TabStripModel::SelectRelativeTab(bool next) {
   // This may happen during automated testing or if a user somehow buffers
   // many key accelerators.
   if (contents_data_.empty())
     return;
 
   int index = selected_index_;
   int delta = next ? 1 : -1;
@@ skipping 19 matching lines @@
   FOR_EACH_OBSERVER(TabStripModelObserver, observers_,
                     TabMoved(moved_data->contents, index, to_position));
 }
 
 // static
 bool TabStripModel::OpenerMatches(const TabContentsData* data,
                                   const NavigationController* opener,
                                   bool use_group) {
   return data->opener == opener || (use_group && data->group == opener);
 }