Bar

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 353 matching lines @@
   // which case we do not want to unfocus ourself.
   if (!has_focus_ && webwidget_)
     webwidget_->setFocus(false);
 }
 
 void RenderWidget::PaintRect(const gfx::Rect& rect,
                              const gfx::Point& canvas_origin,
                              skia::PlatformCanvas* canvas) {
   canvas->save();
 
+  //CGContextRef cg_context = canvas->getTopPlatformDevice().GetBitmapContext();
+  //CGContextSaveGState(cg_context);
+  //CGContextScaleCTM(cg_context, 0.2, 0.2);
+
   // Bring the canvas into the coordinate system of the paint rect.
   canvas->translate(static_cast<SkScalar>(-canvas_origin.x()),
                     static_cast<SkScalar>(-canvas_origin.y()));
 
   // If there is a custom background, tile it.
   if (!background_.empty()) {
     SkPaint paint;
     SkShader* shader = SkShader::CreateBitmapShader(background_,
                                                     SkShader::kRepeat_TileMode,
                                                     SkShader::kRepeat_TileMode);
     paint.setShader(shader)->unref();
     paint.setXfermodeMode(SkXfermode::kSrcOver_Mode);
     canvas->drawPaint(paint);
   }
 
   webwidget_->paint(webkit_glue::ToWebCanvas(canvas), rect);
 
   PaintDebugBorder(rect, canvas);
 
   // Flush to underlying bitmap.  TODO(darin): is this needed?
   canvas->getTopPlatformDevice().accessBitmap(false);
 
+  //CGContextRestoreGState(cg_context);
+
   canvas->restore();
 }
 
 void RenderWidget::PaintDebugBorder(const gfx::Rect& rect,
                                     skia::PlatformCanvas* canvas) {
   static bool kPaintBorder =
       CommandLine::ForCurrentProcess()->HasSwitch(switches::kShowPaintRects);
   if (!kPaintBorder)
     return;
 
@@ skipping 329 matching lines @@
 }
 
 void RenderWidget::OnImeConfirmComposition() {
   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 sequence_num,
                                     const gfx::Size& page_size,
                                     const gfx::Size& desired_size) {
   if (!webwidget_ || dib_handle == TransportDIB::DefaultHandleValue())
     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_,
-                                         dib_handle,
+                                         sequence_num,
                                          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));
 
   DCHECK(paint_at_size_buffer.get());
   if (!paint_at_size_buffer.get())
@@ skipping 18 matching lines @@
     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());
 
+  // Add the scale factor to the canvas, so that we'll get the desired size.
+//#if WEBKIT_USING_SKIA
   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));
+//#else
+  // Scaling the canvas would draw at normal size and then scale the pixels
+  // down, so that only the upper left image is filled. Scale CG equivalent
+  // instead.
+// ToWebCanvas: canvas->getTopPlatformDevice().GetBitmapContext();
+// typedef struct CGContext WebCanvas;
+
+// WebKit's WebFrameImpl:
+//    GraphicsContext gc(canvas);
+
+  //CGContextRef cg_context = canvas->getTopPlatformDevice().GetBitmapContext();
+//fprintf(stderr, "context a %f %f: %p\n", x_scale, y_scale, cg_context);
+  //CGContextSaveGState(cg_context);
+  //CGContextScaleCTM(cg_context, x_scale, y_scale);
+
+  //CGContextTranslateCTM(cg_context, 500, 500);
+
+//#endif
 
   // Have to make sure we're laid out at the right size before
   // rendering.
   gfx::Size old_size = webwidget_->size();
   webwidget_->resize(page_size);
   webwidget_->layout();
 
   // Paint the entire thing (using original bounds, not scaled bounds).
+//orig_bounds.set_width(orig_bounds.width() / x_scale);
+//orig_bounds.set_height(orig_bounds.height() / y_scale);
   PaintRect(orig_bounds, orig_bounds.origin(), canvas.get());
+//#if WEBKIT_USING_SKIA
   canvas->restore();
+//#else
+  //CGContextRestoreGState(cg_context);
+//#endif
 
   // Return the widget to its previous size.
   webwidget_->resize(old_size);
 
-  Send(new ViewHostMsg_PaintAtSize_ACK(routing_id_, dib_handle, bounds.size()));
+  Send(new ViewHostMsg_PaintAtSize_ACK(
+      routing_id_, sequence_num, 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 105 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;
     }
   }
 }