Add InProcessContextProvider and update InProcessCommandBuffer

gpu/ipc/in_process_command_buffer.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 "gpu/ipc/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "gpu/command_buffer/client/gpu_control_client.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/command_buffer/service/image_factory.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/query_manager.h"
 #include "gpu/command_buffer/service/service_utils.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "gpu/command_buffer/service/transfer_buffer_manager.h"
+#include "gpu/ipc/gpu_in_process_thread_service.h"
+#include "gpu/ipc/service/image_transport_surface.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_image.h"
 #include "ui/gl/gl_image_shared_memory.h"
 #include "ui/gl/gl_share_group.h"
 #include "ui/gl/init/gl_factory.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include "base/process/process_handle.h"
 #endif
 
 namespace gpu {
 
 namespace {
 
 base::StaticAtomicSequenceNumber g_next_command_buffer_id;
 
 template <typename T>
 static void RunTaskWithResult(base::Callback<T(void)> task,
                               T* result,
                               base::WaitableEvent* completion) {
   *result = task.Run();
   completion->Signal();
 }
 
-struct ScopedOrderNumberProcessor {
-  ScopedOrderNumberProcessor(SyncPointOrderData* order_data, uint32_t order_num)
-      : order_data_(order_data), order_num_(order_num) {
-    order_data_->BeginProcessingOrderNumber(order_num_);
+class GpuInProcessThreadHolder : public base::Thread {
+ public:
+  GpuInProcessThreadHolder()
+      : base::Thread("GpuThread"),
+        sync_point_manager_(new SyncPointManager(false)) {
+    Start();
   }
 
-  ~ScopedOrderNumberProcessor() {
-    order_data_->FinishProcessingOrderNumber(order_num_);
+  ~GpuInProcessThreadHolder() override { Stop(); }
+
+  const scoped_refptr<InProcessCommandBuffer::Service>& GetGpuThreadService() {
+    if (!gpu_thread_service_) {
+      gpu_thread_service_ = new GpuInProcessThreadService(
+          task_runner(), sync_point_manager_.get(), nullptr, nullptr);
+    }
+    return gpu_thread_service_;
   }
 
  private:
-  SyncPointOrderData* order_data_;
-  uint32_t order_num_;
-};
-
-struct GpuInProcessThreadHolder {
-  GpuInProcessThreadHolder()
-      : sync_point_manager(new SyncPointManager(false)),
-        gpu_thread(new GpuInProcessThread(sync_point_manager.get())) {}
-  std::unique_ptr<SyncPointManager> sync_point_manager;
-  scoped_refptr<InProcessCommandBuffer::Service> gpu_thread;
+  std::unique_ptr<SyncPointManager> sync_point_manager_;
+  scoped_refptr<InProcessCommandBuffer::Service> gpu_thread_service_;
 };
 
 base::LazyInstance<GpuInProcessThreadHolder> g_default_service =
     LAZY_INSTANCE_INITIALIZER;
 
 class ScopedEvent {
  public:
   explicit ScopedEvent(base::WaitableEvent* event) : event_(event) {}
   ~ScopedEvent() { event_->Signal(); }
 
@@ skipping 34 matching lines @@
   if (service)
     return service;
 
   // Call base::ThreadTaskRunnerHandle::IsSet() to ensure that it is
   // instantiated before we create the GPU thread, otherwise shutdown order will
   // delete the ThreadTaskRunnerHandle before the GPU thread's message loop,
   // and when the message loop is shutdown, it will recreate
   // ThreadTaskRunnerHandle, which will re-add a new task to the, AtExitManager,
   // which causes a deadlock because it's already locked.
   base::ThreadTaskRunnerHandle::IsSet();
-  return g_default_service.Get().gpu_thread;
+  return g_default_service.Get().GetGpuThreadService();
 }
 
 }  // anonyous namespace
 
 InProcessCommandBuffer::Service::Service()
     : gpu_driver_bug_workarounds_(base::CommandLine::ForCurrentProcess()) {}
 
 InProcessCommandBuffer::Service::Service(const GpuPreferences& gpu_preferences)
     : gpu_preferences_(gpu_preferences),
       gpu_driver_bug_workarounds_(base::CommandLine::ForCurrentProcess()) {}
 
+InProcessCommandBuffer::Service::Service(
+    gpu::gles2::MailboxManager* mailbox_manager,
+    scoped_refptr<gl::GLShareGroup> share_group)
+    : gpu_driver_bug_workarounds_(base::CommandLine::ForCurrentProcess()),
+      mailbox_manager_(mailbox_manager),
+      share_group_(share_group) {}
+
 InProcessCommandBuffer::Service::~Service() {}
 
 const gpu::GpuPreferences& InProcessCommandBuffer::Service::gpu_preferences() {
   return gpu_preferences_;
 }
 
 const gpu::GpuDriverBugWorkarounds&
 InProcessCommandBuffer::Service::gpu_driver_bug_workarounds() {
   return gpu_driver_bug_workarounds_;
 }
@@ skipping 113 matching lines @@
                                      &capabilities, share_group, image_factory);
 
   base::Callback<bool(void)> init_task =
       base::Bind(&InProcessCommandBuffer::InitializeOnGpuThread,
                  base::Unretained(this), params);
 
   base::WaitableEvent completion(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   bool result = false;
-  QueueTask(
-      base::Bind(&RunTaskWithResult<bool>, init_task, &result, &completion));
+  QueueTask(true, base::Bind(&RunTaskWithResult<bool>, init_task, &result,
+                             &completion));
   completion.Wait();
 
   gpu_memory_buffer_manager_ = gpu_memory_buffer_manager;
 
   if (result)
     capabilities_ = capabilities;
 
   return result;
 }
 
@@ skipping 12 matching lines @@
       &InProcessCommandBuffer::PumpCommandsOnGpuThread, gpu_thread_weak_ptr_));
   command_buffer->SetParseErrorCallback(base::Bind(
       &InProcessCommandBuffer::OnContextLostOnGpuThread, gpu_thread_weak_ptr_));
 
   gl_share_group_ = params.context_group ? params.context_group->gl_share_group_
                                          : service_->share_group();
 
   bool bind_generates_resource = false;
   scoped_refptr<gles2::FeatureInfo> feature_info =
       new gles2::FeatureInfo(service_->gpu_driver_bug_workarounds());
-  decoder_.reset(gles2::GLES2Decoder::Create(
+
+  context_group_ =
       params.context_group
           ? params.context_group->decoder_->GetContextGroup()
           : new gles2::ContextGroup(
                 service_->gpu_preferences(), service_->mailbox_manager(), NULL,
                 service_->shader_translator_cache(),
                 service_->framebuffer_completeness_cache(), feature_info,
-                bind_generates_resource, nullptr, nullptr)));
+                bind_generates_resource, nullptr, nullptr);
+
+  decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
 
   executor_.reset(new CommandExecutor(command_buffer.get(), decoder_.get(),
                                       decoder_.get()));
   command_buffer->SetGetBufferChangeCallback(base::Bind(
       &CommandExecutor::SetGetBuffer, base::Unretained(executor_.get())));
   command_buffer_ = std::move(command_buffer);
 
   decoder_->set_engine(executor_.get());
 
   if (!surface_.get()) {
-    if (params.is_offscreen)
+    if (params.is_offscreen) {
       surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
-    else
-      surface_ = gl::init::CreateViewGLSurface(params.window);
+    } else {
+      surface_ = ImageTransportSurface::CreateNativeSurface(
+          gpu_thread_weak_ptr_factory_.GetWeakPtr(), params.window,
+          gl::GLSurface::SURFACE_DEFAULT);
+      if (!surface_ || !surface_->Initialize(gl::GLSurface::SURFACE_DEFAULT)) {
+        surface_ = nullptr;
+        DLOG(ERROR) << "Failed to create surface.";
+        return false;
+      }
+    }
   }
 
   if (!surface_.get()) {
     LOG(ERROR) << "Could not create GLSurface.";
     DestroyOnGpuThread();
     return false;
   }
 
   sync_point_order_data_ = SyncPointOrderData::Create();
   sync_point_client_ = service_->sync_point_manager()->CreateSyncPointClient(
@@ skipping 82 matching lines @@
 void InProcessCommandBuffer::Destroy() {
   CheckSequencedThread();
   client_thread_weak_ptr_factory_.InvalidateWeakPtrs();
   gpu_control_client_ = nullptr;
   base::WaitableEvent completion(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   bool result = false;
   base::Callback<bool(void)> destroy_task = base::Bind(
       &InProcessCommandBuffer::DestroyOnGpuThread, base::Unretained(this));
-  QueueTask(
-      base::Bind(&RunTaskWithResult<bool>, destroy_task, &result, &completion));
+  QueueTask(false, base::Bind(&RunTaskWithResult<bool>, destroy_task, &result,
+                              &completion));
   completion.Wait();
 }
 
 bool InProcessCommandBuffer::DestroyOnGpuThread() {
   CheckSequencedThread();
   gpu_thread_weak_ptr_factory_.InvalidateWeakPtrs();
   command_buffer_.reset();
   // Clean up GL resources if possible.
   bool have_context = context_.get() && context_->MakeCurrent(surface_.get());
   if (decoder_) {
@@ skipping 38 matching lines @@
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetStateFast() {
   CheckSequencedThread();
   base::AutoLock lock(state_after_last_flush_lock_);
   if (state_after_last_flush_.generation - last_state_.generation < 0x80000000U)
     last_state_ = state_after_last_flush_;
   return last_state_;
 }
 
+void InProcessCommandBuffer::QueueTask(bool out_of_order,
+                                       const base::Closure& task) {
+  if (out_of_order) {
+    service_->ScheduleTask(task);
+    return;
+  }
+  base::AutoLock lock(task_queue_lock_);
+  SyncPointManager* sync_manager = service_->sync_point_manager();
+  uint32_t order_num =
+      sync_point_order_data_->GenerateUnprocessedOrderNumber(sync_manager);
+  task_queue_.push(base::MakeUnique<GpuTask>(task, order_num));
+  service_->ScheduleTask(
+      base::Bind(&InProcessCommandBuffer::ProcessTasksOnGpuThread,
+                 base::Unretained(this)));
+}
+
+void InProcessCommandBuffer::ProcessTasksOnGpuThread() {
+  while (executor_->scheduled()) {
+    base::AutoLock lock(task_queue_lock_);
+    if (task_queue_.empty())
+      break;
+    GpuTask* task = task_queue_.front().get();
+    sync_point_order_data_->BeginProcessingOrderNumber(task->order_number);
+    task->callback.Run();
+    if (!executor_->scheduled()) {
+      sync_point_order_data_->PauseProcessingOrderNumber(task->order_number);
+      return;
+    }
+    sync_point_order_data_->FinishProcessingOrderNumber(task->order_number);
+    task_queue_.pop();
+  }
+}
+
 CommandBuffer::State InProcessCommandBuffer::GetLastState() {
   CheckSequencedThread();
   return last_state_;
 }
 
 int32_t InProcessCommandBuffer::GetLastToken() {
   CheckSequencedThread();
   GetStateFast();
   return last_state_.token;
 }
 
-void InProcessCommandBuffer::FlushOnGpuThread(int32_t put_offset,
-                                              uint32_t order_num) {
+void InProcessCommandBuffer::FlushOnGpuThread(int32_t put_offset) {
   CheckSequencedThread();
   ScopedEvent handle_flush(&flush_event_);
   base::AutoLock lock(command_buffer_lock_);
 
   {
-    ScopedOrderNumberProcessor scoped_order_num(sync_point_order_data_.get(),
-                                                order_num);
     command_buffer_->Flush(put_offset);
     {
       // Update state before signaling the flush event.
       base::AutoLock lock(state_after_last_flush_lock_);
       state_after_last_flush_ = command_buffer_->GetLastState();
     }
-
-    // Currently the in process command buffer does not support being
-    // descheduled, if it does we would need to back off on calling the finish
-    // processing number function until the message is rescheduled and finished
-    // processing. This DCHECK is to enforce this.
-    DCHECK(error::IsError(state_after_last_flush_.error) ||
-           put_offset == state_after_last_flush_.get_offset);
   }
 
   // If we've processed all pending commands but still have pending queries,
   // pump idle work until the query is passed.
   if (put_offset == state_after_last_flush_.get_offset &&
       (executor_->HasMoreIdleWork() || executor_->HasPendingQueries())) {
     ScheduleDelayedWorkOnGpuThread();
   }
 }
 
@@ skipping 21 matching lines @@
 }
 
 void InProcessCommandBuffer::Flush(int32_t put_offset) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
-  SyncPointManager* sync_manager = service_->sync_point_manager();
-  const uint32_t order_num =
-      sync_point_order_data_->GenerateUnprocessedOrderNumber(sync_manager);
   last_put_offset_ = put_offset;
   base::Closure task = base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
-                                  gpu_thread_weak_ptr_, put_offset, order_num);
-  QueueTask(task);
+                                  gpu_thread_weak_ptr_, put_offset);
+  QueueTask(false, task);
 
   flushed_fence_sync_release_ = next_fence_sync_release_ - 1;
 }
 
 void InProcessCommandBuffer::OrderingBarrier(int32_t put_offset) {
   Flush(put_offset);
 }
 
 void InProcessCommandBuffer::WaitForTokenInRange(int32_t start, int32_t end) {
   CheckSequencedThread();
   while (!InRange(start, end, GetLastToken()) &&
-         last_state_.error == gpu::error::kNoError)
+         last_state_.error == gpu::error::kNoError) {
     flush_event_.Wait();
+  }
 }
 
 void InProcessCommandBuffer::WaitForGetOffsetInRange(int32_t start,
                                                      int32_t end) {
   CheckSequencedThread();
 
   GetStateFast();
   while (!InRange(start, end, last_state_.get_offset) &&
          last_state_.error == gpu::error::kNoError) {
     flush_event_.Wait();
     GetStateFast();
   }
 }
 
 void InProcessCommandBuffer::SetGetBuffer(int32_t shm_id) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   base::WaitableEvent completion(
       base::WaitableEvent::ResetPolicy::MANUAL,
       base::WaitableEvent::InitialState::NOT_SIGNALED);
   base::Closure task =
       base::Bind(&InProcessCommandBuffer::SetGetBufferOnGpuThread,
                  base::Unretained(this), shm_id, &completion);
