Bitmap transport

chrome/renderer/render_widget.cc

 // Copyright (c) 2006-2008 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 "base/gfx/point.h"
 #include "base/gfx/size.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "base/scoped_ptr.h"
 #include "build/build_config.h"
 #include "chrome/common/render_messages.h"
+#include "chrome/common/transport_dib.h"
 #include "chrome/renderer/render_process.h"
 #include "skia/ext/platform_canvas.h"
 
 #if defined(OS_POSIX)
 #include "skia/include/SkPixelRef.h"
 #include "skia/include/SkMallocPixelRef.h"
 #endif  // defined(OS_POSIX)
 
 #include "webkit/glue/webinputevent.h"
 #include "webkit/glue/webwidget.h"
@@ skipping 73 matching lines @@
       ime_control_updated_(false),
       ime_control_busy_(false),
       activatable_(activatable) {
   RenderProcess::AddRefProcess();
   DCHECK(render_thread_);
 }
 
 RenderWidget::~RenderWidget() {
   DCHECK(!webwidget_) << "Leaking our WebWidget!";
   if (current_paint_buf_) {
-    RenderProcess::FreeSharedMemory(current_paint_buf_);
+    RenderProcess::ReleaseTransportDIB(current_paint_buf_);
     current_paint_buf_ = NULL;
   }
   if (current_scroll_buf_) {
-    RenderProcess::FreeSharedMemory(current_scroll_buf_);
+    RenderProcess::ReleaseTransportDIB(current_scroll_buf_);
     current_scroll_buf_ = NULL;
   }
   RenderProcess::ReleaseProcess();
 }
 
 /*static*/
 RenderWidget* RenderWidget::Create(int32 opener_id,
                                    RenderThreadBase* render_thread,
                                    bool activatable) {
   DCHECK(opener_id != MSG_ROUTING_NONE);
@@ skipping 168 matching lines @@
   // Generate a full repaint.
   DidInvalidateRect(webwidget_, gfx::Rect(size_.width(), size_.height()));
 }
 
 void RenderWidget::OnPaintRectAck() {
   DCHECK(paint_reply_pending());
   paint_reply_pending_ = false;
   // If we sent a PaintRect message with a zero-sized bitmap, then
   // we should have no current paint buf.
   if (current_paint_buf_) {
-    RenderProcess::FreeSharedMemory(current_paint_buf_);
+    RenderProcess::ReleaseTransportDIB(current_paint_buf_);
     current_paint_buf_ = NULL;
   }
+
   // Continue painting if necessary...
   DoDeferredPaint();
 }
 
 void RenderWidget::OnScrollRectAck() {
-#if defined(OS_WIN)
   DCHECK(scroll_reply_pending());
 
-  RenderProcess::FreeSharedMemory(current_scroll_buf_);
-  current_scroll_buf_ = NULL;
-#endif
+  if (current_scroll_buf_) {
+    RenderProcess::ReleaseTransportDIB(current_scroll_buf_);
+    current_scroll_buf_ = NULL;
+  }
 
   // Continue scrolling if necessary...
   DoDeferredScroll();
 }
 
 void RenderWidget::OnHandleInputEvent(const IPC::Message& message) {
   void* iter = NULL;
 
   const char* data;
   int data_length;
@@ skipping 48 matching lines @@
 
   webwidget_->Paint(canvas, rect);
 
   // Flush to underlying bitmap.  TODO(darin): is this needed?
   canvas->getTopPlatformDevice().accessBitmap(false);
 
   // Let the subclass observe this paint operations.
   DidPaint();
 }
 
