exo: Add useful flags and benchmarking to motion event client.

components/exo/wayland/clients/motion_events.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.
 
 // Implementation of a client that produces output in the form of RGBA
 // buffers when receiving pointer/touch events. RGB contains the lower
 // 24 bits of the event timestamp and A is 0xff.
 
 #include <wayland-client-core.h>
 #include <wayland-client-protocol.h>
 
+#include <iostream>
 #include <vector>
 
+#include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/shared_memory.h"
+#include "base/strings/string_number_conversions.h"
+#include "base/time/time.h"
 #include "third_party/skia/include/core/SkCanvas.h"
 #include "third_party/skia/include/core/SkRefCnt.h"
 #include "third_party/skia/include/core/SkSurface.h"
 
 // Convenient macro that is used to define default deleters for wayland object
 // types allowing them to be used with std::unique_ptr.
 #define DEFAULT_DELETER(TypeName, DeleteFunction)           \
   namespace std {                                           \
   template <>                                               \
   struct default_delete<TypeName> {                         \
@@ skipping 13 matching lines @@
 DEFAULT_DELETER(wl_seat, wl_seat_destroy)
 DEFAULT_DELETER(wl_pointer, wl_pointer_destroy)
 DEFAULT_DELETER(wl_touch, wl_touch_destroy)
 DEFAULT_DELETER(wl_callback, wl_callback_destroy)
 
 namespace exo {
 namespace wayland {
 namespace clients {
 namespace {
 
-// Window size.
-const size_t kWidth = 256;
-const size_t kHeight = 256;
-
 // Buffer format.
 const int32_t kFormat = WL_SHM_FORMAT_ARGB8888;
 const SkColorType kColorType = kBGRA_8888_SkColorType;
 const size_t kBytesPerPixel = 4;
 
 // Number of buffers.
 const size_t kBuffers = 2;
 
 // Rotation speed (degrees/second).
 const double kRotationSpeed = 360.0;
 
-// Helper constants.
-const size_t kStride = kWidth * kBytesPerPixel;
-const size_t kBufferSize = kHeight * kStride;
-const size_t kMemorySize = kBufferSize * kBuffers;
+// Benchmark interval in seconds.
+const int kBenchmarkInterval = 5;
 
 struct Globals {
   std::unique_ptr<wl_compositor> compositor;
   std::unique_ptr<wl_shm> shm;
   std::unique_ptr<wl_shell> shell;
   std::unique_ptr<wl_seat> seat;
 };
 
 void RegistryHandler(void* data,
                      wl_registry* registry,
@@ skipping 124 matching lines @@
 
   static uint32_t initial_time = time;
   frame->time = time - initial_time;
   frame->callback_pending = false;
 }
 
 }  // namespace
 
 class MotionEvents {
  public:
-  MotionEvents() {}
+  MotionEvents(size_t width,
+               size_t height,
+               int scale,
+               size_t rects,

[Daniele Castagna, 2016/11/05 21:49:20]

nit: maybe rect_num?

[reveman, 2016/11/05 22:38:20]

Done. "num_rects" now

+               bool fullscreen)
+      : width_(width),
+        height_(height),
+        scale_(scale),
+        rects_(rects),
+        fullscreen_(fullscreen) {}
 
   // Initialize and run client main loop.
   int Run();
 
  private:
+  size_t stride() const { return width_ * kBytesPerPixel; }
+  size_t buffer_size() const { return stride() * height_; }
+
+  const size_t width_;
+  const size_t height_;
+  const int scale_;
+  const size_t rects_;

[Daniele Castagna, 2016/11/05 21:49:19]

rect_num_?

[reveman, 2016/11/05 22:38:19]

Done.

+  const bool fullscreen_;
+
   DISALLOW_COPY_AND_ASSIGN(MotionEvents);
 };
 
 int MotionEvents::Run() {
   std::unique_ptr<wl_display> display(wl_display_connect(nullptr));
   if (!display) {
     LOG(ERROR) << "wl_display_connect failed";
     return 1;
   }
 
   wl_registry_listener registry_listener = {RegistryHandler, RegistryRemover};
 
   Globals globals;
   wl_registry* registry = wl_display_get_registry(display.get());
   wl_registry_add_listener(registry, &registry_listener, &globals);
 
-  wl_display_dispatch(display.get());
   wl_display_roundtrip(display.get());
 
   if (!globals.compositor) {
     LOG(ERROR) << "Can't find compositor interface";
     return 1;
   }
   if (!globals.shm) {
     LOG(ERROR) << "Can't find shm interface";
     return 1;
   }
   if (!globals.shell) {
     LOG(ERROR) << "Can't find shell interface";
     return 1;
   }
   if (!globals.seat) {
     LOG(ERROR) << "Can't find seat interface";
     return 1;
   }
 
   wl_buffer_listener buffer_listener = {BufferRelease};
 
   Buffer buffers[kBuffers];
   base::SharedMemory shared_memory;
-  shared_memory.CreateAndMapAnonymous(kMemorySize);
+  shared_memory.CreateAndMapAnonymous(buffer_size() * kBuffers);
   std::unique_ptr<wl_shm_pool> shm_pool(
       wl_shm_create_pool(globals.shm.get(), shared_memory.handle().fd,
                          shared_memory.requested_size()));
   for (size_t i = 0; i < kBuffers; ++i) {
-    buffers[i].buffer.reset(static_cast<wl_buffer*>(wl_shm_pool_create_buffer(
-        shm_pool.get(), i * kBufferSize, kWidth, kHeight, kStride, kFormat)));
+    buffers[i].buffer.reset(static_cast<wl_buffer*>(
+        wl_shm_pool_create_buffer(shm_pool.get(), i * buffer_size(), width_,
+                                  height_, stride(), kFormat)));
     if (!buffers[i].buffer) {
       LOG(ERROR) << "Can't create buffer";
       return 1;
     }
     buffers[i].sk_surface = SkSurface::MakeRasterDirect(
-        SkImageInfo::Make(kWidth, kHeight, kColorType, kUnpremul_SkAlphaType),
-        static_cast<uint8_t*>(shared_memory.memory()) + kBufferSize * i,
-        kStride);
+        SkImageInfo::Make(width_, height_, kColorType, kOpaque_SkAlphaType),
+        static_cast<uint8_t*>(shared_memory.memory()) + buffer_size() * i,
+        stride());
     if (!buffers[i].sk_surface) {
       LOG(ERROR) << "Can't create SkSurface";
       return 1;
     }
     wl_buffer_add_listener(buffers[i].buffer.get(), &buffer_listener,
                            &buffers[i]);
   }
 
   std::unique_ptr<wl_surface> surface(static_cast<wl_surface*>(
       wl_compositor_create_surface(globals.compositor.get())));
   if (!surface) {
     LOG(ERROR) << "Can't create surface";
     return 1;
   }
 
   std::unique_ptr<wl_region> opaque_region(static_cast<wl_region*>(
       wl_compositor_create_region(globals.compositor.get())));
   if (!opaque_region) {
     LOG(ERROR) << "Can't create region";
     return 1;
   }
 
-  wl_region_add(opaque_region.get(), 0, 0, kWidth, kHeight);
+  wl_region_add(opaque_region.get(), 0, 0, width_, height_);
   wl_surface_set_opaque_region(surface.get(), opaque_region.get());
 
   std::unique_ptr<wl_shell_surface> shell_surface(
       static_cast<wl_shell_surface*>(
           wl_shell_get_shell_surface(globals.shell.get(), surface.get())));
   if (!shell_surface) {
     LOG(ERROR) << "Can't get shell surface";
     return 1;
   }
 
   wl_shell_surface_set_title(shell_surface.get(), "Test Client");
-  wl_shell_surface_set_toplevel(shell_surface.get());
+  if (fullscreen_) {
+    wl_shell_surface_set_fullscreen(shell_surface.get(),
+                                    WL_SHELL_SURFACE_FULLSCREEN_METHOD_DEFAULT,
+                                    0, nullptr);
+  } else {
+    wl_shell_surface_set_toplevel(shell_surface.get());
+  }
 
   EventTimeStack event_times;
 
   std::unique_ptr<wl_pointer> pointer(
       static_cast<wl_pointer*>(wl_seat_get_pointer(globals.seat.get())));
   if (!pointer) {
     LOG(ERROR) << "Can't get pointer";
     return 1;
   }
 
@@ skipping 11 matching lines @@
   }
 
   wl_touch_listener touch_listener = {TouchDown, TouchUp, TouchMotion,
                                       TouchFrame, TouchCancel};
   wl_touch_add_listener(touch.get(), &touch_listener, &event_times);
 
   Frame frame;
   std::unique_ptr<wl_callback> frame_callback;
   wl_callback_listener frame_listener = {FrameCallback};
 
+  uint32_t frames = 0;
+  base::TimeTicks benchmark_time = base::TimeTicks::Now();
+  base::TimeDelta benchmark_interval =
+      base::TimeDelta::FromSeconds(kBenchmarkInterval);
+
   do {
     if (frame.callback_pending)
       continue;
 
     Buffer* buffer =
         std::find_if(std::begin(buffers), std::end(buffers),
                      [](const Buffer& buffer) { return !buffer.busy; });
     if (buffer == std::end(buffers))
       continue;
 
+    base::TimeTicks current_time = base::TimeTicks::Now();
+    if ((current_time - benchmark_time) > benchmark_interval) {
+      std::cout << frames << " frames in " << benchmark_interval.InSeconds()

[Daniele Castagna, 2016/11/05 21:49:19]

Couldn't we just print this info to the canvas itself?

[reveman, 2016/11/05 22:38:20]

Yes, lets add a --fps-counter flag for that in a follow up patch. Console output
is still useful when running this remotely and it's guaranteed to not interfere
with measurements.

+                << " seconds: "
+                << static_cast<double>(frames) / benchmark_interval.InSeconds()
+                << " fps" << std::endl;
+      benchmark_time = current_time;
+      frames = 0;
+    }
+
     SkCanvas* canvas = buffer->sk_surface->getCanvas();
     canvas->save();
 
-    // Clear background to black.
-    canvas->clear(SK_ColorBLACK);
-
-    // Split buffer into one horizontal rectangle for each event received since
-    // last frame. Latest event at the top.
-    if (!event_times.empty()) {
-      double y = 0;
-      double height = static_cast<double>(kHeight) / event_times.size();
+    if (event_times.empty()) {
+      canvas->clear(SK_ColorBLACK);
+    } else {
+      // Split buffer into one horizontal rectangle for each event received
+      // since last frame. Latest event at the top.
+      int y = 0;
+      int h = (height_ + (event_times.size() / 2)) / event_times.size();

[Daniele Castagna, 2016/11/05 21:49:19]

Is the + event_time.size/2 to make sure it'll cover the whole canvas?

[reveman, 2016/11/05 22:38:20]

Yes, added a comment to make that clear in latest patch.

       while (!event_times.empty()) {
-        SkRect rect = SkRect::MakeXYWH(0, y, kWidth, height);
+        SkIRect rect = SkIRect::MakeXYWH(0, y, width_, h);
         SkPaint paint;
         paint.setColor(SkColorSetRGB((event_times.back() & 0x0000ff) >> 0,
                                      (event_times.back() & 0x00ff00) >> 8,
                                      (event_times.back() & 0xff0000) >> 16));
-        canvas->drawRect(rect, paint);
+        canvas->drawIRect(rect, paint);
         event_times.pop_back();
-        y += height;
+        y += h;
       }
     }
 
-    // Draw a blue rotating rectangle on top.
-    canvas->translate(SkIntToScalar(kWidth / 2), SkIntToScalar(kHeight / 2));
-    canvas->rotate(SkDoubleToScalar((frame.time / 1000.0f) * kRotationSpeed));
-    SkRect rect = SkRect::MakeXYWH(-(kWidth / 4.0f), -(kHeight / 4.0f),
-                                   kWidth / 2.0f, kHeight / 2.0f);
+    // Draw rotating rects.
+    SkScalar half_width = SkScalarHalf(width_);
+    SkScalar half_height = SkScalarHalf(height_);
+    SkIRect rect =
+        SkIRect::MakeXYWH(-SkScalarHalf(half_width), -SkScalarHalf(half_height),
+                          half_width, half_height);
+    SkScalar rotation = SkScalarMulDiv(frame.time, kRotationSpeed, 1000);
     SkPaint paint;
-    paint.setColor(SK_ColorBLUE);
-    canvas->drawRect(rect, paint);
-
+    canvas->translate(half_width, half_height);
+    for (size_t i = 0; i < rects_; ++i) {
+      const SkColor kColors[] = {SK_ColorBLUE, SK_ColorGREEN,
+                                 SK_ColorRED,  SK_ColorYELLOW,
+                                 SK_ColorCYAN, SK_ColorMAGENTA};
+      paint.setColor(SkColorSetA(kColors[i % arraysize(kColors)], 0xA0));
+      canvas->rotate(rotation / rects_);
+      canvas->drawIRect(rect, paint);
+    }
     canvas->restore();
 
+    wl_surface_set_buffer_scale(surface.get(), scale_);
     wl_surface_attach(surface.get(), buffer->buffer.get(), 0, 0);
     buffer->busy = true;
 
     frame_callback.reset(wl_surface_frame(surface.get()));
     wl_callback_add_listener(frame_callback.get(), &frame_listener, &frame);
     frame.callback_pending = true;
 
+    ++frames;
+
     wl_surface_commit(surface.get());
-    wl_display_flush(display.get());
   } while (wl_display_dispatch(display.get()) != -1);
 
   return 0;
 }
 
 }  // namespace clients
 }  // namespace wayland
 }  // namespace exo
 
-int main() {
-  return exo::wayland::clients::MotionEvents().Run();
+namespace switches {
+
+// Specifies the client buffer size.
+const char kSize[] = "size";
+
+// Specifies the client scale factor.

[Daniele Castagna, 2016/11/05 21:49:20]

You might want to expand a little on that. If I were just reading this I'd
expect that setting scale to 2 would make the client bigger, but it actually has
the inverse effect.

[reveman, 2016/11/05 22:38:20]

Done.

+const char kScale[] = "scale";
+
+// Specifies the number of rotating rects to draw.
+const char kRects[] = "rects";
+
+// Specifies if client should be fullscreen.
+const char kFullscreen[] = "fullscreen";
+
+}  // namespace switches
+
+int main(int argc, char* argv[]) {
+  base::CommandLine command_line(argc, argv);
+
+  int width = 256;
+  int height = 256;
+  if (command_line.HasSwitch(switches::kSize)) {
+    std::string size_str = command_line.GetSwitchValueASCII(switches::kSize);
+    if (sscanf(size_str.c_str(), "%dx%d", &width, &height) != 2) {
+      LOG(ERROR) << "Invalid value for " << switches::kSize;
+      return 1;
+    }
+  }
+
+  int scale = 1;
+  if (command_line.HasSwitch(switches::kScale) &&
+      !base::StringToInt(command_line.GetSwitchValueASCII(switches::kScale),
+                         &scale)) {
+    LOG(ERROR) << "Invalid value for " << switches::kScale;
+    return 1;
+  }
+
+  size_t rects = 1;
+  if (command_line.HasSwitch(switches::kRects) &&
+      !base::StringToSizeT(command_line.GetSwitchValueASCII(switches::kRects),
+                           &rects)) {
+    LOG(ERROR) << "Invalid value for " << switches::kRects;
+    return 1;
+  }
+
+  bool fullscreen = command_line.HasSwitch(switches::kFullscreen);
+
+  exo::wayland::clients::MotionEvents client(width, height, scale, rects,
+                                             fullscreen);
+  return client.Run();
 }