-  QueueTask(task);
+  QueueTask(false, task);
   completion.Wait();
 
   {
     base::AutoLock lock(state_after_last_flush_lock_);
     state_after_last_flush_ = command_buffer_->GetLastState();
   }
 }
 
 void InProcessCommandBuffer::SetGetBufferOnGpuThread(
     int32_t shm_id,
@@ skipping 11 matching lines @@
   base::AutoLock lock(command_buffer_lock_);
   return command_buffer_->CreateTransferBuffer(size, id);
 }
 
 void InProcessCommandBuffer::DestroyTransferBuffer(int32_t id) {
   CheckSequencedThread();
   base::Closure task =
       base::Bind(&InProcessCommandBuffer::DestroyTransferBufferOnGpuThread,
                  base::Unretained(this), id);
 
-  QueueTask(task);
+  QueueTask(false, task);
 }
 
 void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32_t id) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->DestroyTransferBuffer(id);
 }
 
 void InProcessCommandBuffer::SetGpuControlClient(GpuControlClient* client) {
   gpu_control_client_ = client;
 }
@@ skipping 20 matching lines @@
   DCHECK(gpu::IsImageFormatCompatibleWithGpuMemoryBufferFormat(
       internalformat, gpu_memory_buffer->GetFormat()));
 
   // This handle is owned by the GPU thread and must be passed to it or it
   // will leak. In otherwords, do not early out on error between here and the
   // queuing of the CreateImage task below.
   bool requires_sync_point = false;
   gfx::GpuMemoryBufferHandle handle = ShareGpuMemoryBufferToGpuThread(
       gpu_memory_buffer->GetHandle(), &requires_sync_point);
 
