[WIP] Make content_shell run under Wayland

ui/ozone/platform/wayland/wayland_connection.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_connection.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 "base/strings/string_util.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
 
-WaylandConnection::WaylandConnection() {}
+WaylandConnection* WaylandConnection::instance_ = nullptr;
+
+WaylandConnection::WaylandConnection() : output_observer_(nullptr) {}
 
 WaylandConnection::~WaylandConnection() {}
 
 bool WaylandConnection::Initialize() {
   static const wl_registry_listener registry_listener = {
       &WaylandConnection::Global, &WaylandConnection::GlobalRemove,
   };
 
   display_.reset(wl_display_connect(nullptr));
   if (!display_) {
@@ skipping 20 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 WaylandConnection::StartProcessingEvents() {
   if (watching_)
     return true;
 
   DCHECK(display_);
   wl_display_flush(display_.get());
 
@@ skipping 54 matching lines @@
     window.second->ApplyPendingBounds();
 }
 
 void WaylandConnection::OnFileCanWriteWithoutBlocking(int fd) {}
 
 const std::vector<std::unique_ptr<WaylandOutput>>&
 WaylandConnection::GetOutputList() const {
   return output_list_;
 }
 
+void WaylandConnection::SetOutputObserver(
+    OzonePlatformScreenDelegate* observer) {
+  output_observer_ = observer;
+}
+
+void WaylandConnection::OnOutputGeometryChanged(int32_t name,
+                                                const gfx::Rect& rect) {
+  if (output_observer_)
+    output_observer_->OnOutputGeometryChanged(name, rect);
+}
+
 // static
 void WaylandConnection::Global(void* data,
                                wl_registry* registry,
                                uint32_t name,
                                const char* interface,
                                uint32_t version) {
   static const wl_seat_listener seat_listener = {
       &WaylandConnection::Capabilities, &WaylandConnection::Name,
   };
   static const xdg_shell_listener shell_listener = {
@@ skipping 34 matching lines @@
     wl::Object<wl_output> output = wl::Bind<wl_output>(registry, name, 1);
     if (!output) {
       LOG(ERROR) << "Failed to bind to wl_output global";
       return;
     }
 
     if (!connection->output_list_.empty())
       NOTIMPLEMENTED() << "Multiple screens support is not implemented";
 
     connection->output_list_.push_back(
-        base::WrapUnique(new WaylandOutput(output.release())));
+        base::WrapUnique(new WaylandOutput(output.release(), name)));
   }
 
   connection->ScheduleFlush();
 }
 
 // static
 void WaylandConnection::GlobalRemove(void* data,
                                      wl_registry* registry,
                                      uint32_t name) {
   NOTIMPLEMENTED();
@@ skipping 25 matching lines @@
 void WaylandConnection::Name(void* data, wl_seat* seat, const char* name) {}
 
 // static
 void WaylandConnection::Ping(void* data, xdg_shell* shell, uint32_t serial) {
   WaylandConnection* connection = static_cast<WaylandConnection*>(data);
   xdg_shell_pong(shell, serial);
   connection->ScheduleFlush();
 }
 
 }  // namespace ui