blob: c088331de68465d076798738e78d24cd07d5a380 [file] [log] [blame]
// Copyright 2016 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/ui/ws/test_utils.h"
#include <utility>
#include "base/memory/ptr_util.h"
#include "cc/output/copy_output_request.h"
#include "gpu/ipc/client/gpu_channel_host.h"
#include "services/shell/public/interfaces/connector.mojom.h"
#include "services/ui/surfaces/surfaces_state.h"
#include "services/ui/ws/display_binding.h"
#include "services/ui/ws/display_manager.h"
#include "services/ui/ws/platform_display_init_params.h"
#include "services/ui/ws/server_window_surface_manager_test_api.h"
#include "services/ui/ws/window_manager_access_policy.h"
#include "services/ui/ws/window_manager_window_tree_factory.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace ui {
namespace ws {
namespace test {
namespace {
// -----------------------------------------------------------------------------
// Empty implementation of PlatformDisplay.
class TestPlatformDisplay : public PlatformDisplay {
public:
explicit TestPlatformDisplay(int64_t id,
bool is_primary,
int32_t* cursor_id_storage)
: id_(id),
is_primary_(is_primary),
cursor_id_storage_(cursor_id_storage) {
display_metrics_.bounds = gfx::Rect(0, 0, 400, 300);
display_metrics_.device_scale_factor = 1.f;
}
~TestPlatformDisplay() override {}
// PlatformDisplay:
void Init(PlatformDisplayDelegate* delegate) override {
// It is necessary to tell the delegate about the ViewportMetrics to make
// sure that the DisplayBinding is correctly initialized (and a root-window
// is created).
delegate->OnViewportMetricsChanged(ViewportMetrics(), display_metrics_);
}
int64_t GetId() const override { return id_; }
void SchedulePaint(const ServerWindow* window,
const gfx::Rect& bounds) override {}
void SetViewportSize(const gfx::Size& size) override {}
void SetTitle(const base::string16& title) override {}
void SetCapture() override {}
void ReleaseCapture() override {}
void SetCursorById(int32_t cursor) override { *cursor_id_storage_ = cursor; }
display::Display::Rotation GetRotation() override {
return display::Display::Rotation::ROTATE_0;
}
float GetDeviceScaleFactor() override {
return display_metrics_.device_scale_factor;
}
void UpdateTextInputState(const ui::TextInputState& state) override {}
void SetImeVisibility(bool visible) override {}
bool IsFramePending() const override { return false; }
void RequestCopyOfOutput(
std::unique_ptr<cc::CopyOutputRequest> output_request) override {}
gfx::Rect GetBounds() const override { return display_metrics_.bounds; }
bool IsPrimaryDisplay() const override { return is_primary_; }
void OnGpuChannelEstablished(
scoped_refptr<gpu::GpuChannelHost> host) override {}
private:
ViewportMetrics display_metrics_;
int64_t id_;
bool is_primary_;
int32_t* cursor_id_storage_;
DISALLOW_COPY_AND_ASSIGN(TestPlatformDisplay);
};
ClientWindowId NextUnusedClientWindowId(WindowTree* tree) {
ClientWindowId client_id;
for (ClientSpecificId id = 1;; ++id) {
// Used the id of the client in the upper bits to simplify things.
const ClientWindowId client_id =
ClientWindowId(WindowIdToTransportId(WindowId(tree->id(), id)));
if (!tree->GetWindowByClientId(client_id))
return client_id;
}
}
} // namespace
// WindowManagerWindowTreeFactorySetTestApi ------------------------------------
WindowManagerWindowTreeFactorySetTestApi::
WindowManagerWindowTreeFactorySetTestApi(
WindowManagerWindowTreeFactorySet*
window_manager_window_tree_factory_set)
: window_manager_window_tree_factory_set_(
window_manager_window_tree_factory_set) {}
WindowManagerWindowTreeFactorySetTestApi::
~WindowManagerWindowTreeFactorySetTestApi() {}
void WindowManagerWindowTreeFactorySetTestApi::Add(const UserId& user_id) {
WindowManagerWindowTreeFactory* factory =
window_manager_window_tree_factory_set_->Add(user_id, nullptr);
factory->CreateWindowTree(nullptr, nullptr);
}
// TestPlatformDisplayFactory -------------------------------------------------
const int64_t TestPlatformDisplayFactory::kFirstDisplayId = 1;
TestPlatformDisplayFactory::TestPlatformDisplayFactory(
int32_t* cursor_id_storage)
: cursor_id_storage_(cursor_id_storage),
next_display_id_(kFirstDisplayId) {}
TestPlatformDisplayFactory::~TestPlatformDisplayFactory() {}
PlatformDisplay* TestPlatformDisplayFactory::CreatePlatformDisplay() {
bool is_primary = (next_display_id_ == kFirstDisplayId);
return new TestPlatformDisplay(next_display_id_++, is_primary,
cursor_id_storage_);
}
// TestFrameGeneratorDelegate -------------------------------------------------
TestFrameGeneratorDelegate::TestFrameGeneratorDelegate(
std::unique_ptr<ServerWindow> root)
: root_(std::move(root)) {}
TestFrameGeneratorDelegate::~TestFrameGeneratorDelegate() {}
ServerWindow* TestFrameGeneratorDelegate::GetRootWindow() {
return root_.get();
}
bool TestFrameGeneratorDelegate::IsInHighContrastMode() {
return false;
}
const ViewportMetrics& TestFrameGeneratorDelegate::GetViewportMetrics() {
return metrics_;
}
// WindowTreeTestApi ---------------------------------------------------------
WindowTreeTestApi::WindowTreeTestApi(WindowTree* tree) : tree_(tree) {}
WindowTreeTestApi::~WindowTreeTestApi() {}
void WindowTreeTestApi::StartPointerWatcher(bool want_moves) {
tree_->StartPointerWatcher(want_moves);
}
void WindowTreeTestApi::StopPointerWatcher() {
tree_->StopPointerWatcher();
}
// DisplayTestApi ------------------------------------------------------------
DisplayTestApi::DisplayTestApi(Display* display) : display_(display) {}
DisplayTestApi::~DisplayTestApi() {}
// EventDispatcherTestApi ----------------------------------------------------
bool EventDispatcherTestApi::IsWindowPointerTarget(
const ServerWindow* window) const {
for (const auto& pair : ed_->pointer_targets_) {
if (pair.second.window == window)
return true;
}
return false;
}
int EventDispatcherTestApi::NumberPointerTargetsForWindow(
ServerWindow* window) {
int count = 0;
for (const auto& pair : ed_->pointer_targets_)
if (pair.second.window == window)
count++;
return count;
}
// TestDisplayBinding ---------------------------------------------------------
WindowTree* TestDisplayBinding::CreateWindowTree(ServerWindow* root) {
const uint32_t embed_flags = 0;
WindowTree* tree = window_server_->EmbedAtWindow(
root, shell::mojom::kRootUserID, ui::mojom::WindowTreeClientPtr(),
embed_flags, base::WrapUnique(new WindowManagerAccessPolicy));
tree->ConfigureWindowManager();
return tree;
}
// TestWindowManager ----------------------------------------------------------
void TestWindowManager::WmCreateTopLevelWindow(
uint32_t change_id,
ClientSpecificId requesting_client_id,
mojo::Map<mojo::String, mojo::Array<uint8_t>> properties) {
got_create_top_level_window_ = true;
change_id_ = change_id;
}
void TestWindowManager::WmClientJankinessChanged(ClientSpecificId client_id,
bool janky) {}
void TestWindowManager::WmPerformMoveLoop(uint32_t change_id,
uint32_t window_id,
mojom::MoveLoopSource source,
const gfx::Point& cursor_location) {
on_perform_move_loop_called_ = true;
}
void TestWindowManager::WmCancelMoveLoop(uint32_t window_id) {}
void TestWindowManager::OnAccelerator(uint32_t ack_id,
uint32_t accelerator_id,
std::unique_ptr<ui::Event> event) {
on_accelerator_called_ = true;
on_accelerator_id_ = accelerator_id;
}
// TestWindowTreeClient -------------------------------------------------------
TestWindowTreeClient::TestWindowTreeClient()
: binding_(this), record_on_change_completed_(false) {}
TestWindowTreeClient::~TestWindowTreeClient() {}
void TestWindowTreeClient::Bind(
mojo::InterfaceRequest<mojom::WindowTreeClient> request) {
binding_.Bind(std::move(request));
}
void TestWindowTreeClient::OnEmbed(uint16_t client_id,
mojom::WindowDataPtr root,
ui::mojom::WindowTreePtr tree,
int64_t display_id,
Id focused_window_id,
bool drawn) {
// TODO(sky): add test coverage of |focused_window_id|.
tracker_.OnEmbed(client_id, std::move(root), drawn);
}
void TestWindowTreeClient::OnEmbeddedAppDisconnected(uint32_t window) {
tracker_.OnEmbeddedAppDisconnected(window);
}
void TestWindowTreeClient::OnUnembed(Id window_id) {
tracker_.OnUnembed(window_id);
}
void TestWindowTreeClient::OnCaptureChanged(Id new_capture_window_id,
Id old_capture_window_id) {
tracker_.OnCaptureChanged(new_capture_window_id, old_capture_window_id);
}
void TestWindowTreeClient::OnTopLevelCreated(uint32_t change_id,
mojom::WindowDataPtr data,
int64_t display_id,
bool drawn) {
tracker_.OnTopLevelCreated(change_id, std::move(data), drawn);
}
void TestWindowTreeClient::OnWindowBoundsChanged(uint32_t window,
const gfx::Rect& old_bounds,
const gfx::Rect& new_bounds) {
tracker_.OnWindowBoundsChanged(window, std::move(old_bounds),
std::move(new_bounds));
}
void TestWindowTreeClient::OnClientAreaChanged(
uint32_t window_id,
const gfx::Insets& new_client_area,
mojo::Array<gfx::Rect> new_additional_client_areas) {}
void TestWindowTreeClient::OnTransientWindowAdded(
uint32_t window_id,
uint32_t transient_window_id) {}
void TestWindowTreeClient::OnTransientWindowRemoved(
uint32_t window_id,
uint32_t transient_window_id) {}
void TestWindowTreeClient::OnWindowHierarchyChanged(
uint32_t window,
uint32_t old_parent,
uint32_t new_parent,
mojo::Array<mojom::WindowDataPtr> windows) {
tracker_.OnWindowHierarchyChanged(window, old_parent, new_parent,
std::move(windows));
}
void TestWindowTreeClient::OnWindowReordered(uint32_t window_id,
uint32_t relative_window_id,
mojom::OrderDirection direction) {
tracker_.OnWindowReordered(window_id, relative_window_id, direction);
}
void TestWindowTreeClient::OnWindowDeleted(uint32_t window) {
tracker_.OnWindowDeleted(window);
}
void TestWindowTreeClient::OnWindowVisibilityChanged(uint32_t window,
bool visible) {
tracker_.OnWindowVisibilityChanged(window, visible);
}
void TestWindowTreeClient::OnWindowOpacityChanged(uint32_t window,
float old_opacity,
float new_opacity) {
tracker_.OnWindowOpacityChanged(window, new_opacity);
}
void TestWindowTreeClient::OnWindowParentDrawnStateChanged(uint32_t window,
bool drawn) {
tracker_.OnWindowParentDrawnStateChanged(window, drawn);
}
void TestWindowTreeClient::OnWindowSharedPropertyChanged(
uint32_t window,
const mojo::String& name,
mojo::Array<uint8_t> new_data) {
tracker_.OnWindowSharedPropertyChanged(window, name, std::move(new_data));
}
void TestWindowTreeClient::OnWindowInputEvent(uint32_t event_id,
uint32_t window,
std::unique_ptr<ui::Event> event,
bool matches_pointer_watcher) {
tracker_.OnWindowInputEvent(window, *event.get(), matches_pointer_watcher);
}
void TestWindowTreeClient::OnPointerEventObserved(
std::unique_ptr<ui::Event> event,
uint32_t window_id) {
tracker_.OnPointerEventObserved(*event.get(), window_id);
}
void TestWindowTreeClient::OnWindowFocused(uint32_t focused_window_id) {
tracker_.OnWindowFocused(focused_window_id);
}
void TestWindowTreeClient::OnWindowPredefinedCursorChanged(
uint32_t window_id,
mojom::Cursor cursor_id) {
tracker_.OnWindowPredefinedCursorChanged(window_id, cursor_id);
}
void TestWindowTreeClient::OnChangeCompleted(uint32_t change_id, bool success) {
if (record_on_change_completed_)
tracker_.OnChangeCompleted(change_id, success);
}
void TestWindowTreeClient::RequestClose(uint32_t window_id) {}
void TestWindowTreeClient::GetWindowManager(
mojo::AssociatedInterfaceRequest<mojom::WindowManager> internal) {}
// TestWindowTreeBinding ------------------------------------------------------
TestWindowTreeBinding::TestWindowTreeBinding(WindowTree* tree)
: WindowTreeBinding(&client_), tree_(tree) {}
TestWindowTreeBinding::~TestWindowTreeBinding() {}
mojom::WindowManager* TestWindowTreeBinding::GetWindowManager() {
if (!window_manager_.get())
window_manager_.reset(new TestWindowManager);
return window_manager_.get();
}
void TestWindowTreeBinding::SetIncomingMethodCallProcessingPaused(bool paused) {
is_paused_ = paused;
}
// TestWindowServerDelegate ----------------------------------------------
TestWindowServerDelegate::TestWindowServerDelegate() {}
TestWindowServerDelegate::~TestWindowServerDelegate() {}
Display* TestWindowServerDelegate::AddDisplay() {
// Display manages its own lifetime.
Display* display = new Display(window_server_, PlatformDisplayInitParams());
display->Init(nullptr);
return display;
}
void TestWindowServerDelegate::OnNoMoreDisplays() {
got_on_no_more_displays_ = true;
}
std::unique_ptr<WindowTreeBinding>
TestWindowServerDelegate::CreateWindowTreeBinding(
BindingType type,
ws::WindowServer* window_server,
ws::WindowTree* tree,
mojom::WindowTreeRequest* tree_request,
mojom::WindowTreeClientPtr* client) {
std::unique_ptr<TestWindowTreeBinding> binding(
new TestWindowTreeBinding(tree));
bindings_.push_back(binding.get());
return std::move(binding);
}
void TestWindowServerDelegate::CreateDefaultDisplays() {
DCHECK(num_displays_to_create_);
DCHECK(window_server_);
for (int i = 0; i < num_displays_to_create_; ++i)
AddDisplay();
}
bool TestWindowServerDelegate::IsTestConfig() const {
return true;
}
// WindowEventTargetingHelper ------------------------------------------------
WindowEventTargetingHelper::WindowEventTargetingHelper()
: wm_client_(nullptr),
cursor_id_(0),
platform_display_factory_(&cursor_id_),
display_binding_(nullptr),
display_(nullptr),
surfaces_state_(new SurfacesState()),
window_server_(nullptr) {
PlatformDisplay::set_factory_for_testing(&platform_display_factory_);
window_server_.reset(new WindowServer(&window_server_delegate_));
PlatformDisplayInitParams display_init_params;
display_init_params.surfaces_state = surfaces_state_;
display_ = new Display(window_server_.get(), display_init_params);
display_binding_ = new TestDisplayBinding(window_server_.get());
display_->Init(base::WrapUnique(display_binding_));
wm_client_ = window_server_delegate_.last_client();
wm_client_->tracker()->changes()->clear();
}
WindowEventTargetingHelper::~WindowEventTargetingHelper() {}
ServerWindow* WindowEventTargetingHelper::CreatePrimaryTree(
const gfx::Rect& root_window_bounds,
const gfx::Rect& window_bounds) {
WindowTree* wm_tree = window_server_->GetTreeWithId(1);
const ClientWindowId embed_window_id(
WindowIdToTransportId(WindowId(wm_tree->id(), 1)));
EXPECT_TRUE(wm_tree->NewWindow(embed_window_id, ServerWindow::Properties()));
EXPECT_TRUE(wm_tree->SetWindowVisibility(embed_window_id, true));
EXPECT_TRUE(wm_tree->AddWindow(FirstRootId(wm_tree), embed_window_id));
display_->root_window()->SetBounds(root_window_bounds);
mojom::WindowTreeClientPtr client;
mojom::WindowTreeClientRequest client_request = GetProxy(&client);
wm_client_->Bind(std::move(client_request));
const uint32_t embed_flags = 0;
wm_tree->Embed(embed_window_id, std::move(client), embed_flags);
ServerWindow* embed_window = wm_tree->GetWindowByClientId(embed_window_id);
WindowTree* tree1 = window_server_->GetTreeWithRoot(embed_window);
EXPECT_NE(nullptr, tree1);
EXPECT_NE(tree1, wm_tree);
WindowTreeTestApi(tree1).set_user_id(wm_tree->user_id());
embed_window->SetBounds(window_bounds);
return embed_window;
}
void WindowEventTargetingHelper::CreateSecondaryTree(
ServerWindow* embed_window,
const gfx::Rect& window_bounds,
TestWindowTreeClient** out_client,
WindowTree** window_tree,
ServerWindow** window) {
WindowTree* tree1 = window_server_->GetTreeWithRoot(embed_window);
ASSERT_TRUE(tree1 != nullptr);
const ClientWindowId child1_id(
WindowIdToTransportId(WindowId(tree1->id(), 1)));
EXPECT_TRUE(tree1->NewWindow(child1_id, ServerWindow::Properties()));
ServerWindow* child1 = tree1->GetWindowByClientId(child1_id);
ASSERT_TRUE(child1);
EXPECT_TRUE(tree1->AddWindow(ClientWindowIdForWindow(tree1, embed_window),
child1_id));
tree1->GetDisplay(embed_window)->AddActivationParent(embed_window);
child1->SetVisible(true);
child1->SetBounds(window_bounds);
EnableHitTest(child1);
TestWindowTreeClient* embed_client =
window_server_delegate_.last_client();
embed_client->tracker()->changes()->clear();
wm_client_->tracker()->changes()->clear();
*out_client = embed_client;
*window_tree = tree1;
*window = child1;
}
void WindowEventTargetingHelper::SetTaskRunner(
scoped_refptr<base::SingleThreadTaskRunner> task_runner) {
message_loop_.SetTaskRunner(task_runner);
}
// ----------------------------------------------------------------------------
ServerWindow* FirstRoot(WindowTree* tree) {
return tree->roots().size() == 1u
? tree->GetWindow((*tree->roots().begin())->id())
: nullptr;
}
ClientWindowId FirstRootId(WindowTree* tree) {
ServerWindow* first_root = FirstRoot(tree);
return first_root ? ClientWindowIdForWindow(tree, first_root)
: ClientWindowId();
}
ClientWindowId ClientWindowIdForWindow(WindowTree* tree,
const ServerWindow* window) {
ClientWindowId client_window_id;
// If window isn't known we'll return 0, which should then error out.
tree->IsWindowKnown(window, &client_window_id);
return client_window_id;
}
ServerWindow* NewWindowInTree(WindowTree* tree, ClientWindowId* client_id) {
return NewWindowInTreeWithParent(tree, FirstRoot(tree), client_id);
}
ServerWindow* NewWindowInTreeWithParent(WindowTree* tree,
ServerWindow* parent,
ClientWindowId* client_id) {
if (!parent)
return nullptr;
ClientWindowId parent_client_id;
if (!tree->IsWindowKnown(parent, &parent_client_id))
return nullptr;
ClientWindowId client_window_id = NextUnusedClientWindowId(tree);
if (!tree->NewWindow(client_window_id, ServerWindow::Properties()))
return nullptr;
if (!tree->SetWindowVisibility(client_window_id, true))
return nullptr;
if (!tree->AddWindow(parent_client_id, client_window_id))
return nullptr;
*client_id = client_window_id;
return tree->GetWindowByClientId(client_window_id);
}
} // namespace test
} // namespace ws
} // namespace ui