-  SyncPointManager* sync_manager = service_->sync_point_manager();
-  const uint32_t order_num =
-      sync_point_order_data_->GenerateUnprocessedOrderNumber(sync_manager);
-
   uint64_t fence_sync = 0;
   if (requires_sync_point) {
     fence_sync = GenerateFenceSyncRelease();
 
     // Previous fence syncs should be flushed already.
     DCHECK_EQ(fence_sync - 1, flushed_fence_sync_release_);
   }
 
-  QueueTask(base::Bind(
-      &InProcessCommandBuffer::CreateImageOnGpuThread, base::Unretained(this),
-      new_id, handle, gfx::Size(base::checked_cast<int>(width),
-                                base::checked_cast<int>(height)),
-      gpu_memory_buffer->GetFormat(),
-      base::checked_cast<uint32_t>(internalformat), order_num, fence_sync));
+  QueueTask(false, base::Bind(&InProcessCommandBuffer::CreateImageOnGpuThread,
+                              base::Unretained(this), new_id, handle,
+                              gfx::Size(base::checked_cast<int>(width),
+                                        base::checked_cast<int>(height)),
+                              gpu_memory_buffer->GetFormat(),
+                              base::checked_cast<uint32_t>(internalformat),
+                              fence_sync));
 
   if (fence_sync) {
     flushed_fence_sync_release_ = fence_sync;
     SyncToken sync_token(GetNamespaceID(), GetExtraCommandBufferData(),
                          GetCommandBufferID(), fence_sync);
     sync_token.SetVerifyFlush();
     gpu_memory_buffer_manager_->SetDestructionSyncToken(gpu_memory_buffer,
                                                         sync_token);
   }
 
   return new_id;
 }
 
 void InProcessCommandBuffer::CreateImageOnGpuThread(
     int32_t id,
     const gfx::GpuMemoryBufferHandle& handle,
     const gfx::Size& size,
     gfx::BufferFormat format,
     uint32_t internalformat,
-    uint32_t order_num,
     uint64_t fence_sync) {
-  ScopedOrderNumberProcessor scoped_order_num(sync_point_order_data_.get(),
-                                              order_num);
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image already exists with same ID.";
     return;
   }
 
