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 575 matching lines @@
 }
 
 bool GpuChannel::StreamState::HasRoute(int32 route_id) const {
   return routes_.find(route_id) != routes_.end();
 }
 
 bool GpuChannel::StreamState::HasRoutes() const {
   return !routes_.empty();
 }
 
+GpuChannel::OrderCallback::OrderCallback(uint32_t order_num,
+                                         const base::Closure& callback)
+    : order_number(order_num), callback_closure(callback) {}
+
+GpuChannel::OrderCallback::~OrderCallback() {}
+
 GpuChannel::GpuChannel(GpuChannelManager* gpu_channel_manager,
                        GpuWatchdog* watchdog,
                        gfx::GLShareGroup* share_group,
                        gpu::gles2::MailboxManager* mailbox,
                        base::SingleThreadTaskRunner* task_runner,
                        base::SingleThreadTaskRunner* io_task_runner,
                        int client_id,
                        uint64_t client_tracing_id,
                        bool software,
                        bool allow_future_sync_points,
@@ skipping 99 matching lines @@
 void GpuChannel::OnAddSubscription(unsigned int target) {
   gpu_channel_manager()->Send(
       new GpuHostMsg_AddSubscription(client_id_, target));
 }
 
 void GpuChannel::OnRemoveSubscription(unsigned int target) {
   gpu_channel_manager()->Send(
       new GpuHostMsg_RemoveSubscription(client_id_, target));
 }
 
+void GpuChannel::AddProcessedOrderNumberCallback(
+    uint32_t order_number,
+    const base::Closure& callback) {
+  processed_order_callbacks_.push(OrderCallback(order_number, callback));
+}
+
 void GpuChannel::StubSchedulingChanged(bool scheduled) {
   bool a_stub_was_descheduled = num_stubs_descheduled_ > 0;
   if (scheduled) {
     num_stubs_descheduled_--;
     message_queue_->ScheduleHandleMessage();
   } else {
     num_stubs_descheduled_++;
   }
   DCHECK_LE(num_stubs_descheduled_, stubs_.size());
   bool a_stub_is_descheduled = num_stubs_descheduled_ > 0;
@@ skipping 351 matching lines @@
     jpeg_decoder_.reset(new GpuJpegDecodeAccelerator(this, io_task_runner_));
   }
   jpeg_decoder_->AddClient(route_id, reply_msg);
 }
 
 void GpuChannel::MessageProcessed(uint32_t order_number) {
   if (order_number != kOutOfOrderNumber) {
     DCHECK(current_order_num_ == order_number);
     DCHECK(processed_order_num_ < order_number);
     processed_order_num_ = order_number;
+
+    while (!processed_order_callbacks_.empty() &&
+           processed_order_callbacks_.top().order_number <= order_number) {
+      processed_order_callbacks_.top().callback_closure.Run();
+      processed_order_callbacks_.pop();
+    }
   }
   if (preempting_flag_.get()) {
     io_task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&GpuChannelMessageFilter::OnMessageProcessed, filter_));
   }
 }
 
 void GpuChannel::CacheShader(const std::string& key,
                              const std::string& shader) {
@@ skipping 62 matching lines @@
 void GpuChannel::HandleUpdateValueState(
     unsigned int target, const gpu::ValueState& state) {
   pending_valuebuffer_state_->UpdateState(target, state);
 }
 
 uint32_t GpuChannel::GetUnprocessedOrderNum() const {
   return message_queue_->GetUnprocessedOrderNum();
 }
 
 }  // namespace content