If SHM pixmaps support is available, for example, Intel drivers now support t...

chrome/plugin/webplugin_proxy.cc

 // Copyright (c) 2009 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 "build/build_config.h"
 
 #if defined(OS_WIN)
 #include "app/win_util.h"
@@ skipping 14 matching lines @@
 #include "chrome/plugin/plugin_thread.h"
 #include "gfx/blit.h"
 #include "gfx/canvas.h"
 #if defined(OS_WIN)
 #include "gfx/gdi_util.h"
 #endif
 #include "skia/ext/platform_device.h"
 #include "third_party/WebKit/WebKit/chromium/public/WebBindings.h"
 #include "webkit/glue/plugins/webplugin_delegate_impl.h"
 
+#if defined(USE_X11)
+#include "app/x11_util_internal.h"
+#endif
+
 using WebKit::WebBindings;
 using webkit_glue::WebPluginResourceClient;
 
 typedef std::map<CPBrowsingContext, WebPluginProxy*> ContextMap;
 static ContextMap& GetContextMap() {
   return *Singleton<ContextMap>::get();
 }
 
 WebPluginProxy::WebPluginProxy(
     PluginChannel* channel,
     int route_id,
     const GURL& page_url,
     gfx::NativeViewId containing_window,
     int host_render_view_routing_id)
     : channel_(channel),
       route_id_(route_id),
       cp_browsing_context_(0),
       window_npobject_(NULL),
       plugin_element_(NULL),
       delegate_(NULL),
       waiting_for_paint_(false),
       containing_window_(containing_window),
       page_url_(page_url),
       transparent_(false),
       host_render_view_routing_id_(host_render_view_routing_id),
       ALLOW_THIS_IN_INITIALIZER_LIST(runnable_method_factory_(this)) {
+#if defined(USE_X11)
+      windowless_shm_pixmap_ = None;
+      use_shm_pixmap_ = false;
+
+      // If the X server supports SHM pixmaps
+      // and the color depth and masks match,
+      // then consider using SHM pixmaps for windowless plugin painting.
+      Display* display = x11_util::GetXDisplay();
+      if (x11_util::QuerySharedMemorySupport(display) ==
+              x11_util::SHARED_MEMORY_PIXMAP &&
+          x11_util::BitsPerPixelForPixmapDepth(
+              display, DefaultDepth(display, 0)) == 32) {
+        Visual* vis = DefaultVisual(display, 0);
+
+        if (vis->red_mask == 0xff0000 &&
+            vis->green_mask == 0xff00 &&
+            vis->blue_mask == 0xff)
+          use_shm_pixmap_ = true;
+      }
+#endif
 }
 
 WebPluginProxy::~WebPluginProxy() {
   if (cp_browsing_context_)
     GetContextMap().erase(cp_browsing_context_);
+
+#if defined(USE_X11)
+  if (windowless_shm_pixmap_ != None)
+    XFreePixmap(x11_util::GetXDisplay(), windowless_shm_pixmap_);
+#endif
 }
 
 bool WebPluginProxy::Send(IPC::Message* msg) {
   return channel_->Send(msg);
 }
 
 void WebPluginProxy::SetWindow(gfx::PluginWindowHandle window) {
   Send(new PluginHostMsg_SetWindow(route_id_, window));
 }
 
@@ skipping 484 matching lines @@
     // This can happen if the renderer has already destroyed the TransportDIB
     // by the time we receive the handle, e.g. in case of multiple resizes.
     windowless_canvas_.reset();
   }
   background_dib_.reset(TransportDIB::Map(background_buffer));
   if (background_dib_.get()) {
     background_canvas_.reset(background_dib_->GetPlatformCanvas(width, height));
   } else {
     background_canvas_.reset();
   }
+
+  // If SHM pixmaps support is available, create a SHM pixmap and
+  // pass it to the delegate for windowless plugin painting.
+  if (delegate_->IsWindowless() && use_shm_pixmap_ && windowless_dib_.get()) {
+    Display* display = x11_util::GetXDisplay();
+    XID root_window = x11_util::GetX11RootWindow();
+    XShmSegmentInfo shminfo = {0};
+
+    if (windowless_shm_pixmap_ != None)
+      XFreePixmap(display, windowless_shm_pixmap_);
+
+    shminfo.shmseg = windowless_dib_->MapToX(display);
+    // Create a shared memory pixmap based on the image buffer.
+    windowless_shm_pixmap_ = XShmCreatePixmap(display, root_window,
+                                              NULL, &shminfo,
+                                              width, height,
+                                              DefaultDepth(display, 0));
+
+    delegate_->SetWindowlessShmPixmap(windowless_shm_pixmap_);
+  }
 }
 
 #endif
 
 void WebPluginProxy::CancelDocumentLoad() {
   Send(new PluginHostMsg_CancelDocumentLoad(route_id_));
 }
 
 void WebPluginProxy::InitiateHTTPRangeRequest(
     const char* url, const char* range_info, int range_request_id) {
@@ skipping 42 matching lines @@
   while (index != resource_clients_.end()) {
     WebPluginResourceClient* client = (*index).second;
 
     if (client == resource_client) {
       resource_clients_.erase(index++);
     } else {
       index++;
     }
   }
 }