@@ skipping 38 matching lines @@
   }
 
   if (fence_sync) {
     sync_point_client_->ReleaseFenceSync(fence_sync);
   }
 }
 
 void InProcessCommandBuffer::DestroyImage(int32_t id) {
   CheckSequencedThread();
 
-  QueueTask(base::Bind(&InProcessCommandBuffer::DestroyImageOnGpuThread,
-                       base::Unretained(this), id));
+  QueueTask(false, base::Bind(&InProcessCommandBuffer::DestroyImageOnGpuThread,
+                              base::Unretained(this), id));
 }
 
 void InProcessCommandBuffer::DestroyImageOnGpuThread(int32_t id) {
   if (!decoder_)
     return;
 
   gpu::gles2::ImageManager* image_manager = decoder_->GetImageManager();
   DCHECK(image_manager);
   if (!image_manager->LookupImage(id)) {
     LOG(ERROR) << "Image with ID doesn't exist.";
@@ skipping 33 matching lines @@
     mailbox_manager->PushTextureUpdates(sync_token);
   }
 
   sync_point_client_->ReleaseFenceSync(release);
 }
 
 bool InProcessCommandBuffer::WaitFenceSyncOnGpuThread(
     gpu::CommandBufferNamespace namespace_id,
     gpu::CommandBufferId command_buffer_id,
     uint64_t release) {
+  DCHECK(!waiting_for_sync_point_);
   gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
   DCHECK(sync_point_manager);
 
   scoped_refptr<gpu::SyncPointClientState> release_state =
       sync_point_manager->GetSyncPointClientState(namespace_id,
                                                   command_buffer_id);
 
   if (!release_state)
     return true;
 
-  if (!release_state->IsFenceSyncReleased(release)) {
+  if (release_state->IsFenceSyncReleased(release)) {
+    gles2::MailboxManager* mailbox_manager =
+        decoder_->GetContextGroup()->mailbox_manager();
+    SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
+    mailbox_manager->PullTextureUpdates(sync_token);
+    return true;
+  }
+
+  if (service_->BlockThreadOnWaitSyncToken()) {
     // Use waitable event which is signalled when the release fence is released.
     sync_point_client_->Wait(
         release_state.get(), release,
         base::Bind(&base::WaitableEvent::Signal,
                    base::Unretained(&fence_sync_wait_event_)));
     fence_sync_wait_event_.Wait();
+    return true;
   }
 
+  waiting_for_sync_point_ = true;
+  sync_point_client_->Wait(
+      release_state.get(), release,
+      base::Bind(&InProcessCommandBuffer::OnWaitFenceSyncCompleted,
+                 gpu_thread_weak_ptr_factory_.GetWeakPtr(), namespace_id,
+                 command_buffer_id, release));
+
+  if (!waiting_for_sync_point_)
+    return true;
+
+  executor_->SetScheduled(false);
+  return false;
+}
+
+void InProcessCommandBuffer::OnWaitFenceSyncCompleted(
+    CommandBufferNamespace namespace_id,
+    CommandBufferId command_buffer_id,
+    uint64_t release) {
+  DCHECK(waiting_for_sync_point_);
   gles2::MailboxManager* mailbox_manager =
       decoder_->GetContextGroup()->mailbox_manager();
   SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
   mailbox_manager->PullTextureUpdates(sync_token);
-  return true;
+  waiting_for_sync_point_ = false;
+  executor_->SetScheduled(true);
+  QueueTask(false, base::Bind(&InProcessCommandBuffer::FlushOnGpuThread,
+                              gpu_thread_weak_ptr_, last_put_offset_));
 }
 
 void InProcessCommandBuffer::DescheduleUntilFinishedOnGpuThread() {
-  NOTIMPLEMENTED();
+  DCHECK(executor_->scheduled());
+  DCHECK(executor_->HasPollingWork());
+
+  executor_->SetScheduled(false);
 }
 
 void InProcessCommandBuffer::RescheduleAfterFinishedOnGpuThread() {
-  NOTIMPLEMENTED();
+  DCHECK(!executor_->scheduled());
+
+  executor_->SetScheduled(true);
+  ProcessTasksOnGpuThread();
 }
 
 void InProcessCommandBuffer::SignalSyncTokenOnGpuThread(
     const SyncToken& sync_token,
     const base::Closure& callback) {
   gpu::SyncPointManager* sync_point_manager = service_->sync_point_manager();
   DCHECK(sync_point_manager);
 
   scoped_refptr<gpu::SyncPointClientState> release_state =
       sync_point_manager->GetSyncPointClientState(
           sync_token.namespace_id(), sync_token.command_buffer_id());
 
   if (!release_state) {
     callback.Run();
     return;
   }
 
   sync_point_client_->WaitOutOfOrder(
       release_state.get(), sync_token.release_count(), WrapCallback(callback));
 }
 
 void InProcessCommandBuffer::SignalQuery(unsigned query_id,
                                          const base::Closure& callback) {
   CheckSequencedThread();
-  QueueTask(base::Bind(&InProcessCommandBuffer::SignalQueryOnGpuThread,
-                       base::Unretained(this), query_id,
-                       WrapCallback(callback)));
+  QueueTask(false, base::Bind(&InProcessCommandBuffer::SignalQueryOnGpuThread,
+                              base::Unretained(this), query_id,
+                              WrapCallback(callback)));
 }
 
 void InProcessCommandBuffer::SignalQueryOnGpuThread(
     unsigned query_id,
     const base::Closure& callback) {
   gles2::QueryManager* query_manager_ = decoder_->GetQueryManager();
   DCHECK(query_manager_);
 
   gles2::QueryManager::Query* query = query_manager_->GetQuery(query_id);
   if (!query)
@@ skipping 35 matching lines @@
   return release <= flushed_fence_sync_release_;
 }
 
 bool InProcessCommandBuffer::IsFenceSyncFlushReceived(uint64_t release) {
   return IsFenceSyncFlushed(release);
 }
 
 void InProcessCommandBuffer::SignalSyncToken(const SyncToken& sync_token,
                                              const base::Closure& callback) {
   CheckSequencedThread();
-  QueueTask(base::Bind(&InProcessCommandBuffer::SignalSyncTokenOnGpuThread,
-                       base::Unretained(this), sync_token,
-                       WrapCallback(callback)));
+  QueueTask(
+      true,
+      base::Bind(&InProcessCommandBuffer::SignalSyncTokenOnGpuThread,
+                 base::Unretained(this), sync_token, WrapCallback(callback)));
 }
 
 bool InProcessCommandBuffer::CanWaitUnverifiedSyncToken(
     const SyncToken* sync_token) {
   return sync_token->namespace_id() == GetNamespaceID();
 }
 
+void InProcessCommandBuffer::DidSwapBuffersComplete(
+    SwapBuffersCompleteParams params) {
+#if defined(OS_MACOSX)
+  gpu::GpuProcessHostedCALayerTreeParamsMac params_mac;
+  params_mac.ca_context_id = params.ca_context_id;
+  params_mac.fullscreen_low_power_ca_context_valid =
+      params.fullscreen_low_power_ca_context_valid;
+  params_mac.fullscreen_low_power_ca_context_id =
+      params.fullscreen_low_power_ca_context_id;
+  params_mac.io_surface.reset(IOSurfaceLookupFromMachPort(params.io_surface));
+  params_mac.pixel_size = params.pixel_size;
+  params_mac.scale_factor = params.scale_factor;
+  params_mac.responses = std::move(params.in_use_responses);
+  gpu::GpuProcessHostedCALayerTreeParamsMac* mac_frame_ptr = &params_mac;
+#else
+  gpu::GpuProcessHostedCALayerTreeParamsMac* mac_frame_ptr = nullptr;
+#endif
+  if (!swap_buffers_completion_callback_.is_null()) {
+    if (!ui::LatencyInfo::Verify(
+            params.latency_info,
+            "InProcessCommandBuffer::DidSwapBuffersComplete")) {
+      swap_buffers_completion_callback_.Run(std::vector<ui::LatencyInfo>(),
+                                            params.result, mac_frame_ptr);
+    } else {
+      swap_buffers_completion_callback_.Run(params.latency_info, params.result,
+                                            mac_frame_ptr);
+    }
+  }
+}
+
+const gles2::FeatureInfo* InProcessCommandBuffer::GetFeatureInfo() const {
+  return context_group_->feature_info();
+}
+
+void InProcessCommandBuffer::SetLatencyInfoCallback(
+    const LatencyInfoCallback& callback) {
+  // TODO(fsamuel): Implement this.
+}
+
+void InProcessCommandBuffer::UpdateVSyncParameters(base::TimeTicks timebase,
+                                                   base::TimeDelta interval) {
+  if (!update_vsync_parameters_completion_callback_.is_null())
+    update_vsync_parameters_completion_callback_.Run(timebase, interval);
+}
+
+void InProcessCommandBuffer::SetSwapBuffersCompletionCallback(
+    const SwapBuffersCompletionCallback& callback) {
+  swap_buffers_completion_callback_ = callback;
+}
+
+void InProcessCommandBuffer::SetUpdateVSyncParametersCallback(
+    const UpdateVSyncParametersCallback& callback) {
+  update_vsync_parameters_completion_callback_ = callback;
+}
+
 gpu::error::Error InProcessCommandBuffer::GetLastError() {
   CheckSequencedThread();
   return last_state_.error;
 }
 
 namespace {
 
 void PostCallback(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     const base::Closure& callback) {
@@ skipping 21 matching lines @@
   base::Closure callback_on_client_thread =
       base::Bind(&RunOnTargetThread, base::Passed(&scoped_callback));
   base::Closure wrapped_callback =
       base::Bind(&PostCallback, base::ThreadTaskRunnerHandle::IsSet()
                                     ? base::ThreadTaskRunnerHandle::Get()
                                     : nullptr,
                  callback_on_client_thread);
   return wrapped_callback;
 }
 
-GpuInProcessThread::GpuInProcessThread(SyncPointManager* sync_point_manager)
-    : base::Thread("GpuThread"), sync_point_manager_(sync_point_manager) {
-  Start();
-}
+InProcessCommandBuffer::GpuTask::GpuTask(const base::Closure& callback,
+                                         uint32_t order_number)
+    : callback(callback), order_number(order_number) {}
 
-GpuInProcessThread::~GpuInProcessThread() {
-  Stop();
-}
-
-void GpuInProcessThread::AddRef() const {
-  base::RefCountedThreadSafe<GpuInProcessThread>::AddRef();
-}
-void GpuInProcessThread::Release() const {
-  base::RefCountedThreadSafe<GpuInProcessThread>::Release();
-}
-
-void GpuInProcessThread::ScheduleTask(const base::Closure& task) {
-  task_runner()->PostTask(FROM_HERE, task);
-}
-
-void GpuInProcessThread::ScheduleDelayedWork(const base::Closure& callback) {
-  // Match delay with GpuCommandBufferStub.
-  task_runner()->PostDelayedTask(FROM_HERE, callback,
-                                 base::TimeDelta::FromMilliseconds(2));
-}
-
-bool GpuInProcessThread::UseVirtualizedGLContexts() {
-  return false;
-}
-
-scoped_refptr<gles2::ShaderTranslatorCache>
-GpuInProcessThread::shader_translator_cache() {
-  if (!shader_translator_cache_.get()) {
-    shader_translator_cache_ =
-        new gpu::gles2::ShaderTranslatorCache(gpu_preferences());
-  }
-  return shader_translator_cache_;
-}
-
-scoped_refptr<gles2::FramebufferCompletenessCache>
-GpuInProcessThread::framebuffer_completeness_cache() {
-  if (!framebuffer_completeness_cache_.get())
-    framebuffer_completeness_cache_ =
-        new gpu::gles2::FramebufferCompletenessCache;
-  return framebuffer_completeness_cache_;
-}
-
-SyncPointManager* GpuInProcessThread::sync_point_manager() {
-  return sync_point_manager_;
-}
+InProcessCommandBuffer::GpuTask::~GpuTask() {}
 
 }  // namespace gpu