Home | History | Annotate | Download | only in ui 
      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