WIP GPU scheduler + delayed activation / tile draw

gpu/ipc/service/gpu_command_buffer_stub.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 "gpu/ipc/service/gpu_command_buffer_stub.h"
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/shared_memory.h"
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "gpu/command_buffer/common/constants.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/mailbox.h"
 #include "gpu/command_buffer/common/sync_token.h"
+#include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gl_state_restorer_impl.h"
 #include "gpu/command_buffer/service/image_manager.h"
 #include "gpu/command_buffer/service/logger.h"
 #include "gpu/command_buffer/service/mailbox_manager.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"
@@ skipping 40 matching lines @@
   explicit GpuCommandBufferMemoryTracker(GpuChannel* channel,
                                          uint64_t share_group_tracing_guid)
       : tracking_group_(
             channel->gpu_channel_manager()
                 ->gpu_memory_manager()
                 ->CreateTrackingGroup(channel->GetClientPID(), this)),
         client_tracing_id_(channel->client_tracing_id()),
         client_id_(channel->client_id()),
         share_group_tracing_guid_(share_group_tracing_guid) {}
 
-  void TrackMemoryAllocatedChange(
-      size_t old_size, size_t new_size) override {
-    tracking_group_->TrackMemoryAllocatedChange(
-        old_size, new_size);
+  void TrackMemoryAllocatedChange(size_t old_size, size_t new_size) override {
+    tracking_group_->TrackMemoryAllocatedChange(old_size, new_size);
   }
 
   bool EnsureGPUMemoryAvailable(size_t size_needed) override {
     return tracking_group_->EnsureGPUMemoryAvailable(size_needed);
   };
 
   uint64_t ClientTracingId() const override { return client_tracing_id_; }
   int ClientId() const override { return client_id_; }
   uint64_t ShareGroupTracingGUID() const override {
     return share_group_tracing_guid_;
@@ skipping 55 matching lines @@
 };
 
 std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
 DevToolsChannelData::CreateForChannel(GpuChannel* channel) {
   std::unique_ptr<base::DictionaryValue> res(new base::DictionaryValue);
   res->SetInteger("renderer_pid", channel->GetClientPID());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
   return base::WrapUnique(new DevToolsChannelData(res.release()));
 }
 
-CommandBufferId GetCommandBufferID(int channel_id, int32_t route_id) {
+}  // anonymous namespace
+
+CommandBufferId GpuCommandBufferStub::GetCommandBufferID(int32_t channel_id,
+                                                         int32_t route_id) {
   return CommandBufferId::FromUnsafeValue(
       (static_cast<uint64_t>(channel_id) << 32) | route_id);
 }
 
-}  // namespace
+int32_t GpuCommandBufferStub::GetChannelID(gpu::CommandBufferId cmd_buffer_id) {
+  return static_cast<int32_t>(cmd_buffer_id.GetUnsafeValue() >> 32);
+}
+
+int32_t GpuCommandBufferStub::GetRouteID(gpu::CommandBufferId cmd_buffer_id) {
+  return static_cast<int32_t>(cmd_buffer_id.GetUnsafeValue());
+}
 
 std::unique_ptr<GpuCommandBufferStub> GpuCommandBufferStub::Create(
     GpuChannel* channel,
     GpuCommandBufferStub* share_command_buffer_stub,
     const GPUCreateCommandBufferConfig& init_params,
     int32_t route_id,
     std::unique_ptr<base::SharedMemory> shared_state_shm) {
   std::unique_ptr<GpuCommandBufferStub> stub(
       new GpuCommandBufferStub(channel, init_params, route_id));
   if (!stub->Initialize(share_command_buffer_stub, init_params,
@@ skipping 17 matching lines @@
       waiting_for_sync_point_(false),
       previous_processed_num_(0),
       active_url_(init_params.active_url),
       active_url_hash_(base::Hash(active_url_.possibly_invalid_spec())) {}
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 }
 
 GpuMemoryManager* GpuCommandBufferStub::GetMemoryManager() const {
-    return channel()->gpu_channel_manager()->gpu_memory_manager();
+  return channel()->gpu_channel_manager()->gpu_memory_manager();
 }
 
 bool GpuCommandBufferStub::OnMessageReceived(const IPC::Message& message) {
-  TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"),
-               "GPUTask",
-               "data",
-               DevToolsChannelData::CreateForChannel(channel()));
+  TRACE_EVENT1(TRACE_DISABLED_BY_DEFAULT("devtools.timeline"), "GPUTask",
+               "data", DevToolsChannelData::CreateForChannel(channel()));
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
 
   bool have_context = false;
   // Ensure the appropriate GL context is current before handling any IPC
   // messages directed at the command buffer. This ensures that the message
   // handler can assume that the context is current (not necessary for
   // RetireSyncPoint or WaitSyncPoint).
   if (decoder_.get() &&
       message.type() != GpuCommandBufferMsg_SetGetBuffer::ID &&
       message.type() != GpuCommandBufferMsg_WaitForTokenInRange::ID &&
@@ skipping 16 matching lines @@
                         OnReturnFrontBuffer);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_WaitForTokenInRange,
                                     OnWaitForTokenInRange);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_WaitForGetOffsetInRange,
                                     OnWaitForGetOffsetInRange);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_AsyncFlush, OnAsyncFlush);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
                         OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncToken,
