blob: 84dde5b56347795b45ad9206613a8e5c384ae7ba [file] [log] [blame]
// Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "services/ws/window_service.h"
#include <memory>
#include "base/run_loop.h"
#include "services/service_manager/public/cpp/connector.h"
#include "services/service_manager/public/cpp/test/test_connector_factory.h"
#include "services/ws/public/cpp/host/gpu_interface_provider.h"
#include "services/ws/public/mojom/constants.mojom.h"
#include "services/ws/public/mojom/window_tree.mojom.h"
#include "services/ws/test_wm.mojom.h"
#include "services/ws/window_manager_interface.h"
#include "services/ws/window_service_test_setup.h"
#include "services/ws/window_tree.h"
#include "services/ws/window_tree_test_helper.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ws {
namespace {
// Used as callback from ScheduleEmbed().
void ScheduleEmbedCallback(base::UnguessableToken* result_token,
const base::UnguessableToken& actual_token) {
*result_token = actual_token;
}
} // namespace
TEST(WindowServiceTest, DeleteWithClients) {
// Use |test_setup| to configure aura and other state.
WindowServiceTestSetup test_setup;
// Create another WindowService.
TestWindowServiceDelegate test_window_service_delegate;
std::unique_ptr<WindowService> window_service_ptr =
std::make_unique<WindowService>(&test_window_service_delegate, nullptr,
test_setup.focus_controller());
WindowService* window_service = window_service_ptr.get();
std::unique_ptr<service_manager::TestConnectorFactory> factory =
service_manager::TestConnectorFactory::CreateForUniqueService(
std::move(window_service_ptr));
std::unique_ptr<service_manager::Connector> connector =
factory->CreateConnector();
// Connect to |window_service| and ask for a new WindowTree.
mojom::WindowTreeFactoryPtr window_tree_factory;
connector->BindInterface(mojom::kServiceName, &window_tree_factory);
mojom::WindowTreePtr window_tree;
mojom::WindowTreeClientPtr client;
mojom::WindowTreeClientRequest client_request = MakeRequest(&client);
window_tree_factory->CreateWindowTree(MakeRequest(&window_tree),
std::move(client));
// Use FlushForTesting() to ensure WindowService processes the request.
window_tree_factory.FlushForTesting();
// There should be at least one WindowTree.
EXPECT_FALSE(window_service->window_trees().empty());
// Destroying the |window_service| should remove all the WindowTrees and
// ensure a DCHECK isn't hit in ~WindowTree.
}
// Implementation of mojom::TestWm that sets a boolean when DoIt() is called.
class TestWm : public WindowManagerInterface, public test::mojom::TestWm {
public:
TestWm(mojo::ScopedInterfaceEndpointHandle handle, bool* do_it_called)
: binding_(this,
mojo::AssociatedInterfaceRequest<test::mojom::TestWm>(
std::move(handle))),
do_it_called_(do_it_called) {}
// test::mojom::TestWm:
void DoIt() override { *do_it_called_ = true; }
private:
mojo::AssociatedBinding<test::mojom::TestWm> binding_;
bool* do_it_called_;
DISALLOW_COPY_AND_ASSIGN(TestWm);
};
// Subclass os TestWindowServiceDelegate that creates TestWm.
class TestWindowServiceDelegateWithInterface
: public TestWindowServiceDelegate {
public:
TestWindowServiceDelegateWithInterface() = default;
~TestWindowServiceDelegateWithInterface() override = default;
bool do_it_called() const { return do_it_called_; }
// TestWindowServiceDelegate:
std::unique_ptr<WindowManagerInterface> CreateWindowManagerInterface(
WindowTree* window_tree,
const std::string& name,
mojo::ScopedInterfaceEndpointHandle handle) override {
if (name != test::mojom::TestWm::Name_)
return nullptr;
return std::make_unique<TestWm>(std::move(handle), &do_it_called_);
}
private:
bool do_it_called_ = false;
DISALLOW_COPY_AND_ASSIGN(TestWindowServiceDelegateWithInterface);
};
TEST(WindowServiceTest, GetWindowManagerInterface) {
// Use |test_setup| to configure aura and other state.
WindowServiceTestSetup test_setup;
// Create another WindowService.
TestWindowServiceDelegateWithInterface test_window_service_delegate;
std::unique_ptr<WindowService> window_service_ptr =
std::make_unique<WindowService>(&test_window_service_delegate, nullptr,
test_setup.focus_controller());
std::unique_ptr<service_manager::TestConnectorFactory> factory =
service_manager::TestConnectorFactory::CreateForUniqueService(
std::move(window_service_ptr));
std::unique_ptr<service_manager::Connector> connector =
factory->CreateConnector();
// Connect to |window_service| and ask for a new WindowTree.
mojom::WindowTreeFactoryPtr window_tree_factory;
connector->BindInterface(mojom::kServiceName, &window_tree_factory);
mojom::WindowTreePtr window_tree;
mojom::WindowTreeClientPtr client;
mojom::WindowTreeClientRequest client_request = MakeRequest(&client);
window_tree_factory->CreateWindowTree(MakeRequest(&window_tree),
std::move(client));
// Request the TestWm interface and call a function on it.
mojom::WindowManagerAssociatedPtr wm;
window_tree->BindWindowManagerInterface(test::mojom::TestWm::Name_,
MakeRequest(&wm));
test::mojom::TestWmAssociatedPtr test_wm(
mojo::AssociatedInterfacePtrInfo<test::mojom::TestWm>(
wm.PassInterface().PassHandle(), test::mojom::TestWm::Version_));
test_wm->DoIt();
test_wm.FlushForTesting();
EXPECT_TRUE(test_window_service_delegate.do_it_called());
}
// Test client ids assigned to window trees that connect to the window service.
TEST(WindowServiceTest, ClientIds) {
// Use |test_setup| to configure aura and other state.
WindowServiceTestSetup test_setup;
// Create another WindowService.
TestWindowServiceDelegate test_window_service_delegate;
WindowService window_service(&test_window_service_delegate, nullptr,
test_setup.focus_controller());
// The first window tree should have the initial client id.
auto tree = window_service.CreateWindowTree(nullptr);
EXPECT_EQ(kInitialClientId, WindowTreeTestHelper(tree.get()).client_id());
// The second window tree should have an incremented client id.
tree = window_service.CreateWindowTree(nullptr);
EXPECT_EQ(kInitialClientId + 1, WindowTreeTestHelper(tree.get()).client_id());
}
// Test client ids assigned to window trees in the decrementing mode.
TEST(WindowServiceTest, ClientIdsDecrement) {
// Use |test_setup| to configure aura and other state.
WindowServiceTestSetup test_setup;
// Create another WindowService that decrements window ids.
const bool decrement = true;
TestWindowServiceDelegate test_window_service_delegate;
WindowService window_service(&test_window_service_delegate, nullptr,
test_setup.focus_controller(), decrement);
// The first window tree should have the initial decrementing client id.
auto tree = window_service.CreateWindowTree(nullptr);
EXPECT_EQ(kInitialClientIdDecrement,
WindowTreeTestHelper(tree.get()).client_id());
// The second window tree should have a decremented client id.
tree = window_service.CreateWindowTree(nullptr);
EXPECT_EQ(kInitialClientIdDecrement - 1,
WindowTreeTestHelper(tree.get()).client_id());
}
TEST(WindowServiceTest, ScheduleEmbedForExistingClientUsingLocalWindow) {
WindowServiceTestSetup setup;
// Schedule an embed in the tree created by |setup|.
base::UnguessableToken token;
const uint32_t window_id_in_child = 149;
setup.window_tree_test_helper()
->window_tree()
->ScheduleEmbedForExistingClient(
window_id_in_child, base::BindOnce(&ScheduleEmbedCallback, &token));
EXPECT_FALSE(token.is_empty());
// Create a window that will serve as the parent for the remote window and
// complete the embedding.
std::unique_ptr<aura::Window> local_window =
std::make_unique<aura::Window>(nullptr);
local_window->Init(ui::LAYER_NOT_DRAWN);
ASSERT_TRUE(setup.service()->CompleteScheduleEmbedForExistingClient(
local_window.get(), token, /* embed_flags */ 0));
EXPECT_TRUE(WindowService::HasRemoteClient(local_window.get()));
}
TEST(WindowServiceTest,
ScheduleEmbedForExistingClientUsingLocalWindowResetOnTreeDeleted) {
WindowServiceTestSetup setup;
TestWindowTreeClient window_tree_client2;
std::unique_ptr<WindowTree> window_tree2 =
setup.service()->CreateWindowTree(&window_tree_client2);
window_tree2->InitFromFactory();
// Schedule an embed in |window_tree2|.
base::UnguessableToken token;
const uint32_t window_id_in_child = 212;
WindowTreeTestHelper(window_tree2.get())
.window_tree()
->ScheduleEmbedForExistingClient(
window_id_in_child, base::BindOnce(&ScheduleEmbedCallback, &token));
EXPECT_FALSE(token.is_empty());
// Create a window that will serve as the parent for the remote window and
// complete the embedding.
std::unique_ptr<aura::Window> local_window =
std::make_unique<aura::Window>(nullptr);
local_window->Init(ui::LAYER_NOT_DRAWN);
ASSERT_TRUE(setup.service()->CompleteScheduleEmbedForExistingClient(
local_window.get(), token, /* embed_flags */ 0));
EXPECT_TRUE(WindowService::HasRemoteClient(local_window.get()));
// Deleting |window_tree2| should remove the remote client.
window_tree2.reset();
EXPECT_FALSE(WindowService::HasRemoteClient(local_window.get()));
}
} // namespace ws