gpu: Remove gpu channel filter and queue from header.

gpu/ipc/service/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 "gpu/ipc/service/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 54 matching lines @@
 // below this threshold.
 const int64_t kStopPreemptThresholdMs = kVsyncIntervalMs;
 
 CommandBufferId GenerateCommandBufferId(int channel_id, int32_t route_id) {
   return CommandBufferId::FromUnsafeValue(
       (static_cast<uint64_t>(channel_id) << 32) | route_id);
 }
 
 }  // anonymous namespace
 
+struct GpuChannelMessage {
+  IPC::Message message;
+  uint32_t order_number;
+  base::TimeTicks time_received;
+
+  GpuChannelMessage(const IPC::Message& msg,
+                    uint32_t order_num,
+                    base::TimeTicks ts)
+      : message(msg), order_number(order_num), time_received(ts) {}
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(GpuChannelMessage);
+};
+
+// This message queue counts and timestamps each message forwarded to the
+// channel so that we can preempt other channels if a message takes too long to
+// process. To guarantee fairness, we must wait a minimum amount of time before
+// preempting and we limit the amount of time that we can preempt in one shot
+// (see constants above).
+class GpuChannelMessageQueue
+    : public base::RefCountedThreadSafe<GpuChannelMessageQueue> {
+ public:
+  GpuChannelMessageQueue(
+      GpuChannel* channel,
+      scoped_refptr<SyncPointOrderData> sync_point_order_data,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+      scoped_refptr<base::SingleThreadTaskRunner> io_task_runner,
+      scoped_refptr<PreemptionFlag> preempting_flag,
+      scoped_refptr<PreemptionFlag> preempted_flag);
+
+  void Destroy();
+
+  SequenceId sequence_id() const {
+    return sync_point_order_data_->sequence_id();
+  }
+
+  bool IsScheduled() const;
+  void SetScheduled(bool scheduled);
+
+  // Should be called before a message begins to be processed. Returns false if
+  // there are no messages to process.
+  const GpuChannelMessage* BeginMessageProcessing();
+  // Should be called if a message began processing but did not finish.
+  void PauseMessageProcessing();
+  // Should be called if a message is completely processed. Returns true if
+  // there are more messages to process.
+  void FinishMessageProcessing();
+
+  void PushBackMessage(const IPC::Message& message);
+
+ private:
+  enum PreemptionState {
+    // Either there's no other channel to preempt, there are no messages
+    // pending processing, or we just finished preempting and have to wait
+    // before preempting again.
+    IDLE,
+    // We are waiting kPreemptWaitTimeMs before checking if we should preempt.
+    WAITING,
+    // We can preempt whenever any IPC processing takes more than
+    // kPreemptWaitTimeMs.
+    CHECKING,
+    // We are currently preempting (i.e. no stub is descheduled).
+    PREEMPTING,
+    // We would like to preempt, but some stub is descheduled.
+    WOULD_PREEMPT_DESCHEDULED,
+  };
+
+  friend class base::RefCountedThreadSafe<GpuChannelMessageQueue>;
+
+  ~GpuChannelMessageQueue();
+
+  void PostHandleMessageOnQueue();
+
+  void UpdatePreemptionState();
+  void UpdatePreemptionStateHelper();
+
+  void UpdateStateIdle();
+  void UpdateStateWaiting();
+  void UpdateStateChecking();
+  void UpdateStatePreempting();
+  void UpdateStateWouldPreemptDescheduled();
+
+  void TransitionToIdle();
+  void TransitionToWaiting();
+  void TransitionToChecking();
+  void TransitionToPreempting();
+  void TransitionToWouldPreemptDescheduled();
+
+  bool ShouldTransitionToIdle() const;
+
+  // These can be accessed from both IO and main threads and are protected by
+  // |channel_lock_|.
+  bool scheduled_ = true;
+  GpuChannel* channel_ = nullptr;  // set to nullptr on Destroy
+  std::deque<std::unique_ptr<GpuChannelMessage>> channel_messages_;
+  bool handle_message_post_task_pending_ = false;
+  mutable base::Lock channel_lock_;
+
+  // The following are accessed on the IO thread only.
+  // No lock is necessary for preemption state because it's only accessed on the
+  // IO thread.
+  PreemptionState preemption_state_ = IDLE;
+  // Maximum amount of time that we can spend in PREEMPTING.
+  // It is reset when we transition to IDLE.
+  base::TimeDelta max_preemption_time_;
+  // This timer is used and runs tasks on the IO thread.
+  std::unique_ptr<base::OneShotTimer> timer_;
+  base::ThreadChecker io_thread_checker_;
+
+  // Keeps track of sync point related state such as message order numbers.
+  scoped_refptr<SyncPointOrderData> sync_point_order_data_;
+
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+  scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
+  scoped_refptr<PreemptionFlag> preempting_flag_;
+  scoped_refptr<PreemptionFlag> preempted_flag_;
+
+  DISALLOW_COPY_AND_ASSIGN(GpuChannelMessageQueue);
+};
+
+// This filter does the following:
+// - handles the Nop message used for verifying sync tokens on the IO thread
+// - forwards messages to child message filters
+// - posts control and out of order messages to the main thread
+// - forwards other messages to the message queue or the scheduler
+class GPU_EXPORT GpuChannelMessageFilter : public IPC::MessageFilter {
+ public:
+  GpuChannelMessageFilter(
+      GpuChannel* gpu_channel,
+      Scheduler* scheduler,
+      scoped_refptr<GpuChannelMessageQueue> message_queue,
+      scoped_refptr<base::SingleThreadTaskRunner> main_task_runner);
+
+  // Methods called on main thread.
+  void Destroy();
+
+  // Called when scheduler is enabled.
+  void AddRoute(int32_t route_id, SequenceId sequence_id);
+  void RemoveRoute(int32_t route_id);
+
+  // Methods called on IO thread.
+  // IPC::MessageFilter implementation.
+  void OnFilterAdded(IPC::Channel* channel) override;
+  void OnFilterRemoved() override;
+  void OnChannelConnected(int32_t peer_pid) override;
+  void OnChannelError() override;
+  void OnChannelClosing() override;
+  bool OnMessageReceived(const IPC::Message& message) override;
+
+  void AddChannelFilter(scoped_refptr<IPC::MessageFilter> filter);
+  void RemoveChannelFilter(scoped_refptr<IPC::MessageFilter> filter);
+
+ private:
+  ~GpuChannelMessageFilter() override;
+
+  bool MessageErrorHandler(const IPC::Message& message, const char* error_msg);
+
+  IPC::Channel* ipc_channel_ = nullptr;
+  base::ProcessId peer_pid_ = base::kNullProcessId;
+  std::vector<scoped_refptr<IPC::MessageFilter>> channel_filters_;
+
+  GpuChannel* gpu_channel_ = nullptr;
+  // Map of route id to scheduler sequence id.
+  base::flat_map<int32_t, SequenceId> route_sequences_;
+  mutable base::Lock gpu_channel_lock_;
+
+  Scheduler* scheduler_;
+  scoped_refptr<GpuChannelMessageQueue> message_queue_;
+  scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
+
+  DISALLOW_COPY_AND_ASSIGN(GpuChannelMessageFilter);
+};
+
 SyncChannelFilteredSender::SyncChannelFilteredSender(
     IPC::ChannelHandle channel_handle,
     IPC::Listener* listener,
     scoped_refptr<base::SingleThreadTaskRunner> ipc_task_runner,
     base::WaitableEvent* shutdown_event)
     : channel_(IPC::SyncChannel::Create(channel_handle,
                                         IPC::Channel::MODE_SERVER,
                                         listener,
                                         ipc_task_runner,
                                         false,
@@ skipping 423 matching lines @@
   DCHECK(ipc_channel_);
 
   if (!gpu_channel_)
     return MessageErrorHandler(message, "Channel destroyed");
 
   if (message.should_unblock() || message.is_reply())
     return MessageErrorHandler(message, "Unexpected message type");
 
   if (message.type() == GpuChannelMsg_Nop::ID) {
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
-    Send(reply);
+    ipc_channel_->Send(reply);
     return true;
   }
 
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     if (filter->OnMessageReceived(message))
       return true;
   }
 
   base::AutoLock auto_lock(gpu_channel_lock_);
   if (!gpu_channel_)
@@ skipping 25 matching lines @@
                                             gpu_channel_->AsWeakPtr(), message),
                              sync_token_fences);
   } else {
     // Message queue takes care of PostTask.
     message_queue_->PushBackMessage(message);
   }
 
   return true;
 }
 
