player_x11 : change X/GL thread to message loop for injecting task

media/tools/player_x11/player_x11.cc

 // Copyright (c) 2010 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 <iostream>
 #include <signal.h>
 #include <X11/Xlib.h>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
@@ skipping 105 matching lines @@
 
   // And starts the playback.
   (*pipeline)->SetPlaybackRate(1.0f);
   return true;
 }
 
 void TerminateHandler(int signal) {
   g_running = false;
 }
 
+void PeriodicalUpdate(MessageLoop* message_loop, bool audio_only) {
+  if (!g_running) {
+    message_loop->Quit();
+    return;
+  }
+
+  // Consume all the X events
+  while (XPending(g_display)) {
+    XEvent e;
+    XNextEvent(g_display, &e);
+    if (e.type == Expose) {
+      if (!audio_only) {
+        // Tell the renderer to paint.
+        DCHECK(Renderer::instance());
+        Renderer::instance()->Paint();
+      }
+    } else if (e.type == ButtonPress) {
+      g_running = false;
+      message_loop->Quit();
+      return;
+    }
+  }
+
+  message_loop->PostDelayedTask(FROM_HERE,
+      NewRunnableFunction(PeriodicalUpdate, message_loop, audio_only), 10);
+}
+
 int main(int argc, char** argv) {
   // Read arguments.
   if (argc == 1) {
     std::cout << "Usage: " << argv[0] << " --file=FILE" << std::endl
               << std::endl
               << "Optional arguments:" << std::endl
               << "  [--enable-openmax]"
               << "  [--audio]"
               << "  [--alsa-device=DEVICE]" << std::endl;
     return 1;
@@ skipping 21 matching lines @@
   thread.reset(new base::Thread("PipelineThread"));
   thread->Start();
   if (InitPipeline(thread->message_loop(), filename.c_str(),
                    enable_audio, &pipeline)) {
     // Main loop of the application.
     g_running = true;
 
     // Check if video is present.
     audio_only = !pipeline->IsRendered(media::mime_type::kMajorTypeVideo);
 
-    while (g_running) {
-      if (XPending(g_display)) {
-        XEvent e;
-        XNextEvent(g_display, &e);
-        if (e.type == Expose) {
-          if (!audio_only) {
-            // Tell the renderer to paint.
-            DCHECK(Renderer::instance());
-            Renderer::instance()->Paint();
-          }
-        } else if (e.type == ButtonPress) {
-          // Stop the playback.
-          break;
-        }
-      } else {
-        // If there's no event in the queue, make an expose event.
-        XEvent event;
-        event.type = Expose;
-        XSendEvent(g_display, g_window, true, ExposureMask, &event);
+    MessageLoop message_loop;
+    if (!audio_only) {
+      // Tell the renderer to paint.
+      DCHECK(Renderer::instance());
+      Renderer::instance()->set_glx_thread_message_loop(&message_loop);
+    }
 
-        // TODO(hclam): It is rather arbitrary to sleep for 10ms and wait
-        // for the next event. We should submit an expose event when
-        // a frame is available but not firing an expose event every 10ms.
-        usleep(10000);
-      }
-    }
+    message_loop.PostTask(FROM_HERE,
+        NewRunnableFunction(PeriodicalUpdate, &message_loop, audio_only));
+    message_loop.Run();
+
     pipeline->Stop(NULL);
   } else{
     std::cout << "Pipeline initialization failed..." << std::endl;
   }
 
   // Cleanup tasks.
   thread->Stop();
   XDestroyWindow(g_display, g_window);
   XCloseDisplay(g_display);
   return 0;
 }