Added global order numbers to in process command buffers.

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 460 matching lines @@
   while (!sync_points_.empty())
     OnRetireSyncPoint(sync_points_.front());
 
   if (decoder_)
     decoder_->set_engine(NULL);
 
   // The scheduler has raw references to the decoder and the command buffer so
   // destroy it before those.
   scheduler_.reset();
 
+  sync_point_client_.reset();
+
   bool have_context = false;
   if (decoder_ && decoder_->GetGLContext()) {
     // Try to make the context current regardless of whether it was lost, so we
     // don't leak resources.
     have_context = decoder_->GetGLContext()->MakeCurrent(surface_.get());
   }
   FOR_EACH_OBSERVER(DestructionObserver,
                     destruction_observers_,
                     OnWillDestroyStub());
 
@@ skipping 23 matching lines @@
 
   scoped_ptr<base::SharedMemory> shared_state_shm(
       new base::SharedMemory(shared_state_handle, false));
 
   command_buffer_.reset(new gpu::CommandBufferService(
       context_group_->transfer_buffer_manager()));
 
   bool result = command_buffer_->Initialize();
   DCHECK(result);
 
+  GpuChannelManager* manager = channel_->gpu_channel_manager();
+  DCHECK(manager);
+
+  gpu::SyncPointManager* sync_point_manager = manager->sync_point_manager();
+  DCHECK(sync_point_manager);
+
   decoder_.reset(::gpu::gles2::GLES2Decoder::Create(context_group_.get()));
   scheduler_.reset(new gpu::GpuScheduler(command_buffer_.get(),
                                          decoder_.get(),
                                          decoder_.get()));
+  sync_point_client_ =
+      sync_point_manager->CreateSyncPointClient(
+          channel_->GetSyncPointClientState(),
+          gpu::CommandBufferNamespace::GPU_IO,
+          command_buffer_id_);
+
   if (preemption_flag_.get())
     scheduler_->SetPreemptByFlag(preemption_flag_);
 
   decoder_->set_engine(scheduler_.get());
 
   if (!handle_.is_null()) {
 #if defined(OS_MACOSX) || defined(UI_COMPOSITOR_IMAGE_TRANSPORT)
     if (software_) {
       LOG(ERROR) << "No software support.";
       OnInitializeFailed(reply_message);
       return;
     }
 #endif
 
     surface_ = ImageTransportSurface::CreateSurface(
         channel_->gpu_channel_manager(),
         this,
         handle_);
   } else {
-    GpuChannelManager* manager = channel_->gpu_channel_manager();
     surface_ = manager->GetDefaultOffscreenSurface();
   }
 
   if (!surface_.get()) {
     DLOG(ERROR) << "Failed to create surface.";
     OnInitializeFailed(reply_message);
     return;
   }
 
   scoped_refptr<gfx::GLContext> context;
@@ skipping 110 matching lines @@
       shared_state_shm.Pass(), kSharedStateSize));
 
   gpu::Capabilities capabilities = decoder_->GetCapabilities();
   capabilities.future_sync_points = channel_->allow_future_sync_points();
 
   GpuCommandBufferMsg_Initialize::WriteReplyParams(
       reply_message, true, capabilities);
   Send(reply_message);
 
   if (handle_.is_null() && !active_url_.is_empty()) {
-    GpuChannelManager* gpu_channel_manager = channel_->gpu_channel_manager();
-    gpu_channel_manager->Send(new GpuHostMsg_DidCreateOffscreenContext(
+    manager->Send(new GpuHostMsg_DidCreateOffscreenContext(
         active_url_));
   }
 
   initialized_ = true;
 }
 
 void GpuCommandBufferStub::OnCreateStreamTexture(
     uint32 texture_id, int32 stream_id, bool* succeeded) {
 #if defined(OS_ANDROID)
   *succeeded = StreamTexture::Create(this, texture_id, stream_id);
@@ skipping 519 matching lines @@
                                                     result));
 }
 
 void GpuCommandBufferStub::SendUpdateVSyncParameters(base::TimeTicks timebase,
                                                      base::TimeDelta interval) {
   Send(new GpuCommandBufferMsg_UpdateVSyncParameters(route_id_, timebase,
                                                      interval));
 }
 
 }  // namespace content