Add cast shell wm_helper class

Add enable_cast_wayland_server flag to selectively enable exo server use.
Add a Cast-specific implementation of wm_helper.
This implementation contains the minimum required to make exo work on cast shell.

support EXO.

Bug: 896710
Test: Built on ChromeOS, is not utilized yet as cast does not yet
Change-Id: I0e38a415fbdecdbe7f116885ed9048834cbca1b5
Reviewed-on: https://chromium-review.googlesource.com/c/1294835
Commit-Queue: Shawn Gallea <sagallea@google.com>
Reviewed-by: Mitsuru Oshima <oshima@chromium.org>
Reviewed-by: Daniele Castagna <dcastagna@chromium.org>
Reviewed-by: Luke Halliwell <halliwell@chromium.org>
Reviewed-by: Daniel Nicoara <dnicoara@chromium.org>
Cr-Commit-Position: refs/heads/master@{#605851}

chromecast/BUILD.gn

@@ -575,6 +575,7 @@ buildflag_header("chromecast_buildflags") {
     "DISABLE_SECURE_FLAC_OPUS_DECODING=$disable_secure_flac_and_opus_decoding",
     "ENABLE_ASSISTANT=$enable_assistant",
     "ENABLE_CAST_FRAGMENT=$enable_cast_fragment",
+    "ENABLE_CAST_WAYLAND_SERVER=$enable_cast_wayland_server",
     "ENABLE_CHROMECAST_EXTENSIONS=$enable_chromecast_extensions",
     "ENABLE_HEADLESS_MUSIC_MODE=$enable_headless_music_mode",
     "ENABLE_PLAYREADY=$enable_playready",

chromecast/browser/BUILD.gn

@@ -329,6 +329,17 @@ cast_source_set("browser") {
     ]
   }
 
+  if (enable_cast_wayland_server) {
+    sources += [
+      "exo/wm_helper_cast_shell.cc",
+      "exo/wm_helper_cast_shell.h",
+    ]
+    deps += [
+      "//components/exo",
+      "//components/exo/wayland",
+    ]
+  }
+
   configs += [ "//media/audio:platform_config" ]
 }
 

chromecast/browser/exo/DEPS

+include_rules = [
+  "+components/exo"
+]

chromecast/browser/exo/wm_helper_cast_shell.cc

