[GPU] Get GPU process running on the mac...

chrome/plugin/command_buffer_stub.cc

 // Copyright (c) 2009 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/process_util.h"
 #include "base/shared_memory.h"
 #include "chrome/common/command_buffer_messages.h"
+#include "chrome/common/plugin_messages.h"
 #include "chrome/plugin/command_buffer_stub.h"
 #include "chrome/plugin/plugin_channel.h"
 
 using gpu::Buffer;
 
 CommandBufferStub::CommandBufferStub(PluginChannel* channel,
+                                     int plugin_host_route_id,
                                      gfx::PluginWindowHandle window)
     : channel_(channel),
+      plugin_host_route_id_(plugin_host_route_id),
       window_(window) {
   route_id_ = channel->GenerateRouteID();
   channel->AddRoute(route_id_, this, false);
 }
 
 CommandBufferStub::~CommandBufferStub() {
   channel_->RemoveRoute(route_id_);
 }
 
 void CommandBufferStub::OnChannelError() {
@@ skipping 25 matching lines @@
 
   // Initialize the CommandBufferService and GPUProcessor.
   if (command_buffer_->Initialize(size)) {
     Buffer buffer = command_buffer_->GetRingBuffer();
     if (buffer.shared_memory) {
       processor_ = new gpu::GPUProcessor(command_buffer_.get());
       if (processor_->Initialize(window_)) {
         command_buffer_->SetPutOffsetChangeCallback(
             NewCallback(processor_.get(),
                         &gpu::GPUProcessor::ProcessCommands));
+#if defined(OS_MACOSX)
+        processor_->SetSwapBuffersCallback(
+            NewCallback(this,
+                        &CommandBufferStub::SwapBuffersCallback));
+#endif
         buffer.shared_memory->ShareToProcess(peer_handle, ring_buffer);
       } else {
         processor_ = NULL;
         command_buffer_.reset();
       }
     }
   }
 
   base::CloseProcessHandle(peer_handle);
 }
@@ skipping 30 matching lines @@
 
   Buffer buffer = command_buffer_->GetTransferBuffer(id);
   if (buffer.shared_memory) {
     buffer.shared_memory->ShareToProcess(peer_handle, transfer_buffer);
     *size = buffer.shared_memory->max_size();
   }
 
   base::CloseProcessHandle(peer_handle);
 }
 
+#if defined(OS_MACOSX)
+void CommandBufferStub::OnSetWindowSize(int32 width, int32 height) {
+  uint64 new_backing_store = processor_->SetWindowSize(width, height);
+  if (new_backing_store) {
+    Send(new PluginHostMsg_GPUPluginSetIOSurface(plugin_host_route_id_,
+                                                 window_,
+                                                 width,
+                                                 height,
+                                                 new_backing_store));
+  }
+}
+
+void CommandBufferStub::SwapBuffersCallback() {
+  Send(new PluginHostMsg_GPUPluginBuffersSwapped(plugin_host_route_id_,
+                                                 window_));
+}
+#endif
+
 void CommandBufferStub::OnMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(CommandBufferStub, msg)
     IPC_MESSAGE_HANDLER(CommandBufferMsg_Initialize, OnInitialize);
     IPC_MESSAGE_HANDLER(CommandBufferMsg_GetState, OnGetState);
     IPC_MESSAGE_HANDLER(CommandBufferMsg_Flush, OnFlush);
     IPC_MESSAGE_HANDLER(CommandBufferMsg_CreateTransferBuffer,
                         OnCreateTransferBuffer);
     IPC_MESSAGE_HANDLER(CommandBufferMsg_DestroyTransferBuffer,
                         OnDestroyTransferBuffer);
     IPC_MESSAGE_HANDLER(CommandBufferMsg_GetTransferBuffer,
                         OnGetTransferBuffer);
+#if defined(OS_MACOSX)
+    IPC_MESSAGE_HANDLER(CommandBufferMsg_SetWindowSize, OnSetWindowSize);
+#endif
     IPC_MESSAGE_UNHANDLED_ERROR()
   IPC_END_MESSAGE_MAP()
 }