linux (and some posix): multiprocess plugins compiling.

chrome/renderer/webplugin_delegate_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/renderer/webplugin_delegate_proxy.h"
 
+#include "build/build_config.h"
+
+#if defined(OS_WIN)
 #include <atlbase.h>
+#endif
 
 #include "base/logging.h"
 #include "base/ref_counted.h"
 #include "base/string_util.h"
 #include "base/gfx/size.h"
 #include "base/gfx/native_widget_types.h"
 #include "chrome/app/chrome_dll_resource.h"
 #include "chrome/common/gfx/chrome_canvas.h"
-#include "chrome/common/gfx/emf.h"
 #include "chrome/common/l10n_util.h"
 #include "chrome/common/plugin_messages.h"
 #include "chrome/common/render_messages.h"
 #include "chrome/common/resource_bundle.h"
-#include "chrome/common/win_util.h"
 #include "chrome/plugin/npobject_proxy.h"
 #include "chrome/plugin/npobject_stub.h"
 #include "chrome/renderer/render_thread.h"
 #include "chrome/renderer/render_view.h"
 #include "googleurl/src/gurl.h"
 #include "grit/generated_resources.h"
 #include "net/base/mime_util.h"
 #include "webkit/glue/webframe.h"
 #include "webkit/glue/webkit_glue.h"
 #include "webkit/glue/webplugin.h"
 #include "webkit/glue/webview.h"
 
+#if defined(OS_WIN)
+#include "chrome/common/gfx/emf.h"
+#include "chrome/common/win_util.h"
+#endif
+
 // Proxy for WebPluginResourceClient.  The object owns itself after creation,
 // deleting itself after its callback has been called.
 class ResourceClientProxy : public WebPluginResourceClient {
  public:
   ResourceClientProxy(PluginChannelHost* channel, int instance_id)
     : channel_(channel), instance_id_(instance_id), resource_id_(0),
       notify_needed_(false), notify_data_(NULL),
       multibyte_response_expected_(false) {
   }
 
   ~ResourceClientProxy() {
   }
 
   void Initialize(int resource_id, const std::string &url, bool notify_needed,
                   intptr_t notify_data, intptr_t existing_stream) {
     resource_id_ = resource_id;
     url_ = url;
     notify_needed_ = notify_needed;
     notify_data_ = notify_data;
 
     PluginMsg_URLRequestReply_Params params;
     params.resource_id = resource_id;
     params.url = url_;
     params.notify_needed = notify_needed_;
     params.notify_data = notify_data_;
     params.stream = existing_stream;
 
-    multibyte_response_expected_ = (existing_stream != NULL);
+    multibyte_response_expected_ = (existing_stream != 0);
 
     channel_->Send(new PluginMsg_HandleURLRequestReply(instance_id_, params));
   }
 
   // PluginResourceClient implementation:
   void WillSendRequest(const GURL& url) {
     DCHECK(channel_ != NULL);
     channel_->Send(new PluginMsg_WillSendRequest(instance_id_, resource_id_,
                                                  url));
   }
@@ skipping 43 matching lines @@
     DCHECK(channel_ != NULL);
     channel_->Send(new PluginMsg_DidFail(instance_id_, resource_id_));
     channel_ = NULL;
     MessageLoop::current()->DeleteSoon(FROM_HERE, this);
   }
 
   bool IsMultiByteResponseExpected() {
     return multibyte_response_expected_;
   }
 
-private:
+ private:
+  scoped_refptr<PluginChannelHost> channel_;
+  int instance_id_;
   int resource_id_;
-  int instance_id_;
-  scoped_refptr<PluginChannelHost> channel_;
   std::string url_;
   bool notify_needed_;
   intptr_t notify_data_;
   // Set to true if the response expected is a multibyte response.
   // For e.g. response for a HTTP byte range request.
   bool multibyte_response_expected_;
 };
 
 WebPluginDelegateProxy* WebPluginDelegateProxy::Create(
     const GURL& url,
     const std::string& mime_type,
     const std::string& clsid,
     RenderView* render_view) {
   return new WebPluginDelegateProxy(mime_type, clsid, render_view);
 }
 
 WebPluginDelegateProxy::WebPluginDelegateProxy(const std::string& mime_type,
                                                const std::string& clsid,
                                                RenderView* render_view)
     : render_view_(render_view),
