linux (and some posix): multiprocess plugins compiling.

chrome/plugin/npobject_util.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/npobject_util.h"
 
-// TODO(port) Just compile an empty file on posix so we can generate the
-// libplugin target needed by other targets. This whole file does compile (see
-// r9934), but it doesn't link because of undefined refs to files which aren't
-// compiling yet (e.g. npobject_proxy stuff).
-#if defined(OS_WIN)
-
+#include "base/string_util.h"
 #include "chrome/common/plugin_messages.h"
-#include "chrome/common/win_util.h"
-
 #include "chrome/plugin/npobject_proxy.h"
 #include "chrome/plugin/plugin_channel_base.h"
 #include "webkit/glue/plugins/nphostapi.h"
 #include "webkit/glue/plugins/plugin_host.h"
 #include "webkit/glue/webkit_glue.h"
 
 // true if the current process is a plugin process, false if it's a renderer
 // process.
 static bool g_plugin_process;
 
@@ skipping 100 matching lines @@
 void PatchNPNFunctions() {
   g_plugin_process = true;
   NPNetscapeFuncs* funcs = GetHostFunctions();
   NPAPI::PluginHost::Singleton()->PatchNPNetscapeFuncs(funcs);
 }
 
 bool IsPluginProcess() {
   return g_plugin_process;
 }
 
-#if defined(OS_WIN)
 void CreateNPIdentifierParam(NPIdentifier id, NPIdentifier_Param* param) {
   param->identifier = id;
 }
 
 NPIdentifier CreateNPIdentifier(const NPIdentifier_Param& param) {
   return param.identifier;
 }
 
 void CreateNPVariantParam(const NPVariant& variant,
                           PluginChannelBase* channel,
@@ skipping 36 matching lines @@
         release = false;
       } else {
         // The channel could be NULL if there was a channel error. The caller's
         // Send call will fail anyways.
         if (channel) {
           // NPObjectStub adds its own reference to the NPObject it owns, so if
           // we were supposed to release the corresponding variant
           // (release==true), we should still do that.
           param->type = NPVARIANT_PARAM_OBJECT_ROUTING_ID;
           int route_id = channel->GenerateRouteID();
-          NPObjectStub* object_stub = new NPObjectStub(
+          new NPObjectStub(
               variant.value.objectValue, channel, route_id, modal_dialog_event);
           param->npobject_routing_id = route_id;
           param->npobject_pointer =
               reinterpret_cast<intptr_t>(variant.value.objectValue);
         } else {
           param->type = NPVARIANT_PARAM_VOID;
         }
       }
       break;
     }
@@ skipping 24 matching lines @@
       result->type = NPVariantType_Int32;
       result->value.intValue = param.int_value;
       break;
     case NPVARIANT_PARAM_DOUBLE:
       result->type = NPVariantType_Double;
       result->value.doubleValue = param.double_value;
       break;
     case NPVARIANT_PARAM_STRING:
       result->type = NPVariantType_String;
       result->value.stringValue.UTF8Characters =
-          static_cast<NPUTF8 *>(_strdup(param.string_value.c_str()));
+          static_cast<NPUTF8 *>(base::strdup(param.string_value.c_str()));
       result->value.stringValue.UTF8Length =
           static_cast<int>(param.string_value.size());
       break;
     case NPVARIANT_PARAM_OBJECT_ROUTING_ID:
       result->type = NPVariantType_Object;
       result->value.objectValue =
           NPObjectProxy::Create(channel,
                                 param.npobject_routing_id,
                                 param.npobject_pointer,
                                 modal_dialog_event);
       break;
     case NPVARIANT_PARAM_OBJECT_POINTER:
       result->type = NPVariantType_Object;
       result->value.objectValue =
           reinterpret_cast<NPObject*>(param.npobject_pointer);
       NPN_RetainObject(result->value.objectValue);
       break;
     default:
       NOTREACHED();
   }
 }
-
-#endif  // defined(OS_WIN)
-
-#endif  // defined(OS_WIN)