chrome/browser/ui/chrome_pages.cc

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