Fix zoom in CSS paint worklets

third_party/WebKit/Source/modules/csspaint/CSSPaintDefinition.cpp

 // Copyright 2016 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 "modules/csspaint/CSSPaintDefinition.h"
 
 #include "bindings/core/v8/ScriptState.h"
 #include "bindings/core/v8/V8Binding.h"
 #include "bindings/core/v8/V8BindingMacros.h"
 #include "bindings/core/v8/V8ObjectConstructor.h"
 #include "core/css/CSSComputedStyleDeclaration.h"
 #include "core/css/cssom/FilteredComputedStylePropertyMap.h"
 #include "core/dom/ExecutionContext.h"
 #include "core/layout/LayoutObject.h"
 #include "modules/csspaint/PaintRenderingContext2D.h"
 #include "modules/csspaint/PaintSize.h"
 #include "platform/graphics/ImageBuffer.h"
 #include "platform/graphics/PaintGeneratedImage.h"
 #include "platform/graphics/RecordingImageBufferSurface.h"
 #include "wtf/PtrUtil.h"
 
 namespace blink {
 
+namespace {
+
+IntSize adjustToCssSize(const IntSize& size, float zoom)

[Justin Novosad, 2016/07/04 15:45:59]

This name is confusing IMHO. My understanding is that the 'size' argument is the
CSS size, and that we are unzooming it to get some sort of intrinsic size.  The
name suggests the opposite.

[Gleb Lanbin, 2016/07/06 20:36:18]

done, renamed to getSpecifiedSize, according to Object-Sizing Terminology
https://drafts.csswg.org/css-images-3/#sizing-terms, i.e. "...The specified size
of an object is given by CSS, such as through the width and height..."

+{
+    IntSize newSize(size);
+    newSize.scale(1 / zoom);

[Justin Novosad, 2016/07/04 15:45:59]

Due to floating-point precision issues, this arithmetic is not guaranteed to
give the pre-zoom size.  In particular, the results are quite likely to be off
by one since the implementation of IntSize::scale truncates its results (as
opposed to rounding).

[Gleb Lanbin, 2016/07/06 20:36:18]

Done.

+    return newSize;
+}
+
+} // namespace
+
 CSSPaintDefinition* CSSPaintDefinition::create(ScriptState* scriptState, v8::Local<v8::Function> constructor, v8::Local<v8::Function> paint, Vector<CSSPropertyID>& nativeInvalidationProperties, Vector<AtomicString>& customInvalidationProperties)
 {
     return new CSSPaintDefinition(scriptState, constructor, paint, nativeInvalidationProperties, customInvalidationProperties);
 }
 
 CSSPaintDefinition::CSSPaintDefinition(ScriptState* scriptState, v8::Local<v8::Function> constructor, v8::Local<v8::Function> paint, Vector<CSSPropertyID>& nativeInvalidationProperties, Vector<AtomicString>& customInvalidationProperties)
     : m_scriptState(scriptState)
     , m_constructor(scriptState->isolate(), constructor)
     , m_paint(scriptState->isolate(), paint)
 {
     m_nativeInvalidationProperties.swap(nativeInvalidationProperties);
     m_customInvalidationProperties.swap(customInvalidationProperties);
 }
 
 CSSPaintDefinition::~CSSPaintDefinition()
 {
 }
 
-PassRefPtr<Image> CSSPaintDefinition::paint(const LayoutObject& layoutObject, const IntSize& size)
+PassRefPtr<Image> CSSPaintDefinition::paint(const LayoutObject& layoutObject, const IntSize& size, float zoom)
 {
     ScriptState::Scope scope(m_scriptState.get());
 
     maybeCreatePaintInstance();
 
     v8::Isolate* isolate = m_scriptState->isolate();
     v8::Local<v8::Object> instance = m_instance.newLocal(isolate);
 
     // We may have failed to create an instance class, in which case produce an
     // invalid image.
     if (isUndefinedOrNull(instance))
         return nullptr;
 
     DCHECK(layoutObject.node());
 
+    const auto cssSize = adjustToCssSize(size, zoom);

[Justin Novosad, 2016/07/04 15:45:58]

abuse of "auto".

[Gleb Lanbin, 2016/07/06 20:36:18]

Done.

     PaintRenderingContext2D* renderingContext = PaintRenderingContext2D::create(
         ImageBuffer::create(wrapUnique(new RecordingImageBufferSurface(size))));
-    PaintSize* paintSize = PaintSize::create(size);
+    PaintSize* paintSize = PaintSize::create(cssSize);
     StylePropertyMap* styleMap = FilteredComputedStylePropertyMap::create(
         CSSComputedStyleDeclaration::create(layoutObject.node()),
         m_nativeInvalidationProperties, m_customInvalidationProperties);
 
     v8::Local<v8::Value> argv[] = {
         toV8(renderingContext, m_scriptState->context()->Global(), isolate),
         toV8(paintSize, m_scriptState->context()->Global(), isolate),
         toV8(styleMap, m_scriptState->context()->Global(), isolate)
     };
 
     v8::Local<v8::Function> paint = m_paint.newLocal(isolate);
 
     v8::TryCatch block(isolate);
     block.SetVerbose(true);
 
     V8ScriptRunner::callFunction(paint, m_scriptState->getExecutionContext(), instance, 3, argv, isolate);
 
     // The paint function may have produced an error, in which case produce an
     // invalid image.
     if (block.HasCaught()) {
         return nullptr;
     }
 
-    return PaintGeneratedImage::create(renderingContext->imageBuffer()->getPicture(), size);
+    return PaintGeneratedImage::create(renderingContext->imageBuffer()->getPicture(), cssSize);
 }
 
 void CSSPaintDefinition::maybeCreatePaintInstance()
 {
     if (m_didCallConstructor)
         return;
 
     DCHECK(m_instance.isEmpty());
 
     v8::Isolate* isolate = m_scriptState->isolate();
     v8::Local<v8::Function> constructor = m_constructor.newLocal(isolate);
     DCHECK(!isUndefinedOrNull(constructor));
 
     v8::Local<v8::Object> paintInstance;
     if (V8ObjectConstructor::newInstance(isolate, constructor).ToLocal(&paintInstance)) {
         m_instance.set(isolate, paintInstance);
     }
 
     m_didCallConstructor = true;
 }
 
 } // namespace blink