This adds in the ability for Chrome to generate windows with snapshots of all...

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 131 matching lines @@
   IPC_MESSAGE_HANDLER(ViewMsg_WasHidden, OnWasHidden)
   IPC_MESSAGE_HANDLER(ViewMsg_WasRestored, OnWasRestored)
   IPC_MESSAGE_HANDLER(ViewMsg_UpdateRect_ACK, OnUpdateRectAck)
   IPC_MESSAGE_HANDLER(ViewMsg_CreateVideo_ACK, OnCreateVideoAck)
   IPC_MESSAGE_HANDLER(ViewMsg_UpdateVideo_ACK, OnUpdateVideoAck)
   IPC_MESSAGE_HANDLER(ViewMsg_HandleInputEvent, OnHandleInputEvent)
   IPC_MESSAGE_HANDLER(ViewMsg_MouseCaptureLost, OnMouseCaptureLost)
   IPC_MESSAGE_HANDLER(ViewMsg_SetFocus, OnSetFocus)
   IPC_MESSAGE_HANDLER(ViewMsg_ImeSetInputMode, OnImeSetInputMode)
   IPC_MESSAGE_HANDLER(ViewMsg_ImeSetComposition, OnImeSetComposition)
+  IPC_MESSAGE_HANDLER(ViewMsg_PaintAtSize, OnMsgPaintAtSize)
   IPC_MESSAGE_HANDLER(ViewMsg_Repaint, OnMsgRepaint)
   IPC_MESSAGE_HANDLER(ViewMsg_SetTextDirection, OnSetTextDirection)
   IPC_MESSAGE_HANDLER(ViewMsg_Move_ACK, OnRequestMoveAck)
   IPC_MESSAGE_UNHANDLED_ERROR()
 IPC_END_MESSAGE_MAP()
 
 bool RenderWidget::Send(IPC::Message* message) {
   // Don't send any messages after the browser has told us to close.
   if (closing_) {
     delete message;
@@ skipping 81 matching lines @@
   if (!webwidget_)
     return;
 
   // See OnWasHidden
   SetHidden(false);
 
   if (!needs_repainting && !needs_repainting_on_restore_)
     return;
   needs_repainting_on_restore_ = false;
 
-  // Tag the next paint as a restore ack, which is picked up by DoDeferredUpdate
-  // when it sends out the next PaintRect message.
+  // Tag the next paint as a restore ack, which is picked up by
+  // DoDeferredUpdate when it sends out the next PaintRect message.
   set_next_paint_is_restore_ack();
 
   // Generate a full repaint.
   didInvalidateRect(gfx::Rect(size_.width(), size_.height()));
 }
 
 void RenderWidget::OnRequestMoveAck() {
   DCHECK(pending_window_rect_count_);
   pending_window_rect_count_--;
 }
 
 void RenderWidget::OnUpdateRectAck() {
   DCHECK(update_reply_pending());
   update_reply_pending_ = false;
 
   // If we sent an UpdateRect message with a zero-sized bitmap, then we should
-  // have no current update buf.
+  // have no current paint buffer.
   if (current_paint_buf_) {
     RenderProcess::current()->ReleaseTransportDIB(current_paint_buf_);
     current_paint_buf_ = NULL;
   }
 
   // Notify subclasses.
   DidFlushPaint();
 
   // Continue painting if necessary...
   CallDoDeferredUpdate();
@@ skipping 431 matching lines @@
   if (!webwidget_->handleCompositionEvent(command, cursor_position,
       target_start, target_end, ime_string)) {
     // If the composition event can't be handled, let the browser process
     // know so it can update it's state.
     Send(new ViewHostMsg_ImeUpdateStatus(routing_id(), IME_CANCEL_COMPOSITION,
                                          WebRect()));
   }
   ime_control_busy_ = false;
 }
 
+// Forces a repaint even if we're hidden, so we can update backing
+// store even before a tab has been shown for the first time, and it
+// does it synchronously.
+void RenderWidget::OnMsgPaintAtSize(const TransportDIB::Handle& dib_handle,
+                                    const gfx::Size& desired_size) {
+  if (!webwidget_ || dib_handle == TransportDIB::DefaultHandleValue())
+    return;
+
+  if (webwidget_->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_,
+                                         dib_handle,
+                                         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_scale_buffer(TransportDIB::Map(dib_handle));
+
+  DCHECK(paint_at_scale_buffer.get());
+  if (!paint_at_scale_buffer.get())
+    return;
+
+  // Have to make sure we're laid out before rendering.
+  webwidget_->layout();
+
+  gfx::Size canvas_size = webwidget_->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(gfx::Point(0,0), 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(gfx::Point(0,0), canvas_size);
+
+  scoped_ptr<skia::PlatformCanvas> canvas(
+      paint_at_scale_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 what we expect.
+  canvas->scale(SkFloatToScalar(x_scale), SkFloatToScalar(y_scale));
+
+  // Paint the entire thing (using original bounds, not scaled bounds).
+  PaintRect(orig_bounds, orig_bounds.origin(), canvas.get());
+  canvas->restore();
+
+  Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, dib_handle, bounds.size()));
+}
+
 void RenderWidget::OnMsgRepaint(const gfx::Size& size_to_paint) {
   // During shutdown we can just ignore this message.
   if (!webwidget_)
     return;
 
   set_next_paint_is_repaint_ack();
   gfx::Rect repaint_rect(size_to_paint.width(), size_to_paint.height());
   didInvalidateRect(repaint_rect);
 }
 
@@ skipping 138 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;
     }
   }
 }
-