linux (and some posix): multiprocess plugins compiling.

chrome/plugin/webplugin_delegate_stub.cc

 // Copyright (c) 2006-2008 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 "chrome/plugin/webplugin_delegate_stub.h"
 
+#include "build/build_config.h"
+
 #include "base/command_line.h"
 #include "chrome/common/chrome_switches.h"
-#include "chrome/common/gfx/emf.h"
 #include "chrome/common/plugin_messages.h"
-#include "chrome/common/win_util.h"
 #include "chrome/plugin/npobject_stub.h"
 #include "chrome/plugin/plugin_channel.h"
 #include "chrome/plugin/plugin_thread.h"
 #include "chrome/plugin/webplugin_proxy.h"
 #include "third_party/npapi/bindings/npapi.h"
 #include "third_party/npapi/bindings/npruntime.h"
 #include "skia/ext/platform_device.h"
 #include "webkit/glue/webcursor.h"
 #include "webkit/glue/webplugin_delegate.h"
 
+#if defined(OS_WIN)
+#include "chrome/common/gfx/emf.h"
+#include "chrome/common/win_util.h"
+#endif
+
 class FinishDestructionTask : public Task {
  public:
   FinishDestructionTask(WebPluginDelegate* delegate, WebPlugin* webplugin)
     : delegate_(delegate), webplugin_(webplugin) { }
 
   void Run() {
     // WebPlugin must outlive WebPluginDelegate.
     if (delegate_)
       delegate_->PluginDestroyed();
 
@@ skipping 85 matching lines @@
   }
 
   char **argn = new char*[argc];
   char **argv = new char*[argc];
   for (int i = 0; i < argc; ++i) {
     argn[i] = const_cast<char*>(params.arg_names[i].c_str());
     argv[i] = const_cast<char*>(params.arg_values[i].c_str());
   }
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
-  FilePath path =
-      FilePath(command_line.GetSwitchValue(switches::kPluginPath));
+  FilePath path = FilePath::FromWStringHack(
+      command_line.GetSwitchValue(switches::kPluginPath));
   delegate_ = WebPluginDelegate::Create(
       path, mime_type_, gfx::NativeViewFromId(params.containing_window));
   if (delegate_) {
     webplugin_ = new WebPluginProxy(channel_, instance_id_, delegate_);
 #if defined(OS_WIN)
     webplugin_->SetModalDialogEvent(params.modal_dialog_event);
 #endif
     *result = delegate_->Initialize(
         params.url, argn, argv, argc, webplugin_, params.load_manually);
   }
@@ skipping 69 matching lines @@
 void WebPluginDelegateStub::OnPaint(const gfx::Rect& damaged_rect) {
   webplugin_->Paint(damaged_rect);
 }
 
 void WebPluginDelegateStub::OnDidPaint() {
   webplugin_->DidPaint();
 }
 
 void WebPluginDelegateStub::OnPrint(base::SharedMemoryHandle* shared_memory,
                                     size_t* size) {
+#if defined(OS_WIN)
   gfx::Emf emf;
   if (!emf.CreateDc(NULL, NULL)) {
     NOTREACHED();
     return;
   }
   HDC hdc = emf.hdc();
   skia::PlatformDeviceWin::InitializeDC(hdc);
   delegate_->Print(hdc);
   if (!emf.CloseDc()) {
     NOTREACHED();
     return;
   }
 
   *size = emf.GetDataSize();
   DCHECK(*size);
   base::SharedMemory shared_buf;
   CreateSharedBuffer(*size, &shared_buf, shared_memory);
 
   // Retrieve a copy of the data.
   bool success = emf.GetData(shared_buf.memory(), *size);
   DCHECK(success);
+#else
+  // TODO(port): plugin printing.
+  NOTIMPLEMENTED();
+#endif
 }
 
 void WebPluginDelegateStub::OnUpdateGeometry(
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect,
-    const base::SharedMemoryHandle& windowless_buffer,
-    const base::SharedMemoryHandle& background_buffer) {
+    const TransportDIB::Id& windowless_buffer_id,
+    const TransportDIB::Id& background_buffer_id) {
   webplugin_->UpdateGeometry(
-      window_rect, clip_rect, windowless_buffer, background_buffer);
+      window_rect, clip_rect,
+      windowless_buffer_id, background_buffer_id);
 }
 
 void WebPluginDelegateStub::OnGetPluginScriptableObject(int* route_id,
                                                         intptr_t* npobject_ptr) {
   NPObject* object = delegate_->GetPluginScriptableObject();
   if (!object) {
     *route_id = MSG_ROUTING_NONE;
     return;
   }
 
   *route_id = channel_->GenerateRouteID();
   *npobject_ptr = reinterpret_cast<intptr_t>(object);
   // The stub will delete itself when the proxy tells it that it's released, or
   // otherwise when the channel is closed.
-  NPObjectStub* stub = new NPObjectStub(
+  new NPObjectStub(
       object, channel_.get(), *route_id, webplugin_->modal_dialog_event());
 
   // Release ref added by GetPluginScriptableObject (our stub holds its own).
   NPN_ReleaseObject(object);
 }
 
 void WebPluginDelegateStub::OnSendJavaScriptStream(const std::string& url,
                                                    const std::wstring& result,
                                                    bool success,
                                                    bool notify_needed,
@@ skipping 35 matching lines @@
   if (!shared_buf->Create(std::wstring(), false, false, size)) {
     NOTREACHED();
     return;
   }
   if (!shared_buf->Map(size)) {
     NOTREACHED();
     shared_buf->Close();
     return;
   }
 
+#if defined(OS_WIN)
   BOOL result = DuplicateHandle(GetCurrentProcess(),
                                 shared_buf->handle(),
                                 channel_->renderer_handle(),
                                 remote_handle, 0, FALSE,
                                 DUPLICATE_SAME_ACCESS);
   DCHECK_NE(result, 0);
 
   // If the calling function's shared_buf is on the stack, its destructor will
   // close the shared memory buffer handle. This is fine since we already
   // duplicated the handle to the renderer process so it will stay "alive".
+#else
+  // TODO(port): this should use TransportDIB.
+  NOTIMPLEMENTED();
+#endif
 }
 
 void WebPluginDelegateStub::OnHandleURLRequestReply(
     const PluginMsg_URLRequestReply_Params& params) {
   WebPluginResourceClient* resource_client =
       delegate_->CreateResourceClient(params.resource_id, params.url,
                                       params.notify_needed,
                                       params.notify_data,
                                       params.stream);
   webplugin_->OnResourceCreated(params.resource_id, resource_client);
 }
 
 void WebPluginDelegateStub::OnURLRequestRouted(const std::string& url,
                                                bool notify_needed,
                                                intptr_t notify_data) {
   delegate_->URLRequestRouted(url, notify_needed, notify_data);
 }