#include "base/metrics/histogram.h"
#include "base/prefs/pref_service.h"
#include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/bookmarks/bookmark_model.h"
+#include "chrome/app/chrome_command_ids.h"
#include "chrome/browser/bookmarks/bookmark_model_factory.h"
-#include "chrome/browser/bookmarks/bookmark_utils.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/browsing_data/browsing_data_helper.h"
#include "chrome/browser/browsing_data/browsing_data_remover.h"
#include "chrome/browser/chrome_notification_types.h"
#include "chrome/browser/chrome_page_zoom.h"
#include "chrome/browser/devtools/devtools_window.h"
-#include "chrome/browser/extensions/extension_service.h"
-#include "chrome/browser/extensions/tab_helper.h"
+#include "chrome/browser/dom_distiller/tab_utils.h"
#include "chrome/browser/favicon/favicon_tab_helper.h"
-#include "chrome/browser/google/google_util.h"
#include "chrome/browser/lifetime/application_lifetime.h"
#include "chrome/browser/platform_util.h"
#include "chrome/browser/prefs/incognito_mode_prefs.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/rlz/rlz.h"
+#include "chrome/browser/search/search.h"
#include "chrome/browser/sessions/session_service_factory.h"
#include "chrome/browser/sessions/tab_restore_service.h"
#include "chrome/browser/sessions/tab_restore_service_delegate.h"
#include "chrome/browser/sessions/tab_restore_service_factory.h"
-#include "chrome/browser/translate/translate_tab_helper.h"
-#include "chrome/browser/ui/bookmarks/bookmark_prompt_controller.h"
+#include "chrome/browser/signin/signin_header_helper.h"
+#include "chrome/browser/translate/chrome_translate_client.h"
+#include "chrome/browser/ui/accelerator_utils.h"
#include "chrome/browser/ui/bookmarks/bookmark_utils.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_command_controller.h"
#include "chrome/browser/ui/find_bar/find_bar_controller.h"
#include "chrome/browser/ui/find_bar/find_tab_helper.h"
#include "chrome/browser/ui/fullscreen/fullscreen_controller.h"
-#include "chrome/browser/ui/omnibox/location_bar.h"
+#include "chrome/browser/ui/location_bar/location_bar.h"
#include "chrome/browser/ui/scoped_tabbed_browser_displayer.h"
+#include "chrome/browser/ui/search/search_tab_helper.h"
#include "chrome/browser/ui/status_bubble.h"
#include "chrome/browser/ui/tab_contents/core_tab_helper.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
-#include "chrome/browser/ui/translate/translate_bubble_model.h"
-#include "chrome/browser/ui/webui/ntp/core_app_launcher_handler.h"
+#include "chrome/browser/ui/zoom/zoom_controller.h"
#include "chrome/browser/upgrade_detector.h"
-#include "chrome/browser/web_applications/web_app.h"
#include "chrome/common/chrome_switches.h"
#include "chrome/common/chrome_version_info.h"
#include "chrome/common/content_restriction.h"
#include "chrome/common/pref_names.h"
-#include "components/web_modal/web_contents_modal_dialog_manager.h"
+#include "components/bookmarks/browser/bookmark_model.h"
+#include "components/bookmarks/browser/bookmark_utils.h"
+#include "components/google/core/browser/google_util.h"
+#include "components/translate/core/browser/language_state.h"
+#include "components/web_modal/popup_manager.h"
#include "content/public/browser/devtools_agent_host.h"
#include "content/public/browser/navigation_controller.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/browser/notification_service.h"
#include "content/public/browser/page_navigator.h"
#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host_view.h"
#include "content/public/browser/user_metrics.h"
#include "content/public/browser/web_contents.h"
-#include "content/public/browser/web_contents_view.h"
+#include "content/public/common/page_state.h"
#include "content/public/common/renderer_preferences.h"
#include "content/public/common/url_constants.h"
#include "content/public/common/url_utils.h"
+#include "content/public/common/user_agent.h"
#include "net/base/escape.h"
-#include "webkit/common/user_agent/user_agent_util.h"
+#include "ui/events/keycodes/keyboard_codes.h"
#if defined(OS_WIN)
#include "chrome/browser/ui/metro_pin_tab_helper_win.h"
-#include "win8/util/win8_util.h"
+#endif
+
+#if defined(ENABLE_EXTENSIONS)
+#include "chrome/browser/extensions/api/commands/command_service.h"
+#include "chrome/browser/extensions/api/extension_action/extension_action_api.h"
+#include "chrome/browser/extensions/tab_helper.h"
+#include "chrome/browser/ui/webui/ntp/core_app_launcher_handler.h"
+#include "chrome/browser/web_applications/web_app.h"
+#include "chrome/common/extensions/manifest_handlers/app_launch_info.h"
+#include "extensions/browser/extension_registry.h"
+#include "extensions/browser/extension_system.h"
+#include "extensions/common/extension.h"
+#include "extensions/common/extension_set.h"
#endif
#if defined(ENABLE_PRINTING)
-#if defined(ENABLE_FULL_PRINTING)
+#if defined(ENABLE_PRINT_PREVIEW)
#include "chrome/browser/printing/print_preview_dialog_controller.h"
#include "chrome/browser/printing/print_view_manager.h"
#else
#include "chrome/browser/printing/print_view_manager_basic.h"
-#endif // defined(ENABLE_FULL_PRINTING)
+#endif // defined(ENABLE_PRINT_PREVIEW)
#endif // defined(ENABLE_PRINTING)
namespace {
const char kOsOverrideForTabletSite[] = "Linux; Android 4.0.3";
}
+using base::UserMetricsAction;
using content::NavigationController;
using content::NavigationEntry;
using content::OpenURLParams;
using content::Referrer;
using content::SSLStatus;
-using content::UserMetricsAction;
using content::WebContents;
-using web_modal::WebContentsModalDialogManager;
namespace chrome {
namespace {
-void BookmarkCurrentPageInternal(Browser* browser, bool from_star) {
+bool CanBookmarkCurrentPageInternal(const Browser* browser,
+ bool check_remove_bookmark_ui) {
+ BookmarkModel* model =
+ BookmarkModelFactory::GetForProfile(browser->profile());
+ return browser_defaults::bookmarks_enabled &&
+ browser->profile()->GetPrefs()->GetBoolean(
+ bookmarks::prefs::kEditBookmarksEnabled) &&
+ model && model->loaded() && browser->is_type_tabbed() &&
+ (!check_remove_bookmark_ui ||
+ !chrome::ShouldRemoveBookmarkThisPageUI(browser->profile()));
+}
+
+#if defined(ENABLE_EXTENSIONS)
+bool GetBookmarkOverrideCommand(
+ Profile* profile,
+ const extensions::Extension** extension,
+ extensions::Command* command,
+ extensions::CommandService::ExtensionCommandType* command_type) {
+ DCHECK(extension);
+ DCHECK(command);
+ DCHECK(command_type);
+
+ ui::Accelerator bookmark_page_accelerator =
+ chrome::GetPrimaryChromeAcceleratorForCommandId(IDC_BOOKMARK_PAGE);
+ if (bookmark_page_accelerator.key_code() == ui::VKEY_UNKNOWN)
+ return false;
+
+ extensions::CommandService* command_service =
+ extensions::CommandService::Get(profile);
+ const extensions::ExtensionSet& extension_set =
+ extensions::ExtensionRegistry::Get(profile)->enabled_extensions();
+ for (extensions::ExtensionSet::const_iterator i = extension_set.begin();
+ i != extension_set.end();
+ ++i) {
+ extensions::Command prospective_command;
+ extensions::CommandService::ExtensionCommandType prospective_command_type;
+ if (command_service->GetBoundExtensionCommand((*i)->id(),
+ bookmark_page_accelerator,
+ &prospective_command,
+ &prospective_command_type)) {
+ *extension = i->get();
+ *command = prospective_command;
+ *command_type = prospective_command_type;
+ return true;
+ }
+ }
+ return false;
+}
+#endif
+
+void BookmarkCurrentPageInternal(Browser* browser) {
content::RecordAction(UserMetricsAction("Star"));
BookmarkModel* model =
return; // Ignore requests until bookmarks are loaded.
GURL url;
- string16 title;
+ base::string16 title;
WebContents* web_contents =
browser->tab_strip_model()->GetActiveWebContents();
GetURLAndTitleToBookmark(web_contents, &url, &title);
- bool was_bookmarked = model->IsBookmarked(url);
- if (!was_bookmarked && web_contents->GetBrowserContext()->IsOffTheRecord()) {
+ bool is_bookmarked_by_any = model->IsBookmarked(url);
+ if (!is_bookmarked_by_any &&
+ web_contents->GetBrowserContext()->IsOffTheRecord()) {
// If we're incognito the favicon may not have been saved. Save it now
// so that bookmarks have an icon for the page.
FaviconTabHelper::FromWebContents(web_contents)->SaveFavicon();
}
- bookmark_utils::AddIfNotBookmarked(model, url, title);
- if (from_star && !was_bookmarked)
- BookmarkPromptController::AddedBookmark(browser, url);
+ bool was_bookmarked_by_user = bookmarks::IsBookmarkedByUser(model, url);
+ bookmarks::AddIfNotBookmarked(model, url, title);
+ bool is_bookmarked_by_user = bookmarks::IsBookmarkedByUser(model, url);
// Make sure the model actually added a bookmark before showing the star. A
// bookmark isn't created if the url is invalid.
- if (browser->window()->IsActive() && model->IsBookmarked(url)) {
+ if (browser->window()->IsActive() && is_bookmarked_by_user) {
// Only show the bubble if the window is active, otherwise we may get into
// weird situations where the bubble is deleted as soon as it is shown.
- browser->window()->ShowBookmarkBubble(url, was_bookmarked);
+ browser->window()->ShowBookmarkBubble(url, was_bookmarked_by_user);
}
}
-WebContents* GetOrCloneTabForDisposition(Browser* browser,
- WindowOpenDisposition disposition) {
+// Based on |disposition|, creates a new tab as necessary, and returns the
+// appropriate tab to navigate. If that tab is the current tab, reverts the
+// location bar contents, since all browser-UI-triggered navigations should
+// revert any omnibox edits in the current tab.
+WebContents* GetTabAndRevertIfNecessary(Browser* browser,
+ WindowOpenDisposition disposition) {
WebContents* current_tab = browser->tab_strip_model()->GetActiveWebContents();
switch (disposition) {
case NEW_FOREGROUND_TAB:
case NEW_BACKGROUND_TAB: {
- current_tab = current_tab->Clone();
+ WebContents* new_tab = current_tab->Clone();
browser->tab_strip_model()->AddWebContents(
- current_tab, -1, content::PAGE_TRANSITION_LINK,
- disposition == NEW_FOREGROUND_TAB ? TabStripModel::ADD_ACTIVE :
- TabStripModel::ADD_NONE);
- break;
+ new_tab, -1, ui::PAGE_TRANSITION_LINK,
+ (disposition == NEW_FOREGROUND_TAB) ?
+ TabStripModel::ADD_ACTIVE : TabStripModel::ADD_NONE);
+ return new_tab;
}
case NEW_WINDOW: {
- current_tab = current_tab->Clone();
- Browser* b = new Browser(Browser::CreateParams(
+ WebContents* new_tab = current_tab->Clone();
+ Browser* new_browser = new Browser(Browser::CreateParams(
browser->profile(), browser->host_desktop_type()));
- b->tab_strip_model()->AddWebContents(
- current_tab, -1, content::PAGE_TRANSITION_LINK,
+ new_browser->tab_strip_model()->AddWebContents(
+ new_tab, -1, ui::PAGE_TRANSITION_LINK,
TabStripModel::ADD_ACTIVE);
- b->window()->Show();
- break;
+ new_browser->window()->Show();
+ return new_tab;
}
default:
- break;
+ browser->window()->GetLocationBar()->Revert();
+ return current_tab;
}
- return current_tab;
}
void ReloadInternal(Browser* browser,
//
// Also notify RenderViewHostDelegate of the user gesture; this is
// normally done in Browser::Navigate, but a reload bypasses Navigate.
- WebContents* web_contents = GetOrCloneTabForDisposition(browser, disposition);
- web_contents->UserGestureDone();
- if (!web_contents->FocusLocationBarByDefault())
- web_contents->GetView()->Focus();
+ WebContents* new_tab = GetTabAndRevertIfNecessary(browser, disposition);
+ new_tab->UserGestureDone();
+ if (!new_tab->FocusLocationBarByDefault())
+ new_tab->Focus();
if (ignore_cache)
- web_contents->GetController().ReloadIgnoringCache(true);
+ new_tab->GetController().ReloadIgnoringCache(true);
else
- web_contents->GetController().Reload(true);
+ new_tab->GetController().Reload(true);
}
-bool IsShowingWebContentsModalDialog(const Browser* browser) {
+bool IsShowingWebContentsModalDialog(Browser* browser) {
WebContents* web_contents =
browser->tab_strip_model()->GetActiveWebContents();
if (!web_contents)
return false;
- WebContentsModalDialogManager* web_contents_modal_dialog_manager =
- WebContentsModalDialogManager::FromWebContents(web_contents);
- return web_contents_modal_dialog_manager->IsDialogActive();
+ // In test code we may not have a popup manager.
+ if (!browser->popup_manager())
+ return false;
+
+ // TODO(gbillock): This is currently called in production by the CanPrint
+ // method, and may be too restrictive if we allow print preview to overlap.
+ // Re-assess how to queue print preview after we know more about popup
+ // management policy.
+ return browser->popup_manager()->IsWebModalDialogActive(web_contents);
}
+#if defined(ENABLE_BASIC_PRINTING)
bool PrintPreviewShowing(const Browser* browser) {
-#if defined(ENABLE_FULL_PRINTING)
+#if defined(ENABLE_PRINT_PREVIEW)
WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
printing::PrintPreviewDialogController* controller =
printing::PrintPreviewDialogController::GetInstance();
return false;
#endif
}
+#endif // ENABLE_BASIC_PRINTING
} // namespace
CoreTabHelper* core_tab_helper =
CoreTabHelper::FromWebContents(current_tab);
content_restrictions = core_tab_helper->content_restrictions();
- NavigationEntry* active_entry =
- current_tab->GetController().GetActiveEntry();
- // See comment in UpdateCommandsForTabState about why we call url().
+ NavigationEntry* last_committed_entry =
+ current_tab->GetController().GetLastCommittedEntry();
if (!content::IsSavableURL(
- active_entry ? active_entry->GetURL() : GURL()) ||
+ last_committed_entry ? last_committed_entry->GetURL() : GURL()) ||
current_tab->ShowingInterstitialPage())
content_restrictions |= CONTENT_RESTRICTION_SAVE;
if (current_tab->ShowingInterstitialPage())
IncognitoModePrefs::DISABLED) {
incognito = false;
}
- } else {
- if (browser_defaults::kAlwaysOpenIncognitoWindow &&
- IncognitoModePrefs::ShouldLaunchIncognito(
- *CommandLine::ForCurrentProcess(), prefs)) {
- incognito = true;
- }
+ } else if (profile->IsGuestSession() ||
+ (browser_defaults::kAlwaysOpenIncognitoWindow &&
+ IncognitoModePrefs::ShouldLaunchIncognito(
+ *CommandLine::ForCurrentProcess(), prefs))) {
+ incognito = true;
}
if (incognito) {
Browser* OpenEmptyWindow(Profile* profile, HostDesktopType desktop_type) {
Browser* browser = new Browser(
Browser::CreateParams(Browser::TYPE_TABBED, profile, desktop_type));
- AddBlankTabAt(browser, -1, true);
+ AddTabAt(browser, GURL(), -1, true);
browser->window()->Show();
return browser;
}
ScopedTabbedBrowserDisplayer displayer(profile->GetOffTheRecordProfile(),
desktop_type);
AddSelectedTabWithURL(displayer.browser(), url,
- content::PAGE_TRANSITION_LINK);
+ ui::PAGE_TRANSITION_LINK);
}
bool CanGoBack(const Browser* browser) {
void GoBack(Browser* browser, WindowOpenDisposition disposition) {
content::RecordAction(UserMetricsAction("Back"));
- WebContents* current_tab = browser->tab_strip_model()->GetActiveWebContents();
if (CanGoBack(browser)) {
- WebContents* new_tab = GetOrCloneTabForDisposition(browser, disposition);
+ WebContents* current_tab =
+ browser->tab_strip_model()->GetActiveWebContents();
+ WebContents* new_tab = GetTabAndRevertIfNecessary(browser, disposition);
// If we are on an interstitial page and clone the tab, it won't be copied
// to the new tab, so we don't need to go back.
- if (current_tab->ShowingInterstitialPage() && new_tab != current_tab)
- return;
- new_tab->GetController().GoBack();
+ if ((new_tab == current_tab) || !current_tab->ShowingInterstitialPage())
+ new_tab->GetController().GoBack();
}
}
void GoForward(Browser* browser, WindowOpenDisposition disposition) {
content::RecordAction(UserMetricsAction("Forward"));
if (CanGoForward(browser)) {
- GetOrCloneTabForDisposition(browser, disposition)->
+ GetTabAndRevertIfNecessary(browser, disposition)->
GetController().GoForward();
}
}
bool NavigateToIndexWithDisposition(Browser* browser,
int index,
- WindowOpenDisposition disp) {
- NavigationController& controller =
- GetOrCloneTabForDisposition(browser, disp)->GetController();
- if (index < 0 || index >= controller.GetEntryCount())
+ WindowOpenDisposition disposition) {
+ NavigationController* controller =
+ &GetTabAndRevertIfNecessary(browser, disposition)->GetController();
+ if (index < 0 || index >= controller->GetEntryCount())
return false;
- controller.GoToIndex(index);
+ controller->GoToIndex(index);
return true;
}
content::RecordAction(UserMetricsAction("Home"));
std::string extra_headers;
-#if defined(ENABLE_RLZ)
+#if defined(ENABLE_RLZ) && !defined(OS_IOS)
// If the home page is a Google home page, add the RLZ header to the request.
PrefService* pref_service = browser->profile()->GetPrefs();
if (pref_service) {
if (google_util::IsGoogleHomePageUrl(
GURL(pref_service->GetString(prefs::kHomePage)))) {
extra_headers = RLZTracker::GetAccessPointHttpHeader(
- RLZTracker::CHROME_HOME_PAGE);
+ RLZTracker::ChromeHomePage());
}
}
+#endif // defined(ENABLE_RLZ) && !defined(OS_IOS)
+
+ GURL url = browser->profile()->GetHomePage();
+
+#if defined(ENABLE_EXTENSIONS)
+ // Streamlined hosted apps should return to their launch page when the home
+ // button is pressed.
+ if (browser->is_app()) {
+ const extensions::Extension* extension =
+ extensions::ExtensionRegistry::Get(browser->profile())
+ ->GetExtensionById(
+ web_app::GetExtensionIdFromApplicationName(browser->app_name()),
+ extensions::ExtensionRegistry::EVERYTHING);
+ if (!extension)
+ return;
+
+ url = extensions::AppLaunchInfo::GetLaunchWebURL(extension);
+ }
#endif
OpenURLParams params(
- browser->profile()->GetHomePage(), Referrer(), disposition,
- content::PageTransitionFromInt(
- content::PAGE_TRANSITION_AUTO_BOOKMARK |
- content::PAGE_TRANSITION_HOME_PAGE),
+ url, Referrer(), disposition,
+ ui::PageTransitionFromInt(
+ ui::PAGE_TRANSITION_AUTO_BOOKMARK |
+ ui::PAGE_TRANSITION_HOME_PAGE),
false);
params.extra_headers = extra_headers;
browser->OpenURL(params);
GURL url(location_bar->GetDestinationURL());
- content::PageTransition page_transition = location_bar->GetPageTransition();
- content::PageTransition page_transition_without_qualifier(
- PageTransitionStripQualifier(page_transition));
+ ui::PageTransition page_transition = location_bar->GetPageTransition();
+ ui::PageTransition page_transition_without_qualifier(
+ ui::PageTransitionStripQualifier(page_transition));
WindowOpenDisposition open_disposition =
location_bar->GetWindowOpenDisposition();
// A PAGE_TRANSITION_TYPED means the user has typed a URL. We do not want to
// Instant should also not handle PAGE_TRANSITION_RELOAD because its knowledge
// of the omnibox text may be stale if the user focuses in the omnibox and
// presses enter without typing anything.
- if (page_transition_without_qualifier != content::PAGE_TRANSITION_TYPED &&
- page_transition_without_qualifier != content::PAGE_TRANSITION_RELOAD &&
+ if (page_transition_without_qualifier != ui::PAGE_TRANSITION_TYPED &&
+ page_transition_without_qualifier != ui::PAGE_TRANSITION_RELOAD &&
browser->instant_controller() &&
browser->instant_controller()->OpenInstant(open_disposition, url))
return;
TabStripModel::ADD_FORCE_INDEX | TabStripModel::ADD_INHERIT_OPENER;
Navigate(¶ms);
- DCHECK(browser->profile()->GetExtensionService());
+#if defined(ENABLE_EXTENSIONS)
+ DCHECK(extensions::ExtensionSystem::Get(
+ browser->profile())->extension_service());
const extensions::Extension* extension =
- browser->profile()->GetExtensionService()->GetInstalledApp(url);
+ extensions::ExtensionRegistry::Get(browser->profile())
+ ->enabled_extensions().GetAppByURL(url);
if (extension) {
CoreAppLauncherHandler::RecordAppLaunchType(
extension_misc::APP_LAUNCH_OMNIBOX_LOCATION,
extension->GetType());
}
+#endif
}
void Stop(Browser* browser) {
browser->tab_strip_model()->GetActiveWebContents()->Stop();
}
-#if !defined(OS_WIN)
void NewWindow(Browser* browser) {
NewEmptyWindow(browser->profile()->GetOriginalProfile(),
browser->host_desktop_type());
NewEmptyWindow(browser->profile()->GetOffTheRecordProfile(),
browser->host_desktop_type());
}
-#endif // OS_WIN
void CloseWindow(Browser* browser) {
content::RecordAction(UserMetricsAction("CloseWindow"));
TabStripModel::NEW_TAB_ENUM_COUNT);
if (browser->is_type_tabbed()) {
- AddBlankTabAt(browser, -1, true);
- browser->tab_strip_model()->GetActiveWebContents()->GetView()->
- RestoreFocus();
+ AddTabAt(browser, GURL(), -1, true);
+ browser->tab_strip_model()->GetActiveWebContents()->RestoreFocus();
} else {
ScopedTabbedBrowserDisplayer displayer(browser->profile(),
browser->host_desktop_type());
Browser* b = displayer.browser();
- AddBlankTabAt(b, -1, true);
+ AddTabAt(b, GURL(), -1, true);
b->window()->Show();
// The call to AddBlankTabAt above did not set the focus to the tab as its
// window was not active, so we have to do it explicitly.
// See http://crbug.com/6380.
- b->tab_strip_model()->GetActiveWebContents()->GetView()->RestoreFocus();
+ b->tab_strip_model()->GetActiveWebContents()->RestoreFocus();
}
}
browser->tab_strip_model()->CloseSelectedTabs();
}
-void RestoreTab(Browser* browser) {
- content::RecordAction(UserMetricsAction("RestoreTab"));
- TabRestoreService* service =
- TabRestoreServiceFactory::GetForProfile(browser->profile());
- if (service)
- service->RestoreMostRecentEntry(browser->tab_restore_service_delegate(),
- browser->host_desktop_type());
+bool CanZoomIn(content::WebContents* contents) {
+ ZoomController* zoom_controller = ZoomController::FromWebContents(contents);
+ return zoom_controller->GetZoomPercent() !=
+ contents->GetMaximumZoomPercent() + 1;
+}
+
+bool CanZoomOut(content::WebContents* contents) {
+ ZoomController* zoom_controller = ZoomController::FromWebContents(contents);
+ return zoom_controller->GetZoomPercent() !=
+ contents->GetMinimumZoomPercent();
+}
+
+bool ActualSize(content::WebContents* contents) {
+ ZoomController* zoom_controller = ZoomController::FromWebContents(contents);
+ return zoom_controller->GetZoomPercent() != 100.0f;
}
TabStripModelDelegate::RestoreTabType GetRestoreTabType(
browser->tab_strip_model()->SelectPreviousTab();
}
-void OpenTabpose(Browser* browser) {
-#if defined(OS_MACOSX)
- if (!CommandLine::ForCurrentProcess()->HasSwitch(
- switches::kEnableExposeForTabs)) {
- return;
- }
-
- content::RecordAction(UserMetricsAction("OpenTabpose"));
- browser->window()->OpenTabpose();
-#else
- NOTREACHED();
-#endif
-}
-
void MoveTabNext(Browser* browser) {
content::RecordAction(UserMetricsAction("MoveTabNext"));
browser->tab_strip_model()->MoveTabNext();
index + 1, contents_dupe, add_types);
} else {
Browser* new_browser = NULL;
- if (browser->is_app() &&
- !browser->is_type_popup()) {
+ if (browser->is_app() && !browser->is_type_popup()) {
new_browser = new Browser(
- Browser::CreateParams::CreateForApp(browser->type(),
- browser->app_name(),
+ Browser::CreateParams::CreateForApp(browser->app_name(),
+ browser->is_trusted_source(),
gfx::Rect(),
browser->profile(),
browser->host_desktop_type()));
// The page transition below is only for the purpose of inserting the tab.
new_browser->tab_strip_model()->AddWebContents(
contents_dupe, -1,
- content::PAGE_TRANSITION_LINK,
+ ui::PAGE_TRANSITION_LINK,
TabStripModel::ADD_ACTIVE);
}
}
void BookmarkCurrentPage(Browser* browser) {
- BookmarkCurrentPageInternal(browser, false);
-}
+ DCHECK(!chrome::ShouldRemoveBookmarkThisPageUI(browser->profile()));
+
+#if defined(ENABLE_EXTENSIONS)
+ const extensions::Extension* extension = NULL;
+ extensions::Command command;
+ extensions::CommandService::ExtensionCommandType command_type;
+ if (GetBookmarkOverrideCommand(browser->profile(),
+ &extension,
+ &command,
+ &command_type)) {
+ switch (command_type) {
+ case extensions::CommandService::NAMED:
+ browser->window()->ExecuteExtensionCommand(extension, command);
+ break;
+ case extensions::CommandService::BROWSER_ACTION:
+ case extensions::CommandService::PAGE_ACTION:
+ // BookmarkCurrentPage is called through a user gesture, so it is safe
+ // to grant the active tab permission.
+ extensions::ExtensionActionAPI::Get(browser->profile())->
+ ShowExtensionActionPopup(extension, browser, true);
+ break;
+ }
+ return;
+ }
+#endif
-void BookmarkCurrentPageFromStar(Browser* browser) {
- BookmarkCurrentPageInternal(browser, true);
+ BookmarkCurrentPageInternal(browser);
}
bool CanBookmarkCurrentPage(const Browser* browser) {
- BookmarkModel* model =
- BookmarkModelFactory::GetForProfile(browser->profile());
- return browser_defaults::bookmarks_enabled &&
- browser->profile()->GetPrefs()->GetBoolean(
- prefs::kEditBookmarksEnabled) &&
- model && model->loaded() && browser->is_type_tabbed();
+ return CanBookmarkCurrentPageInternal(browser, true);
}
void BookmarkAllTabs(Browser* browser) {
bool CanBookmarkAllTabs(const Browser* browser) {
return browser->tab_strip_model()->count() > 1 &&
- CanBookmarkCurrentPage(browser);
+ !chrome::ShouldRemoveBookmarkOpenPagesUI(browser->profile()) &&
+ CanBookmarkCurrentPageInternal(browser, false);
}
void Translate(Browser* browser) {
WebContents* web_contents =
browser->tab_strip_model()->GetActiveWebContents();
- TranslateTabHelper* translate_tab_helper =
- TranslateTabHelper::FromWebContents(web_contents);
-
- TranslateBubbleModel::ViewState view_state =
- TranslateBubbleModel::VIEW_STATE_BEFORE_TRANSLATE;
- if (translate_tab_helper) {
- if (translate_tab_helper->language_state().translation_pending())
- view_state = TranslateBubbleModel::VIEW_STATE_TRANSLATING;
- else if (translate_tab_helper->language_state().IsPageTranslated())
- view_state = TranslateBubbleModel::VIEW_STATE_AFTER_TRANSLATE;
+ ChromeTranslateClient* chrome_translate_client =
+ ChromeTranslateClient::FromWebContents(web_contents);
+
+ translate::TranslateStep step = translate::TRANSLATE_STEP_BEFORE_TRANSLATE;
+ if (chrome_translate_client) {
+ if (chrome_translate_client->GetLanguageState().translation_pending())
+ step = translate::TRANSLATE_STEP_TRANSLATING;
+ else if (chrome_translate_client->GetLanguageState().IsPageTranslated())
+ step = translate::TRANSLATE_STEP_AFTER_TRANSLATE;
}
- browser->window()->ShowTranslateBubble(web_contents, view_state);
+ browser->window()->ShowTranslateBubble(
+ web_contents, step, translate::TranslateErrors::NONE, true);
+}
+
+void ManagePasswordsForPage(Browser* browser) {
+ if (!browser->window()->IsActive())
+ return;
+
+ WebContents* web_contents =
+ browser->tab_strip_model()->GetActiveWebContents();
+ chrome::ShowManagePasswordsBubble(web_contents);
}
-void TogglePagePinnedToStartScreen(Browser* browser) {
#if defined(OS_WIN)
+void TogglePagePinnedToStartScreen(Browser* browser) {
MetroPinTabHelper::FromWebContents(
browser->tab_strip_model()->GetActiveWebContents())->
TogglePinnedToStartScreen();
-#endif
}
+#endif
void SavePage(Browser* browser) {
content::RecordAction(UserMetricsAction("SavePage"));
web_contents, url, ssl);
}
-
void Print(Browser* browser) {
#if defined(ENABLE_PRINTING)
WebContents* contents = browser->tab_strip_model()->GetActiveWebContents();
-#if defined(ENABLE_FULL_PRINTING)
+
+#if defined(ENABLE_PRINT_PREVIEW)
printing::PrintViewManager* print_view_manager =
printing::PrintViewManager::FromWebContents(contents);
- if (browser->profile()->GetPrefs()->GetBoolean(prefs::kPrintPreviewDisabled))
- print_view_manager->PrintNow();
- else
+ if (!browser->profile()->GetPrefs()->GetBoolean(
+ prefs::kPrintPreviewDisabled)) {
print_view_manager->PrintPreviewNow(false);
-#else
+ return;
+ }
+#else // ENABLE_PRINT_PREVIEW
printing::PrintViewManagerBasic* print_view_manager =
printing::PrintViewManagerBasic::FromWebContents(contents);
+#endif // ENABLE_PRINT_PREVIEW
+
+#if defined(ENABLE_BASIC_PRINTING)
print_view_manager->PrintNow();
-#endif // defined(ENABLE_FULL_PRINTING)
+#endif // ENABLE_BASIC_PRINTING
+
#endif // defined(ENABLE_PRINTING)
}
-bool CanPrint(const Browser* browser) {
+bool CanPrint(Browser* browser) {
// Do not print when printing is disabled via pref or policy.
// Do not print when a constrained window is showing. It's confusing.
+ // TODO(gbillock): Need to re-assess the call to
+ // IsShowingWebContentsModalDialog after a popup management policy is
+ // refined -- we will probably want to just queue the print request, not
+ // block it.
return browser->profile()->GetPrefs()->GetBoolean(prefs::kPrintingEnabled) &&
!(IsShowingWebContentsModalDialog(browser) ||
GetContentRestrictions(browser) & CONTENT_RESTRICTION_PRINT);
}
-void AdvancedPrint(Browser* browser) {
-#if defined(ENABLE_FULL_PRINTING)
+#if defined(ENABLE_BASIC_PRINTING)
+void BasicPrint(Browser* browser) {
+#if defined(ENABLE_PRINT_PREVIEW)
printing::PrintViewManager* print_view_manager =
printing::PrintViewManager::FromWebContents(
browser->tab_strip_model()->GetActiveWebContents());
- print_view_manager->AdvancedPrintNow();
+ print_view_manager->BasicPrint();
#endif
}
-bool CanAdvancedPrint(const Browser* browser) {
+bool CanBasicPrint(Browser* browser) {
// If printing is not disabled via pref or policy, it is always possible to
// advanced print when the print preview is visible. The exception to this
// is under Win8 ash, since showing the advanced print dialog will open it
- // modally on the Desktop and hang the browser. We can remove this check
- // once we integrate with the system print charm.
+ // modally on the Desktop and hang the browser.
#if defined(OS_WIN)
if (chrome::GetActiveDesktop() == chrome::HOST_DESKTOP_TYPE_ASH)
return false;
return browser->profile()->GetPrefs()->GetBoolean(prefs::kPrintingEnabled) &&
(PrintPreviewShowing(browser) || CanPrint(browser));
}
-
-void PrintToDestination(Browser* browser) {
-#if defined(ENABLE_FULL_PRINTING)
- printing::PrintViewManager* print_view_manager =
- printing::PrintViewManager::FromWebContents(
- browser->tab_strip_model()->GetActiveWebContents());
- print_view_manager->PrintToDestination();
-#endif
-}
+#endif // ENABLE_BASIC_PRINTING
void EmailPageLocation(Browser* browser) {
content::RecordAction(UserMetricsAction("EmailPageLocation"));
DCHECK(wc);
std::string title = net::EscapeQueryParamValue(
- UTF16ToUTF8(wc->GetTitle()), false);
+ base::UTF16ToUTF8(wc->GetTitle()), false);
std::string page_url = net::EscapeQueryParamValue(wc->GetURL().spec(), false);
std::string mailto = std::string("mailto:?subject=Fwd:%20") +
title + "&body=%0A%0A" + page_url;
- platform_util::OpenExternal(GURL(mailto));
+ platform_util::OpenExternal(browser->profile(), GURL(mailto));
}
bool CanEmailPageLocation(const Browser* browser) {
void FindInPage(Browser* browser, bool find_next, bool forward_direction) {
ShowFindBar(browser);
if (find_next) {
- string16 find_text;
+ base::string16 find_text;
FindTabHelper* find_helper = FindTabHelper::FromWebContents(
browser->tab_strip_model()->GetActiveWebContents());
#if defined(OS_MACOSX)
}
void Zoom(Browser* browser, content::PageZoom zoom) {
- if (browser->is_devtools())
- return;
-
chrome_page_zoom::Zoom(browser->tab_strip_model()->GetActiveWebContents(),
zoom);
}
}
bool CanOpenTaskManager() {
-#if defined(OS_WIN)
- // In metro we can't display the task manager, as it is a native window.
- return !win8::IsSingleWindowMetroMode();
-#else
+#if defined(ENABLE_TASK_MANAGER)
return true;
+#else
+ return false;
#endif
}
void OpenTaskManager(Browser* browser) {
+#if defined(ENABLE_TASK_MANAGER)
content::RecordAction(UserMetricsAction("TaskManager"));
chrome::ShowTaskManager(browser);
+#else
+ NOTREACHED();
+#endif
}
void OpenFeedbackDialog(Browser* browser) {
}
void ShowAvatarMenu(Browser* browser) {
- browser->window()->ShowAvatarBubbleFromAvatarButton();
+ browser->window()->ShowAvatarBubbleFromAvatarButton(
+ BrowserWindow::AVATAR_BUBBLE_MODE_DEFAULT,
+ signin::ManageAccountsParams());
}
void OpenUpdateChromeDialog(Browser* browser) {
chrome::NOTIFICATION_OUTDATED_INSTALL,
content::NotificationService::AllSources(),
content::NotificationService::NoDetails());
+ } else if (UpgradeDetector::GetInstance()->is_outdated_install_no_au()) {
+ content::NotificationService::current()->Notify(
+ chrome::NOTIFICATION_OUTDATED_INSTALL_NO_AU,
+ content::NotificationService::AllSources(),
+ content::NotificationService::NoDetails());
} else {
content::RecordAction(UserMetricsAction("UpdateChrome"));
browser->window()->ShowUpdateChromeDialog();
}
void ToggleSpeechInput(Browser* browser) {
- browser->tab_strip_model()->GetActiveWebContents()->
- GetRenderViewHost()->ToggleSpeechInput();
- if (browser->instant_controller())
- browser->instant_controller()->ToggleVoiceSearch();
+ SearchTabHelper* search_tab_helper =
+ SearchTabHelper::FromWebContents(
+ browser->tab_strip_model()->GetActiveWebContents());
+ // |search_tab_helper| can be null in unit tests.
+ if (search_tab_helper)
+ search_tab_helper->ToggleVoiceSearch();
+}
+
+void DistillCurrentPage(Browser* browser) {
+ DistillCurrentPageAndView(browser->tab_strip_model()->GetActiveWebContents());
}
bool CanRequestTabletSite(WebContents* current_tab) {
- if (!current_tab)
- return false;
- return current_tab->GetController().GetActiveEntry() != NULL;
+ return current_tab &&
+ current_tab->GetController().GetLastCommittedEntry() != NULL;
}
bool IsRequestingTabletSite(Browser* browser) {
if (!current_tab)
return false;
content::NavigationEntry* entry =
- current_tab->GetController().GetActiveEntry();
+ current_tab->GetController().GetLastCommittedEntry();
if (!entry)
return false;
return entry->GetIsOverridingUserAgent();
if (!current_tab)
return;
NavigationController& controller = current_tab->GetController();
- NavigationEntry* entry = controller.GetActiveEntry();
+ NavigationEntry* entry = controller.GetLastCommittedEntry();
if (!entry)
return;
if (entry->GetIsOverridingUserAgent()) {
} else {
entry->SetIsOverridingUserAgent(true);
chrome::VersionInfo version_info;
- std::string product;
- if (version_info.is_valid())
- product = version_info.ProductNameAndVersionForUserAgent();
- current_tab->SetUserAgentOverride(
- webkit_glue::BuildUserAgentFromOSAndProduct(
- kOsOverrideForTabletSite, product));
+ std::string product = version_info.ProductNameAndVersionForUserAgent();
+ current_tab->SetUserAgentOverride(content::BuildUserAgentFromOSAndProduct(
+ kOsOverrideForTabletSite, product));
}
controller.ReloadOriginalRequestURL(true);
}
void ToggleFullscreenMode(Browser* browser) {
- browser->fullscreen_controller()->ToggleFullscreenMode();
+ DCHECK(browser);
+ browser->fullscreen_controller()->ToggleBrowserFullscreenMode();
}
void ClearCache(Browser* browser) {
content::RecordAction(UserMetricsAction("ViewSource"));
DCHECK(contents);
- // Note that Clone does not copy the pending or transient entries, so the
- // active entry in view_source_contents will be the last committed entry.
WebContents* view_source_contents = contents->Clone();
- DCHECK(view_source_contents->GetController().CanPruneAllButVisible());
- view_source_contents->GetController().PruneAllButVisible();
- NavigationEntry* active_entry =
- view_source_contents->GetController().GetActiveEntry();
- if (!active_entry)
+ DCHECK(view_source_contents->GetController().CanPruneAllButLastCommitted());
+ view_source_contents->GetController().PruneAllButLastCommitted();
+ NavigationEntry* last_committed_entry =
+ view_source_contents->GetController().GetLastCommittedEntry();
+ if (!last_committed_entry)
return;
GURL view_source_url =
GURL(content::kViewSourceScheme + std::string(":") + url.spec());
- active_entry->SetVirtualURL(view_source_url);
+ last_committed_entry->SetVirtualURL(view_source_url);
// Do not restore scroller position.
- active_entry->SetPageState(page_state.RemoveScrollOffset());
+ last_committed_entry->SetPageState(page_state.RemoveScrollOffset());
// Do not restore title, derive it from the url.
- active_entry->SetTitle(string16());
+ last_committed_entry->SetTitle(base::string16());
// Now show view-source entry.
if (browser->CanSupportWindowFeature(Browser::FEATURE_TABSTRIP)) {
// The page transition below is only for the purpose of inserting the tab.
b->tab_strip_model()->AddWebContents(view_source_contents, -1,
- content::PAGE_TRANSITION_LINK,
+ ui::PAGE_TRANSITION_LINK,
TabStripModel::ADD_ACTIVE);
}
}
bool CanViewSource(const Browser* browser) {
- return browser->tab_strip_model()->GetActiveWebContents()->
- GetController().CanViewSource();
+ return !browser->is_devtools() &&
+ browser->tab_strip_model()->GetActiveWebContents()->GetController().
+ CanViewSource();
}
+#if defined(ENABLE_EXTENSIONS)
void CreateApplicationShortcuts(Browser* browser) {
content::RecordAction(UserMetricsAction("CreateShortcut"));
extensions::TabHelper::FromWebContents(
CreateApplicationShortcuts();
}
+void CreateBookmarkAppFromCurrentWebContents(Browser* browser) {
+ content::RecordAction(UserMetricsAction("CreateHostedApp"));
+ extensions::TabHelper::FromWebContents(
+ browser->tab_strip_model()->GetActiveWebContents())->
+ CreateHostedAppFromWebContents();
+}
+
bool CanCreateApplicationShortcuts(const Browser* browser) {
return extensions::TabHelper::FromWebContents(
browser->tab_strip_model()->GetActiveWebContents())->
CanCreateApplicationShortcuts();
}
+bool CanCreateBookmarkApp(const Browser* browser) {
+ return extensions::TabHelper::FromWebContents(
+ browser->tab_strip_model()->GetActiveWebContents())
+ ->CanCreateBookmarkApp();
+}
+
void ConvertTabToAppWindow(Browser* browser,
content::WebContents* contents) {
- const GURL& url = contents->GetController().GetActiveEntry()->GetURL();
+ const GURL& url = contents->GetController().GetLastCommittedEntry()->GetURL();
std::string app_name = web_app::GenerateApplicationNameFromURL(url);
int index = browser->tab_strip_model()->GetIndexOfWebContents(contents);
browser->tab_strip_model()->DetachWebContentsAt(index);
Browser* app_browser = new Browser(
- Browser::CreateParams::CreateForApp(
- Browser::TYPE_POPUP, app_name, gfx::Rect(), browser->profile(),
- browser->host_desktop_type()));
+ Browser::CreateParams::CreateForApp(app_name,
+ true /* trusted_source */,
+ gfx::Rect(),
+ browser->profile(),
+ browser->host_desktop_type()));
app_browser->tab_strip_model()->AppendWebContents(contents, true);
contents->GetMutableRendererPrefs()->can_accept_load_drops = false;
contents->GetRenderViewHost()->SyncRendererPrefs();
app_browser->window()->Show();
}
+#endif // defined(ENABLE_EXTENSIONS)
} // namespace chrome
projects / platform / framework / web / crosswalk.git / blobdiff