exo: Add --transparent-background to wayland 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 <fcntl.h>
 #include <linux-dmabuf-unstable-v1-client-protocol.h>
@@ skipping 365 matching lines @@
 }  // namespace
 
 class MotionEvents {
  public:
   MotionEvents(size_t width,
                size_t height,
                int scale,
                size_t num_rects,
                size_t max_frames_pending,
                bool fullscreen,
+               bool transparent_background,
                bool show_fps_counter,
                size_t num_benchmark_runs,
                base::TimeDelta benchmark_interval,
                const std::string* use_drm)
       : width_(width),
         height_(height),
         scale_(scale),
         num_rects_(num_rects),
         max_frames_pending_(max_frames_pending),
         fullscreen_(fullscreen),
+        transparent_background_(transparent_background),
         show_fps_counter_(show_fps_counter),
         num_benchmark_runs_(num_benchmark_runs),
         benchmark_interval_(benchmark_interval),
         use_drm_(use_drm) {}
 
   // Initialize and run client main loop.
   int Run();
 
  private:
   bool CreateBuffer(Buffer* buffer);
 
   const size_t width_;
   const size_t height_;
   const int scale_;
   const size_t num_rects_;
   const size_t max_frames_pending_;
   const bool fullscreen_;
+  const bool transparent_background_;
   const bool show_fps_counter_;
   const size_t num_benchmark_runs_;
   const base::TimeDelta benchmark_interval_;
   const std::string* use_drm_;
 
   std::unique_ptr<wl_display> display_;
   Globals globals_;
 
 #if defined(OZONE_PLATFORM_GBM)
   base::ScopedFD drm_fd_;
@@ skipping 130 matching lines @@
                            &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;
+  if (!transparent_background_) {
+    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, width_, height_);
+    wl_surface_set_opaque_region(surface.get(), opaque_region.get());
   }
 
-  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(), kClientTitle);
 
@@ skipping 101 matching lines @@
           presentation.latency_time = base::TimeDelta();
           presentation.num_frames_presented = kBenchmarkWarmupFrames;
           presentation.num_events_presented = 0;
         }
 
         cpu_time_start = base::ThreadTicks::Now();
       }
 
       SkCanvas* canvas = buffer->sk_surface->getCanvas();
       if (event_times.empty()) {
-        canvas->clear(SK_ColorBLACK);
+        canvas->clear(transparent_background_ ? SK_ColorTRANSPARENT
+                                              : SK_ColorBLACK);
       } else {
         // Split buffer into one horizontal rectangle for each event received
         // since last frame. Latest event at the top.
         int y = 0;
         // Note: Rounding up to ensure we cover the whole canvas.
         int h = (height_ + (event_times.size() / 2)) / event_times.size();
         while (!event_times.empty()) {
           SkIRect rect = SkIRect::MakeXYWH(0, y, width_, h);
           SkPaint paint;
           paint.setColor(SkColorSetRGB((event_times.back() & 0x0000ff) >> 0,
@@ skipping 199 matching lines @@
 
 // Specifies the number of rotating rects to draw.
 const char kNumRects[] = "num-rects";
 
 // Specifies the maximum number of pending frames.
 const char kMaxFramesPending[] = "max-frames-pending";
 
 // Specifies if client should be fullscreen.
 const char kFullscreen[] = "fullscreen";
 
+// Specifies if the background should be transparent.
+const char kTransparentBackground[] = "transparent-background";
+
 // Specifies if FPS counter should be shown.
 const char kShowFpsCounter[] = "show-fps-counter";
 
 // Enables benchmark mode and specifies the number of benchmark runs to
 // perform before client will exit. Client will print the results to
 // standard output as a tab seperated list.
 //
 //  The output format is:
 //   "frames wall-time-ms cpu-time-ms"
 const char kBenchmark[] = "benchmark";
@@ skipping 66 matching lines @@
 
   std::unique_ptr<std::string> use_drm;
   if (command_line->HasSwitch(switches::kUseDrm)) {
     use_drm.reset(
         new std::string(command_line->GetSwitchValueASCII(switches::kUseDrm)));
   }
 
   exo::wayland::clients::MotionEvents client(
       width, height, scale, num_rects, max_frames_pending,
       command_line->HasSwitch(switches::kFullscreen),
+      command_line->HasSwitch(switches::kTransparentBackground),
       command_line->HasSwitch(switches::kShowFpsCounter), num_benchmark_runs,
       base::TimeDelta::FromMilliseconds(benchmark_interval_ms), use_drm.get());
   return client.Run();
 }