+      plugin_(NULL),
+      windowless_(false),
       mime_type_(mime_type),
       clsid_(clsid),
-      plugin_(NULL),
-      windowless_(false),
+      send_deferred_update_geometry_(false),
       npobject_(NULL),
-      send_deferred_update_geometry_(false),
+      window_script_object_(NULL),
       sad_plugin_(NULL),
-      window_script_object_(NULL),
-      transparent_(false),
-      invalidate_pending_(false) {
+      invalidate_pending_(false),
+      transparent_(false) {
 }
 
 WebPluginDelegateProxy::~WebPluginDelegateProxy() {
 }
 
 void WebPluginDelegateProxy::PluginDestroyed() {
   plugin_ = NULL;
 
   if (npobject_) {
     // When we destroy the plugin instance, the NPObjectStub NULLs out its
@@ skipping 19 matching lines @@
   render_view_->PluginDestroyed(this);
   MessageLoop::current()->DeleteSoon(FROM_HERE, this);
 }
 
 void WebPluginDelegateProxy::FlushGeometryUpdates() {
   if (send_deferred_update_geometry_) {
     send_deferred_update_geometry_ = false;
     Send(new PluginMsg_UpdateGeometry(instance_id_,
                                       plugin_rect_,
                                       deferred_clip_rect_,
-                                      NULL,
-                                      NULL));
+                                      TransportDIB::Id(),
+                                      TransportDIB::Id()));
   }
 }
 
 bool WebPluginDelegateProxy::Initialize(const GURL& url, char** argn,
                                         char** argv, int argc,
                                         WebPlugin* plugin,
                                         bool load_manually) {
   std::wstring channel_name;
   FilePath plugin_path;
   if (!RenderThread::current()->Send(new ViewHostMsg_OpenChannelToPlugin(
@@ skipping 102 matching lines @@
   return plugin_path_;
 }
 
 void WebPluginDelegateProxy::InstallMissingPlugin() {
   Send(new PluginMsg_InstallMissingPlugin(instance_id_));
 }
 
 void WebPluginDelegateProxy::OnMessageReceived(const IPC::Message& msg) {
   IPC_BEGIN_MESSAGE_MAP(WebPluginDelegateProxy, msg)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindow, OnSetWindow)
+#if defined(OS_WIN)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetWindowlessPumpEvent,
                         OnSetWindowlessPumpEvent)
+#endif
     IPC_MESSAGE_HANDLER(PluginHostMsg_CancelResource, OnCancelResource)
     IPC_MESSAGE_HANDLER(PluginHostMsg_InvalidateRect, OnInvalidateRect)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetWindowScriptNPObject,
                         OnGetWindowScriptNPObject)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetPluginElement,
                         OnGetPluginElement)
     IPC_MESSAGE_HANDLER(PluginHostMsg_SetCookie, OnSetCookie)
     IPC_MESSAGE_HANDLER(PluginHostMsg_GetCookies, OnGetCookies)
     IPC_MESSAGE_HANDLER(PluginHostMsg_ShowModalHTMLDialog,
                         OnShowModalHTMLDialog)
