On Windows, create a new TransportDIB::Handle struct which includes the file

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 467 matching lines @@
     const gfx::Rect& window_rect,
     const gfx::Rect& clip_rect,
     const TransportDIB::Handle& windowless_buffer,
     const TransportDIB::Handle& background_buffer,
     bool transparent
 #if defined(OS_MACOSX)
     ,
     int ack_key
 #endif
     ) {
+  TransportDIB::ScopedHandle scoped_windowless_handle(windowless_buffer);
+  TransportDIB::ScopedHandle scoped_background_handle(background_buffer);
   gfx::Rect old = delegate_->GetRect();
   gfx::Rect old_clip_rect = delegate_->GetClipRect();
   transparent_ = transparent;
 
   // Update the buffers before doing anything that could call into plugin code,
   // so that we don't process buffer changes out of order if plugins make
   // synchronous calls that lead to nested UpdateGeometry calls.
   if (TransportDIB::is_valid(windowless_buffer)) {
     // The plugin's rect changed, so now we have a new buffer to draw into.
-    SetWindowlessBuffer(windowless_buffer, background_buffer, window_rect);
+    SetWindowlessBuffer(scoped_windowless_handle.release(),
+                        scoped_background_handle.release(),
+                        window_rect);
   }
 
 #if defined(OS_MACOSX)
   delegate_->UpdateGeometryAndContext(window_rect, clip_rect,
                                       windowless_context_);
 #else
   delegate_->UpdateGeometry(window_rect, clip_rect);
 #endif
 
   // Send over any pending invalidates which occured when the plugin was
   // off screen.
   if (delegate_->IsWindowless() && !clip_rect.IsEmpty() &&
       !damaged_rect_.IsEmpty()) {
     InvalidateRect(damaged_rect_);
   }
 
 #if defined(OS_MACOSX)
   // The renderer is expecting an ACK message if ack_key is not -1.
   if (ack_key != -1) {
     Send(new PluginHostMsg_UpdateGeometry_ACK(route_id_, ack_key));
   }
 #endif
 }
 
