⚠ Archived content — this site is no longer maintained.   Current WebKit documentation is at docs.webkit.org.

Changeset 267615 in webkit


Ignore:
Timestamp:
Sep 25, 2020, 6:42:08 PM (6 years ago)
Author:
commit-queue@webkit.org
Message:

Move SerializationState from ImageBuffer to ImageBitmap
​https://bugs.webkit.org/show_bug.cgi?id=216565

Patch by Said Abou-Hallawa <​sabouhallawa@apple.com> on 2020-09-25
Reviewed by Kenneth Russell.

Introduce ImageBitmapBacking and make it a member of ImageBitmap. It
represents the backing store of an ImageBitmap. Currently it encapsulates
an ImageBuffer and the new enum SerializationState. In the future, it can
be extended to encapsulate either a texture or an ImageBuffer.

  • Headers.cmake:
  • Sources.txt:
  • WebCore.xcodeproj/project.pbxproj:
  • bindings/js/SerializedScriptValue.cpp:

(WebCore::CloneSerializer::dumpImageBitmap):
(WebCore::CloneDeserializer::deserialize):
(WebCore::CloneDeserializer::CloneDeserializer):
(WebCore::CloneDeserializer::readTransferredImageBitmap):
(WebCore::CloneDeserializer::readImageBitmap):
(WebCore::SerializedScriptValue::SerializedScriptValue):
(WebCore::SerializedScriptValue::computeMemoryCost const):
(WebCore::SerializedScriptValue::create):
(WebCore::SerializedScriptValue::deserialize):

  • bindings/js/SerializedScriptValue.h:

(WebCore::SerializedScriptValue::SerializedScriptValue):

  • html/ImageBitmap.cpp:

(WebCore::ImageBitmap::create):
(WebCore::ImageBitmap::detachBitmaps):
(WebCore::ImageBitmap::resolveWithBlankImageBuffer):
(WebCore::ImageBitmap::createPromise):
(WebCore::ImageBitmap::createFromBuffer):
(WebCore::ImageBitmap::ImageBitmap):
(WebCore::ImageBitmap::takeImageBitmapBacking):
(WebCore::ImageBitmap::takeImageBuffer):
(WebCore::ImageBitmap::width const): Deleted.
(WebCore::ImageBitmap::height const): Deleted.
(WebCore::ImageBitmap::close): Deleted.
(WebCore::ImageBitmap::transferOwnershipAndClose): Deleted.

  • html/ImageBitmap.h:
  • html/ImageBitmapBacking.cpp: Added.

(WebCore::ImageBitmapBacking::ImageBitmapBacking):
(WebCore::ImageBitmapBacking::buffer const):
(WebCore::ImageBitmapBacking::takeImageBuffer):
(WebCore::ImageBitmapBacking::width const):
(WebCore::ImageBitmapBacking::height const):

  • html/ImageBitmapBacking.h: Added.

(WebCore::ImageBitmapBacking::originClean const):
(WebCore::ImageBitmapBacking::premultiplyAlpha const):
(WebCore::ImageBitmapBacking::forciblyPremultiplyAlpha const):
(WebCore::ImageBitmapBacking::serializationState const):

  • html/OffscreenCanvas.cpp:

(WebCore::OffscreenCanvas::transferToImageBitmap):

  • html/canvas/ImageBitmapRenderingContext.cpp:

(WebCore::ImageBitmapRenderingContext::setOutputBitmap):

  • platform/graphics/ImageBuffer.h:

(): Deleted.

