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