-// static
-size_t RenderWidget::GetPaintBufSize(const gfx::Rect& rect) {
-  // TODO(darin): protect against overflow
-  const size_t stride = skia::PlatformCanvas::StrideForWidth(rect.width());
-  return stride * rect.height();
-}
-
 void RenderWidget::DoDeferredPaint() {
   if (!webwidget_ || paint_reply_pending() || paint_rect_.IsEmpty())
     return;
 
   // When we are hidden, we want to suppress painting, but we still need to
   // mark this DoDeferredPaint as complete.
   if (is_hidden_ || size_.IsEmpty()) {
     paint_rect_ = gfx::Rect();
     needs_repainting_on_restore_ = true;
     return;
   }
 
   // Layout may generate more invalidation...
   webwidget_->Layout();
 
   // OK, save the current paint_rect to a local since painting may cause more
   // invalidation.  Some WebCore rendering objects only layout when painted.
   gfx::Rect damaged_rect = paint_rect_;
   paint_rect_ = gfx::Rect();
 
   // Compute a buffer for painting and cache it.
-#if defined(OS_WIN)
-  current_paint_buf_ =
-      RenderProcess::AllocSharedMemory(GetPaintBufSize(damaged_rect));
-  if (!current_paint_buf_) {
+  skia::PlatformCanvas* canvas =
+      RenderProcess::GetDrawingCanvas(&current_paint_buf_, damaged_rect);
+  if (!canvas) {
     NOTREACHED();
     return;
   }
-  skia::PlatformCanvasWin canvas(damaged_rect.width(), damaged_rect.height(),
-                                 true, current_paint_buf_->handle());
-#elif defined(OS_POSIX)
-  // Currently, on POSIX, we are serialising the bitmap data over the IPC
-  // channel.
-  skia::PlatformCanvas canvas(damaged_rect.width(), damaged_rect.height(),
-                              true);
-#endif  // defined(OS_POSIX)
 
-  PaintRect(damaged_rect, &canvas);
+  PaintRect(damaged_rect, canvas);
 
   ViewHostMsg_PaintRect_Params params;
   params.bitmap_rect = damaged_rect;
   params.view_size = size_;
   params.plugin_window_moves = plugin_window_moves_;
   params.flags = next_paint_flags_;
+  params.bitmap = current_paint_buf_->id();
 
-#if defined(OS_WIN)
-  // Windows passes a HANDLE to the shared memory over IPC
-  params.bitmap = current_paint_buf_->handle();
-#elif defined(OS_POSIX)
-  // POSIX currently passes the data itself.
-  params.bitmap = canvas.getDevice()->accessBitmap(false);
-#endif  // defined(OS_WIN)
+  delete canvas;
 
   plugin_window_moves_.clear();
 
   paint_reply_pending_ = true;
   Send(new ViewHostMsg_PaintRect(routing_id_, params));
   next_paint_flags_ = 0;
 
   UpdateIME();
 }
 
@@ skipping 40 matching lines @@
       damaged_rect.set_height(dy);
     } else {
       damaged_rect.set_y(scroll_rect_.bottom() + dy);
       damaged_rect.set_height(-dy);
     }
   }
 
   // In case the scroll offset exceeds the width/height of the scroll rect
   damaged_rect = scroll_rect_.Intersect(damaged_rect);
 
-#if defined(OS_WIN)
-  current_scroll_buf_ =
-      RenderProcess::AllocSharedMemory(GetPaintBufSize(damaged_rect));
-  if (!current_scroll_buf_) {
+  skia::PlatformCanvas* canvas =
+      RenderProcess::GetDrawingCanvas(&current_scroll_buf_, damaged_rect);
+  if (!canvas) {
     NOTREACHED();
     return;
   }
-  skia::PlatformCanvasWin canvas(damaged_rect.width(), damaged_rect.height(),
-                                 true, current_scroll_buf_->handle());
-#elif defined(OS_POSIX)
-  // Currently, on POSIX, we are serialising the bitmap data over the IPC
-  // channel.
-  skia::PlatformCanvas canvas(damaged_rect.width(), damaged_rect.height(),
-                              true);
-#endif  // defined(OS_POSIX)
 
   // Set these parameters before calling Paint, since that could result in
   // further invalidates (uncommon).
   ViewHostMsg_ScrollRect_Params params;
   params.bitmap_rect = damaged_rect;
   params.dx = scroll_delta_.x();
   params.dy = scroll_delta_.y();
   params.clip_rect = scroll_rect_;
   params.view_size = size_;
   params.plugin_window_moves = plugin_window_moves_;
-
-#if defined(OS_WIN)
-  // Windows passes a HANDLE to the shared memory over IPC
-  params.bitmap = current_scroll_buf_->handle();
-#elif defined(OS_POSIX)
-  // POSIX currently passes the data itself.
-  params.bitmap = canvas.getDevice()->accessBitmap(false);
-#endif  // defined(OS_WIN)
+  params.bitmap = current_scroll_buf_->id();
 
   plugin_window_moves_.clear();
 
   // Mark the scroll operation as no longer pending.
   scroll_rect_ = gfx::Rect();
 
-  PaintRect(damaged_rect, &canvas);
+  PaintRect(damaged_rect, canvas);
   Send(new ViewHostMsg_ScrollRect(routing_id_, params));
+  delete canvas;
   UpdateIME();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // WebWidgetDelegate
 
 gfx::NativeViewId RenderWidget::GetContainingView(WebWidget* webwidget) {
   return host_window_;
 }
 
@@ skipping 282 matching lines @@
   for (; i < plugin_window_moves_.size(); ++i) {
     if (plugin_window_moves_[i].window == move.window) {
       plugin_window_moves_[i] = move;
       break;
     }
   }
 
   if (i == plugin_window_moves_.size())
     plugin_window_moves_.push_back(move);
 }