Make channel preemption not require view contexts for hookup

content/common/gpu/gpu_channel.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.h"
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
@@ skipping 204 matching lines @@
   channel_messages_.push_back(msg.release());
   if (!had_messages)
     ScheduleHandleMessage();
 }
 
 GpuChannelMessageFilter::GpuChannelMessageFilter(
     const base::WeakPtr<GpuChannel>& gpu_channel,
     GpuChannelMessageQueue* message_queue,
     gpu::SyncPointManager* sync_point_manager,
     base::SingleThreadTaskRunner* task_runner,
+    gpu::PreemptionFlag* preempting_flag,
     bool future_sync_points)
     : preemption_state_(IDLE),
       gpu_channel_(gpu_channel),
       message_queue_(message_queue),
       sender_(nullptr),
       peer_pid_(base::kNullProcessId),
       sync_point_manager_(sync_point_manager),
       task_runner_(task_runner),
+      preempting_flag_(preempting_flag),
       a_stub_is_descheduled_(false),
       future_sync_points_(future_sync_points) {}
 
 GpuChannelMessageFilter::~GpuChannelMessageFilter() {}
 
 void GpuChannelMessageFilter::OnFilterAdded(IPC::Sender* sender) {
   DCHECK(!sender_);
   sender_ = sender;
   timer_ = make_scoped_ptr(new base::OneShotTimer<GpuChannelMessageFilter>);
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
@@ skipping 118 matching lines @@
   }
 
   UpdatePreemptionState();
   return handled;
 }
 
 void GpuChannelMessageFilter::OnMessageProcessed() {
   UpdatePreemptionState();
 }
 
-void GpuChannelMessageFilter::SetPreemptingFlagAndSchedulingState(
-    gpu::PreemptionFlag* preempting_flag,
-    bool a_stub_is_descheduled) {
-  preempting_flag_ = preempting_flag;
-  a_stub_is_descheduled_ = a_stub_is_descheduled;
-}
-
 void GpuChannelMessageFilter::UpdateStubSchedulingState(
     bool a_stub_is_descheduled) {
   a_stub_is_descheduled_ = a_stub_is_descheduled;
   UpdatePreemptionState();
 }
 
 bool GpuChannelMessageFilter::Send(IPC::Message* message) {
   return sender_->Send(message);
 }
 
@@ skipping 154 matching lines @@
 }
 
 bool GpuChannel::StreamState::HasRoutes() const {
   return !routes_.empty();
 }
 
 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
                        gpu::gles2::MailboxManager* mailbox,
+                       gpu::PreemptionFlag* preempting_flag,
                        base::SingleThreadTaskRunner* task_runner,
                        base::SingleThreadTaskRunner* io_task_runner,
                        int client_id,
                        uint64_t client_tracing_id,
-                       bool software,
                        bool allow_future_sync_points,
                        bool allow_real_time_streams)
     : gpu_channel_manager_(gpu_channel_manager),
       channel_id_(IPC::Channel::GenerateVerifiedChannelID("gpu")),
+      preempting_flag_(preempting_flag),
       client_id_(client_id),
       client_tracing_id_(client_tracing_id),
       task_runner_(task_runner),
       io_task_runner_(io_task_runner),
-      share_group_(share_group ? share_group : new gfx::GLShareGroup),
-      mailbox_manager_(mailbox
-                           ? scoped_refptr<gpu::gles2::MailboxManager>(mailbox)
-                           : gpu::gles2::MailboxManager::Create()),
+      share_group_(share_group),
+      mailbox_manager_(mailbox),
       subscription_ref_set_(new gpu::gles2::SubscriptionRefSet),
       pending_valuebuffer_state_(new gpu::ValueStateMap),
       watchdog_(watchdog),
