ozone/platform/wayland: Add support for wl_output_interface

ui/ozone/platform/wayland/wayland_display.cc

 // 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 "ui/ozone/platform/wayland/wayland_display.h"
 
 #include <xdg-shell-unstable-v5-client-protocol.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/message_loop/message_loop.h"
 #include "ui/ozone/platform/wayland/wayland_object.h"
 #include "ui/ozone/platform/wayland/wayland_window.h"
 
 static_assert(XDG_SHELL_VERSION_CURRENT == 5, "Unsupported xdg-shell version");
 
 namespace ui {
 namespace {
 const uint32_t kMaxCompositorVersion = 4;
 const uint32_t kMaxSeatVersion = 4;
 const uint32_t kMaxShmVersion = 1;
 const uint32_t kMaxXdgShellVersion = 1;
 }  // namespace
 
+WaylandDisplay* WaylandDisplay::instance_ = nullptr;

[Michael Forney, 2016/06/10 18:12:21]

Why do we need to make this a singleton?

[joone, 2016/06/14 00:04:43]

We don't need WaylandDisplay::instance any more since 
WaylandDisplay::SetOutputCompleteClosure was moved to WaylandScreen.

+
 WaylandDisplay::WaylandDisplay() {}
 
-WaylandDisplay::~WaylandDisplay() {}
+WaylandDisplay::~WaylandDisplay() {
+  for (WaylandScreen* screen : screen_list_)
+    delete screen;
+  screen_list_.clear();
+  instance_ = nullptr;
+}
 
 bool WaylandDisplay::Initialize() {
   static const wl_registry_listener registry_listener = {
       &WaylandDisplay::Global, &WaylandDisplay::GlobalRemove,
   };
 
   display_.reset(wl_display_connect(nullptr));
   if (!display_) {
     LOG(ERROR) << "Failed to connect to Wayland display";
     return false;
@@ skipping 18 matching lines @@
   }
   if (!seat_) {
     LOG(ERROR) << "No wl_seat object";
     return false;
   }
   if (!shell_) {
     LOG(ERROR) << "No xdg_shell object";
     return false;
   }
 
+  instance_ = this;
   return true;
 }
 
 bool WaylandDisplay::StartProcessingEvents() {
   if (watching_)
     return true;
 
   DCHECK(display_);
   wl_display_flush(display_.get());
 
@@ skipping 22 matching lines @@
 
 void WaylandDisplay::AddWindow(gfx::AcceleratedWidget widget,
                                WaylandWindow* window) {
   window_map_[widget] = window;
 }
 
 void WaylandDisplay::RemoveWindow(gfx::AcceleratedWidget widget) {
   window_map_.erase(widget);
 }
 
+WaylandScreen* WaylandDisplay::PrimaryScreen() const {
+  if (!screen_list_.size())
+    return nullptr;
+  return screen_list_.front();
+}
+
 void WaylandDisplay::OnDispatcherListChanged() {
   StartProcessingEvents();
 }
 
 void WaylandDisplay::Flush() {
   wl_display_flush(display_.get());
   scheduled_flush_ = false;
 }
 
 void WaylandDisplay::DispatchUiEvent(Event* event) {
   PlatformEventSource::DispatchEvent(event);
 }
 
 void WaylandDisplay::OnFileCanReadWithoutBlocking(int fd) {
   wl_display_dispatch(display_.get());
   for (const auto& window : window_map_)
     window.second->ApplyPendingBounds();
 }
 
 void WaylandDisplay::OnFileCanWriteWithoutBlocking(int fd) {}
 
+void WaylandDisplay::OnOutputGeometryChanged(int32_t name,
+                                             const gfx::Rect& rect) {
+  display::Screen::GetScreen()->OnOutputGeometryChanged(name, rect);

[Michael Forney, 2016/06/10 18:12:21]

Can't WaylandScreen call this?

Also, maybe I'm misunderstanding something, but where is the
display::Screen::OnOutputGeometryChanged method declared?

I don't see it in ui/display/screen.h

[joone, 2016/06/14 00:04:43]

I missed to include the header file.

+  if (!output_complete_closure_.is_null())
+    output_complete_closure_.Run();
+}
+
+void WaylandDisplay::SetOutputCompleteClosure(const base::Closure& closure) {
+  output_complete_closure_ = closure;

[Michael Forney, 2016/06/10 18:12:21]

I think this should be a method on WaylandScreen.

[joone, 2016/06/14 00:04:43]

Done.

+}
+
+const std::vector<WaylandScreen*>& WaylandDisplay::GetScreenList() const {
+  return screen_list_;
+}
+
 // static
 void WaylandDisplay::Global(void* data,
                             wl_registry* registry,
                             uint32_t name,
                             const char* interface,
                             uint32_t version) {
   static const wl_seat_listener seat_listener = {
       &WaylandDisplay::Capabilities, &WaylandDisplay::Name,
   };
   static const xdg_shell_listener shell_listener = {
@@ skipping 22 matching lines @@
   } else if (!display->shell_ && strcmp(interface, "xdg_shell") == 0) {
     display->shell_ = wl::Bind<xdg_shell>(
         registry, name, std::min(version, kMaxXdgShellVersion));
     if (!display->shell_) {
       LOG(ERROR) << "Failed to  bind to xdg_shell global";
       return;
     }
     xdg_shell_add_listener(display->shell_.get(), &shell_listener, display);
     xdg_shell_use_unstable_version(display->shell_.get(),
                                    XDG_SHELL_VERSION_CURRENT);
+  } else if (strcmp(interface, "wl_output") == 0) {
+    WaylandScreen* screen = new WaylandScreen(registry, name);
+    if (!display->screen_list_.empty())
+      NOTIMPLEMENTED() << "Multiple screens support is not implemented";
+
+    display->screen_list_.push_back(screen);
   }
 
   display->ScheduleFlush();
 }
 
 // static
 void WaylandDisplay::GlobalRemove(void* data,
                                   wl_registry* registry,
                                   uint32_t name) {
   NOTIMPLEMENTED();
@@ skipping 25 matching lines @@
 void WaylandDisplay::Name(void* data, wl_seat* seat, const char* name) {}
 
 // static
 void WaylandDisplay::Ping(void* data, xdg_shell* shell, uint32_t serial) {
   WaylandDisplay* display = static_cast<WaylandDisplay*>(data);
   xdg_shell_pong(shell, serial);
   display->ScheduleFlush();
 }
 
 }  // namespace ui