@@ skipping 18 matching lines @@
 void WebPluginDelegateProxy::UpdateGeometry(
                 const gfx::Rect& window_rect,
                 const gfx::Rect& clip_rect) {
   plugin_rect_ = window_rect;
   if (!windowless_) {
     deferred_clip_rect_ = clip_rect;
     send_deferred_update_geometry_ = true;
     return;
   }
 
-  HANDLE transport_store_handle = NULL;
-  HANDLE background_store_handle = NULL;
+  // Be careful to explicitly call the default constructors for these ids,
+  // as they can be POD on some platforms and we want them initialized.
+  TransportDIB::Id transport_store_id = TransportDIB::Id();
+  TransportDIB::Id background_store_id = TransportDIB::Id();
+
+#if defined(OS_WIN)
+  // TODO(port): use TransportDIB instead of allocating these directly.
   if (!backing_store_canvas_.get() ||
       (window_rect.width() != backing_store_canvas_->getDevice()->width() ||
        window_rect.height() != backing_store_canvas_->getDevice()->height())) {
     // Create a shared memory section that the plugin paints into
     // asynchronously.
     ResetWindowlessBitmaps();
     if (!window_rect.IsEmpty()) {
       if (!CreateBitmap(&backing_store_, &backing_store_canvas_) ||
           !CreateBitmap(&transport_store_, &transport_store_canvas_) ||
           (transparent_ &&
            !CreateBitmap(&background_store_, &background_store_canvas_))) {
         DCHECK(false);
         ResetWindowlessBitmaps();
         return;
       }
 
-      transport_store_handle = transport_store_->handle();
+      // TODO(port): once we use TransportDIB we will properly fill in these
+      // ids; for now we just fill in the HANDLE field.
+      transport_store_id.handle = transport_store_->handle();
       if (background_store_.get())
-        background_store_handle = background_store_->handle();
+        background_store_id.handle = background_store_->handle();
     }
   }
+#else
+  // TODO(port): refactor our allocation of backing stores.
+  NOTIMPLEMENTED();
+#endif
 
   IPC::Message* msg = new PluginMsg_UpdateGeometry(
       instance_id_, window_rect, clip_rect,
-      transport_store_handle, background_store_handle);
+      transport_store_id, background_store_id);
   msg->set_unblock(true);
   Send(msg);
 }
 
+#if defined(OS_WIN)
 // Copied from render_widget.cc
 static size_t GetPaintBufSize(const gfx::Rect& rect) {
   // TODO(darin): protect against overflow
   return 4 * rect.width() * rect.height();
 }
+#endif
 
 void WebPluginDelegateProxy::ResetWindowlessBitmaps() {
   backing_store_.reset();
   transport_store_.reset();
   backing_store_canvas_.reset();
   transport_store_canvas_.reset();
   background_store_.reset();
   background_store_canvas_.release();
   backing_store_painted_ = gfx::Rect();
 }
 
 bool WebPluginDelegateProxy::CreateBitmap(
     scoped_ptr<base::SharedMemory>* memory,
-    scoped_ptr<skia::PlatformCanvasWin>* canvas) {
+    scoped_ptr<skia::PlatformCanvas>* canvas) {
+#if defined(OS_WIN)
   size_t size = GetPaintBufSize(plugin_rect_);
   scoped_ptr<base::SharedMemory> new_shared_memory(new base::SharedMemory());
   if (!new_shared_memory->Create(L"", false, true, size))
     return false;
 
   scoped_ptr<skia::PlatformCanvasWin> new_canvas(new skia::PlatformCanvasWin);
   if (!new_canvas->initialize(plugin_rect_.width(), plugin_rect_.height(),
                               true, new_shared_memory->handle())) {
     return false;
   }
 
   memory->swap(new_shared_memory);
   canvas->swap(new_canvas);
   return true;
+#else
+  // TODO(port): use TransportDIB properly.
+  NOTIMPLEMENTED();
+  return false;
+#endif
 }
 
