linux (and some posix): multiprocess plugins compiling.

chrome/plugin/chrome_plugin_host.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/chrome_plugin_host.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/message_loop.h"
+#include "base/process_util.h"
 #include "chrome/common/child_process.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_plugin_lib.h"
 #include "chrome/common/chrome_plugin_util.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/plugin/plugin_thread.h"
 #include "chrome/plugin/webplugin_proxy.h"
 #include "net/base/data_url.h"
 #include "net/base/upload_data.h"
@@ skipping 14 matching lines @@
 // NOTE: All methods must be called on the Plugin thread.
 class PluginRequestHandlerProxy
     : public PluginHelper, public ResourceLoaderBridge::Peer {
  public:
   static PluginRequestHandlerProxy* FromCPRequest(CPRequest* request) {
     return ScopableCPRequest::GetData<PluginRequestHandlerProxy*>(request);
   }
 
   PluginRequestHandlerProxy(ChromePluginLib* plugin,
                             ScopableCPRequest* cprequest)
-      : PluginHelper(plugin), cprequest_(cprequest), response_data_offset_(0),
-        completed_(false), sync_(false), read_buffer_(NULL) {
+      : PluginHelper(plugin), cprequest_(cprequest), sync_(false),
+        response_data_offset_(0), completed_(false), read_buffer_(NULL) {
     load_flags_ = PluginResponseUtils::CPLoadFlagsToNetFlags(0);
     cprequest_->data = this;  // see FromCPRequest().
   }
 
   ~PluginRequestHandlerProxy() {
     if (bridge_.get() && !completed_) {
       bridge_->Cancel();
     }
   }
 
@@ skipping 86 matching lines @@
     bridge_.reset(
         PluginThread::current()->resource_dispatcher()->CreateBridge(
             cprequest_->method,
             GURL(cprequest_->url),
             GURL(cprequest_->url),  // TODO(jackson): policy url?
             GURL(),  // TODO(mpcomplete): referrer?
             "null",  // frame_origin
             "null",  // main_frame_origin
             extra_headers_,
             load_flags_,
-            GetCurrentProcessId(),
+            base::GetCurrentProcId(),
             ResourceType::OBJECT,
             cprequest_->context,
             WebAppCacheContext::kNoAppCacheContextId,
             MSG_ROUTING_CONTROL));
     if (!bridge_.get())
       return CPERR_FAILURE;
 
     for (size_t i = 0; i < upload_content_.size(); ++i) {
       switch (upload_content_[i].type()) {
         case net::UploadData::TYPE_BYTES: {
@@ skipping 36 matching lines @@
         response_headers_, type, buf, buf_size);
   }
 
   int Read(void* buf, uint32 buf_size) {
     uint32 avail =
         static_cast<uint32>(response_data_.size()) - response_data_offset_;
     uint32 count = buf_size;
     if (count > avail)
       count = avail;
 
-    int rv = CPERR_FAILURE;
     if (count) {
       // Data is ready now.
       memcpy(buf, &response_data_[0] + response_data_offset_, count);
       response_data_offset_ += count;
     } else if (!completed_) {
       read_buffer_ = buf;
       read_buffer_size_ = buf_size;
       DCHECK(!sync_);
       return CPERR_IO_PENDING;
     }
@@ skipping 13 matching lines @@
  private:
   scoped_ptr<ScopableCPRequest> cprequest_;
   scoped_ptr<ResourceLoaderBridge> bridge_;
   std::vector<net::UploadData::Element> upload_content_;
   std::string extra_headers_;
   uint32 load_flags_;
   bool sync_;
 
   scoped_refptr<net::HttpResponseHeaders> response_headers_;
   std::string response_data_;
-  int response_data_offset_;
+  size_t response_data_offset_;
   bool completed_;
   void* read_buffer_;
   uint32 read_buffer_size_;
 };
 
 //
 // Generic functions
 //
 
 void STDCALL CPB_SetKeepProcessAlive(CPID id, CPBool keep_alive) {
@@ skipping 152 matching lines @@
 //
 
 CPError STDCALL CPB_CreateRequest(CPID id, CPBrowsingContext context,
                                   const char* method, const char* url,
                                   CPRequest** request) {
   CHECK(ChromePluginLib::IsPluginThread());
   ChromePluginLib* plugin = ChromePluginLib::FromCPID(id);
   CHECK(plugin);
 
   ScopableCPRequest* cprequest = new ScopableCPRequest(url, method, context);
-  PluginRequestHandlerProxy* handler =
-      new PluginRequestHandlerProxy(plugin, cprequest);
+  new PluginRequestHandlerProxy(plugin, cprequest);
 
   *request = cprequest;
   return CPERR_SUCCESS;
 }
 
 CPError STDCALL CPR_StartRequest(CPRequest* request) {
   CHECK(ChromePluginLib::IsPluginThread());
   PluginRequestHandlerProxy* handler =
       PluginRequestHandlerProxy::FromCPRequest(request);
   CHECK(handler);
@@ skipping 185 matching lines @@
 
     response_funcs.size = sizeof(response_funcs);
     response_funcs.received_redirect = CPRR_ReceivedRedirect;
     response_funcs.start_completed = CPRR_StartCompleted;
     response_funcs.read_completed = CPRR_ReadCompleted;
     response_funcs.upload_progress = CPRR_UploadProgress;
   }
 
   return &browser_funcs;
 }