// Copyright 2022 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/apps/app_service/publishers/plugin_vm_apps.h"
#include <memory>
#include <string>
#include <vector>
#include "base/files/file_util.h"
#include "base/memory/raw_ptr.h"
#include "base/strings/escape.h"
#include "base/test/bind.h"
#include "chrome/browser/apps/app_service/app_service_proxy.h"
#include "chrome/browser/apps/app_service/app_service_proxy_factory.h"
#include "chrome/browser/apps/app_service/launch_result_type.h"
#include "chrome/browser/ash/file_manager/path_util.h"
#include "chrome/browser/ash/plugin_vm/mock_plugin_vm_manager.h"
#include "chrome/browser/ash/plugin_vm/plugin_vm_manager_factory.h"
#include "chrome/browser/ash/plugin_vm/plugin_vm_test_helper.h"
#include "chrome/browser/ash/profiles/profile_helper.h"
#include "chrome/browser/web_applications/test/web_app_install_test_utils.h"
#include "chrome/test/base/testing_profile.h"
#include "chrome/test/base/testing_profile_manager.h"
#include "chromeos/ash/components/dbus/chunneld/chunneld_client.h"
#include "chromeos/ash/components/dbus/cicerone/fake_cicerone_client.h"
#include "chromeos/ash/components/dbus/seneschal/seneschal_client.h"
#include "components/services/app_service/public/cpp/app_registry_cache.h"
#include "components/services/app_service/public/cpp/intent_util.h"
#include "content/public/test/browser_task_environment.h"
#include "storage/browser/file_system/external_mount_points.h"
#include "storage/browser/file_system/file_system_url.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace apps {
using MockPluginVmManager =
testing::StrictMock<plugin_vm::test::MockPluginVmManager>;
class PluginVmAppsTest : public testing::Test {
public:
PluginVmAppsTest()
: task_environment_(content::BrowserTaskEnvironment::REAL_IO_THREAD) {}
plugin_vm::PluginVmTestHelper* test_helper() { return test_helper_.get(); }
AppServiceProxy* app_service_proxy() { return app_service_proxy_; }
TestingProfile* profile() { return profile_.get(); }
MockPluginVmManager* plugin_vm_manager() { return plugin_vm_manager_; }
void SetUp() override {
profile_ = std::make_unique<TestingProfile>();
app_service_proxy_ = AppServiceProxyFactory::GetForProfile(profile_.get());
web_app::test::AwaitStartWebAppProviderAndSubsystems(profile_.get());
test_helper_ =
std::make_unique<plugin_vm::PluginVmTestHelper>(profile_.get());
test_helper_->AllowPluginVm();
test_helper_->EnablePluginVm();
mount_points_ = storage::ExternalMountPoints::GetSystemInstance();
mount_name_ =
file_manager::util::GetDownloadsMountPointName(profile_.get());
mount_points_->RegisterFileSystem(
mount_name_, storage::kFileSystemTypeLocal,
storage::FileSystemMountOption(), GetMyFilesFolderPath());
plugin_vm_manager_ = static_cast<MockPluginVmManager*>(
plugin_vm::PluginVmManagerFactory::GetInstance()
->SetTestingFactoryAndUse(
profile_.get(),
base::BindRepeating([](content::BrowserContext*)
-> std::unique_ptr<KeyedService> {
return std::make_unique<MockPluginVmManager>();
})));
}
void TearDown() override {
base::DeletePathRecursively(GetPvmDefaultPath());
mount_points_->RevokeAllFileSystems();
test_helper_.reset();
profile_.reset();
}
base::FilePath GetMyFilesFolderPath() {
return file_manager::util::GetMyFilesFolderForProfile(profile_.get());
}
base::FilePath GetPvmDefaultPath() {
return GetMyFilesFolderPath().Append("PvmDefault");
}
storage::FileSystemURL GetMyFilesFileSystemURL(const std::string& path) {
return mount_points_->CreateExternalFileSystemURL(
blink::StorageKey::CreateFirstParty(
file_manager::util::GetFilesAppOrigin()),
mount_name_, base::FilePath(path));
}
// Set up the test PluginVm app for our desired mime types.
std::string AddPluginVmAppWithExtensionTypes(
std::string app_id,
std::vector<std::string> extension_types) {
vm_tools::apps::App app;
for (std::string extension_type : extension_types) {
app.add_extensions(extension_type);
}
app.set_desktop_file_id(app_id);
vm_tools::apps::App::LocaleString::Entry* entry =
app.mutable_name()->add_values();
entry->set_locale(std::string());
entry->set_value(app_id);
test_helper()->AddApp(app);
return plugin_vm::PluginVmTestHelper::GenerateAppId(app.desktop_file_id());
}
// Get the registered intent filters for the app in App Service.
std::vector<std::unique_ptr<IntentFilter>> GetIntentFiltersForApp(
std::string app_id) {
std::vector<std::unique_ptr<IntentFilter>> intent_filters;
app_service_proxy()->AppRegistryCache().ForOneApp(
app_id, [&intent_filters](const AppUpdate& update) {
intent_filters = update.IntentFilters();
});
return intent_filters;
}
private:
struct ScopedDBusClients {
ScopedDBusClients() {
ash::CiceroneClient::InitializeFake();
ash::ConciergeClient::InitializeFake();
ash::SeneschalClient::InitializeFake();
ash::ChunneldClient::InitializeFake();
}
~ScopedDBusClients() {
ash::ChunneldClient::Shutdown();
ash::SeneschalClient::Shutdown();
ash::ConciergeClient::Shutdown();
ash::CiceroneClient::Shutdown();
}
} dbus_clients_;
raw_ptr<AppServiceProxy, DanglingUntriaged> app_service_proxy_ = nullptr;
content::BrowserTaskEnvironment task_environment_;
std::unique_ptr<TestingProfile> profile_;
std::unique_ptr<plugin_vm::PluginVmTestHelper> test_helper_;
raw_ptr<storage::ExternalMountPoints> mount_points_;
std::string mount_name_;
raw_ptr<MockPluginVmManager, DanglingUntriaged> plugin_vm_manager_;
};
TEST_F(PluginVmAppsTest, AppServiceHasPluginVmIntentFilters) {
std::vector<std::string> extension_types = {"csv", "txt"};
std::string app_id =
AddPluginVmAppWithExtensionTypes("app_id", extension_types);
std::vector<std::unique_ptr<IntentFilter>> intent_filters =
GetIntentFiltersForApp(app_id);
EXPECT_EQ(intent_filters.size(), 1U);
EXPECT_EQ(intent_filters[0]->conditions.size(), 2U);
// Check that the filter has the correct action type.
{
const Condition* condition = intent_filters[0]->conditions[0].get();
ASSERT_EQ(condition->condition_type, ConditionType::kAction);
EXPECT_EQ(condition->condition_values.size(), 1U);
ASSERT_EQ(condition->condition_values[0]->match_type,
PatternMatchType::kLiteral);
ASSERT_EQ(condition->condition_values[0]->value,
apps_util::kIntentActionView);
}
// Check that the filter has all our extension types.
{
const Condition* condition = intent_filters[0]->conditions[1].get();
ASSERT_EQ(condition->condition_type, ConditionType::kFile);
EXPECT_EQ(condition->condition_values.size(), 2U);
ASSERT_EQ(condition->condition_values[0]->value, extension_types[0]);
ASSERT_EQ(condition->condition_values[1]->value, extension_types[1]);
}
}
TEST_F(PluginVmAppsTest, LaunchAppWithIntent) {
std::string app_id = AddPluginVmAppWithExtensionTypes("app_id", {"txt"});
apps::IntentPtr intent =
std::make_unique<apps::Intent>(apps_util::kIntentActionView);
std::vector<apps::IntentFilePtr> files;
// Add a file in the PvmDefault directory so that PluginVm has access to it.
files.push_back(std::make_unique<apps::IntentFile>(
GetMyFilesFileSystemURL("PvmDefault/file").ToGURL()));
intent->files = {std::move(files)};
// Retrieve the callback object when we reach the end of LaunchPluginVmApp().
plugin_vm::PluginVmManager::LaunchPluginVmCallback launch_plugin_vm_callback;
EXPECT_CALL(*plugin_vm_manager(), LaunchPluginVm(testing::_))
.WillOnce(testing::Invoke(
[&](plugin_vm::PluginVmManager::LaunchPluginVmCallback callback) {
EXPECT_TRUE(launch_plugin_vm_callback.is_null());
launch_plugin_vm_callback = std::move(callback);
}));
app_service_proxy()->LaunchAppWithIntent(
app_id, /*event_flags=*/0, std::move(intent), LaunchSource::kUnknown,
std::unique_ptr<WindowInfo>(), base::DoNothing());
// Check that the callback is not null, i.e. that we reached the end of
// LaunchPluginVmApp(). Getting to this point confirms that the arguments we
// took from LaunchAppWithIntent were converted successfully for
// LaunchPluginVmApp() to pass the validity checks inside LaunchPluginVmApp().
ASSERT_FALSE(launch_plugin_vm_callback.is_null());
}
TEST_F(PluginVmAppsTest, LaunchAppWithIntent_FailedDirectoryNotShared) {
std::string app_id = AddPluginVmAppWithExtensionTypes("app_id", {"txt"});
apps::IntentPtr intent =
std::make_unique<apps::Intent>(apps_util::kIntentActionView);
std::vector<apps::IntentFilePtr> files;
// Add a file in the downloads directory so that PluginVm does NOT have access
// to it.
files.push_back(std::make_unique<apps::IntentFile>(
GetMyFilesFileSystemURL("Downloads/file").ToGURL()));
intent->files = {std::move(files)};
std::optional<State> result_state;
app_service_proxy()->LaunchAppWithIntent(
app_id, /*event_flags=*/0, std::move(intent), LaunchSource::kUnknown,
std::unique_ptr<WindowInfo>(),
base::BindLambdaForTesting(
[&result_state](apps::LaunchResult&& callback_result) {
result_state = callback_result.state;
}));
ASSERT_EQ(result_state.value_or(apps::State::kSuccess),
apps::State::kFailedDirectoryNotShared);
}
} // namespace apps
Codebase Browser
chromium