1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "chrome/browser/ui/chrome_pages.h" 6 7 #include "base/command_line.h" 8 #include "base/logging.h" 9 #include "base/strings/string_number_conversions.h" 10 #include "base/strings/stringprintf.h" 11 #include "chrome/browser/download/download_shelf.h" 12 #include "chrome/browser/extensions/extension_service.h" 13 #include "chrome/browser/profiles/profile.h" 14 #include "chrome/browser/profiles/profile_manager.h" 15 #include "chrome/browser/signin/signin_manager_factory.h" 16 #include "chrome/browser/ui/browser.h" 17 #include "chrome/browser/ui/browser_finder.h" 18 #include "chrome/browser/ui/browser_navigator.h" 19 #include "chrome/browser/ui/browser_window.h" 20 #include "chrome/browser/ui/extensions/application_launch.h" 21 #include "chrome/browser/ui/scoped_tabbed_browser_displayer.h" 22 #include "chrome/browser/ui/settings_window_manager.h" 23 #include "chrome/browser/ui/singleton_tabs.h" 24 #include "chrome/browser/ui/tabs/tab_strip_model.h" 25 #include "chrome/browser/ui/webui/options/content_settings_handler.h" 26 #include "chrome/common/chrome_switches.h" 27 #include "chrome/common/url_constants.h" 28 #include "components/signin/core/browser/signin_manager.h" 29 #include "content/public/browser/user_metrics.h" 30 #include "content/public/browser/web_contents.h" 31 #include "google_apis/gaia/gaia_urls.h" 32 #include "net/base/url_util.h" 33 34 #if defined(OS_WIN) 35 #include "chrome/browser/enumerate_modules_model_win.h" 36 #endif 37 38 #if defined(OS_CHROMEOS) 39 #include "chrome/browser/chromeos/genius_app/app_id.h" 40 #include "chromeos/chromeos_switches.h" 41 #endif 42 43 using base::UserMetricsAction; 44 45 namespace chrome { 46 namespace { 47 48 const char kHashMark[] = "#"; 49 50 void OpenBookmarkManagerWithHash(Browser* browser, 51 const std::string& action, 52 int64 node_id) { 53 content::RecordAction(UserMetricsAction("ShowBookmarkManager")); 54 content::RecordAction(UserMetricsAction("ShowBookmarks")); 55 NavigateParams params(GetSingletonTabNavigateParams( 56 browser, 57 GURL(kChromeUIBookmarksURL).Resolve(base::StringPrintf( 58 "/#%s%s", action.c_str(), base::Int64ToString(node_id).c_str())))); 59 params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE; 60 ShowSingletonTabOverwritingNTP(browser, params); 61 } 62 63 void NavigateToSingletonTab(Browser* browser, const GURL& url) { 64 NavigateParams params(GetSingletonTabNavigateParams(browser, url)); 65 params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE; 66 ShowSingletonTabOverwritingNTP(browser, params); 67 } 68 69 // Shows either the help app or the appropriate help page for |source|. If 70 // |browser| is NULL and the help page is used (vs the app), the help page is 71 // shown in the last active browser. If there is no such browser, a new browser 72 // is created. 73 void ShowHelpImpl(Browser* browser, 74 Profile* profile, 75 HostDesktopType host_desktop_type, 76 HelpSource source) { 77 content::RecordAction(UserMetricsAction("ShowHelpTab")); 78 #if defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD) 79 const CommandLine* command_line = CommandLine::ForCurrentProcess(); 80 if (!command_line->HasSwitch(chromeos::switches::kDisableGeniusApp)) { 81 const extensions::Extension* extension = 82 profile->GetExtensionService()->GetInstalledExtension( 83 genius_app::kGeniusAppId); 84 OpenApplication(AppLaunchParams(profile, extension, 0, host_desktop_type)); 85 return; 86 } 87 #endif 88 GURL url; 89 switch (source) { 90 case HELP_SOURCE_KEYBOARD: 91 url = GURL(kChromeHelpViaKeyboardURL); 92 break; 93 case HELP_SOURCE_MENU: 94 url = GURL(kChromeHelpViaMenuURL); 95 break; 96 case HELP_SOURCE_WEBUI: 97 url = GURL(kChromeHelpViaWebUIURL); 98 break; 99 default: 100 NOTREACHED() << "Unhandled help source " << source; 101 } 102 scoped_ptr<ScopedTabbedBrowserDisplayer> displayer; 103 if (!browser) { 104 displayer.reset( 105 new ScopedTabbedBrowserDisplayer(profile, host_desktop_type)); 106 browser = displayer->browser(); 107 } 108 ShowSingletonTab(browser, url); 109 } 110 111 } // namespace 112 113 void ShowBookmarkManager(Browser* browser) { 114 content::RecordAction(UserMetricsAction("ShowBookmarkManager")); 115 content::RecordAction(UserMetricsAction("ShowBookmarks")); 116 ShowSingletonTabOverwritingNTP( 117 browser, 118 GetSingletonTabNavigateParams(browser, GURL(kChromeUIBookmarksURL))); 119 } 120 121 void ShowBookmarkManagerForNode(Browser* browser, int64 node_id) { 122 OpenBookmarkManagerWithHash(browser, std::string(), node_id); 123 } 124 125 void ShowHistory(Browser* browser) { 126 content::RecordAction(UserMetricsAction("ShowHistory")); 127 NavigateParams params( 128 GetSingletonTabNavigateParams(browser, GURL(kChromeUIHistoryURL))); 129 params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE; 130 ShowSingletonTabOverwritingNTP(browser, params); 131 } 132 133 void ShowDownloads(Browser* browser) { 134 content::RecordAction(UserMetricsAction("ShowDownloads")); 135 if (browser->window()) { 136 DownloadShelf* shelf = browser->window()->GetDownloadShelf(); 137 // The downloads page is always shown in response to a user action. 138 if (shelf->IsShowing()) 139 shelf->Close(DownloadShelf::USER_ACTION); 140 } 141 ShowSingletonTabOverwritingNTP( 142 browser, 143 GetSingletonTabNavigateParams(browser, GURL(kChromeUIDownloadsURL))); 144 } 145 146 void ShowExtensions(Browser* browser, 147 const std::string& extension_to_highlight) { 148 content::RecordAction(UserMetricsAction("ShowExtensions")); 149 NavigateParams params( 150 GetSingletonTabNavigateParams(browser, GURL(kChromeUIExtensionsURL))); 151 params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE; 152 if (!extension_to_highlight.empty()) { 153 GURL::Replacements replacements; 154 std::string query("id="); 155 query += extension_to_highlight; 156 replacements.SetQueryStr(query); 157 params.url = params.url.ReplaceComponents(replacements); 158 } 159 ShowSingletonTabOverwritingNTP(browser, params); 160 } 161 162 void ShowConflicts(Browser* browser) { 163 #if defined(OS_WIN) 164 EnumerateModulesModel* model = EnumerateModulesModel::GetInstance(); 165 if (model->modules_to_notify_about() > 0) { 166 GURL help_center_url = model->GetFirstNotableConflict(); 167 if (help_center_url.is_valid()) { 168 ShowSingletonTab(browser, help_center_url); 169 model->AcknowledgeConflictNotification(); 170 return; 171 } 172 } 173 #endif 174 175 content::RecordAction(UserMetricsAction("AboutConflicts")); 176 ShowSingletonTab(browser, GURL(kChromeUIConflictsURL)); 177 } 178 179 void ShowHelp(Browser* browser, HelpSource source) { 180 ShowHelpImpl( 181 browser, browser->profile(), browser->host_desktop_type(), source); 182 } 183 184 void ShowHelpForProfile(Profile* profile, 185 HostDesktopType host_desktop_type, 186 HelpSource source) { 187 ShowHelpImpl(NULL, profile, host_desktop_type, source); 188 } 189 190 void ShowPolicy(Browser* browser) { 191 ShowSingletonTab(browser, GURL(kChromeUIPolicyURL)); 192 } 193 194 void ShowSlow(Browser* browser) { 195 #if defined(OS_CHROMEOS) 196 ShowSingletonTab(browser, GURL(kChromeUISlowURL)); 197 #endif 198 } 199 200 GURL GetSettingsUrl(const std::string& sub_page) { 201 std::string url = std::string(kChromeUISettingsURL) + sub_page; 202 #if defined(OS_CHROMEOS) 203 if (sub_page.find(kInternetOptionsSubPage, 0) != std::string::npos) { 204 std::string::size_type loc = sub_page.find("?", 0); 205 std::string network_page = 206 loc != std::string::npos ? sub_page.substr(loc) : std::string(); 207 url = std::string(kChromeUISettingsURL) + network_page; 208 } 209 #endif 210 return GURL(url); 211 } 212 213 bool IsTrustedPopupWindowWithScheme(const Browser* browser, 214 const std::string& scheme) { 215 if (!browser->is_type_popup() || !browser->is_trusted_source()) 216 return false; 217 if (scheme.empty()) // Any trusted popup window 218 return true; 219 const content::WebContents* web_contents = 220 browser->tab_strip_model()->GetWebContentsAt(0); 221 if (!web_contents) 222 return false; 223 GURL url(web_contents->GetURL()); 224 return url.SchemeIs(scheme.c_str()); 225 } 226 227 void ShowSettings(Browser* browser) { 228 ShowSettingsSubPage(browser, std::string()); 229 } 230 231 void ShowSettingsSubPage(Browser* browser, const std::string& sub_page) { 232 if (::switches::SettingsWindowEnabled()) { 233 ShowSettingsSubPageForProfile(browser->profile(), sub_page); 234 return; 235 } 236 ShowSettingsSubPageInTabbedBrowser(browser, sub_page); 237 } 238 239 void ShowSettingsSubPageForProfile(Profile* profile, 240 const std::string& sub_page) { 241 if (::switches::SettingsWindowEnabled()) { 242 content::RecordAction(base::UserMetricsAction("ShowOptions")); 243 SettingsWindowManager::GetInstance()->ShowChromePageForProfile( 244 profile, GetSettingsUrl(sub_page)); 245 return; 246 } 247 Browser* browser = 248 chrome::FindTabbedBrowser(profile, false, HOST_DESKTOP_TYPE_NATIVE); 249 if (!browser) { 250 browser = new Browser( 251 Browser::CreateParams(profile, chrome::HOST_DESKTOP_TYPE_NATIVE)); 252 } 253 ShowSettingsSubPageInTabbedBrowser(browser, sub_page); 254 } 255 256 void ShowSettingsSubPageInTabbedBrowser(Browser* browser, 257 const std::string& sub_page) { 258 content::RecordAction(UserMetricsAction("ShowOptions")); 259 GURL gurl = GetSettingsUrl(sub_page); 260 NavigateParams params(GetSingletonTabNavigateParams(browser, gurl)); 261 params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE; 262 ShowSingletonTabOverwritingNTP(browser, params); 263 } 264 265 void ShowContentSettings(Browser* browser, 266 ContentSettingsType content_settings_type) { 267 ShowSettingsSubPage( 268 browser, 269 kContentSettingsExceptionsSubPage + std::string(kHashMark) + 270 options::ContentSettingsHandler::ContentSettingsTypeToGroupName( 271 content_settings_type)); 272 } 273 274 void ShowClearBrowsingDataDialog(Browser* browser) { 275 content::RecordAction(UserMetricsAction("ClearBrowsingData_ShowDlg")); 276 ShowSettingsSubPage(browser, kClearBrowserDataSubPage); 277 } 278 279 void ShowPasswordManager(Browser* browser) { 280 content::RecordAction(UserMetricsAction("Options_ShowPasswordManager")); 281 ShowSettingsSubPage(browser, kPasswordManagerSubPage); 282 } 283 284 void ShowImportDialog(Browser* browser) { 285 content::RecordAction(UserMetricsAction("Import_ShowDlg")); 286 ShowSettingsSubPage(browser, kImportDataSubPage); 287 } 288 289 void ShowAboutChrome(Browser* browser) { 290 content::RecordAction(UserMetricsAction("AboutChrome")); 291 if (::switches::SettingsWindowEnabled()) { 292 SettingsWindowManager::GetInstance()->ShowChromePageForProfile( 293 browser->profile(), GURL(kChromeUIUberURL)); 294 return; 295 } 296 NavigateParams params( 297 GetSingletonTabNavigateParams(browser, GURL(kChromeUIUberURL))); 298 params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE; 299 ShowSingletonTabOverwritingNTP(browser, params); 300 } 301 302 void ShowSearchEngineSettings(Browser* browser) { 303 content::RecordAction(UserMetricsAction("EditSearchEngines")); 304 ShowSettingsSubPage(browser, kSearchEnginesSubPage); 305 } 306 307 void ShowBrowserSignin(Browser* browser, signin::Source source) { 308 Profile* original_profile = browser->profile()->GetOriginalProfile(); 309 SigninManagerBase* manager = 310 SigninManagerFactory::GetForProfile(original_profile); 311 DCHECK(manager->IsSigninAllowed()); 312 // If we're signed in, just show settings. 313 if (!manager->GetAuthenticatedUsername().empty()) { 314 ShowSettings(browser); 315 } else { 316 // If the browser's profile is an incognito profile, make sure to use 317 // a browser window from the original profile. The user cannot sign in 318 // from an incognito window. 319 scoped_ptr<ScopedTabbedBrowserDisplayer> displayer; 320 if (browser->profile()->IsOffTheRecord()) { 321 displayer.reset(new ScopedTabbedBrowserDisplayer( 322 original_profile, chrome::HOST_DESKTOP_TYPE_NATIVE)); 323 browser = displayer->browser(); 324 } 325 326 NavigateToSingletonTab(browser, GURL(signin::GetPromoURL(source, false))); 327 DCHECK_GT(browser->tab_strip_model()->count(), 0); 328 } 329 } 330 331 } // namespace chrome 332