Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d7e45e4f authored by Nolan Scobie's avatar Nolan Scobie
Browse files

Remove RecordingCanvas's reliance on Skia's private SkTemplates.h 

SkAutoTMalloc was previously used through some transitive inclusion of
SkTemplates.h. Skia is trying to move these private types into an
internal namespace to address leakage, so this usage must be removed
first.

AutoTMalloc has the same API surface as SkAutoTMalloc, but is not the
same due to SkAutoTMalloc delegating most of its work to other private
Skia dependencies and had to be rewritten.

AutoTMalloc is declared in utils/AutoMalloc.h since there are other
"AutoMalloc-like" variants that will be needed in HWUI to replace other
Skia types.

Changes in include ordering are from required clang reformatting.

Bug: 264403827
Test: existing presubmits (should be a drop-in replacement)
Change-Id: I1763ce0a643ba3e2f7be58e860dbdf08e3ba07bc
parent 3fac6887

libs/hwui/RecordingCanvas.h

+11 −9
Original line number Diff line number Diff line
@@ -16,11 +16,13 @@ 


#pragma once



#include "CanvasTransform.h"

#include "hwui/Bitmap.h"

#include "utils/Macros.h"

#include "utils/TypeLogic.h"

#include <SkRuntimeEffect.h>

#include <log/log.h>



#include <cstdlib>

#include <vector>



#include "CanvasTransform.h"

#include "SkCanvas.h"

#include "SkCanvasVirtualEnforcer.h"

#include "SkDrawable.h"
@@ -28,11 +30,11 @@ 
#include "SkPaint.h"

#include "SkPath.h"

#include "SkRect.h"



#include "hwui/Bitmap.h"

#include "pipeline/skia/AnimatedDrawables.h"



#include <SkRuntimeEffect.h>

#include <vector>

#include "utils/AutoMalloc.h"

#include "utils/Macros.h"

#include "utils/TypeLogic.h"



enum class SkBlendMode;

class SkRRect;
@@ -145,7 +147,7 @@ private: 
    template <typename Fn, typename... Args>

    void map(const Fn[], Args...) const;



    SkAutoTMalloc<uint8_t> fBytes;

    AutoTMalloc<uint8_t> fBytes;

    size_t fUsed = 0;

    size_t fReserved = 0;

libs/hwui/utils/AutoMalloc.h

0 → 100644
+94 −0
Original line number Diff line number Diff line 
/**

 * Copyright (C) 2023 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



#pragma once



#include <cstdlib>

#include <memory>

#include <type_traits>



namespace android {

namespace uirenderer {



/** Manages an array of T elements, freeing the array in the destructor.

 *  Does NOT call any constructors/destructors on T (T must be POD).

 */

template <typename T,

          typename = std::enable_if_t<std::is_trivially_default_constructible<T>::value &&

                                      std::is_trivially_destructible<T>::value>>

class AutoTMalloc {

public:

    /** Takes ownership of the ptr. The ptr must be a value which can be passed to std::free. */

    explicit AutoTMalloc(T* ptr = nullptr) : fPtr(ptr) {}



    /** Allocates space for 'count' Ts. */

    explicit AutoTMalloc(size_t count) : fPtr(mallocIfCountThrowOnFail(count)) {}



    AutoTMalloc(AutoTMalloc&&) = default;

    AutoTMalloc& operator=(AutoTMalloc&&) = default;



    /** Resize the memory area pointed to by the current ptr preserving contents. */

    void realloc(size_t count) { fPtr.reset(reallocIfCountThrowOnFail(count)); }



    /** Resize the memory area pointed to by the current ptr without preserving contents. */

    T* reset(size_t count = 0) {

        fPtr.reset(mallocIfCountThrowOnFail(count));

        return this->get();

    }



    T* get() const { return fPtr.get(); }



    operator T*() { return fPtr.get(); }



    operator const T*() const { return fPtr.get(); }



    T& operator[](int index) { return fPtr.get()[index]; }



    const T& operator[](int index) const { return fPtr.get()[index]; }



    /**

     *  Transfer ownership of the ptr to the caller, setting the internal

     *  pointer to NULL. Note that this differs from get(), which also returns

     *  the pointer, but it does not transfer ownership.

     */

    T* release() { return fPtr.release(); }



private:

    struct FreeDeleter {

        void operator()(uint8_t* p) { std::free(p); }

    };

    std::unique_ptr<T, FreeDeleter> fPtr;



    T* mallocIfCountThrowOnFail(size_t count) {

        T* newPtr = nullptr;

        if (count) {

            newPtr = (T*)std::malloc(count * sizeof(T));

            LOG_ALWAYS_FATAL_IF(!newPtr, "failed to malloc %zu bytes", count * sizeof(T));

        }

        return newPtr;

    }

    T* reallocIfCountThrowOnFail(size_t count) {

        T* newPtr = nullptr;

        if (count) {

            newPtr = (T*)std::realloc(fPtr.release(), count * sizeof(T));

            LOG_ALWAYS_FATAL_IF(!newPtr, "failed to realloc %zu bytes", count * sizeof(T));

        }

        return newPtr;

    }

};



}  // namespace uirenderer

}  // namespace android