linux (and some posix): multiprocess plugins compiling.

chrome/plugin/webplugin_proxy.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_proxy.h"
 
-#include "base/gfx/gdi_util.h"
 #include "base/scoped_handle.h"
 #include "base/shared_memory.h"
 #include "base/singleton.h"
 #include "base/waitable_event.h"
+#include "build/build_config.h"
 #include "chrome/common/gfx/chrome_canvas.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/url_constants.h"
-#include "chrome/common/win_util.h"
 #include "chrome/plugin/npobject_proxy.h"
 #include "chrome/plugin/npobject_util.h"
 #include "chrome/plugin/plugin_channel.h"
 #include "chrome/plugin/plugin_thread.h"
 #include "chrome/plugin/webplugin_delegate_stub.h"
 #include "skia/ext/platform_device.h"
 #include "webkit/glue/webplugin_delegate.h"
 
+#if defined(OS_WIN)
+#include "base/gfx/gdi_util.h"
+#include "chrome/common/win_util.h"
+#endif
+
 typedef std::map<CPBrowsingContext, WebPluginProxy*> ContextMap;
 static ContextMap& GetContextMap() {
   return *Singleton<ContextMap>::get();
 }
 
 WebPluginProxy::WebPluginProxy(
     PluginChannel* channel,
     int route_id,
     WebPluginDelegate* delegate)
     : channel_(channel),
       route_id_(route_id),
       cp_browsing_context_(0),
       window_npobject_(NULL),
       plugin_element_(NULL),
       delegate_(delegate),
       waiting_for_paint_(false),
-#pragma warning(suppress: 4355)  // can use this
-      runnable_method_factory_(this) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(runnable_method_factory_(this))
+{
 }
 
 WebPluginProxy::~WebPluginProxy() {
   if (cp_browsing_context_)
     GetContextMap().erase(cp_browsing_context_);
 }
 
 bool WebPluginProxy::Send(IPC::Message* msg) {
   return channel_->Send(msg);
 }
