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

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 "base/logging.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 kMaxShmVersion = 1;
+const uint32_t kMaxXdgShellVersion = 1;
+}  // namespace
 
 WaylandDisplay::WaylandDisplay() {}
 
 WaylandDisplay::~WaylandDisplay() {}
 
 bool WaylandDisplay::Initialize() {
   static const wl_registry_listener registry_listener = {
       &WaylandDisplay::Global, &WaylandDisplay::GlobalRemove,
   };
 
@@ skipping 71 matching lines @@
                             wl_registry* registry,
                             uint32_t name,
                             const char* interface,
                             uint32_t version) {
   static const xdg_shell_listener shell_listener = {
       &WaylandDisplay::Ping,
   };
 
   WaylandDisplay* display = static_cast<WaylandDisplay*>(data);
   if (!display->compositor_ && strcmp(interface, "wl_compositor") == 0) {
-    display->compositor_ = wl::Bind<wl_compositor>(registry, name, version);
+    display->compositor_ = wl::Bind<wl_compositor>(
+        registry, name, std::min(version, kMaxCompositorVersion));

[spang, 2016/02/17 23:25:03]

Should

version < 4

be an error? Or is the code actually prepared to deal with old servers?

Same for the others. If the server doesn't support the one you tested against,
are we expecting that to actually work?

     if (!display->compositor_)
       LOG(ERROR) << "Failed to bind to wl_compositor global";
   } else if (!display->shm_ && strcmp(interface, "wl_shm") == 0) {
-    display->shm_ = wl::Bind<wl_shm>(registry, name, version);
+    display->shm_ =
+        wl::Bind<wl_shm>(registry, name, std::min(version, kMaxShmVersion));
     if (!display->shm_)
       LOG(ERROR) << "Failed to bind to wl_shm global";
   } else if (!display->shell_ && strcmp(interface, "xdg_shell") == 0) {
-    display->shell_ = wl::Bind<xdg_shell>(registry, name, version);
+    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);
   }
 }
 
 // static
 void WaylandDisplay::GlobalRemove(void* data,
                                   wl_registry* registry,
                                   uint32_t name) {
   NOTIMPLEMENTED();
 }
 
 // static
 void WaylandDisplay::Ping(void* data, xdg_shell* shell, uint32_t serial) {
   xdg_shell_pong(shell, serial);
 }
 
 }  // namespace ui