-                        OnWaitSyncToken)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken,
-                        OnSignalSyncToken)
-    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery,
-                        OnSignalQuery)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_WaitSyncToken, OnWaitSyncToken)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalSyncToken, OnSignalSyncToken)
+    IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_SignalQuery, OnSignalQuery)
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateImage, OnCreateImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyImage, OnDestroyImage);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_CreateStreamTexture,
                         OnCreateStreamTexture)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
 
   CheckCompleteWaits();
 
   // Ensure that any delayed work that was created will be handled.
@@ skipping 108 matching lines @@
   }
 
   ScheduleDelayedWork(
       base::TimeDelta::FromMilliseconds(kHandleMoreWorkPeriodBusyMs));
 }
 
 bool GpuCommandBufferStub::HasUnprocessedCommands() {
   if (command_buffer_) {
     CommandBuffer::State state = command_buffer_->GetLastState();
     return command_buffer_->GetPutOffset() != state.get_offset &&
-        !error::IsError(state.error);
+           !error::IsError(state.error);
   }
   return false;
 }
 
 void GpuCommandBufferStub::ScheduleDelayedWork(base::TimeDelta delay) {
   bool has_more_work = executor_.get() && (executor_->HasPendingQueries() ||
                                            executor_->HasMoreIdleWork() ||
                                            executor_->HasPollingWork());
   if (!has_more_work) {
     last_idle_time_ = base::TimeTicks();
@@ skipping 51 matching lines @@
     Send(wait_for_get_offset_->reply.release());
     wait_for_get_offset_.reset();
   }
 
   if (initialized_) {
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
     // If we are currently shutting down the GPU process to help with recovery
     // (exit_on_context_lost workaround), then don't tell the browser about
     // offscreen context destruction here since it's not client-invoked, and
     // might bypass the 3D API blocking logic.
-    if ((surface_handle_ == gpu::kNullSurfaceHandle) && !active_url_.is_empty()
-        && !gpu_channel_manager->is_exiting_for_lost_context()) {
+    if ((surface_handle_ == gpu::kNullSurfaceHandle) &&
+        !active_url_.is_empty() &&
+        !gpu_channel_manager->is_exiting_for_lost_context()) {
       gpu_channel_manager->delegate()->DidDestroyOffscreenContext(active_url_);
     }
   }
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   executor_.reset();
@@ skipping 68 matching lines @@
   gl::GLSurface::Format surface_format = gl::GLSurface::SURFACE_DEFAULT;
   bool offscreen = (surface_handle_ == kNullSurfaceHandle);
   gl::GLSurface* default_surface = manager->GetDefaultOffscreenSurface();
   if (!default_surface) {
     DLOG(ERROR) << "Failed to create default offscreen surface.";
     return false;
   }
 #if defined(OS_ANDROID)
   if (init_params.attribs.red_size <= 5 &&
       init_params.attribs.green_size <= 6 &&
-      init_params.attribs.blue_size <= 5 &&
-      init_params.attribs.alpha_size == 0)
+      init_params.attribs.blue_size <= 5 && init_params.attribs.alpha_size == 0)
     surface_format = gl::GLSurface::SURFACE_RGB565;
   // We can only use virtualized contexts for onscreen command buffers if their
   // config is compatible with the offscreen ones - otherwise MakeCurrent fails.
   if (surface_format != default_surface->GetFormat() && !offscreen)
     use_virtualized_gl_context_ = false;
 #endif
 
-  command_buffer_.reset(new CommandBufferService(
-      context_group_->transfer_buffer_manager()));
+  command_buffer_.reset(
+      new CommandBufferService(context_group_->transfer_buffer_manager()));
 
   decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
   executor_.reset(new CommandExecutor(command_buffer_.get(), decoder_.get(),
                                       decoder_.get()));
   sync_point_client_ = channel_->sync_point_manager()->CreateSyncPointClient(
       channel_->GetSyncPointOrderData(stream_id_),
       CommandBufferNamespace::GPU_IO, command_buffer_id_);
 
-  executor_->SetPreemptByFlag(channel_->preempted_flag());
+  executor_->SetPreemptionCallback(channel_->GetPreemptionCallback());
 
   decoder_->set_engine(executor_.get());
 
   if (offscreen) {
     surface_ = default_surface;
   } else {
     surface_ = ImageTransportSurface::CreateNativeSurface(
         AsWeakPtr(), surface_handle_, surface_format);
     if (!surface_ || !surface_->Initialize(surface_format)) {
       surface_ = nullptr;
@@ skipping 18 matching lines @@
       // Ensure that context creation did not lose track of the intended
       // gl_share_group.
       DCHECK(context->share_group() == gl_share_group);
       gl_share_group->SetSharedContext(surface_.get(), context.get());
     }
     // This should be either:
     // (1) a non-virtual GL context, or
     // (2) a mock context.
     DCHECK(context->GetHandle() ||
            gl::GetGLImplementation() == gl::kGLImplementationMockGL);
-    context = new GLContextVirtual(
-        gl_share_group, context.get(), decoder_->AsWeakPtr());
+    context = new GLContextVirtual(gl_share_group, context.get(),
+                                   decoder_->AsWeakPtr());
     if (!context->Initialize(
             surface_.get(),
             GenerateGLContextAttribs(init_params.attribs,
                                      context_group_->gpu_preferences()))) {
       // The real context created above for the default offscreen surface
       // might not be compatible with this surface.
       context = NULL;
       DLOG(ERROR) << "Failed to initialize virtual GL context.";
       return false;
     }
   }
   if (!context.get()) {
     context = gl::init::CreateGLContext(
         gl_share_group, surface_.get(),
         GenerateGLContextAttribs(init_params.attribs,
                                  context_group_->gpu_preferences()));
   }
   if (!context.get()) {
     DLOG(ERROR) << "Failed to create context.";
     return false;
   }
 
   if (!context->MakeCurrent(surface_.get())) {
     LOG(ERROR) << "Failed to make context current.";
     return false;
   }
 
   if (!context->GetGLStateRestorer()) {
-    context->SetGLStateRestorer(
-        new GLStateRestorerImpl(decoder_->AsWeakPtr()));
+    context->SetGLStateRestorer(new GLStateRestorerImpl(decoder_->AsWeakPtr()));
   }
 
   if (!context_group_->has_program_cache() &&
       !context_group_->feature_info()->workarounds().disable_program_cache) {
     context_group_->set_program_cache(manager->program_cache());
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
   if (!decoder_->Initialize(surface_, context, offscreen,
                             gpu::gles2::DisallowedFeatures(),
                             init_params.attribs)) {
     DLOG(ERROR) << "Failed to initialize decoder.";
     return false;
   }
 
   if (manager->gpu_preferences().enable_gpu_service_logging) {
     decoder_->set_log_commands(true);
   }
 
-  decoder_->GetLogger()->SetMsgCallback(
-      base::Bind(&GpuCommandBufferStub::SendConsoleMessage,
-                 base::Unretained(this)));
-  decoder_->SetShaderCacheCallback(
-      base::Bind(&GpuCommandBufferStub::SendCachedShader,
-                 base::Unretained(this)));
+  decoder_->GetLogger()->SetMsgCallback(base::Bind(
+      &GpuCommandBufferStub::SendConsoleMessage, base::Unretained(this)));
+  decoder_->SetShaderCacheCallback(base::Bind(
+      &GpuCommandBufferStub::SendCachedShader, base::Unretained(this)));
   decoder_->SetFenceSyncReleaseCallback(base::Bind(
       &GpuCommandBufferStub::OnFenceSyncRelease, base::Unretained(this)));
   decoder_->SetWaitFenceSyncCallback(base::Bind(
       &GpuCommandBufferStub::OnWaitFenceSync, base::Unretained(this)));
   decoder_->SetDescheduleUntilFinishedCallback(
       base::Bind(&GpuCommandBufferStub::OnDescheduleUntilFinished,
                  base::Unretained(this)));
   decoder_->SetRescheduleAfterFinishedCallback(
       base::Bind(&GpuCommandBufferStub::OnRescheduleAfterFinished,
                  base::Unretained(this)));
@@ skipping 104 matching lines @@
   }
   wait_for_get_offset_ =
       base::MakeUnique<WaitForCommandState>(start, end, reply_message);
   CheckCompleteWaits();
 }
 
 void GpuCommandBufferStub::CheckCompleteWaits() {
   if (wait_for_token_ || wait_for_get_offset_) {
     CommandBuffer::State state = command_buffer_->GetLastState();
     if (wait_for_token_ &&
-        (CommandBuffer::InRange(
-             wait_for_token_->start, wait_for_token_->end, state.token) ||
+        (CommandBuffer::InRange(wait_for_token_->start, wait_for_token_->end,
+                                state.token) ||
          state.error != error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForTokenInRange::WriteReplyParams(
           wait_for_token_->reply.get(), state);
       Send(wait_for_token_->reply.release());
       wait_for_token_.reset();
     }
     if (wait_for_get_offset_ &&
         (CommandBuffer::InRange(wait_for_get_offset_->start,
-                                     wait_for_get_offset_->end,
-                                     state.get_offset) ||
+                                wait_for_get_offset_->end, state.get_offset) ||
          state.error != error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForGetOffsetInRange::WriteReplyParams(
           wait_for_get_offset_->reply.get(), state);
       Send(wait_for_get_offset_->reply.release());
       wait_for_get_offset_.reset();
     }
   }
 }
 
 void GpuCommandBufferStub::OnAsyncFlush(
     int32_t put_offset,
     uint32_t flush_count,
     const std::vector<ui::LatencyInfo>& latency_info) {
-  TRACE_EVENT1(
-      "gpu", "GpuCommandBufferStub::OnAsyncFlush", "put_offset", put_offset);
+  TRACE_EVENT1("gpu", "GpuCommandBufferStub::OnAsyncFlush", "put_offset",
+               put_offset);
   DCHECK(command_buffer_);
 
   // We received this message out-of-order. This should not happen but is here
   // to catch regressions. Ignore the message.
   DVLOG_IF(0, flush_count - last_flush_count_ >= 0x8000000U)
       << "Received a Flush message out-of-order";
 
   if (flush_count > last_flush_count_ &&
       ui::LatencyInfo::Verify(latency_info,
                               "GpuCommandBufferStub::OnAsyncFlush") &&
@@ skipping 41 matching lines @@
 
   if (command_buffer_)
     command_buffer_->DestroyTransferBuffer(id);
 }
 
 void GpuCommandBufferStub::OnCommandProcessed() {
   DCHECK(channel_->watchdog());
   channel_->watchdog()->CheckArmed();
 }
 
-void GpuCommandBufferStub::ReportState() { command_buffer_->UpdateState(); }
+void GpuCommandBufferStub::ReportState() {
+  command_buffer_->UpdateState();
+}
 
 void GpuCommandBufferStub::PutChanged() {
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
   executor_->PutChanged();
 }
 
 void GpuCommandBufferStub::PullTextureUpdates(
     CommandBufferNamespace namespace_id,
     CommandBufferId command_buffer_id,
     uint32_t release) {
-  gles2::MailboxManager* mailbox_manager =
-      context_group_->mailbox_manager();
+  gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent()) {
     SyncToken sync_token(namespace_id, 0, command_buffer_id, release);
     mailbox_manager->PullTextureUpdates(sync_token);
   }
 }
 
 void GpuCommandBufferStub::OnWaitSyncToken(const SyncToken& sync_token) {
   OnWaitFenceSync(sync_token.namespace_id(), sync_token.command_buffer_id(),
                   sync_token.release_count());
 }
 
 void GpuCommandBufferStub::OnSignalSyncToken(const SyncToken& sync_token,
                                              uint32_t id) {
   scoped_refptr<SyncPointClientState> release_state =
       channel_->sync_point_manager()->GetSyncPointClientState(
           sync_token.namespace_id(), sync_token.command_buffer_id());
 
   if (release_state) {
-    sync_point_client_->Wait(release_state.get(), sync_token.release_count(),
-                             base::Bind(&GpuCommandBufferStub::OnSignalAck,
-                                        this->AsWeakPtr(), id));
+    sync_point_client_->Wait(
+        release_state.get(), sync_token.release_count(),
+        base::Bind(&GpuCommandBufferStub::OnSignalAck, this->AsWeakPtr(), id));
   } else {
     OnSignalAck(id);
   }
 }
 
 void GpuCommandBufferStub::OnSignalAck(uint32_t id) {
   Send(new GpuCommandBufferMsg_SignalAck(route_id_, id));
 }
 
 void GpuCommandBufferStub::OnSignalQuery(uint32_t query_id, uint32_t id) {
   if (decoder_) {
     gles2::QueryManager* query_manager = decoder_->GetQueryManager();
     if (query_manager) {
-      gles2::QueryManager::Query* query =
-          query_manager->GetQuery(query_id);
+      gles2::QueryManager::Query* query = query_manager->GetQuery(query_id);
       if (query) {
-        query->AddCallback(
-          base::Bind(&GpuCommandBufferStub::OnSignalAck,
-                     this->AsWeakPtr(),
-                     id));
+        query->AddCallback(base::Bind(&GpuCommandBufferStub::OnSignalAck,
+                                      this->AsWeakPtr(), id));
         return;
       }
     }
   }
   // Something went wrong, run callback immediately.
   OnSignalAck(id);
 }
 
 void GpuCommandBufferStub::OnFenceSyncRelease(uint64_t release) {
   if (sync_point_client_->client_state()->IsFenceSyncReleased(release)) {
     DLOG(ERROR) << "Fence Sync has already been released.";
     return;
   }
 
-  gles2::MailboxManager* mailbox_manager =
-      context_group_->mailbox_manager();
+  gles2::MailboxManager* mailbox_manager = context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent()) {
-    SyncToken sync_token(CommandBufferNamespace::GPU_IO, 0,
-                              command_buffer_id_, release);
+    SyncToken sync_token(CommandBufferNamespace::GPU_IO, 0, command_buffer_id_,
+                         release);
     mailbox_manager->PushTextureUpdates(sync_token);
   }
 
   sync_point_client_->ReleaseFenceSync(release);
+  command_buffer_->SetReleaseCount(release);
 }
 
 void GpuCommandBufferStub::OnDescheduleUntilFinished() {
   DCHECK(executor_->scheduled());
   DCHECK(executor_->HasPollingWork());
-
   executor_->SetScheduled(false);
-  channel_->OnStreamRescheduled(stream_id_, false);
+  channel_->DescheduleCommandBuffer(this);
 }
 
 void GpuCommandBufferStub::OnRescheduleAfterFinished() {
   DCHECK(!executor_->scheduled());
-
   executor_->SetScheduled(true);
-  channel_->OnStreamRescheduled(stream_id_, true);
+  channel_->ScheduleCommandBuffer(this);
 }
 
-bool GpuCommandBufferStub::OnWaitFenceSync(
-    CommandBufferNamespace namespace_id,
-    CommandBufferId command_buffer_id,
-    uint64_t release) {
+bool GpuCommandBufferStub::OnWaitFenceSync(CommandBufferNamespace namespace_id,
+                                           CommandBufferId command_buffer_id,
+                                           uint64_t release) {
   DCHECK(!waiting_for_sync_point_);
   DCHECK(executor_->scheduled());
 
   scoped_refptr<SyncPointClientState> release_state =
       channel_->sync_point_manager()->GetSyncPointClientState(
           namespace_id, command_buffer_id);
 
   if (!release_state)
     return true;
 
   if (release_state->IsFenceSyncReleased(release)) {
     PullTextureUpdates(namespace_id, command_buffer_id, release);
     return true;
   }
 
   TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
                            this);
   waiting_for_sync_point_ = true;
   sync_point_client_->WaitNonThreadSafe(
       release_state.get(), release, channel_->task_runner(),
       base::Bind(&GpuCommandBufferStub::OnWaitFenceSyncCompleted,
                  this->AsWeakPtr(), namespace_id, command_buffer_id, release));
 
   if (!waiting_for_sync_point_)
     return true;
 
   executor_->SetScheduled(false);
-  channel_->OnStreamRescheduled(stream_id_, false);
+  channel_->DescheduleCommandBuffer(this);
   return false;
 }
 
 void GpuCommandBufferStub::OnWaitFenceSyncCompleted(
     CommandBufferNamespace namespace_id,
     CommandBufferId command_buffer_id,
     uint64_t release) {
   DCHECK(waiting_for_sync_point_);
   TRACE_EVENT_ASYNC_END1("gpu", "WaitFenceSync", this, "GpuCommandBufferStub",
                          this);
   PullTextureUpdates(namespace_id, command_buffer_id, release);
   waiting_for_sync_point_ = false;
   executor_->SetScheduled(true);
-  channel_->OnStreamRescheduled(stream_id_, true);
+  channel_->ScheduleCommandBuffer(this);
 }
 
 void GpuCommandBufferStub::OnCreateImage(
     const GpuCommandBufferMsg_CreateImage_Params& params) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnCreateImage");
   const int32_t id = params.id;
   const gfx::GpuMemoryBufferHandle& handle = params.gpu_memory_buffer;
   const gfx::Size& size = params.size;
   const gfx::BufferFormat& format = params.format;
   const uint32_t internalformat = params.internal_format;
@@ skipping 55 matching lines @@
   }
 
   image_manager->RemoveImage(id);
 }
 
 void GpuCommandBufferStub::SendConsoleMessage(int32_t id,
                                               const std::string& message) {
   GPUCommandBufferConsoleMessage console_message;
   console_message.id = id;
   console_message.message = message;
-  IPC::Message* msg = new GpuCommandBufferMsg_ConsoleMsg(
-      route_id_, console_message);
+  IPC::Message* msg =
+      new GpuCommandBufferMsg_ConsoleMsg(route_id_, console_message);
   msg->set_unblock(true);
   Send(msg);
 }
 
-void GpuCommandBufferStub::SendCachedShader(
-    const std::string& key, const std::string& shader) {
+void GpuCommandBufferStub::SendCachedShader(const std::string& key,
+                                            const std::string& shader) {
   channel_->CacheShader(key, shader);
 }
 
 void GpuCommandBufferStub::AddDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.AddObserver(observer);
 }
 
 void GpuCommandBufferStub::RemoveDestructionObserver(
     DestructionObserver* observer) {
@@ skipping 37 matching lines @@
       command_buffer_->GetLastState().error == error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(error::kUnknown);
   if (decoder_)
     decoder_->MarkContextLost(error::kUnknown);
   command_buffer_->SetParseError(error::kLostContext);
 }
 
 }  // namespace gpu