SkPDFMetadata.cpp File Reference

#include "src/pdf/SkPDFMetadata.h"
#include "include/private/base/SkTemplates.h"
#include "include/private/base/SkTo.h"
#include "src/base/SkUTF.h"
#include "src/base/SkUtils.h"
#include "src/core/SkMD5.h"
#include "src/pdf/SkPDFTypes.h"
#include "src/pdf/SkPDFUtils.h"
#include <utility>

Go to the source code of this file.

Functions
static bool	operator!= (const SkPDF::DateTime &u, const SkPDF::DateTime &v)
static SkString	pdf_date (const SkPDF::DateTime &dt)
static void	hexify (const uint8_t **inputPtr, char **outputPtr, int count)
static SkString	uuid_to_string (const SkUUID &uuid)
static int	count_xml_escape_size (const SkString &input)
SkString	escape_xml (const SkString &input, const char *before=nullptr, const char *after=nullptr)

Variables
static constexpr SkPDF::DateTime	kZeroTime = {0, 0, 0, 0, 0, 0, 0, 0}

Function Documentation

count_xml_escape_size()

static int count_xml_escape_size ( const SkString &  input )

static

Definition at line 175 of file SkPDFMetadata.cpp.

                                                        {
    int extra = 0;
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] == '&') {
            extra += 4;  // strlen("&amp;") - strlen("&")
        } else if (input[i] == '<') {
            extra += 3;  // strlen("&lt;") - strlen("<")
        }
    }
    return extra;
}

escape_xml()

SkString escape_xml	(	const SkString &	input,
		const char *	before = nullptr,
		const char *	after = nullptr
	)

Definition at line 187 of file SkPDFMetadata.cpp.

                                                 {
    if (input.size() == 0) {
        return input;
    }
    // "&" --> "&amp;" and  "<" --> "&lt;"
    // text is assumed to be in UTF-8
    // all strings are xml content, not attribute values.
    size_t beforeLen = before ? strlen(before) : 0;
    size_t afterLen = after ? strlen(after) : 0;
    int extra = count_xml_escape_size(input);
    SkString output(input.size() + extra + beforeLen + afterLen);
    char* out = output.data();
    if (before) {
        strncpy(out, before, beforeLen);
        out += beforeLen;
    }
    static const char kAmp[] = "&amp;";
    static const char kLt[] = "&lt;";
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] == '&') {
            memcpy(out, kAmp, strlen(kAmp));
            out += strlen(kAmp);
        } else if (input[i] == '<') {
            memcpy(out, kLt, strlen(kLt));
            out += strlen(kLt);
        } else {
            *out++ = input[i];
        }
    }
    if (after) {
        strncpy(out, after, afterLen);
        out += afterLen;
    }
    // Validate that we haven't written outside of our string.
    SkASSERT(out == &output.data()[output.size()]);
    *out = '\0';
    return output;
}

hexify()

static void hexify ( const uint8_t **  inputPtr, char **  outputPtr, int  count  )

static

Definition at line 122 of file SkPDFMetadata.cpp.

                                                                          {
    SkASSERT(inputPtr && *inputPtr);
    SkASSERT(outputPtr && *outputPtr);
    while (count-- > 0) {
        uint8_t value = *(*inputPtr)++;
        *(*outputPtr)++ = SkHexadecimalDigits::gLower[value >> 4];
        *(*outputPtr)++ = SkHexadecimalDigits::gLower[value & 0xF];
    }
}

operator!=()

static bool operator!= ( const SkPDF::DateTime &  u, const SkPDF::DateTime &  v  )

static

Definition at line 22 of file SkPDFMetadata.cpp.

                                                                       {
    return u.fTimeZoneMinutes != v.fTimeZoneMinutes ||
           u.fYear != v.fYear ||
           u.fMonth != v.fMonth ||
           u.fDayOfWeek != v.fDayOfWeek ||
           u.fDay != v.fDay ||
           u.fHour != v.fHour ||
           u.fMinute != v.fMinute ||
           u.fSecond != v.fSecond;
}

pdf_date()

static SkString pdf_date ( const SkPDF::DateTime &  dt )

static

Definition at line 33 of file SkPDFMetadata.cpp.

                                                  {
    int timeZoneMinutes = SkToInt(dt.fTimeZoneMinutes);
    char timezoneSign = timeZoneMinutes >= 0 ? '+' : '-';
    int timeZoneHours = SkTAbs(timeZoneMinutes) / 60;
    timeZoneMinutes = SkTAbs(timeZoneMinutes) % 60;
    return SkStringPrintf(
            "D:%04u%02u%02u%02u%02u%02u%c%02d'%02d'",
            static_cast<unsigned>(dt.fYear), static_cast<unsigned>(dt.fMonth),
            static_cast<unsigned>(dt.fDay), static_cast<unsigned>(dt.fHour),
            static_cast<unsigned>(dt.fMinute),
            static_cast<unsigned>(dt.fSecond), timezoneSign, timeZoneHours,
            timeZoneMinutes);
}

uuid_to_string()

static SkString uuid_to_string ( const SkUUID &  uuid )

static

Definition at line 132 of file SkPDFMetadata.cpp.

                                                   {
    //  8-4-4-4-12
    char buffer[36];  // [32 + 4]
    char* ptr = buffer;
    const uint8_t* data = uuid.fData;
    hexify(&data, &ptr, 4);
    *ptr++ = '-';
    hexify(&data, &ptr, 2);
    *ptr++ = '-';
    hexify(&data, &ptr, 2);
    *ptr++ = '-';
    hexify(&data, &ptr, 2);
    *ptr++ = '-';
    hexify(&data, &ptr, 6);
    SkASSERT(ptr == buffer + 36);
    SkASSERT(data == uuid.fData + 16);
    return SkString(buffer, 36);
}

Variable Documentation

kZeroTime

constexpr SkPDF::DateTime kZeroTime = {0, 0, 0, 0, 0, 0, 0, 0}

staticconstexpr

Definition at line 20 of file SkPDFMetadata.cpp.

{0, 0, 0, 0, 0, 0, 0, 0};