Revert r180578, r180591, and r180604 from 1410 branch.

media/tools/player_x11/player_x11.cc

 // Copyright (c) 2012 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 <signal.h>
 
 #include <iostream>  // NOLINT
 
 #include "base/at_exit.h"
 #include "base/bind.h"
@@ skipping 26 matching lines @@
 #include <X11/Xlib.h>
 #include "media/tools/player_x11/gl_video_renderer.h"
 #include "media/tools/player_x11/x11_video_renderer.h"
 
 static Display* g_display = NULL;
 static Window g_window = 0;
 static bool g_running = false;
 
 media::AudioManager* g_audio_manager = NULL;
 
+media::VideoRendererBase* g_video_renderer = NULL;
+
 scoped_refptr<media::FileDataSource> CreateFileDataSource(
     const std::string& file_path) {
   scoped_refptr<media::FileDataSource> file_data_source(
       new media::FileDataSource());
   CHECK(file_data_source->Initialize(base::FilePath(file_path)));
   return file_data_source;
 }
 
 // Initialize X11. Returns true if successful. This method creates the X11
 // window. Further initialization is done in X11VideoRenderer.
@@ skipping 17 matching lines @@
   XSelectInput(g_display, g_window,
                ExposureMask | ButtonPressMask | KeyPressMask);
   XMapWindow(g_display, g_window);
   return true;
 }
 
 void SetOpaque(bool /*opaque*/) {
 }
 
 typedef base::Callback<void(media::VideoFrame*)> PaintCB;
-void Paint(MessageLoop* message_loop, const PaintCB& paint_cb,
-           const scoped_refptr<media::VideoFrame>& video_frame) {
+void Paint(MessageLoop* message_loop, const PaintCB& paint_cb) {
   if (message_loop != MessageLoop::current()) {
     message_loop->PostTask(FROM_HERE, base::Bind(
-        &Paint, message_loop, paint_cb, video_frame));
+        &Paint, message_loop, paint_cb));
     return;
   }
 
-  paint_cb.Run(video_frame);
+  scoped_refptr<media::VideoFrame> video_frame;
+  g_video_renderer->GetCurrentFrame(&video_frame);
+  if (video_frame)
+    paint_cb.Run(video_frame);
+  g_video_renderer->PutCurrentFrame(video_frame);
 }
 
 static void OnBufferingState(media::Pipeline::BufferingState buffering_state) {}
 
 // TODO(vrk): Re-enabled audio. (crbug.com/112159)
 bool InitPipeline(const scoped_refptr<base::MessageLoopProxy>& message_loop,
                   const scoped_refptr<media::DataSource>& data_source,
                   const PaintCB& paint_cb,
                   bool /* enable_audio */,
                   scoped_refptr<media::Pipeline>* pipeline,
                   MessageLoop* paint_message_loop) {
   // Create our filter factories.
   scoped_ptr<media::FilterCollection> collection(
       new media::FilterCollection());
   collection->SetDemuxer(new media::FFmpegDemuxer(message_loop, data_source));
   collection->GetAudioDecoders()->push_back(new media::FFmpegAudioDecoder(
       message_loop));
   collection->GetVideoDecoders()->push_back(new media::FFmpegVideoDecoder(
       message_loop));
 
   // Create our video renderer and save a reference to it for painting.
-  scoped_ptr<media::VideoRenderer> video_renderer(new media::VideoRendererBase(
+  g_video_renderer = new media::VideoRendererBase(
       message_loop,
       media::SetDecryptorReadyCB(),
       base::Bind(&Paint, paint_message_loop, paint_cb),
       base::Bind(&SetOpaque),
-      true));
-  collection->SetVideoRenderer(video_renderer.Pass());
+      true);
+  collection->AddVideoRenderer(g_video_renderer);
 
-  scoped_ptr<media::AudioRenderer> audio_renderer(new media::AudioRendererImpl(
+  collection->AddAudioRenderer(new media::AudioRendererImpl(
       message_loop,
       new media::NullAudioSink(),
       media::SetDecryptorReadyCB()));
-  collection->SetAudioRenderer(audio_renderer.Pass());
 
   // Create the pipeline and start it.
   *pipeline = new media::Pipeline(message_loop, new media::MediaLog());
   media::PipelineStatusNotification note;
   (*pipeline)->Start(
       collection.Pass(), base::Closure(), media::PipelineStatusCB(),
       note.Callback(), base::Bind(&OnBufferingState));
 
   // Wait until the pipeline is fully initialized.
   note.Wait();
@@ skipping 154 matching lines @@
   // Release callback which releases video renderer. Do this before cleaning up
   // X below since the video renderer has some X cleanup duties as well.
   paint_cb.Reset();
 
   XDestroyWindow(g_display, g_window);
   XCloseDisplay(g_display);
   g_audio_manager = NULL;
 
   return 0;
 }