Discharge7443/brave-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
4e16ef96e8ee662ac393d6d429b475348cac4b39
brave-core/browser/ui/brave_browser_command_controller.cc
T
cdesouza-chromium 4e16ef96e8 [IWYU] Fixing logging inclusions //browser/ui (#29529) 
This change is one of many fixing inclusion for the following files:

    - `base/notimplemented.h`
    - `base/notreached.h`
    - `base/check.h`
    - `base/dcheck_is_on.h`
    - `base/check_deref.h`
    - `base/check_op.h`
    - `base/logging/log_severity.h`
    - `base/logging.h`

This change is a mechanical change done with the following script:
https://github.com/brave/brave-browser/issues/46707#issuecomment-2960116515

Resolves https://github.com/brave/brave-browser/issues/46707
2025-06-12 15:57:38 +01:00

779 lines
27 KiB
C++
Raw Blame History

/* Copyright (c) 2019 The Brave Authors. All rights reserved.
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
#include "brave/browser/ui/brave_browser_command_controller.h"
#include <optional>
#include "base/check.h"
#include "base/check_is_test.h"
#include "base/containers/fixed_flat_set.h"
#include "base/feature_list.h"
#include "base/logging.h"
#include "base/notreached.h"
#include "base/types/to_address.h"
#include "brave/app/brave_command_ids.h"
#include "brave/browser/ai_chat/ai_chat_utils.h"
#include "brave/browser/profiles/profile_util.h"
#include "brave/browser/ui/brave_pages.h"
#include "brave/browser/ui/browser_commands.h"
#include "brave/browser/ui/sidebar/sidebar_utils.h"
#include "brave/browser/ui/tabs/features.h"
#include "brave/components/ai_chat/core/browser/utils.h"
#include "brave/components/ai_chat/core/common/features.h"
#include "brave/components/ai_chat/core/common/pref_names.h"
#include "brave/components/brave_rewards/core/rewards_util.h"
#include "brave/components/brave_vpn/common/buildflags/buildflags.h"
#include "brave/components/brave_wallet/common/common_utils.h"
#include "brave/components/brave_wayback_machine/buildflags/buildflags.h"
#include "brave/components/commander/common/buildflags/buildflags.h"
#include "brave/components/commands/common/features.h"
#include "brave/components/playlist/common/buildflags/buildflags.h"
#include "brave/components/speedreader/common/buildflags/buildflags.h"
#include "chrome/app/chrome_command_ids.h"
#include "chrome/browser/browser_process.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/send_tab_to_self/send_tab_to_self_util.h"
#include "chrome/browser/ui/browser.h"
#include "chrome/browser/ui/browser_command_controller.h"
#include "chrome/browser/ui/browser_commands.h"
#include "chrome/browser/ui/browser_window/public/browser_window_features.h"
#include "chrome/browser/ui/tabs/tab_change_type.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/browser/ui/tabs/tab_strip_model_observer.h"
#include "chrome/browser/ui/ui_features.h"
#include "chrome/common/pref_names.h"
#include "components/prefs/pref_service.h"
#include "components/sync/base/command_line_switches.h"
#include "content/public/browser/web_contents.h"
#if BUILDFLAG(ENABLE_BRAVE_VPN)
#include "brave/browser/brave_vpn/brave_vpn_service_factory.h"
#include "brave/browser/brave_vpn/vpn_utils.h"
#include "brave/components/brave_vpn/browser/brave_vpn_service.h"
#include "brave/components/brave_vpn/common/pref_names.h"
#endif
#if BUILDFLAG(ENABLE_SPEEDREADER)
#include "brave/components/speedreader/common/features.h"
#endif
#if BUILDFLAG(ENABLE_PLAYLIST_WEBUI)
#include "brave/browser/playlist/playlist_service_factory.h"
#include "brave/components/playlist/common/features.h"
#endif
#if BUILDFLAG(ENABLE_COMMANDER)
#include "brave/browser/ui/commander/commander_service.h"
#endif
#if BUILDFLAG(ENABLE_TOR)
#include "brave/browser/tor/tor_profile_service_factory.h"
#endif
namespace {
bool IsBraveCommands(int id) {
return id >= IDC_BRAVE_COMMANDS_START && id <= IDC_BRAVE_COMMANDS_LAST;
}
bool IsBraveOverrideCommands(int id) {
static constexpr auto kOverrideCommands = base::MakeFixedFlatSet<int>({
IDC_NEW_WINDOW,
IDC_NEW_INCOGNITO_WINDOW,
});
return kOverrideCommands.contains(id);
}
} // namespace
namespace chrome {
BraveBrowserCommandController::BraveBrowserCommandController(Browser* browser)
: BrowserCommandController(browser),
browser_(*browser),
brave_command_updater_(nullptr) {
InitBraveCommandState();
#if BUILDFLAG(ENABLE_BRAVE_VPN)
if (auto* vpn_service = brave_vpn::BraveVpnServiceFactory::GetForProfile(
browser_->profile())) {
brave_vpn::BraveVPNServiceObserver::Observe(vpn_service);
}
#endif
}
BraveBrowserCommandController::~BraveBrowserCommandController() = default;
void BraveBrowserCommandController::TabChangedAt(content::WebContents* contents,
int index,
TabChangeType type) {
UpdateCommandEnabled(IDC_CLOSE_DUPLICATE_TABS,
brave::HasDuplicateTabs(&*browser_));
UpdateCommandsForTabs();
UpdateCommandsForSend();
}
void BraveBrowserCommandController::TabPinnedStateChanged(
TabStripModel* tab_strip_model,
content::WebContents* contents,
int index) {
UpdateCommandsForPin();
}
void BraveBrowserCommandController::OnTabStripModelChanged(
TabStripModel* tab_strip_model,
const TabStripModelChange& change,
const TabStripSelectionChange& selection) {
BrowserCommandController::OnTabStripModelChanged(tab_strip_model, change,
selection);
UpdateCommandEnabled(IDC_WINDOW_CLOSE_TABS_TO_LEFT,
brave::CanCloseTabsToLeft(&*browser_));
UpdateCommandEnabled(IDC_CLOSE_DUPLICATE_TABS,
brave::HasDuplicateTabs(&*browser_));
UpdateCommandsForTabs();
UpdateCommandsForSend();
UpdateCommandsForPin();
if (tabs::features::IsBraveSplitViewEnabled() && browser_->is_type_normal() &&
selection.active_tab_changed()) {
UpdateCommandForSplitView();
}
if (base::FeatureList::IsEnabled(features::kSideBySide) &&
browser_->is_type_normal() && selection.active_tab_changed()) {
UpdateCommandForSplitViewWithSideBySide();
}
}
void BraveBrowserCommandController::OnSplitTabChanged(
const SplitTabChange& change) {
UpdateCommandForSplitViewWithSideBySide();
}
void BraveBrowserCommandController::OnTabGroupChanged(
const TabGroupChange& change) {
UpdateCommandsForTabs();
}
void BraveBrowserCommandController::OnTileTabs(const TabTile& tile) {
UpdateCommandForSplitView();
}
void BraveBrowserCommandController::OnWillBreakTile(const TabTile& tile) {
UpdateCommandForSplitView();
}
void BraveBrowserCommandController::OnWillDeleteBrowserData() {
split_view_browser_data_observation_.Reset();
}
bool BraveBrowserCommandController::SupportsCommand(int id) const {
return IsBraveCommands(id) ? brave_command_updater_.SupportsCommand(id)
: BrowserCommandController::SupportsCommand(id);
}
bool BraveBrowserCommandController::IsCommandEnabled(int id) const {
return IsBraveCommands(id) ? brave_command_updater_.IsCommandEnabled(id)
: BrowserCommandController::IsCommandEnabled(id);
}
bool BraveBrowserCommandController::ExecuteCommandWithDisposition(
int id,
WindowOpenDisposition disposition,
base::TimeTicks time_stamp) {
return IsBraveCommands(id) || IsBraveOverrideCommands(id)
? ExecuteBraveCommandWithDisposition(id, disposition, time_stamp)
: BrowserCommandController::ExecuteCommandWithDisposition(
id, disposition, time_stamp);
}
void BraveBrowserCommandController::AddCommandObserver(
int id,
CommandObserver* observer) {
IsBraveCommands(id)
? brave_command_updater_.AddCommandObserver(id, observer)
: BrowserCommandController::AddCommandObserver(id, observer);
}
void BraveBrowserCommandController::RemoveCommandObserver(
int id,
CommandObserver* observer) {
IsBraveCommands(id)
? brave_command_updater_.RemoveCommandObserver(id, observer)
: BrowserCommandController::RemoveCommandObserver(id, observer);
}
void BraveBrowserCommandController::RemoveCommandObserver(
CommandObserver* observer) {
brave_command_updater_.RemoveCommandObserver(observer);
BrowserCommandController::RemoveCommandObserver(observer);
}
bool BraveBrowserCommandController::UpdateCommandEnabled(int id, bool state) {
return IsBraveCommands(id)
? brave_command_updater_.UpdateCommandEnabled(id, state)
: BrowserCommandController::UpdateCommandEnabled(id, state);
}
void BraveBrowserCommandController::InitBraveCommandState() {
// Sync, Rewards, and Wallet pages don't work in tor(guest) sessions.
// They also don't work in private windows but they are redirected
// to a normal window in this case.
const bool is_guest_session = browser_->profile()->IsGuestSession();
if (!is_guest_session) {
// If Rewards is not supported due to OFAC sanctions we still want to show
// the menu item.
if (brave_rewards::IsSupported(browser_->profile()->GetPrefs())) {
UpdateCommandForBraveRewards();
}
if (brave_wallet::IsAllowed(browser_->profile()->GetPrefs())) {
UpdateCommandForBraveWallet();
}
if (syncer::IsSyncAllowedByFlag()) {
UpdateCommandForBraveSync();
}
}
UpdateCommandForWebcompatReporter();
#if BUILDFLAG(ENABLE_TOR)
UpdateCommandForTor();
#endif
UpdateCommandForSidebar();
UpdateCommandForBraveVPN();
UpdateCommandForPlaylist();
UpdateCommandForWaybackMachine();
pref_change_registrar_.Init(browser_->profile()->GetPrefs());
UpdateCommandForAIChat();
if (ai_chat::IsAllowedForContext(browser_->profile(), false)) {
pref_change_registrar_.Add(
ai_chat::prefs::kEnabledByPolicy,
base::BindRepeating(
&BraveBrowserCommandController::UpdateCommandForAIChat,
base::Unretained(this)));
}
#if BUILDFLAG(ENABLE_BRAVE_VPN)
if (brave_vpn::IsAllowedForContext(browser_->profile())) {
pref_change_registrar_.Add(
brave_vpn::prefs::kManagedBraveVPNDisabled,
base::BindRepeating(
&BraveBrowserCommandController::UpdateCommandForBraveVPN,
base::Unretained(this)));
}
#endif
bool add_new_profile_enabled = !is_guest_session;
bool open_guest_profile_enabled = !is_guest_session;
if (!is_guest_session) {
if (PrefService* local_state = g_browser_process->local_state()) {
add_new_profile_enabled =
local_state->GetBoolean(prefs::kBrowserAddPersonEnabled);
open_guest_profile_enabled =
local_state->GetBoolean(prefs::kBrowserGuestModeEnabled);
}
}
UpdateCommandEnabled(IDC_ADD_NEW_PROFILE, add_new_profile_enabled);
UpdateCommandEnabled(IDC_OPEN_GUEST_PROFILE, open_guest_profile_enabled);
UpdateCommandEnabled(IDC_COPY_CLEAN_LINK, true);
UpdateCommandEnabled(IDC_TOGGLE_TAB_MUTE, true);
#if BUILDFLAG(ENABLE_SPEEDREADER)
if (base::FeatureList::IsEnabled(speedreader::kSpeedreaderFeature)) {
UpdateCommandEnabled(IDC_SPEEDREADER_ICON_ONCLICK, true);
}
#endif
#if BUILDFLAG(ENABLE_COMMANDER)
UpdateCommandEnabled(IDC_COMMANDER, commander::IsEnabled());
#endif
UpdateCommandEnabled(IDC_SHOW_APPS_PAGE,
!browser_->profile()->IsPrimaryOTRProfile());
UpdateCommandEnabled(IDC_BRAVE_BOOKMARK_BAR_SUBMENU, true);
UpdateCommandEnabled(IDC_TOGGLE_VERTICAL_TABS, true);
UpdateCommandEnabled(IDC_TOGGLE_VERTICAL_TABS_WINDOW_TITLE, true);
UpdateCommandEnabled(IDC_TOGGLE_VERTICAL_TABS_EXPANDED, true);
UpdateCommandEnabled(IDC_CONFIGURE_BRAVE_NEWS,
!browser_->profile()->IsOffTheRecord());
UpdateCommandEnabled(
IDC_CONFIGURE_SHORTCUTS,
base::FeatureList::IsEnabled(commands::features::kBraveCommands));
UpdateCommandEnabled(IDC_SHOW_BRAVE_TALK, true);
UpdateCommandEnabled(IDC_TOGGLE_SHIELDS, true);
UpdateCommandEnabled(IDC_TOGGLE_JAVASCRIPT, true);
UpdateCommandEnabled(IDC_CLOSE_DUPLICATE_TABS,
brave::HasDuplicateTabs(&*browser_));
UpdateCommandEnabled(IDC_WINDOW_ADD_ALL_TABS_TO_NEW_GROUP, true);
UpdateCommandEnabled(IDC_SCROLL_TAB_TO_TOP, true);
UpdateCommandEnabled(IDC_SCROLL_TAB_TO_BOTTOM, true);
UpdateCommandEnabled(IDC_BRAVE_SEND_TAB_TO_SELF, true);
UpdateCommandsForTabs();
UpdateCommandsForSend();
UpdateCommandsForPin();
UpdateCommandEnabled(IDC_TOGGLE_ALL_BOOKMARKS_BUTTON_VISIBILITY, true);
UpdateCommandEnabled(IDC_EXPORT_ALL_BOOKMARKS, true);
if (browser_->is_type_normal()) {
// Delete these when upstream enables by default.
UpdateCommandEnabled(IDC_READING_LIST_MENU, true);
UpdateCommandEnabled(IDC_READING_LIST_MENU_ADD_TAB, true);
UpdateCommandEnabled(IDC_READING_LIST_MENU_SHOW_UI, true);
}
}
void BraveBrowserCommandController::UpdateCommandForBraveRewards() {
UpdateCommandEnabled(IDC_SHOW_BRAVE_REWARDS, true);
}
void BraveBrowserCommandController::UpdateCommandForWebcompatReporter() {
UpdateCommandEnabled(IDC_SHOW_BRAVE_WEBCOMPAT_REPORTER, true);
}
#if BUILDFLAG(ENABLE_TOR)
void BraveBrowserCommandController::UpdateCommandForTor() {
// Enable new tor connection only for tor profile.
UpdateCommandEnabled(IDC_NEW_TOR_CONNECTION_FOR_SITE,
browser_->profile()->IsTor());
UpdateCommandEnabled(
IDC_NEW_OFFTHERECORD_WINDOW_TOR,
!TorProfileServiceFactory::IsTorDisabled(browser_->profile()));
}
#endif
void BraveBrowserCommandController::UpdateCommandForSidebar() {
if (sidebar::CanUseSidebar(&*browser_)) {
UpdateCommandEnabled(IDC_SIDEBAR_SHOW_OPTION_MENU, true);
UpdateCommandEnabled(IDC_SIDEBAR_TOGGLE_POSITION, true);
UpdateCommandEnabled(IDC_TOGGLE_SIDEBAR, true);
}
}
void BraveBrowserCommandController::UpdateCommandForAIChat() {
// AI Chat command implementation needs sidebar
bool allowed_for_context = ai_chat::IsAllowedForContext(browser_->profile());
UpdateCommandEnabled(IDC_TOGGLE_AI_CHAT, sidebar::CanUseSidebar(&*browser_) &&
allowed_for_context);
UpdateCommandEnabled(
IDC_OPEN_FULL_PAGE_CHAT,
ai_chat::features::IsAIChatHistoryEnabled() && allowed_for_context);
}
void BraveBrowserCommandController::UpdateCommandForBraveVPN() {
#if BUILDFLAG(ENABLE_BRAVE_VPN)
if (!brave_vpn::IsBraveVPNEnabled(browser_->profile())) {
UpdateCommandEnabled(IDC_SHOW_BRAVE_VPN_PANEL, false);
UpdateCommandEnabled(IDC_BRAVE_VPN_MENU, false);
UpdateCommandEnabled(IDC_TOGGLE_BRAVE_VPN_TOOLBAR_BUTTON, false);
UpdateCommandEnabled(IDC_SEND_BRAVE_VPN_FEEDBACK, false);
UpdateCommandEnabled(IDC_ABOUT_BRAVE_VPN, false);
UpdateCommandEnabled(IDC_MANAGE_BRAVE_VPN_PLAN, false);
UpdateCommandEnabled(IDC_TOGGLE_BRAVE_VPN, false);
#if BUILDFLAG(IS_WIN)
UpdateCommandEnabled(IDC_TOGGLE_BRAVE_VPN_TRAY_ICON, false);
#endif
return;
}
UpdateCommandEnabled(IDC_SHOW_BRAVE_VPN_PANEL, true);
UpdateCommandEnabled(IDC_TOGGLE_BRAVE_VPN_TOOLBAR_BUTTON, true);
#if BUILDFLAG(IS_WIN)
UpdateCommandEnabled(IDC_TOGGLE_BRAVE_VPN_TRAY_ICON, true);
#endif
UpdateCommandEnabled(IDC_SEND_BRAVE_VPN_FEEDBACK, true);
UpdateCommandEnabled(IDC_ABOUT_BRAVE_VPN, true);
UpdateCommandEnabled(IDC_MANAGE_BRAVE_VPN_PLAN, true);
if (auto* vpn_service = brave_vpn::BraveVpnServiceFactory::GetForProfile(
browser_->profile())) {
// Only show vpn sub menu for purchased user.
UpdateCommandEnabled(IDC_BRAVE_VPN_MENU, vpn_service->is_purchased_user());
UpdateCommandEnabled(IDC_TOGGLE_BRAVE_VPN,
vpn_service->is_purchased_user());
}
#endif
}
void BraveBrowserCommandController::UpdateCommandForPlaylist() {
#if BUILDFLAG(ENABLE_PLAYLIST_WEBUI)
if (base::FeatureList::IsEnabled(playlist::features::kPlaylist)) {
UpdateCommandEnabled(
IDC_SHOW_PLAYLIST_BUBBLE,
browser_->is_type_normal() &&
playlist::PlaylistServiceFactory::GetForBrowserContext(
browser_->profile()));
}
#endif
}
void BraveBrowserCommandController::UpdateCommandForWaybackMachine() {
#if BUILDFLAG(ENABLE_BRAVE_WAYBACK_MACHINE)
UpdateCommandEnabled(IDC_SHOW_WAYBACK_MACHINE_BUBBLE, true);
#endif
}
void BraveBrowserCommandController::UpdateCommandsForTabs() {
UpdateCommandEnabled(IDC_WINDOW_MUTE_ALL_TABS,
brave::CanMuteAllTabs(&*browser_, false));
UpdateCommandEnabled(IDC_WINDOW_MUTE_OTHER_TABS,
brave::CanMuteAllTabs(&*browser_, true));
UpdateCommandEnabled(IDC_WINDOW_UNMUTE_ALL_TABS,
brave::CanUnmuteAllTabs(&*browser_));
UpdateCommandEnabled(IDC_GROUP_TABS_ON_CURRENT_ORIGIN, true);
UpdateCommandEnabled(IDC_MOVE_GROUP_TO_NEW_WINDOW, true);
bool is_in_group = brave::IsInGroup(&*browser_);
bool has_ungrouped_tabs = brave::HasUngroupedTabs(&*browser_);
UpdateCommandEnabled(IDC_WINDOW_GROUP_UNGROUPED_TABS, has_ungrouped_tabs);
UpdateCommandEnabled(IDC_WINDOW_UNGROUP_GROUP, is_in_group);
UpdateCommandEnabled(IDC_WINDOW_REMOVE_TAB_FROM_GROUP, is_in_group);
UpdateCommandEnabled(IDC_WINDOW_NAME_GROUP, is_in_group);
UpdateCommandEnabled(IDC_WINDOW_NEW_TAB_IN_GROUP, is_in_group);
UpdateCommandEnabled(IDC_WINDOW_UNGROUP_ALL_TABS,
brave::CanUngroupAllTabs(&*browser_));
UpdateCommandEnabled(IDC_WINDOW_TOGGLE_GROUP_EXPANDED, is_in_group);
UpdateCommandEnabled(IDC_WINDOW_CLOSE_UNGROUPED_TABS, has_ungrouped_tabs);
UpdateCommandEnabled(IDC_WINDOW_CLOSE_TABS_NOT_IN_CURRENT_GROUP, is_in_group);
UpdateCommandEnabled(IDC_WINDOW_CLOSE_GROUP, is_in_group);
UpdateCommandEnabled(IDC_WINDOW_BRING_ALL_TABS,
brave::CanBringAllTabs(&*browser_));
}
void BraveBrowserCommandController::UpdateCommandsForSend() {
UpdateCommandEnabled(
IDC_BRAVE_SEND_TAB_TO_SELF,
send_tab_to_self::ShouldDisplayEntryPoint(
browser_->tab_strip_model()->GetActiveWebContents()));
}
void BraveBrowserCommandController::UpdateCommandsForPin() {
UpdateCommandEnabled(IDC_WINDOW_CLOSE_UNPINNED_TABS,
brave::CanCloseUnpinnedTabs(&*browser_));
}
void BraveBrowserCommandController::UpdateCommandForSplitView() {
if (!split_view_browser_data_observation_.IsObserving()) {
split_view_browser_data_observation_.Observe(
browser_->GetFeatures().split_view_browser_data());
}
UpdateCommandEnabled(IDC_NEW_SPLIT_VIEW, brave::CanOpenNewSplitViewForTab(
base::to_address(browser_)));
UpdateCommandEnabled(IDC_TILE_TABS,
brave::CanTileTabs(base::to_address(browser_)));
const auto is_tab_tiled = brave::IsTabsTiled(base::to_address(browser_));
for (auto command_enabled_when_tab_is_tiled :
{IDC_BREAK_TILE, IDC_SWAP_SPLIT_VIEW}) {
UpdateCommandEnabled(command_enabled_when_tab_is_tiled, is_tab_tiled);
}
}
void BraveBrowserCommandController::UpdateCommandForSplitViewWithSideBySide() {
// Some upstream unit test calls split tab apis w/o enabling SideBySide
// feature.
if (!base::FeatureList::IsEnabled(features::kSideBySide)) {
CHECK_IS_TEST();
return;
}
UpdateCommandEnabled(
IDC_NEW_SPLIT_VIEW,
brave::CanOpenNewSplitTabsWithSideBySide(base::to_address(browser_)));
UpdateCommandEnabled(IDC_TILE_TABS, brave::CanSplitTabsWithSideBySide(
base::to_address(browser_)));
const bool is_split_tabs = brave::IsSplitTabs(base::to_address(browser_));
for (auto command_enabled_when_tab_is_split :
{IDC_BREAK_TILE, IDC_SWAP_SPLIT_VIEW}) {
UpdateCommandEnabled(command_enabled_when_tab_is_split, is_split_tabs);
}
}
void BraveBrowserCommandController::UpdateCommandForBraveSync() {
UpdateCommandEnabled(IDC_SHOW_BRAVE_SYNC, true);
}
void BraveBrowserCommandController::UpdateCommandForBraveWallet() {
UpdateCommandEnabled(IDC_SHOW_BRAVE_WALLET, true);
UpdateCommandEnabled(IDC_SHOW_BRAVE_WALLET_PANEL, true);
UpdateCommandEnabled(IDC_CLOSE_BRAVE_WALLET_PANEL, true);
}
bool BraveBrowserCommandController::ExecuteBraveCommandWithDisposition(
int id,
WindowOpenDisposition disposition,
base::TimeTicks time_stamp) {
if (!SupportsCommand(id) || !IsCommandEnabled(id)) {
return false;
}
if (browser_->tab_strip_model()->active_index() == TabStripModel::kNoTab) {
return true;
}
DCHECK(IsCommandEnabled(id)) << "Invalid/disabled command " << id;
switch (id) {
case IDC_NEW_WINDOW:
// Use chromium's action for non-Tor profiles.
if (!browser_->profile()->IsTor()) {
return BrowserCommandController::ExecuteCommandWithDisposition(
id, disposition, time_stamp);
}
NewEmptyWindow(browser_->profile()->GetOriginalProfile());
break;
case IDC_NEW_INCOGNITO_WINDOW:
// Use chromium's action for non-Tor profiles.
if (!browser_->profile()->IsTor()) {
return BrowserCommandController::ExecuteCommandWithDisposition(
id, disposition, time_stamp);
}
NewIncognitoWindow(browser_->profile()->GetOriginalProfile());
break;
case IDC_SHOW_BRAVE_REWARDS:
brave::ShowBraveRewards(&*browser_);
break;
case IDC_SHOW_BRAVE_WEBCOMPAT_REPORTER:
brave::ShowWebcompatReporter(&*browser_);
break;
case IDC_NEW_OFFTHERECORD_WINDOW_TOR:
brave::NewOffTheRecordWindowTor(&*browser_);
break;
case IDC_NEW_TOR_CONNECTION_FOR_SITE:
brave::NewTorConnectionForSite(&*browser_);
break;
case IDC_SHOW_BRAVE_SYNC:
brave::ShowSync(&*browser_);
break;
case IDC_SHOW_BRAVE_WALLET:
brave::ShowBraveWallet(&*browser_);
break;
case IDC_TOGGLE_AI_CHAT:
brave::ToggleAIChat(&*browser_);
break;
case IDC_OPEN_FULL_PAGE_CHAT:
brave::ShowFullpageChat(&*browser_);
break;
case IDC_SPEEDREADER_ICON_ONCLICK:
brave::MaybeDistillAndShowSpeedreaderBubble(&*browser_);
break;
case IDC_SHOW_BRAVE_WALLET_PANEL:
brave::ShowWalletBubble(&*browser_);
break;
case IDC_CLOSE_BRAVE_WALLET_PANEL:
brave::CloseWalletBubble(&*browser_);
break;
case IDC_SHOW_BRAVE_VPN_PANEL:
brave::ShowBraveVPNBubble(&*browser_);
break;
case IDC_TOGGLE_BRAVE_VPN_TRAY_ICON:
brave::ToggleBraveVPNTrayIcon();
break;
case IDC_TOGGLE_BRAVE_VPN_TOOLBAR_BUTTON:
brave::ToggleBraveVPNButton(&*browser_);
break;
case IDC_SEND_BRAVE_VPN_FEEDBACK:
case IDC_ABOUT_BRAVE_VPN:
case IDC_MANAGE_BRAVE_VPN_PLAN:
brave::OpenBraveVPNUrls(&*browser_, id);
break;
case IDC_SIDEBAR_TOGGLE_POSITION:
brave::ToggleSidebarPosition(&*browser_);
break;
case IDC_TOGGLE_SIDEBAR:
brave::ToggleSidebar(&*browser_);
break;
case IDC_COPY_CLEAN_LINK:
brave::CopySanitizedURL(
&*browser_,
browser_->tab_strip_model()->GetActiveWebContents()->GetVisibleURL());
break;
case IDC_TOGGLE_TAB_MUTE:
brave::ToggleActiveTabAudioMute(&*browser_);
break;
case IDC_TOGGLE_VERTICAL_TABS:
brave::ToggleVerticalTabStrip(&*browser_);
break;
case IDC_TOGGLE_VERTICAL_TABS_WINDOW_TITLE:
brave::ToggleWindowTitleVisibilityForVerticalTabs(&*browser_);
break;
case IDC_TOGGLE_VERTICAL_TABS_EXPANDED:
brave::ToggleVerticalTabStripExpanded(&*browser_);
break;
case IDC_CONFIGURE_BRAVE_NEWS:
brave::ShowBraveNewsConfigure(&*browser_);
break;
case IDC_CONFIGURE_SHORTCUTS:
brave::ShowShortcutsPage(&*browser_);
break;
case IDC_SHOW_BRAVE_TALK:
brave::ShowBraveTalk(&*browser_);
break;
case IDC_TOGGLE_SHIELDS:
brave::ToggleShieldsEnabled(&*browser_);
break;
case IDC_TOGGLE_JAVASCRIPT:
brave::ToggleJavascriptEnabled(&*browser_);
break;
case IDC_SHOW_PLAYLIST_BUBBLE:
#if BUILDFLAG(ENABLE_PLAYLIST_WEBUI)
brave::ShowPlaylistBubble(&*browser_);
#else
NOTREACHED() << " This command shouldn't be enabled";
#endif
break;
case IDC_SHOW_WAYBACK_MACHINE_BUBBLE:
#if BUILDFLAG(ENABLE_BRAVE_WAYBACK_MACHINE)
brave::ShowWaybackMachineBubble(&*browser_);
#endif
break;
case IDC_GROUP_TABS_ON_CURRENT_ORIGIN:
brave::GroupTabsOnCurrentOrigin(&*browser_);
break;
case IDC_MOVE_GROUP_TO_NEW_WINDOW:
brave::MoveGroupToNewWindow(&*browser_);
break;
case IDC_CLOSE_DUPLICATE_TABS:
brave::CloseDuplicateTabs(&*browser_);
break;
case IDC_WINDOW_CLOSE_TABS_TO_LEFT:
brave::CloseTabsToLeft(&*browser_);
break;
case IDC_WINDOW_CLOSE_UNPINNED_TABS:
brave::CloseUnpinnedTabs(&*browser_);
break;
case IDC_WINDOW_ADD_ALL_TABS_TO_NEW_GROUP:
brave::AddAllTabsToNewGroup(&*browser_);
break;
case IDC_WINDOW_MUTE_ALL_TABS:
brave::MuteAllTabs(&*browser_, false);
break;
case IDC_WINDOW_MUTE_OTHER_TABS:
brave::MuteAllTabs(&*browser_, true);
break;
case IDC_WINDOW_UNMUTE_ALL_TABS:
brave::UnmuteAllTabs(&*browser_);
break;
case IDC_SCROLL_TAB_TO_TOP:
brave::ScrollTabToTop(&*browser_);
break;
case IDC_SCROLL_TAB_TO_BOTTOM:
brave::ScrollTabToBottom(&*browser_);
break;
case IDC_BRAVE_SEND_TAB_TO_SELF:
chrome::SendTabToSelf(&*browser_);
break;
case IDC_TOGGLE_ALL_BOOKMARKS_BUTTON_VISIBILITY:
brave::ToggleAllBookmarksButtonVisibility(base::to_address(browser_));
break;
case IDC_EXPORT_ALL_BOOKMARKS:
brave::ExportAllBookmarks(&*browser_);
break;
case IDC_COMMANDER:
#if BUILDFLAG(ENABLE_COMMANDER)
brave::ToggleCommander(base::to_address(browser_));
#endif
break;
case IDC_SHOW_APPS_PAGE:
brave::ShowAppsPage(&*browser_);
break;
case IDC_WINDOW_GROUP_UNGROUPED_TABS:
brave::GroupUngroupedTabs(&*browser_);
break;
case IDC_WINDOW_UNGROUP_GROUP:
brave::UngroupCurrentGroup(&*browser_);
break;
case IDC_WINDOW_REMOVE_TAB_FROM_GROUP:
brave::RemoveTabFromGroup(&*browser_);
break;
case IDC_WINDOW_UNGROUP_ALL_TABS:
brave::UngroupAllTabs(&*browser_);
break;
case IDC_WINDOW_NAME_GROUP:
brave::NameGroup(&*browser_);
break;
case IDC_WINDOW_NEW_TAB_IN_GROUP:
brave::NewTabInGroup(&*browser_);
break;
case IDC_WINDOW_TOGGLE_GROUP_EXPANDED:
brave::ToggleGroupExpanded(&*browser_);
break;
case IDC_WINDOW_CLOSE_UNGROUPED_TABS:
brave::CloseUngroupedTabs(&*browser_);
break;
case IDC_WINDOW_CLOSE_TABS_NOT_IN_CURRENT_GROUP:
brave::CloseTabsNotInCurrentGroup(&*browser_);
break;
case IDC_WINDOW_CLOSE_GROUP:
brave::CloseGroup(&*browser_);
break;
case IDC_WINDOW_BRING_ALL_TABS:
brave::BringAllTabs(&*browser_);
break;
case IDC_NEW_SPLIT_VIEW: {
if (tabs::features::IsBraveSplitViewEnabled()) {
brave::NewSplitViewForTab(&*browser_);
} else {
CHECK(base::FeatureList::IsEnabled(features::kSideBySide));
chrome::NewSplitTab(base::to_address(browser_));
}
break;
}
case IDC_TILE_TABS: {
if (tabs::features::IsBraveSplitViewEnabled()) {
brave::TileTabs(&*browser_);
} else {
CHECK(base::FeatureList::IsEnabled(features::kSideBySide));
brave::SplitTabsWithSideBySide(base::to_address(browser_));
}
break;
}
case IDC_BREAK_TILE: {
if (tabs::features::IsBraveSplitViewEnabled()) {
brave::BreakTiles(&*browser_);
} else {
CHECK(base::FeatureList::IsEnabled(features::kSideBySide));
brave::RemoveSplitWithSideBySide(base::to_address(browser_));
}
break;
}
case IDC_SWAP_SPLIT_VIEW: {
if (tabs::features::IsBraveSplitViewEnabled()) {
brave::SwapTabsInTile(&*browser_);
} else {
CHECK(base::FeatureList::IsEnabled(features::kSideBySide));
brave::SwapTabsInSplitWithSideBySide(base::to_address(browser_));
}
break;
}
default:
LOG(WARNING) << "Received Unimplemented Command: " << id;
break;
}
return true;
}
#if BUILDFLAG(ENABLE_BRAVE_VPN)
void BraveBrowserCommandController::OnPurchasedStateChanged(
brave_vpn::mojom::PurchasedState state,
const std::optional<std::string>& description) {
UpdateCommandForBraveVPN();
}
#endif
} // namespace chrome
Reference in New Issue View Git Blame Copy Permalink