Remove GraphicsContext::applyDeviceScaleFactor()

Source/web/PageWidgetDelegate.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 49 matching lines @@
 {
     page.animator().updateLayoutAndStyleForPainting(&root);
 }
 
 void PageWidgetDelegate::paint(Page& page, PageOverlayList* overlays, WebCanvas* canvas, const WebRect& rect, CanvasBackground background, LocalFrame& root)
 {
     if (rect.isEmpty())
         return;
     GraphicsContext gc(canvas);
     gc.setCertainlyOpaque(background == Opaque);
-    gc.applyDeviceScaleFactor(page.deviceScaleFactor());
-    gc.setDeviceScaleFactor(page.deviceScaleFactor());

[f(malita), 2014/11/14 03:24:56]

This looks weird: the device scale factor is supposed to convey a supplemental
scale not reflected in the CTM; scaling AND setting a DSF doesn't smell right.

Just a thought, probably better to not stir it up :)

[Stephen Chennney, 2014/11/14 15:26:22]

It's does what it was designed to do, but that may not be right. The code needs
to both apply the factor, and tell GraphicsContext what that factor was.
GraphicsContext then uses the deviceScaleFactior in two other drawing ops.

The interesting question is: why use that scale factor in other ops if it is
already baked into the transform.

I think the GraphicsContext::drawPicture usage is just plain wrong (because you
still can't determine if it will be rasterized at 1-1 size, and even if you
ignore that, you should be dividing by the scale, not multiplying).

The marker drawing code that uses it is correct in that it makes use of the
device scale to generate higher res markers, then it unapplies the
deviceScaleFactor before drawing. Effectively it is trying to draw something the
same visual size but with higher resolution if the device scale factor is
higher. This code will break if we ever have high device scale factors.

+    float scaleFactor = page.deviceScaleFactor();
+    gc.scale(scaleFactor, scaleFactor);
+    gc.setDeviceScaleFactor(scaleFactor);
     IntRect dirtyRect(rect);
     gc.save(); // Needed to save the canvas, not the GraphicsContext.
     FrameView* view = root.view();
     if (view) {
         gc.clip(dirtyRect);
         view->paint(&gc, dirtyRect);
         if (overlays)
             overlays->paintWebFrame(gc);
     } else {
         gc.fillRect(dirtyRect, Color::white);
@@ skipping 108 matching lines @@
 {
     return mainFrame.eventHandler().handleWheelEvent(PlatformWheelEventBuilder(mainFrame.view(), event));
 }
 
 bool PageWidgetEventHandler::handleTouchEvent(LocalFrame& mainFrame, const WebTouchEvent& event)
 {
     return mainFrame.eventHandler().handleTouchEvent(PlatformTouchEventBuilder(mainFrame.view(), event));
 }
 
 } // namespace blink