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

gpu/command_buffer/service/in_process_command_buffer.cc

 // Copyright 2013 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/command_buffer/service/in_process_command_buffer.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 #include <set>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/lazy_instance.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/weak_ptr.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/sequence_checker.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.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/gpu_memory_buffer_support.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/command_buffer_service.h"
 #include "gpu/command_buffer/service/command_executor.h"
 #include "gpu/command_buffer/service/context_group.h"
 #include "gpu/command_buffer/service/gl_context_virtual.h"
 #include "gpu/command_buffer/service/gpu_preferences.h"
 #include "gpu/command_buffer/service/image_factory.h"
@@ skipping 170 matching lines @@
   }
   return program_cache_.get();
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : command_buffer_id_(
           CommandBufferId::FromUnsafeValue(g_next_command_buffer_id.GetNext())),
       delayed_work_pending_(false),
       image_factory_(nullptr),
-      gpu_control_client_(nullptr),
-#if DCHECK_IS_ON()
-      context_lost_(false),
-#endif
       last_put_offset_(-1),
       gpu_memory_buffer_manager_(nullptr),
       next_fence_sync_release_(1),
       flushed_fence_sync_release_(0),
       flush_event_(false, false),
       service_(GetInitialService(service)),
       fence_sync_wait_event_(false, false),
-      client_thread_weak_ptr_factory_(this),
       gpu_thread_weak_ptr_factory_(this) {
   DCHECK(service_.get());
   next_image_id_.GetNext();
 }
 
 InProcessCommandBuffer::~InProcessCommandBuffer() {
   Destroy();
 }
 
 bool InProcessCommandBuffer::MakeCurrent() {
   CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
 
   if (error::IsError(command_buffer_->GetLastState().error)) {
     DLOG(ERROR) << "MakeCurrent failed because context lost.";
     return false;
   }
   if (!decoder_->MakeCurrent()) {
     DLOG(ERROR) << "Context lost because MakeCurrent failed.";
     command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
     command_buffer_->SetParseError(gpu::error::kLostContext);
     return false;
   }
   return true;
 }
 
-void InProcessCommandBuffer::PumpCommandsOnGpuThread() {
+void InProcessCommandBuffer::PumpCommands() {
   CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
 
   if (!MakeCurrent())
     return;
 
   executor_->PutChanged();
 }
 
+bool InProcessCommandBuffer::GetBufferChanged(int32_t transfer_buffer_id) {
+  CheckSequencedThread();
+  command_buffer_lock_.AssertAcquired();
+  command_buffer_->SetGetBuffer(transfer_buffer_id);
+  return true;
+}
+
 bool InProcessCommandBuffer::Initialize(
     scoped_refptr<gfx::GLSurface> surface,
     bool is_offscreen,
     gfx::AcceleratedWidget window,
     const gfx::Size& size,
     const std::vector<int32_t>& attribs,
     gfx::GpuPreference gpu_preference,
+    const base::Closure& context_lost_callback,
     InProcessCommandBuffer* share_group,
     GpuMemoryBufferManager* gpu_memory_buffer_manager,
     ImageFactory* image_factory) {
   DCHECK(!share_group || service_.get() == share_group->service_.get());
+  context_lost_callback_ = WrapCallback(context_lost_callback);
 
-  if (surface) {
+  if (surface.get()) {
     // GPU thread must be the same as client thread due to GLSurface not being
     // thread safe.
     sequence_checker_.reset(new base::SequenceChecker);
     surface_ = surface;
-  } else {
-    origin_task_runner_ = base::ThreadTaskRunnerHandle::Get();
-    client_thread_weak_ptr_ = client_thread_weak_ptr_factory_.GetWeakPtr();
   }
 
   gpu::Capabilities capabilities;
   InitializeOnGpuThreadParams params(is_offscreen,
                                      window,
                                      size,
                                      attribs,
                                      gpu_preference,
                                      &capabilities,
                                      share_group,
@@ skipping 27 matching lines @@
 
   DCHECK(params.size.width() >= 0 && params.size.height() >= 0);
 
   TransferBufferManager* manager = new TransferBufferManager(nullptr);
   transfer_buffer_manager_ = manager;
   manager->Initialize();
 
   scoped_ptr<CommandBufferService> command_buffer(
       new CommandBufferService(transfer_buffer_manager_.get()));
   command_buffer->SetPutOffsetChangeCallback(base::Bind(
-      &InProcessCommandBuffer::PumpCommandsOnGpuThread, gpu_thread_weak_ptr_));
+      &InProcessCommandBuffer::PumpCommands, gpu_thread_weak_ptr_));
   command_buffer->SetParseErrorCallback(base::Bind(
-      &InProcessCommandBuffer::OnContextLostOnGpuThread, gpu_thread_weak_ptr_));
+      &InProcessCommandBuffer::OnContextLost, gpu_thread_weak_ptr_));
 
   if (!command_buffer->Initialize()) {
     LOG(ERROR) << "Could not initialize command buffer.";
     DestroyOnGpuThread();
     return false;
   }
 
   gl_share_group_ = params.context_group
                         ? params.context_group->gl_share_group_
                         : service_->share_group();
