Removal of TabContentsDelegate::GetBrowser() interface method

chrome/browser/browser.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/browser.h"
 
 #if defined(OS_WIN)
 #include <shellapi.h>
 #include <windows.h>
 #endif  // OS_WIN
@@ skipping 429 matching lines @@
 // static
 void Browser::OpenURLOffTheRecord(Profile* profile, const GURL& url) {
   Profile* off_the_record_profile = profile->GetOffTheRecordProfile();
   Browser* browser = BrowserList::FindBrowserWithType(
       off_the_record_profile, TYPE_NORMAL, false);
   if (!browser)
     browser = Browser::Create(off_the_record_profile);
   // TODO(eroman): should we have referrer here?
   browser->AddTabWithURL(
       url, GURL(), PageTransition::LINK, -1, TabStripModel::ADD_SELECTED, NULL,
-      std::string());
+      std::string(), &browser);
   browser->window()->Show();
 }
 
 // static
 Browser* Browser::FindAppWindowOrPanel(Profile* profile,
                                        Extension* extension_app) {
   // Test the focused browser first.
   Browser* browser = BrowserList::GetLastActive();
   if (browser && BrowserHostsExtensionApp(browser, profile, extension_app))
     return browser;
@@ skipping 69 matching lines @@
       browser->SelectTabContentsAt(tab_idx, false);
       return tab;
     }
   }
 
   // The app is not yet open.  Load it.
   switch (container) {
     case Extension::LAUNCH_WINDOW:
     case Extension::LAUNCH_PANEL:
       tab = Browser::OpenApplicationWindow(profile, extension, container,
-                                           GURL());
+                                           GURL(), &browser);
       break;
     case Extension::LAUNCH_TAB: {
-      tab = Browser::OpenApplicationTab(profile, extension);
+      tab = Browser::OpenApplicationTab(profile, extension, &browser);
       break;
     }
     default:
       NOTREACHED();
       break;
   }
   if (tab) {
-    Browser* browser = tab->delegate()->GetBrowser();
     if (browser && extension && extension->launch_fullscreen())
       browser->window()->SetFullscreen(true);
   }
   return tab;
 }
 
 // static
 TabContents* Browser::OpenApplicationWindow(
     Profile* profile,
     Extension* extension,
     Extension::LaunchContainer container,
-    const GURL& url_input) {
+    const GURL& url_input,
+    Browser** browser) {
   GURL url;
   if (!url_input.is_empty()) {
     if (extension)
       DCHECK(extension->web_extent().ContainsURL(url_input));
     url = url_input;
   } else {
     DCHECK(extension);
     url = extension->GetFullLaunchURL();
   }
 
   // TODO(erikkay) this can't be correct for extensions
   std::string app_name = web_app::GenerateApplicationNameFromURL(url);
   RegisterAppPrefs(app_name);
 
   bool as_panel = extension && (container == Extension::LAUNCH_PANEL);
-  Browser* browser = Browser::CreateForApp(app_name, extension, profile,
-                                           as_panel);
-  TabContents* tab_contents = browser->AddTabWithURL(
+  Browser* local_browser = Browser::CreateForApp(app_name, extension, profile,
+                                                 as_panel);
+  TabContents* tab_contents = local_browser->AddTabWithURL(
       url, GURL(), PageTransition::START_PAGE, -1, TabStripModel::ADD_SELECTED,
-      NULL, std::string());
+      NULL, std::string(), &local_browser);
 
   tab_contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
   tab_contents->render_view_host()->SyncRendererPrefs();
-  browser->window()->Show();
+  local_browser->window()->Show();
 
   // TODO(jcampan): http://crbug.com/8123 we should not need to set the initial
   //                focus explicitly.
   tab_contents->view()->SetInitialFocus();
 
   if (!as_panel) {
     // Set UPDATE_SHORTCUT as the pending web app action. This action is picked
     // up in LoadingStateChanged to schedule a GetApplicationInfo. And when
     // the web app info is available, TabContents notifies Browser via
     // OnDidGetApplicationInfo, which calls
     // web_app::UpdateShortcutForTabContents when it sees UPDATE_SHORTCUT as
     // pending web app action.
-    browser->pending_web_app_action_ = UPDATE_SHORTCUT;
+    local_browser->pending_web_app_action_ = UPDATE_SHORTCUT;
   }
 
+  if (browser)
+    *browser = local_browser;
+
   return tab_contents;
 }
 
 // static
 TabContents* Browser::OpenApplicationWindow(Profile* profile,
-                                            GURL& url) {
-  return OpenApplicationWindow(profile, NULL, Extension::LAUNCH_WINDOW, url);
+                                            GURL& url, Browser** browser) {
+  return OpenApplicationWindow(profile, NULL, Extension::LAUNCH_WINDOW, url,
+                               browser);
 }
 
 // static
 TabContents* Browser::OpenApplicationTab(Profile* profile,
-                                         Extension* extension) {
-  Browser* browser = BrowserList::GetLastActiveWithProfile(profile);
-  if (!browser || browser->type() != Browser::TYPE_NORMAL)
+                                         Extension* extension,
+                                         Browser** browser) {
+  Browser* local_browser = BrowserList::GetLastActiveWithProfile(profile);
+  if (!local_browser || local_browser->type() != Browser::TYPE_NORMAL)
     return NULL;
 
   // TODO(erikkay): This doesn't seem like the right transition in all cases.
   PageTransition::Type transition = PageTransition::START_PAGE;
   GURL url = extension->GetFullLaunchURL();
   TabContents* tab_contents =
-      browser->CreateTabContentsForURL(url, GURL(), profile,
-                                       transition, false, NULL);
+      local_browser->CreateTabContentsForURL(url, GURL(), profile,
+                                             transition, false, NULL);
   tab_contents->SetExtensionApp(extension);
-  browser->AddTab(tab_contents, transition);
+  local_browser->AddTab(tab_contents, transition);
+
+  if (browser)
+    *browser = local_browser;
+
   return tab_contents;
 }
 
 // static
 void Browser::OpenBookmarkManagerWindow(Profile* profile) {
   Browser* browser = Browser::Create(profile);
   browser->ShowBookmarkManagerTab();
   browser->window()->Show();
 }
 
