diff --git a/gpu/BUILD.gn b/gpu/BUILD.gn
index a7acb930112d2c..b5416c7f7f4579 100644
--- a/gpu/BUILD.gn
+++ b/gpu/BUILD.gn
@@ -105,6 +105,8 @@ test("command_buffer_gles2_tests") {
 static_library("test_support") {
   testonly = true
   sources = [
+    "command_buffer/client/client_test_helper.cc",
+    "command_buffer/client/client_test_helper.h",
     "command_buffer/client/gles2_interface_stub.cc",
     "command_buffer/client/gles2_interface_stub.h",
     "command_buffer/service/error_state_mock.cc",
@@ -121,6 +123,7 @@ static_library("test_support") {
     "//testing/gmock",
     "//testing/gtest",
     "//ui/gl:gl_unittest_utils",
+    "//ui/latency:test_support",
   ]
 }
 
@@ -219,8 +222,6 @@ test("gpu_unittests") {
   sources = [
     "command_buffer/client/buffer_tracker_unittest.cc",
     "command_buffer/client/client_discardable_manager_unittest.cc",
-    "command_buffer/client/client_test_helper.cc",
-    "command_buffer/client/client_test_helper.h",
     "command_buffer/client/cmd_buffer_helper_test.cc",
     "command_buffer/client/fenced_allocator_test.cc",
     "command_buffer/client/gles2_implementation_unittest.cc",
diff --git a/gpu/command_buffer/client/client_test_helper.cc b/gpu/command_buffer/client/client_test_helper.cc
index e1cbda5955f598..cbfb70eebca935 100644
--- a/gpu/command_buffer/client/client_test_helper.cc
+++ b/gpu/command_buffer/client/client_test_helper.cc
@@ -35,7 +35,7 @@ void FakeCommandBufferServiceBase::SetReleaseCount(uint64_t release_count) {
 // Get's the Id of the next transfer buffer that will be returned
 // by CreateTransferBuffer. This is useful for testing expected ids.
 int32_t FakeCommandBufferServiceBase::GetNextFreeTransferBufferId() {
-  for (size_t ii = 0; ii < arraysize(transfer_buffer_buffers_); ++ii) {
+  for (int32_t ii = 0; ii < kMaxTransferBuffers; ++ii) {
     if (!transfer_buffer_buffers_[ii].get()) {
       return kTransferBufferBaseId + ii;
     }
diff --git a/gpu/command_buffer/client/cmd_buffer_helper_test.cc b/gpu/command_buffer/client/cmd_buffer_helper_test.cc
index 3cada6afbdeb29..9027ae50670575 100644
--- a/gpu/command_buffer/client/cmd_buffer_helper_test.cc
+++ b/gpu/command_buffer/client/cmd_buffer_helper_test.cc
@@ -42,9 +42,8 @@ const int32_t kUnusedCommandId = 5;  // we use 0 and 2 currently.
 class CommandBufferDirectLocked : public CommandBufferDirect {
  public:
   explicit CommandBufferDirectLocked(
-      TransferBufferManager* transfer_buffer_manager,
-      AsyncAPIInterface* handler)
-      : CommandBufferDirect(transfer_buffer_manager, handler),
+      TransferBufferManager* transfer_buffer_manager)
+      : CommandBufferDirect(transfer_buffer_manager),
         flush_locked_(false),
         last_flush_(-1),
         previous_put_offset_(0),
@@ -98,19 +97,17 @@ class CommandBufferDirectLocked : public CommandBufferDirect {
 class CommandBufferHelperTest : public testing::Test {
  protected:
   virtual void SetUp() {
-    api_mock_.reset(new AsyncAPIMock(true));
+    transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
+    command_buffer_.reset(
+        new CommandBufferDirectLocked(transfer_buffer_manager_.get()));
+    api_mock_.reset(new AsyncAPIMock(true, command_buffer_->service()));
+    command_buffer_->set_handler(api_mock_.get());
 
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
     EXPECT_CALL(*api_mock_, DoCommand(cmd::kNoop, _, _))
         .WillRepeatedly(Return(error::kNoError));
 
-    transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
-    command_buffer_.reset(new CommandBufferDirectLocked(
-        transfer_buffer_manager_.get(), api_mock_.get()));
-
-    api_mock_->set_command_buffer_service(command_buffer_->service());
-
     helper_.reset(new CommandBufferHelper(command_buffer_.get()));
     helper_->Initialize(kCommandBufferSizeBytes);
 
@@ -253,9 +250,9 @@ class CommandBufferHelperTest : public testing::Test {
 
   CommandBufferOffset get_helper_put() { return helper_->put_; }
 
-  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<TransferBufferManager> transfer_buffer_manager_;
   std::unique_ptr<CommandBufferDirectLocked> command_buffer_;
+  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<CommandBufferHelper> helper_;
   std::vector<std::unique_ptr<CommandBufferEntry[]>> test_command_args_;
   unsigned int test_command_next_id_;
diff --git a/gpu/command_buffer/client/fenced_allocator_test.cc b/gpu/command_buffer/client/fenced_allocator_test.cc
index c19a06672712ce..000738d7a49277 100644
--- a/gpu/command_buffer/client/fenced_allocator_test.cc
+++ b/gpu/command_buffer/client/fenced_allocator_test.cc
@@ -38,7 +38,12 @@ class BaseFencedAllocatorTest : public testing::Test {
   static const int kAllocAlignment = 16;
 
   void SetUp() override {
-    api_mock_.reset(new AsyncAPIMock(true));
+    transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
+    command_buffer_.reset(
+        new CommandBufferDirect(transfer_buffer_manager_.get()));
+    api_mock_.reset(new AsyncAPIMock(true, command_buffer_->service()));
+    command_buffer_->set_handler(api_mock_.get());
+
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
     EXPECT_CALL(*api_mock_, DoCommand(cmd::kNoop, 0, _))
@@ -48,21 +53,15 @@ class BaseFencedAllocatorTest : public testing::Test {
         .WillRepeatedly(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
                               Return(error::kNoError)));
 
-    transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
-    command_buffer_.reset(new CommandBufferDirect(
-        transfer_buffer_manager_.get(), api_mock_.get()));
-
-    api_mock_->set_command_buffer_service(command_buffer_->service());
-
     helper_.reset(new CommandBufferHelper(command_buffer_.get()));
     helper_->Initialize(kBufferSize);
   }
 
   int32_t GetToken() { return command_buffer_->GetLastState().token; }
 
-  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<TransferBufferManager> transfer_buffer_manager_;
   std::unique_ptr<CommandBufferDirect> command_buffer_;
+  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<CommandBufferHelper> helper_;
   base::MessageLoop message_loop_;
 };
diff --git a/gpu/command_buffer/client/mapped_memory_unittest.cc b/gpu/command_buffer/client/mapped_memory_unittest.cc
index 134f55a18419c2..c36f66358e0961 100644
--- a/gpu/command_buffer/client/mapped_memory_unittest.cc
+++ b/gpu/command_buffer/client/mapped_memory_unittest.cc
@@ -35,7 +35,12 @@ class MappedMemoryTestBase : public testing::Test {
   static const unsigned int kBufferSize = 1024;
 
   void SetUp() override {
-    api_mock_.reset(new AsyncAPIMock(true));
+    transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
+    command_buffer_.reset(
+        new CommandBufferDirect(transfer_buffer_manager_.get()));
+    api_mock_.reset(new AsyncAPIMock(true, command_buffer_->service()));
+    command_buffer_->set_handler(api_mock_.get());
+
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
     EXPECT_CALL(*api_mock_, DoCommand(cmd::kNoop, 0, _))
@@ -45,21 +50,15 @@ class MappedMemoryTestBase : public testing::Test {
         .WillRepeatedly(DoAll(Invoke(api_mock_.get(), &AsyncAPIMock::SetToken),
                               Return(error::kNoError)));
 
-    transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
-    command_buffer_.reset(new CommandBufferDirect(
-        transfer_buffer_manager_.get(), api_mock_.get()));
-
-    api_mock_->set_command_buffer_service(command_buffer_->service());
-
     helper_.reset(new CommandBufferHelper(command_buffer_.get()));
     helper_->Initialize(kBufferSize);
   }
 
   int32_t GetToken() { return command_buffer_->GetLastState().token; }
 
-  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<TransferBufferManager> transfer_buffer_manager_;
   std::unique_ptr<CommandBufferDirect> command_buffer_;
+  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<CommandBufferHelper> helper_;
   base::MessageLoop message_loop_;
 };
diff --git a/gpu/command_buffer/client/ring_buffer_test.cc b/gpu/command_buffer/client/ring_buffer_test.cc
index 86ffa7d9960873..242e369836b401 100644
--- a/gpu/command_buffer/client/ring_buffer_test.cc
+++ b/gpu/command_buffer/client/ring_buffer_test.cc
@@ -60,7 +60,12 @@ class BaseRingBufferTest : public testing::Test {
 
   void SetUp() override {
     delay_set_token_ = false;
-    api_mock_.reset(new AsyncAPIMock(true));
+    transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
+    command_buffer_.reset(
+        new CommandBufferDirect(transfer_buffer_manager_.get()));
+    api_mock_.reset(new AsyncAPIMock(true, command_buffer_->service()));
+    command_buffer_->set_handler(api_mock_.get());
+
     // ignore noops in the mock - we don't want to inspect the internals of the
     // helper.
     EXPECT_CALL(*api_mock_, DoCommand(cmd::kNoop, 0, _))
@@ -70,21 +75,15 @@ class BaseRingBufferTest : public testing::Test {
         .WillRepeatedly(DoAll(Invoke(this, &BaseRingBufferTest::SetToken),
                               Return(error::kNoError)));
 
-    transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
-    command_buffer_.reset(new CommandBufferDirect(
-        transfer_buffer_manager_.get(), api_mock_.get()));
-
-    api_mock_->set_command_buffer_service(command_buffer_->service());
-
     helper_.reset(new CommandBufferHelper(command_buffer_.get()));
     helper_->Initialize(kBufferSize);
   }
 
   int32_t GetToken() { return command_buffer_->GetLastState().token; }
 
-  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<TransferBufferManager> transfer_buffer_manager_;
   std::unique_ptr<CommandBufferDirect> command_buffer_;
+  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<CommandBufferHelper> helper_;
   std::vector<const volatile void*> set_token_arguments_;
   bool delay_set_token_;
diff --git a/gpu/command_buffer/service/command_buffer_direct.cc b/gpu/command_buffer/service/command_buffer_direct.cc
index 765edd1b49af7e..6047417b2dc59e 100644
--- a/gpu/command_buffer/service/command_buffer_direct.cc
+++ b/gpu/command_buffer/service/command_buffer_direct.cc
@@ -13,27 +13,17 @@ namespace gpu {
 namespace {
 
 uint64_t g_next_command_buffer_id = 1;
-bool AlwaysTrue() {
-  return true;
-}
 
 }  // anonymous namespace
 
 CommandBufferDirect::CommandBufferDirect(
-    TransferBufferManager* transfer_buffer_manager,
-    AsyncAPIInterface* handler)
-    : CommandBufferDirect(transfer_buffer_manager,
-                          handler,
-                          base::Bind(&AlwaysTrue),
-                          nullptr) {}
+    TransferBufferManager* transfer_buffer_manager)
+    : CommandBufferDirect(transfer_buffer_manager, nullptr) {}
 
 CommandBufferDirect::CommandBufferDirect(
     TransferBufferManager* transfer_buffer_manager,
-    AsyncAPIInterface* handler,
-    const MakeCurrentCallback& callback,
     SyncPointManager* sync_point_manager)
-    : service_(this, transfer_buffer_manager, handler),
-      make_current_callback_(callback),
+    : service_(this, transfer_buffer_manager),
       sync_point_manager_(sync_point_manager),
       command_buffer_id_(
           CommandBufferId::FromUnsafeValue(g_next_command_buffer_id++)) {
@@ -84,10 +74,7 @@ CommandBuffer::State CommandBufferDirect::WaitForGetOffsetInRange(
 }
 
 void CommandBufferDirect::Flush(int32_t put_offset) {
-  if (!make_current_callback_.Run()) {
-    service_.SetParseError(error::kLostContext);
-    return;
-  }
+  DCHECK(handler_);
   uint32_t order_num = 0;
   if (sync_point_manager_) {
     // If sync point manager is supported, assign order numbers to commands.
@@ -109,7 +96,7 @@ void CommandBufferDirect::Flush(int32_t put_offset) {
     return;
   }
 
-  service_.Flush(put_offset);
+  service_.Flush(put_offset, handler_);
   if (sync_point_manager_) {
     // Finish processing order number here.
     sync_point_order_data_->FinishProcessingOrderNumber(order_num);
diff --git a/gpu/command_buffer/service/command_buffer_direct.h b/gpu/command_buffer/service/command_buffer_direct.h
index 1c94cc6f98a2c1..d27c0a6046377d 100644
--- a/gpu/command_buffer/service/command_buffer_direct.h
+++ b/gpu/command_buffer/service/command_buffer_direct.h
@@ -26,14 +26,12 @@ class GPU_EXPORT CommandBufferDirect : public CommandBuffer,
   using MakeCurrentCallback = base::Callback<bool()>;
 
   CommandBufferDirect(TransferBufferManager* transfer_buffer_manager,
-                      AsyncAPIInterface* handler,
-                      const MakeCurrentCallback& callback,
                       SyncPointManager* sync_point_manager);
-  CommandBufferDirect(TransferBufferManager* transfer_buffer_manager,
-                      AsyncAPIInterface* handler);
+  explicit CommandBufferDirect(TransferBufferManager* transfer_buffer_manager);
 
   ~CommandBufferDirect() override;
 
+  void set_handler(AsyncAPIInterface* handler) { handler_ = handler; }
   CommandBufferServiceBase* service() { return &service_; }
 
   // CommandBuffer implementation:
@@ -65,9 +63,9 @@ class GPU_EXPORT CommandBufferDirect : public CommandBuffer,
 
  private:
   CommandBufferService service_;
-  MakeCurrentCallback make_current_callback_;
   SyncPointManager* sync_point_manager_;
 
+  AsyncAPIInterface* handler_ = nullptr;
   scoped_refptr<SyncPointOrderData> sync_point_order_data_;
   scoped_refptr<SyncPointClientState> sync_point_client_state_;
   bool pause_commands_ = false;
diff --git a/gpu/command_buffer/service/command_buffer_service.cc b/gpu/command_buffer/service/command_buffer_service.cc
index 7ca29e18057795..74865e90df3ec6 100644
--- a/gpu/command_buffer/service/command_buffer_service.cc
+++ b/gpu/command_buffer/service/command_buffer_service.cc
@@ -41,14 +41,10 @@ class MemoryBufferBacking : public BufferBacking {
 
 CommandBufferService::CommandBufferService(
     CommandBufferServiceClient* client,
-    TransferBufferManager* transfer_buffer_manager,
-    AsyncAPIInterface* handler)
-    : client_(client),
-      transfer_buffer_manager_(transfer_buffer_manager),
-      handler_(handler) {
+    TransferBufferManager* transfer_buffer_manager)
+    : client_(client), transfer_buffer_manager_(transfer_buffer_manager) {
   DCHECK(client_);
   DCHECK(transfer_buffer_manager_);
-  DCHECK(handler_);
   state_.token = 0;
 }
 
@@ -60,14 +56,16 @@ void CommandBufferService::UpdateState() {
     shared_state_->Write(state_);
 }
 
-void CommandBufferService::Flush(int32_t put_offset) {
+void CommandBufferService::Flush(int32_t put_offset,
+                                 AsyncAPIInterface* handler) {
+  DCHECK(handler);
   if (put_offset < 0 || put_offset >= num_entries_) {
     SetParseError(gpu::error::kOutOfBounds);
     return;
   }
 
   TRACE_EVENT1("gpu", "CommandBufferService:PutChanged", "handler",
-               handler_->GetLogPrefix().as_string());
+               handler->GetLogPrefix().as_string());
 
   put_offset_ = put_offset;
 
@@ -83,10 +81,21 @@ void CommandBufferService::Flush(int32_t put_offset) {
     TRACE_COUNTER_ID1("gpu", "CommandBufferService::Paused", this, paused_);
   }
 
-  error::Error error = error::kNoError;
-  handler_->BeginDecoding();
+  handler->BeginDecoding();
+  int end = put_offset_ < state_.get_offset ? num_entries_ : put_offset_;
   while (put_offset_ != state_.get_offset) {
-    error = ProcessCommands(kParseCommandsSlice);
+    int num_entries = end - state_.get_offset;
+    int entries_processed = 0;
+    error::Error error =
+        handler->DoCommands(kParseCommandsSlice, buffer_ + state_.get_offset,
+                            num_entries, &entries_processed);
+
+    state_.get_offset += entries_processed;
+    DCHECK_LE(state_.get_offset, num_entries_);
+    if (state_.get_offset == num_entries_) {
+      end = put_offset_;
+      state_.get_offset = 0;
+    }
 
     if (error::IsError(error)) {
       SetParseError(error);
@@ -104,7 +113,7 @@ void CommandBufferService::Flush(int32_t put_offset) {
       break;
   }
 
-  handler_->EndDecoding();
+  handler->EndDecoding();
 }
 
 void CommandBufferService::SetGetBuffer(int32_t transfer_buffer_id) {
@@ -225,21 +234,4 @@ void CommandBufferService::SetScheduled(bool scheduled) {
   scheduled_ = scheduled;
 }
 
-error::Error CommandBufferService::ProcessCommands(int num_commands) {
-  int num_entries = put_offset_ < state_.get_offset
-                        ? num_entries_ - state_.get_offset
-                        : put_offset_ - state_.get_offset;
-
-  int entries_processed = 0;
-  error::Error result =
-      handler_->DoCommands(num_commands, buffer_ + state_.get_offset,
-                           num_entries, &entries_processed);
-
-  state_.get_offset += entries_processed;
-  if (state_.get_offset == num_entries_)
-    state_.get_offset = 0;
-
-  return result;
-}
-
 }  // namespace gpu
diff --git a/gpu/command_buffer/service/command_buffer_service.h b/gpu/command_buffer/service/command_buffer_service.h
index 730a9a1b585ee8..12f83731f984e4 100644
--- a/gpu/command_buffer/service/command_buffer_service.h
+++ b/gpu/command_buffer/service/command_buffer_service.h
@@ -73,8 +73,7 @@ class GPU_EXPORT CommandBufferService : public CommandBufferServiceBase {
   static const int kParseCommandsSlice = 20;
 
   CommandBufferService(CommandBufferServiceClient* client,
-                       TransferBufferManager* transfer_buffer_manager,
-                       AsyncAPIInterface* handler);
+                       TransferBufferManager* transfer_buffer_manager);
   ~CommandBufferService() override;
 
   // CommandBufferServiceBase implementation:
@@ -92,9 +91,8 @@ class GPU_EXPORT CommandBufferService : public CommandBufferServiceBase {
   // state transfer buffer.
   void UpdateState();
 
-  // Flushes up to the put_offset and calls the PutOffsetChangeCallback to
-  // execute commands.
-  void Flush(int32_t put_offset);
+  // Flushes up to the put_offset and execute commands with the handler.
+  void Flush(int32_t put_offset, AsyncAPIInterface* handler);
 
   // Sets the get buffer and call the GetBufferChangeCallback.
   void SetGetBuffer(int32_t transfer_buffer_id);
@@ -123,11 +121,8 @@ class GPU_EXPORT CommandBufferService : public CommandBufferServiceBase {
   int32_t put_offset() const { return put_offset_; }
 
  private:
-  error::Error ProcessCommands(int num_commands);
-
   CommandBufferServiceClient* client_;
   TransferBufferManager* transfer_buffer_manager_;
-  AsyncAPIInterface* handler_;
 
   CommandBuffer::State state_;
   int32_t put_offset_ = 0;
diff --git a/gpu/command_buffer/service/command_buffer_service_unittest.cc b/gpu/command_buffer/service/command_buffer_service_unittest.cc
index 1e249a9fed75d0..7531d5f83bbd60 100644
--- a/gpu/command_buffer/service/command_buffer_service_unittest.cc
+++ b/gpu/command_buffer/service/command_buffer_service_unittest.cc
@@ -33,9 +33,6 @@ class CommandBufferServiceTest : public testing::Test,
   MOCK_METHOD0(OnCommandProcessed, void());
 
  protected:
-  virtual void SetUp() { api_mock_.reset(new AsyncAPIMock(false)); }
-  virtual void TearDown() {}
-
   void AddDoCommandsExpect(error::Error _return,
                            int num_entries,
                            int num_processed) {
@@ -49,7 +46,8 @@ class CommandBufferServiceTest : public testing::Test,
   void MakeService(unsigned int entry_count) {
     transfer_buffer_manager_ = base::MakeUnique<TransferBufferManager>(nullptr);
     command_buffer_service_ = base::MakeUnique<CommandBufferService>(
-        this, transfer_buffer_manager_.get(), api_mock());
+        this, transfer_buffer_manager_.get());
+    api_mock_.reset(new AsyncAPIMock(false, command_buffer_service_.get()));
     SetNewGetBuffer(entry_count * sizeof(CommandBufferEntry));
   }
 
@@ -65,7 +63,7 @@ class CommandBufferServiceTest : public testing::Test,
   int32_t GetPut() { return command_buffer_service_->put_offset(); }
 
   error::Error SetPutAndProcessAllCommands(int32_t put) {
-    command_buffer_service_->Flush(put);
+    command_buffer_service_->Flush(put, api_mock());
     EXPECT_EQ(put, GetPut());
     return command_buffer_service_->GetState().error;
   }
@@ -98,9 +96,9 @@ class CommandBufferServiceTest : public testing::Test,
   MOCK_METHOD0(OnParseError, void());
 
  private:
-  std::unique_ptr<AsyncAPIMock> api_mock_;
   std::unique_ptr<TransferBufferManager> transfer_buffer_manager_;
   std::unique_ptr<CommandBufferService> command_buffer_service_;
+  std::unique_ptr<AsyncAPIMock> api_mock_;
   scoped_refptr<Buffer> buffer_;
   Sequence sequence_;
 };
@@ -306,7 +304,7 @@ TEST_F(CommandBufferServiceTest, TestError) {
   EXPECT_EQ(2, GetPut());
 
   EXPECT_CALL(*this, OnParseError()).Times(1);
-  command_buffer_service()->Flush(kNumEntries + 1);
+  command_buffer_service()->Flush(kNumEntries + 1, api_mock());
   CommandBuffer::State state1 = command_buffer_service()->GetState();
   EXPECT_EQ(2, GetPut());
   EXPECT_EQ(error::kOutOfBounds, state1.error);
@@ -317,7 +315,7 @@ TEST_F(CommandBufferServiceTest, TestError) {
   EXPECT_EQ(2, GetPut());
 
   EXPECT_CALL(*this, OnParseError()).Times(1);
-  command_buffer_service()->Flush(-1);
+  command_buffer_service()->Flush(-1, api_mock());
   CommandBuffer::State state2 = command_buffer_service()->GetState();
   EXPECT_EQ(2, GetPut());
   EXPECT_EQ(error::kOutOfBounds, state2.error);
@@ -356,7 +354,7 @@ TEST_F(CommandBufferServiceTest, SetBuffer) {
 
   // Trying to execute commands should fail however.
   EXPECT_CALL(*this, OnParseError()).Times(1);
-  command_buffer_service()->Flush(2);
+  command_buffer_service()->Flush(2, api_mock());
   CommandBuffer::State state4 = command_buffer_service()->GetState();
   EXPECT_EQ(0, GetPut());
   EXPECT_EQ(error::kOutOfBounds, state4.error);
@@ -378,7 +376,7 @@ TEST_F(CommandBufferServiceTest, InvalidSetBuffer) {
 
   // Trying to execute commands should fail however.
   EXPECT_CALL(*this, OnParseError()).Times(1);
-  command_buffer_service()->Flush(2);
+  command_buffer_service()->Flush(2, api_mock());
   CommandBuffer::State state3 = command_buffer_service()->GetState();
   EXPECT_EQ(0, GetPut());
   EXPECT_EQ(error::kOutOfBounds, state3.error);
diff --git a/gpu/command_buffer/service/common_decoder.cc b/gpu/command_buffer/service/common_decoder.cc
index ae6920f7af80ad..e6a55d6bf9212a 100644
--- a/gpu/command_buffer/service/common_decoder.cc
+++ b/gpu/command_buffer/service/common_decoder.cc
@@ -126,16 +126,17 @@ bool CommonDecoder::Bucket::GetAsStrings(
   return true;
 }
 
-CommonDecoder::CommonDecoder()
-    : command_buffer_service_(nullptr),
-      max_bucket_size_(kDefaultMaxBucketSize) {}
+CommonDecoder::CommonDecoder(CommandBufferServiceBase* command_buffer_service)
+    : command_buffer_service_(command_buffer_service),
+      max_bucket_size_(kDefaultMaxBucketSize) {
+  DCHECK(command_buffer_service_);
+}
 
 CommonDecoder::~CommonDecoder() {}
 
 void* CommonDecoder::GetAddressAndCheckSize(unsigned int shm_id,
                                             unsigned int data_offset,
                                             unsigned int data_size) {
-  CHECK(command_buffer_service_);
   scoped_refptr<gpu::Buffer> buffer =
       command_buffer_service_->GetTransferBuffer(shm_id);
   if (!buffer.get())
@@ -147,7 +148,6 @@ void* CommonDecoder::GetAddressAndSize(unsigned int shm_id,
                                        unsigned int data_offset,
                                        unsigned int minimum_size,
                                        unsigned int* data_size) {
-  CHECK(command_buffer_service_);
   scoped_refptr<gpu::Buffer> buffer =
       command_buffer_service_->GetTransferBuffer(shm_id);
   if (!buffer.get() || buffer->GetRemainingSize(data_offset) < minimum_size)
@@ -157,7 +157,6 @@ void* CommonDecoder::GetAddressAndSize(unsigned int shm_id,
 
 unsigned int CommonDecoder::GetSharedMemorySize(unsigned int shm_id,
                                                 unsigned int offset) {
-  CHECK(command_buffer_service_);
   scoped_refptr<gpu::Buffer> buffer =
       command_buffer_service_->GetTransferBuffer(shm_id);
   if (!buffer.get())
diff --git a/gpu/command_buffer/service/common_decoder.h b/gpu/command_buffer/service/common_decoder.h
index ebf06327e9fcce..d6122b26e055b1 100644
--- a/gpu/command_buffer/service/common_decoder.h
+++ b/gpu/command_buffer/service/common_decoder.h
@@ -109,15 +109,9 @@ class GPU_EXPORT CommonDecoder {
     DISALLOW_COPY_AND_ASSIGN(Bucket);
   };
 
-  CommonDecoder();
+  explicit CommonDecoder(CommandBufferServiceBase* command_buffer_service);
   ~CommonDecoder();
 
-  // Sets the engine, to get shared memory buffers from, and to set the token
-  // to.
-  void set_command_buffer_service(
-      CommandBufferServiceBase* command_buffer_service) {
-    command_buffer_service_ = command_buffer_service;
-  }
   CommandBufferServiceBase* command_buffer_service() const {
     return command_buffer_service_;
   }
diff --git a/gpu/command_buffer/service/common_decoder_unittest.cc b/gpu/command_buffer/service/common_decoder_unittest.cc
index dd7971201f6dec..5368ae69ebf04d 100644
--- a/gpu/command_buffer/service/common_decoder_unittest.cc
+++ b/gpu/command_buffer/service/common_decoder_unittest.cc
@@ -56,6 +56,8 @@ TEST(CommonDecoderBucket, SetData) {
 
 class TestCommonDecoder : public CommonDecoder {
  public:
+  explicit TestCommonDecoder(CommandBufferServiceBase* command_buffer_service)
+      : CommonDecoder(command_buffer_service) {}
   error::Error DoCommand(unsigned int command,
                          unsigned int arg_count,
                          const volatile void* cmd_data) {
@@ -71,11 +73,11 @@ class CommonDecoderTest : public testing::Test {
  protected:
   static const size_t kBufferSize = 1024;
   static const uint32_t kInvalidShmId = UINT32_MAX;
+  CommonDecoderTest() : decoder_(&command_buffer_service_) {}
 
   void SetUp() override {
     command_buffer_service_.CreateTransferBufferHelper(kBufferSize,
                                                        &valid_shm_id_);
-    decoder_.set_command_buffer_service(&command_buffer_service_);
   }
 
   void TearDown() override {}
diff --git a/gpu/command_buffer/service/context_group_unittest.cc b/gpu/command_buffer/service/context_group_unittest.cc
index 263a778e23020f..3ef61f90ddc55d 100644
--- a/gpu/command_buffer/service/context_group_unittest.cc
+++ b/gpu/command_buffer/service/context_group_unittest.cc
@@ -8,6 +8,7 @@
 
 #include <memory>
 
+#include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/image_manager.h"
@@ -42,7 +43,7 @@ class ContextGroupTest : public GpuServiceTest {
  protected:
   void SetUp() override {
     GpuServiceTest::SetUp();
-    decoder_.reset(new MockGLES2Decoder());
+    decoder_.reset(new MockGLES2Decoder(&command_buffer_service_));
     scoped_refptr<FeatureInfo> feature_info = new FeatureInfo;
     group_ = scoped_refptr<ContextGroup>(new ContextGroup(
         gpu_preferences_, nullptr /* mailbox_manager */,
@@ -56,6 +57,7 @@ class ContextGroupTest : public GpuServiceTest {
   GpuPreferences gpu_preferences_;
   ImageManager image_manager_;
   ServiceDiscardableManager discardable_manager_;
+  FakeCommandBufferServiceBase command_buffer_service_;
   std::unique_ptr<MockGLES2Decoder> decoder_;
   scoped_refptr<ContextGroup> group_;
 };
@@ -111,7 +113,9 @@ TEST_F(ContextGroupTest, InitializeNoExtensions) {
 }
 
 TEST_F(ContextGroupTest, MultipleContexts) {
-  std::unique_ptr<MockGLES2Decoder> decoder2_(new MockGLES2Decoder());
+  FakeCommandBufferServiceBase command_buffer_service2;
+  std::unique_ptr<MockGLES2Decoder> decoder2_(
+      new MockGLES2Decoder(&command_buffer_service2));
   TestHelper::SetupContextGroupInitExpectations(
       gl_.get(), DisallowedFeatures(), "", "",
       CONTEXT_TYPE_OPENGLES2, kBindGeneratesResource);
diff --git a/gpu/command_buffer/service/framebuffer_manager_unittest.cc b/gpu/command_buffer/service/framebuffer_manager_unittest.cc
index b415ab59abb6f0..1ebaedaf63aa62 100644
--- a/gpu/command_buffer/service/framebuffer_manager_unittest.cc
+++ b/gpu/command_buffer/service/framebuffer_manager_unittest.cc
@@ -5,6 +5,7 @@
 #include <stddef.h>
 #include <stdint.h>
 
+#include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
@@ -149,7 +150,7 @@ class FramebufferInfoTestBase : public GpuServiceTest {
     TestHelper::SetupFeatureInfoInitExpectationsWithGLVersion(gl_.get(),
         extensions, "", gl_version, context_type_);
     feature_info_->InitializeForTesting(context_type_);
-    decoder_.reset(new MockGLES2Decoder());
+    decoder_.reset(new MockGLES2Decoder(&command_buffer_service_));
     manager_.CreateFramebuffer(kClient1Id, kService1Id);
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
     framebuffer_ = manager_.GetFramebuffer(kClient1Id);
@@ -164,6 +165,7 @@ class FramebufferInfoTestBase : public GpuServiceTest {
   std::unique_ptr<TextureManager> texture_manager_;
   std::unique_ptr<RenderbufferManager> renderbuffer_manager_;
   std::unique_ptr<MockErrorState> error_state_;
+  FakeCommandBufferServiceBase command_buffer_service_;
   std::unique_ptr<MockGLES2Decoder> decoder_;
 };
 
diff --git a/gpu/command_buffer/service/gl_context_virtual_unittest.cc b/gpu/command_buffer/service/gl_context_virtual_unittest.cc
index fa6912e6e32745..cdac976c64ec6c 100644
--- a/gpu/command_buffer/service/gl_context_virtual_unittest.cc
+++ b/gpu/command_buffer/service/gl_context_virtual_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 
+#include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "ui/gl/gl_context_stub.h"
@@ -19,10 +20,12 @@ using testing::Return;
 
 class GLContextVirtualTest : public GpuServiceTest {
  public:
-  GLContextVirtualTest() : decoder_(new gles2::MockGLES2Decoder()) {}
+  GLContextVirtualTest()
+      : decoder_(new gles2::MockGLES2Decoder(&command_buffer_service_)) {}
   ~GLContextVirtualTest() override {}
 
  protected:
+  FakeCommandBufferServiceBase command_buffer_service_;
   std::unique_ptr<MockGLES2Decoder> decoder_;
 };
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index cf5da742e48d72..064b3cd922bd60 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -479,11 +479,11 @@ uint32_t GLES2Decoder::GetAndClearBackbufferClearBitsForTest() {
   return 0;
 }
 
-GLES2Decoder::GLES2Decoder()
-    : initialized_(false),
+GLES2Decoder::GLES2Decoder(CommandBufferServiceBase* command_buffer_service)
+    : CommonDecoder(command_buffer_service),
+      initialized_(false),
       debug_(false),
-      log_commands_(false) {
-}
+      log_commands_(false) {}
 
 GLES2Decoder::~GLES2Decoder() {
 }
@@ -500,7 +500,8 @@ base::StringPiece GLES2Decoder::GetLogPrefix() {
 // cmd stuff to outside this class.
 class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
  public:
-  explicit GLES2DecoderImpl(ContextGroup* group);
+  GLES2DecoderImpl(CommandBufferServiceBase* command_buffer_service,
+                   ContextGroup* group);
   ~GLES2DecoderImpl() override;
 
   error::Error DoCommands(unsigned int num_commands,
@@ -3060,15 +3061,19 @@ GLenum BackFramebuffer::CheckStatus() {
   return glCheckFramebufferStatusEXT(GL_FRAMEBUFFER);
 }
 
-GLES2Decoder* GLES2Decoder::Create(ContextGroup* group) {
+GLES2Decoder* GLES2Decoder::Create(
+    CommandBufferServiceBase* command_buffer_service,
+    ContextGroup* group) {
   if (group->gpu_preferences().use_passthrough_cmd_decoder) {
-    return new GLES2DecoderPassthroughImpl(group);
+    return new GLES2DecoderPassthroughImpl(command_buffer_service, group);
   }
-  return new GLES2DecoderImpl(group);
+  return new GLES2DecoderImpl(command_buffer_service, group);
 }
 
-GLES2DecoderImpl::GLES2DecoderImpl(ContextGroup* group)
-    : GLES2Decoder(),
+GLES2DecoderImpl::GLES2DecoderImpl(
+    CommandBufferServiceBase* command_buffer_service,
+    ContextGroup* group)
+    : GLES2Decoder(command_buffer_service),
       group_(group),
       logger_(&debug_marker_manager_),
       state_(group_->feature_info(), this, &logger_),
@@ -4314,7 +4319,7 @@ bool GLES2DecoderImpl::MakeCurrent() {
 
 void GLES2DecoderImpl::ProcessFinishedAsyncTransfers() {
   ProcessPendingReadPixels(false);
-  if (command_buffer_service() && query_manager_.get())
+  if (query_manager_.get())
     query_manager_->ProcessPendingTransferQueries();
 }
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.h b/gpu/command_buffer/service/gles2_cmd_decoder.h
index 85b6acc5dec8d0..1bc8eafe70850f 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.h
@@ -96,7 +96,8 @@ class GPU_EXPORT GLES2Decoder : public CommonDecoder,
   static const unsigned int kDefaultStencilMask;
 
   // Creates a decoder.
-  static GLES2Decoder* Create(ContextGroup* group);
+  static GLES2Decoder* Create(CommandBufferServiceBase* command_buffer_service,
+                              ContextGroup* group);
 
   ~GLES2Decoder() override;
 
@@ -320,7 +321,7 @@ class GPU_EXPORT GLES2Decoder : public CommonDecoder,
       unsigned int type) = 0;
 
  protected:
-  GLES2Decoder();
+  explicit GLES2Decoder(CommandBufferServiceBase* command_buffer_service);
 
   base::StringPiece GetLogPrefix() override;
 
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_mock.cc b/gpu/command_buffer/service/gles2_cmd_decoder_mock.cc
index f447b2bed2ed62..5df3d06eb0ce3f 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_mock.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_mock.cc
@@ -9,7 +9,9 @@
 namespace gpu {
 namespace gles2 {
 
-MockGLES2Decoder::MockGLES2Decoder() : GLES2Decoder(), weak_ptr_factory_(this) {
+MockGLES2Decoder::MockGLES2Decoder(
+    CommandBufferServiceBase* command_buffer_service)
+    : GLES2Decoder(command_buffer_service), weak_ptr_factory_(this) {
   ON_CALL(*this, MakeCurrent())
       .WillByDefault(testing::Return(true));
 }
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
index c2629a3536c723..a2597112228cf7 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_mock.h
@@ -36,7 +36,7 @@ struct ContextState;
 
 class MockGLES2Decoder : public GLES2Decoder {
  public:
-  MockGLES2Decoder();
+  explicit MockGLES2Decoder(CommandBufferServiceBase* command_buffer_service);
   virtual ~MockGLES2Decoder();
 
   base::WeakPtr<GLES2Decoder> AsWeakPtr() override;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.cc b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.cc
index d9adaf81f7b0b4..6d9c62281f938d 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.cc
@@ -70,8 +70,11 @@ void PassthroughResources::Destroy(bool have_context) {
   texture_object_map.clear();
 }
 
-GLES2DecoderPassthroughImpl::GLES2DecoderPassthroughImpl(ContextGroup* group)
-    : commands_to_process_(0),
+GLES2DecoderPassthroughImpl::GLES2DecoderPassthroughImpl(
+    CommandBufferServiceBase* command_buffer_service,
+    ContextGroup* group)
+    : GLES2Decoder(command_buffer_service),
+      commands_to_process_(0),
       debug_marker_manager_(),
       logger_(&debug_marker_manager_),
       surface_(),
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h
index a73c57bb895d94..c74afbc994a800 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_passthrough.h
@@ -69,7 +69,8 @@ struct PassthroughResources {
 
 class GLES2DecoderPassthroughImpl : public GLES2Decoder {
  public:
-  explicit GLES2DecoderPassthroughImpl(ContextGroup* group);
+  GLES2DecoderPassthroughImpl(CommandBufferServiceBase* command_buffer_service,
+                              ContextGroup* group);
   ~GLES2DecoderPassthroughImpl() override;
 
   Error DoCommands(unsigned int num_commands,
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
index 74be9a9c151fc3..fe09265ec9b4f5 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.cc
@@ -231,7 +231,8 @@ void GLES2DecoderTestBase::InitDecoderWithCommandLine(
   // We initialize the ContextGroup with a MockGLES2Decoder so that
   // we can use the ContextGroup to figure out how the real GLES2Decoder
   // will initialize itself.
-  mock_decoder_.reset(new MockGLES2Decoder());
+  command_buffer_service_.reset(new FakeCommandBufferServiceBase());
+  mock_decoder_.reset(new MockGLES2Decoder(command_buffer_service_.get()));
 
   EXPECT_TRUE(group_->Initialize(mock_decoder_.get(), init.context_type,
                                  DisallowedFeatures()));
@@ -458,7 +459,6 @@ void GLES2DecoderTestBase::InitDecoderWithCommandLine(
   }
 #endif
 
-  command_buffer_service_.reset(new FakeCommandBufferServiceBase());
   scoped_refptr<gpu::Buffer> buffer =
       command_buffer_service_->CreateTransferBufferHelper(kSharedBufferSize,
                                                           &shared_memory_id_);
@@ -476,7 +476,8 @@ void GLES2DecoderTestBase::InitDecoderWithCommandLine(
       normalized_init.lose_context_when_out_of_memory;
   attribs.context_type = init.context_type;
 
-  decoder_.reset(GLES2Decoder::Create(group_.get()));
+  decoder_.reset(
+      GLES2Decoder::Create(command_buffer_service_.get(), group_.get()));
   decoder_->SetIgnoreCachedStateForTest(ignore_cached_state_for_test_);
   decoder_->GetLogger()->set_log_synthesized_gl_errors(false);
   ASSERT_TRUE(decoder_->Initialize(surface_, context_, false,
@@ -488,7 +489,6 @@ void GLES2DecoderTestBase::InitDecoderWithCommandLine(
         .WillOnce(Return(GL_NO_ERROR));
   }
   decoder_->MakeCurrent();
-  decoder_->set_command_buffer_service(command_buffer_service_.get());
   decoder_->BeginDecoding();
 
   EXPECT_CALL(*gl_, GenBuffersARB(_, _))
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
index edefc80bd4e95a..3624e8c26cfb74 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_unittest_base.h
@@ -657,6 +657,7 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   std::unique_ptr<::testing::StrictMock<::gl::MockGLInterface>> gl_;
   scoped_refptr<gl::GLSurfaceStub> surface_;
   scoped_refptr<GLContextMock> context_;
+  std::unique_ptr<FakeCommandBufferServiceBase> command_buffer_service_;
   std::unique_ptr<MockGLES2Decoder> mock_decoder_;
   std::unique_ptr<GLES2Decoder> decoder_;
   MemoryTracker* memory_tracker_;
@@ -756,7 +757,6 @@ class GLES2DecoderTestBase : public ::testing::TestWithParam<bool> {
   void SetupInitStateManualExpectations(bool es3_capable);
   void SetupInitStateManualExpectationsForDoLineWidth(GLfloat width);
 
-  std::unique_ptr<FakeCommandBufferServiceBase> command_buffer_service_;
   GpuPreferences gpu_preferences_;
   gles2::ImageManager image_manager_;
   ServiceDiscardableManager discardable_manager_;
diff --git a/gpu/command_buffer/service/gpu_tracer_unittest.cc b/gpu/command_buffer/service/gpu_tracer_unittest.cc
index 06e48561f45389..ac2ab7b5101ddc 100644
--- a/gpu/command_buffer/service/gpu_tracer_unittest.cc
+++ b/gpu/command_buffer/service/gpu_tracer_unittest.cc
@@ -5,6 +5,7 @@
 #include <stdint.h>
 
 #include "base/bind.h"
+#include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/gpu_tracer.h"
@@ -335,7 +336,8 @@ class BaseGpuTracerTest : public BaseGpuTest {
   void DoBasicTracerTest() {
     ExpectTracerOffsetQueryMocks();
 
-    MockGLES2Decoder decoder;
+    FakeCommandBufferServiceBase command_buffer_service;
+    MockGLES2Decoder decoder(&command_buffer_service);
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetTracingEnabled(true);
@@ -353,7 +355,8 @@ class BaseGpuTracerTest : public BaseGpuTest {
 
     const GpuTracerSource source = static_cast<GpuTracerSource>(0);
 
-    MockGLES2Decoder decoder;
+    FakeCommandBufferServiceBase command_buffer_service;
+    MockGLES2Decoder decoder(&command_buffer_service);
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetTracingEnabled(false);
@@ -380,7 +383,8 @@ class BaseGpuTracerTest : public BaseGpuTest {
     const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
-    MockGLES2Decoder decoder;
+    FakeCommandBufferServiceBase command_buffer_service;
+    MockGLES2Decoder decoder(&command_buffer_service);
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetTracingEnabled(true);
@@ -454,7 +458,8 @@ class BaseGpuTracerTest : public BaseGpuTest {
         offset_time;
     const bool valid_timer = gpu_timing_client_->IsAvailable();
 
-    MockGLES2Decoder decoder;
+    FakeCommandBufferServiceBase command_buffer_service;
+    MockGLES2Decoder decoder(&command_buffer_service);
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetOutputter(outputter_ref_);
@@ -532,7 +537,8 @@ class BaseGpuTracerTest : public BaseGpuTest {
     const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
-    MockGLES2Decoder decoder;
+    FakeCommandBufferServiceBase command_buffer_service;
+    MockGLES2Decoder decoder(&command_buffer_service);
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     GPUTracerTester tracer(&decoder);
     tracer.SetTracingEnabled(true);
@@ -594,7 +600,8 @@ class BaseGpuTracerTest : public BaseGpuTest {
     const int64_t expect_end_time =
         (end_timestamp / base::Time::kNanosecondsPerMicrosecond) + offset_time;
 
-    MockGLES2Decoder decoder;
+    FakeCommandBufferServiceBase command_buffer_service;
+    MockGLES2Decoder decoder(&command_buffer_service);
     EXPECT_CALL(decoder, GetGLContext()).WillOnce(Return(GetGLContext()));
     EXPECT_CALL(decoder, MakeCurrent()).WillRepeatedly(Return(true));
     GPUTracerTester tracer(&decoder);
@@ -733,7 +740,7 @@ class GPUTracerTest : public GpuServiceTest {
   void SetUp() override {
     g_fakeCPUTime = 0;
     GpuServiceTest::SetUpWithGLVersion("3.2", "");
-    decoder_.reset(new MockGLES2Decoder());
+    decoder_.reset(new MockGLES2Decoder(&command_buffer_service_));
     EXPECT_CALL(*decoder_, GetGLContext())
         .Times(AtMost(1))
         .WillRepeatedly(Return(GetGLContext()));
@@ -745,6 +752,7 @@ class GPUTracerTest : public GpuServiceTest {
     decoder_ = nullptr;
     GpuServiceTest::TearDown();
   }
+  FakeCommandBufferServiceBase command_buffer_service_;
   std::unique_ptr<MockGLES2Decoder> decoder_;
   std::unique_ptr<GPUTracerTester> tracer_tester_;
 };
diff --git a/gpu/command_buffer/service/mocks.cc b/gpu/command_buffer/service/mocks.cc
index 52b0ea11d62d7d..e8d115383e8a80 100644
--- a/gpu/command_buffer/service/mocks.cc
+++ b/gpu/command_buffer/service/mocks.cc
@@ -12,7 +12,9 @@ using testing::_;
 
 namespace gpu {
 
-AsyncAPIMock::AsyncAPIMock(bool default_do_commands) {
+AsyncAPIMock::AsyncAPIMock(bool default_do_commands,
+                           CommandBufferServiceBase* command_buffer_service)
+    : command_buffer_service_(command_buffer_service) {
   testing::DefaultValue<error::Error>::Set(
       error::kNoError);
 
diff --git a/gpu/command_buffer/service/mocks.h b/gpu/command_buffer/service/mocks.h
index 58d32fed1ce24d..a848a1b17c0115 100644
--- a/gpu/command_buffer/service/mocks.h
+++ b/gpu/command_buffer/service/mocks.h
@@ -30,7 +30,8 @@ class CommandBufferServiceBase;
 // Mocks an AsyncAPIInterface, using GMock.
 class AsyncAPIMock : public AsyncAPIInterface {
  public:
-  explicit AsyncAPIMock(bool default_do_commands);
+  explicit AsyncAPIMock(bool default_do_commands,
+                        CommandBufferServiceBase* command_buffer_service);
   virtual ~AsyncAPIMock();
 
   error::Error FakeDoCommands(unsigned int num_commands,
@@ -76,12 +77,6 @@ class AsyncAPIMock : public AsyncAPIInterface {
 
   base::StringPiece GetLogPrefix() override { return "None"; }
 
-  // Sets the engine, to forward SetToken commands to it.
-  void set_command_buffer_service(
-      CommandBufferServiceBase* command_buffer_service) {
-    command_buffer_service_ = command_buffer_service;
-  }
-
   // Forwards the SetToken commands to the engine.
   void SetToken(unsigned int command,
                 unsigned int arg_count,
diff --git a/gpu/command_buffer/service/query_manager_unittest.cc b/gpu/command_buffer/service/query_manager_unittest.cc
index 798885f3f60cf3..e582bf108a8fef 100644
--- a/gpu/command_buffer/service/query_manager_unittest.cc
+++ b/gpu/command_buffer/service/query_manager_unittest.cc
@@ -69,8 +69,7 @@ class QueryManagerTest : public GpuServiceTest {
     buffer = command_buffer_service_->CreateTransferBufferHelper(
         kSharedBufferSize, &shared_memory2_id_);
     memset(buffer->memory(), kInitialMemoryValue, kSharedBufferSize);
-    decoder_.reset(new MockGLES2Decoder());
-    decoder_->set_command_buffer_service(command_buffer_service_.get());
+    decoder_.reset(new MockGLES2Decoder(command_buffer_service_.get()));
     TestHelper::SetupFeatureInfoInitExpectations(
         gl_.get(), extension_expectations);
     EXPECT_CALL(*decoder_.get(), GetGLContext())
@@ -104,14 +103,12 @@ class QueryManagerTest : public GpuServiceTest {
     EXPECT_TRUE(manager_->EndQuery(query, submit_count));
   }
 
+  std::unique_ptr<FakeCommandBufferServiceBase> command_buffer_service_;
   std::unique_ptr<MockGLES2Decoder> decoder_;
   std::unique_ptr<QueryManager> manager_;
 
   int32_t shared_memory_id_ = 0;
   int32_t shared_memory2_id_ = 0;
-
- private:
-  std::unique_ptr<FakeCommandBufferServiceBase> command_buffer_service_;
 };
 
 class QueryManagerManualSetupTest : public QueryManagerTest {
diff --git a/gpu/command_buffer/service/service_discardable_manager_unittest.cc b/gpu/command_buffer/service/service_discardable_manager_unittest.cc
index 86eed6d5345e94..6cdffaf1192d86 100644
--- a/gpu/command_buffer/service/service_discardable_manager_unittest.cc
+++ b/gpu/command_buffer/service/service_discardable_manager_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "gpu/command_buffer/service/service_discardable_manager.h"
 
+#include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "gpu/command_buffer/service/gpu_service_test.h"
 #include "gpu/command_buffer/service/image_manager.h"
@@ -66,7 +67,7 @@ class ServiceDiscardableManagerTest : public GpuServiceTest {
  protected:
   void SetUp() override {
     GpuServiceTest::SetUp();
-    decoder_.reset(new MockGLES2Decoder());
+    decoder_.reset(new MockGLES2Decoder(&command_buffer_service_));
     feature_info_ = new FeatureInfo();
     context_group_ = scoped_refptr<ContextGroup>(
         new ContextGroup(gpu_preferences_, nullptr, nullptr, nullptr, nullptr,
@@ -118,6 +119,7 @@ class ServiceDiscardableManagerTest : public GpuServiceTest {
   scoped_refptr<FeatureInfo> feature_info_;
   MockDestructionObserver destruction_observer_;
   TextureManager* texture_manager_;
+  FakeCommandBufferServiceBase command_buffer_service_;
   std::unique_ptr<MockGLES2Decoder> decoder_;
   scoped_refptr<gles2::ContextGroup> context_group_;
 };
diff --git a/gpu/command_buffer/service/texture_manager_unittest.cc b/gpu/command_buffer/service/texture_manager_unittest.cc
index 242a73f382690d..ad82cf301ecdae 100644
--- a/gpu/command_buffer/service/texture_manager_unittest.cc
+++ b/gpu/command_buffer/service/texture_manager_unittest.cc
@@ -12,6 +12,7 @@
 
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/service/error_state_mock.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
@@ -674,7 +675,8 @@ class TextureTestBase : public GpuServiceTest {
         kMaxCubeMapTextureSize, kMaxRectangleTextureSize, kMax3DTextureSize,
         kMaxArrayTextureLayers, kUseDefaultTextures, nullptr,
         &discardable_manager_));
-    decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>());
+    decoder_.reset(new ::testing::StrictMock<gles2::MockGLES2Decoder>(
+        &command_buffer_service_));
     error_state_.reset(new ::testing::StrictMock<gles2::MockErrorState>());
     manager_->CreateTexture(kClient1Id, kService1Id);
     texture_ref_ = manager_->GetTexture(kClient1Id);
@@ -706,6 +708,7 @@ class TextureTestBase : public GpuServiceTest {
         texture_ref, pname, value, error);
   }
 
+  FakeCommandBufferServiceBase command_buffer_service_;
   std::unique_ptr<MockGLES2Decoder> decoder_;
   std::unique_ptr<MockErrorState> error_state_;
   scoped_refptr<FeatureInfo> feature_info_;
diff --git a/gpu/command_buffer/tests/fuzzer_main.cc b/gpu/command_buffer/tests/fuzzer_main.cc
index e010a447808bac..422b924c8ae8fe 100644
--- a/gpu/command_buffer/tests/fuzzer_main.cc
+++ b/gpu/command_buffer/tests/fuzzer_main.cc
@@ -141,15 +141,15 @@ class CommandBufferSetup {
         true /* bind_generates_resource */, &image_manager_,
         nullptr /* image_factory */, nullptr /* progress_reporter */,
         GpuFeatureInfo(), &discardable_manager_);
-    decoder_.reset(gles2::GLES2Decoder::Create(context_group.get()));
     command_buffer_.reset(new CommandBufferDirect(
-        context_group->transfer_buffer_manager(), decoder_.get(),
-        base::Bind(&gles2::GLES2Decoder::MakeCurrent,
-                   base::Unretained(decoder_.get())),
-        &sync_point_manager_));
+        context_group->transfer_buffer_manager(), &sync_point_manager_));
+
+    decoder_.reset(gles2::GLES2Decoder::Create(command_buffer_->service(),
+                                               context_group.get()));
+    command_buffer_->set_handler(decoder_.get());
+
     InitializeInitialCommandBuffer();
 
-    decoder_->set_command_buffer_service(command_buffer_->service());
     decoder_->SetFenceSyncReleaseCallback(
         base::Bind(&CommandBufferDirect::OnFenceSyncRelease,
                    base::Unretained(command_buffer_.get())));
@@ -181,6 +181,7 @@ class CommandBufferSetup {
       vertex_translator_ = decoder_->GetTranslator(GL_VERTEX_SHADER);
       fragment_translator_ = decoder_->GetTranslator(GL_FRAGMENT_SHADER);
     }
+    decoder_->MakeCurrent();
   }
 
   void ResetDecoder() {
diff --git a/gpu/command_buffer/tests/gl_manager.cc b/gpu/command_buffer/tests/gl_manager.cc
index 33b7b2fcbf9353..fbba456321d8e9 100644
--- a/gpu/command_buffer/tests/gl_manager.cc
+++ b/gpu/command_buffer/tests/gl_manager.cc
@@ -175,14 +175,9 @@ class IOSurfaceGpuMemoryBuffer : public gfx::GpuMemoryBuffer {
 class CommandBufferCheckLostContext : public CommandBufferDirect {
  public:
   CommandBufferCheckLostContext(TransferBufferManager* transfer_buffer_manager,
-                                AsyncAPIInterface* handler,
-                                const MakeCurrentCallback& callback,
                                 SyncPointManager* sync_point_manager,
                                 bool context_lost_allowed)
-      : CommandBufferDirect(transfer_buffer_manager,
-                            handler,
-                            callback,
-                            sync_point_manager),
+      : CommandBufferDirect(transfer_buffer_manager, sync_point_manager),
         context_lost_allowed_(context_lost_allowed) {}
 
   ~CommandBufferCheckLostContext() override {}
@@ -323,17 +318,17 @@ void GLManager::InitializeWithCommandLine(
         &discardable_manager_);
   }
 
-  decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group));
+  command_buffer_.reset(new CommandBufferCheckLostContext(
+      context_group->transfer_buffer_manager(), options.sync_point_manager,
+      options.context_lost_allowed));
+
+  decoder_.reset(::gpu::gles2::GLES2Decoder::Create(command_buffer_->service(),
+                                                    context_group));
   if (options.force_shader_name_hashing) {
     decoder_->SetForceShaderNameHashingForTest(true);
   }
-  command_buffer_.reset(new CommandBufferCheckLostContext(
-      decoder_->GetContextGroup()->transfer_buffer_manager(), decoder_.get(),
-      base::Bind(&gles2::GLES2Decoder::MakeCurrent,
-                 base::Unretained(decoder_.get())),
-      options.sync_point_manager, options.context_lost_allowed));
 
-  decoder_->set_command_buffer_service(command_buffer_->service());
+  command_buffer_->set_handler(decoder_.get());
 
   surface_ = gl::init::CreateOffscreenGLSurface(gfx::Size());
   ASSERT_TRUE(surface_.get() != NULL) << "could not create offscreen surface";
@@ -416,6 +411,8 @@ void GLManager::SetupBaseContext() {
 
 void GLManager::MakeCurrent() {
   ::gles2::SetGLContext(gles2_implementation_.get());
+  if (!decoder_->MakeCurrent())
+    command_buffer_->service()->SetParseError(error::kLostContext);
 }
 
 void GLManager::SetSurface(gl::GLSurface* surface) {
diff --git a/gpu/gles2_conform_support/egl/context.cc b/gpu/gles2_conform_support/egl/context.cc
index de8cdbdc93b92e..f3331620660bb0 100644
--- a/gpu/gles2_conform_support/egl/context.cc
+++ b/gpu/gles2_conform_support/egl/context.cc
@@ -266,18 +266,15 @@ bool Context::CreateService(gl::GLSurface* gl_surface) {
       nullptr /* progress_reporter */, gpu::GpuFeatureInfo(),
       &discardable_manager_));
 
-  std::unique_ptr<gpu::gles2::GLES2Decoder> decoder(
-      gpu::gles2::GLES2Decoder::Create(group.get()));
-  if (!decoder.get())
-    return false;
-
   transfer_buffer_manager_ =
       base::MakeUnique<gpu::TransferBufferManager>(nullptr);
   std::unique_ptr<gpu::CommandBufferDirect> command_buffer(
-      new gpu::CommandBufferDirect(transfer_buffer_manager_.get(),
-                                   decoder.get()));
+      new gpu::CommandBufferDirect(transfer_buffer_manager_.get()));
+
+  std::unique_ptr<gpu::gles2::GLES2Decoder> decoder(
+      gpu::gles2::GLES2Decoder::Create(command_buffer->service(), group.get()));
 
-  decoder->set_command_buffer_service(command_buffer->service());
+  command_buffer->set_handler(decoder.get());
 
   gl::GLContextAttribs context_attribs;
   context_attribs.gpu_preference = gl::PreferDiscreteGpu;
diff --git a/gpu/ipc/in_process_command_buffer.cc b/gpu/ipc/in_process_command_buffer.cc
index 4212fde723a925..80bb6bbcce16d3 100644
--- a/gpu/ipc/in_process_command_buffer.cc
+++ b/gpu/ipc/in_process_command_buffer.cc
@@ -314,12 +314,10 @@ bool InProcessCommandBuffer::InitializeOnGpuThread(
                 nullptr /* image_factory */, nullptr /* progress_reporter */,
                 GpuFeatureInfo(), service_->discardable_manager());
 
-  decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
-
   command_buffer_ = base::MakeUnique<CommandBufferService>(
-      this, transfer_buffer_manager_.get(), decoder_.get());
-
-  decoder_->set_command_buffer_service(command_buffer_.get());
+      this, transfer_buffer_manager_.get());
+  decoder_.reset(
+      gles2::GLES2Decoder::Create(command_buffer_.get(), context_group_.get()));
 
   if (!surface_.get()) {
     if (params.is_offscreen) {
@@ -447,13 +445,13 @@ void InProcessCommandBuffer::Destroy() {
 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_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
+  command_buffer_.reset();
   context_ = nullptr;
   surface_ = nullptr;
   if (sync_point_order_data_) {
@@ -580,7 +578,7 @@ void InProcessCommandBuffer::FlushOnGpuThread(
   if (!MakeCurrent())
     return;
 
-  command_buffer_->Flush(put_offset);
+  command_buffer_->Flush(put_offset, decoder_.get());
   // Update state before signaling the flush event.
   UpdateLastStateOnGpuThread();
 
diff --git a/gpu/ipc/service/gpu_command_buffer_stub.cc b/gpu/ipc/service/gpu_command_buffer_stub.cc
index b9bdf6ac810133..4b2a2c5843cbcd 100644
--- a/gpu/ipc/service/gpu_command_buffer_stub.cc
+++ b/gpu/ipc/service/gpu_command_buffer_stub.cc
@@ -633,18 +633,15 @@ bool GpuCommandBufferStub::Initialize(
     use_virtualized_gl_context_ = false;
 #endif
 
-
-  decoder_.reset(gles2::GLES2Decoder::Create(context_group_.get()));
-
   command_buffer_.reset(new CommandBufferService(
-      this, context_group_->transfer_buffer_manager(), decoder_.get()));
+      this, context_group_->transfer_buffer_manager()));
+  decoder_.reset(
+      gles2::GLES2Decoder::Create(command_buffer_.get(), context_group_.get()));
 
   sync_point_client_state_ =
       channel_->sync_point_manager()->CreateSyncPointClientState(
           CommandBufferNamespace::GPU_IO, command_buffer_id_, sequence_id_);
 
-  decoder_->set_command_buffer_service(command_buffer_.get());
-
   if (offscreen) {
     // Do we want to create an offscreen rendering context suitable
     // for directly drawing to a separately supplied surface? In that
@@ -970,7 +967,7 @@ void GpuCommandBufferStub::OnAsyncFlush(
   last_flush_count_ = flush_count;
   CommandBuffer::State pre_state = command_buffer_->GetState();
   FastSetActiveURL(active_url_, active_url_hash_, channel_);
-  command_buffer_->Flush(put_offset);
+  command_buffer_->Flush(put_offset, decoder_.get());
   CommandBuffer::State post_state = command_buffer_->GetState();
 
   if (pre_state.get_offset != post_state.get_offset)
diff --git a/media/gpu/android_video_decode_accelerator_unittest.cc b/media/gpu/android_video_decode_accelerator_unittest.cc
index b4bad911feeffc..b8468b406a666e 100644
--- a/media/gpu/android_video_decode_accelerator_unittest.cc
+++ b/media/gpu/android_video_decode_accelerator_unittest.cc
@@ -17,6 +17,7 @@
 #include "base/run_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "gpu/command_buffer/client/client_test_helper.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_mock.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/android/media_jni_registrar.h"
@@ -137,7 +138,8 @@ class FakeOverlayChooser : public NiceMock<AndroidVideoSurfaceChooser> {
 class AndroidVideoDecodeAcceleratorTest : public testing::Test {
  public:
   // We pick this profile since it's always supported.
-  AndroidVideoDecodeAcceleratorTest() : config_(H264PROFILE_BASELINE) {}
+  AndroidVideoDecodeAcceleratorTest()
+      : gl_decoder_(&command_buffer_service_), config_(H264PROFILE_BASELINE) {}
 
   ~AndroidVideoDecodeAcceleratorTest() override {}
 
@@ -243,6 +245,7 @@ class AndroidVideoDecodeAcceleratorTest : public testing::Test {
   scoped_refptr<gl::GLSurface> surface_;
   scoped_refptr<gl::GLContext> context_;
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+  gpu::FakeCommandBufferServiceBase command_buffer_service_;
   NiceMock<gpu::gles2::MockGLES2Decoder> gl_decoder_;
   NiceMock<MockVDAClient> client_;
   FakeCodecAllocator codec_allocator_;