move quit of paint message_loop into OnStop() in dervied classes

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/keysym.h>
 #include <X11/Xlib.h>
 
 #include "base/at_exit.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/scoped_ptr.h"
 #include "base/thread.h"
-#include "base/waitable_event.h"
+#include "media/base/callback.h"
 #include "media/base/media.h"
 #include "media/base/media_switches.h"
 #include "media/base/pipeline_impl.h"
 #include "media/filters/audio_renderer_impl.h"
 #include "media/filters/ffmpeg_audio_decoder.h"
 #include "media/filters/ffmpeg_demuxer.h"
 #include "media/filters/ffmpeg_video_decoder.h"
 #include "media/filters/file_data_source.h"
 #include "media/filters/null_audio_renderer.h"
 #include "media/filters/omx_video_decoder.h"
 
 #if defined(RENDERER_GL)
 #include "media/tools/player_x11/gl_video_renderer.h"
 typedef GlVideoRenderer Renderer;
 #elif defined(RENDERER_GLES)
 #include "media/tools/player_x11/gles_video_renderer.h"
 typedef GlesVideoRenderer Renderer;
 #elif defined(RENDERER_X11)
 #include "media/tools/player_x11/x11_video_renderer.h"
 typedef X11VideoRenderer Renderer;
 #else
 #error No video renderer defined.
 #endif
 
 Display* g_display = NULL;
 Window g_window = 0;
 bool g_running = false;
 
+void Quit(MessageLoop* message_loop) {
+  message_loop->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+}
+
 // Initialize X11. Returns true if successful. This method creates the X11
 // window. Further initialization is done in X11VideoRenderer.
 bool InitX11() {
   g_display = XOpenDisplay(NULL);
   if (!g_display) {
     std::cout << "Error - cannot open display" << std::endl;
     return false;
   }
 
   // Get properties of the screen.
@@ skipping 70 matching lines @@
   return true;
 }
 
 void TerminateHandler(int signal) {
   g_running = false;
 }
 
 void PeriodicalUpdate(
     media::PipelineImpl* pipeline,
     MessageLoop* message_loop,
-    base::WaitableEvent* stop_event,
     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);
@@ skipping 21 matching lines @@
                        &depth);
           base::TimeDelta time = pipeline->GetMediaDuration();
           pipeline->Seek(time*e.xbutton.x/width, NULL);
         }
         break;
       case KeyPress:
         {
           KeySym key = XKeycodeToKeysym(g_display, e.xkey.keycode, 0);
           if (key == XK_Escape) {
             g_running = false;
-            // QuitNow is more responsive than Quit since renderer_base is till
-            // posting paint messages.
-            pipeline->Stop(NewCallback(stop_event,
-                                       &base::WaitableEvent::Signal));
-            message_loop->Quit();
+            // Quit message_loop only when pipeline is fully stopped.
+            pipeline->Stop(media::TaskToCallbackAdapter::NewCallback(
+                NewRunnableFunction(Quit, message_loop)));
             return;
           } else if (key == XK_space) {
             if (pipeline->GetPlaybackRate() < 0.01f) // paused
               pipeline->SetPlaybackRate(1.0f);
             else
               pipeline->SetPlaybackRate(0.0f);
           }
         }
         break;
       default:
         break;
     }
   }
 
   message_loop->PostDelayedTask(FROM_HERE,
       NewRunnableFunction(PeriodicalUpdate, pipeline,
-                          message_loop, stop_event, audio_only), 10);
+                          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]"
@@ skipping 17 matching lines @@
 
   // Initialize X11.
   if (!InitX11())
     return 1;
 
   // Initialize the pipeline thread and the pipeline.
   base::AtExitManager at_exit;
   scoped_ptr<base::Thread> thread;
   scoped_refptr<media::PipelineImpl> pipeline;
   MessageLoop message_loop;
-  base::WaitableEvent stop_event(false, false);
   thread.reset(new base::Thread("PipelineThread"));
   thread->Start();
   if (InitPipeline(thread->message_loop(), filename.c_str(),
                    enable_audio, &pipeline, &message_loop)) {
     // Main loop of the application.
     g_running = true;
 
     // Check if video is present.
     audio_only = !pipeline->IsRendered(media::mime_type::kMajorTypeVideo);
 
     message_loop.PostTask(FROM_HERE,
         NewRunnableFunction(PeriodicalUpdate, pipeline.get(),
-                            &message_loop, &stop_event, audio_only));
+                            &message_loop, audio_only));
     message_loop.Run();
-
-    // Need to wait for pipeline to be fully stopped before stopping the thread.
-    stop_event.Wait();
   } else{
     std::cout << "Pipeline initialization failed..." << std::endl;
   }
 
   // Cleanup tasks.
   thread->Stop();
   XDestroyWindow(g_display, g_window);
   XCloseDisplay(g_display);
   return 0;
 }