Location:
trunk/Source/WebCore
Files:
2 added
11 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r267614 r267615  
     12020-09-25  Said Abou-Hallawa  <sabouhallawa@apple.com>
     2
     3        Move SerializationState from ImageBuffer to ImageBitmap
     4        https://bugs.webkit.org/show_bug.cgi?id=216565
     5
     6        Reviewed by Kenneth Russell.
     7
     8        Introduce ImageBitmapBacking and make it a member of ImageBitmap. It
     9        represents the backing store of an ImageBitmap. Currently it encapsulates
     10        an ImageBuffer and the new enum SerializationState. In the future, it can
     11        be extended to encapsulate either a texture or an ImageBuffer.
     12
     13        * Headers.cmake:
     14        * Sources.txt:
     15        * WebCore.xcodeproj/project.pbxproj:
     16        * bindings/js/SerializedScriptValue.cpp:
     17        (WebCore::CloneSerializer::dumpImageBitmap):
     18        (WebCore::CloneDeserializer::deserialize):
     19        (WebCore::CloneDeserializer::CloneDeserializer):
     20        (WebCore::CloneDeserializer::readTransferredImageBitmap):
     21        (WebCore::CloneDeserializer::readImageBitmap):
     22        (WebCore::SerializedScriptValue::SerializedScriptValue):
     23        (WebCore::SerializedScriptValue::computeMemoryCost const):
     24        (WebCore::SerializedScriptValue::create):
     25        (WebCore::SerializedScriptValue::deserialize):
     26        * bindings/js/SerializedScriptValue.h:
     27        (WebCore::SerializedScriptValue::SerializedScriptValue):
     28        * html/ImageBitmap.cpp:
     29        (WebCore::ImageBitmap::create):
     30        (WebCore::ImageBitmap::detachBitmaps):
     31        (WebCore::ImageBitmap::resolveWithBlankImageBuffer):
     32        (WebCore::ImageBitmap::createPromise):
     33        (WebCore::ImageBitmap::createFromBuffer):
     34        (WebCore::ImageBitmap::ImageBitmap):
     35        (WebCore::ImageBitmap::takeImageBitmapBacking):
     36        (WebCore::ImageBitmap::takeImageBuffer):
     37        (WebCore::ImageBitmap::width const): Deleted.
     38        (WebCore::ImageBitmap::height const): Deleted.
     39        (WebCore::ImageBitmap::close): Deleted.
     40        (WebCore::ImageBitmap::transferOwnershipAndClose): Deleted.
     41        * html/ImageBitmap.h:
     42        * html/ImageBitmapBacking.cpp: Added.
     43        (WebCore::ImageBitmapBacking::ImageBitmapBacking):
     44        (WebCore::ImageBitmapBacking::buffer const):
     45        (WebCore::ImageBitmapBacking::takeImageBuffer):
     46        (WebCore::ImageBitmapBacking::width const):
     47        (WebCore::ImageBitmapBacking::height const):
     48        * html/ImageBitmapBacking.h: Added.
     49        (WebCore::ImageBitmapBacking::originClean const):
     50        (WebCore::ImageBitmapBacking::premultiplyAlpha const):
     51        (WebCore::ImageBitmapBacking::forciblyPremultiplyAlpha const):
     52        (WebCore::ImageBitmapBacking::serializationState const):
     53        * html/OffscreenCanvas.cpp:
     54        (WebCore::OffscreenCanvas::transferToImageBitmap):
     55        * html/canvas/ImageBitmapRenderingContext.cpp:
     56        (WebCore::ImageBitmapRenderingContext::setOutputBitmap):
     57        * platform/graphics/ImageBuffer.h:
     58        (): Deleted.
     59
    1602020-09-25  Chris Dumez  <cdumez@apple.com>
    261

  • trunk/Source/WebCore/Headers.cmake

    r267576 r267615  
    655655    html/HTMLVideoElement.h
    656656    html/ImageBitmap.h
     657    html/ImageBitmapBacking.h
    657658    html/ImageData.h
    658659    html/ImageDocument.h

  • trunk/Source/WebCore/Sources.txt

    r267613 r267615  
    11951195html/HiddenInputType.cpp
    11961196html/ImageBitmap.cpp
     1197html/ImageBitmapBacking.cpp
    11971198html/ImageData.cpp
    11981199html/ImageDocument.cpp

  • trunk/Source/WebCore/WebCore.xcodeproj/project.pbxproj

    r267613 r267615  
    21582158                72144333223EC8B000F12FF7 /* SVGProperty.h in Headers */ = {isa = PBXBuildFile; fileRef = 55EE5363223B2A2400FBA944 /* SVGProperty.h */; settings = {ATTRIBUTES = (Private, ); }; };
    21592159                72144334223EC91600F12FF7 /* SVGPropertyOwner.h in Headers */ = {isa = PBXBuildFile; fileRef = 55EE5360223B2A2100FBA944 /* SVGPropertyOwner.h */; settings = {ATTRIBUTES = (Private, ); }; };
     2160                721B49742512BA3B00FE9D3B /* ImageBitmapBacking.h in Headers */ = {isa = PBXBuildFile; fileRef = 721B49702512AC0400FE9D3B /* ImageBitmapBacking.h */; settings = {ATTRIBUTES = (Private, ); }; };
    21602161                72283F0E230B268C00F5D828 /* ImagePaintingOptions.h in Headers */ = {isa = PBXBuildFile; fileRef = 72C18A3F230B04B7006847C7 /* ImagePaintingOptions.h */; settings = {ATTRIBUTES = (Private, ); }; };
    21612162                724ED3321A3A8B2300F5F13C /* JSEXTBlendMinMax.h in Headers */ = {isa = PBXBuildFile; fileRef = 724ED3301A3A8B2300F5F13C /* JSEXTBlendMinMax.h */; };
    … …  
    98919892                721443452240C8BA00F12FF7 /* SVGAnimatedValueProperty.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGAnimatedValueProperty.h; sourceTree = "<group>"; };
    98929893                721443462240CAD200F12FF7 /* SVGValueProperty.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = SVGValueProperty.h; sourceTree = "<group>"; };
     9894                721B496F2512AC0400FE9D3B /* ImageBitmapBacking.cpp */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.cpp; path = ImageBitmapBacking.cpp; sourceTree = "<group>"; };
     9895                721B49702512AC0400FE9D3B /* ImageBitmapBacking.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = ImageBitmapBacking.h; sourceTree = "<group>"; };
    98939896                722A815C238FD50500C00583 /* AnimationFrameRate.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = AnimationFrameRate.h; sourceTree = "<group>"; };
    98949897                724ED3291A3A7E5400F5F13C /* EXTBlendMinMax.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EXTBlendMinMax.cpp; sourceTree = "<group>"; };
    … …  
    2309523098                                31D26BBF1F86D189008FF255 /* ImageBitmap.h */,
    2309623099                                31D26BC11F86D18B008FF255 /* ImageBitmap.idl */,
     23100                                721B496F2512AC0400FE9D3B /* ImageBitmapBacking.cpp */,
     23101                                721B49702512AC0400FE9D3B /* ImageBitmapBacking.h */,
    2309723102                                31D26BC01F86D18A008FF255 /* ImageBitmapOptions.h */,
    2309823103                                31D26BBD1F86D187008FF255 /* ImageBitmapOptions.idl */,
    … …  
    3175531760                                55A336F91D821E3C0022C4C7 /* ImageBackingStore.h in Headers */,
    3175631761                                31815A311F9A6C8F00FCBF89 /* ImageBitmap.h in Headers */,
     31762                                721B49742512BA3B00FE9D3B /* ImageBitmapBacking.h in Headers */,
    3175731763                                7C7903B31F86F95C00463A70 /* ImageBitmapRenderingContext.h in Headers */,
    3175831764                                318EAD4D1FA91380008CEF86 /* ImageBitmapRenderingContextSettings.h in Headers */,

  • trunk/Source/WebCore/bindings/js/SerializedScriptValue.cpp

    r267373 r267615  
    3636#include "CryptoKeyRaw.h"
    3737#include "IDBValue.h"
     38#include "ImageBitmapBacking.h"
    3839#include "JSBlob.h"
    3940#include "JSCryptoKey.h"
    … …  
    10441045
    10451046        write(ImageBitmapTag);
    1046         write(static_cast<uint8_t>(imageBitmap.originClean()));
    1047         write(static_cast<uint8_t>(imageBitmap.premultiplyAlpha()));
    1048         write(static_cast<uint8_t>(imageBitmap.forciblyPremultiplyAlpha()));
     1047        write(static_cast<uint8_t>(imageBitmap.serializationState().toRaw()));
    10491048        write(static_cast<int32_t>(logicalSize.width()));
    10501049        write(static_cast<int32_t>(logicalSize.height()));
    … …  
    19321931    }
    19331932
    1934     static DeserializationResult deserialize(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>>&& imageBuffers
     1933    static DeserializationResult deserialize(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, Vector<Optional<ImageBitmapBacking>>&& backingStores
    19351934#if ENABLE(OFFSCREEN_CANVAS)
    19361935        , Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
    … …  
    19441943        if (!buffer.size())
    19451944            return std::make_pair(jsNull(), SerializationReturnCode::UnspecifiedError);
    1946         CloneDeserializer deserializer(lexicalGlobalObject, globalObject, messagePorts, arrayBufferContentsArray, buffer, blobURLs, blobFilePaths, sharedBuffers, WTFMove(imageBuffers)
     1945        CloneDeserializer deserializer(lexicalGlobalObject, globalObject, messagePorts, arrayBufferContentsArray, buffer, blobURLs, blobFilePaths, sharedBuffers, WTFMove(backingStores)
    19471946#if ENABLE(OFFSCREEN_CANVAS)
    19481947            , WTFMove(detachedOffscreenCanvases)
    … …  
    19971996    };
    19981997
    1999     CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, ArrayBufferContentsArray* arrayBufferContents, Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>>&& imageBuffers, const Vector<uint8_t>& buffer
     1998    CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, ArrayBufferContentsArray* arrayBufferContents, Vector<Optional<ImageBitmapBacking>>&& backingStores, const Vector<uint8_t>& buffer
    20001999#if ENABLE(OFFSCREEN_CANVAS)
    20012000        , Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases = { }
    … …  
    20152014        , m_arrayBufferContents(arrayBufferContents)
    20162015        , m_arrayBuffers(arrayBufferContents ? arrayBufferContents->size() : 0)
    2017         , m_imageBuffers(WTFMove(imageBuffers))
    2018         , m_imageBitmaps(m_imageBuffers.size())
     2016        , m_backingStores(WTFMove(backingStores))
     2017        , m_imageBitmaps(m_backingStores.size())
    20192018#if ENABLE(OFFSCREEN_CANVAS)
    20202019        , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
    … …  
    20292028    }
    20302029
    2031     CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, ArrayBufferContentsArray* arrayBufferContents, const Vector<uint8_t>& buffer, const Vector<String>& blobURLs, const Vector<String> blobFilePaths, ArrayBufferContentsArray* sharedBuffers, Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>>&& imageBuffers
     2030    CloneDeserializer(JSGlobalObject* lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, ArrayBufferContentsArray* arrayBufferContents, const Vector<uint8_t>& buffer, const Vector<String>& blobURLs, const Vector<String> blobFilePaths, ArrayBufferContentsArray* sharedBuffers, Vector<Optional<ImageBitmapBacking>>&& backingStores
    20322031#if ENABLE(OFFSCREEN_CANVAS)
    20332032        , Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
    … …  
    20502049        , m_blobFilePaths(blobFilePaths)
    20512050        , m_sharedBuffers(sharedBuffers)
    2052         , m_imageBuffers(WTFMove(imageBuffers))
    2053         , m_imageBitmaps(m_imageBuffers.size())
     2051        , m_backingStores(WTFMove(backingStores))
     2052        , m_imageBitmaps(m_backingStores.size())
    20542053#if ENABLE(OFFSCREEN_CANVAS)
    20552054        , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
    … …  
    28842883        uint32_t index;
    28852884        bool indexSuccessfullyRead = read(index);
    2886         if (!indexSuccessfullyRead || index >= m_imageBuffers.size()) {
     2885        if (!indexSuccessfullyRead || index >= m_backingStores.size()) {
    28872886            fail();
    28882887            return JSValue();
    … …  
    28902889
    28912890        if (!m_imageBitmaps[index])
    2892             m_imageBitmaps[index] = ImageBitmap::create(WTFMove(m_imageBuffers.at(index)));
     2891            m_imageBitmaps[index] = ImageBitmap::create(WTFMove(m_backingStores.at(index)));
    28932892
    28942893        auto bitmap = m_imageBitmaps[index].get();
    … …  
    29632962    JSValue readImageBitmap()
    29642963    {
    2965         uint8_t originClean;
    2966         uint8_t premultiplyAlpha;
    2967         uint8_t forciblyPremultiplyAlpha;
     2964        uint8_t serializationState;
    29682965        int32_t logicalWidth;
    29692966        int32_t logicalHeight;
    … …  
    29712968        RefPtr<ArrayBuffer> arrayBuffer;
    29722969
    2973         if (!read(originClean) || !read(premultiplyAlpha) || !read(forciblyPremultiplyAlpha) || !read(logicalWidth) || !read(logicalHeight) || !read(resolutionScale) || !readArrayBuffer(arrayBuffer)) {
     2970        if (!read(serializationState) || !read(logicalWidth) || !read(logicalHeight) || !read(resolutionScale) || !readArrayBuffer(arrayBuffer)) {
    29742971            fail();
    29752972            return JSValue();
    … …  
    30002997        buffer->putImageData(AlphaPremultiplication::Premultiplied, *imageData, { IntPoint::zero(), logicalSize });
    30012998
    3002         auto bitmap = ImageBitmap::create({ WTFMove(buffer), ImageBuffer::SerializationState { static_cast<bool>(originClean), static_cast<bool>(premultiplyAlpha), static_cast<bool>(forciblyPremultiplyAlpha) }});
     2999        auto bitmap = ImageBitmap::create(ImageBitmapBacking(WTFMove(buffer), OptionSet<SerializationState>::fromRaw(serializationState)));
    30033000        return getJSValue(bitmap);
    30043001    }
    … …  
    34353432    Vector<String> m_blobFilePaths;
    34363433    ArrayBufferContentsArray* m_sharedBuffers;
    3437     Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>> m_imageBuffers;
     3434    Vector<Optional<ImageBitmapBacking>> m_backingStores;
    34383435    Vector<RefPtr<ImageBitmap>> m_imageBitmaps;
    34393436#if ENABLE(OFFSCREEN_CANVAS)
    … …  
    36593656}
    36603657
    3661 SerializedScriptValue::SerializedScriptValue(Vector<uint8_t>&& buffer, const Vector<String>& blobURLs, std::unique_ptr<ArrayBufferContentsArray> arrayBufferContentsArray, std::unique_ptr<ArrayBufferContentsArray> sharedBufferContentsArray, Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>>&& imageBuffers
     3658SerializedScriptValue::SerializedScriptValue(Vector<uint8_t>&& buffer, const Vector<String>& blobURLs, std::unique_ptr<ArrayBufferContentsArray> arrayBufferContentsArray, std::unique_ptr<ArrayBufferContentsArray> sharedBufferContentsArray, Vector<Optional<ImageBitmapBacking>>&& backingStores
    36623659#if ENABLE(OFFSCREEN_CANVAS)
    36633660        , Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& detachedOffscreenCanvases
    … …  
    36703667    , m_arrayBufferContentsArray(WTFMove(arrayBufferContentsArray))
    36713668    , m_sharedBufferContentsArray(WTFMove(sharedBufferContentsArray))
    3672     , m_imageBuffers(WTFMove(imageBuffers))
     3669    , m_backingStores(WTFMove(backingStores))
    36733670#if ENABLE(OFFSCREEN_CANVAS)
    36743671    , m_detachedOffscreenCanvases(WTFMove(detachedOffscreenCanvases))
    … …  
    37003697    }
    37013698
    3702     for (auto& pair : m_imageBuffers) {
    3703         if (pair.first)
    3704             cost += pair.first->memoryCost();
     3699    for (auto& backingStore : m_backingStores) {
     3700        if (auto buffer = backingStore ? backingStore->buffer() : nullptr)
     3701            cost += buffer->memoryCost();
    37053702    }
    37063703
    … …  
    39263923        return arrayBufferContentsArray.releaseException();
    39273924
    3928     auto imageBuffers = ImageBitmap::detachBitmaps(WTFMove(imageBitmaps));
     3925    auto backingStores = ImageBitmap::detachBitmaps(WTFMove(imageBitmaps));
    39293926
    39303927#if ENABLE(OFFSCREEN_CANVAS)
    … …  
    39343931#endif
    39353932
    3936     return adoptRef(*new SerializedScriptValue(WTFMove(buffer), blobURLs, arrayBufferContentsArray.releaseReturnValue(), context == SerializationContext::WorkerPostMessage ? WTFMove(sharedBuffers) : nullptr, WTFMove(imageBuffers)
     3933    return adoptRef(*new SerializedScriptValue(WTFMove(buffer), blobURLs, arrayBufferContentsArray.releaseReturnValue(), context == SerializationContext::WorkerPostMessage ? WTFMove(sharedBuffers) : nullptr, WTFMove(backingStores)
    39373934#if ENABLE(OFFSCREEN_CANVAS)
    39383935                , WTFMove(detachedCanvases)
    … …  
    39903987JSValue SerializedScriptValue::deserialize(JSGlobalObject& lexicalGlobalObject, JSGlobalObject* globalObject, const Vector<RefPtr<MessagePort>>& messagePorts, const Vector<String>& blobURLs, const Vector<String>& blobFilePaths, SerializationErrorMode throwExceptions)
    39913988{
    3992     DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject, messagePorts, WTFMove(m_imageBuffers)
     3989    DeserializationResult result = CloneDeserializer::deserialize(&lexicalGlobalObject, globalObject, messagePorts, WTFMove(m_backingStores)
    39933990#if ENABLE(OFFSCREEN_CANVAS)
    39943991        , WTFMove(m_detachedOffscreenCanvases)

  • trunk/Source/WebCore/bindings/js/SerializedScriptValue.h

    r265208 r267615  
    2828
    2929#include "ExceptionOr.h"
    30 #include "ImageBuffer.h"
    3130#include <JavaScriptCore/ArrayBuffer.h>
    3231#include <JavaScriptCore/JSCJSValue.h>
    … …  
    5251#endif
    5352class IDBValue;
    54 class ImageBitmap;
    5553class MessagePort;
     54class ImageBitmapBacking;
    5655class SharedBuffer;
    5756enum class SerializationReturnCode;
    … …  
    118117    WEBCORE_EXPORT SerializedScriptValue(Vector<unsigned char>&&);
    119118    WEBCORE_EXPORT SerializedScriptValue(Vector<unsigned char>&&, std::unique_ptr<ArrayBufferContentsArray>);
    120     SerializedScriptValue(Vector<unsigned char>&&, const Vector<String>& blobURLs, std::unique_ptr<ArrayBufferContentsArray>, std::unique_ptr<ArrayBufferContentsArray> sharedBuffers, Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>>&& imageBuffers
     119    SerializedScriptValue(Vector<unsigned char>&&, const Vector<String>& blobURLs, std::unique_ptr<ArrayBufferContentsArray>, std::unique_ptr<ArrayBufferContentsArray> sharedBuffers, Vector<Optional<ImageBitmapBacking>>&& backingStores
    121120#if ENABLE(OFFSCREEN_CANVAS)
    122121        , Vector<std::unique_ptr<DetachedOffscreenCanvas>>&& = { }
    … …  
    132131    std::unique_ptr<ArrayBufferContentsArray> m_arrayBufferContentsArray;
    133132    std::unique_ptr<ArrayBufferContentsArray> m_sharedBufferContentsArray;
    134     Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>> m_imageBuffers;
     133    Vector<Optional<ImageBitmapBacking>> m_backingStores;
    135134#if ENABLE(OFFSCREEN_CANVAS)
    136135    Vector<std::unique_ptr<DetachedOffscreenCanvas>> m_detachedOffscreenCanvases;

  • trunk/Source/WebCore/html/ImageBitmap.cpp

    r265360 r267615  
    7070Ref<ImageBitmap> ImageBitmap::create(IntSize size)
    7171{
    72     return create(ImageBuffer::create(FloatSize(size.width(), size.height()), bufferRenderingMode));
    73 }
    74 
    75 Ref<ImageBitmap> ImageBitmap::create(std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>&& buffer)
    76 {
    77     auto imageBitmap = create(WTFMove(buffer.first));
    78     imageBitmap->m_originClean = buffer.second.originClean;
    79     imageBitmap->m_premultiplyAlpha = buffer.second.premultiplyAlpha;
    80     imageBitmap->m_forciblyPremultiplyAlpha = buffer.second.forciblyPremultiplyAlpha;
    81     return imageBitmap;
    82 }
    83 
    84 Ref<ImageBitmap> ImageBitmap::create(std::unique_ptr<ImageBuffer>&& buffer)
    85 {
    86     return adoptRef(*new ImageBitmap(WTFMove(buffer)));
     72    return create({ ImageBuffer::create(FloatSize(size.width(), size.height()), bufferRenderingMode) });
     73}
     74
     75Ref<ImageBitmap> ImageBitmap::create(Optional<ImageBitmapBacking>&& backingStore)
     76{
     77    return adoptRef(*new ImageBitmap(WTFMove(backingStore)));
    8778}
    8879
    … …  
    9687}
    9788
    98 Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>> ImageBitmap::detachBitmaps(Vector<RefPtr<ImageBitmap>>&& bitmaps)
    99 {
    100     Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>> buffers;
     89Vector<Optional<ImageBitmapBacking>> ImageBitmap::detachBitmaps(Vector<RefPtr<ImageBitmap>>&& bitmaps)
     90{
     91    Vector<Optional<ImageBitmapBacking>> buffers;
    10192    for (auto& bitmap : bitmaps)
    102         buffers.append(std::make_pair(bitmap->transferOwnershipAndClose(), ImageBuffer::SerializationState { bitmap->originClean(), bitmap->premultiplyAlpha(), bitmap->forciblyPremultiplyAlpha() }));
     93        buffers.append(bitmap->takeImageBitmapBacking());
    10394    return buffers;
    10495}
    105 
    10696
    10797void ImageBitmap::createPromise(ScriptExecutionContext& scriptExecutionContext, ImageBitmap::Source&& source, ImageBitmapOptions&& options, int sx, int sy, int sw, int sh, ImageBitmap::Promise&& promise)
    … …  
    244234    auto bitmapData = ImageBuffer::create(FloatSize(1, 1), bufferRenderingMode);
    245235
    246     // 7. Create a new ImageBitmap object.
    247     auto imageBitmap = create(WTFMove(bitmapData));
    248 
    249236    // 9. If the origin of image's image is not the same origin as the origin specified by the
    250237    //    entry settings object, then set the origin-clean flag of the ImageBitmap object's
    251238    //    bitmap to false.
    252     imageBitmap->m_originClean = originClean;
     239    OptionSet<SerializationState> serializationState;
     240    if (originClean)
     241        serializationState.add(SerializationState::OriginClean);
     242   
     243    // 7. Create a new ImageBitmap object.
     244    auto imageBitmap = create(ImageBitmapBacking(WTFMove(bitmapData), serializationState));
    253245
    254246    // 10. Return a new promise, but continue running these steps in parallel.
    … …  
    374366    bitmapData->context().drawImage(*imageForRender, destRect, sourceRectangle.releaseReturnValue(), { interpolationQualityForResizeQuality(options.resizeQuality), imageOrientationForOrientation(options.imageOrientation) });
    375367
    376     // 7. Create a new ImageBitmap object.
    377     auto imageBitmap = create(WTFMove(bitmapData));
    378 
    379368    // 9. If the origin of image's image is not the same origin as the origin specified by the
    380369    //    entry settings object, then set the origin-clean flag of the ImageBitmap object's
    381370    //    bitmap to false.
    382 
    383     imageBitmap->m_originClean = !taintsOrigin(*cachedImage);
    384 
    385     imageBitmap->m_premultiplyAlpha = (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied);
     371    OptionSet<SerializationState> serializationState;
     372    if (!taintsOrigin(*cachedImage))
     373        serializationState.add(SerializationState::OriginClean);
     374
     375    if (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied)
     376        serializationState.add(SerializationState::PremultiplyAlpha);
     377
     378    // 7. Create a new ImageBitmap object.
     379    auto imageBitmap = create(ImageBitmapBacking(WTFMove(bitmapData), serializationState));
    386380
    387381    // 10. Return a new promise, but continue running these steps in parallel.
    … …  
    440434    bitmapData->context().drawImage(*imageForRender, destRect, sourceRectangle.releaseReturnValue(), { interpolationQualityForResizeQuality(options.resizeQuality), imageOrientationForOrientation(options.imageOrientation) });
    441435
    442     // 3. Create a new ImageBitmap object.
    443     auto imageBitmap = create(WTFMove(bitmapData));
    444 
    445436    // 5. Set the origin-clean flag of the ImageBitmap object's bitmap to the same value as
    446437    //    the origin-clean flag of the canvas element's bitmap.
    447 
    448     imageBitmap->m_originClean = canvas.originClean();
    449 
    450     imageBitmap->m_premultiplyAlpha = (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied);
     438    OptionSet<SerializationState> serializationState;
     439    if (canvas.originClean())
     440        serializationState.add(SerializationState::OriginClean);
     441
     442    if (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied)
     443        serializationState.add(SerializationState::PremultiplyAlpha);
     444
     445    // 3. Create a new ImageBitmap object.
     446    auto imageBitmap = create(ImageBitmapBacking(WTFMove(bitmapData), serializationState));
    451447
    452448    // 6. Return a new promise, but continue running these steps in parallel.
    … …  
    515511    }
    516512
    517     // 5. Let imageBitmap be a new ImageBitmap object.
    518     auto imageBitmap = create(WTFMove(bitmapData));
    519 
    520513    // 6.3. If the origin of image's video is not same origin with entry
    521514    //      settings object's origin, then set the origin-clean flag of
    522515    //      image's bitmap to false.
    523     imageBitmap->m_originClean = !taintsOrigin(scriptExecutionContext.securityOrigin(), *video);
    524 
    525     imageBitmap->m_premultiplyAlpha = (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied);
     516    OptionSet<SerializationState> serializationState;
     517    if (!taintsOrigin(scriptExecutionContext.securityOrigin(), *video))
     518        serializationState.add(SerializationState::OriginClean);
     519
     520    if (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied)
     521        serializationState.add(SerializationState::PremultiplyAlpha);
     522
     523    // 5. Let imageBitmap be a new ImageBitmap object.
     524    auto imageBitmap = create(ImageBitmapBacking(WTFMove(bitmapData), serializationState));
    526525
    527526    // 6.4.1. Resolve p with imageBitmap.
    … …  
    567566    bitmapData->context().drawImage(*imageForRender, destRect, sourceRectangle.releaseReturnValue(), { interpolationQualityForResizeQuality(options.resizeQuality), imageOrientationForOrientation(options.imageOrientation) });
    568567
    569     // 3. Create a new ImageBitmap object.
    570     auto imageBitmap = create(WTFMove(bitmapData));
    571 
    572568    // 5. Set the origin-clean flag of the ImageBitmap object's bitmap to the same
    573569    //    value as the origin-clean flag of the bitmap of the image argument.
    574     imageBitmap->m_originClean = existingImageBitmap->originClean();
    575 
    576     imageBitmap->m_premultiplyAlpha = (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied);
    577 
    578     // At least in the Core Graphics backend, when creating an ImageBitmap from
    579     // an ImageBitmap, the alpha channel of bitmapData isn't premultiplied even
    580     // though the alpha mode of the internal surface claims it is. Instruct
    581     // users of this ImageBitmap to ignore the internal surface's alpha mode.
    582     imageBitmap->m_forciblyPremultiplyAlpha = imageBitmap->m_premultiplyAlpha;
     570    OptionSet<SerializationState> serializationState;
     571    if (existingImageBitmap->originClean())
     572        serializationState.add(SerializationState::OriginClean);
     573
     574    if (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied) {
     575        serializationState.add(SerializationState::PremultiplyAlpha);
     576
     577        // At least in the Core Graphics backend, when creating an ImageBitmap from
     578        // an ImageBitmap, the alpha channel of bitmapData isn't premultiplied even
     579        // though the alpha mode of the internal surface claims it is. Instruct
     580        // users of this ImageBitmap to ignore the internal surface's alpha mode.
     581        serializationState.add(SerializationState::ForciblyPremultiplyAlpha);
     582    }
     583
     584    // 3. Create a new ImageBitmap object.
     585    auto imageBitmap = create(ImageBitmapBacking(WTFMove(bitmapData), serializationState));
    583586
    584587    // 6. Return a new promise, but continue running these steps in parallel.
    … …  
    753756    bitmapData->context().drawImage(*image, destRect, sourceRectangle.releaseReturnValue(), { interpolationQualityForResizeQuality(options.resizeQuality), imageOrientationForOrientation(options.imageOrientation) });
    754757
    755     auto imageBitmap = create(WTFMove(bitmapData));
    756 
    757     imageBitmap->m_premultiplyAlpha = (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied);
     758    OptionSet<SerializationState> serializationState = SerializationState::OriginClean;
     759    if (alphaPremultiplicationForPremultiplyAlpha(options.premultiplyAlpha) == AlphaPremultiplication::Premultiplied)
     760        serializationState.add(SerializationState::PremultiplyAlpha);
     761
     762    auto imageBitmap = create(ImageBitmapBacking(WTFMove(bitmapData), serializationState));
    758763
    759764    promise.resolve(WTFMove(imageBitmap));
    … …  
    800805        && options.imageOrientation == ImageBitmapOptions::Orientation::None) {
    801806        bitmapData->putImageData(AlphaPremultiplication::Unpremultiplied, *imageData, sourceRectangle.releaseReturnValue(), { }, alphaPremultiplication);
    802         auto imageBitmap = create(WTFMove(bitmapData));
     807        auto imageBitmap = create(ImageBitmapBacking(WTFMove(bitmapData)));
    803808        // The result is implicitly origin-clean, and alpha premultiplication has already been handled.
    804809        promise.resolve(WTFMove(imageBitmap));
    … …  
    814819
    815820    // 6.4.1. Resolve p with ImageBitmap.
    816     auto imageBitmap = create(WTFMove(bitmapData));
     821    auto imageBitmap = create({ WTFMove(bitmapData) });
    817822    // The result is implicitly origin-clean, and alpha premultiplication has already been handled.
    818823    promise.resolve(WTFMove(imageBitmap));
    819824}
    820825
    821 ImageBitmap::ImageBitmap(std::unique_ptr<ImageBuffer>&& buffer)
    822     : m_bitmapData(WTFMove(buffer))
    823 {
    824     ASSERT(m_bitmapData);
     826ImageBitmap::ImageBitmap(Optional<ImageBitmapBacking>&& backingStore)
     827    : m_backingStore(WTFMove(backingStore))
     828{
     829    ASSERT_IMPLIES(m_backingStore, m_backingStore->buffer());
    825830}
    826831
    827832ImageBitmap::~ImageBitmap() = default;
    828833
    829 unsigned ImageBitmap::width() const
    830 {
    831     if (m_detached || !m_bitmapData)
    832         return 0;
    833 
    834     // FIXME: Is this the right width?
    835     return m_bitmapData->logicalSize().width();
    836 }
    837 
    838 unsigned ImageBitmap::height() const
    839 {
    840     if (m_detached || !m_bitmapData)
    841         return 0;
    842 
    843     // FIXME: Is this the right height?
    844     return m_bitmapData->logicalSize().height();
    845 }
    846 
    847 void ImageBitmap::close()
    848 {
    849     m_detached = true;
    850     m_bitmapData = nullptr;
    851 }
    852 
    853 std::unique_ptr<ImageBuffer> ImageBitmap::transferOwnershipAndClose()
    854 {
    855     m_detached = true;
    856     return WTFMove(m_bitmapData);
    857 }
    858 
    859 }
     834Optional<ImageBitmapBacking> ImageBitmap::takeImageBitmapBacking()
     835{
     836    return std::exchange(m_backingStore, WTF::nullopt);
     837}
     838
     839std::unique_ptr<ImageBuffer> ImageBitmap::takeImageBuffer()
     840{
     841    if (auto backingStore = takeImageBitmapBacking())
     842        return backingStore->takeImageBuffer();
     843    ASSERT(isDetached());
     844    return nullptr;
     845}
     846
     847} // namespace WebCore

  • trunk/Source/WebCore/html/ImageBitmap.h

    r265360 r267615  
    2727
    2828#include "IDLTypes.h"
    29 #include "ImageBuffer.h"
     29#include "ImageBitmapBacking.h"
    3030#include "ScriptWrappable.h"
    3131#include <wtf/RefCounted.h>
    … …  
    8484
    8585    static Ref<ImageBitmap> create(IntSize);
    86     static Ref<ImageBitmap> create(std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>&&);
     86    static Ref<ImageBitmap> create(Optional<ImageBitmapBacking>&&);
    8787
    8888    ~ImageBitmap();
    8989
    90     unsigned width() const;
    91     unsigned height() const;
    92     void close();
     90    ImageBuffer* buffer() const { return m_backingStore ? m_backingStore->buffer() : nullptr; }
     91    // This function has the implicit side-effect of detaching the backing store.
     92    // It returns nullptr if the ImageBitmap's already detached.
     93    std::unique_ptr<ImageBuffer> takeImageBuffer();
     94    OptionSet<SerializationState> serializationState() const { return m_backingStore ? m_backingStore->serializationState() : SerializationState(); }
    9395
    94     bool isDetached() const { return m_detached; }
     96    unsigned width() const { return m_backingStore ? m_backingStore->width() : 0; }
     97    unsigned height() const { return m_backingStore ? m_backingStore->height() : 0; }
    9598
    96     ImageBuffer* buffer() { return m_bitmapData.get(); }
     99    bool originClean() const { return m_backingStore && m_backingStore->originClean(); }
     100    bool premultiplyAlpha() const { return m_backingStore && m_backingStore->premultiplyAlpha(); }
     101    bool forciblyPremultiplyAlpha() const { return m_backingStore && m_backingStore->forciblyPremultiplyAlpha(); }
    97102
    98     bool originClean() const { return m_originClean; }
     103    Optional<ImageBitmapBacking> takeImageBitmapBacking();
     104    bool isDetached() const { return !m_backingStore.hasValue(); }
     105    void close() { takeImageBitmapBacking(); }
    99106
    100     bool premultiplyAlpha() const { return m_premultiplyAlpha; }
    101 
    102     // When WebGL consumes an Image coming from an ImageBitmap's ImageBuffer, it typically honors
    103     // the alpha mode of that native image - CGImageAlphaInfo in the Core Graphics backend. For
    104     // ImageBitmaps created from ImageBitmaps, this information is not accurate, and callers must be
    105     // told to ignore the alpha mode, and forcibly premultiply the alpha channel.
    106     bool forciblyPremultiplyAlpha() const { return m_forciblyPremultiplyAlpha; }
    107 
    108     std::unique_ptr<ImageBuffer> transferOwnershipAndClose();
    109 
    110     static Vector<std::pair<std::unique_ptr<ImageBuffer>, ImageBuffer::SerializationState>> detachBitmaps(Vector<RefPtr<ImageBitmap>>&&);
     107    static Vector<Optional<ImageBitmapBacking>> detachBitmaps(Vector<RefPtr<ImageBitmap>>&&);
    111108
    112109private:
    … …  
    114111    friend class PendingImageBitmap;
    115112
    116     static Ref<ImageBitmap> create(std::unique_ptr<ImageBuffer>&&);
    117     ImageBitmap(std::unique_ptr<ImageBuffer>&&);
     113    ImageBitmap(Optional<ImageBitmapBacking>&&);
    118114
    119115    static void resolveWithBlankImageBuffer(bool originClean, Promise&&);
    … …  
    134130    static void createFromBuffer(Ref<ArrayBuffer>&&, String mimeType, long long expectedContentLength, const URL&, ImageBitmapOptions&&, Optional<IntRect>, Promise&&);
    135131
    136     std::unique_ptr<ImageBuffer> m_bitmapData;
    137     bool m_detached { false };
    138     bool m_originClean { true };
    139     bool m_premultiplyAlpha { false };
    140     bool m_forciblyPremultiplyAlpha { false };
     132    Optional<ImageBitmapBacking> m_backingStore;
    141133};
    142134

  • trunk/Source/WebCore/html/OffscreenCanvas.cpp

    r266275 r267615  
    251251
    252252        if (!m_hasCreatedImageBuffer)
    253             return { ImageBitmap::create({ ImageBuffer::create(size(), RenderingMode::Unaccelerated), ImageBuffer::SerializationState { true, false, false }}) };
     253            return { ImageBitmap::create(ImageBitmapBacking(ImageBuffer::create(size(), RenderingMode::Unaccelerated))) };
    254254
    255255        auto buffer = takeImageBuffer();
    … …  
    257257            return { RefPtr<ImageBitmap> { nullptr } };
    258258
    259         return { ImageBitmap::create({ WTFMove(buffer), ImageBuffer::SerializationState { originClean(), false, false }}) };
     259        return { ImageBitmap::create(ImageBitmapBacking(WTFMove(buffer), originClean() ? SerializationState::OriginClean : SerializationState())) };
    260260    }
    261261

  • trunk/Source/WebCore/html/canvas/ImageBitmapRenderingContext.cpp

    r254893 r267615  
    118118    else
    119119        canvas()->setOriginTainted();
    120     canvas()->setImageBufferAndMarkDirty(imageBitmap->transferOwnershipAndClose());
     120    canvas()->setImageBufferAndMarkDirty(imageBitmap->takeImageBuffer());
    121121}
    122122

  • trunk/Source/WebCore/platform/graphics/ImageBuffer.h

    r265360 r267615  
    3939class ImageBuffer {
    4040public:
    41     struct SerializationState {
    42         bool originClean { false };
    43         bool premultiplyAlpha { false };
    44         bool forciblyPremultiplyAlpha { false };
    45     };
    46 
    4741    // Will return a null pointer on allocation failure.
    4842    WEBCORE_EXPORT static std::unique_ptr<ImageBuffer> create(const FloatSize&, ShouldAccelerate, ShouldUseDisplayList, RenderingPurpose, float resolutionScale = 1, ColorSpace = ColorSpace::SRGB, const HostWindow* = nullptr);
Note: See TracChangeset for help on using the changeset viewer.