return nullptr;
}
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(path));
- if (stream.get() == nullptr) {
+ std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(path);
+ if (!stream) {
SkDebugf("Could not read %s.\n", path);
return nullptr;
}
SKPSrc::SKPSrc(Path path) : fPath(path) {}
Error SKPSrc::draw(SkCanvas* canvas) const {
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
+ std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(fPath.c_str());
if (!stream) {
return SkStringPrintf("Couldn't read %s.", fPath.c_str());
}
- sk_sp<SkPicture> pic(SkPicture::MakeFromStream(stream));
+ sk_sp<SkPicture> pic(SkPicture::MakeFromStream(stream.get()));
if (!pic) {
return SkStringPrintf("Couldn't decode %s as a picture.", fPath.c_str());
}
- stream.reset((SkStream*)nullptr); // Might as well drop this when we're done with it.
+ stream = nullptr; // Might as well drop this when we're done with it.
canvas->clipRect(kSKPViewport);
canvas->drawPicture(pic);
}
SkISize SKPSrc::size() const {
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fPath.c_str()));
+ std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(fPath.c_str());
if (!stream) {
return SkISize::Make(0,0);
}
SkPictInfo info;
- if (!SkPicture::InternalOnly_StreamIsSKP(stream, &info)) {
+ if (!SkPicture::InternalOnly_StreamIsSKP(stream.get(), &info)) {
return SkISize::Make(0,0);
}
SkRect viewport = kSKPViewport;
/*~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~*/
MSKPSrc::MSKPSrc(Path path) : fPath(path) {
- std::unique_ptr<SkStreamAsset> stream(SkStream::NewFromFile(fPath.c_str()));
+ std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(fPath.c_str());
(void)fReader.init(stream.get());
}
Error MSKPSrc::draw(SkCanvas* c) const { return this->draw(0, c); }
Error MSKPSrc::draw(int i, SkCanvas* canvas) const {
- std::unique_ptr<SkStreamAsset> stream(SkStream::NewFromFile(fPath.c_str()));
+ std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(fPath.c_str());
if (!stream) {
return SkStringPrintf("Unable to open file: %s", fPath.c_str());
}
virtual ~SkStream() {}
/**
- * Attempts to open the specified file, and return a stream to it (using
- * mmap if available). On success, the caller is responsible for deleting.
- * On failure, returns NULL.
+ * Attempts to open the specified file as a stream, returns nullptr on failure.
*/
- static SkStreamAsset* NewFromFile(const char path[]);
+ static std::unique_ptr<SkStreamAsset> MakeFromFile(const char path[]);
/** Reads or skips size number of bytes.
* If buffer == NULL, skip size bytes, return how many were skipped.
#endif
/** Return a new typeface given font data and configuration. If the data
- is not valid font data, returns nullptr. Ownership of the font data is
- transferred, so the caller must not reference it again.
+ is not valid font data, returns nullptr.
*/
- static sk_sp<SkTypeface> MakeFromFontData(SkFontData*);
+ static sk_sp<SkTypeface> MakeFromFontData(std::unique_ptr<SkFontData>);
/** Write a unique signature to a stream, sufficient to reconstruct a
typeface referencing the same font when Deserialize is called.
SkStreamAsset* openStream(int* ttcIndex) const;
/**
- * Return the font data, or NULL on failure.
- * The caller is responsible for deleting the font data.
+ * Return the font data, or nullptr on failure.
*/
- SkFontData* createFontData() const;
+ std::unique_ptr<SkFontData> makeFontData() const;
/**
* Return a scalercontext for the given descriptor. If this fails, then
virtual SkStreamAsset* onOpenStream(int* ttcIndex) const = 0;
// TODO: make pure virtual.
- virtual SkFontData* onCreateFontData() const;
+ virtual std::unique_ptr<SkFontData> onMakeFontData() const;
virtual void onGetFontDescriptor(SkFontDescriptor*, bool* isLocal) const = 0;
/**
* Create a typeface from the specified font data.
- * Takes ownership of the font data, so the caller should not reference it again.
* Will return NULL if the typeface could not be created.
* The caller must call unref() on the returned object if it is not null.
*/
- SkTypeface* createFromFontData(SkFontData*) const;
+ SkTypeface* createFromFontData(std::unique_ptr<SkFontData>) const;
/**
* Create a typeface for the specified fileName and TTC index
virtual SkTypeface* onCreateFromStream(SkStreamAsset*, int ttcIndex) const = 0;
// TODO: make pure virtual.
virtual SkTypeface* onCreateFromStream(SkStreamAsset*, const FontParameters&) const;
- virtual SkTypeface* onCreateFromFontData(SkFontData*) const;
+ virtual SkTypeface* onCreateFromFontData(std::unique_ptr<SkFontData>) const;
virtual SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const = 0;
virtual SkTypeface* onLegacyCreateTypeface(const char familyName[], SkFontStyle) const = 0;
void SkCGDrawBitmap(CGContextRef, const SkBitmap&, float x, float y);
/**
- * Create an SkBitmap drawing of the encoded PDF document, returning true on
- * success. Deletes the stream when finished.
- */
-bool SkPDFDocumentToBitmap(SkStream* stream, SkBitmap* output);
-
-/**
- * Return a provider that wraps the specified stream. It will become the only
- * owner of the stream, so the caller must stop referring to the stream.
- *
+ * Return a provider that wraps the specified stream.
* When the provider is finally deleted, it will delete the stream.
*/
-CGDataProviderRef SkCreateDataProviderFromStream(SkStream*);
+CGDataProviderRef SkCreateDataProviderFromStream(std::unique_ptr<SkStream>);
-CGDataProviderRef SkCreateDataProviderFromData(SkData*);
+CGDataProviderRef SkCreateDataProviderFromData(sk_sp<SkData>);
#endif // defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
#endif // SkCGUtils_DEFINED
#include "SkStream.h"
#include "SkDOM.h"
+#include <memory>
+
///////////////////////////////////////////////////////////////////////////////
class SkAnimatorView : public SkView {
}
bool SkAnimatorView::decodeFile(const char path[]) {
- SkAutoTDelete<SkStream> is(SkStream::NewFromFile(path));
- return is.get() != nullptr && this->decodeStream(is);
+ std::unique_ptr<SkStream> is = SkStream::MakeFromFile(path);
+ return is && this->decodeStream(is.get());
}
bool SkAnimatorView::decodeMemory(const void* buffer, size_t size) {
// SkDebugf("animator decode %s\n", uri);
// SkStream* stream = SkStream::GetURIStream(fPrefix.c_str(), uri);
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(uri));
- if (stream.get()) {
- bool success = decodeStream(stream);
+ std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(uri);
+ if (stream) {
+ bool success = decodeStream(stream.get());
if (hasError() && fError.hasNoun() == false)
fError.setNoun(uri);
return success;
// SkDebugf("animator decode %s\n", uri);
// SkStream* stream = SkStream::GetURIStream(fMaker->fPrefix.c_str(), uri);
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(uri));
- if (stream.get()) {
+ std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(uri);
+ if (stream) {
this->setURIBase(uri);
- return decodeStream(stream);
+ return decodeStream(stream.get());
} else {
return false;
}
*/
#include "SkFontDescriptor.h"
+#include "SkMakeUnique.h"
#include "SkStream.h"
#include "SkData.h"
if (length > 0) {
sk_sp<SkData> data(SkData::MakeUninitialized(length));
if (stream->read(data->writable_data(), length) == length) {
- result->fFontData.reset(new SkFontData(new SkMemoryStream(data),
- index, axis, axisCount));
+ result->fFontData = skstd::make_unique<SkFontData>(
+ skstd::make_unique<SkMemoryStream>(data), index, axis, axisCount);
} else {
SkDEBUGFAIL("Could not read font data");
return false;
stream->writePackedUInt(kSentinel);
if (fFontData.get() && fFontData->hasStream()) {
- SkAutoTDelete<SkStreamAsset> fontData(fFontData->detachStream());
- size_t length = fontData->getLength();
+ std::unique_ptr<SkStreamAsset> fontStream = fFontData->detachStream();
+ size_t length = fontStream->getLength();
stream->writePackedUInt(length);
- stream->writeStream(fontData, length);
+ stream->writeStream(fontStream.get(), length);
} else {
stream->writePackedUInt(0);
}
class SkFontData {
public:
- /** This takes ownership of 'stream'. Makes a copy of the data in 'axis'. */
- SkFontData(SkStreamAsset* stream, int index, const SkFixed axis[], int axisCount)
- : fStream(stream), fIndex(index), fAxisCount(axisCount), fAxis(axisCount)
+ /** Makes a copy of the data in 'axis'. */
+ SkFontData(std::unique_ptr<SkStreamAsset> stream, int index, const SkFixed axis[],int axisCount)
+ : fStream(std::move(stream)), fIndex(index), fAxisCount(axisCount), fAxis(axisCount)
{
for (int i = 0; i < axisCount; ++i) {
fAxis[i] = axis[i];
}
}
bool hasStream() const { return fStream.get() != nullptr; }
- SkStreamAsset* duplicateStream() const { return fStream->duplicate(); }
- SkStreamAsset* detachStream() { return fStream.release(); }
+ std::unique_ptr<SkStreamAsset> detachStream() { return std::move(fStream); }
SkStreamAsset* getStream() { return fStream.get(); }
+ SkStreamAsset const* getStream() const { return fStream.get(); }
int getIndex() const { return fIndex; }
int getAxisCount() const { return fAxisCount; }
const SkFixed* getAxis() const { return fAxis.get(); }
private:
- SkAutoTDelete<SkStreamAsset> fStream;
+ std::unique_ptr<SkStreamAsset> fStream;
int fIndex;
int fAxisCount;
SkAutoSTMalloc<4, SkFixed> fAxis;
const char* getFullName() const { return fFullName.c_str(); }
const char* getPostscriptName() const { return fPostscriptName.c_str(); }
bool hasFontData() const { return fFontData.get() != nullptr; }
- SkFontData* detachFontData() { return fFontData.release(); }
+ std::unique_ptr<SkFontData> detachFontData() { return std::move(fFontData); }
void setFamilyName(const char* name) { fFamilyName.set(name); }
void setFullName(const char* name) { fFullName.set(name); }
void setPostscriptName(const char* name) { fPostscriptName.set(name); }
- /** Set the font data only if it is necessary for serialization.
- * This method takes ownership of the font data. */
- void setFontData(SkFontData* data) { fFontData.reset(data); }
+ /** Set the font data only if it is necessary for serialization. */
+ void setFontData(std::unique_ptr<SkFontData> data) { fFontData = std::move(data); }
private:
SkString fFamilyName;
SkString fFullName;
SkString fPostscriptName;
- SkAutoTDelete<SkFontData> fFontData;
+ std::unique_ptr<SkFontData> fFontData;
SkFontStyle fStyle;
};
return this->onCreateFromStream(stream, params);
}
-SkTypeface* SkFontMgr::createFromFontData(SkFontData* data) const {
+SkTypeface* SkFontMgr::createFromFontData(std::unique_ptr<SkFontData> data) const {
if (nullptr == data) {
return nullptr;
}
- return this->onCreateFromFontData(data);
+ return this->onCreateFromFontData(std::move(data));
}
// This implementation is temporary until it can be made pure virtual.
}
// This implementation is temporary until it can be made pure virtual.
-SkTypeface* SkFontMgr::onCreateFromFontData(SkFontData* data) const {
- SkTypeface* ret = this->createFromStream(data->detachStream(), data->getIndex());
- delete data;
- return ret;
+SkTypeface* SkFontMgr::onCreateFromFontData(std::unique_ptr<SkFontData> data) const {
+ return this->createFromStream(data->detachStream().release(), data->getIndex());
}
SkTypeface* SkFontMgr::createFromFile(const char path[], int ttcIndex) const {
#include "SkStreamPriv.h"
#include "SkData.h"
#include "SkFixed.h"
+#include "SkMakeUnique.h"
#include "SkString.h"
#include "SkOSFile.h"
#include "SkTypes.h"
return data;
}
-SkStreamAsset* SkStream::NewFromFile(const char path[]) {
+std::unique_ptr<SkStreamAsset> SkStream::MakeFromFile(const char path[]) {
auto data(mmap_filename(path));
if (data) {
- return new SkMemoryStream(std::move(data));
+ return skstd::make_unique<SkMemoryStream>(std::move(data));
}
- // If we get here, then our attempt at using mmap failed, so try normal
- // file access.
- SkFILEStream* stream = new SkFILEStream(path);
+ // If we get here, then our attempt at using mmap failed, so try normal file access.
+ auto stream = skstd::make_unique<SkFILEStream>(path);
if (!stream->isValid()) {
- delete stream;
- stream = nullptr;
+ return nullptr;
}
- return stream;
+ return std::move(stream);
}
// Declared in SkStreamPriv.h:
#include "SkEndian.h"
#include "SkFontDescriptor.h"
#include "SkFontMgr.h"
+#include "SkMakeUnique.h"
#include "SkMutex.h"
#include "SkOTTable_OS_2.h"
#include "SkOnce.h"
return sk_sp<SkTypeface>(fm->createFromStream(stream, index));
}
-sk_sp<SkTypeface> SkTypeface::MakeFromFontData(SkFontData* data) {
+sk_sp<SkTypeface> SkTypeface::MakeFromFontData(std::unique_ptr<SkFontData> data) {
SkAutoTUnref<SkFontMgr> fm(SkFontMgr::RefDefault());
- return sk_sp<SkTypeface>(fm->createFromFontData(data));
+ return sk_sp<SkTypeface>(fm->createFromFontData(std::move(data)));
}
sk_sp<SkTypeface> SkTypeface::MakeFromFile(const char path[], int index) {
// Embed font data if it's a local font.
if (isLocal && !desc.hasFontData()) {
- desc.setFontData(this->onCreateFontData());
+ desc.setFontData(this->onMakeFontData());
}
desc.serialize(wstream);
}
return nullptr;
}
- SkFontData* data = desc.detachFontData();
+ std::unique_ptr<SkFontData> data = desc.detachFontData();
if (data) {
- sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(data));
+ sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(std::move(data)));
if (typeface) {
return typeface;
}
return this->onOpenStream(ttcIndex);
}
-SkFontData* SkTypeface::createFontData() const {
- return this->onCreateFontData();
+std::unique_ptr<SkFontData> SkTypeface::makeFontData() const {
+ return this->onMakeFontData();
}
// This implementation is temporary until this method can be made pure virtual.
-SkFontData* SkTypeface::onCreateFontData() const {
+std::unique_ptr<SkFontData> SkTypeface::onMakeFontData() const {
int index;
- SkAutoTDelete<SkStreamAsset> stream(this->onOpenStream(&index));
- return new SkFontData(stream.release(), index, nullptr, 0);
+ std::unique_ptr<SkStreamAsset> stream(this->onOpenStream(&index));
+ return skstd::make_unique<SkFontData>(std::move(stream), index, nullptr, 0);
};
int SkTypeface::charsToGlyphs(const void* chars, Encoding encoding,
}
SkMovie* SkMovie::DecodeFile(const char path[]) {
- SkAutoTDelete<SkStreamRewindable> stream(SkStream::NewFromFile(path));
- return stream.get() ? SkMovie::DecodeStream(stream) : nullptr;
+ std::unique_ptr<SkStreamRewindable> stream = SkStream::MakeFromFile(path);
+ return stream ? SkMovie::DecodeStream(stream.get()) : nullptr;
}
}
SkStreamAsset* SkFontConfigInterfaceDirect::openStream(const FontIdentity& identity) {
- return SkStream::NewFromFile(identity.fString.c_str());
+ return SkStream::MakeFromFile(identity.fString.c_str()).release();
}
///////////////////////////////////////////////////////////////////////////////
void onGetFamilyName(SkString* familyName) const override { *familyName = fFamilyName; }
void onGetFontDescriptor(SkFontDescriptor*, bool*) const override;
SkStreamAsset* onOpenStream(int* ttcIndex) const override;
- SkFontData* onCreateFontData() const override;
+ std::unique_ptr<SkFontData> onMakeFontData() const override;
private:
typedef SkTypeface_FreeType INHERITED;
SkFaceRec* fNext;
FT_Face fFace;
FT_StreamRec fFTStream;
- SkAutoTDelete<SkStreamAsset> fSkStream;
+ std::unique_ptr<SkStreamAsset> fSkStream;
uint32_t fRefCnt;
uint32_t fFontID;
- // assumes ownership of the stream, will delete when its done
- SkFaceRec(SkStreamAsset* strm, uint32_t fontID);
+ SkFaceRec(std::unique_ptr<SkStreamAsset> stream, uint32_t fontID);
};
extern "C" {
static void sk_ft_stream_close(FT_Stream) {}
}
-SkFaceRec::SkFaceRec(SkStreamAsset* stream, uint32_t fontID)
- : fNext(nullptr), fSkStream(stream), fRefCnt(1), fFontID(fontID)
+SkFaceRec::SkFaceRec(std::unique_ptr<SkStreamAsset> stream, uint32_t fontID)
+ : fNext(nullptr), fSkStream(std::move(stream)), fRefCnt(1), fFontID(fontID)
{
sk_bzero(&fFTStream, sizeof(fFTStream));
fFTStream.size = fSkStream->getLength();
- fFTStream.descriptor.pointer = fSkStream;
+ fFTStream.descriptor.pointer = fSkStream.get();
fFTStream.read = sk_ft_stream_io;
fFTStream.close = sk_ft_stream_close;
}
rec = rec->fNext;
}
- SkAutoTDelete<SkFontData> data(typeface->createFontData());
+ std::unique_ptr<SkFontData> data = typeface->makeFontData();
if (nullptr == data || !data->hasStream()) {
return nullptr;
}
- // this passes ownership of stream to the rec
rec = new SkFaceRec(data->detachStream(), fontID);
FT_Open_Args args;
}
}
-FT_Face SkTypeface_FreeType::Scanner::openFace(SkStream* stream, int ttcIndex,
+FT_Face SkTypeface_FreeType::Scanner::openFace(SkStreamAsset* stream, int ttcIndex,
FT_Stream ftStream) const
{
if (fLibrary == nullptr) {
return face;
}
-bool SkTypeface_FreeType::Scanner::recognizedFont(SkStream* stream, int* numFaces) const {
+bool SkTypeface_FreeType::Scanner::recognizedFont(SkStreamAsset* stream, int* numFaces) const {
SkAutoMutexAcquire libraryLock(fLibraryMutex);
FT_StreamRec streamRec;
#include "SkTSearch.h"
bool SkTypeface_FreeType::Scanner::scanFont(
- SkStream* stream, int ttcIndex,
+ SkStreamAsset* stream, int ttcIndex,
SkString* name, SkFontStyle* style, bool* isFixedPitch, AxisDefinitions* axes) const
{
SkAutoMutexAcquire libraryLock(fLibraryMutex);
SkFixed fMaximum;
};
using AxisDefinitions = SkSTArray<4, AxisDefinition, true>;
- bool recognizedFont(SkStream* stream, int* numFonts) const;
- bool scanFont(SkStream* stream, int ttcIndex,
+ bool recognizedFont(SkStreamAsset* stream, int* numFonts) const;
+ bool scanFont(SkStreamAsset* stream, int ttcIndex,
SkString* name, SkFontStyle* style, bool* isFixedPitch,
AxisDefinitions* axes) const;
static void computeAxisValues(
const SkString& name);
private:
- FT_Face openFace(SkStream* stream, int ttcIndex, FT_Stream ftStream) const;
+ FT_Face openFace(SkStreamAsset* stream, int ttcIndex, FT_Stream ftStream) const;
FT_Library fLibrary;
mutable SkMutex fLibraryMutex;
};
#include "SkFontDescriptor.h"
#include "SkFontMgr.h"
#include "SkGlyph.h"
+#include "SkMakeUnique.h"
#include "SkMaskGamma.h"
#include "SkMathPriv.h"
#include "SkMutex.h"
protected:
int onGetUPEM() const override;
SkStreamAsset* onOpenStream(int* ttcIndex) const override;
- SkFontData* onCreateFontData() const override;
+ std::unique_ptr<SkFontData> onMakeFontData() const override;
void onGetFamilyName(SkString* familyName) const override;
SkTypeface::LocalizedStrings* onCreateFamilyNameIterator() const override;
int onGetTableTags(SkFontTableTag tags[]) const override;
return true;
}
-SkFontData* SkTypeface_Mac::onCreateFontData() const {
+std::unique_ptr<SkFontData> SkTypeface_Mac::onMakeFontData() const {
int index;
- SkAutoTDelete<SkStreamAsset> stream(this->onOpenStream(&index));
+ std::unique_ptr<SkStreamAsset> stream(this->onOpenStream(&index));
CFIndex cgAxisCount;
SkAutoSTMalloc<4, SkFixed> axisValues;
if (get_variations(fFontRef, &cgAxisCount, &axisValues)) {
- return new SkFontData(stream.release(), index, axisValues.get(), cgAxisCount);
+ return skstd::make_unique<SkFontData>(std::move(stream), index,
+ axisValues.get(), cgAxisCount);
}
- return new SkFontData(stream.release(), index, nullptr, 0);
+ return skstd::make_unique<SkFontData>(std::move(stream), index, nullptr, 0);
}
///////////////////////////////////////////////////////////////////////////////
}
SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
- AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromData(data));
+ AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromData(sk_ref_sp(data)));
if (nullptr == pr) {
return nullptr;
}
return create_from_dataProvider(pr);
}
- SkTypeface* onCreateFromStream(SkStreamAsset* stream, int ttcIndex) const override {
- AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromStream(stream));
+ SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
+ std::unique_ptr<SkStreamAsset> stream(bareStream);
+ AutoCFRelease<CGDataProviderRef> pr(SkCreateDataProviderFromStream(std::move(stream)));
if (nullptr == pr) {
return nullptr;
}
}
return dict;
}
- SkTypeface* onCreateFromStream(SkStreamAsset* s, const FontParameters& params) const override {
- AutoCFRelease<CGDataProviderRef> provider(SkCreateDataProviderFromStream(s));
+ SkTypeface* onCreateFromStream(SkStreamAsset* bs, const FontParameters& params) const override {
+ std::unique_ptr<SkStreamAsset> s(bs);
+ AutoCFRelease<CGDataProviderRef> provider(SkCreateDataProviderFromStream(std::move(s)));
if (nullptr == provider) {
return nullptr;
}
}
return dict;
}
- SkTypeface* onCreateFromFontData(SkFontData* data) const override {
- SkAutoTDelete<SkFontData> fontData(data);
- SkStreamAsset* stream = fontData->detachStream();
- AutoCFRelease<CGDataProviderRef> provider(SkCreateDataProviderFromStream(stream));
+ SkTypeface* onCreateFromFontData(std::unique_ptr<SkFontData> fontData) const override {
+ AutoCFRelease<CGDataProviderRef> provider(
+ SkCreateDataProviderFromStream(fontData->detachStream()));
if (nullptr == provider) {
return nullptr;
}
return nullptr;
}
- AutoCFRelease<CFDictionaryRef> cgVariations(get_axes(cg, fontData));
+ AutoCFRelease<CFDictionaryRef> cgVariations(get_axes(cg, fontData.get()));
// The CGFontRef returned by CGFontCreateCopyWithVariations when the passed CGFontRef was
// created from a data provider does not appear to have any ownership of the underlying
// data. The original CGFontRef must be kept alive until the copy will no longer be used.
SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
// could be in base impl
- return this->createFromStream(SkStream::NewFromFile(path));
+ return this->createFromStream(SkStream::MakeFromFile(path).release());
}
SkTypeface* onLegacyCreateTypeface(const char familyName[], SkFontStyle style) const override {
#include "SkFontDescriptor.h"
#include "SkFontMgr.h"
#include "SkFontStyle.h"
+#include "SkMakeUnique.h"
#include "SkMutex.h"
#include "SkString.h"
#include "SkTypeface.h"
return fFCI->openStream(this->getIdentity());
}
-SkFontData* SkTypeface_FCI::onCreateFontData() const {
+std::unique_ptr<SkFontData> SkTypeface_FCI::onMakeFontData() const {
if (fFontData) {
- return new SkFontData(*fFontData.get());
+ return skstd::make_unique<SkFontData>(*fFontData);
}
const SkFontConfigInterface::FontIdentity& id = this->getIdentity();
- return new SkFontData( fFCI->openStream(id), id.fTTCIndex, nullptr, 0);
+ return skstd::make_unique<SkFontData>(std::unique_ptr<SkStreamAsset>(fFCI->openStream(id)),
+ id.fTTCIndex, nullptr, 0);
}
void SkTypeface_FCI::onGetFontDescriptor(SkFontDescriptor* desc, bool* isLocalStream) const {
SkTypeface* onCreateFromData(SkData*, int ttcIndex) const override { return nullptr; }
SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
- SkAutoTDelete<SkStreamAsset> stream(bareStream);
+ std::unique_ptr<SkStreamAsset> stream(bareStream);
const size_t length = stream->getLength();
if (!length) {
return nullptr;
// TODO should the caller give us the style or should we get it from freetype?
SkFontStyle style;
bool isFixedPitch = false;
- if (!fScanner.scanFont(stream, 0, nullptr, &style, &isFixedPitch, nullptr)) {
+ if (!fScanner.scanFont(stream.get(), 0, nullptr, &style, &isFixedPitch, nullptr)) {
return nullptr;
}
- std::unique_ptr<SkFontData> fontData(new SkFontData(stream.release(), ttcIndex,
- nullptr, 0));
+ auto fontData = skstd::make_unique<SkFontData>(std::move(stream), ttcIndex, nullptr, 0);
return SkTypeface_FCI::Create(std::move(fontData), style, isFixedPitch);
}
SkTypeface* onCreateFromStream(SkStreamAsset* s, const FontParameters& params) const override {
using Scanner = SkTypeface_FreeType::Scanner;
- SkAutoTDelete<SkStreamAsset> stream(s);
+ std::unique_ptr<SkStreamAsset> stream(s);
const size_t length = stream->getLength();
if (!length) {
return nullptr;
SkFontStyle style;
SkString name;
Scanner::AxisDefinitions axisDefinitions;
- if (!fScanner.scanFont(stream, params.getCollectionIndex(), &name, &style, &isFixedPitch,
- &axisDefinitions))
+ if (!fScanner.scanFont(stream.get(), params.getCollectionIndex(),
+ &name, &style, &isFixedPitch, &axisDefinitions))
{
return nullptr;
}
SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
Scanner::computeAxisValues(axisDefinitions, paramAxes, paramAxisCount, axisValues, name);
- std::unique_ptr<SkFontData> fontData(new SkFontData(stream.release(),
- params.getCollectionIndex(),
- axisValues.get(),
- axisDefinitions.count()));
+ auto fontData = skstd::make_unique<SkFontData>(std::move(stream),
+ params.getCollectionIndex(),
+ axisValues.get(),
+ axisDefinitions.count());
return SkTypeface_FCI::Create(std::move(fontData), style, isFixedPitch);
}
SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
- SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
+ std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(path);
return stream.get() ? this->createFromStream(stream.release(), ttcIndex) : nullptr;
}
#include "SkFontMgr_android.h"
#include "SkFontMgr_android_parser.h"
#include "SkFontStyle.h"
+#include "SkMakeUnique.h"
#include "SkOSFile.h"
#include "SkPaint.h"
#include "SkRefCnt.h"
}
}
- SkStreamAsset* createStream() const {
+ std::unique_ptr<SkStreamAsset> makeStream() const {
if (fFile) {
sk_sp<SkData> data(SkData::MakeFromFILE(fFile));
- return data ? new SkMemoryStream(std::move(data)) : nullptr;
+ return data ? skstd::make_unique<SkMemoryStream>(std::move(data)) : nullptr;
}
- return SkStream::NewFromFile(fPathName.c_str());
+ return SkStream::MakeFromFile(fPathName.c_str());
}
virtual void onGetFontDescriptor(SkFontDescriptor* desc, bool* serialize) const override {
}
SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = fIndex;
- return this->createStream();
+ return this->makeStream().release();
}
- SkFontData* onCreateFontData() const override {
- return new SkFontData(this->createStream(), fIndex, fAxes.begin(), fAxes.count());
+ std::unique_ptr<SkFontData> onMakeFontData() const override {
+ return skstd::make_unique<SkFontData>(this->makeStream(), fIndex,
+ fAxes.begin(), fAxes.count());
}
const SkString fPathName;
class SkTypeface_AndroidStream : public SkTypeface_Android {
public:
- SkTypeface_AndroidStream(SkFontData* data,
+ SkTypeface_AndroidStream(std::unique_ptr<SkFontData> data,
const SkFontStyle& style,
bool isFixedPitch,
const SkString& familyName)
: INHERITED(style, isFixedPitch, familyName)
- , fData(data)
+ , fData(std::move(data))
{ }
virtual void onGetFontDescriptor(SkFontDescriptor* desc,
SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = fData->getIndex();
- return fData->duplicateStream();
+ return fData->getStream()->duplicate();
}
- SkFontData* onCreateFontData() const override {
- return new SkFontData(*fData.get());
+ std::unique_ptr<SkFontData> onMakeFontData() const override {
+ return skstd::make_unique<SkFontData>(*fData);
}
private:
- const SkAutoTDelete<const SkFontData> fData;
+ const std::unique_ptr<const SkFontData> fData;
typedef SkTypeface_Android INHERITED;
};
SkString pathName(family.fBasePath);
pathName.append(fontFile.fFileName);
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(pathName.c_str()));
- if (!stream.get()) {
+ std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(pathName.c_str());
+ if (!stream) {
SkDEBUGF(("Requested font file %s does not exist or cannot be opened.\n",
pathName.c_str()));
continue;
}
SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
- SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
+ std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(path);
return stream.get() ? this->createFromStream(stream.release(), ttcIndex) : nullptr;
}
SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
- SkAutoTDelete<SkStreamAsset> stream(bareStream);
+ std::unique_ptr<SkStreamAsset> stream(bareStream);
bool isFixedPitch;
SkFontStyle style;
SkString name;
- if (!fScanner.scanFont(stream, ttcIndex, &name, &style, &isFixedPitch, nullptr)) {
+ if (!fScanner.scanFont(stream.get(), ttcIndex, &name, &style, &isFixedPitch, nullptr)) {
return nullptr;
}
- SkFontData* data(new SkFontData(stream.release(), ttcIndex, nullptr, 0));
- return new SkTypeface_AndroidStream(data, style, isFixedPitch, name);
+ auto data = skstd::make_unique<SkFontData>(std::move(stream), ttcIndex, nullptr, 0);
+ return new SkTypeface_AndroidStream(std::move(data), style, isFixedPitch, name);
}
SkTypeface* onCreateFromStream(SkStreamAsset* s, const FontParameters& params) const override {
using Scanner = SkTypeface_FreeType::Scanner;
- SkAutoTDelete<SkStreamAsset> stream(s);
+ std::unique_ptr<SkStreamAsset> stream(s);
bool isFixedPitch;
SkFontStyle style;
SkString name;
Scanner::AxisDefinitions axisDefinitions;
- if (!fScanner.scanFont(stream, params.getCollectionIndex(), &name, &style, &isFixedPitch,
- &axisDefinitions))
+ if (!fScanner.scanFont(stream.get(), params.getCollectionIndex(),
+ &name, &style, &isFixedPitch, &axisDefinitions))
{
return nullptr;
}
SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
Scanner::computeAxisValues(axisDefinitions, paramAxes, paramAxisCount, axisValues, name);
- SkFontData* data(new SkFontData(stream.release(), params.getCollectionIndex(),
- axisValues.get(), axisDefinitions.count()));
- return new SkTypeface_AndroidStream(data, style, isFixedPitch, name);
+ auto data = skstd::make_unique<SkFontData>(std::move(stream), params.getCollectionIndex(),
+ axisValues.get(), axisDefinitions.count());
+ return new SkTypeface_AndroidStream(std::move(data), style, isFixedPitch, name);
}
- SkTypeface* onCreateFromFontData(SkFontData* data) const override {
+ SkTypeface* onCreateFromFontData(std::unique_ptr<SkFontData> data) const override {
SkStreamAsset* stream(data->getStream());
bool isFixedPitch;
SkFontStyle style;
if (!fScanner.scanFont(stream, data->getIndex(), &name, &style, &isFixedPitch, nullptr)) {
return nullptr;
}
- return new SkTypeface_AndroidStream(data, style, isFixedPitch, name);
+ return new SkTypeface_AndroidStream(std::move(data), style, isFixedPitch, name);
}
SkTypeface* onLegacyCreateTypeface(const char familyName[], SkFontStyle style) const override {
#include "SkFontMgr.h"
#include "SkFontMgr_custom.h"
#include "SkFontStyle.h"
+#include "SkMakeUnique.h"
#include "SkOSFile.h"
#include "SkRefCnt.h"
#include "SkStream.h"
protected:
SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = fData->getIndex();
- return fData->duplicateStream();
+ return fData->getStream()->duplicate();
}
- SkFontData* onCreateFontData() const override {
- return new SkFontData(*fData.get());
+ std::unique_ptr<SkFontData> onMakeFontData() const override {
+ return skstd::make_unique<SkFontData>(*fData);
}
private:
- std::unique_ptr<const SkFontData> fData;
+ const std::unique_ptr<const SkFontData> fData;
typedef SkTypeface_Custom INHERITED;
};
protected:
SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = this->getIndex();
- return SkStream::NewFromFile(fPath.c_str());
+ return SkStream::MakeFromFile(fPath.c_str()).release();
}
private:
SkTypeface* onCreateFromStream(SkStreamAsset* s, const FontParameters& params) const override {
using Scanner = SkTypeface_FreeType::Scanner;
- SkAutoTDelete<SkStreamAsset> stream(s);
+ std::unique_ptr<SkStreamAsset> stream(s);
bool isFixedPitch;
SkFontStyle style;
SkString name;
Scanner::AxisDefinitions axisDefinitions;
- if (!fScanner.scanFont(stream, params.getCollectionIndex(), &name, &style, &isFixedPitch,
- &axisDefinitions))
+ if (!fScanner.scanFont(stream.get(), params.getCollectionIndex(),
+ &name, &style, &isFixedPitch, &axisDefinitions))
{
return nullptr;
}
SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
Scanner::computeAxisValues(axisDefinitions, paramAxes, paramAxisCount, axisValues, name);
- std::unique_ptr<SkFontData> data(new SkFontData(stream.release(),
- params.getCollectionIndex(),
- axisValues.get(), axisDefinitions.count()));
+ auto data = skstd::make_unique<SkFontData>(std::move(stream), params.getCollectionIndex(),
+ axisValues.get(), axisDefinitions.count());
return new SkTypeface_Stream(std::move(data), style, isFixedPitch, false, name);
}
- SkTypeface* onCreateFromFontData(SkFontData* data) const override {
+ SkTypeface* onCreateFromFontData(std::unique_ptr<SkFontData> data) const override {
bool isFixedPitch;
SkFontStyle style;
SkString name;
{
return nullptr;
}
- std::unique_ptr<SkFontData> unique_data(data);
- return new SkTypeface_Stream(std::move(unique_data), style, isFixedPitch, false, name);
+ return new SkTypeface_Stream(std::move(data), style, isFixedPitch, false, name);
}
SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
- SkAutoTDelete<SkStreamAsset> stream(SkStream::NewFromFile(path));
+ std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(path);
return stream.get() ? this->createFromStream(stream.release(), ttcIndex) : nullptr;
}
while (iter.next(&name, false)) {
SkString filename(SkOSPath::Join(directory.c_str(), name.c_str()));
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(filename.c_str()));
- if (!stream.get()) {
+ std::unique_ptr<SkStreamAsset> stream = SkStream::MakeFromFile(filename.c_str());
+ if (!stream) {
SkDebugf("---- failed to open <%s>\n", filename.c_str());
continue;
}
int numFaces;
- if (!scanner.recognizedFont(stream, &numFaces)) {
+ if (!scanner.recognizedFont(stream.get(), &numFaces)) {
SkDebugf("---- failed to open <%s> as a font\n", filename.c_str());
continue;
}
bool isFixedPitch;
SkString realname;
SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
- if (!scanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch, nullptr)) {
+ if (!scanner.scanFont(stream.get(), faceIndex,
+ &realname, &style, &isFixedPitch, nullptr))
+ {
SkDebugf("---- failed to open <%s> <%d> as a font\n",
filename.c_str(), faceIndex);
continue;
const uint8_t* data, size_t size, int index,
SkFontMgr_Custom::Families* families)
{
- SkAutoTDelete<SkMemoryStream> stream(new SkMemoryStream(data, size, false));
+ auto stream = skstd::make_unique<SkMemoryStream>(data, size, false);
int numFaces;
- if (!scanner.recognizedFont(stream, &numFaces)) {
+ if (!scanner.recognizedFont(stream.get(), &numFaces)) {
SkDebugf("---- failed to open <%d> as a font\n", index);
return;
}
bool isFixedPitch;
SkString realname;
SkFontStyle style = SkFontStyle(); // avoid uninitialized warning
- if (!scanner.scanFont(stream, faceIndex, &realname, &style, &isFixedPitch, nullptr)) {
+ if (!scanner.scanFont(stream.get(), faceIndex,
+ &realname, &style, &isFixedPitch, nullptr))
+ {
SkDebugf("---- failed to open <%d> <%d> as a font\n", index, faceIndex);
return;
}
addTo = new SkFontStyleSet_Custom(realname);
families->push_back().reset(addTo);
}
- std::unique_ptr<SkFontData> data(
- new SkFontData(stream.release(), faceIndex, nullptr, 0));
+ auto data = skstd::make_unique<SkFontData>(std::move(stream), faceIndex, nullptr, 0);
addTo->appendTypeface(sk_make_sp<SkTypeface_Stream>(std::move(data),
style, isFixedPitch,
true, realname));
#include "SkFontHost_FreeType_common.h"
#include "SkFontMgr.h"
#include "SkFontStyle.h"
+#include "SkMakeUnique.h"
#include "SkMath.h"
#include "SkMutex.h"
#include "SkOSFile.h"
class SkTypeface_stream : public SkTypeface_FreeType {
public:
/** @param data takes ownership of the font data.*/
- SkTypeface_stream(SkFontData* data, const SkFontStyle& style, bool fixedWidth)
+ SkTypeface_stream(std::unique_ptr<SkFontData> data, const SkFontStyle& style, bool fixedWidth)
: INHERITED(style, fixedWidth)
- , fData(data)
+ , fData(std::move(data))
{ };
void onGetFamilyName(SkString* familyName) const override {
SkStreamAsset* onOpenStream(int* ttcIndex) const override {
*ttcIndex = fData->getIndex();
- return fData->duplicateStream();
+ return fData->getStream()->duplicate();
}
- SkFontData* onCreateFontData() const override {
- return new SkFontData(*fData.get());
+ std::unique_ptr<SkFontData> onMakeFontData() const override {
+ return skstd::make_unique<SkFontData>(*fData);
}
private:
- const SkAutoTDelete<const SkFontData> fData;
+ const std::unique_ptr<const SkFontData> fData;
typedef SkTypeface_FreeType INHERITED;
};
SkStreamAsset* onOpenStream(int* ttcIndex) const override {
FCLocker lock;
*ttcIndex = get_int(fPattern, FC_INDEX, 0);
- return SkStream::NewFromFile(get_string(fPattern, FC_FILE));
+ return SkStream::MakeFromFile(get_string(fPattern, FC_FILE)).release();
}
void onFilterRec(SkScalerContextRec* rec) const override {
}
SkTypeface* onCreateFromStream(SkStreamAsset* bareStream, int ttcIndex) const override {
- SkAutoTDelete<SkStreamAsset> stream(bareStream);
+ std::unique_ptr<SkStreamAsset> stream(bareStream);
const size_t length = stream->getLength();
if (length <= 0 || (1u << 30) < length) {
return nullptr;
SkFontStyle style;
bool isFixedWidth = false;
- if (!fScanner.scanFont(stream, ttcIndex, nullptr, &style, &isFixedWidth, nullptr)) {
+ if (!fScanner.scanFont(stream.get(), ttcIndex, nullptr, &style, &isFixedWidth, nullptr)) {
return nullptr;
}
- return new SkTypeface_stream(new SkFontData(stream.release(), ttcIndex, nullptr, 0), style,
- isFixedWidth);
+ auto data = skstd::make_unique<SkFontData>(std::move(stream), ttcIndex, nullptr, 0);
+ return new SkTypeface_stream(std::move(data), style, isFixedWidth);
}
SkTypeface* onCreateFromStream(SkStreamAsset* s, const FontParameters& params) const override {
using Scanner = SkTypeface_FreeType::Scanner;
- SkAutoTDelete<SkStreamAsset> stream(s);
+ std::unique_ptr<SkStreamAsset> stream(s);
bool isFixedPitch;
SkFontStyle style;
SkString name;
Scanner::AxisDefinitions axisDefinitions;
- if (!fScanner.scanFont(stream, params.getCollectionIndex(), &name, &style, &isFixedPitch,
- &axisDefinitions))
+ if (!fScanner.scanFont(stream.get(), params.getCollectionIndex(),
+ &name, &style, &isFixedPitch, &axisDefinitions))
{
return nullptr;
}
SkAutoSTMalloc<4, SkFixed> axisValues(axisDefinitions.count());
Scanner::computeAxisValues(axisDefinitions, paramAxes, paramAxisCount, axisValues, name);
- SkFontData* data(new SkFontData(stream.release(), params.getCollectionIndex(),
- axisValues.get(), axisDefinitions.count()));
- return new SkTypeface_stream(data, style, isFixedPitch);
+ auto data = skstd::make_unique<SkFontData>(std::move(stream), params.getCollectionIndex(),
+ axisValues.get(), axisDefinitions.count());
+ return new SkTypeface_stream(std::move(data), style, isFixedPitch);
}
SkTypeface* onCreateFromData(SkData* data, int ttcIndex) const override {
}
SkTypeface* onCreateFromFile(const char path[], int ttcIndex) const override {
- return this->createFromStream(SkStream::NewFromFile(path), ttcIndex);
+ return this->createFromStream(SkStream::MakeFromFile(path).release(), ttcIndex);
}
- SkTypeface* onCreateFromFontData(SkFontData* fontData) const override {
+ SkTypeface* onCreateFromFontData(std::unique_ptr<SkFontData> fontData) const override {
SkStreamAsset* stream(fontData->getStream());
const size_t length = stream->getLength();
if (length <= 0 || (1u << 30) < length) {
return nullptr;
}
- return new SkTypeface_stream(fontData, style, isFixedWidth);
+ return new SkTypeface_stream(std::move(fontData), style, isFixedWidth);
}
SkTypeface* onLegacyCreateTypeface(const char familyName[], SkFontStyle style) const override {
}
SkTypeface* SkFontMgr_DirectWrite::onCreateFromFile(const char path[], int ttcIndex) const {
- return this->createFromStream(SkStream::NewFromFile(path), ttcIndex);
+ return this->createFromStream(SkStream::MakeFromFile(path).release(), ttcIndex);
}
HRESULT SkFontMgr_DirectWrite::getByFamilyName(const WCHAR wideFamilyName[],
}
static uint32_t compute_checksum(const SkTypeface* tf) {
- SkFontData* fontData = tf->createFontData();
+ std::unique_ptr<SkFontData> fontData = tf->makeFontData();
if (!fontData) {
return 0;
}
// Embed font data if it's a local font.
if (isLocal && !desc.hasFontData()) {
- desc.setFontData(tf->createFontData());
+ desc.setFontData(tf->makeFontData());
}
desc.serialize(wstream);
}
return nullptr;
}
- SkFontData* data = desc.detachFontData();
+ std::unique_ptr<SkFontData> data = desc.detachFontData();
if (data) {
- sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(data));
+ sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(std::move(data)));
if (typeface) {
return typeface;
}
}
}
-///////////////////////////////////////////////////////////////////////////////
-
-#include "SkStream.h"
-
-class SkAutoPDFRelease {
-public:
- SkAutoPDFRelease(CGPDFDocumentRef doc) : fDoc(doc) {}
- ~SkAutoPDFRelease() {
- if (fDoc) {
- CGPDFDocumentRelease(fDoc);
- }
- }
-private:
- CGPDFDocumentRef fDoc;
-};
-#define SkAutoPDFRelease(...) SK_REQUIRE_LOCAL_VAR(SkAutoPDFRelease)
-
-bool SkPDFDocumentToBitmap(SkStream* stream, SkBitmap* output) {
- CGDataProviderRef data = SkCreateDataProviderFromStream(stream);
- if (nullptr == data) {
- return false;
- }
-
- CGPDFDocumentRef pdf = CGPDFDocumentCreateWithProvider(data);
- CGDataProviderRelease(data);
- if (nullptr == pdf) {
- return false;
- }
- SkAutoPDFRelease releaseMe(pdf);
-
- CGPDFPageRef page = CGPDFDocumentGetPage(pdf, 1);
- if (nullptr == page) {
- return false;
- }
-
- CGRect bounds = CGPDFPageGetBoxRect(page, kCGPDFMediaBox);
-
- int w = (int)CGRectGetWidth(bounds);
- int h = (int)CGRectGetHeight(bounds);
-
- SkBitmap bitmap;
- if (!bitmap.tryAllocN32Pixels(w, h)) {
- return false;
- }
- bitmap.eraseColor(SK_ColorWHITE);
-
- size_t bitsPerComponent;
- CGBitmapInfo info;
- getBitmapInfo(bitmap, &bitsPerComponent, &info, nullptr);
-
- CGColorSpaceRef cs = CGColorSpaceCreateDeviceRGB();
- CGContextRef ctx = CGBitmapContextCreate(bitmap.getPixels(), w, h,
- bitsPerComponent, bitmap.rowBytes(),
- cs, info);
- CGColorSpaceRelease(cs);
-
- if (ctx) {
- CGContextDrawPDFPage(ctx, page);
- CGContextRelease(ctx);
- }
-
- output->swap(bitmap);
- return true;
-}
-
///////////////////////////////////////////////////////////////////////////////////////////////////
SK_API bool SkCopyPixelsFromCGImage(const SkImageInfo& info, size_t rowBytes, void* pixels,
delete (SkStream*)info;
}
-CGDataProviderRef SkCreateDataProviderFromStream(SkStream* stream) {
+CGDataProviderRef SkCreateDataProviderFromStream(std::unique_ptr<SkStream> stream) {
// TODO: Replace with SkStream::getData() when that is added. Then we only
// have one version of CGDataProviderCreateWithData (i.e. same release proc)
const void* addr = stream->getMemoryBase();
if (addr) {
// special-case when the stream is just a block of ram
- return CGDataProviderCreateWithData(stream, addr, stream->getLength(),
+ return CGDataProviderCreateWithData(stream.release(), addr, stream->getLength(),
delete_stream_proc);
}
rec.skipForward = skip_forward_proc;
rec.rewind = rewind_proc;
rec.releaseInfo = release_info_proc;
- return CGDataProviderCreateSequential(stream, &rec);
+ return CGDataProviderCreateSequential(stream.release(), &rec);
}
///////////////////////////////////////////////////////////////////////////////
#include "SkData.h"
-CGDataProviderRef SkCreateDataProviderFromData(SkData* data) {
- data->ref();
- return CGDataProviderCreateWithData(data, data->data(), data->size(),
- unref_proc);
+CGDataProviderRef SkCreateDataProviderFromData(sk_sp<SkData> data) {
+ return CGDataProviderCreateWithData(data.release(), data->data(), data->size(), unref_proc);
}
#endif//defined(SK_BUILD_FOR_MAC) || defined(SK_BUILD_FOR_IOS)
const char* badImagesFolder = "invalid_images";
- SkString resourcePath = GetResourcePath(badImagesFolder);
-
for (size_t i = 0; i < SK_ARRAY_COUNT(badImages); ++i) {
- SkString fullPath = SkOSPath::Join(resourcePath.c_str(), badImages[i]);
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(fullPath.c_str()));
+ SkString resourcePath = SkOSPath::Join(badImagesFolder, badImages[i]);
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(resourcePath.c_str()));
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
// These images are corrupt. It's not important whether we succeed/fail in codec
#include "png.h"
-static SkStreamAsset* resource(const char path[]) {
- SkString fullPath = GetResourcePath(path);
- return SkStream::NewFromFile(fullPath.c_str());
-}
-
static void md5(const SkBitmap& bm, SkMD5::Digest* digest) {
SkAutoLockPixels autoLockPixels(bm);
SkASSERT(bm.getPixels());
bool supportsSubsetDecoding,
bool supportsIncomplete = true) {
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
if (!stream) {
- SkDebugf("Missing resource '%s'\n", path);
return;
}
// SkAndroidCodec tests
if (supportsScanlineDecoding || supportsSubsetDecoding) {
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
if (!stream) {
- SkDebugf("Missing resource '%s'\n", path);
return;
}
if (!isIncomplete) {
// Test SkCodecImageGenerator
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
sk_sp<SkData> fullData(SkData::MakeFromStream(stream, stream->getLength()));
SkAutoTDelete<SkImageGenerator> gen(
SkCodecImageGenerator::NewFromEncodedCodec(fullData.get()));
// Test interlaced PNG in stripes, similar to DM's kStripe_Mode
DEF_TEST(Codec_stripes, r) {
const char * path = "plane_interlaced.png";
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
+ REPORTER_ASSERT(r, stream);
if (!stream) {
- SkDebugf("Missing resource '%s'\n", path);
+ return;
}
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
static void test_dimensions(skiatest::Reporter* r, const char path[]) {
// Create the codec from the resource file
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
if (!stream) {
- SkDebugf("Missing resource '%s'\n", path);
return;
}
SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
}
static void test_invalid(skiatest::Reporter* r, const char path[]) {
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
if (!stream) {
- SkDebugf("Missing resource '%s'\n", path);
return;
}
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
}
static void test_invalid_parameters(skiatest::Reporter* r, const char path[]) {
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
if (!stream) {
- SkDebugf("Missing resource '%s'\n", path);
return;
}
SkAutoTDelete<SkCodec> decoder(SkCodec::NewFromStream(stream.release()));
// Test that SkCodec now supports an image with these bits set.
DEF_TEST(Codec_wbmp, r) {
const char* path = "mandrill.wbmp";
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
if (!stream) {
- SkDebugf("Missing resource '%s'\n", path);
return;
}
DEF_TEST(Codec_jpeg_rewind, r) {
const char* path = "mandrill_512_q075.jpg";
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
if (!stream) {
- SkDebugf("Missing resource '%s'\n", path);
return;
}
SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(stream.release()));
}
static void check_color_xform(skiatest::Reporter* r, const char* path) {
- SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(resource(path)));
+ SkAutoTDelete<SkAndroidCodec> codec(SkAndroidCodec::NewFromStream(GetResourceAsStream(path)));
SkAndroidCodec::AndroidOptions opts;
opts.fSampleSize = 3;
DEF_TEST(Codec_PngRoundTrip, r) {
const char* path = "mandrill_512_q075.jpg";
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
SkColorType colorTypesOpaque[] = {
}
path = "grayscale.jpg";
- stream.reset(resource(path));
+ stream.reset(GetResourceAsStream(path));
codec.reset(SkCodec::NewFromStream(stream.release()));
check_round_trip(r, codec.get(), codec->getInfo());
path = "yellow_rose.png";
- stream.reset(resource(path));
+ stream.reset(GetResourceAsStream(path));
codec.reset(SkCodec::NewFromStream(stream.release()));
SkColorType colorTypesWithAlpha[] = {
}
path = "index8.png";
- stream.reset(resource(path));
+ stream.reset(GetResourceAsStream(path));
codec.reset(SkCodec::NewFromStream(stream.release()));
for (SkAlphaType alphaType : alphaTypes) {
static void test_conversion_possible(skiatest::Reporter* r, const char* path,
bool testScanlineDecoder) {
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
SkImageInfo infoF16 = codec->getInfo().makeColorType(kRGBA_F16_SkColorType);
}
}
-static SkStreamAsset* resource(const char path[]) {
- SkString fullPath = GetResourcePath(path);
- return SkStream::NewFromFile(fullPath.c_str());
-}
-
static void test_path(skiatest::Reporter* r, const char* path,
const float red[], const float green[], const float blue[],
const SkGammaNamed expectedGamma) {
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
REPORTER_ASSERT(r, nullptr != stream);
if (!stream) {
return;
#include "SkCodec.h"
#include "Test.h"
-static SkStreamAsset* resource(const char path[]) {
- SkString fullPath = GetResourcePath(path);
- return SkStream::NewFromFile(fullPath.c_str());
-}
-
DEF_TEST(ExifOrientation, r) {
- SkAutoTDelete<SkStream> stream(resource("exif-orientation-2-ur.jpg"));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream("exif-orientation-2-ur.jpg"));
REPORTER_ASSERT(r, nullptr != stream);
if (!stream) {
return;
SkCodec::Origin origin = codec->getOrigin();
REPORTER_ASSERT(r, SkCodec::kTopRight_Origin == origin);
- stream.reset(resource("mandrill_512_q075.jpg"));
+ stream.reset(GetResourceAsStream("mandrill_512_q075.jpg"));
codec.reset(SkCodec::NewFromStream(stream.release()));
REPORTER_ASSERT(r, nullptr != codec);
origin = codec->getOrigin();
#include "SkImage.h"
#include "SkImageSource.h"
#include "SkLightingShader.h"
+#include "SkMakeUnique.h"
#include "SkMallocPixelRef.h"
#include "SkNormalSource.h"
#include "SkOSFile.h"
{
// Load typeface as stream to create with axis settings.
- SkAutoTDelete<SkStreamAsset> distortable(GetResourceAsStream("/fonts/Distortable.ttf"));
+ std::unique_ptr<SkStreamAsset> distortable(GetResourceAsStream("/fonts/Distortable.ttf"));
if (!distortable) {
INFOF(reporter, "Could not run fontstream test because Distortable.ttf not found.");
} else {
SkFixed axis = SK_FixedSqrt2;
sk_sp<SkTypeface> typeface(SkTypeface::MakeFromFontData(
- new SkFontData(distortable.release(), 0, &axis, 1)));
+ skstd::make_unique<SkFontData>(std::move(distortable), 0, &axis, 1)));
if (!typeface) {
INFOF(reporter, "Could not run fontstream test because Distortable.ttf not created.");
} else {
#include "SkYUVSizeInfo.h"
#include "Test.h"
-static SkStreamAsset* resource(const char path[]) {
- SkString fullPath = GetResourcePath(path);
- return SkStream::NewFromFile(fullPath.c_str());
-}
-
static void codec_yuv(skiatest::Reporter* reporter,
const char path[],
SkISize expectedSizes[3]) {
- SkAutoTDelete<SkStream> stream(resource(path));
+ SkAutoTDelete<SkStream> stream(GetResourceAsStream(path));
if (!stream) {
- INFOF(reporter, "Missing resource '%s'\n", path);
return;
}
SkAutoTDelete<SkCodec> codec(SkCodec::NewFromStream(stream.release()));
SkStreamAsset* GetResourceAsStream(const char* resource) {
SkString resourcePath = GetResourcePath(resource);
SkAutoTDelete<SkFILEStream> stream(new SkFILEStream(resourcePath.c_str()));
- if (stream->isValid()) {
- return stream.release();
- } else {
+ if (!stream->isValid()) {
SkDebugf("Resource %s not found.\n", resource);
return nullptr;
}
+ return stream.release();
}
sk_sp<SkTypeface> MakeResourceAsTypeface(const char* resource) {
continue;
}
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(FLAGS_skps[i]));
+ std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(FLAGS_skps[i]);
if (!stream) {
SkDebugf("Could not read %s.\n", FLAGS_skps[i]);
return 1;
}
- sk_sp<SkPicture> src(SkPicture::MakeFromStream(stream));
+ sk_sp<SkPicture> src(SkPicture::MakeFromStream(stream.get()));
if (!src) {
SkDebugf("Could not read %s as an SkPicture.\n", FLAGS_skps[i]);
return 1;
SkOSFile::Iter iter(inputs, "skp");
for (SkString file; iter.next(&file); ) {
- SkAutoTDelete<SkStream> stream =
- SkStream::NewFromFile(SkOSPath::Join(inputs, file.c_str()).c_str());
- sk_sp<SkPicture> picture(SkPicture::MakeFromStream(stream));
+ std::unique_ptr<SkStream> stream =
+ SkStream::MakeFromFile(SkOSPath::Join(inputs, file.c_str()).c_str());
+ sk_sp<SkPicture> picture(SkPicture::MakeFromStream(stream.get()));
SkDynamicMemoryWStream scratch;
Sniffer sniff(file.c_str());
DEFINE_bool2(quiet, q, false, "Silence all non-error related output");
static sk_sp<SkPicture> load_picture(const char path[]) {
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(path));
- if (stream.get()) {
+ std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(path);
+ if (stream) {
return SkPicture::MakeFromStream(stream.get());
}
return nullptr;
}
static sk_sp<SkPicture> read_picture(const char path[]) {
- SkAutoTDelete<SkStream> stream(SkStream::NewFromFile(path));
- if (stream.get() == nullptr) {
+ std::unique_ptr<SkStream> stream = SkStream::MakeFromFile(path);
+ if (!stream) {
SkDebugf("Could not read %s.\n", path);
return nullptr;
}
projects / platform / upstream / libSkiaSharp.git / commitdiff