Remove calls to deprecated MessageLoop methods on Windows and Linux.

media/gpu/rendering_helper.cc

 // Copyright 2013 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 "media/gpu/rendering_helper.h"
 
 #include <string.h>
 
 #include <algorithm>
 #include <memory>
 #include <numeric>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/command_line.h"
 #include "base/mac/scoped_nsautorelease_pool.h"
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
+#include "base/single_thread_task_runner.h"
 #include "base/strings/stringize_macros.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/time/time.h"
 #include "build/build_config.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 #include "ui/gl/init/gl_factory.h"
 
 #if defined(OS_WIN)
@@ skipping 522 matching lines @@
 
   Clear();
   done->Signal();
 }
 
 void RenderingHelper::CreateTexture(uint32_t texture_target,
                                     uint32_t* texture_id,
                                     const gfx::Size& size,
                                     base::WaitableEvent* done) {
   if (base::MessageLoop::current() != message_loop_) {
-    message_loop_->PostTask(
+    message_loop_->task_runner()->PostTask(
         FROM_HERE,
         base::Bind(&RenderingHelper::CreateTexture, base::Unretained(this),
                    texture_target, texture_id, size, done));
     return;
   }
   glGenTextures(1, texture_id);
   glBindTexture(texture_target, *texture_id);
   if (texture_target == GL_TEXTURE_2D) {
     glTexImage2D(GL_TEXTURE_2D,
                  0,
@@ skipping 54 matching lines @@
   video->pending_frames.push(video_frame);
 
   if (video->frames_to_drop > 0 && video->pending_frames.size() > 1) {
     --video->frames_to_drop;
     video->pending_frames.pop();
   }
 
   // Schedules the first RenderContent() if need.
   if (scheduled_render_time_.is_null()) {
     scheduled_render_time_ = base::TimeTicks::Now();
-    message_loop_->PostTask(FROM_HERE, render_task_.callback());
+    message_loop_->task_runner()->PostTask(FROM_HERE, render_task_.callback());
   }
 }
 
 void RenderingHelper::RenderTexture(uint32_t texture_target,
                                     uint32_t texture_id) {
   // The ExternalOES sampler is bound to GL_TEXTURE1 and the Texture2D sampler
   // is bound to GL_TEXTURE0.
   if (texture_target == GL_TEXTURE_2D) {
     glActiveTexture(GL_TEXTURE0 + 0);
   } else if (texture_target == GL_TEXTURE_EXTERNAL_OES) {
@@ skipping 229 matching lines @@
     int64_t intervals = (target - vsync_timebase_) / vsync_interval_;
     target = vsync_timebase_ + intervals * vsync_interval_;
   }
 
   // When the rendering falls behind, drops frames.
   while (scheduled_render_time_ < target) {
     scheduled_render_time_ += frame_duration_;
     DropOneFrameForAllVideos();
   }
 
-  message_loop_->PostDelayedTask(FROM_HERE, render_task_.callback(),
-                                 target - now);
+  message_loop_->task_runner()->PostDelayedTask(
+      FROM_HERE, render_task_.callback(), target - now);
 }
 }  // namespace media