@@ skipping 233 matching lines @@
   return (tabstrip_model_.insertion_policy() == TabStripModel::INSERT_AFTER) ?
       tab_count() : relative_index;
 }
 
 TabContents* Browser::AddTabWithURL(const GURL& url,
                                     const GURL& referrer,
                                     PageTransition::Type transition,
                                     int index,
                                     int add_types,
                                     SiteInstance* instance,
-                                    const std::string& extension_app_id) {
+                                    const std::string& extension_app_id,
+                                    Browser** browser_used) {
   TabContents* contents = NULL;
   if (CanSupportWindowFeature(FEATURE_TABSTRIP) || tabstrip_model()->empty()) {
     GURL url_to_load = url;
     if (url_to_load.is_empty())
       url_to_load = GetHomePage();
     contents = CreateTabContentsForURL(url_to_load, referrer, profile_,
                                        transition, false, instance);
     contents->SetExtensionAppById(extension_app_id);
     tabstrip_model_.AddTabContents(contents, index, transition, add_types);
     // TODO(sky): figure out why this is needed. Without it we seem to get
     // failures in startup tests.
     // By default, content believes it is not hidden.  When adding contents
     // in the background, tell it that it's hidden.
     if ((add_types & TabStripModel::ADD_SELECTED) == 0) {
       // TabStripModel::AddTabContents invokes HideContents if not foreground.
       contents->WasHidden();
     }
+
+    if (browser_used)
+      *browser_used = this;
   } else {
     // We're in an app window or a popup window. Find an existing browser to
     // open this URL in, creating one if none exists.
     Browser* b = BrowserList::FindBrowserWithFeature(profile_,
                                                      FEATURE_TABSTRIP);
     if (!b)
       b = Browser::Create(profile_);
     contents = b->AddTabWithURL(url, referrer, transition, index, add_types,
-                                instance, extension_app_id);
+                                instance, extension_app_id, &b);
     b->window()->Show();
+
+    if (browser_used)
+      *browser_used = b;
   }
   return contents;
 }
 
 TabContents* Browser::AddTab(TabContents* tab_contents,
                              PageTransition::Type type) {
   tabstrip_model_.AddTabContents(
       tab_contents, -1, type, TabStripModel::ADD_SELECTED);
   return tab_contents;
 }
