Make channel preemption not require view contexts for hookup

content/common/gpu/gpu_channel_manager.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 "content/common/gpu/gpu_channel_manager.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_memory_buffer_factory.h"
 #include "content/common/gpu/gpu_memory_manager.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/common/message_router.h"
+#include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/value_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_program_cache.h"
 #include "gpu/command_buffer/service/shader_translator_cache.h"
 #include "gpu/command_buffer/service/sync_point_manager.h"
 #include "ipc/message_filter.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_share_group.h"
@@ skipping 17 matching lines @@
     base::SingleThreadTaskRunner* task_runner,
     base::SingleThreadTaskRunner* io_task_runner,
     base::WaitableEvent* shutdown_event,
     gpu::SyncPointManager* sync_point_manager,
     GpuMemoryBufferFactory* gpu_memory_buffer_factory)
     : task_runner_(task_runner),
       io_task_runner_(io_task_runner),
       channel_(channel),
       watchdog_(watchdog),
       shutdown_event_(shutdown_event),
+      share_group_(new gfx::GLShareGroup),
+      mailbox_manager_(gpu::gles2::MailboxManager::Create()),
       gpu_memory_manager_(
           this,
           GpuMemoryManager::kDefaultMaxSurfacesWithFrontbufferSoftLimit),
       sync_point_manager_(sync_point_manager),
       gpu_memory_buffer_factory_(gpu_memory_buffer_factory),
       weak_factory_(this) {
   DCHECK(task_runner);
   DCHECK(io_task_runner);
+  const base::CommandLine* command_line =
+      base::CommandLine::ForCurrentProcess();
+  if (command_line->HasSwitch(switches::kUIPrioritizeInGpuProcess))
+    preemption_flag_ = new gpu::PreemptionFlag;
 }
 
 GpuChannelManager::~GpuChannelManager() {
   // Destroy channels before anything else because of dependencies.
   gpu_channels_.clear();
   if (default_offscreen_surface_.get()) {
     default_offscreen_surface_->Destroy();
     default_offscreen_surface_ = NULL;
   }
 }
@@ skipping 70 matching lines @@
     return OnControlMessageReceived(msg);
 
   return router_.RouteMessage(msg);
 }
 
 bool GpuChannelManager::Send(IPC::Message* msg) {
   return channel_->Send(msg);
 }
 
 scoped_ptr<GpuChannel> GpuChannelManager::CreateGpuChannel(
-    gfx::GLShareGroup* share_group,
-    gpu::gles2::MailboxManager* mailbox_manager,
     int client_id,
     uint64_t client_tracing_id,
+    bool preempts,
     bool allow_future_sync_points,
     bool allow_real_time_streams) {
-  return make_scoped_ptr(new GpuChannel(
-      this, watchdog_, share_group, mailbox_manager, task_runner_.get(),
-      io_task_runner_.get(), client_id, client_tracing_id, false,
-      allow_future_sync_points, allow_real_time_streams));
+  return make_scoped_ptr(
+      new GpuChannel(this, watchdog_, share_group(), mailbox_manager(),
+                     preempts ? preemption_flag() : nullptr, task_runner_.get(),
+                     io_task_runner_.get(), client_id, client_tracing_id,
+                     allow_future_sync_points, allow_real_time_streams));
 }
 
-void GpuChannelManager::OnEstablishChannel(int client_id,
-                                           uint64_t client_tracing_id,
-                                           bool share_context,
-                                           bool allow_future_sync_points,
-                                           bool allow_real_time_streams) {
-  gfx::GLShareGroup* share_group = nullptr;
-  gpu::gles2::MailboxManager* mailbox_manager = nullptr;
-  if (share_context) {
-    if (!share_group_.get()) {
-      share_group_ = new gfx::GLShareGroup;
-      DCHECK(!mailbox_manager_.get());
-      mailbox_manager_ = gpu::gles2::MailboxManager::Create();
-    }
-    share_group = share_group_.get();
-    mailbox_manager = mailbox_manager_.get();
-  }
-
-  scoped_ptr<GpuChannel> channel = CreateGpuChannel(
-      share_group, mailbox_manager, client_id, client_tracing_id,
-      allow_future_sync_points, allow_real_time_streams);
+void GpuChannelManager::OnEstablishChannel(
+    const GpuMsg_EstablishChannel_Params& params) {
+  DCHECK(!params.preempts || !params.preempted);

[no sievers, 2015/09/23 21:53:21]

nit: don't feel strongly at all, but you could also consider merging the two
bools into an enum describing the scheduling priority (UI vs. NORMAL or so) of
the channel.

[piman, 2015/09/23 23:33:37]

I'm expecting this to be superseded by the per-stream priorities, so I expect
this to be removed eventually. I didn't want to be too intrusive at the IPC
level by adding more complex enums (though in retrospect I'm not sure which is
better).

+  scoped_ptr<GpuChannel> channel(CreateGpuChannel(
+      params.client_id, params.client_tracing_id, params.preempts,
+      params.allow_future_sync_points, params.allow_real_time_streams));
+  if (params.preempted)
+    channel->SetPreemptByFlag(preemption_flag_.get());
   IPC::ChannelHandle channel_handle = channel->Init(shutdown_event_);
 
-  gpu_channels_.set(client_id, channel.Pass());
+  gpu_channels_.set(params.client_id, channel.Pass());
 
   Send(new GpuHostMsg_ChannelEstablished(channel_handle));
 }
 
 void GpuChannelManager::OnCloseChannel(
     const IPC::ChannelHandle& channel_handle) {
   for (auto it = gpu_channels_.begin(); it != gpu_channels_.end(); ++it) {
     if (it->second->channel_id() == channel_handle.name) {
       gpu_channels_.erase(it);
       return;
     }
   }
 }
 
 void GpuChannelManager::OnCreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
-    int32 surface_id,
     int32 client_id,
     const GPUCreateCommandBufferConfig& init_params,
     int32 route_id) {
-  DCHECK(surface_id);
   CreateCommandBufferResult result = CREATE_COMMAND_BUFFER_FAILED;
 
   auto it = gpu_channels_.find(client_id);
   if (it != gpu_channels_.end()) {
-    result = it->second->CreateViewCommandBuffer(window, surface_id,
-                                                 init_params, route_id);
+    result = it->second->CreateViewCommandBuffer(window, init_params, route_id);
   }
 
   Send(new GpuHostMsg_CommandBufferCreated(result));
 }
 
 void GpuChannelManager::DestroyGpuMemoryBuffer(
     gfx::GpuMemoryBufferId id,
     int client_id) {
   io_task_runner_->PostTask(
       FROM_HERE, base::Bind(&GpuChannelManager::DestroyGpuMemoryBufferOnIO,
@@ skipping 116 matching lines @@
     }
   }
   if (!stub || !stub->decoder()->MakeCurrent())
     return;
   glFinish();
   DidAccessGpu();
 }
 #endif
 
 }  // namespace content