Discharge7443/brave-core
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
brave-core/browser/ui/brave_browser_browsertest.cc
T
Claudio DeSouza 8eac087646 [cr147] Browser::ShouldDisplayFavicon deleted 
This information is not to be retrieved with the `TabUIHelper`.

Chromium changes:
https://chromium.googlesource.com/chromium/src/+/79b6f0c7d59514e77293ea1ac57d079d3c0adf4e

commit 79b6f0c7d59514e77293ea1ac57d079d3c0adf4e
Author: Steven Luong <stluong@chromium.org>
Date:   Wed Feb 18 12:55:46 2026 -0800

    [TabRendererData] Move themify and show icon to TabUIHelper

    Move favicon related properties to be calculated in the TabUIHelper
    so that the TabRendererData will be easier to deprecate.

    Bug: 484410926
    Change-Id: I0de4e22d4f80ddb2980a166539f85d44af66a271
    Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/7584127
    Commit-Queue: Steven Luong <stluong@chromium.org>
    Reviewed-by: Eshwar Stalin <estalin@chromium.org>
    Reviewed-by: Darryl James <dljames@chromium.org>
    Cr-Commit-Position: refs/heads/main@{#1586641}
2026-03-26 19:25:09 -04:00

338 lines
14 KiB
C++
Raw Permalink Blame History

/* Copyright (c) 2021 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.h"
#include "base/test/run_until.h"
#include "brave/browser/ui/browser_commands.h"
#include "brave/components/constants/pref_names.h"
#include "chrome/browser/bookmarks/bookmark_model_factory.h"
#include "chrome/browser/devtools/devtools_window_testing.h"
#include "chrome/browser/profiles/profile.h"
#include "chrome/browser/search/search.h"
#include "chrome/browser/ui/browser_commands.h"
#include "chrome/browser/ui/browser_finder.h"
#include "chrome/browser/ui/browser_tabstrip.h"
#include "chrome/browser/ui/browser_window/public/browser_window_features.h"
#include "chrome/browser/ui/browser_window/public/browser_window_interface_iterator.h"
#include "chrome/browser/ui/startup/launch_mode_recorder.h"
#include "chrome/browser/ui/startup/startup_browser_creator.h"
#include "chrome/browser/ui/startup/startup_browser_creator_impl.h"
#include "chrome/browser/ui/tab_ui_helper.h"
#include "chrome/browser/ui/tabs/tab_strip_model.h"
#include "chrome/browser/ui/views/frame/browser_view.h"
#include "chrome/browser/ui/webui/ntp/new_tab_ui.h"
#include "chrome/test/base/in_process_browser_test.h"
#include "chrome/test/base/ui_test_utils.h"
#include "components/bookmarks/browser/bookmark_model.h"
#include "components/bookmarks/browser/bookmark_utils.h"
#include "components/bookmarks/common/bookmark_pref_names.h"
#include "components/optimization_guide/optimization_guide_internals/webui/url_constants.h"
#include "components/prefs/pref_service.h"
#include "content/public/browser/navigation_entry.h"
#include "content/public/test/browser_test.h"
#include "content/public/test/browser_test_utils.h"
#include "content/public/test/test_navigation_observer.h"
#include "content/public/test/test_utils.h"
using BraveBrowserBrowserTest = InProcessBrowserTest;
namespace {
Browser* OpenNewBrowser(Profile* profile) {
base::CommandLine dummy(base::CommandLine::NO_PROGRAM);
StartupBrowserCreatorImpl creator(base::FilePath(), dummy,
chrome::startup::IsFirstRun::kYes);
creator.Launch(profile, chrome::startup::IsProcessStartup::kNo,
/*restore_tabbed_browser=*/true);
return chrome::FindBrowserWithProfile(profile);
}
void AddBookmarkNode(Profile* profile) {
const GURL url = GURL("https://www.brave.com");
bookmarks::BookmarkModel* bookmark_model =
BookmarkModelFactory::GetForBrowserContext(profile);
std::vector<raw_ptr<const bookmarks::BookmarkNode, VectorExperimental>>
nodes = bookmark_model->GetNodesByURL(url);
EXPECT_EQ(0UL, nodes.size());
// We need to pass a non-empty title when creating a bookmark so that an
// accessible name is also available, otherwise we'll hit a CHECK() and
// the test will crash (see accessibility_paint_checks.cc).
bookmarks::AddIfNotBookmarked(bookmark_model, url, u"brave");
nodes = bookmark_model->GetNodesByURL(url);
EXPECT_EQ(1UL, nodes.size());
}
} // namespace
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest, NTPFaviconTest) {
ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), GURL("brave://newtab/")));
tabs::TabInterface* const tab_interface =
browser()->tab_strip_model()->GetActiveTab();
EXPECT_TRUE(TabUIHelper::From(tab_interface)->ShouldDisplayFavicon());
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest, LoadWebUIURLWithBadSchemeTest) {
ASSERT_TRUE(
ui_test_utils::NavigateToURL(browser(), GURL("http://settings/")));
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest, DisabledFeatureURLLoadTest) {
// We disabled optimization hints but loading related url should not be
// crashed. See https://bugs.chromium.org/p/chromium/issues/detail?id=1476101
ASSERT_TRUE(ui_test_utils::NavigateToURL(
browser(), GURL(content::GetWebUIURLString(
optimization_guide_internals::
kChromeUIOptimizationGuideInternalsHost))));
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest, OpenNewTabWhenTabStripIsEmpty) {
ASSERT_TRUE(embedded_test_server()->Start());
Browser* new_browser = OpenNewBrowser(browser()->profile());
ASSERT_TRUE(new_browser);
new_browser->profile()->GetPrefs()->SetBoolean(kEnableClosingLastTab, false);
TabStripModel* tab_strip = new_browser->tab_strip_model();
auto page_url = embedded_test_server()->GetURL("/empty.html");
ASSERT_TRUE(ui_test_utils::NavigateToURL(new_browser, page_url));
ASSERT_EQ(1, tab_strip->count());
EXPECT_EQ(page_url,
tab_strip->GetWebContentsAt(0)->GetURL().possibly_invalid_spec());
auto* devtools_window = DevToolsWindowTesting::OpenDevToolsWindowSync(
tab_strip->GetActiveWebContents(), false);
EXPECT_EQ(chrome::GetTotalBrowserCount(), 3u);
// Close the last tab.
tab_strip->GetActiveWebContents()->Close();
ui_test_utils::WaitForBrowserToClose(
DevToolsWindowTesting::Get(devtools_window)->browser());
EXPECT_EQ(chrome::GetTotalBrowserCount(), 2u);
ASSERT_EQ(1, tab_strip->count());
// Expecting a new tab is opened.
EXPECT_EQ(new_browser->GetNewTabURL(),
tab_strip->GetWebContentsAt(0)->GetURL().possibly_invalid_spec());
// No reentrancy for Ctrl+W
tab_strip->CloseSelectedTabs();
base::RunLoop().RunUntilIdle();
// Expecting a new tab is opened.
EXPECT_EQ(new_browser->GetNewTabURL(),
tab_strip->GetWebContentsAt(0)->GetURL().possibly_invalid_spec());
// Add a couple of more tabs.
chrome::AddTabAt(new_browser, new_browser->GetNewTabURL(), -1, true);
chrome::AddTabAt(new_browser, new_browser->GetNewTabURL(), -1, true);
ASSERT_EQ(3, tab_strip->count());
EXPECT_EQ(chrome::GetTotalBrowserCount(), 2u);
// Close the browser window.
new_browser->window()->Close();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(chrome::GetTotalBrowserCount(), 1u);
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest,
DoNotOpenNewTabWhenTabStripIsEmpty) {
ASSERT_TRUE(embedded_test_server()->Start());
Browser* new_browser = OpenNewBrowser(browser()->profile());
ASSERT_TRUE(new_browser);
new_browser->profile()->GetPrefs()->SetBoolean(kEnableClosingLastTab, true);
TabStripModel* tab_strip = new_browser->tab_strip_model();
auto page_url = embedded_test_server()->GetURL("/empty.html");
ASSERT_TRUE(ui_test_utils::NavigateToURL(new_browser, page_url));
ASSERT_EQ(1, tab_strip->count());
EXPECT_EQ(page_url,
tab_strip->GetWebContentsAt(0)->GetURL().possibly_invalid_spec());
EXPECT_EQ(chrome::GetTotalBrowserCount(), 2u);
// Close the last tab.
tab_strip->GetActiveWebContents()->Close();
base::RunLoop().RunUntilIdle();
EXPECT_EQ(chrome::GetTotalBrowserCount(), 1u);
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest,
DoNotOpenNewTabWhenBringingAllTabs) {
// Given that kEnableClosingLastTab is false, which normally creates a new tab
// when tab strip is empty.
ASSERT_TRUE(embedded_test_server()->Start());
Browser* new_browser = OpenNewBrowser(browser()->profile());
ASSERT_TRUE(new_browser);
new_browser->profile()->GetPrefs()->SetBoolean(kEnableClosingLastTab, false);
// When "Bring all tabs to this window" commands executes
brave::BringAllTabs(browser());
// Then other windows should be closed
base::RunLoop().RunUntilIdle();
EXPECT_EQ(browser()->tab_strip_model()->count(), 2);
EXPECT_EQ(chrome::GetTotalBrowserCount(), 1u);
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest,
CloseBrowserAfterDetachingAllTabToAnotherBrowser) {
browser()->profile()->GetPrefs()->SetBoolean(kEnableClosingLastTab, false);
Browser* browser2 = CreateBrowser(browser()->profile());
ASSERT_TRUE(browser2);
TabStripModel* tab_strip = browser()->tab_strip_model();
TabStripModel* tab_strip2 = browser2->tab_strip_model();
// New browser has one tab and it'll be attached to browser() and |browser2|
// should be gone.
EXPECT_EQ(1, tab_strip2->count());
auto detached_tab = tab_strip2->DetachTabAtForInsertion(0);
tab_strip->InsertDetachedTabAt(0, std::move(detached_tab),
AddTabTypes::ADD_ACTIVE);
EXPECT_TRUE(
base::test::RunUntil([] { return chrome::GetTotalBrowserCount() == 1; }));
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest,
CreateAnotherWindowWithExistingTab) {
ASSERT_TRUE(embedded_test_server()->Start());
browser()->profile()->GetPrefs()->SetBoolean(kEnableClosingLastTab, false);
TabStripModel* tab_strip = browser()->tab_strip_model();
auto page_url = embedded_test_server()->GetURL("/empty.html");
ASSERT_TRUE(ui_test_utils::NavigateToURL(browser(), page_url));
ASSERT_EQ(1, tab_strip->count());
EXPECT_EQ(page_url,
tab_strip->GetWebContentsAt(0)->GetURL().possibly_invalid_spec());
// Close the last tab.
tab_strip->GetActiveWebContents()->Close();
ASSERT_EQ(0, tab_strip->count());
// Wait till another new tab is opened.
EXPECT_TRUE(
base::test::RunUntil([tab_strip] { return tab_strip->count() == 1; }));
EXPECT_EQ(browser()->GetNewTabURL(),
tab_strip->GetWebContentsAt(0)->GetURL().possibly_invalid_spec());
ui_test_utils::NavigateToURLWithDisposition(
browser(), GURL("https://www.brave.com/"),
WindowOpenDisposition::NEW_FOREGROUND_TAB,
ui_test_utils::BROWSER_TEST_WAIT_FOR_LOAD_STOP);
ASSERT_EQ(2, tab_strip->count());
// Create another browser with existing tab.
ui_test_utils::BrowserCreatedObserver browser_created_observer;
chrome::MoveTabsToNewWindow(browser(), {1});
Browser* new_browser = browser_created_observer.Wait();
ASSERT_EQ(1, tab_strip->count());
ASSERT_TRUE(new_browser);
base::RunLoop().RunUntilIdle();
// Check new browser by detaching a tab from another window has
// one tab.
EXPECT_EQ(1, new_browser->tab_strip_model()->count());
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest, BookmarkBarOnNTPTest) {
auto* profile = browser()->profile();
auto* contents = browser()->tab_strip_model()->GetActiveWebContents();
// Check Bookmark bar is hidden by default for non NTP.
EXPECT_FALSE(NewTabUI::IsNewTab(contents->GetLastCommittedURL()));
EXPECT_EQ(BookmarkBar::HIDDEN,
BookmarkBarController::From(browser())->bookmark_bar_state());
// Check show bookmarks on NTP is on by default.
EXPECT_TRUE(profile->GetPrefs()->GetBoolean(
bookmarks::prefs::kAlwaysShowBookmarkBarOnNTP));
// Loading NTP.
EXPECT_TRUE(
content::NavigateToURL(contents, GURL(chrome::kChromeUINewTabURL)));
EXPECT_TRUE(NewTabUI::IsNewTab(contents->GetLastCommittedURL()));
// Check bookmark bar on NTP is shown even if bookmark bar is empty.
EXPECT_EQ(BookmarkBar::SHOW,
BookmarkBarController::From(browser())->bookmark_bar_state());
AddBookmarkNode(profile);
// Check bookmark is also visible on NTP after adding bookmark regardless of
// show bookmark bar option value.
chrome::ToggleBookmarkBar(browser());
EXPECT_EQ(BookmarkBar::SHOW,
BookmarkBarController::From(browser())->bookmark_bar_state());
chrome::ToggleBookmarkBar(browser());
EXPECT_EQ(BookmarkBar::HIDDEN,
BookmarkBarController::From(browser())->bookmark_bar_state());
EXPECT_FALSE(profile->GetPrefs()->GetBoolean(
bookmarks::prefs::kAlwaysShowBookmarkBarOnNTP));
// Turn off showing bookmark bar on NTP.
profile->GetPrefs()->SetBoolean(bookmarks::prefs::kAlwaysShowBookmarkBarOnNTP,
true);
// Check bookmark bar on NTP is visible when
// bookmarks::prefs::kAlwaysShowBookmarkBarOnNTP pref is on.
EXPECT_EQ(BookmarkBar::SHOW,
BookmarkBarController::From(browser())->bookmark_bar_state());
// Check bookmark bar on NTP is visible when kBookmarkBar pref is on.
chrome::ToggleBookmarkBar(browser());
EXPECT_EQ(BookmarkBar::SHOW,
BookmarkBarController::From(browser())->bookmark_bar_state());
}
IN_PROC_BROWSER_TEST_F(BraveBrowserBrowserTest, BookmarkBarOnNTPTestIncognito) {
Browser* incognito = CreateIncognitoBrowser();
auto* profile = incognito->profile();
auto* contents = incognito->tab_strip_model()->GetActiveWebContents();
// Check Bookmark bar is hidden by default for non NTP.
EXPECT_FALSE(NewTabUI::IsNewTab(contents->GetLastCommittedURL()));
EXPECT_EQ(BookmarkBar::HIDDEN,
BookmarkBarController::From(incognito)->bookmark_bar_state());
// Check show bookmarks on NTP is on by default.
EXPECT_TRUE(profile->GetPrefs()->GetBoolean(
bookmarks::prefs::kAlwaysShowBookmarkBarOnNTP));
// Loading NTP.
EXPECT_TRUE(
content::NavigateToURL(contents, GURL(chrome::kChromeUINewTabURL)));
EXPECT_TRUE(NewTabUI::IsNewTab(contents->GetLastCommittedURL()));
// Check bookmark bar on NTP is shown even if bookmark bar is empty.
EXPECT_EQ(BookmarkBar::SHOW,
BookmarkBarController::From(incognito)->bookmark_bar_state());
AddBookmarkNode(profile);
// Check bookmark is also visible on NTP after adding bookmark regardless of
// show bookmark bar option value.
chrome::ToggleBookmarkBar(incognito);
EXPECT_EQ(BookmarkBar::SHOW,
BookmarkBarController::From(incognito)->bookmark_bar_state());
chrome::ToggleBookmarkBar(incognito);
EXPECT_EQ(BookmarkBar::HIDDEN,
BookmarkBarController::From(incognito)->bookmark_bar_state());
EXPECT_FALSE(profile->GetPrefs()->GetBoolean(
bookmarks::prefs::kAlwaysShowBookmarkBarOnNTP));
// Turn on showing bookmark bar on NTP.
profile->GetPrefs()->SetBoolean(bookmarks::prefs::kAlwaysShowBookmarkBarOnNTP,
true);
// Check bookmark bar on NTP is visible when
// bookmarks::prefs::kAlwaysShowBookmarkBarOnNTP pref is on.
EXPECT_EQ(BookmarkBar::SHOW,
BookmarkBarController::From(incognito)->bookmark_bar_state());
// Check bookmark bar on NTP is visible when kBookmarkBar pref is on.
chrome::ToggleBookmarkBar(incognito);
EXPECT_EQ(BookmarkBar::SHOW,
BookmarkBarController::From(incognito)->bookmark_bar_state());
}
Reference in New Issue View Git Blame Copy Permalink