@@ skipping 197 matching lines @@
                                       const char* target, unsigned int len,
                                       const char* buf, bool is_file_data,
                                       bool notify, const char* url,
                                       intptr_t notify_data,
                                       bool popups_allowed) {
   if (!url) {
     NOTREACHED();
     return;
   }
 
-  if (!target && (0 == _strcmpi(method, "GET"))) {
+  if (!target && (0 == base::strcasecmp(method, "GET"))) {
     // Please refer to https://bugzilla.mozilla.org/show_bug.cgi?id=366082
     // for more details on this.
+#if defined(OS_WIN)
     if (delegate_->GetQuirks() &
         WebPluginDelegate::PLUGIN_QUIRK_BLOCK_NONSTANDARD_GETURL_REQUESTS) {
       GURL request_url(url);
       if (!request_url.SchemeIs(chrome::kHttpScheme) &&
           !request_url.SchemeIs(chrome::kHttpsScheme) &&
           !request_url.SchemeIs(chrome::kFtpScheme)) {
         return;
       }
     }
+#else
+    // TODO(port): we need a GetQuirks() on our delegate impl.
+    NOTIMPLEMENTED();
+#endif
   }
 
   PluginHostMsg_URLRequest_Params params;
   params.method = method;
   params.is_javascript_url = is_javascript_url;
   if (target)
     params.target = std::string(target);
 
   if (len) {
     params.buffer.resize(len);
     memcpy(&params.buffer.front(), buf, len);
   }
 
   params.is_file_data = is_file_data;
   params.notify = notify;
   params.url = url;
   params.notify_data = notify_data;
   params.popups_allowed = popups_allowed;
 
   Send(new PluginHostMsg_URLRequest(route_id_, params));
 }
 
 void WebPluginProxy::Paint(const gfx::Rect& rect) {
+#if defined(OS_WIN)
   if (!windowless_hdc_)
     return;
 
   // Clear the damaged area so that if the plugin doesn't paint there we won't
   // end up with the old values.
   gfx::Rect offset_rect = rect;
   offset_rect.Offset(delegate_->GetRect().origin());
   if (!background_hdc_) {
     FillRect(windowless_hdc_, &offset_rect.ToRECT(),
         static_cast<HBRUSH>(GetStockObject(BLACK_BRUSH)));
   } else {
     BitBlt(windowless_hdc_, offset_rect.x(), offset_rect.y(),
       offset_rect.width(), offset_rect.height(), background_hdc_,
       rect.x(), rect.y(), SRCCOPY);
   }
 
   RECT clip_rect = rect.ToRECT();
   HRGN clip_region = CreateRectRgnIndirect(&clip_rect);
   SelectClipRgn(windowless_hdc_, clip_region);
 
   // Before we send the invalidate, paint so that renderer uses the updated
   // bitmap.
   delegate_->Paint(windowless_hdc_, offset_rect);
 
   SelectClipRgn(windowless_hdc_, NULL);
   DeleteObject(clip_region);
+#else
+  // TODO(port): windowless painting.
+  NOTIMPLEMENTED();
+#endif
 }
 
 void WebPluginProxy::UpdateGeometry(
     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) {
+#if defined(OS_WIN)
+  // TODO(port): this isn't correct usage of a TransportDIB; for now,
+  // the caller temporarly just stuffs the handle into the HANDLE
+  // field of the TransportDIB::Id so it should behave like the older
+  // code.
   gfx::Rect old = delegate_->GetRect();
   gfx::Rect old_clip_rect = delegate_->GetClipRect();
 
   bool moved = old.x() != window_rect.x() || old.y() != window_rect.y();
   delegate_->UpdateGeometry(window_rect, clip_rect);
-  if (windowless_buffer) {
+  if (windowless_buffer_id.handle) {
     // The plugin's rect changed, so now we have a new buffer to draw into.
-    SetWindowlessBuffer(windowless_buffer, background_buffer);
+    SetWindowlessBuffer(windowless_buffer_id.handle,
+                        background_buffer_id.handle);
   } else if (moved) {
     // The plugin moved, so update our world transform.
     UpdateTransform();
   }
   // Send over any pending invalidates which occured when the plugin was
   // off screen.
   if (delegate_->IsWindowless() && !clip_rect.IsEmpty() &&
       old_clip_rect.IsEmpty() && !damaged_rect_.IsEmpty()) {
     InvalidateRect(damaged_rect_);
   }
+#else
+  NOTIMPLEMENTED();
+#endif
 }
 
+#if defined(OS_WIN)
 void WebPluginProxy::SetWindowlessBuffer(
     const base::SharedMemoryHandle& windowless_buffer,
     const base::SharedMemoryHandle& background_buffer) {
   // Convert the shared memory handle to a handle that works in our process,
   // and then use that to create an HDC.
   ConvertBuffer(windowless_buffer,
                 &windowless_shared_section_,
                 &windowless_bitmap_,
                 &windowless_hdc_);
   if (background_buffer) {
@@ skipping 47 matching lines @@
 
   XFORM xf;
   xf.eDx = static_cast<FLOAT>(-delegate_->GetRect().x());
   xf.eDy = static_cast<FLOAT>(-delegate_->GetRect().y());
   xf.eM11 = 1;
   xf.eM21 = 0;
   xf.eM12 = 0;
   xf.eM22 = 1;
   SetWorldTransform(windowless_hdc_, &xf);
 }
+#endif
 
 void WebPluginProxy::CancelDocumentLoad() {
   Send(new PluginHostMsg_CancelDocumentLoad(route_id_));
 }
 
 void WebPluginProxy::InitiateHTTPRangeRequest(const char* url,
                                               const char* range_info,
                                               intptr_t existing_stream,
                                               bool notify_needed,
                                               intptr_t notify_data) {
 
   Send(new PluginHostMsg_InitiateHTTPRangeRequest(route_id_, url,
                                                   range_info, existing_stream,
                                                   notify_needed, notify_data));
 }
 
 void WebPluginProxy::OnPaint(const gfx::Rect& damaged_rect) {
   Paint(damaged_rect);
   Send(new PluginHostMsg_InvalidateRect(route_id_, damaged_rect));
 }
 
 bool WebPluginProxy::IsOffTheRecord() {
   return channel_->off_the_record();
 }