Remove CommandBuffer::GetState

content/common/gpu/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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/hash.h"
 #include "base/memory/shared_memory.h"
@@ skipping 192 matching lines @@
   // here. This is so the reply can be delayed if the scheduler is unscheduled.
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuCommandBufferStub, message)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_Initialize,
                                     OnInitialize);
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_SetGetBuffer,
                                     OnSetGetBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_ProduceFrontBuffer,
                         OnProduceFrontBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Echo, OnEcho);
-    IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuCommandBufferMsg_GetState, OnGetState);
     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_SetLatencyInfo, OnSetLatencyInfo);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_Rescheduled, OnRescheduled);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_RegisterTransferBuffer,
                         OnRegisterTransferBuffer);
     IPC_MESSAGE_HANDLER(GpuCommandBufferMsg_DestroyTransferBuffer,
@@ skipping 163 matching lines @@
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   scheduler_.reset();
 
   bool have_context = false;
   if (decoder_ && command_buffer_ &&
-      command_buffer_->GetState().error != gpu::error::kLostContext)
+      command_buffer_->GetLastState().error != gpu::error::kLostContext)
     have_context = decoder_->MakeCurrent();
   FOR_EACH_OBSERVER(DestructionObserver,
                     destruction_observers_,
                     OnWillDestroyStub());
 
   if (decoder_) {
     decoder_->Destroy(have_context);
     decoder_.reset();
   }
 
@@ skipping 236 matching lines @@
 void GpuCommandBufferStub::OnProduceFrontBuffer(const gpu::Mailbox& mailbox) {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnProduceFrontBuffer");
   if (!decoder_) {
     LOG(ERROR) << "Can't produce front buffer before initialization.";
     return;
   }
 
   decoder_->ProduceFrontBuffer(mailbox);
 }
 
-void GpuCommandBufferStub::OnGetState(IPC::Message* reply_message) {
-  TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnGetState");
-  if (command_buffer_) {
-    gpu::CommandBuffer::State state = command_buffer_->GetState();
-    CheckContextLost();
-    GpuCommandBufferMsg_GetState::WriteReplyParams(reply_message, state);
-  } else {
-    DLOG(ERROR) << "no command_buffer.";
-    reply_message->set_reply_error();
-  }
-  Send(reply_message);
-}
-
 void GpuCommandBufferStub::OnParseError() {
   TRACE_EVENT0("gpu", "GpuCommandBufferStub::OnParseError");
   DCHECK(command_buffer_.get());
-  gpu::CommandBuffer::State state = command_buffer_->GetState();
+  gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   IPC::Message* msg = new GpuCommandBufferMsg_Destroyed(
       route_id_, state.context_lost_reason);
   msg->set_unblock(true);
   Send(msg);
 
   // Tell the browser about this context loss as well, so it can
   // determine whether client APIs like WebGL need to be immediately
   // blocked from automatically running.
   GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
   gpu_channel_manager->Send(new GpuHostMsg_DidLoseContext(
@@ skipping 26 matching lines @@
     LOG(ERROR)
         << "Got WaitForGetOffset command while currently waiting for offset.";
   }
   wait_for_get_offset_ =
       make_scoped_ptr(new WaitForCommandState(start, end, reply_message));
   CheckCompleteWaits();
 }
 
 void GpuCommandBufferStub::CheckCompleteWaits() {
   if (wait_for_token_ || wait_for_get_offset_) {
-    gpu::CommandBuffer::State state = command_buffer_->GetState();
+    gpu::CommandBuffer::State state = command_buffer_->GetLastState();
     if (wait_for_token_ &&
         (gpu::CommandBuffer::InRange(
              wait_for_token_->start, wait_for_token_->end, state.token) ||
          state.error != gpu::error::kNoError)) {
       ReportState();
       GpuCommandBufferMsg_WaitForTokenInRange::WriteReplyParams(
           wait_for_token_->reply.get(), state);
       Send(wait_for_token_->reply.release());
       wait_for_token_.reset();
     }
@@ skipping 307 matching lines @@
 void GpuCommandBufferStub::SuggestHaveFrontBuffer(
     bool suggest_have_frontbuffer) {
   // This can be called outside of OnMessageReceived, so the context needs
   // to be made current before calling methods on the surface.
   if (surface_.get() && MakeCurrent())
     surface_->SetFrontbufferAllocation(suggest_have_frontbuffer);
 }
 
 bool GpuCommandBufferStub::CheckContextLost() {
   DCHECK(command_buffer_);
-  gpu::CommandBuffer::State state = command_buffer_->GetState();
+  gpu::CommandBuffer::State state = command_buffer_->GetLastState();
   bool was_lost = state.error == gpu::error::kLostContext;
   // Lose all other contexts if the reset was triggered by the robustness
   // extension instead of being synthetic.
   if (was_lost && decoder_ && decoder_->WasContextLostByRobustnessExtension() &&
       (gfx::GLContext::LosesAllContextsOnContextLost() ||
        use_virtualized_gl_context_))
     channel_->LoseAllContexts();
   CheckCompleteWaits();
   return was_lost;
 }
 
 void GpuCommandBufferStub::MarkContextLost() {
   if (!command_buffer_ ||
-      command_buffer_->GetState().error == gpu::error::kLostContext)
+      command_buffer_->GetLastState().error == gpu::error::kLostContext)
     return;
 
   command_buffer_->SetContextLostReason(gpu::error::kUnknown);
   if (decoder_)
     decoder_->LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB);
   command_buffer_->SetParseError(gpu::error::kLostContext);
 }
 
 uint64 GpuCommandBufferStub::GetMemoryUsage() const {
   return GetMemoryManager()->GetClientMemoryUsage(this);
 }
 
 }  // namespace content