+// 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 "chromecast/browser/exo/wm_helper_cast_shell.h"
+
+#include "base/memory/singleton.h"
+#include "chromecast/browser/cast_browser_process.h"
+#include "chromecast/graphics/cast_screen.h"
+#include "chromecast/graphics/cast_window_manager_aura.h"
+#include "ui/aura/client/focus_client.h"
+#include "ui/base/dragdrop/drag_drop_types.h"
+#include "ui/display/display.h"
+#include "ui/display/manager/display_configurator.h"
+#include "ui/display/manager/display_manager.h"
+#include "ui/display/screen.h"
+#include "ui/display/types/display_snapshot.h"
+#include "ui/events/devices/input_device_manager.h"
+#include "ui/wm/public/activation_client.h"
+
+namespace exo {
+
+WMHelperCastShell::WMHelperCastShell(
+    aura::Env* env,
+    chromecast::CastWindowManagerAura* cast_window_manager_aura,
+    CastScreen* cast_screen)
+    : cast_window_manager_aura_(cast_window_manager_aura),
+      env_(env),
+      cast_screen_(cast_screen) {
+  cast_screen_->AddObserver(&display_observer_);
+}
+
+WMHelperCastShell::~WMHelperCastShell() {
+  cast_screen_->RemoveObserver(&display_observer_);
+}
+
+aura::Env* WMHelperCastShell::env() {
+  return env_;
+}
+
+void WMHelperCastShell::AddActivationObserver(
+    wm::ActivationChangeObserver* observer) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::RemoveActivationObserver(
+    wm::ActivationChangeObserver* observer) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::AddFocusObserver(
+    aura::client::FocusChangeObserver* observer) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::RemoveFocusObserver(
+    aura::client::FocusChangeObserver* observer) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::AddDragDropObserver(DragDropObserver* observer) {
+  drag_drop_observers_.AddObserver(observer);
+}
+
+void WMHelperCastShell::RemoveDragDropObserver(DragDropObserver* observer) {
+  drag_drop_observers_.RemoveObserver(observer);
+}
+
+void WMHelperCastShell::SetDragDropDelegate(aura::Window* window) {
+  aura::client::SetDragDropDelegate(window, this);
+}
+
+void WMHelperCastShell::ResetDragDropDelegate(aura::Window* window) {
+  aura::client::SetDragDropDelegate(window, nullptr);
+}
+
+void WMHelperCastShell::AddVSyncObserver(
+    ui::CompositorVSyncManager::Observer* observer) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::RemoveVSyncObserver(
+    ui::CompositorVSyncManager::Observer* observer) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::OnDragEntered(const ui::DropTargetEvent& event) {}
+
+int WMHelperCastShell::OnDragUpdated(const ui::DropTargetEvent& event) {}
+
+void WMHelperCastShell::OnDragExited() {}
+
+int WMHelperCastShell::OnPerformDrop(const ui::DropTargetEvent& event) {
+  NOTIMPLEMENTED();
+  return ui::DragDropTypes::DRAG_MOVE;
+}
+
+const display::ManagedDisplayInfo& WMHelperCastShell::GetDisplayInfo(
+    int64_t display_id) const {
+  return display_observer_.GetDisplayInfo(display_id);
+}
+
+const std::vector<uint8_t>& WMHelperCastShell::GetDisplayIdentificationData(
+    int64_t display_id) const {
+  NOTIMPLEMENTED();
+  static std::vector<uint8_t> no_data;
+  return no_data;
+}
+
+aura::Window* WMHelperCastShell::GetPrimaryDisplayContainer(int container_id) {
+  return cast_window_manager_aura_->GetRootWindow();
+}
+
+aura::Window* WMHelperCastShell::GetActiveWindow() const {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+aura::Window* WMHelperCastShell::GetFocusedWindow() const {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+aura::Window* WMHelperCastShell::GetRootWindowForNewWindows() const {
+  return cast_window_manager_aura_->GetRootWindow();
+}
+
+aura::client::CursorClient* WMHelperCastShell::GetCursorClient() {
+  NOTIMPLEMENTED();
+  return nullptr;
+}
+
+void WMHelperCastShell::AddPreTargetHandler(ui::EventHandler* handler) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::PrependPreTargetHandler(ui::EventHandler* handler) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::RemovePreTargetHandler(ui::EventHandler* handler) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::AddPostTargetHandler(ui::EventHandler* handler) {
+  NOTIMPLEMENTED();
+}
+
+void WMHelperCastShell::RemovePostTargetHandler(ui::EventHandler* handler) {
+  NOTIMPLEMENTED();
+}
+
+bool WMHelperCastShell::IsTabletModeWindowManagerEnabled() const {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+double WMHelperCastShell::GetDefaultDeviceScaleFactor() const {
+  NOTIMPLEMENTED();
+  return 1.0;
+}
+
+WMHelperCastShell::CastDisplayObserver::CastDisplayObserver() {}
+
+WMHelperCastShell::CastDisplayObserver::~CastDisplayObserver() {}
+
+void WMHelperCastShell::CastDisplayObserver::OnWillProcessDisplayChanges() {}
+
+void WMHelperCastShell::CastDisplayObserver::OnDidProcessDisplayChanges() {}
+
+void WMHelperCastShell::CastDisplayObserver::OnDisplayAdded(
+    const display::Display& new_display) {
+  display::ManagedDisplayInfo md(new_display.id(), "CastDisplayInfo", true);
+  md.SetBounds(new_display.bounds());
+  display_info_.emplace(new_display.id(), md);
+}
+
+void WMHelperCastShell::CastDisplayObserver::OnDisplayRemoved(
+    const display::Display& old_display) {
+  display_info_.erase(old_display.id());
+}
+
+void WMHelperCastShell::CastDisplayObserver::OnDisplayMetricsChanged(
+    const display::Display& display,
+    uint32_t changed_metrics) {
+  // Currently only updates bounds
+  if ((DISPLAY_METRIC_BOUNDS & changed_metrics) == DISPLAY_METRIC_BOUNDS)
+    display_info_[display.id()].SetBounds(display.bounds());
+}
+
+const display::ManagedDisplayInfo&
+WMHelperCastShell::CastDisplayObserver::GetDisplayInfo(
+    int64_t display_id) const {
+  auto iter = display_info_.find(display_id);
+  CHECK(iter != display_info_.end()) << display_id;
+  return iter->second;
+}
+
+}  // namespace exo

chromecast/browser/exo/wm_helper_cast_shell.h

+// 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.
+
+#ifndef CHROMECAST_BROWSER_EXO_WM_HELPER_CAST_SHELL_H_
+#define CHROMECAST_BROWSER_EXO_WM_HELPER_CAST_SHELL_H_
+
+#include <cstdint>
+#include <map>
+#include <vector>
+
+#include "base/macros.h"
+#include "base/observer_list.h"
+#include "components/exo/wm_helper.h"
+#include "ui/aura/client/drag_drop_delegate.h"
+#include "ui/base/cursor/cursor.h"
+#include "ui/compositor/compositor_vsync_manager.h"
+#include "ui/display/display_observer.h"
+
+namespace aura {
+class env;
+class Window;
+namespace client {
+class CursorClient;
+class FocusChangeObserver;
+}  // namespace client
+}  // namespace aura
+
+namespace chromecast {
+class CastWindowManagerAura;
+}
+
+namespace wm {
+class ActivationChangeObserver;
+}
+
+namespace display {
+class ManagedDisplayInfo;
+}
+
+namespace ui {
+class EventHandler;
+class DropTargetEvent;
+}  // namespace ui
+
+namespace wm {
+class ActivationChangeObserver;
+}
+
+class CastScreen;
+
+namespace exo {
+
+// A CastShell-specific helper class for accessing WindowManager related
+// features.
+class WMHelperCastShell : public WMHelper {
+ public:
+  WMHelperCastShell(aura::Env* env,
+                    chromecast::CastWindowManagerAura* cast_window_manager_aura,
+                    CastScreen* cast_screen);
+  ~WMHelperCastShell() override;
+
+  // Overridden from WMHelper
+  aura::Env* env() override;
+  void AddActivationObserver(wm::ActivationChangeObserver* observer) override;
+  void RemoveActivationObserver(
+      wm::ActivationChangeObserver* observer) override;
+  void AddFocusObserver(aura::client::FocusChangeObserver* observer) override;
+  void RemoveFocusObserver(
+      aura::client::FocusChangeObserver* observer) override;
+
+  void AddDragDropObserver(DragDropObserver* observer) override;
+  void RemoveDragDropObserver(DragDropObserver* observer) override;
+  void SetDragDropDelegate(aura::Window*) override;
+  void ResetDragDropDelegate(aura::Window*) override;
+  void AddVSyncObserver(
+      ui::CompositorVSyncManager::Observer* observer) override;
+  void RemoveVSyncObserver(
+      ui::CompositorVSyncManager::Observer* observer) override;
+
+  const display::ManagedDisplayInfo& GetDisplayInfo(
+      int64_t display_id) const override;
+  const std::vector<uint8_t>& GetDisplayIdentificationData(
+      int64_t display_id) const override;
+
+  aura::Window* GetPrimaryDisplayContainer(int container_id) override;
+  aura::Window* GetActiveWindow() const override;
+  aura::Window* GetFocusedWindow() const override;
+  aura::Window* GetRootWindowForNewWindows() const override;
+  aura::client::CursorClient* GetCursorClient() override;
+  void AddPreTargetHandler(ui::EventHandler* handler) override;
+  void PrependPreTargetHandler(ui::EventHandler* handler) override;
+  void RemovePreTargetHandler(ui::EventHandler* handler) override;
+  void AddPostTargetHandler(ui::EventHandler* handler) override;
+  void RemovePostTargetHandler(ui::EventHandler* handler) override;
+  bool IsTabletModeWindowManagerEnabled() const override;
+  double GetDefaultDeviceScaleFactor() const override;
+
+  // Overridden from aura::client::DragDropDelegate:
+  void OnDragEntered(const ui::DropTargetEvent& event) override;
+  int OnDragUpdated(const ui::DropTargetEvent& event) override;
+  void OnDragExited() override;
+  int OnPerformDrop(const ui::DropTargetEvent& event) override;
+
+ private:
+  class CastDisplayObserver : public display::DisplayObserver {
+   public:
+    CastDisplayObserver();
+    ~CastDisplayObserver() override;
+
+    // Overridden from display::DisplayObserver
+    void OnWillProcessDisplayChanges() override;
+    void OnDidProcessDisplayChanges() override;
+    void OnDisplayAdded(const display::Display& new_display) override;
+    void OnDisplayRemoved(const display::Display& old_display) override;
+    void OnDisplayMetricsChanged(const display::Display& display,
+                                 uint32_t changed_metrics) override;
+
+    const display::ManagedDisplayInfo& GetDisplayInfo(int64_t display_id) const;
+
+   private:
+    std::map<int64_t, display::ManagedDisplayInfo> display_info_;
+  };
+
+  chromecast::CastWindowManagerAura* cast_window_manager_aura_;
+  aura::Env* const env_;
+  CastScreen* cast_screen_;
+  CastDisplayObserver display_observer_;
+  DISALLOW_COPY_AND_ASSIGN(WMHelperCastShell);
+};
+
+}  // namespace exo
+
+#endif  // CHROMECAST_BROWSER_EXO_EM_HELPER_CAST_SHELL_H_

chromecast/chromecast.gni

@@ -98,6 +98,9 @@ declare_args() {
   # Set to true to disable secure flac/opus support in EME, when using
   # cast CMA media backend and supporting Widevine or Playready.
   disable_secure_flac_and_opus_decoding = false
+
+  # Set to true to enable wayland server
+  enable_cast_wayland_server = false
 }
 
 declare_args() {