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

chrome/browser/ui/browser.h

 // 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.
 
 #ifndef CHROME_BROWSER_UI_BROWSER_H_
 #define CHROME_BROWSER_UI_BROWSER_H_
 #pragma once
 
 #include <map>
 #include <set>
@@ skipping 307 matching lines @@
   // TabStripModel pass-thrus /////////////////////////////////////////////////
 
   TabStripModel* tabstrip_model() const {
     // TODO(beng): remove this accessor. It violates google style.
     return tab_handler_->GetTabStripModel();
   }
 
   int tab_count() const;
   int selected_index() const;
   int GetIndexOfController(const NavigationController* controller) const;
+  TabContentsWrapper* GetSelectedTabContentsWrapper() const;
+  TabContentsWrapper* GetTabContentsWrapperAt(int index) const;
+  // Same as above but correctly handles if GetSelectedTabContents() is NULL
+  // in the model before dereferencing to get the raw TabContents.
+  // TODO(pinkerton): These should really be returning TabContentsWrapper
+  // objects, but that would require changing about 50+ other files. In order
+  // to keep changes localized, the default is to return a TabContents. Note
+  // this differs from the TabStripModel because it has far fewer clients.
+  TabContents* GetSelectedTabContents() const;
   TabContents* GetTabContentsAt(int index) const;
-  TabContents* GetSelectedTabContents() const;
   void SelectTabContentsAt(int index, bool user_gesture);
   void CloseAllTabs();
 
   // Tab adding/showing functions /////////////////////////////////////////////
 
   // Returns the index to insert a tab at during session restore and startup.
   // |relative_index| gives the index of the url into the number of tabs that
   // are going to be opened. For example, if three urls are passed in on the
   // command line this is invoked three times with the values 0, 1 and 2.
   int GetIndexForInsertionDuringRestore(int relative_index);
 
   // Adds a selected tab with the specified URL and transition, returns the
   // created TabContents.
-  TabContents* AddSelectedTabWithURL(const GURL& url,
-                                     PageTransition::Type transition);
+  TabContentsWrapper* AddSelectedTabWithURL(
+      const GURL& url,
+      PageTransition::Type transition);
 
   // Add a new tab, given a TabContents. A TabContents appropriate to
   // display the last committed entry is created and returned.
