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

chrome/browser/renderer_host/render_widget_host.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/render_widget_host.h"
 
 #include "app/keyboard_codes.h"
 #include "base/auto_reset.h"
 #include "base/command_line.h"
 #include "base/message_loop.h"
@@ skipping 745 matching lines @@
 }
 
 void RenderWidgetHost::OnMsgPaintAtSizeAck(int tag, const gfx::Size& size) {
   if (painting_observer_) {
     painting_observer_->WidgetDidReceivePaintAtSizeAck(this, tag, size);
   }
 }
 
 void RenderWidgetHost::OnMsgUpdateRect(
     const ViewHostMsg_UpdateRect_Params& params) {
+  TransportDIB::ScopedHandle dib_handle(params.dib_handle);
   TimeTicks paint_start = TimeTicks::Now();
 
   if (paint_observer_.get())
     paint_observer_->RenderWidgetHostWillPaint(this);
 
   // Update our knowledge of the RenderWidget's size.
   current_size_ = params.view_size;
 
   bool is_resize_ack =
       ViewHostMsg_UpdateRect_Flags::is_resize_ack(params.flags);
@@ skipping 14 matching lines @@
     UMA_HISTOGRAM_TIMES("MPArch.RWH_RepaintDelta", delta);
   }
 
   DCHECK(!params.bitmap_rect.IsEmpty());
   DCHECK(!params.view_size.IsEmpty());
 
   bool painted_synchronously = true;  // Default to sending a paint ACK below.
   if (!is_gpu_rendering_active_) {
     const size_t size = params.bitmap_rect.height() *
         params.bitmap_rect.width() * 4;
-    TransportDIB* dib = process_->GetTransportDIB(params.bitmap);
+    TransportDIB* dib = process_->GetTransportDIB(params.dib_id,
+                                                  dib_handle.release());
 
     // If gpu process does painting, scroll_rect and copy_rects are always empty
     // and backing store is never used.
     if (dib) {
       if (dib->size() < size) {
         DLOG(WARNING) << "Transport DIB too small for given rectangle";
         process()->ReceivedBadMessage(ViewHostMsg_UpdateRect__ID);
       } else {
         // Scroll the backing store.
         if (!params.scroll_rect.IsEmpty()) {
           ScrollBackingStoreRect(params.dx, params.dy,
                                  params.scroll_rect,
                                  params.view_size);
         }
 
         // Paint the backing store. This will update it with the
         // renderer-supplied bits. The view will read out of the backing store
         // later to actually draw to the screen.
-        PaintBackingStoreRect(params.bitmap, params.bitmap_rect,
-                              params.copy_rects, params.view_size,
+        PaintBackingStoreRect(params.dib_id,
+                              params.dib_handle,
+                              params.bitmap_rect,
+                              params.copy_rects,
+                              params.view_size,
                               &painted_synchronously);
       }
     }
   }
 
   // ACK early so we can prefetch the next PaintRect if there is a next one.
   // This must be done AFTER we're done painting with the bitmap supplied by the
   // renderer. This ACK is a signal to the renderer that the backing store can
   // be re-used, so the bitmap may be invalid after this call. If the backing
   // store is painting asynchronously, it will manage issuing this IPC.
@@ skipping 43 matching lines @@
 
 void RenderWidgetHost::OnMsgCreateVideo(const gfx::Size& size) {
   DCHECK(!video_layer_.get());
 
   video_layer_.reset(view_->AllocVideoLayer(size));
 
   // TODO(scherkus): support actual video ids!
   Send(new ViewMsg_CreateVideo_ACK(routing_id_, -1));
 }
 
-void RenderWidgetHost::OnMsgUpdateVideo(TransportDIB::Id bitmap,
+void RenderWidgetHost::OnMsgUpdateVideo(TransportDIB::Id dib_id,
+                                        TransportDIB::Handle dib_handle,
                                         const gfx::Rect& bitmap_rect) {
-  PaintVideoLayer(bitmap, bitmap_rect);
+  PaintVideoLayer(dib_id, dib_handle, bitmap_rect);
 
   // TODO(scherkus): support actual video ids!
   Send(new ViewMsg_UpdateVideo_ACK(routing_id_, -1));
 }
 
 void RenderWidgetHost::OnMsgDestroyVideo() {
   video_layer_.reset();
 }
 
 void RenderWidgetHost::OnMsgInputEventAck(const IPC::Message& message) {
@@ skipping 145 matching lines @@
   if (view_) {
     view_->AcceleratedSurfaceSetIOSurface(window, width, height, mach_port);
   }
 }
 
 void RenderWidgetHost::OnAcceleratedSurfaceSetTransportDIB(
     gfx::PluginWindowHandle window,
     int32 width,
     int32 height,
     TransportDIB::Handle transport_dib) {
+  TransportDIB::ScopedHandle scoped_dib_handle(transport_dib);
   if (view_) {
     view_->AcceleratedSurfaceSetTransportDIB(window, width, height,
-                                             transport_dib);
+                                             scoped_dib_handle.release());
   }
 }
 
 void RenderWidgetHost::OnAcceleratedSurfaceBuffersSwapped(
     gfx::PluginWindowHandle window) {
   if (view_) {
     view_->AcceleratedSurfaceBuffersSwapped(window);
   }
 }
 #elif defined(OS_POSIX)
@@ skipping 13 matching lines @@
   if (view_) {
     view_->DestroyPluginContainer(id);
   } else {
     NOTIMPLEMENTED();
   }
 }
 
 #endif
 
 void RenderWidgetHost::PaintBackingStoreRect(
-    TransportDIB::Id bitmap,
+    TransportDIB::Id dib_id,
+    TransportDIB::Handle dib_handle,
     const gfx::Rect& bitmap_rect,
     const std::vector<gfx::Rect>& copy_rects,
     const gfx::Size& view_size,
     bool* painted_synchronously) {
   // On failure, we need to be sure our caller knows we're done with the
   // backing store.
   *painted_synchronously = true;
 
   // The view may be destroyed already.
   if (!view_)
     return;
 
   if (is_hidden_) {
     // Don't bother updating the backing store when we're hidden. Just mark it
     // as being totally invalid. This will cause a complete repaint when the
     // view is restored.
     needs_repainting_on_restore_ = true;
     return;
   }
 
   bool needs_full_paint = false;
-  BackingStoreManager::PrepareBackingStore(this, view_size, bitmap, bitmap_rect,
-                                           copy_rects, &needs_full_paint,
+  BackingStoreManager::PrepareBackingStore(this,
+                                           view_size,
+                                           dib_id,
+                                           dib_handle,
+                                           bitmap_rect,
+                                           copy_rects,
+                                           &needs_full_paint,
                                            painted_synchronously);
   if (needs_full_paint) {
     repaint_start_time_ = TimeTicks::Now();
     repaint_ack_pending_ = true;
     Send(new ViewMsg_Repaint(routing_id_, view_size));
   }
 }
 
 void RenderWidgetHost::ScrollBackingStoreRect(int dx, int dy,
                                               const gfx::Rect& clip_rect,
                                               const gfx::Size& view_size) {
   if (is_hidden_) {
     // Don't bother updating the backing store when we're hidden. Just mark it
     // as being totally invalid. This will cause a complete repaint when the
     // view is restored.
     needs_repainting_on_restore_ = true;
     return;
   }
 
   // TODO(darin): do we need to do something else if our backing store is not
   // the same size as the advertised view?  maybe we just assume there is a
   // full paint on its way?
   BackingStore* backing_store = BackingStoreManager::Lookup(this);
   if (!backing_store || (backing_store->size() != view_size))
     return;
   backing_store->ScrollBackingStore(dx, dy, clip_rect, view_size);
 }
 
-void RenderWidgetHost::PaintVideoLayer(TransportDIB::Id bitmap,
+void RenderWidgetHost::PaintVideoLayer(TransportDIB::Id dib_id,
+                                       TransportDIB::Handle dib_handle,
                                        const gfx::Rect& bitmap_rect) {
   if (is_hidden_ || !video_layer_.get())
     return;
 
-  video_layer_->CopyTransportDIB(process(), bitmap, bitmap_rect);
+  video_layer_->CopyTransportDIB(process(), dib_id, dib_handle, bitmap_rect);
 
   // Don't update the view if we're hidden or if the view has been destroyed.
   if (is_hidden_ || !view_)
     return;
 
   // Trigger a paint for the updated video layer bitmap.
   std::vector<gfx::Rect> copy_rects;
   copy_rects.push_back(bitmap_rect);
 
   view_being_painted_ = true;
@@ skipping 69 matching lines @@
     // of this key event.
     if (!processed && !is_hidden_ && !front_item.skip_in_browser) {
       UnhandledKeyboardEvent(front_item);
 
       // WARNING: This RenderWidgetHost can be deallocated at this point
       // (i.e.  in the case of Ctrl+W, where the call to
       // UnhandledKeyboardEvent destroys this RenderWidgetHost).
     }
   }
 }