src/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/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.h"
  16 #include "chrome/browser/signin/signin_manager_factory.h"
  17 #include "chrome/browser/ui/browser.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/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/url_constants.h"
  26 #include "content/public/browser/user_metrics.h"
  27 #include "google_apis/gaia/gaia_urls.h"
  28 #include "net/base/url_util.h"
  29 #include "url/gurl.h"
  30
  31 #if defined(OS_WIN)
  32 #include "chrome/browser/enumerate_modules_model_win.h"
  33 #endif
  34
  35 #if defined(OS_CHROMEOS)
  36 #include "chrome/browser/chromeos/genius_app/app_id.h"
  37 #include "chromeos/chromeos_switches.h"
  38 #endif
  39
  40 using content::UserMetricsAction;
  41
  42 namespace chrome {
  43 namespace {
  44
  45 const char kHashMark[] = "#";
  46
  47 void OpenBookmarkManagerWithHash(Browser* browser,
  48                                  const std::string& action,
  49                                  int64 node_id) {
  50   content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
  51   content::RecordAction(UserMetricsAction("ShowBookmarks"));
  52   NavigateParams params(GetSingletonTabNavigateParams(
  53       browser,
  54       GURL(kChromeUIBookmarksURL).Resolve(
  55           base::StringPrintf("/#%s%s", action.c_str(),
  56               base::Int64ToString(node_id).c_str()))));
  57   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
  58   ShowSingletonTabOverwritingNTP(browser, params);
  59 }
  60
  61 void NavigateToSingletonTab(Browser* browser, const GURL& url) {
  62   NavigateParams params(GetSingletonTabNavigateParams(browser, url));
  63   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
  64   ShowSingletonTabOverwritingNTP(browser, params);
  65 }
  66
  67 // Shows either the help app or the appropriate help page for |source|. If
  68 // |browser| is NULL and the help page is used (vs the app), the help page is
  69 // shown in the last active browser. If there is no such browser, a new browser
  70 // is created.
  71 void ShowHelpImpl(Browser* browser,
  72                   Profile* profile,
  73                   HostDesktopType host_desktop_type,
  74                   HelpSource source) {
  75   content::RecordAction(UserMetricsAction("ShowHelpTab"));
  76 #if defined(OS_CHROMEOS) && defined(OFFICIAL_BUILD)
  77   const CommandLine* command_line = CommandLine::ForCurrentProcess();
  78   if (!command_line->HasSwitch(chromeos::switches::kDisableGeniusApp)) {
  79     Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
  80     const extensions::Extension* extension = profile->GetExtensionService()->
  81         GetInstalledExtension(genius_app::kGeniusAppId);
  82     OpenApplication(
  83         AppLaunchParams(profile, extension, 0, host_desktop_type));
  84     return;
  85   }
  86 #endif
  87   GURL url;
  88   switch (source) {
  89     case HELP_SOURCE_KEYBOARD:
  90       url = GURL(kChromeHelpViaKeyboardURL);
  91       break;
  92     case HELP_SOURCE_MENU:
  93       url = GURL(kChromeHelpViaMenuURL);
  94       break;
  95     case HELP_SOURCE_WEBUI:
  96       url = GURL(kChromeHelpViaWebUIURL);
  97       break;
  98     default:
  99       NOTREACHED() << "Unhandled help source " << source;
 100   }
 101   scoped_ptr<ScopedTabbedBrowserDisplayer> displayer;
 102   if (!browser) {
 103     displayer.reset(
 104         new ScopedTabbedBrowserDisplayer(profile, host_desktop_type));
 105     browser = displayer->browser();
 106   }
 107   ShowSingletonTab(browser, url);
 108 }
 109
 110 }  // namespace
 111
 112 void ShowBookmarkManager(Browser* browser) {
 113   content::RecordAction(UserMetricsAction("ShowBookmarkManager"));
 114   content::RecordAction(UserMetricsAction("ShowBookmarks"));
 115   ShowSingletonTabOverwritingNTP(
 116       browser,
 117       GetSingletonTabNavigateParams(browser, GURL(kChromeUIBookmarksURL)));
 118 }
 119
 120 void ShowBookmarkManagerForNode(Browser* browser, int64 node_id) {
 121   OpenBookmarkManagerWithHash(browser, std::string(), node_id);
 122 }
 123
 124 void ShowHistory(Browser* browser) {
 125   content::RecordAction(UserMetricsAction("ShowHistory"));
 126   NavigateParams params(
 127       GetSingletonTabNavigateParams(browser, GURL(kChromeUIHistoryURL)));
 128   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
 129   ShowSingletonTabOverwritingNTP(browser, params);
 130 }
 131
 132 void ShowDownloads(Browser* browser) {
 133   content::RecordAction(UserMetricsAction("ShowDownloads"));
 134   if (browser->window()) {
 135     DownloadShelf* shelf = browser->window()->GetDownloadShelf();
 136     // The downloads page is always shown in response to a user action.
 137     if (shelf->IsShowing())
 138       shelf->Close(DownloadShelf::USER_ACTION);
 139   }
 140   ShowSingletonTabOverwritingNTP(
 141       browser,
 142       GetSingletonTabNavigateParams(browser, GURL(kChromeUIDownloadsURL)));
 143 }
 144
 145 void ShowExtensions(Browser* browser,
 146                     const std::string& extension_to_highlight) {
 147   content::RecordAction(UserMetricsAction("ShowExtensions"));
 148   NavigateParams params(
 149       GetSingletonTabNavigateParams(browser, GURL(kChromeUIExtensionsURL)));
 150   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
 151   if (!extension_to_highlight.empty()) {
 152     GURL::Replacements replacements;
 153     std::string query("id=");
 154     query += extension_to_highlight;
 155     replacements.SetQueryStr(query);
 156     params.url = params.url.ReplaceComponents(replacements);
 157   }
 158   ShowSingletonTabOverwritingNTP(browser, params);
 159 }
 160
 161 void ShowConflicts(Browser* browser) {
 162 #if defined(OS_WIN)
 163   EnumerateModulesModel* model = EnumerateModulesModel::GetInstance();
 164   if (model->modules_to_notify_about() > 0) {
 165     GURL help_center_url = model->GetFirstNotableConflict();
 166     if (help_center_url.is_valid()) {
 167       EnumerateModulesModel::RecordLearnMoreStat(true);
 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(browser, browser->profile(), browser->host_desktop_type(),
 181       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 void ShowSettings(Browser* browser) {
 201   content::RecordAction(UserMetricsAction("ShowOptions"));
 202   ShowSettingsSubPage(browser, std::string());
 203 }
 204
 205 void ShowSettingsSubPage(Browser* browser, const std::string& sub_page) {
 206   std::string url = std::string(kChromeUISettingsURL) + sub_page;
 207 #if defined(OS_CHROMEOS)
 208   if (sub_page.find(kInternetOptionsSubPage, 0) != std::string::npos) {
 209     std::string::size_type loc = sub_page.find("?", 0);
 210     std::string network_page = loc != std::string::npos ?
 211         sub_page.substr(loc) : std::string();
 212     url = std::string(kChromeUISettingsURL) + network_page;
 213   }
 214 #endif
 215   NavigateParams params(GetSingletonTabNavigateParams(browser, GURL(url)));
 216   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
 217   ShowSingletonTabOverwritingNTP(browser, params);
 218 }
 219
 220 void ShowContentSettings(Browser* browser,
 221                          ContentSettingsType content_settings_type) {
 222   ShowSettingsSubPage(
 223       browser,
 224       kContentSettingsExceptionsSubPage + std::string(kHashMark) +
 225       options::ContentSettingsHandler::ContentSettingsTypeToGroupName(
 226           content_settings_type));
 227 }
 228
 229 void ShowClearBrowsingDataDialog(Browser* browser) {
 230   content::RecordAction(UserMetricsAction("ClearBrowsingData_ShowDlg"));
 231   ShowSettingsSubPage(browser, kClearBrowserDataSubPage);
 232 }
 233
 234 void ShowPasswordManager(Browser* browser) {
 235   content::RecordAction(UserMetricsAction("Options_ShowPasswordManager"));
 236   ShowSettingsSubPage(browser, kPasswordManagerSubPage);
 237 }
 238
 239 void ShowImportDialog(Browser* browser) {
 240   content::RecordAction(UserMetricsAction("Import_ShowDlg"));
 241   ShowSettingsSubPage(browser, kImportDataSubPage);
 242 }
 243
 244 void ShowAboutChrome(Browser* browser) {
 245   content::RecordAction(UserMetricsAction("AboutChrome"));
 246   NavigateParams params(
 247       GetSingletonTabNavigateParams(browser, GURL(kChromeUIUberURL)));
 248   params.path_behavior = NavigateParams::IGNORE_AND_NAVIGATE;
 249   ShowSingletonTabOverwritingNTP(browser, params);
 250 }
 251
 252 void ShowSearchEngineSettings(Browser* browser) {
 253   content::RecordAction(UserMetricsAction("EditSearchEngines"));
 254   ShowSettingsSubPage(browser, kSearchEnginesSubPage);
 255 }
 256
 257 void ShowBrowserSignin(Browser* browser, signin::Source source) {
 258   Profile* original_profile = browser->profile()->GetOriginalProfile();
 259   SigninManagerBase* manager =
 260       SigninManagerFactory::GetForProfile(original_profile);
 261   DCHECK(manager->IsSigninAllowed());
 262   // If we're signed in, just show settings.
 263   if (!manager->GetAuthenticatedUsername().empty()) {
 264     ShowSettings(browser);
 265   } else {
 266     // If the browser's profile is an incognito profile, make sure to use
 267     // a browser window from the original profile.  The user cannot sign in
 268     // from an incognito window.
 269     scoped_ptr<ScopedTabbedBrowserDisplayer> displayer;
 270     if (browser->profile()->IsOffTheRecord()) {
 271       displayer.reset(new ScopedTabbedBrowserDisplayer(
 272           original_profile, chrome::HOST_DESKTOP_TYPE_NATIVE));
 273       browser = displayer->browser();
 274     }
 275
 276     NavigateToSingletonTab(browser,
 277                            GURL(signin::GetPromoURL(source, false)));
 278     DCHECK_GT(browser->tab_strip_model()->count(), 0);
 279   }
 280 }
 281
 282 void ShowGaiaSignin(Browser* browser,
 283                     const std::string& service,
 284                     const GURL& continue_url) {
 285   GURL url(GaiaUrls::GetInstance()->service_login_url());
 286   url = net::AppendQueryParameter(url, "service", service);
 287   if (continue_url.is_valid())
 288     url = net::AppendQueryParameter(url, "continue", continue_url.spec());
 289   NavigateToSingletonTab(browser, url);
 290 }
 291
 292 }  // namespace chrome