@@ skipping 107 matching lines @@
     TabContents* tc = tabstrip_model_.GetTabContentsAt(i);
     if (CompareURLsIgnoreRef(tc->GetURL(), url) ||
         CompareURLsIgnoreRef(tc->GetURL(), rewritten_url)) {
       tabstrip_model_.SelectTabContentsAt(i, false);
       return;
     }
   }
 
   // Otherwise, just create a new tab.
   AddTabWithURL(url, GURL(), PageTransition::AUTO_BOOKMARK, -1,
-                TabStripModel::ADD_SELECTED, NULL, std::string());
+                TabStripModel::ADD_SELECTED, NULL, std::string(), NULL);
 }
 
 void Browser::UpdateCommandsForFullscreenMode(bool is_fullscreen) {
 #if !defined(OS_MACOSX)
   const bool show_main_ui = (type() == TYPE_NORMAL) && !is_fullscreen;
 #else
   const bool show_main_ui = (type() == TYPE_NORMAL);
 #endif
 
   bool main_not_fullscreen_or_popup =
@@ skipping 784 matching lines @@
 }
 
 void Browser::OpenUpdateChromeDialog() {
   UserMetrics::RecordAction(UserMetricsAction("UpdateChrome"), profile_);
   window_->ShowUpdateChromeDialog();
 }
 
 void Browser::OpenHelpTab() {
   GURL help_url = google_util::AppendGoogleLocaleParam(GURL(kHelpContentUrl));
   AddTabWithURL(help_url, GURL(), PageTransition::AUTO_BOOKMARK, -1,
-                TabStripModel::ADD_SELECTED, NULL, std::string());
+                TabStripModel::ADD_SELECTED, NULL, std::string(), NULL);
 }
 
 void Browser::OpenThemeGalleryTabAndActivate() {
   OpenURL(GURL(l10n_util::GetStringUTF8(IDS_THEMES_GALLERY_URL)),
           GURL(), NEW_FOREGROUND_TAB, PageTransition::LINK);
   window_->Activate();
 }
 
 void Browser::OpenPrivacyDashboardTabAndActivate() {
   OpenURL(GURL(l10n_util::GetStringUTF8(IDS_PRIVACY_DASHBOARD_URL)),
@@ skipping 331 matching lines @@
 }
 
 TabContents* Browser::AddBlankTabAt(int index, bool foreground) {
   // Time new tab page creation time.  We keep track of the timing data in
   // TabContents, but we want to include the time it takes to create the
   // TabContents object too.
   base::TimeTicks new_tab_start_time = base::TimeTicks::Now();
   TabContents* tab_contents = AddTabWithURL(
       GURL(chrome::kChromeUINewTabURL), GURL(), PageTransition::TYPED, index,
       foreground ? TabStripModel::ADD_SELECTED : TabStripModel::ADD_NONE, NULL,
-      std::string());
+      std::string(), NULL);
   tab_contents->set_new_tab_start_time(new_tab_start_time);
   return tab_contents;
 }
 
 Browser* Browser::CreateNewStripWithContents(TabContents* detached_contents,
                                              const gfx::Rect& window_bounds,
                                              const DockInfo& dock_info,
                                              bool maximize) {
   DCHECK(CanSupportWindowFeature(FEATURE_TABSTRIP));
 
@@ skipping 169 matching lines @@
   TabCloseableStateWatcher* watcher =
       g_browser_process->tab_closeable_state_watcher();
   return !watcher || watcher->CanCloseTab(this);
 }
 
 void Browser::ToggleUseVerticalTabs() {
   use_vertical_tabs_.SetValue(!UseVerticalTabs());
   UseVerticalTabsChanged();
 }
 
