// Copyright 2024 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/ui/ash/picker/picker_client_impl.h"
#include <functional>
#include <memory>
#include <string>
#include <utility>
#include "ash/picker/picker_controller.h"
#include "base/files/file_util.h"
#include "base/functional/bind.h"
#include "base/test/scoped_feature_list.h"
#include "base/test/test_future.h"
#include "chrome/browser/ash/app_list/search/test/test_ranker_manager.h"
#include "chrome/browser/ash/drive/drive_integration_service.h"
#include "chrome/browser/ash/drive/drivefs_test_support.h"
#include "chrome/browser/ash/fileapi/recent_model.h"
#include "chrome/browser/ash/fileapi/recent_model_factory.h"
#include "chrome/browser/ash/fileapi/test/fake_recent_source.h"
#include "chrome/browser/ash/input_method/editor_mediator_factory.h"
#include "chrome/browser/bookmarks/bookmark_model_factory.h"
#include "chrome/browser/history/history_service_factory.h"
#include "chrome/browser/search_engines/template_url_service_factory.h"
#include "chrome/browser/ui/webui/ash/mako/mako_bubble_coordinator.h"
#include "chrome/common/extensions/api/file_manager_private.h"
#include "chrome/test/base/browser_with_test_window_test.h"
#include "chrome/test/base/testing_browser_process.h"
#include "chrome/test/base/testing_profile.h"
#include "chrome/test/base/testing_profile_manager.h"
#include "chromeos/ash/components/disks/disk_mount_manager.h"
#include "chromeos/ash/components/disks/fake_disk_mount_manager.h"
#include "chromeos/ash/components/drivefs/fake_drivefs.h"
#include "chromeos/constants/chromeos_features.h"
#include "components/bookmarks/browser/bookmark_model.h"
#include "components/bookmarks/test/bookmark_test_helpers.h"
#include "components/favicon/core/test/mock_favicon_service.h"
#include "components/favicon_base/favicon_types.h"
#include "components/history/core/browser/history_database_params.h"
#include "components/history/core/browser/history_service.h"
#include "components/history/core/test/test_history_database.h"
#include "components/user_manager/fake_user_manager.h"
#include "content/public/test/test_utils.h"
#include "services/network/public/cpp/shared_url_loader_factory.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/base/ime/ash/ime_bridge.h"
#include "ui/base/ime/ash/input_method_ash.h"
#include "ui/base/ime/fake_text_input_client.h"
#include "ui/display/screen.h"
#include "ui/display/test/test_screen.h"
#include "ui/views/accessibility/ax_event_manager.h"
#include "ui/views/test/ax_event_counter.h"
namespace {
using ::testing::_;
using ::testing::AllOf;
using ::testing::AnyNumber;
using ::testing::Contains;
using ::testing::Field;
using ::testing::IsEmpty;
using ::testing::IsSupersetOf;
using ::testing::NiceMock;
using ::testing::Not;
using ::testing::Property;
using ::testing::SizeIs;
using ::testing::UnorderedElementsAre;
using ::testing::VariantWith;
using MockSearchResultsCallback =
testing::MockFunction<PickerClientImpl::CrosSearchResultsCallback>;
namespace fmp = extensions::api::file_manager_private;
class TestFaviconService : public favicon::MockFaviconService {
public:
TestFaviconService() = default;
TestFaviconService(const TestFaviconService&) = delete;
TestFaviconService& operator=(const TestFaviconService&) = delete;
~TestFaviconService() override = default;
// favicon::FaviconService:
base::CancelableTaskTracker::TaskId GetFaviconImageForPageURL(
const GURL& page_url,
favicon_base::FaviconImageCallback callback,
base::CancelableTaskTracker* tracker) override {
page_url_ = page_url;
std::move(callback).Run(favicon_base::FaviconImageResult());
return {};
}
GURL page_url_;
};
bool CreateTestFile(const base::FilePath& path) {
base::ScopedAllowBlockingForTesting allow_blocking;
if (!base::WriteFile(path, "test_file")) {
return false;
}
return true;
}
std::unique_ptr<KeyedService> BuildTestHistoryService(
base::FilePath profile_path,
content::BrowserContext* context) {
auto service = std::make_unique<history::HistoryService>();
service->Init(history::TestHistoryDatabaseParamsForPath(profile_path));
return std::move(service);
}
struct Volume {
fmp::VolumeType type;
std::vector<ash::RecentFile> files;
};
std::unique_ptr<KeyedService> BuildTestRecentModelFactory(
std::vector<Volume> volumes,
content::BrowserContext* /*context*/) {
std::vector<std::unique_ptr<ash::RecentSource>> sources;
for (Volume& volume : volumes) {
auto source = std::make_unique<ash::FakeRecentSource>(volume.type);
source->AddProducer(std::make_unique<ash::FileProducer>(
/*lag=*/base::Milliseconds(0), std::move(volume.files)));
sources.push_back(std::move(source));
}
return ash::RecentModel::CreateForTest(std::move(sources));
}
std::unique_ptr<KeyedService> BuildTestDriveIntegrationService(
const base::FilePath& profile_path,
std::unique_ptr<drive::FakeDriveFsHelper>& fake_drivefs_helper,
content::BrowserContext* context) {
Profile* profile = Profile::FromBrowserContext(context);
base::ScopedAllowBlockingForTesting allow_blocking;
base::FilePath mount_path = profile_path.Append("drivefs");
static_cast<ash::disks::FakeDiskMountManager*>(
ash::disks::DiskMountManager::GetInstance())
->RegisterMountPointForNetworkStorageScheme("drivefs",
mount_path.value());
fake_drivefs_helper =
std::make_unique<drive::FakeDriveFsHelper>(profile, mount_path);
auto service = std::make_unique<drive::DriveIntegrationService>(
profile, "drivefs", mount_path,
fake_drivefs_helper->CreateFakeDriveFsListenerFactory());
// Wait until the DriveIntegrationService is initialized.
while (!service->IsMounted() || !service->GetDriveFsInterface()) {
base::RunLoop().RunUntilIdle();
}
return service;
}
void AddSearchToHistory(TestingProfile* profile,
GURL url,
base::Time last_visit = base::Time::Now()) {
history::HistoryService* history = HistoryServiceFactory::GetForProfile(
profile, ServiceAccessType::EXPLICIT_ACCESS);
history->AddPageWithDetails(url, /*title=*/u"", /*visit_count=*/1,
/*typed_count=*/1,
/*last_visit=*/last_visit,
/*hidden=*/false, history::SOURCE_BROWSED);
profile->BlockUntilHistoryProcessesPendingRequests();
}
void AddBookmarks(TestingProfile* profile,
std::u16string_view title,
GURL url) {
auto* bookmark_model = BookmarkModelFactory::GetForBrowserContext(profile);
bookmarks::test::WaitForBookmarkModelToLoad(bookmark_model);
bookmark_model->AddURL(bookmark_model->bookmark_bar_node(), 0,
std::u16string(title), url);
}
ash::RecentFile CreateRecentFile(const base::FilePath& file_path,
storage::FileSystemType type,
base::Time last_modified = base::Time::Now()) {
CreateTestFile(file_path);
return ash::RecentFile(storage::FileSystemURL::CreateForTest(
blink::StorageKey(), type, file_path),
last_modified);
}
void SetRecentFiles(TestingProfile* profile, std::vector<Volume> volumes) {
ash::RecentModelFactory::GetInstance()->SetTestingFactoryAndUse(
profile,
base::BindRepeating(BuildTestRecentModelFactory, std::move(volumes)));
}
class PickerClientImplTest : public BrowserWithTestWindowTest {
public:
PickerClientImplTest() = default;
void SetUp() override {
ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
ash::CrosDisksClient::InitializeFake();
ash::disks::DiskMountManager::InitializeForTesting(
new ash::disks::FakeDiskMountManager());
BrowserWithTestWindowTest::SetUp();
}
void TearDown() override {
BrowserWithTestWindowTest::TearDown();
ash::disks::DiskMountManager::Shutdown();
ash::CrosDisksClient::Shutdown();
}
scoped_refptr<network::SharedURLLoaderFactory> GetSharedURLLoaderFactory() {
return test_shared_url_loader_factory_;
}
drivefs::FakeDriveFs& GetFakeDriveFs() {
return fake_drivefs_helper_->fake_drivefs();
}
TestingProfile* CreateProfile(const std::string& profile_name) override {
auto* profile = profile_manager()->CreateTestingProfile(
profile_name, GetTestingFactories(), /*is_main_profile=*/false,
test_shared_url_loader_factory_);
OnUserProfileCreated(profile_name, profile);
return profile;
}
TestingProfile::TestingFactories GetTestingFactories() override {
return {
TestingProfile::TestingFactory{
HistoryServiceFactory::GetInstance(),
base::BindRepeating(&BuildTestHistoryService, temp_dir_.GetPath())},
TestingProfile::TestingFactory{
BookmarkModelFactory::GetInstance(),
BookmarkModelFactory::GetDefaultFactory()},
TestingProfile::TestingFactory{
TemplateURLServiceFactory::GetInstance(),
base::BindRepeating(&TemplateURLServiceFactory::BuildInstanceFor)},
TestingProfile::TestingFactory{
ash::RecentModelFactory::GetInstance(),
base::BindRepeating(&BuildTestRecentModelFactory,
std::vector<Volume>{})},
TestingProfile::TestingFactory{
drive::DriveIntegrationServiceFactory::GetInstance(),
base::BindRepeating(&BuildTestDriveIntegrationService,
temp_dir_.GetPath(),
std::ref(fake_drivefs_helper_))},
TestingProfile::TestingFactory{
ash::input_method::EditorMediatorFactory::GetInstance(),
base::BindRepeating(
&ash::input_method::EditorMediatorFactory::BuildInstanceFor)}};
}
void LogIn(const std::string& email) override {
// DriveFS needs the account to have an ID.
const AccountId account_id =
AccountId::FromUserEmailGaiaId(email, "test gaia");
user_manager()->AddUser(account_id);
ash_test_helper()->test_session_controller_client()->AddUserSession(email);
user_manager()->UserLoggedIn(
account_id,
user_manager::FakeUserManager::GetFakeUsernameHash(account_id),
/*browser_restart=*/false,
/*is_child=*/false);
}
private:
base::ScopedTempDir temp_dir_;
scoped_refptr<network::SharedURLLoaderFactory>
test_shared_url_loader_factory_;
std::unique_ptr<drive::FakeDriveFsHelper> fake_drivefs_helper_;
};
TEST_F(PickerClientImplTest, StartCrosSearch) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
AddSearchToHistory(profile(), GURL("http://foo.com/history"));
AddBookmarks(profile(), u"Foobaz", GURL("http://foo.com/bookmarks"));
AddTab(browser(), GURL("http://foo.com/tab"));
base::test::TestFuture<void> test_done;
auto ranker_manager =
std::make_unique<app_list::TestRankerManager>(profile());
ranker_manager->SetBestMatchString(u"tab");
client.set_ranker_manager_for_test(std::move(ranker_manager));
NiceMock<MockSearchResultsCallback> mock_search_callback;
EXPECT_CALL(mock_search_callback, Call(_, _)).Times(AnyNumber());
EXPECT_CALL(
mock_search_callback,
Call(
ash::AppListSearchResultType::kOmnibox,
IsSupersetOf({
VariantWith<ash::PickerBrowsingHistoryResult>(AllOf(
Field("url", &ash::PickerBrowsingHistoryResult::url,
GURL("http://foo.com/history")),
Field("best_match",
&ash::PickerBrowsingHistoryResult::best_match, false))),
VariantWith<ash::PickerBrowsingHistoryResult>(AllOf(
Field("url", &ash::PickerBrowsingHistoryResult::url,
GURL("http://foo.com/tab")),
Field("best_match",
&ash::PickerBrowsingHistoryResult::best_match, true))),
VariantWith<ash::PickerBrowsingHistoryResult>(AllOf(
Field("title", &ash::PickerBrowsingHistoryResult::title,
u"Foobaz"),
Field("url", &ash::PickerBrowsingHistoryResult::url,
GURL("http://foo.com/bookmarks")),
Field("best_match",
&ash::PickerBrowsingHistoryResult::best_match, false))),
})))
.WillOnce([&]() { test_done.SetValue(); });
client.StartCrosSearch(
u"foo", /*category=*/std::nullopt,
base::BindRepeating(&MockSearchResultsCallback::Call,
base::Unretained(&mock_search_callback)));
ASSERT_TRUE(test_done.Wait());
}
TEST_F(PickerClientImplTest, IgnoresWhatYouTypedResults) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<void> test_done;
NiceMock<MockSearchResultsCallback> mock_search_callback;
EXPECT_CALL(mock_search_callback, Call(_, _)).Times(AnyNumber());
EXPECT_CALL(mock_search_callback,
Call(ash::AppListSearchResultType::kOmnibox, IsEmpty()))
.WillOnce([&]() { test_done.SetValue(); });
client.StartCrosSearch(
u"a.com", /*category=*/std::nullopt,
base::BindRepeating(&MockSearchResultsCallback::Call,
base::Unretained(&mock_search_callback)));
ASSERT_TRUE(test_done.Wait());
}
TEST_F(PickerClientImplTest, GetRecentLocalFilesWithNoFiles) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
client.GetRecentLocalFileResults(/*max_files=*/100, future.GetCallback());
EXPECT_THAT(future.Get(), IsEmpty());
}
TEST_F(PickerClientImplTest, GetRecentLocalFilesReturnsOnlyLocalFiles) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
const base::FilePath mount_path = GetFakeDriveFs().mount_path();
SetRecentFiles(
profile(),
{
Volume{
.type = fmp::VolumeType::kDownloads,
.files =
{
CreateRecentFile(mount_path.AppendASCII("local.png"),
storage::kFileSystemTypeLocal),
},
},
Volume{
.type = fmp::VolumeType::kDrive,
.files =
{
CreateRecentFile(mount_path.AppendASCII("drive.png"),
storage::kFileSystemTypeDriveFs),
},
},
});
client.GetRecentLocalFileResults(/*max_files=*/100, future.GetCallback());
EXPECT_THAT(
future.Get(),
UnorderedElementsAre(VariantWith<ash::PickerLocalFileResult>(
Field("title", &ash::PickerLocalFileResult::title, u"local.png"))));
}
TEST_F(PickerClientImplTest, GetRecentLocalFilesDoesNotReturnOldFiles) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
SetRecentFiles(
profile(),
{
Volume{
.type = fmp::VolumeType::kDownloads,
.files =
{
CreateRecentFile(
GetFakeDriveFs().mount_path().AppendASCII("old.png"),
storage::kFileSystemTypeLocal,
base::Time::Now() - base::Days(31)),
},
},
});
client.GetRecentLocalFileResults(/*max_files=*/100, future.GetCallback());
EXPECT_THAT(future.Get(), IsEmpty());
}
TEST_F(PickerClientImplTest, GetRecentDriveFilesWithNoFiles) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
client.GetRecentDriveFileResults(/*max_files=*/100, future.GetCallback());
EXPECT_THAT(future.Get(), IsEmpty());
}
TEST_F(PickerClientImplTest, GetRecentDriveFilesReturnsOnlyDriveFiles) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
const base::FilePath mount_path = GetFakeDriveFs().mount_path();
SetRecentFiles(
profile(),
{
Volume{
.type = fmp::VolumeType::kDownloads,
.files =
{
CreateRecentFile(mount_path.AppendASCII("local.png"),
storage::kFileSystemTypeLocal),
},
},
Volume{
.type = fmp::VolumeType::kDrive,
.files =
{
CreateRecentFile(mount_path.AppendASCII("drive.png"),
storage::kFileSystemTypeDriveFs),
},
},
});
client.GetRecentDriveFileResults(/*max_files=*/100, future.GetCallback());
EXPECT_THAT(
future.Get(),
UnorderedElementsAre(VariantWith<ash::PickerDriveFileResult>(AllOf(
Field("title", &ash::PickerDriveFileResult::title, u"drive.png"),
Field("url", &ash::PickerDriveFileResult::url,
GURL("https://file_alternate_link/drive.png"))))));
}
TEST_F(PickerClientImplTest, GetRecentDriveFilesDoesNotReturnOldFiles) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
SetRecentFiles(
profile(),
{
Volume{
.type = fmp::VolumeType::kDrive,
.files =
{
CreateRecentFile(
GetFakeDriveFs().mount_path().AppendASCII("old.png"),
storage::kFileSystemTypeDriveFs,
base::Time::Now() - base::Days(31)),
},
},
});
client.GetRecentLocalFileResults(/*max_files=*/100, future.GetCallback());
EXPECT_THAT(future.Get(), IsEmpty());
}
TEST_F(PickerClientImplTest, GetRecentLocalFilesTruncates) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
const base::FilePath mount_path = GetFakeDriveFs().mount_path();
SetRecentFiles(
profile(),
{
Volume{
.type = fmp::VolumeType::kDownloads,
.files =
{
CreateRecentFile(mount_path.AppendASCII("1.jpg"),
storage::kFileSystemTypeLocal),
CreateRecentFile(mount_path.AppendASCII("2.jpg"),
storage::kFileSystemTypeLocal),
},
},
});
client.GetRecentLocalFileResults(/*max_files=*/1, future.GetCallback());
EXPECT_THAT(future.Get(), SizeIs(1));
}
TEST_F(PickerClientImplTest, GetRecentDriveFilesTruncates) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
const base::FilePath mount_path = GetFakeDriveFs().mount_path();
SetRecentFiles(
profile(),
{
Volume{
.type = fmp::VolumeType::kDrive,
.files =
{
CreateRecentFile(mount_path.AppendASCII("1"),
storage::kFileSystemTypeDriveFs),
CreateRecentFile(mount_path.AppendASCII("2"),
storage::kFileSystemTypeDriveFs),
},
},
});
client.GetRecentDriveFileResults(/*max_files=*/1, future.GetCallback());
EXPECT_THAT(future.Get(), SizeIs(1));
}
TEST_F(PickerClientImplTest, GetSuggestedLinkResultsReturnsLinks) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
const base::Time now = base::Time::Now();
AddSearchToHistory(profile(), GURL("http://a.com/history"),
now - base::Seconds(1));
AddSearchToHistory(profile(), GURL("http://b.com/history"), now);
TestFaviconService favicon_service;
client.get_link_suggester_for_test()->set_favicon_service_for_test(
&favicon_service);
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
client.GetSuggestedLinkResults(100u, future.GetRepeatingCallback());
EXPECT_THAT(future.Get(),
ElementsAre(VariantWith<ash::PickerBrowsingHistoryResult>(Field(
"url", &ash::PickerBrowsingHistoryResult::url,
GURL("http://b.com/history"))),
VariantWith<ash::PickerBrowsingHistoryResult>(Field(
"url", &ash::PickerBrowsingHistoryResult::url,
GURL("http://a.com/history")))));
EXPECT_EQ(favicon_service.page_url_, GURL("http://a.com/history"));
}
TEST_F(PickerClientImplTest, GetSuggestedLinkResultsAreTruncatedToMostRecent) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
const base::Time now = base::Time::Now();
AddSearchToHistory(profile(), GURL("http://a.com/history"),
now - base::Seconds(1));
AddSearchToHistory(profile(), GURL("http://b.com/history"), now);
TestFaviconService favicon_service;
client.get_link_suggester_for_test()->set_favicon_service_for_test(
&favicon_service);
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
client.GetSuggestedLinkResults(1u, future.GetRepeatingCallback());
EXPECT_THAT(future.Get(),
ElementsAre(VariantWith<ash::PickerBrowsingHistoryResult>(
Field("url", &ash::PickerBrowsingHistoryResult::url,
GURL("http://b.com/history")))));
EXPECT_EQ(favicon_service.page_url_, GURL("http://b.com/history"));
}
class PickerClientImplEditorTest : public PickerClientImplTest {
public:
ash::input_method::EditorMediator& GetEditorMediator(Profile* profile) {
return *ash::input_method::EditorMediatorFactory::GetForProfile(profile);
}
ui::InputMethod& ime() { return ime_; }
protected:
void SetUp() override {
PickerClientImplTest::SetUp();
ash::IMEBridge::Get()->SetInputContextHandler(&ime_);
}
void TearDown() override {
PickerClientImplTest::TearDown();
ash::IMEBridge::Get()->SetInputContextHandler(nullptr);
}
private:
ash::InputMethodAsh ime_{nullptr};
};
TEST_F(PickerClientImplEditorTest,
IsEligibleForEditorReturnsFalseIfEditorDisabled) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kHardBlocked);
EXPECT_FALSE(client.IsEligibleForEditor());
}
TEST_F(PickerClientImplEditorTest,
IsEligibleForEditorReturnsFalseIfHardBlocked) {
base::test::ScopedFeatureList features(chromeos::features::kOrcaDogfood);
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kHardBlocked);
EXPECT_FALSE(client.IsEligibleForEditor());
}
TEST_F(PickerClientImplEditorTest,
IsEligibleForEditorReturnsTrueIfSoftBlocked) {
base::test::ScopedFeatureList features(chromeos::features::kOrcaDogfood);
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kSoftBlocked);
EXPECT_TRUE(client.IsEligibleForEditor());
}
TEST_F(PickerClientImplEditorTest,
CacheEditorContextReturnsNullCallbackWhenEditorFlagDisabled) {
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kHardBlocked);
EXPECT_TRUE(client.CacheEditorContext().is_null());
}
TEST_F(PickerClientImplEditorTest,
CacheEditorContextReturnsNullCallbackWhenBlocked) {
base::test::ScopedFeatureList features(chromeos::features::kOrcaDogfood);
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kSoftBlocked);
EXPECT_TRUE(client.CacheEditorContext().is_null());
}
TEST_F(PickerClientImplEditorTest,
CacheEditorContextReturnsCallbackWhenNotBlocked) {
base::test::ScopedFeatureList features(chromeos::features::kOrcaDogfood);
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kConsentNeeded);
EXPECT_FALSE(client.CacheEditorContext().is_null());
}
TEST_F(PickerClientImplEditorTest, CacheEditorContextCachesCaretBounds) {
base::test::ScopedFeatureList features(chromeos::features::kOrcaDogfood);
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kConsentNeeded);
ui::FakeTextInputClient text_input_client(
&ime(), {
.type = ui::TEXT_INPUT_TYPE_TEXT,
.caret_bounds = gfx::Rect(1, 2, 3, 4),
});
text_input_client.Focus();
client.CacheEditorContext();
EXPECT_EQ(GetEditorMediator(profile())
.mako_bubble_coordinator_for_testing()
.context_caret_bounds_for_testing(),
gfx::Rect(1, 2, 3, 4));
}
TEST_F(PickerClientImplEditorTest, GetSuggestedEditorResults) {
base::test::ScopedFeatureList features(chromeos::features::kOrcaDogfood);
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kRewrite);
ui::FakeTextInputClient text_input_client(&ime(),
{.type = ui::TEXT_INPUT_TYPE_TEXT});
text_input_client.Focus();
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
client.GetSuggestedEditorResults(future.GetCallback());
EXPECT_TRUE(future.Wait());
// TODO: b/331286774 - Add expectation for the suggested editor results once
// EditorServiceConnector is injectable.
}
TEST_F(PickerClientImplEditorTest,
GetSuggestedEditorResultsReturnsNothingWhenBlocked) {
base::test::ScopedFeatureList features(chromeos::features::kOrcaDogfood);
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
GetEditorMediator(profile()).OverrideEditorModeForTesting(
ash::input_method::EditorMode::kSoftBlocked);
ui::FakeTextInputClient text_input_client(&ime(),
{.type = ui::TEXT_INPUT_TYPE_TEXT});
text_input_client.Focus();
base::test::TestFuture<std::vector<ash::PickerSearchResult>> future;
client.GetSuggestedEditorResults(future.GetCallback());
EXPECT_THAT(future.Get(), IsEmpty());
}
TEST_F(PickerClientImplEditorTest, AnnounceSendsLiveRegionChanges) {
base::test::ScopedFeatureList features(chromeos::features::kOrcaDogfood);
ash::PickerController controller;
PickerClientImpl client(&controller, user_manager());
views::test::AXEventCounter counter(views::AXEventManager::Get());
client.Announce(u"hello");
counter.WaitForEvent(ax::mojom::Event::kLiveRegionChanged);
}
// TODO: b/325540366 - Add PickerClientImpl tests.
} // namespace
Codebase Browser
chromium