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 513 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::wstring 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());
 
   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 1736 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 531 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();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // Browser, SelectFileDialog::Listener implementation:
 
 void Browser::FileSelected(const FilePath& path, int index, void* params) {
   profile_->set_last_selected_directory(path.DirName());
@@ skipping 780 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 326 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);
 }