Revert of Report lost context from GLES2Implementation based on share group state.

gpu/ipc/client/command_buffer_proxy_impl.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/client/command_buffer_proxy_impl.h"
 
 #include <utility>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/shared_memory.h"
-#include "base/optional.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "gpu/command_buffer/client/gpu_control_client.h"
 #include "gpu/command_buffer/client/gpu_memory_buffer_manager.h"
 #include "gpu/command_buffer/common/cmd_buffer_common.h"
 #include "gpu/command_buffer/common/command_buffer_id.h"
 #include "gpu/command_buffer/common/command_buffer_shared.h"
 #include "gpu/command_buffer/common/gpu_memory_allocation.h"
 #include "gpu/command_buffer/common/gpu_memory_buffer_support.h"
@@ skipping 75 matching lines @@
 
   gpu::error::ContextLostReason context_lost_reason =
       gpu::error::kGpuChannelLost;
   if (shared_state_shm_ && shared_state_shm_->memory()) {
     TryUpdateState();
     // The GPU process might have intentionally been crashed
     // (exit_on_context_lost), so try to find out the original reason.
     if (last_state_.error == gpu::error::kLostContext)
       context_lost_reason = last_state_.context_lost_reason;
   }
-  OnLostContextNoReentrancy(context_lost_reason, gpu::error::kLostContext);
+  OnDestroyed(context_lost_reason, gpu::error::kLostContext);
 }
 
 void CommandBufferProxyImpl::OnDestroyed(gpu::error::ContextLostReason reason,
                                          gpu::error::Error error) {
-  OnLostContextNoReentrancy(reason, error);
+  CheckLock();
+
+  // When the client sees that the context is lost, they should delete this
+  // CommandBufferProxyImpl and create a new one.
+  last_state_.error = error;
+  last_state_.context_lost_reason = reason;
+
+  // Prevent any further messages from being sent, and ensure we only call
+  // the client for lost context a single time.
+  if (channel_) {
+    channel_->DestroyCommandBuffer(this);
+    channel_ = nullptr;
+    if (gpu_control_client_)
+      gpu_control_client_->OnGpuControlLostContext();
+  }
 }
 
 void CommandBufferProxyImpl::OnConsoleMessage(
     const GPUCommandBufferConsoleMessage& message) {
   if (gpu_control_client_)
     gpu_control_client_->OnGpuControlErrorMessage(message.message.c_str(),
                                                   message.id);
 }
 
 void CommandBufferProxyImpl::AddDeletionObserver(DeletionObserver* observer) {
@@ skipping 361 matching lines @@
     DLOG(ERROR) << "GpuCommandBufferMsg_CreateStreamTexture returned failure";
     return 0;
   }
   return stream_id;
 }
 
 void CommandBufferProxyImpl::SetLock(base::Lock* lock) {
   lock_ = lock;
 }
 
+bool CommandBufferProxyImpl::IsGpuChannelLost() {
+  return !channel_ || channel_->IsLost();
+}
+
 void CommandBufferProxyImpl::EnsureWorkVisible() {
   if (channel_)
     channel_->ValidateFlushIDReachedServer(stream_id_, true);
 }
 
 gpu::CommandBufferNamespace CommandBufferProxyImpl::GetNamespaceID() const {
   return gpu::CommandBufferNamespace::GPU_IO;
 }
 
 gpu::CommandBufferId CommandBufferProxyImpl::GetCommandBufferID() const {
@@ skipping 174 matching lines @@
 }
 
 void CommandBufferProxyImpl::OnUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   if (!update_vsync_parameters_completion_callback_.is_null())
     update_vsync_parameters_completion_callback_.Run(timebase, interval);
 }
 
 void CommandBufferProxyImpl::InvalidGpuMessage() {
   LOG(ERROR) << "Received invalid message from the GPU process.";
-  OnLostContextNoReentrancy(gpu::error::kInvalidGpuMessage,
-                            gpu::error::kLostContext);
+  OnDestroyed(gpu::error::kInvalidGpuMessage, gpu::error::kLostContext);
 }
 
 void CommandBufferProxyImpl::InvalidGpuReply() {
+  CheckLock();
   LOG(ERROR) << "Received invalid reply from the GPU process.";
-  // This method may be inside a callstack from the GpuControlClient (we got a
-  // bad reply to something we are sending to the GPU process). So avoid
-  // re-entering the GpuControlClient here.
-  OnLostContextAvoidReentrancy(gpu::error::kInvalidGpuMessage,
-                               gpu::error::kLostContext);
-}
-
-void CommandBufferProxyImpl::OnLostContextAvoidReentrancy(
-    gpu::error::ContextLostReason reason,
-    gpu::error::Error error) {
-  CheckLock();
-  // Set the error and reason immediately, in case clients want to query them
-  // as we unwind the stack.
-  last_state_.error = error;
-  last_state_.context_lost_reason = reason;
-  // Create a fresh call stack to call back to the GpuControlClient. For
-  // cases where we're inside a method that the GpuControlClient called
-  // on us and we don't want to re-enter it.
+  last_state_.error = gpu::error::kLostContext;
+  last_state_.context_lost_reason = gpu::error::kInvalidGpuMessage;
   callback_thread_->PostTask(
       FROM_HERE,
-      base::Bind(&CommandBufferProxyImpl::OnLostContextImplFromAvoidReentrancy,
+      base::Bind(&CommandBufferProxyImpl::InvalidGpuReplyOnClientThread,
                  weak_this_));
 }
 
-void CommandBufferProxyImpl::OnLostContextNoReentrancy(
-    gpu::error::ContextLostReason reason,
-    gpu::error::Error error) {
-  last_state_.error = error;
-  last_state_.context_lost_reason = reason;
-  OnLostContextImpl();
-}
-
-void CommandBufferProxyImpl::OnLostContextImplFromAvoidReentrancy() {
-  // This is a fresh call stack so we need to grab the lock.
-  base::Optional<base::AutoLock> hold;
+void CommandBufferProxyImpl::InvalidGpuReplyOnClientThread() {
+  std::unique_ptr<base::AutoLock> lock;
   if (lock_)
-    hold.emplace(*lock_);
-  OnLostContextImpl();
-}
-
-void CommandBufferProxyImpl::OnLostContextImpl() {
-  CheckLock();
-  // Prevent any further messages from being sent, and ensure we only call
-  // the client for lost context a single time.
-  if (!channel_)
-    return;
-  channel_->DestroyCommandBuffer(this);
-  channel_ = nullptr;
-  if (gpu_control_client_)
-    gpu_control_client_->OnGpuControlLostContext();
+    lock.reset(new base::AutoLock(*lock_));
+  OnDestroyed(gpu::error::kInvalidGpuMessage, gpu::error::kLostContext);
 }
 
 }  // namespace gpu