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