-void WebPluginDelegateProxy::Paint(HDC hdc, const gfx::Rect& damaged_rect) {
+void WebPluginDelegateProxy::Paint(gfx::NativeDrawingContext context,
+                                   const gfx::Rect& damaged_rect) {
   // If the plugin is no longer connected (channel crashed) draw a crashed
   // plugin bitmap
   if (!channel_host_->channel_valid()) {
-    PaintSadPlugin(hdc, damaged_rect);
+    PaintSadPlugin(context, damaged_rect);
     return;
   }
 
   // No paint events for windowed plugins.
   if (!windowless_)
     return;
 
+  // TODO(port): side-stepping some windowless plugin code for now.
+#if defined(OS_WIN)
   // We got a paint before the plugin's coordinates, so there's no buffer to
   // copy from.
   if (!backing_store_canvas_.get())
     return;
 
   // Limit the damaged rectangle to whatever is contained inside the plugin
   // rectangle, as that's the rectangle that we'll bitblt to the hdc.
   gfx::Rect rect = damaged_rect.Intersect(plugin_rect_);
 
   bool background_changed = false;
-  if (background_store_canvas_.get() && BackgroundChanged(hdc, rect)) {
+  if (background_store_canvas_.get() && BackgroundChanged(context, rect)) {
     background_changed = true;
     HDC background_hdc =
         background_store_canvas_->getTopPlatformDevice().getBitmapDC();
     BitBlt(background_hdc, rect.x()-plugin_rect_.x(), rect.y()-plugin_rect_.y(),
-        rect.width(), rect.height(), hdc, rect.x(), rect.y(), SRCCOPY);
+        rect.width(), rect.height(), context, rect.x(), rect.y(), SRCCOPY);
   }
 
   gfx::Rect offset_rect = rect;
   offset_rect.Offset(-plugin_rect_.x(), -plugin_rect_.y());
   if (background_changed || !backing_store_painted_.Contains(offset_rect)) {
     Send(new PluginMsg_Paint(instance_id_, offset_rect));
     CopyFromTransportToBacking(offset_rect);
   }
 
   HDC backing_hdc = backing_store_canvas_->getTopPlatformDevice().getBitmapDC();
-  BitBlt(hdc, rect.x(), rect.y(), rect.width(), rect.height(), backing_hdc,
+  BitBlt(context, rect.x(), rect.y(), rect.width(), rect.height(), backing_hdc,
       rect.x()-plugin_rect_.x(), rect.y()-plugin_rect_.y(), SRCCOPY);
 
   if (invalidate_pending_) {
     // Only send the PaintAck message if this paint is in response to an
     // invalidate from the plugin, since this message acts as an access token
     // to ensure only one process is using the transport dib at a time.
     invalidate_pending_ = false;
     Send(new PluginMsg_DidPaint(instance_id_));
   }
+#else
+  // TODO(port): windowless plugin paint handling goes here.
+  NOTIMPLEMENTED();
+#endif
 }
 
+#if defined(OS_WIN)
+// TODO(port): this should be portable; just avoiding windowless plugins for
+// now.
 bool WebPluginDelegateProxy::BackgroundChanged(
     HDC hdc,
     const gfx::Rect& rect) {
   HBITMAP hbitmap = static_cast<HBITMAP>(GetCurrentObject(hdc, OBJ_BITMAP));
   if (hbitmap == NULL) {
     NOTREACHED();
     return true;
   }
 
   BITMAP bitmap = { 0 };
@@ skipping 24 matching lines @@
     // the plugin origin from the coordinates.
     uint32_t* canvas_row_start =
         background_store_canvas_->getDevice()->accessBitmap(true).getAddr32(
             check_rect.x() - plugin_rect_.x(), y - plugin_rect_.y());
     if (memcmp(hdc_row_start, canvas_row_start, row_byte_size) != 0)
       return true;
   }
 
   return false;
 }
+#endif
 
-void WebPluginDelegateProxy::Print(HDC hdc) {
+void WebPluginDelegateProxy::Print(gfx::NativeDrawingContext context) {
   base::SharedMemoryHandle shared_memory;
   size_t size;
   if (!Send(new PluginMsg_Print(instance_id_, &shared_memory, &size)))
     return;
 
   base::SharedMemory memory(shared_memory, true);
   if (!memory.Map(size)) {
     NOTREACHED();
     return;
   }
 
+#if defined(OS_WIN)
   gfx::Emf emf;
   if (!emf.CreateFromData(memory.memory(), size)) {
     NOTREACHED();
     return;
   }
   // Playback the buffer.
-  emf.Playback(hdc, NULL);
+  emf.Playback(context, NULL);
+#else
+  // TODO(port): plugin printing.
+  NOTIMPLEMENTED();
+#endif
 }
 
 NPObject* WebPluginDelegateProxy::GetPluginScriptableObject() {
   if (npobject_)
     return NPN_RetainObject(npobject_);
 
   int route_id = MSG_ROUTING_NONE;
   intptr_t npobject_ptr;
   Send(new PluginMsg_GetPluginScriptableObject(
       instance_id_, &route_id, &npobject_ptr));
@@ skipping 89 matching lines @@
     int route_id, bool* success, intptr_t* npobject_ptr) {
   *success = false;
   NPObject* npobject = NULL;
   if (plugin_)
     npobject = plugin_->GetPluginElement();
   if (!npobject)
     return;
 
   // 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(
       npobject, channel_host_.get(), route_id,
       render_view_->modal_dialog_event());
   *success = true;
   *npobject_ptr = reinterpret_cast<intptr_t>(npobject);
 }
 
 void WebPluginDelegateProxy::OnSetCookie(const GURL& url,
                                          const GURL& policy_url,
                                          const std::string& cookie) {
   if (plugin_)
@@ skipping 19 matching lines @@
 
 void WebPluginDelegateProxy::OnMissingPluginStatus(int status) {
   if (render_view_)
     render_view_->OnMissingPluginStatus(this, status);
 }
 
 void WebPluginDelegateProxy::OnGetCPBrowsingContext(uint32* context) {
   *context = render_view_ ? render_view_->GetCPBrowsingContext() : 0;
 }
 
-void WebPluginDelegateProxy::PaintSadPlugin(HDC hdc, const gfx::Rect& rect) {
+void WebPluginDelegateProxy::PaintSadPlugin(gfx::NativeDrawingContext hdc,
+                                            const gfx::Rect& rect) {
+#if defined(OS_WIN)
   const int width = plugin_rect_.width();
   const int height = plugin_rect_.height();
 
   ChromeCanvas canvas(width, height, false);
   SkPaint paint;
 
   paint.setStyle(SkPaint::kFill_Style);
   paint.setColor(SK_ColorBLACK);
   canvas.drawRectCoords(0, 0, SkIntToScalar(width), SkIntToScalar(height),
                         paint);
 
   if (!sad_plugin_) {
     sad_plugin_ = ResourceBundle::GetSharedInstance().GetBitmapNamed(
         IDR_SAD_PLUGIN);
   }
 
   if (sad_plugin_) {
     canvas.DrawBitmapInt(*sad_plugin_,
                          std::max(0, (width - sad_plugin_->width())/2),
                          std::max(0, (height - sad_plugin_->height())/2));
   }
 
   canvas.getTopPlatformDevice().drawToHDC(
       hdc, plugin_rect_.x(), plugin_rect_.y(), NULL);
-  return;
+#else
+  // TODO(port): it ought to be possible to refactor this to be shared between
+  // platforms.  It's just the final drawToHDC that kills us.
+  NOTIMPLEMENTED();
+#endif
 }
 
 void WebPluginDelegateProxy::CopyFromTransportToBacking(const gfx::Rect& rect) {
   if (!backing_store_canvas_.get())
     return;
 
+#if defined(OS_WIN)
   // Copy the damaged rect from the transport bitmap to the backing store.
   HDC backing = backing_store_canvas_->getTopPlatformDevice().getBitmapDC();
   HDC transport = transport_store_canvas_->getTopPlatformDevice().getBitmapDC();
   BitBlt(backing, rect.x(), rect.y(), rect.width(), rect.height(),
       transport, rect.x(), rect.y(), SRCCOPY);
   backing_store_painted_ = backing_store_painted_.Union(rect);
+#else
+  // TODO(port): probably some new code in TransportDIB should go here.
+  NOTIMPLEMENTED();
+#endif
 }
 
 void WebPluginDelegateProxy::OnHandleURLRequest(
     const PluginHostMsg_URLRequest_Params& params) {
   const char* data = NULL;
   if (params.buffer.size())
     data = &params.buffer[0];
 
   const char* target = NULL;
   if (params.target.length())
@@ skipping 27 matching lines @@
   plugin_->CancelDocumentLoad();
 }
 
 void WebPluginDelegateProxy::OnInitiateHTTPRangeRequest(
    const std::string& url, const std::string& range_info,
    intptr_t existing_stream, bool notify_needed, intptr_t notify_data) {
   plugin_->InitiateHTTPRangeRequest(url.c_str(), range_info.c_str(),
                                     existing_stream, notify_needed,
                                     notify_data);
 }