@@ skipping 104 matching lines @@
       base::Bind(&InProcessCommandBuffer::WaitFenceSyncOnGpuThread,
                  base::Unretained(this)));
 
   image_factory_ = params.image_factory;
 
   return true;
 }
 
 void InProcessCommandBuffer::Destroy() {
   CheckSequencedThread();
-  client_thread_weak_ptr_factory_.InvalidateWeakPtrs();
-  gpu_control_client_ = nullptr;
+
   base::WaitableEvent completion(true, false);
   bool result = false;
   base::Callback<bool(void)> destroy_task = base::Bind(
       &InProcessCommandBuffer::DestroyOnGpuThread, base::Unretained(this));
   QueueTask(
       base::Bind(&RunTaskWithResult<bool>, destroy_task, &result, &completion));
   completion.Wait();
 }
 
 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();
   }
-  context_ = nullptr;
-  surface_ = nullptr;
-  sync_point_client_ = nullptr;
+  context_ = NULL;
+  surface_ = NULL;
+  sync_point_client_ = NULL;
   if (sync_point_order_data_) {
     sync_point_order_data_->Destroy();
     sync_point_order_data_ = nullptr;
   }
-  gl_share_group_ = nullptr;
+  gl_share_group_ = NULL;
 #if defined(OS_ANDROID)
   stream_texture_manager_.reset();
 #endif
 
   return true;
 }
 
 void InProcessCommandBuffer::CheckSequencedThread() {
   DCHECK(!sequence_checker_ ||
          sequence_checker_->CalledOnValidSequencedThread());
 }
 
-void InProcessCommandBuffer::OnContextLostOnGpuThread() {
-  if (!origin_task_runner_)
-    return OnContextLost();  // Just kidding, we're on the client thread.
-  origin_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&InProcessCommandBuffer::OnContextLost,
-                            client_thread_weak_ptr_));
-}
-
 void InProcessCommandBuffer::OnContextLost() {
   CheckSequencedThread();
-
-#if DCHECK_IS_ON()
-  // This method shouldn't be called more than once.
-  DCHECK(!context_lost_);
-  context_lost_ = true;
-#endif
-
-  if (gpu_control_client_)
-    gpu_control_client_->OnGpuControlLostContext();
+  if (!context_lost_callback_.is_null()) {
+    context_lost_callback_.Run();
+    context_lost_callback_.Reset();
+  }
 }
 
 CommandBuffer::State InProcessCommandBuffer::GetStateFast() {
   CheckSequencedThread();
   base::AutoLock lock(state_after_last_flush_lock_);
   if (state_after_last_flush_.generation - last_state_.generation < 0x80000000U)
     last_state_ = state_after_last_flush_;
   return last_state_;
 }
 
@@ skipping 33 matching lines @@
   }
 
   // If we've processed all pending commands but still have pending queries,
   // pump idle work until the query is passed.
   if (put_offset == state_after_last_flush_.get_offset &&
       (executor_->HasMoreIdleWork() || executor_->HasPendingQueries())) {
     ScheduleDelayedWorkOnGpuThread();
   }
 }
 
-void InProcessCommandBuffer::PerformDelayedWorkOnGpuThread() {
+void InProcessCommandBuffer::PerformDelayedWork() {
   CheckSequencedThread();
   delayed_work_pending_ = false;
   base::AutoLock lock(command_buffer_lock_);
   if (MakeCurrent()) {
     executor_->PerformIdleWork();
     executor_->ProcessPendingQueries();
     if (executor_->HasMoreIdleWork() || executor_->HasPendingQueries()) {
       ScheduleDelayedWorkOnGpuThread();
     }
   }
 }
 
 void InProcessCommandBuffer::ScheduleDelayedWorkOnGpuThread() {
   CheckSequencedThread();
   if (delayed_work_pending_)
     return;
   delayed_work_pending_ = true;
-  service_->ScheduleDelayedWork(
-      base::Bind(&InProcessCommandBuffer::PerformDelayedWorkOnGpuThread,
-                 gpu_thread_weak_ptr_));
+  service_->ScheduleDelayedWork(base::Bind(
+      &InProcessCommandBuffer::PerformDelayedWork, gpu_thread_weak_ptr_));
 }
 
 void InProcessCommandBuffer::Flush(int32_t put_offset) {
   CheckSequencedThread();
   if (last_state_.error != gpu::error::kNoError)
     return;
 
   if (last_put_offset_ == put_offset)
     return;
 
@@ skipping 76 matching lines @@
                  id);
 
   QueueTask(task);
 }
 
 void InProcessCommandBuffer::DestroyTransferBufferOnGpuThread(int32_t id) {
   base::AutoLock lock(command_buffer_lock_);
   command_buffer_->DestroyTransferBuffer(id);
 }
 
-void InProcessCommandBuffer::SetGpuControlClient(GpuControlClient* client) {
-  gpu_control_client_ = client;
-}
-
 gpu::Capabilities InProcessCommandBuffer::GetCapabilities() {
   return capabilities_;
 }
 
 int32_t InProcessCommandBuffer::CreateImage(ClientBuffer buffer,
                                             size_t width,
                                             size_t height,
                                             unsigned internalformat) {
   CheckSequencedThread();
 
@@ skipping 412 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu