Share SyncPointManager between ipc and in-process

content/common/gpu/gpu_command_buffer_stub.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 "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/hash.h"
 #include "base/json/json_writer.h"
 #include "base/memory/shared_memory.h"
@@ skipping 125 matching lines @@
   scoped_ptr<base::DictionaryValue> res(new base::DictionaryValue);
   res->SetInteger("renderer_pid", channel->renderer_pid());
   res->SetDouble("used_bytes", channel->GetMemoryUsage());
   res->SetDouble("limit_bytes",
                  channel->gpu_channel_manager()
                      ->gpu_memory_manager()
                      ->GetMaximumClientAllocation());
   return new DevToolsChannelData(res.release());
 }
 
+void RunOnThread(scoped_refptr<base::SingleThreadTaskRunner> task_runner,
+                 const base::Closure& callback) {
+  if (task_runner->BelongsToCurrentThread()) {
+    callback.Run();
+  } else {
+    task_runner->PostTask(FROM_HERE, callback);
+  }
+}
+
 }  // namespace
 
 GpuCommandBufferStub::GpuCommandBufferStub(
     GpuChannel* channel,
     GpuCommandBufferStub* share_group,
     const gfx::GLSurfaceHandle& handle,
     gpu::gles2::MailboxManager* mailbox_manager,
     gpu::gles2::SubscriptionRefSet* subscription_ref_set,
     gpu::ValueStateMap* pending_valuebuffer_state,
     const gfx::Size& size,
@@ skipping 733 matching lines @@
     return true;
   }
 
   if (sync_point_wait_count_ == 0) {
     TRACE_EVENT_ASYNC_BEGIN1("gpu", "WaitSyncPoint", this,
                              "GpuCommandBufferStub", this);
   }
   scheduler_->SetScheduled(false);
   ++sync_point_wait_count_;
   manager->sync_point_manager()->AddSyncPointCallback(
-      sync_point, base::Bind(&GpuCommandBufferStub::OnWaitSyncPointCompleted,
-                             this->AsWeakPtr(), sync_point));
+      sync_point,
+      base::Bind(&RunOnThread, base::ThreadTaskRunnerHandle::Get(),
+                 base::Bind(&GpuCommandBufferStub::OnWaitSyncPointCompleted,
+                            this->AsWeakPtr(), sync_point)));
   return scheduler_->IsScheduled();
 }
 
 void GpuCommandBufferStub::OnWaitSyncPointCompleted(uint32 sync_point) {
   PullTextureUpdates(sync_point);
   --sync_point_wait_count_;
   if (sync_point_wait_count_ == 0) {
     TRACE_EVENT_ASYNC_END1("gpu", "WaitSyncPoint", this,
                            "GpuCommandBufferStub", this);
   }
   scheduler_->SetScheduled(true);
 }
 
 void GpuCommandBufferStub::PullTextureUpdates(uint32 sync_point) {
   gpu::gles2::MailboxManager* mailbox_manager =
       context_group_->mailbox_manager();
   if (mailbox_manager->UsesSync() && MakeCurrent())
     mailbox_manager->PullTextureUpdates(sync_point);
 }
 
 void GpuCommandBufferStub::OnSignalSyncPoint(uint32 sync_point, uint32 id) {
   GpuChannelManager* manager = channel_->gpu_channel_manager();
   manager->sync_point_manager()->AddSyncPointCallback(
       sync_point,
-      base::Bind(&GpuCommandBufferStub::OnSignalSyncPointAck,
-                 this->AsWeakPtr(),
-                 id));
+      base::Bind(&RunOnThread, base::ThreadTaskRunnerHandle::Get(),
+                 base::Bind(&GpuCommandBufferStub::OnSignalSyncPointAck,
+                            this->AsWeakPtr(), id)));
 }
 
 void GpuCommandBufferStub::OnSignalSyncPointAck(uint32 id) {
   Send(new GpuCommandBufferMsg_SignalSyncPointAck(route_id_, id));
 }
 
 void GpuCommandBufferStub::OnSignalQuery(uint32 query_id, uint32 id) {
   if (decoder_) {
     gpu::gles2::QueryManager* query_manager = decoder_->GetQueryManager();
     if (query_manager) {
@@ skipping 211 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content