Implemented new fence syncs which replaces the old sync points.

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 58 matching lines @@
 const int64 kStopPreemptThresholdMs = kVsyncIntervalMs;
 
 }  // anonymous namespace
 
 scoped_refptr<GpuChannelMessageQueue> GpuChannelMessageQueue::Create(
     const base::WeakPtr<GpuChannel>& gpu_channel,
     base::SingleThreadTaskRunner* task_runner) {
   return new GpuChannelMessageQueue(gpu_channel, task_runner);
 }
 
-scoped_refptr<gpu::SyncPointClientState>
-    GpuChannelMessageQueue::GetSyncPointClientState() {
-  return sync_point_client_state_;
+scoped_refptr<gpu::SyncPointOrderData>
+GpuChannelMessageQueue::GetSyncPointOrderData() {
+  return sync_point_order_data_;
 }
 
 GpuChannelMessageQueue::GpuChannelMessageQueue(
     const base::WeakPtr<GpuChannel>& gpu_channel,
     base::SingleThreadTaskRunner* task_runner)
     : enabled_(true),
-      sync_point_client_state_(gpu::SyncPointClientState::Create()),
+      sync_point_order_data_(gpu::SyncPointOrderData::Create()),
       gpu_channel_(gpu_channel),
       task_runner_(task_runner) {}
 
 GpuChannelMessageQueue::~GpuChannelMessageQueue() {
   DCHECK(channel_messages_.empty());
 }
 
 uint32_t GpuChannelMessageQueue::GetUnprocessedOrderNum() const {
-  return sync_point_client_state_->unprocessed_order_num();
+  return sync_point_order_data_->unprocessed_order_num();
 }
 
 uint32_t GpuChannelMessageQueue::GetProcessedOrderNum() const {
-  return sync_point_client_state_->processed_order_num();
+  return sync_point_order_data_->processed_order_num();
 }
 
 void GpuChannelMessageQueue::PushBackMessage(
     gpu::SyncPointManager* sync_point_manager, const IPC::Message& message) {
   base::AutoLock auto_lock(channel_messages_lock_);
   if (enabled_) {
     PushMessageHelper(sync_point_manager,
                       make_scoped_ptr(new GpuChannelMessage(message)));
   }
 }
@@ skipping 28 matching lines @@
   base::AutoLock auto_lock(channel_messages_lock_);
   if (!channel_messages_.empty())
     return channel_messages_.front()->time_received;
   return base::TimeTicks();
 }
 
 GpuChannelMessage* GpuChannelMessageQueue::GetNextMessage() const {
   base::AutoLock auto_lock(channel_messages_lock_);
   if (!channel_messages_.empty()) {
     DCHECK_GT(channel_messages_.front()->order_number,
-              sync_point_client_state_->processed_order_num());
+              sync_point_order_data_->processed_order_num());
     DCHECK_LE(channel_messages_.front()->order_number,
-              sync_point_client_state_->unprocessed_order_num());
+              sync_point_order_data_->unprocessed_order_num());
 
     return channel_messages_.front();
   }
   return nullptr;
 }
 
 void GpuChannelMessageQueue::BeginMessageProcessing(
     const GpuChannelMessage* msg) {
-  sync_point_client_state_->BeginProcessingOrderNumber(msg->order_number);
+  sync_point_order_data_->BeginProcessingOrderNumber(msg->order_number);
 }
 
 bool GpuChannelMessageQueue::MessageProcessed() {
   base::AutoLock auto_lock(channel_messages_lock_);
   DCHECK(!channel_messages_.empty());
   scoped_ptr<GpuChannelMessage> msg(channel_messages_.front());
   channel_messages_.pop_front();
-  sync_point_client_state_->FinishProcessingOrderNumber(msg->order_number);
+  sync_point_order_data_->FinishProcessingOrderNumber(msg->order_number);
   return !channel_messages_.empty();
 }
 
 void GpuChannelMessageQueue::DeleteAndDisableMessages(
     GpuChannelManager* gpu_channel_manager) {
   {
     base::AutoLock auto_lock(channel_messages_lock_);
     DCHECK(enabled_);
     enabled_ = false;
   }
 
   // We guarantee that the queues will no longer be modified after enabled_
   // is set to false, it is now safe to modify the queue without the lock.
   // All public facing modifying functions check enabled_ while all
   // private modifying functions DCHECK(enabled_) to enforce this.
   while (!channel_messages_.empty()) {
     scoped_ptr<GpuChannelMessage> msg(channel_messages_.front());
     channel_messages_.pop_front();
     // This needs to clean up both GpuCommandBufferMsg_InsertSyncPoint and
     // GpuCommandBufferMsg_RetireSyncPoint messages, safer to just check
     // if we have a sync point number here.
     if (msg->sync_point) {
       gpu_channel_manager->sync_point_manager()->RetireSyncPoint(
           msg->sync_point);
     }
   }
+
+  if (sync_point_order_data_) {
+    sync_point_order_data_->Destroy();
+    sync_point_order_data_ = nullptr;
+  }
 }
 
 void GpuChannelMessageQueue::ScheduleHandleMessage() {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&GpuChannel::HandleMessage, gpu_channel_));
 }
 
 void GpuChannelMessageQueue::PushMessageHelper(
     gpu::SyncPointManager* sync_point_manager,
     scoped_ptr<GpuChannelMessage> msg) {
   channel_messages_lock_.AssertAcquired();
   DCHECK(enabled_);
 
-  msg->order_number =
-      sync_point_client_state_->GenerateUnprocessedOrderNumber(
-          sync_point_manager);
+  msg->order_number = sync_point_order_data_->GenerateUnprocessedOrderNumber(
+      sync_point_manager);
   msg->time_received = base::TimeTicks::Now();
 
   bool had_messages = !channel_messages_.empty();
   channel_messages_.push_back(msg.release());
   if (!had_messages)
     ScheduleHandleMessage();
 }
 
 GpuChannelMessageFilter::GpuChannelMessageFilter(
     const base::WeakPtr<GpuChannel>& gpu_channel,
@@ skipping 72 matching lines @@
 }
 
 bool GpuChannelMessageFilter::OnMessageReceived(const IPC::Message& message) {
   DCHECK(sender_);
 
   if (message.should_unblock() || message.is_reply()) {
     DLOG(ERROR) << "Unexpected message type";
     return true;
   }
 
+  if (message.type() == GpuChannelMsg_Nop::ID) {
+    IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
+    Send(reply);
+    return true;
+  }
+
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     if (filter->OnMessageReceived(message)) {
       return true;
     }
   }
 
   bool handled = false;
   if ((message.type() == GpuCommandBufferMsg_RetireSyncPoint::ID) &&
       !future_sync_points_) {
     DLOG(ERROR) << "Untrusted client should not send "
@@ skipping 467 matching lines @@
     IPC_MESSAGE_HANDLER(GpuChannelMsg_DestroyCommandBuffer,
                         OnDestroyCommandBuffer)
     IPC_MESSAGE_HANDLER_DELAY_REPLY(GpuMsg_CreateJpegDecoder,
                                     OnCreateJpegDecoder)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   DCHECK(handled) << msg.type();
   return handled;
 }
 
-scoped_refptr<gpu::SyncPointClientState> GpuChannel::GetSyncPointClientState() {
-  return message_queue_->GetSyncPointClientState();
+scoped_refptr<gpu::SyncPointOrderData> GpuChannel::GetSyncPointOrderData() {
+  return message_queue_->GetSyncPointOrderData();
 }
 
 void GpuChannel::HandleMessage() {
   // If we have been preempted by another channel, just post a task to wake up.
   if (preempted_flag_ && preempted_flag_->IsSet()) {
     ScheduleHandleMessage();
     return;
   }
 
   GpuChannelMessage* m = message_queue_->GetNextMessage();
@@ skipping 254 matching lines @@
     }
   }
 }
 
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 }  // namespace content