+bool Browser::LargeIconsPermitted() const {
+  // We don't show the big icons in tabs for TYPE_EXTENSION_APP windows because
+  // for those windows, we already have a big icon in the top-left outside any
+  // tab. Having big tab icons too looks kinda redonk.
+  return TYPE_EXTENSION_APP != type();
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, TabStripModelObserver implementation:
 
 void Browser::TabInsertedAt(TabContents* contents,
                             int index,
                             bool foreground) {
   contents->set_delegate(this);
   contents->controller().SetWindowID(session_id());
 
   SyncHistoryWithTabs(index);
@@ skipping 545 matching lines @@
       break;
     }
     default:
       NOTREACHED();
       break;
   }
 
   pending_web_app_action_ = NONE;
 }
 
-Browser* Browser::GetBrowser() {
-  return this;
-}
-
 void Browser::ContentTypeChanged(TabContents* source) {
   if (source == GetSelectedTabContents())
     UpdateZoomCommandsForTabState();
 }
 
 void Browser::CommitMatchPreview(TabContents* source) {
   int index = tabstrip_model_.GetIndexOfTabContents(source);
   DCHECK_NE(-1, index);
   TabContents* preview_contents =
       source->match_preview()->ReleasePreviewContents();
@@ skipping 790 matching lines @@
         (*iter)->window()->Show();
         return true;
       }
     }
 
     // If the extension wants to be opened in a window, but there is no
     // existing window, create one, then open the URL there.
     if (destination_extension->launch_container() ==
         Extension::LAUNCH_WINDOW) {
       Browser::OpenApplicationWindow(profile_, destination_extension,
-                                     Extension::LAUNCH_WINDOW, url);
+                                     Extension::LAUNCH_WINDOW, url, NULL);
       return true;
     }
   }
 
   // Otherwise, we are opening a normal web page.
   //
   // If our source tab is in an app window, we don't want to open the tab
   // there. Find a normal browser to open it in.
   if (extension_app_) {
     Browser* browser = GetOrCreateTabbedBrowser(profile_);
@@ skipping 133 matching lines @@
   if (profile_->IsOffTheRecord() && disposition == OFF_THE_RECORD)
     disposition = NEW_FOREGROUND_TAB;
 
   if (disposition == SINGLETON_TAB) {
     ShowSingletonTab(url);
     return;
   } else if (disposition == NEW_WINDOW) {
     Browser* browser = Browser::Create(profile_);
     new_contents = browser->AddTabWithURL(
         url, referrer, transition, index,
-        TabStripModel::ADD_SELECTED | add_types, instance, std::string());
+        TabStripModel::ADD_SELECTED | add_types, instance, std::string(),
+        &browser);
     browser->window()->Show();
   } else if ((disposition == CURRENT_TAB) && current_tab) {
     tabstrip_model_.TabNavigating(current_tab, transition);
 
     bool user_initiated = (PageTransition::StripQualifier(transition) ==
                            PageTransition::AUTO_BOOKMARK);
 
     if (user_initiated && source_tab_was_frontmost &&
         window_->GetLocationBar()) {
       // Forcibly reset the location bar if the url is going to change in the
@@ skipping 14 matching lines @@
     // the throbber will show the default favicon for a split second when
     // navigating away from the new tab page.
     ScheduleUIUpdate(current_tab, TabContents::INVALIDATE_URL);
   } else if (disposition == OFF_THE_RECORD) {
     OpenURLOffTheRecord(profile_, url);
     return;
   } else if (disposition != SUPPRESS_OPEN) {
     if (disposition != NEW_BACKGROUND_TAB)
       add_types |= TabStripModel::ADD_SELECTED;
     new_contents = AddTabWithURL(url, referrer, transition, index, add_types,
-                                 instance, std::string());
+                                 instance, std::string(), NULL);
   }
 
   if (disposition != NEW_BACKGROUND_TAB && source_tab_was_frontmost &&
       new_contents) {
     // Give the focus to the newly navigated tab, if the source tab was
     // front-most.
     new_contents->Focus();
   }
 }
 
@@ skipping 137 matching lines @@
 }
 
 bool Browser::IsPinned(TabContents* source) {
   int index = tabstrip_model_.GetIndexOfTabContents(source);
   if (index == TabStripModel::kNoTab) {
     NOTREACHED() << "IsPinned called for tab not in our strip";
     return false;
   }
   return tabstrip_model_.IsTabPinned(index);
 }