Remove MessageLoop::current() from rendering_helper.cc.

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/threading/thread_task_runner_handle.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)
 #include <windows.h>
 #endif
@@ skipping 299 matching lines @@
   }
 
   render_task_.Reset(
       base::Bind(&RenderingHelper::RenderContent, base::Unretained(this)));
 
   frame_duration_ = params.rendering_fps > 0
                         ? base::TimeDelta::FromSeconds(1) / params.rendering_fps
                         : base::TimeDelta();
 
   render_as_thumbnails_ = params.render_as_thumbnails;
-  message_loop_ = base::MessageLoop::current();
+  task_runner_ = base::ThreadTaskRunnerHandle::Get();
 
   gl_surface_ = gl::init::CreateViewGLSurface(window_);
 #if defined(USE_OZONE)
   gl_surface_->Resize(platform_window_delegate_->GetSize(), 1.f, true);
 #endif  // defined(USE_OZONE)
   screen_size_ = gl_surface_->GetSize();
 
   gl_context_ = gl::init::CreateGLContext(nullptr, gl_surface_.get(),
                                           gl::PreferIntegratedGpu);
   CHECK(gl_context_->MakeCurrent(gl_surface_.get()));
@@ skipping 178 matching lines @@
           base::Bind(&WaitForSwapAck, wait_for_swap_ack.QuitClosure()));
       wait_for_swap_ack.Run();
     } else {
       gl_surface_->SwapBuffers();
     }
   }
   glDeleteTextures(1, &texture_id);
 }
 
 void RenderingHelper::UnInitialize(base::WaitableEvent* done) {
-  CHECK_EQ(base::MessageLoop::current(), message_loop_);
+  CHECK(task_runner_->BelongsToCurrentThread());
 
   render_task_.Cancel();
 
   if (render_as_thumbnails_) {
     glDeleteTextures(1, &thumbnails_texture_id_);
     glDeleteFramebuffersEXT(1, &thumbnails_fbo_id_);
   }
 
   gl_context_->ReleaseCurrent(gl_surface_.get());
   gl_context_ = NULL;
   gl_surface_ = NULL;
 
   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_->task_runner()->PostTask(
+  if (!task_runner_->BelongsToCurrentThread()) {
+    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 14 matching lines @@
 }
 
 // Helper function to set GL viewport.
 static inline void GLSetViewPort(const gfx::Rect& area) {
   glViewport(area.x(), area.y(), area.width(), area.height());
   glScissor(area.x(), area.y(), area.width(), area.height());
 }
 
 void RenderingHelper::RenderThumbnail(uint32_t texture_target,
                                       uint32_t texture_id) {
-  CHECK_EQ(base::MessageLoop::current(), message_loop_);
+  CHECK(task_runner_->BelongsToCurrentThread());
   const int width = thumbnail_size_.width();
   const int height = thumbnail_size_.height();
   const int thumbnails_in_row = thumbnails_fbo_size_.width() / width;
   const int thumbnails_in_column = thumbnails_fbo_size_.height() / height;
   const int row = (frame_count_ / thumbnails_in_row) % thumbnails_in_column;
   const int col = frame_count_ % thumbnails_in_row;
 
   gfx::Rect area(col * width, row * height, width, height);
 
   glUniform1i(glGetUniformLocation(program_, "tex_flip"), 0);
   glBindFramebufferEXT(GL_FRAMEBUFFER, thumbnails_fbo_id_);
   GLSetViewPort(area);
   RenderTexture(texture_target, texture_id);
   glBindFramebufferEXT(GL_FRAMEBUFFER,
                        gl_surface_->GetBackingFramebufferObject());
 
   // Need to flush the GL commands before we return the tnumbnail texture to
   // the decoder.
   glFlush();
   ++frame_count_;
 }
 
 void RenderingHelper::QueueVideoFrame(
     size_t window_id,
     scoped_refptr<VideoFrameTexture> video_frame) {
-  CHECK_EQ(base::MessageLoop::current(), message_loop_);
+  CHECK(task_runner_->BelongsToCurrentThread());
   RenderedVideo* video = &videos_[window_id];
   DCHECK(!video->is_flushing);
 
   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_->task_runner()->PostTask(FROM_HERE, render_task_.callback());
+    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) {
     glActiveTexture(GL_TEXTURE0 + 1);
   }
   glBindTexture(texture_target, texture_id);
   glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
   glBindTexture(texture_target, 0);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
 void RenderingHelper::DeleteTexture(uint32_t texture_id) {
-  CHECK_EQ(base::MessageLoop::current(), message_loop_);
+  CHECK(task_runner_->BelongsToCurrentThread());
   glDeleteTextures(1, &texture_id);
   CHECK_EQ(static_cast<int>(glGetError()), GL_NO_ERROR);
 }
 
 gl::GLContext* RenderingHelper::GetGLContext() {
   return gl_context_.get();
 }
 
 void* RenderingHelper::GetGLDisplay() {
   return gl_surface_->GetDisplay();
 }
 
 void RenderingHelper::Clear() {
   videos_.clear();
-  message_loop_ = NULL;
+  task_runner_ = nullptr;
   gl_context_ = NULL;
   gl_surface_ = NULL;
 
   render_as_thumbnails_ = false;
   frame_count_ = 0;
   thumbnails_fbo_id_ = 0;
   thumbnails_texture_id_ = 0;
 }
 
 void RenderingHelper::GetThumbnailsAsRGB(std::vector<unsigned char>* rgb,
@@ skipping 29 matching lines @@
   *alpha_solid = solid;
 
   done->Signal();
 }
 
 void RenderingHelper::Flush(size_t window_id) {
   videos_[window_id].is_flushing = true;
 }
 
 void RenderingHelper::RenderContent() {
-  CHECK_EQ(base::MessageLoop::current(), message_loop_);
+  CHECK(task_runner_->BelongsToCurrentThread());
 
   // Update the VSync params.
   //
   // It's safe to use Unretained here since |rendering_thread_| will be stopped
   // in VideoDecodeAcceleratorTest.TearDown(), while the |rendering_helper_| is
   // a member of that class. (See video_decode_accelerator_unittest.cc.)
   gfx::VSyncProvider* vsync_provider = gl_surface_->GetVSyncProvider();
   if (vsync_provider && !ignore_vsync_) {
     vsync_provider->GetVSyncParameters(base::Bind(
         &RenderingHelper::UpdateVSyncParameters, base::Unretained(this),
@@ skipping 144 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_->task_runner()->PostDelayedTask(
-      FROM_HERE, render_task_.callback(), target - now);
+  task_runner_->PostDelayedTask(FROM_HERE, render_task_.callback(),
+                                target - now);
 }
 }  // namespace media