Remove unused features for in-process GL contexts.

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>
@@ skipping 191 matching lines @@
           gpu_preferences().gpu_program_cache_size,
           gpu_preferences().disable_gpu_shader_disk_cache));
   }
   return program_cache_.get();
 }
 
 InProcessCommandBuffer::InProcessCommandBuffer(
     const scoped_refptr<Service>& service)
     : command_buffer_id_(
           CommandBufferId::FromUnsafeValue(g_next_command_buffer_id.GetNext())),
-      context_lost_(false),
       delayed_work_pending_(false),
       image_factory_(nullptr),
       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),
       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 (!context_lost_ && decoder_->MakeCurrent())
-    return true;
-  DLOG(ERROR) << "Context lost because MakeCurrent failed.";
-  command_buffer_->SetContextLostReason(decoder_->GetContextLostReason());
-  command_buffer_->SetParseError(gpu::error::kLostContext);
-  return false;
+  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::PumpCommands() {
   CheckSequencedThread();
   command_buffer_lock_.AssertAcquired();
 
   if (!MakeCurrent())
     return;
 
   executor_->PutChanged();
@@ skipping 66 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::PumpCommands, gpu_thread_weak_ptr_));
-  command_buffer->SetParseErrorCallback(base::Bind(

[danakj, 2016/04/06 23:44:42]

Oops, gotta put this back too. :) Done.

-      &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 150 matching lines @@
   DCHECK(!sequence_checker_ ||
          sequence_checker_->CalledOnValidSequencedThread());
 }
 
 void InProcessCommandBuffer::OnContextLost() {
   CheckSequencedThread();
   if (!context_lost_callback_.is_null()) {
     context_lost_callback_.Run();
     context_lost_callback_.Reset();
   }
-
-  context_lost_ = true;
 }
 
 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 16 matching lines @@
 
   {
     ScopedOrderNumberProcessor scoped_order_num(sync_point_order_data_.get(),
                                                 order_num);
     command_buffer_->Flush(put_offset);
     {
       // Update state before signaling the flush event.
       base::AutoLock lock(state_after_last_flush_lock_);
       state_after_last_flush_ = command_buffer_->GetLastState();
     }
-    DCHECK((!error::IsError(state_after_last_flush_.error) && !context_lost_) ||
-           (error::IsError(state_after_last_flush_.error) && context_lost_));
 
     // Currently the in process command buffer does not support being
     // descheduled, if it does we would need to back off on calling the finish
     // processing number function until the message is rescheduled and finished
     // processing. This DCHECK is to enforce this.
-    DCHECK(context_lost_ || put_offset == state_after_last_flush_.get_offset);
+    DCHECK(error::IsError(state_after_last_flush_.error) ||
+           put_offset == state_after_last_flush_.get_offset);
   }
 
   // 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();
   }
 }
 
@@ skipping 354 matching lines @@
   DCHECK(query_manager_);
 
   gles2::QueryManager::Query* query = query_manager_->GetQuery(query_id);
   if (!query)
     callback.Run();
   else
     query->AddCallback(callback);
 }
 
 void InProcessCommandBuffer::SetLock(base::Lock*) {
+  // No support for using on multiple threads.
+  NOTREACHED();
 }
 
 bool InProcessCommandBuffer::IsGpuChannelLost() {
   // There is no such channel to lose for in-process contexts. This only
   // makes sense for out-of-process command buffers.
   return false;
 }
 
 void InProcessCommandBuffer::EnsureWorkVisible() {
   // This is only relevant for out-of-process command buffers.
@@ skipping 162 matching lines @@
     framebuffer_completeness_cache_ =
         new gpu::gles2::FramebufferCompletenessCache;
   return framebuffer_completeness_cache_;
 }
 
 SyncPointManager* GpuInProcessThread::sync_point_manager() {
   return sync_point_manager_;
 }
 
 }  // namespace gpu