blob: 3e7898428224ec0e491fc17ca880189830da6a1b [file] [log] [blame]
// Copyright 2015 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 <stdint.h>
#include <map>
#include <memory>
#include <queue>
#include <set>
#include "base/macros.h"
#include "base/memory/weak_ptr.h"
#include "services/ui/common/types.h"
#include "services/ui/public/interfaces/window_manager_constants.mojom.h"
#include "services/ui/public/interfaces/window_tree_host.mojom.h"
#include "services/ui/ws/focus_controller_delegate.h"
#include "services/ui/ws/focus_controller_observer.h"
#include "services/ui/ws/platform_display.h"
#include "services/ui/ws/server_window.h"
#include "services/ui/ws/server_window_observer.h"
#include "services/ui/ws/server_window_tracker.h"
#include "services/ui/ws/user_id_tracker_observer.h"
#include "services/ui/ws/window_manager_window_tree_factory_set_observer.h"
#include "ui/display/display.h"
namespace ui {
namespace ws {
class DisplayBinding;
class DisplayManager;
class FocusController;
struct PlatformDisplayInitParams;
class WindowManagerDisplayRoot;
class WindowServer;
class WindowTree;
namespace test {
class DisplayTestApi;
// Displays manages the state associated with a single display. Display has a
// single root window whose children are the roots for a per-user
// WindowManager. Display is configured in two distinct
// ways:
// . with a DisplayBinding. In this mode there is only ever one WindowManager
// for the display, which comes from the client that created the
// Display.
// . without a DisplayBinding. In this mode a WindowManager is automatically
// created per user.
class Display : public PlatformDisplayDelegate,
public mojom::WindowTreeHost,
public FocusControllerObserver,
public FocusControllerDelegate,
public ServerWindowObserver,
public UserIdTrackerObserver,
public WindowManagerWindowTreeFactorySetObserver {
Display(WindowServer* window_server,
const PlatformDisplayInitParams& platform_display_init_params);
~Display() override;
// Initializes state that depends on the existence of a Display.
void Init(std::unique_ptr<DisplayBinding> binding);
int64_t GetId() const;
DisplayManager* display_manager();
const DisplayManager* display_manager() const;
PlatformDisplay* platform_display() { return platform_display_.get(); }
// Returns a mojom::WsDisplay for the specified display. WindowManager
// specific values are not set.
mojom::WsDisplayPtr ToWsDisplay() const;
// Returns a display::Display for the specficied display.
display::Display ToDisplay() const;
// Schedules a paint for the specified region in the coordinates of |window|.
void SchedulePaint(const ServerWindow* window, const gfx::Rect& bounds);
// Schedules destruction of surfaces in |window|. If a frame has been
// scheduled but not drawn surface destruction is delayed until the frame is
// drawn, otherwise destruction is immediate.
void ScheduleSurfaceDestruction(ServerWindow* window);
display::Display::Rotation GetRotation() const;
gfx::Size GetSize() const;
WindowServer* window_server() { return window_server_; }
// Returns the root of the Display. The root's children are the roots
// of the corresponding WindowManagers.
ServerWindow* root_window() { return root_.get(); }
const ServerWindow* root_window() const { return root_.get(); }
// Returns the ServerWindow whose id is |id|. This does not do a search over
// all windows, rather just the display and window manager root windows.
// In general you shouldn't use this, rather use WindowServer::GetWindow(),
// which calls this as necessary.
ServerWindow* GetRootWithId(const WindowId& id);
WindowManagerDisplayRoot* GetWindowManagerDisplayRootWithRoot(
const ServerWindow* window);
WindowManagerDisplayRoot* GetWindowManagerDisplayRootForUser(
const UserId& user_id) {
return const_cast<WindowManagerDisplayRoot*>(
const_cast<const Display*>(this)->GetWindowManagerDisplayRootForUser(
const WindowManagerDisplayRoot* GetWindowManagerDisplayRootForUser(
const UserId& user_id) const;
WindowManagerDisplayRoot* GetActiveWindowManagerDisplayRoot() {
return const_cast<WindowManagerDisplayRoot*>(
const_cast<const Display*>(this)->GetActiveWindowManagerDisplayRoot());
const WindowManagerDisplayRoot* GetActiveWindowManagerDisplayRoot() const;
size_t num_window_manger_states() const {
return window_manager_display_root_map_.size();
// TODO(sky): this should only be called by WindowServer, move to interface
// used by WindowServer.
// See description of WindowServer::SetFocusedWindow() for details on return
// value.
bool SetFocusedWindow(ServerWindow* window);
// NOTE: this returns the focused window only if the focused window is in this
// display. If this returns null focus may be in another display.
ServerWindow* GetFocusedWindow();
void ActivateNextWindow();
void AddActivationParent(ServerWindow* window);
void RemoveActivationParent(ServerWindow* window);
void UpdateTextInputState(ServerWindow* window,
const ui::TextInputState& state);
void SetImeVisibility(ServerWindow* window, bool visible);
// Called just before |tree| is destroyed.
void OnWillDestroyTree(WindowTree* tree);
void UpdateNativeCursor(int32_t cursor_id);
// mojom::WindowTreeHost:
void SetSize(const gfx::Size& size) override;
void SetTitle(const mojo::String& title) override;
friend class test::DisplayTestApi;
using WindowManagerDisplayRootMap =
std::map<UserId, std::unique_ptr<WindowManagerDisplayRoot>>;
// Inits the necessary state once the display is ready.
void InitWindowManagerDisplayRootsIfNecessary();
// Creates the set of WindowManagerDisplayRoots from the
// WindowManagerWindowTreeFactorySet.
void CreateWindowManagerDisplayRootsFromFactories();
void CreateWindowManagerDisplayRootFromFactory(
WindowManagerWindowTreeFactory* factory);
// PlatformDisplayDelegate:
ServerWindow* GetRootWindow() override;
bool IsInHighContrastMode() override;
void OnEvent(const ui::Event& event) override;
void OnNativeCaptureLost() override;
void OnDisplayClosed() override;
void OnViewportMetricsChanged(const ViewportMetrics& old_metrics,
const ViewportMetrics& new_metrics) override;
void OnCompositorFrameDrawn() override;
// FocusControllerDelegate:
bool CanHaveActiveChildren(ServerWindow* window) const override;
// FocusControllerObserver:
void OnActivationChanged(ServerWindow* old_active_window,
ServerWindow* new_active_window) override;
void OnFocusChanged(FocusControllerChangeSource change_source,
ServerWindow* old_focused_window,
ServerWindow* new_focused_window) override;
// ServerWindowObserver:
void OnWindowDestroyed(ServerWindow* window) override;
// UserIdTrackerObserver:
void OnUserIdRemoved(const UserId& id) override;
// WindowManagerWindowTreeFactorySetObserver:
void OnWindowManagerWindowTreeFactoryReady(
WindowManagerWindowTreeFactory* factory) override;
std::unique_ptr<DisplayBinding> binding_;
// Set once Init() has been called.
bool init_called_ = false;
WindowServer* const window_server_;
std::unique_ptr<ServerWindow> root_;
std::unique_ptr<PlatformDisplay> platform_display_;
std::unique_ptr<FocusController> focus_controller_;
// The last cursor set. Used to track whether we need to change the cursor.
int32_t last_cursor_;
ServerWindowTracker activation_parents_;
// Set of windows with surfaces that need to be destroyed once the frame
// draws.
std::set<ServerWindow*> windows_needing_frame_destruction_;
WindowManagerDisplayRootMap window_manager_display_root_map_;
} // namespace ws
} // namespace ui