-  TabContents* AddTab(TabContents* tab_contents, PageTransition::Type type);
+  TabContents* AddTab(TabContentsWrapper* tab_contents,
+                      PageTransition::Type type);
 
   // Add a tab with its session history restored from the SessionRestore
   // system. If select is true, the tab is selected. |tab_index| gives the index
   // to insert the tab at. |selected_navigation| is the index of the
   // TabNavigation in |navigations| to select. If |extension_app_id| is
   // non-empty the tab is an app tab and |extension_app_id| is the id of the
   // extension. If |pin| is true and |tab_index|/ is the last pinned tab, then
   // the newly created tab is pinned. If |from_last_session| is true,
   // |navigations| are from the previous session.
   TabContents* AddRestoredTab(const std::vector<TabNavigation>& navigations,
@@ skipping 230 matching lines @@
   void SetBlockCommandExecution(bool block);
 
   // Gets the last blocked command after calling SetBlockCommandExecution(true).
   // Returns the command id or -1 if there is no command blocked. The
   // disposition type of the command will be stored in |*disposition| if it's
   // not null.
   int GetLastBlockedCommand(WindowOpenDisposition* disposition);
 
   // Called by browser::Navigate() when a navigation has occurred in a tab in
   // this Browser. Updates the UI for the start of this navigation.
-  void UpdateUIForNavigationInTab(TabContents* contents,
+  void UpdateUIForNavigationInTab(TabContentsWrapper* contents,
                                   PageTransition::Type transition,
                                   bool user_initiated);
 
   // Called by browser::Navigate() to retrieve the home page if no URL is
   // specified.
   GURL GetHomePage() const;
 
   // Interface implementations ////////////////////////////////////////////////
 
   // Overridden from PageNavigator:
   virtual void OpenURL(const GURL& url, const GURL& referrer,
                        WindowOpenDisposition disposition,
                        PageTransition::Type transition);
 
   // Overridden from CommandUpdater::CommandUpdaterDelegate:
   virtual void ExecuteCommand(int id);
 
   // Overridden from TabRestoreServiceObserver:
   virtual void TabRestoreServiceChanged(TabRestoreService* service);
   virtual void TabRestoreServiceDestroyed(TabRestoreService* service);
 
+  // Centralized method for creating a TabContents, configuring and installing
+  // all its supporting objects and observers.
+  static TabContentsWrapper*
+      TabContentsFactory(Profile* profile,
+                         SiteInstance* site_instance,
+                         int routing_id,
+                         const TabContents* base_tab_contents,
+                         SessionStorageNamespace* session_storage_namespace);
 
   // Overridden from TabHandlerDelegate:
   virtual Profile* GetProfile() const;
   virtual Browser* AsBrowser();
 
   // Overridden from TabStripModelDelegate:
-  virtual TabContents* AddBlankTab(bool foreground);
-  virtual TabContents* AddBlankTabAt(int index, bool foreground);
-  virtual Browser* CreateNewStripWithContents(TabContents* detached_contents,
-                                              const gfx::Rect& window_bounds,
-                                              const DockInfo& dock_info,
-                                              bool maximize);
-  virtual void ContinueDraggingDetachedTab(TabContents* contents,
+  virtual TabContentsWrapper* AddBlankTab(bool foreground);
+  virtual TabContentsWrapper* AddBlankTabAt(int index, bool foreground);
+  virtual Browser* CreateNewStripWithContents(
+      TabContentsWrapper* detached_contents,
+      const gfx::Rect& window_bounds,
+      const DockInfo& dock_info,
+      bool maximize);
+  virtual void ContinueDraggingDetachedTab(TabContentsWrapper* contents,
                                            const gfx::Rect& window_bounds,
                                            const gfx::Rect& tab_bounds);
   virtual int GetDragActions() const;
   // Construct a TabContents for a given URL, profile and transition type.
   // If instance is not null, its process will be used to render the tab.
-  virtual TabContents* CreateTabContentsForURL(const GURL& url,
+  virtual TabContentsWrapper* CreateTabContentsForURL(const GURL& url,
                                                const GURL& referrer,
                                                Profile* profile,
                                                PageTransition::Type transition,
                                                bool defer_load,
                                                SiteInstance* instance) const;
   virtual bool CanDuplicateContentsAt(int index);
   virtual void DuplicateContentsAt(int index);
   virtual void CloseFrameAfterDragSession();
-  virtual void CreateHistoricalTab(TabContents* contents);
-  virtual bool RunUnloadListenerBeforeClosing(TabContents* contents);
+  virtual void CreateHistoricalTab(TabContentsWrapper* contents);
+  virtual bool RunUnloadListenerBeforeClosing(TabContentsWrapper* contents);
   virtual bool CanCloseContentsAt(int index);
   virtual bool CanBookmarkAllTabs() const;
   virtual void BookmarkAllTabs();
   virtual bool CanCloseTab() const;
   virtual void ToggleUseVerticalTabs();
   virtual bool CanRestoreTab();
   virtual void RestoreTab();
   virtual bool LargeIconsPermitted() const;
 
   // Overridden from TabStripModelObserver:
-  virtual void TabInsertedAt(TabContents* contents,
+  virtual void TabInsertedAt(TabContentsWrapper* contents,
                              int index,
                              bool foreground);
   virtual void TabClosingAt(TabStripModel* tab_strip_model,
-                            TabContents* contents,
+                            TabContentsWrapper* contents,
                             int index);
-  virtual void TabDetachedAt(TabContents* contents, int index);
-  virtual void TabDeselectedAt(TabContents* contents, int index);
-  virtual void TabSelectedAt(TabContents* old_contents,
-                             TabContents* new_contents,
+  virtual void TabDetachedAt(TabContentsWrapper* contents, int index);
+  virtual void TabDeselectedAt(TabContentsWrapper* contents, int index);
+  virtual void TabSelectedAt(TabContentsWrapper* old_contents,
+                             TabContentsWrapper* new_contents,
                              int index,
                              bool user_gesture);
-  virtual void TabMoved(TabContents* contents,
+  virtual void TabMoved(TabContentsWrapper* contents,
                         int from_index,
                         int to_index);
-  virtual void TabReplacedAt(TabContents* old_contents,
-                             TabContents* new_contents,
+  virtual void TabReplacedAt(TabContentsWrapper* old_contents,
+                             TabContentsWrapper* new_contents,
                              int index);
-  virtual void TabPinnedStateChanged(TabContents* contents, int index);
+  virtual void TabPinnedStateChanged(TabContentsWrapper* contents, int index);
   virtual void TabStripEmpty();
 
  private:
   FRIEND_TEST_ALL_PREFIXES(BrowserTest, NoTabsInPopups);
 
   // Used to describe why a tab is being detached. This is used by
   // TabDetachedAtImpl.
   enum DetachType {
     // Result of TabDetachedAt.
     DETACH_TYPE_DETACH,
@@ skipping 77 matching lines @@
   // Overridden from NotificationObserver:
   virtual void Observe(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Overridden from ProfileSyncServiceObserver:
   virtual void OnStateChanged();
 
   // Overriden from InstantDelegate:
   virtual void PrepareForInstant();
-  virtual void ShowInstant(TabContents* preview_contents);
+  virtual void ShowInstant(TabContentsWrapper* preview_contents);
   virtual void HideInstant();
-  virtual void CommitInstant(TabContents* preview_contents);
+  virtual void CommitInstant(TabContentsWrapper* preview_contents);
   virtual void SetSuggestedText(const string16& text);
   virtual gfx::Rect GetInstantBounds();
 
   // Command and state updating ///////////////////////////////////////////////
 
   // Initialize state for all browser commands.
   void InitCommandState();
 
   // Update commands whose state depends on the tab's state.
   void UpdateCommandsForTabState();
@@ skipping 109 matching lines @@
   // Shows the Find Bar, optionally selecting the next entry that matches the
   // existing search string for that Tab. |forward_direction| controls the
   // search direction.
   void FindInPage(bool find_next, bool forward_direction);
 
   // Closes the frame.
   // TODO(beng): figure out if we need this now that the frame itself closes
   //             after a return to the message loop.
   void CloseFrame();
 
-  void TabDetachedAtImpl(TabContents* contents, int index, DetachType type);
+  void TabDetachedAtImpl(TabContentsWrapper* contents,
+      int index, DetachType type);
 
   // Create a preference dictionary for the provided application name. This is
   // done only once per application name / per session.
   static void RegisterAppPrefs(const std::string& app_name);
 
   // Shared code between Reload() and ReloadIgnoringCache().
   void ReloadInternal(WindowOpenDisposition disposition, bool ignore_cache);
 
   // Return true if the window dispositions means opening a new tab.
   bool ShouldOpenNewTabForWindowDisposition(WindowOpenDisposition disposition);
@@ skipping 166 matching lines @@
   // The profile's tab restore service. The service is owned by the profile,
   // and we install ourselves as an observer.
   TabRestoreService* tab_restore_service_;
 
   scoped_ptr<InstantController> instant_;
 
   DISALLOW_COPY_AND_ASSIGN(Browser);
 };
 
 #endif  // CHROME_BROWSER_UI_BROWSER_H_