linux (and some posix): multiprocess plugins compiling.

chrome/plugin/plugin_thread.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/plugin_thread.h"
+
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
 #include <windows.h>
 #include <objbase.h>
-
-#include "chrome/plugin/plugin_thread.h"
+#endif
 
 #include "base/command_line.h"
+#include "base/process_util.h"
 #include "chrome/common/child_process.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/notification_service.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/plugin/chrome_plugin_host.h"
 #include "chrome/plugin/npobject_util.h"
 #include "chrome/renderer/render_thread.h"
 #include "net/base/net_errors.h"
@@ skipping 18 matching lines @@
 
 void PluginThread::OnControlMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(PluginThread, msg)
     IPC_MESSAGE_HANDLER(PluginProcessMsg_CreateChannel, OnCreateChannel)
     IPC_MESSAGE_HANDLER(PluginProcessMsg_PluginMessage, OnPluginMessage)
   IPC_END_MESSAGE_MAP()
 }
 
 void PluginThread::Init() {
   ChildThread::Init();
+
   PatchNPNFunctions();
+#if defined(OS_WIN)
   CoInitialize(NULL);
+#endif
+
   notification_service_.reset(new NotificationService);
 
   // Preload the library to avoid loading, unloading then reloading
   preloaded_plugin_module_ = base::LoadNativeLibrary(plugin_path_);
 
   ChromePluginLib::Create(plugin_path_, GetCPBrowserFuncsForPlugin());
 
   scoped_refptr<NPAPI::PluginLib> plugin =
       NPAPI::PluginLib::CreatePluginLib(plugin_path_);
   if (plugin.get()) {
     plugin->NP_Initialize();
   }
 
   // Certain plugins, such as flash, steal the unhandled exception filter
   // thus we never get crash reports when they fault. This call fixes it.
   message_loop()->set_exception_restoration(true);
 }
 
 void PluginThread::CleanUp() {
   if (preloaded_plugin_module_) {
-    FreeLibrary(preloaded_plugin_module_);
+    base::UnloadNativeLibrary(preloaded_plugin_module_);
     preloaded_plugin_module_ = NULL;
   }
   PluginChannelBase::CleanupChannels();
   NPAPI::PluginLib::UnloadAllPlugins();
   ChromePluginLib::UnloadAllPlugins();
   notification_service_.reset();
+#if defined(OS_WIN)
   CoUninitialize();
+#endif
 
   if (webkit_glue::ShouldForcefullyTerminatePluginProcess())
-    TerminateProcess(GetCurrentProcess(), 0);
+    base::KillProcess(base::GetCurrentProcessHandle(), 0, /* wait= */ false);
 
   // Call this last because it deletes the ResourceDispatcher, which is used
   // in some of the above cleanup.
   // See http://code.google.com/p/chromium/issues/detail?id=8980
   ChildThread::CleanUp();
 }
 
 void PluginThread::OnCreateChannel(bool off_the_record) {
   std::wstring channel_name;
   scoped_refptr<PluginChannel> channel =
@@ skipping 47 matching lines @@
   if (!plugin_thread)
     return false;
 
   plugin_thread->Send(
       new PluginProcessHostMsg_GetPluginFinderUrl(plugin_finder_url));
   DCHECK(!plugin_finder_url->empty());
   return true;
 }
 
 bool IsDefaultPluginEnabled() {
+#if defined(OS_WIN)
   return true;
+#else
+  NOTIMPLEMENTED();
+  return false;
+#endif
 }
 
 // Dispatch the resolve proxy resquest to the right code, depending on which
 // process the plugin is running in {renderer, browser, plugin}.
 bool FindProxyForUrl(const GURL& url, std::string* proxy_list) {
   int net_error;
   std::string proxy_result;
 
   bool result;
   if (IsPluginProcess()) {
     result = PluginThread::current()->Send(
         new PluginProcessHostMsg_ResolveProxy(url, &net_error, &proxy_result));
   } else {
     result = RenderThread::current()->Send(
         new ViewHostMsg_ResolveProxy(url, &net_error, &proxy_result));
   }
 
   if (!result || net_error != net::OK)
     return false;
 
   *proxy_list = proxy_result;
   return true;
 }
 
 } // namespace webkit_glue