Make lost context and error message callbacks on GpuControl go to client

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/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"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/ipc/client/gpu_channel_host.h"
 #include "gpu/ipc/common/gpu_messages.h"
 #include "gpu/ipc/common/gpu_param_traits.h"
 #include "ui/gfx/geometry/size.h"
 #include "ui/gl/gl_bindings.h"
 
 namespace gpu {
 
 namespace {
 
 gpu::CommandBufferId CommandBufferProxyID(int channel_id, int32_t route_id) {
   return gpu::CommandBufferId::FromUnsafeValue(
       (static_cast<uint64_t>(channel_id) << 32) | route_id);
 }
 
 }  // namespace
 
 CommandBufferProxyImpl::CommandBufferProxyImpl(GpuChannelHost* channel,
                                                int32_t route_id,
                                                int32_t stream_id)
     : lock_(nullptr),
+      gpu_control_client_(nullptr),
       channel_(channel),
       command_buffer_id_(CommandBufferProxyID(channel->channel_id(), route_id)),
       route_id_(route_id),
       stream_id_(stream_id),
       flush_count_(0),
       last_put_offset_(-1),
       last_barrier_put_offset_(-1),
       next_fence_sync_release_(1),
       flushed_fence_sync_release_(0),
       verified_fence_sync_release_(0),
@@ skipping 48 matching lines @@
     // (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;
   }
   OnDestroyed(context_lost_reason, gpu::error::kLostContext);
 }
 
 void CommandBufferProxyImpl::OnDestroyed(gpu::error::ContextLostReason reason,
                                          gpu::error::Error error) {
   CheckLock();
-  // Prevent any further messages from being sent.
-  if (channel_) {
-    channel_->DestroyCommandBuffer(this);
-    channel_ = nullptr;
-  }
+  DCHECK(gpu_control_client_);

[piman, 2016/04/11 21:54:26]

Same as InProcessCommandBuffer, I think we want to allow for this to be null.

 
   // 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;
 
-  if (!context_lost_callback_.is_null()) {
-    context_lost_callback_.Run();
-    // Avoid calling the error callback more than once.
-    context_lost_callback_.Reset();
+  // 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;
+    gpu_control_client_->OnGpuControlLostContext();
   }
 }
 
 void CommandBufferProxyImpl::OnConsoleMessage(
     const GPUCommandBufferConsoleMessage& message) {
-  if (!console_message_callback_.is_null()) {
-    console_message_callback_.Run(message.message, message.id);
-  }
+  DCHECK(gpu_control_client_);

[piman, 2016/04/11 21:54:26]

(ditto)

+  gpu_control_client_->OnGpuControlErrorMessage(message.message.c_str(),
+                                                message.id);
 }
 
 void CommandBufferProxyImpl::AddDeletionObserver(DeletionObserver* observer) {
   scoped_ptr<base::AutoLock> lock;
   if (lock_)
     lock.reset(new base::AutoLock(*lock_));
   deletion_observers_.AddObserver(observer);
 }
 
 void CommandBufferProxyImpl::RemoveDeletionObserver(
     DeletionObserver* observer) {
   scoped_ptr<base::AutoLock> lock;
   if (lock_)
     lock.reset(new base::AutoLock(*lock_));
   deletion_observers_.RemoveObserver(observer);
 }
 
 void CommandBufferProxyImpl::OnSignalAck(uint32_t id) {
   SignalTaskMap::iterator it = signal_tasks_.find(id);
   if (it == signal_tasks_.end()) {
     DLOG(ERROR) << "Gpu process sent invalid SignalAck.";
     InvalidGpuMessage();
     return;
   }
   base::Closure callback = it->second;
   signal_tasks_.erase(it);
   callback.Run();
 }
 
-void CommandBufferProxyImpl::SetContextLostCallback(
-    const base::Closure& callback) {
-  CheckLock();
-  context_lost_callback_ = callback;
-}
-
 bool CommandBufferProxyImpl::Initialize() {
   TRACE_EVENT0("gpu", "CommandBufferProxyImpl::Initialize");
   shared_state_shm_.reset(channel_->factory()
                               ->AllocateSharedMemory(sizeof(*shared_state()))
                               .release());
   if (!shared_state_shm_)
     return false;
 
   if (!shared_state_shm_->Map(sizeof(*shared_state())))
     return false;
@@ skipping 207 matching lines @@
 }
 
 void CommandBufferProxyImpl::DestroyTransferBuffer(int32_t id) {
   CheckLock();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   Send(new GpuCommandBufferMsg_DestroyTransferBuffer(route_id_, id));
 }
 
+void CommandBufferProxyImpl::SetGpuControlClient(GpuControlClient* client) {
+  CheckLock();
+  gpu_control_client_ = client;
+}
+
 gpu::Capabilities CommandBufferProxyImpl::GetCapabilities() {
   return capabilities_;
 }
 
 int32_t CommandBufferProxyImpl::CreateImage(ClientBuffer buffer,
                                             size_t width,
                                             size_t height,
                                             unsigned internal_format) {
   CheckLock();
   if (last_state_.error != gpu::error::kNoError)
@@ skipping 248 matching lines @@
 }
 
 void CommandBufferProxyImpl::OnUpdateState(
     const gpu::CommandBuffer::State& state) {
   // Handle wraparound. It works as long as we don't have more than 2B state
   // updates in flight across which reordering occurs.
   if (state.generation - last_state_.generation < 0x80000000U)
     last_state_ = state;
 }
 
-void CommandBufferProxyImpl::SetOnConsoleMessageCallback(
-    const GpuConsoleMessageCallback& callback) {
-  CheckLock();
-  console_message_callback_ = callback;
-}
-
 void CommandBufferProxyImpl::TryUpdateState() {
   if (last_state_.error == gpu::error::kNoError)
     shared_state()->Read(&last_state_);
 }
 
 void CommandBufferProxyImpl::UpdateVerifiedReleases(uint32_t verified_flush) {
   while (!flushed_release_flush_id_.empty()) {
     const std::pair<uint64_t, uint32_t>& front_item =
         flushed_release_flush_id_.front();
     if (front_item.second > verified_flush)
@@ skipping 45 matching lines @@
 }
 
 void CommandBufferProxyImpl::InvalidGpuReplyOnClientThread() {
   scoped_ptr<base::AutoLock> lock;
   if (lock_)
     lock.reset(new base::AutoLock(*lock_));
   OnDestroyed(gpu::error::kInvalidGpuMessage, gpu::error::kLostContext);
 }
 
 }  // namespace gpu