-bool GpuChannelMessageFilter::Send(IPC::Message* message) {
-  return ipc_channel_->Send(message);
-}
-
 bool GpuChannelMessageFilter::MessageErrorHandler(const IPC::Message& message,
                                                   const char* error_msg) {
   DLOG(ERROR) << error_msg;
   if (message.is_sync()) {
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     reply->set_reply_error();
-    Send(reply);
+    ipc_channel_->Send(reply);
   }
   return true;
 }
 
 // Definitions for constructor and destructor of this interface are needed to
 // avoid MSVC LNK2019.
 FilteredSender::FilteredSender() = default;
 
 FilteredSender::~FilteredSender() = default;
 
@@ skipping 206 matching lines @@
   if (stub && (stub->HasUnprocessedCommands() || !stub->IsScheduled())) {
     DCHECK((uint32_t)GpuCommandBufferMsg_AsyncFlush::ID == msg.type() ||
            (uint32_t)GpuCommandBufferMsg_WaitSyncToken::ID == msg.type());
     DCHECK_EQ(stub->IsScheduled(), message_queue_->IsScheduled());
     message_queue_->PauseMessageProcessing();
   } else {
     message_queue_->FinishMessageProcessing();
   }
 }
 
+void GpuChannel::HandleMessageForTesting(const IPC::Message& msg) {
+  // Message filter gets message first on IO thread.
+  filter_->OnMessageReceived(msg);
+}
+
 void GpuChannel::HandleMessageHelper(const IPC::Message& msg) {
   int32_t routing_id = msg.routing_id();
 
   bool handled = false;
   if (routing_id == MSG_ROUTING_CONTROL) {
     handled = OnControlMessageReceived(msg);
   } else {
     handled = router_.RouteMessage(msg);
   }
 
@@ skipping 206 matching lines @@
 
       return manager->gpu_memory_buffer_factory()
           ->AsImageFactory()
           ->CreateImageForGpuMemoryBuffer(handle, size, format, internalformat,
                                           client_id_, surface_handle);
     }
   }
 }
 
 }  // namespace gpu