-#if defined(OS_WIN)
-void WebPluginProxy::SetWindowlessBuffer(
-    const TransportDIB::Handle& windowless_buffer,
-    const TransportDIB::Handle& background_buffer,
-    const gfx::Rect& window_rect) {
-  // Create a canvas that will reference the shared bits. We have to handle
-  // errors here since we're mapping a large amount of memory that may not fit
-  // in our address space, or go wrong in some other way.
-  windowless_canvas_.reset(new skia::PlatformCanvas);
-  if (!windowless_canvas_->initialize(
-          window_rect.width(),
-          window_rect.height(),
-          true,
-          win_util::GetSectionFromProcess(windowless_buffer,
-              channel_->renderer_handle(), false))) {
-    windowless_canvas_.reset();
-    background_canvas_.reset();
-    return;
-  }
-
-  if (background_buffer) {
-    background_canvas_.reset(new skia::PlatformCanvas);
-    if (!background_canvas_->initialize(
-            window_rect.width(),
-            window_rect.height(),
-            true,
-            win_util::GetSectionFromProcess(background_buffer,
-                channel_->renderer_handle(), false))) {
-      windowless_canvas_.reset();
-      background_canvas_.reset();
-      return;
-    }
-  }
-}
-
-#elif defined(OS_MACOSX)
-
 void WebPluginProxy::SetWindowlessBuffer(
     const TransportDIB::Handle& windowless_buffer,
     const TransportDIB::Handle& background_buffer,
     const gfx::Rect& window_rect) {
-  // Convert the shared memory handle to a handle that works in our process,
-  // and then use that to create a CGContextRef.
+  // We have to handle errors here since we're mapping a large amount of memory
+  // that may not fit in our address space. Also, the renderer may have already
+  // destroyed the TransportDIB by the time we receive the handle, e.g. in case
+  // of multiple resizes.
+#if defined(OS_MACOSX)
   windowless_dib_.reset(TransportDIB::Map(windowless_buffer));
   background_dib_.reset(TransportDIB::Map(background_buffer));
-  windowless_context_.reset(CGBitmapContextCreate(
-      windowless_dib_->memory(),
-      window_rect.width(),
-      window_rect.height(),
-      8, 4 * window_rect.width(),
-      mac_util::GetSystemColorSpace(),
-      kCGImageAlphaPremultipliedFirst |
-      kCGBitmapByteOrder32Host));
-  CGContextTranslateCTM(windowless_context_, 0, window_rect.height());
-  CGContextScaleCTM(windowless_context_, 1, -1);
+  if (windowless_dib_.get()) {
+    windowless_context_.reset(CGBitmapContextCreate(
+        windowless_dib_->memory(),
+        window_rect.width(),
+        window_rect.height(),
+        8, 4 * window_rect.width(),
+        mac_util::GetSystemColorSpace(),
+        kCGImageAlphaPremultipliedFirst |
+        kCGBitmapByteOrder32Host));
+    CGContextTranslateCTM(windowless_context_, 0, window_rect.height());
+    CGContextScaleCTM(windowless_context_, 1, -1);
+  } else {
+    windowless_context_.reset();
+  }
   if (background_dib_.get()) {
     background_context_.reset(CGBitmapContextCreate(
         background_dib_->memory(),
         window_rect.width(),
         window_rect.height(),
         8, 4 * window_rect.width(),
         mac_util::GetSystemColorSpace(),
         kCGImageAlphaPremultipliedFirst |
         kCGBitmapByteOrder32Host));
     CGContextTranslateCTM(background_context_, 0, window_rect.height());
     CGContextScaleCTM(background_context_, 1, -1);
+  } else {
+    background_context_.reset();
   }
-}
-
-#elif defined(USE_X11)
-
-void WebPluginProxy::SetWindowlessBuffer(
-    const TransportDIB::Handle& windowless_buffer,
-    const TransportDIB::Handle& background_buffer,
-    const gfx::Rect& window_rect) {
+#else
   int width = window_rect.width();
   int height = window_rect.height();
-  windowless_dib_.reset(TransportDIB::Map(windowless_buffer));
-  if (windowless_dib_.get()) {
-    windowless_canvas_.reset(windowless_dib_->GetPlatformCanvas(width, height));
-  } else {
-    // 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_dib_.reset(TransportDIB::CreateWithHandle(windowless_buffer));
+  background_dib_.reset(TransportDIB::CreateWithHandle(background_buffer));
+  windowless_canvas_.reset(windowless_dib_->GetPlatformCanvas(width, height));
+  background_canvas_.reset(background_dib_->GetPlatformCanvas(width, height));
+  if (!windowless_canvas_.get() || !background_canvas_.get()) {
     windowless_canvas_.reset();
+    background_canvas_.reset();
+    // Destroy the TransportDIB if the canvas was not created successfully.
+    // Otherwise we may have an unnecessary handle which is keeping the shared
+    // memory open.
+    windowless_dib_.reset();
+    background_dib_.reset();
   }
-  background_dib_.reset(TransportDIB::Map(background_buffer));
-  if (background_dib_.get()) {
-    background_canvas_.reset(background_dib_->GetPlatformCanvas(width, height));
-  } else {
-    background_canvas_.reset();
-  }
+#endif
 
+#if defined(USE_X11)
   // 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
 }
 
-#endif
-
 void WebPluginProxy::CancelDocumentLoad() {
   Send(new PluginHostMsg_CancelDocumentLoad(route_id_));
 }
 
 void WebPluginProxy::InitiateHTTPRangeRequest(
     const char* url, const char* range_info, int range_request_id) {
   Send(new PluginHostMsg_InitiateHTTPRangeRequest(
       route_id_, url, range_info, range_request_id));
 }
 
@@ skipping 70 matching lines @@
   while (index != resource_clients_.end()) {
     WebPluginResourceClient* client = (*index).second;
 
     if (client == resource_client) {
       resource_clients_.erase(index++);
     } else {
       index++;
     }
   }
 }