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

chrome/browser/renderer_host/backing_store_win.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/browser/renderer_host/backing_store_win.h"
 
 #include "app/surface/transport_dib.h"
 #include "base/command_line.h"
 #include "chrome/browser/renderer_host/render_process_host.h"
 #include "chrome/browser/renderer_host/render_widget_host.h"
@@ skipping 51 matching lines @@
     rv = StretchDIBits(hdc,
                        dest_x, dest_y, dest_w, dest_h,
                        src_x, bottom_up_src_y, src_w, src_h,
                        pixels, bitmap_info, DIB_RGB_COLORS, SRCCOPY);
   }
   DCHECK(rv != GDI_ERROR);
 }
 
 }  // namespace
 
-BackingStoreWin::BackingStoreWin(RenderWidgetHost* widget, const gfx::Size& size)
+BackingStoreWin::BackingStoreWin(RenderWidgetHost* widget,
+                                 const gfx::Size& size)
     : BackingStore(widget, size),
       backing_store_dib_(NULL),
       original_bitmap_(NULL) {
   HDC screen_dc = ::GetDC(NULL);
   color_depth_ = ::GetDeviceCaps(screen_dc, BITSPIXEL);
   // Color depths less than 16 bpp require a palette to be specified. Instead,
   // we specify the desired color depth as 16 which lets the OS to come up
   // with an approximation.
   if (color_depth_ < 16)
     color_depth_ = 16;
@@ skipping 24 matching lines @@
   }
   return enabled;
 }
 
 size_t BackingStoreWin::MemorySize() {
   return size().GetArea() * (color_depth_ / 8);
 }
 
 void BackingStoreWin::PaintToBackingStore(
     RenderProcessHost* process,
-    TransportDIB::Id bitmap,
+    TransportDIB::Id dib_id,
+    TransportDIB::Handle dib_handle,
     const gfx::Rect& bitmap_rect,
     const std::vector<gfx::Rect>& copy_rects,
     bool* painted_synchronously) {
+  TransportDIB::ScopedHandle scoped_dib_handle(dib_handle);
   // Our paints are always synchronous and the TransportDIB can be freed when
   // we're done (even on error).
   *painted_synchronously = true;
 
   if (!backing_store_dib_) {
     backing_store_dib_ = CreateDIB(hdc_, size().width(),
                                    size().height(), color_depth_);
     if (!backing_store_dib_) {
       NOTREACHED();
       return;
     }
     original_bitmap_ = SelectObject(hdc_, backing_store_dib_);
   }
 
-  TransportDIB* dib = process->GetTransportDIB(bitmap);
+  TransportDIB* dib = process->GetTransportDIB(dib_id,
+                                               scoped_dib_handle.release());
   if (!dib)
     return;
 
   BITMAPINFOHEADER hdr;
   gfx::CreateBitmapHeader(bitmap_rect.width(), bitmap_rect.height(), &hdr);
   // Account for a bitmap_rect that exceeds the bounds of our view
   gfx::Rect view_rect(size());
 
   for (size_t i = 0; i < copy_rects.size(); i++) {
     gfx::Rect paint_rect = view_rect.Intersect(copy_rects[i]);
@@ skipping 25 matching lines @@
 
 void BackingStoreWin::ScrollBackingStore(int dx, int dy,
                                          const gfx::Rect& clip_rect,
                                          const gfx::Size& view_size) {
   RECT damaged_rect, r = clip_rect.ToRECT();
   ScrollDC(hdc_, dx, dy, NULL, &r, NULL, &damaged_rect);
 
   // TODO(darin): this doesn't work if dx and dy are both non-zero!
   DCHECK(dx == 0 || dy == 0);
 }