-      software_(software),
       num_stubs_descheduled_(0),
       allow_future_sync_points_(allow_future_sync_points),
       allow_real_time_streams_(allow_real_time_streams),
       weak_factory_(this) {
   DCHECK(gpu_channel_manager);
   DCHECK(client_id);
 
   message_queue_ =
       GpuChannelMessageQueue::Create(weak_factory_.GetWeakPtr(), task_runner);
 
   filter_ = new GpuChannelMessageFilter(
       weak_factory_.GetWeakPtr(), message_queue_.get(),
       gpu_channel_manager_->sync_point_manager(), task_runner_.get(),
-      allow_future_sync_points_);
+      preempting_flag, allow_future_sync_points_);
 
   subscription_ref_set_->AddObserver(this);
 }
 
 GpuChannel::~GpuChannel() {
   // Clear stubs first because of dependencies.
   stubs_.clear();
 
   message_queue_->DeleteAndDisableMessages(gpu_channel_manager_);
 
@@ skipping 90 matching lines @@
       io_task_runner_->PostTask(
           FROM_HERE,
           base::Bind(&GpuChannelMessageFilter::UpdateStubSchedulingState,
                      filter_, a_stub_is_descheduled));
     }
   }
 }
 
 CreateCommandBufferResult GpuChannel::CreateViewCommandBuffer(
     const gfx::GLSurfaceHandle& window,
-    int32 surface_id,
     const GPUCreateCommandBufferConfig& init_params,
     int32 route_id) {
-  TRACE_EVENT1("gpu",
-               "GpuChannel::CreateViewCommandBuffer",
-               "surface_id",
-               surface_id);
+  TRACE_EVENT1("gpu", "GpuChannel::CreateViewCommandBuffer", "route_id",
+               route_id);
 
   int32 share_group_id = init_params.share_group_id;
   GpuCommandBufferStub* share_group = stubs_.get(share_group_id);
 
   if (!share_group && share_group_id != MSG_ROUTING_NONE)
     return CREATE_COMMAND_BUFFER_FAILED;
 
   int32 stream_id = init_params.stream_id;
   GpuStreamPriority stream_priority = init_params.stream_priority;
 
   if (share_group && stream_id != share_group->stream_id())
     return CREATE_COMMAND_BUFFER_FAILED;
 
   if (!allow_real_time_streams_ &&
       stream_priority == GpuStreamPriority::REAL_TIME)
     return CREATE_COMMAND_BUFFER_FAILED;
 
   auto stream_it = streams_.find(stream_id);
   if (stream_it != streams_.end() &&
       stream_priority != GpuStreamPriority::INHERIT &&
       stream_priority != stream_it->second.priority()) {
     return CREATE_COMMAND_BUFFER_FAILED;
   }
 
+  bool offscreen = false;
   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this, task_runner_.get(), share_group, window, mailbox_manager_.get(),
       subscription_ref_set_.get(), pending_valuebuffer_state_.get(),
       gfx::Size(), disallowed_features_, init_params.attribs,
-      init_params.gpu_preference, stream_id, route_id, surface_id, watchdog_,
-      software_, init_params.active_url));
+      init_params.gpu_preference, stream_id, route_id, offscreen, watchdog_,
+      init_params.active_url));
 
   if (preempted_flag_.get())
     stub->SetPreemptByFlag(preempted_flag_);

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

Can you remove this method from GpuCommandBufferStub and pass it in the
constructor instead, now that we don't need the deferred setup anymore?

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

Done.

 
   if (!router_.AddRoute(route_id, stub.get())) {
     DLOG(ERROR) << "GpuChannel::CreateViewCommandBuffer(): "
                    "failed to add route";
     return CREATE_COMMAND_BUFFER_FAILED_AND_CHANNEL_LOST;
   }
 
   if (stream_it != streams_.end()) {
     stream_it->second.AddRoute(route_id);
   } else {
@@ skipping 20 matching lines @@
 }
 
 bool GpuChannel::AddRoute(int32 route_id, IPC::Listener* listener) {
   return router_.AddRoute(route_id, listener);
 }
 
 void GpuChannel::RemoveRoute(int32 route_id) {
   router_.RemoveRoute(route_id);
 }
 
-gpu::PreemptionFlag* GpuChannel::GetPreemptionFlag() {
-  if (!preempting_flag_.get()) {
-    preempting_flag_ = new gpu::PreemptionFlag;
-    io_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(
-            &GpuChannelMessageFilter::SetPreemptingFlagAndSchedulingState,
-            filter_, preempting_flag_, num_stubs_descheduled_ > 0));
-  }
-  return preempting_flag_.get();
-}
-
 void GpuChannel::SetPreemptByFlag(
     scoped_refptr<gpu::PreemptionFlag> preempted_flag) {
+  DCHECK(stubs_.empty());
   preempted_flag_ = preempted_flag;
-
-  for (auto& kv : stubs_)
-    kv.second->SetPreemptByFlag(preempted_flag_);
 }
 
 void GpuChannel::OnDestroy() {
   TRACE_EVENT0("gpu", "GpuChannel::OnDestroy");
   gpu_channel_manager_->RemoveChannel(client_id_);
 }
 
 bool GpuChannel::OnControlMessageReceived(const IPC::Message& msg) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuChannel, msg)
@@ skipping 147 matching lines @@
   }
 
   auto stream_it = streams_.find(stream_id);
   if (stream_it != streams_.end() &&
       stream_priority != GpuStreamPriority::INHERIT &&
       stream_priority != stream_it->second.priority()) {
     *succeeded = false;
     return;
   }
 
+  bool offscreen = true;
   scoped_ptr<GpuCommandBufferStub> stub(new GpuCommandBufferStub(
       this, task_runner_.get(), share_group, gfx::GLSurfaceHandle(),
       mailbox_manager_.get(), subscription_ref_set_.get(),
       pending_valuebuffer_state_.get(), size, disallowed_features_,
       init_params.attribs, init_params.gpu_preference, init_params.stream_id,
-      route_id, 0, watchdog_, software_, init_params.active_url));
+      route_id, offscreen, watchdog_, init_params.active_url));
 
   if (preempted_flag_.get())
     stub->SetPreemptByFlag(preempted_flag_);
 
   if (!router_.AddRoute(route_id, stub.get())) {
     DLOG(ERROR) << "GpuChannel::OnCreateOffscreenCommandBuffer(): "
                    "failed to add route";
     *succeeded = false;
     return;
   }
@@ skipping 106 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content