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

chrome/renderer/render_widget.cc

 // Copyright (c) 2010 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/render_widget.h"
 
 #include "app/surface/transport_dib.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
@@ skipping 490 matching lines @@
   // invalidation.  Some WebCore rendering objects only layout when painted.
   PaintAggregator::PendingUpdate update = paint_aggregator_.GetPendingUpdate();
   paint_aggregator_.ClearPendingUpdate();
 
   gfx::Rect scroll_damage = update.GetScrollDamage();
   gfx::Rect bounds = update.GetPaintBounds().Union(scroll_damage);
 
   // A plugin may be able to do an optimized paint. First check this, in which
   // case we can skip all of the bitmap generation and regular paint code.
   TransportDIB::Id dib_id = TransportDIB::Id();
+  TransportDIB::Handle dib_handle = TransportDIB::DefaultHandleValue();
   TransportDIB* dib = NULL;
   std::vector<gfx::Rect> copy_rects;
   gfx::Rect optimized_copy_rect, optimized_copy_location;
   if (update.scroll_rect.IsEmpty() &&
       !is_gpu_rendering_active_ &&
       GetBitmapForOptimizedPluginPaint(bounds, &dib, &optimized_copy_location,
                                        &optimized_copy_rect)) {
     bounds = optimized_copy_location;
     copy_rects.push_back(optimized_copy_rect);
     dib_id = dib->id();
+    dib_handle = dib->handle();
   } else if (!is_gpu_rendering_active_) {
     // Compute a buffer for painting and cache it.
     scoped_ptr<skia::PlatformCanvas> canvas(
         RenderProcess::current()->GetDrawingCanvas(&current_paint_buf_,
                                                    bounds));
     if (!canvas.get()) {
       NOTREACHED();
       return;
     }
 
@@ skipping 15 matching lines @@
 
     // The scroll damage is just another rectangle to paint and copy.
     copy_rects.swap(update.paint_rects);
     if (!scroll_damage.IsEmpty())
       copy_rects.push_back(scroll_damage);
 
     for (size_t i = 0; i < copy_rects.size(); ++i)
       PaintRect(copy_rects[i], bounds.origin(), canvas.get());
 
     dib_id = current_paint_buf_->id();
+    dib_handle = current_paint_buf_->handle();
   } else {  // Accelerated compositing path
     // Begin painting.
     bool finish = next_paint_is_resize_ack();
     webwidget_->composite(finish);
   }
 
   // sending an ack to browser process that the paint is complete...
   ViewHostMsg_UpdateRect_Params params;
-  params.bitmap = dib_id;
+  params.dib_id = dib_id;
+  params.dib_handle = dib_handle;
   params.bitmap_rect = bounds;
   params.dx = update.scroll_delta.x();
   params.dy = update.scroll_delta.y();
   if (is_gpu_rendering_active_) {
     // If painting is done via the gpu process then we clear out all damage
     // rects to save the browser process from doing unecessary work.
     params.scroll_rect = gfx::Rect();
     params.copy_rects.clear();
   } else {
     params.scroll_rect = update.scroll_rect;
@@ skipping 237 matching lines @@
   if (webwidget_)
     webwidget_->confirmComposition();
 }
 
 // This message causes the renderer to render an image of the
 // desired_size, regardless of whether the tab is hidden or not.
 void RenderWidget::OnMsgPaintAtSize(const TransportDIB::Handle& dib_handle,
                                     int tag,
                                     const gfx::Size& page_size,
                                     const gfx::Size& desired_size) {
-  if (!webwidget_ || dib_handle == TransportDIB::DefaultHandleValue())
+  TransportDIB::ScopedHandle scoped_dib_handle(dib_handle);
+  if (!webwidget_ || !TransportDIB::is_valid(dib_handle))
     return;
 
   if (page_size.IsEmpty() || desired_size.IsEmpty()) {
     // If one of these is empty, then we just return the dib we were
     // given, to avoid leaking it.
     Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, tag, desired_size));
     return;
   }
 
   // Map the given DIB ID into this process, and unmap it at the end
   // of this function.
-  scoped_ptr<TransportDIB> paint_at_size_buffer(TransportDIB::Map(dib_handle));
+  scoped_ptr<TransportDIB> paint_at_size_buffer(
+      TransportDIB::CreateWithHandle(scoped_dib_handle.release()));
+  gfx::Size canvas_size = page_size;
+  scoped_ptr<skia::PlatformCanvas> canvas(
+      paint_at_size_buffer->GetPlatformCanvas(canvas_size.width(),
+                                              canvas_size.height()));
+  if (!canvas.get()) {
+    NOTREACHED();
+    return;
+  }
 
-  DCHECK(paint_at_size_buffer.get());
-  if (!paint_at_size_buffer.get())
-    return;
-
-  gfx::Size canvas_size = page_size;
   float x_scale = static_cast<float>(desired_size.width()) /
                   static_cast<float>(canvas_size.width());
   float y_scale = static_cast<float>(desired_size.height()) /
                   static_cast<float>(canvas_size.height());
 
   gfx::Rect orig_bounds(canvas_size);
   canvas_size.set_width(static_cast<int>(canvas_size.width() * x_scale));
   canvas_size.set_height(static_cast<int>(canvas_size.height() * y_scale));
   gfx::Rect bounds(canvas_size);
 
-  scoped_ptr<skia::PlatformCanvas> canvas(
-      paint_at_size_buffer->GetPlatformCanvas(canvas_size.width(),
-                                              canvas_size.height()));
-  if (!canvas.get()) {
-    NOTREACHED();
-    return;
-  }
-
   // Reset bounds to what we actually received, but they should be the
   // same.
   DCHECK_EQ(bounds.width(), canvas->getDevice()->width());
   DCHECK_EQ(bounds.height(), canvas->getDevice()->height());
   bounds.set_width(canvas->getDevice()->width());
   bounds.set_height(canvas->getDevice()->height());
 
   canvas->save();
   // Add the scale factor to the canvas, so that we'll get the desired size.
   canvas->scale(SkFloatToScalar(x_scale), SkFloatToScalar(y_scale));
@@ skipping 144 matching lines @@
 
 void RenderWidget::CleanupWindowInPluginMoves(gfx::PluginWindowHandle window) {
   for (WebPluginGeometryVector::iterator i = plugin_window_moves_.begin();
        i != plugin_window_moves_.end(); ++i) {
     if (i->window == window) {
       plugin_window_moves_.erase(i);
       break;
     }
   }
 }