ozone/platform/wayland: Add support for wl_output_interface

ui/ozone/platform/wayland/fake_server.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/fake_server.h"
 
 #include <sys/socket.h>
 #include <wayland-server.h>
 #include <xdg-shell-unstable-v5-server-protocol.h>
 
 #include "base/bind.h"
 #include "base/files/scoped_file.h"
 #include "base/memory/ptr_util.h"
 #include "base/run_loop.h"
 #include "base/strings/string_number_conversions.h"
 
 namespace wl {
 namespace {
 
 const uint32_t kCompositorVersion = 4;
+const uint32_t kOutputVersion = 2;
 const uint32_t kSeatVersion = 4;
 const uint32_t kXdgShellVersion = 1;
 
 void DestroyResource(wl_client* client, wl_resource* resource) {
   wl_resource_destroy(resource);
 }
 
 // wl_compositor
 
 void CreateSurface(wl_client* client, wl_resource* resource, uint32_t id) {
@@ skipping 240 matching lines @@
   wl_resource* resource = wl_resource_create(
       client, global->interface_, std::min(version, global->version_), id);
   if (!resource) {
     wl_client_post_no_memory(client);
     return;
   }
   if (!global->resource_)
     global->resource_ = resource;
   wl_resource_set_implementation(resource, global->implementation_, global,
                                  &Global::OnResourceDestroyed);
+
+  if (global->interface_ == &wl_output_interface) {
+    auto output = static_cast<MockOutput*>(data);
+    gfx::Rect bounds = output->Display().bounds();
+    const char* kUnknownMake = "unknown";
+    const char* kUnknownModel = "unknown";
+    wl_output_send_geometry(resource, bounds.x(), bounds.y(), 0, 0, 0,
+                            kUnknownMake, kUnknownModel, 0);
+    wl_output_send_mode(resource, WL_OUTPUT_MODE_CURRENT, bounds.width(),
+                        bounds.height(), 0);
+  }

[Michael Forney, 2016/06/14 00:55:18]

Maybe instead you could add a virtual method to Global, OnBind or something, and
just override that for MockOutput.

[joone, 2016/06/14 22:10:28]

Done.

 }
 
 // static
 void Global::OnResourceDestroyed(wl_resource* resource) {
   auto global = static_cast<Global*>(wl_resource_get_user_data(resource));
   if (global->resource_ == resource)
     global->resource_ = nullptr;
 }
 
 MockCompositor::MockCompositor()
     : Global(&wl_compositor_interface, &compositor_impl, kCompositorVersion) {}
 
 MockCompositor::~MockCompositor() {}
 
 void MockCompositor::AddSurface(std::unique_ptr<MockSurface> surface) {
   surfaces_.push_back(std::move(surface));
 }
 
+MockOutput::MockOutput()
+    : Global(&wl_output_interface, nullptr, kOutputVersion) {}
+
+MockOutput::~MockOutput() {}
+
 MockSeat::MockSeat() : Global(&wl_seat_interface, &seat_impl, kSeatVersion) {}
 
 MockSeat::~MockSeat() {}
 
 MockXdgShell::MockXdgShell()
     : Global(&xdg_shell_interface, &xdg_shell_impl, kXdgShellVersion) {}
 
 MockXdgShell::~MockXdgShell() {}
 
 void DisplayDeleter::operator()(wl_display* display) {
   wl_display_destroy(display);
 }
 
 FakeServer::FakeServer()
     : Thread("fake_wayland_server"),
       pause_event_(false, false),
       resume_event_(false, false) {}
 
 FakeServer::~FakeServer() {
   Resume();
   Stop();
 }
 
+void FakeServer::AddDisplay(const display::Display& fake_display) {
+  output_.SetDisplay(fake_display);
+}
+
 bool FakeServer::Start() {
   display_.reset(wl_display_create());
   if (!display_)
     return false;
   event_loop_ = wl_display_get_event_loop(display_.get());
 
   int fd[2];
   if (socketpair(AF_UNIX, SOCK_STREAM | SOCK_CLOEXEC, 0, fd) < 0)
     return false;
   base::ScopedFD server_fd(fd[0]);
   base::ScopedFD client_fd(fd[1]);
 
   if (wl_display_init_shm(display_.get()) < 0)
     return false;
   if (!compositor_.Initialize(display_.get()))
     return false;
+  if (!output_.Initialize(display_.get()))
+    return false;
   if (!seat_.Initialize(display_.get()))
     return false;
   if (!xdg_shell_.Initialize(display_.get()))
     return false;
 
   client_ = wl_client_create(display_.get(), server_fd.get());
   if (!client_)
     return false;
   (void)server_fd.release();
 
@@ skipping 35 matching lines @@
 }
 
 void FakeServer::OnFileCanReadWithoutBlocking(int fd) {
   wl_event_loop_dispatch(event_loop_, 0);
   wl_display_flush_clients(display_.get());
 }
 
 void FakeServer::OnFileCanWriteWithoutBlocking(int fd) {}
 
 }  // namespace wl