Make channel preemption not require view contexts for hookup

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/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 161 matching lines @@
 }
 
 }  // namespace
 
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     base::SingleThreadTaskRunner* task_runner,
     GpuCommandBufferStub* share_group,
     const gfx::GLSurfaceHandle& handle,
     gpu::gles2::MailboxManager* mailbox_manager,
+    gpu::PreemptionFlag* preempt_by_flag,
     gpu::gles2::SubscriptionRefSet* subscription_ref_set,
     gpu::ValueStateMap* pending_valuebuffer_state,
     const gfx::Size& size,
     const gpu::gles2::DisallowedFeatures& disallowed_features,
     const std::vector<int32>& attribs,
     gfx::GpuPreference gpu_preference,
     int32 stream_id,
     int32 route_id,
-    int32 surface_id,
+    bool offscreen,
     GpuWatchdog* watchdog,
-    bool software,
     const GURL& active_url)
     : channel_(channel),
       task_runner_(task_runner),
       initialized_(false),
       handle_(handle),
       initial_size_(size),
       disallowed_features_(disallowed_features),
       requested_attribs_(attribs),
       gpu_preference_(gpu_preference),
       use_virtualized_gl_context_(false),
       command_buffer_id_(GetCommandBufferID(channel->client_id(), route_id)),
       stream_id_(stream_id),
       route_id_(route_id),
-      surface_id_(surface_id),
-      software_(software),
+      offscreen_(offscreen),
       last_flush_count_(0),
       last_memory_allocation_valid_(false),
       watchdog_(watchdog),
       waiting_for_sync_point_(false),
       previous_processed_num_(0),
+      preemption_flag_(preempt_by_flag),
       active_url_(active_url),
       total_gpu_memory_(0) {
   active_url_hash_ = base::Hash(active_url.possibly_invalid_spec());
   FastSetActiveURL(active_url_, active_url_hash_);
 
   gpu::gles2::ContextCreationAttribHelper attrib_parser;
   attrib_parser.Parse(requested_attribs_);
 
   if (share_group) {
     context_group_ = share_group->context_group_;
@@ skipping 13 matching lines @@
 // performance regressions when enabling FCM.
 // http://crbug.com/180463
 #if defined(OS_MACOSX)
   if (gpu_preference_ == gfx::PreferIntegratedGpu)
     use_virtualized_gl_context_ = true;
 #endif
 
   use_virtualized_gl_context_ |=
       context_group_->feature_info()->UseVirtualizedGLContexts();
 
-  bool is_offscreen = surface_id_ == 0;
-  if (is_offscreen && initial_size_.IsEmpty()) {
+  if (offscreen && initial_size_.IsEmpty()) {
     // If we're an offscreen surface with zero width and/or height, set to a
     // non-zero size so that we have a complete framebuffer for operations like
     // glClear.
     initial_size_ = gfx::Size(1, 1);
   }
 }
 
 GpuCommandBufferStub::~GpuCommandBufferStub() {
   Destroy();
 }
@@ skipping 211 matching lines @@
     Send(wait_for_get_offset_->reply.release());
     wait_for_get_offset_.reset();
   }
 
   if (initialized_) {
     GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
     if (handle_.is_null() && !active_url_.is_empty()) {
       gpu_channel_manager->Send(
           new GpuHostMsg_DidDestroyOffscreenContext(active_url_));
     }
-    gpu_channel_manager->Send(
-        new GpuHostMsg_DestroyCommandBuffer(surface_id()));
   }
 
   memory_manager_client_state_.reset();
 
   while (!sync_points_.empty())
     OnRetireSyncPoint(sync_points_.front());
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
@@ skipping 61 matching lines @@
           channel_->GetSyncPointClientState(),
           gpu::CommandBufferNamespace::GPU_IO,
           command_buffer_id_);
 
   if (preemption_flag_.get())
     scheduler_->SetPreemptByFlag(preemption_flag_);
 
   decoder_->set_engine(scheduler_.get());
 
   if (!handle_.is_null()) {
-#if defined(OS_MACOSX) || defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
-    if (software_) {
-      LOG(ERROR) << "No software support.";
-      OnInitializeFailed(reply_message);
-      return;
-    }
-#endif
-
     surface_ = ImageTransportSurface::CreateSurface(
         channel_->gpu_channel_manager(),
         this,
         handle_);
   } else {
     surface_ = manager->GetDefaultOffscreenSurface();
   }
 
   if (!surface_.get()) {
     DLOG(ERROR) << "Failed to create surface.";
@@ skipping 56 matching lines @@
   if (!context->GetTotalGpuMemory(&total_gpu_memory_))
     total_gpu_memory_ = 0;
 
   if (!context_group_->has_program_cache() &&
       !context_group_->feature_info()->workarounds().disable_program_cache) {
     context_group_->set_program_cache(
         channel_->gpu_channel_manager()->program_cache());
   }
 
   // Initialize the decoder with either the view or pbuffer GLContext.
-  if (!decoder_->Initialize(surface_,
-                            context,
-                            !surface_id(),
-                            initial_size_,
-                            disallowed_features_,
-                            requested_attribs_)) {
+  if (!decoder_->Initialize(surface_, context, offscreen_, initial_size_,
+                            disallowed_features_, requested_attribs_)) {
     DLOG(ERROR) << "Failed to initialize decoder.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   if (base::CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableGPUServiceLogging)) {
     decoder_->set_log_commands(true);
   }
 
@@ skipping 376 matching lines @@
 }
 
 
 void GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback(
     bool has_callback) {
   TRACE_EVENT0(
       "gpu",
       "GpuCommandBufferStub::OnSetClientHasMemoryAllocationChangedCallback");
   if (has_callback) {
     if (!memory_manager_client_state_) {
-      memory_manager_client_state_.reset(GetMemoryManager()->CreateClientState(
-          this, surface_id_ != 0, true));
+      memory_manager_client_state_.reset(
+          GetMemoryManager()->CreateClientState(this, !offscreen_, true));
     }
   } else {
     memory_manager_client_state_.reset();
   }
 }
 
 void GpuCommandBufferStub::OnCreateImage(int32 id,
                                          gfx::GpuMemoryBufferHandle handle,
                                          gfx::Size size,
                                          gfx::BufferFormat format,
@@ skipping 72 matching lines @@
 void GpuCommandBufferStub::AddDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.AddObserver(observer);
 }
 
 void GpuCommandBufferStub::RemoveDestructionObserver(
     DestructionObserver* observer) {
   destruction_observers_.RemoveObserver(observer);
 }
 
-void GpuCommandBufferStub::SetPreemptByFlag(
-    scoped_refptr<gpu::PreemptionFlag> flag) {
-  preemption_flag_ = flag;
-  if (scheduler_)
-    scheduler_->SetPreemptByFlag(preemption_flag_);
-}
-
 bool GpuCommandBufferStub::GetTotalGpuMemory(uint64* bytes) {
   *bytes = total_gpu_memory_;
   return !!total_gpu_memory_;
 }
 
 gfx::Size GpuCommandBufferStub::GetSurfaceSize() const {
   if (!surface_.get())
     return gfx::Size();
   return surface_->GetSize();
 }
@@ skipping 81 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content