ozone/platform/wayland: Use more realistic event processing and request flushing in tests

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/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;
@@ skipping 34 matching lines @@
     return false;
   }
   if (!shell_) {
     LOG(ERROR) << "No xdg_shell object";
     return false;
   }
 
   return true;
 }
 
-void WaylandDisplay::Flush() {
+bool WaylandDisplay::StartProcessingEvents() {
+  if (watching_)
+    return true;
+
   DCHECK(display_);
   wl_display_flush(display_.get());
+
+  DCHECK(base::MessageLoopForUI::IsCurrent());
+  if (!base::MessageLoopForUI::current()->WatchFileDescriptor(
+          wl_display_get_fd(display_.get()), true,
+          base::MessagePumpLibevent::WATCH_READ, &controller_, this))
+    return false;
+
+  watching_ = true;
+  return true;
+}
+
+void WaylandDisplay::ScheduleFlush() {
+  if (scheduled_flush_ || !watching_)
+    return;
+  base::MessageLoopForUI::current()->task_runner()->PostTask(
+      FROM_HERE, base::Bind(&WaylandDisplay::Flush, base::Unretained(this)));
+  scheduled_flush_ = true;
 }
 
 WaylandWindow* WaylandDisplay::GetWindow(gfx::AcceleratedWidget widget) {
   auto it = window_map_.find(widget);
   return it == window_map_.end() ? nullptr : it->second;
 }
 
 void WaylandDisplay::AddWindow(gfx::AcceleratedWidget widget,
                                WaylandWindow* window) {
   window_map_[widget] = window;
 }
 
 void WaylandDisplay::RemoveWindow(gfx::AcceleratedWidget widget) {
   window_map_.erase(widget);
 }
 
 void WaylandDisplay::OnDispatcherListChanged() {
-  if (watching_)
-    return;
+  StartProcessingEvents();
+}
 
-  DCHECK(display_);
-  DCHECK(base::MessageLoopForUI::IsCurrent());
-  base::MessageLoopForUI::current()->WatchFileDescriptor(
-      wl_display_get_fd(display_.get()), true,
-      base::MessagePumpLibevent::WATCH_READ, &controller_, this);
-  watching_ = true;
+void WaylandDisplay::Flush() {
+  wl_display_flush(display_.get());
+  scheduled_flush_ = false;
 }
 
 void WaylandDisplay::OnFileCanReadWithoutBlocking(int fd) {
   wl_display_dispatch(display_.get());
   for (const auto& window : window_map_)
     window.second->ApplyPendingBounds();
 }
 
 void WaylandDisplay::OnFileCanWriteWithoutBlocking(int fd) {}
 
@@ skipping 22 matching lines @@
     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);
   }
+
+  display->ScheduleFlush();
 }
 
 // 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) {
+  WaylandDisplay* display = static_cast<WaylandDisplay*>(data);
   xdg_shell_pong(shell, serial);
+  display->ScheduleFlush();
 }
 
 }  // namespace ui