ozone/platform/wayland: Ensure that globals are bound with supported versions

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/strings/string_number_conversions.h"
 
 namespace wl {
 namespace {
 
 const uint32_t kCompositorVersion = 4;
-const uint32_t kSurfaceVersion = 4;
 const uint32_t kXdgShellVersion = 1;
-const uint32_t kXdgSurfaceVersion = 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) {
   auto compositor =
       static_cast<MockCompositor*>(wl_resource_get_user_data(resource));
-  wl_resource* surface_resource =
-      wl_resource_create(client, &wl_surface_interface, kSurfaceVersion, id);
+  wl_resource* surface_resource = wl_resource_create(
+      client, &wl_surface_interface, wl_resource_get_version(resource), id);
   if (!surface_resource) {
     wl_client_post_no_memory(client);
     return;
   }
   compositor->AddSurface(make_scoped_ptr(new MockSurface(surface_resource)));
 }
 
 const struct wl_compositor_interface compositor_impl = {
     &CreateSurface,  // create_surface
     nullptr,         // create_region
@@ skipping 27 matching lines @@
 const struct wl_surface_interface surface_impl = {
     &DestroyResource,  // destroy
     &Attach,           // attach
     &Damage,           // damage
     nullptr,           // frame
     nullptr,           // set_opaque_region
     nullptr,           // set_input_region
     &Commit,           // commit
     nullptr,           // set_buffer_transform
     nullptr,           // set_buffer_scale
+    nullptr,           // damage_buffer
 };
 
 // xdg_shell
 
 void UseUnstableVersion(wl_client* client,
                         wl_resource* resource,
                         int32_t version) {
   static_cast<MockXdgShell*>(wl_resource_get_user_data(resource))
       ->UseUnstableVersion(version);
 }
 
 void GetXdgSurface(wl_client* client,
                    wl_resource* resource,
                    uint32_t id,
                    wl_resource* surface_resource) {
   auto surface =
       static_cast<MockSurface*>(wl_resource_get_user_data(surface_resource));
   if (surface->xdg_surface) {
     wl_resource_post_error(resource, XDG_SHELL_ERROR_ROLE,
                            "surface already has a role");
     return;
   }
   wl_resource* xdg_surface_resource = wl_resource_create(
-      client, &xdg_surface_interface, kXdgSurfaceVersion, id);
+      client, &xdg_surface_interface, wl_resource_get_version(resource), id);
   if (!xdg_surface_resource) {
     wl_client_post_no_memory(client);
     return;
   }
   surface->xdg_surface.reset(new MockXdgSurface(xdg_surface_resource));
 }
 
 void Pong(wl_client* client, wl_resource* resource, uint32_t serial) {
   static_cast<MockXdgShell*>(wl_resource_get_user_data(resource))->Pong(serial);
 }
@@ skipping 110 matching lines @@
   global_.reset(wl_global_create(display, interface_, version_, this, &Bind));
   return global_;
 }
 
 // static
 void Global::Bind(wl_client* client,
                   void* data,
                   uint32_t version,
                   uint32_t id) {
   auto global = static_cast<Global*>(data);
-  wl_resource* resource =
-      wl_resource_create(client, global->interface_, global->version_, id);
+  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);
 }
 
@@ skipping 94 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