Add OrderingBarrierCHROMIUM API.

content/common/gpu/client/gpu_channel_host.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/client/gpu_channel_host.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop.h"
@@ skipping 12 matching lines @@
 
 using base::AutoLock;
 using base::MessageLoopProxy;
 
 namespace content {
 
 GpuListenerInfo::GpuListenerInfo() {}
 
 GpuListenerInfo::~GpuListenerInfo() {}
 
+ProxyFlushInfo::ProxyFlushInfo()
+    : flush_pending(false),
+      route_id(MSG_ROUTING_NONE),
+      put_offset(0),
+      flush_count(0) {
+}
+
+ProxyFlushInfo::~ProxyFlushInfo() {
+}
+
 // static
 scoped_refptr<GpuChannelHost> GpuChannelHost::Create(
     GpuChannelHostFactory* factory,
     const gpu::GPUInfo& gpu_info,
     const IPC::ChannelHandle& channel_handle,
     base::WaitableEvent* shutdown_event,
     gpu::GpuMemoryBufferManager* gpu_memory_buffer_manager) {
   DCHECK(factory->IsMainThread());
   scoped_refptr<GpuChannelHost> host =
       new GpuChannelHost(factory, gpu_info, gpu_memory_buffer_manager);
@@ skipping 62 matching lines @@
   } else if (base::MessageLoop::current()) {
     bool result = sync_filter_->Send(message.release());
     if (!result)
       DVLOG(1) << "GpuChannelHost::Send failed: SyncMessageFilter::Send failed";
     return result;
   }
 
   return false;
 }
 
+void GpuChannelHost::OrderingBarrier(
+    int route_id,
+    int32 put_offset,
+    unsigned int flush_count,
+    const std::vector<ui::LatencyInfo>& latency_info,
+    bool put_offset_changed,
+    bool do_flush) {
+  AutoLock lock(context_lock_);
+  if (flush_info_.flush_pending && flush_info_.route_id != route_id)
+    InternalFlush();
+
+  if (put_offset_changed) {
+    flush_info_.flush_pending = true;
+    flush_info_.route_id = route_id;
+    flush_info_.put_offset = put_offset;
+    flush_info_.flush_count = flush_count;
+    flush_info_.latency_info.insert(flush_info_.latency_info.end(),
+                                    latency_info.begin(), latency_info.end());
+
+    if (do_flush)
+      InternalFlush();
+  }
+}
+
+void GpuChannelHost::InternalFlush() {
+  DCHECK(flush_info_.flush_pending);
+  Send(new GpuCommandBufferMsg_AsyncFlush(
+      flush_info_.route_id, flush_info_.put_offset, flush_info_.flush_count,
+      flush_info_.latency_info));
+  flush_info_.latency_info.clear();
+  flush_info_.flush_pending = false;
+}
+
 CommandBufferProxyImpl* GpuChannelHost::CreateViewCommandBuffer(
     int32 surface_id,
     CommandBufferProxyImpl* share_group,
     const std::vector<int32>& attribs,
     const GURL& active_url,
     gfx::GpuPreference gpu_preference) {
   TRACE_EVENT1("gpu",
                "GpuChannelHost::CreateViewCommandBuffer",
                "surface_id",
                surface_id);
@@ skipping 46 matching lines @@
   TRACE_EVENT0("gpu", "GpuChannelHost::CreateOffscreenCommandBuffer");
 
   GPUCreateCommandBufferConfig init_params;
   init_params.share_group_id =
       share_group ? share_group->GetRouteID() : MSG_ROUTING_NONE;
   init_params.attribs = attribs;
   init_params.active_url = active_url;
   init_params.gpu_preference = gpu_preference;
   int32 route_id = GenerateRouteID();
   bool succeeded = false;
-  if (!Send(new GpuChannelMsg_CreateOffscreenCommandBuffer(size,
-                                                           init_params,
-                                                           route_id,
-                                                           &succeeded))) {
+  if (!Send(new GpuChannelMsg_CreateOffscreenCommandBuffer(
+          size, init_params, route_id, &succeeded))) {
     LOG(ERROR) << "Failed to send GpuChannelMsg_CreateOffscreenCommandBuffer.";
     return NULL;
   }
 
   if (!succeeded) {
     LOG(ERROR)
         << "GpuChannelMsg_CreateOffscreenCommandBuffer returned failure.";
     return NULL;
   }
 
@@ skipping 27 matching lines @@
 void GpuChannelHost::DestroyCommandBuffer(
     CommandBufferProxyImpl* command_buffer) {
   TRACE_EVENT0("gpu", "GpuChannelHost::DestroyCommandBuffer");
 
   int route_id = command_buffer->GetRouteID();
   Send(new GpuChannelMsg_DestroyCommandBuffer(route_id));
   RemoveRoute(route_id);
 
   AutoLock lock(context_lock_);
   proxies_.erase(route_id);
+  if (flush_info_.flush_pending && flush_info_.route_id == route_id)
+    flush_info_.flush_pending = false;
+
   delete command_buffer;
 }
 
 void GpuChannelHost::DestroyChannel() {
   // channel_ must be destroyed on the main thread.
   if (channel_.get() && !factory_->IsMainThread())
     factory_->GetMainLoop()->DeleteSoon(FROM_HERE, channel_.release());
   channel_.reset();
 }
 
@@ skipping 144 matching lines @@
 
   listeners_.clear();
 }
 
 bool GpuChannelHost::MessageFilter::IsLost() const {
   AutoLock lock(lock_);
   return lost_;
 }
 
 }  // namespace content