The Tor Browser: gfx/skia/trunk/include/xml/SkXMLParser.h@129ffea94266

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

     2 /*

     3  * Copyright 2006 The Android Open Source Project

     4  *

     5  * Use of this source code is governed by a BSD-style license that can be

     6  * found in the LICENSE file.

     7  */

    10 #ifndef SkXMLParser_DEFINED

    11 #define SkXMLParser_DEFINED

    13 #include "SkString.h"

    15 class SkStream;

    17 class SkDOM;

    18 struct SkDOMNode;

    20 class SkXMLParserError {

    21 public:

    22     enum ErrorCode {

    23         kNoError,

    24         kEmptyFile,

    25         kUnknownElement,

    26         kUnknownAttributeName,

    27         kErrorInAttributeValue,

    28         kDuplicateIDs,

    29         kUnknownError

    30     };

    32     SkXMLParserError();

    33     virtual ~SkXMLParserError();

    34     ErrorCode getErrorCode() const { return fCode; }

    35     virtual void getErrorString(SkString* str) const;

    36     int getLineNumber() const { return fLineNumber; }

    37     int getNativeCode() const { return fNativeCode; }

    38     bool hasError() const { return fCode != kNoError || fNativeCode != -1; }

    39     bool hasNoun() const { return fNoun.size() > 0; }

    40     void reset();

    41     void setCode(ErrorCode code) { fCode = code; }

    42     void setNoun(const SkString& str) { fNoun.set(str); }

    43     void setNoun(const char* ch)  { fNoun.set(ch); }

    44     void setNoun(const char* ch, size_t len) { fNoun.set(ch, len); }

    45 protected:

    46     ErrorCode fCode;

    47 private:

    48     int fLineNumber;

    49     int fNativeCode;

    50     SkString fNoun;

    51     friend class SkXMLParser;

    52 };

    54 class SkXMLParser {

    55 public:

    56             SkXMLParser(SkXMLParserError* parserError = NULL);

    57     virtual ~SkXMLParser();

    59     /** Returns true for success

    60     */

    61     bool parse(const char doc[], size_t len);

    62     bool parse(SkStream& docStream);

    63     bool parse(const SkDOM&, const SkDOMNode*);

    65     static void GetNativeErrorString(int nativeErrorCode, SkString* str);

    67 protected:

    68     // override in subclasses; return true to stop parsing

    69     virtual bool onStartElement(const char elem[]);

    70     virtual bool onAddAttribute(const char name[], const char value[]);

    71     virtual bool onEndElement(const char elem[]);

    72     virtual bool onText(const char text[], int len);

    74 public:

    75     // public for ported implementation, not meant for clients to call

    76     virtual bool startElement(const char elem[]);

    77     virtual bool addAttribute(const char name[], const char value[]);

    78     virtual bool endElement(const char elem[]);

    79     virtual bool text(const char text[], int len);

    80     void* fParser;

    81 protected:

    82     SkXMLParserError* fError;

    83 private:

    84     void reportError(void* parser);

    85 };

    87 #if 0

    88 class SkXMLPullParser {

    89 public:

    90             SkXMLPullParser();

    91     explicit SkXMLPullParser(SkStream*);

    92     virtual ~SkXMLPullParser();

    94     SkStream*   getStream() const { return fStream; }

    95     SkStream*   setStream(SkStream* stream);

    97     enum EventType {

    98         ERROR = -1,

    99         START_DOCUMENT,

   100         END_DOCUMENT,

   101         START_TAG,

   102         END_TAG,

   103         TEXT,

   104         CDSECT,

   105         ENTITY_REF,

   106         IGNORABLE_WHITESPACE,

   107         PROCESSING_INSTRUCTION,

   108         COMMENT,

   109         DOCDECL

   110     };

   112     EventType   nextToken();

   113     EventType   getEventType() const { return fCurr.fEventType; }

   115     struct AttrInfo {

   116         const char* fName;

   117         const char* fValue;

   118     };

   120     int         getDepth() const { return fDepth; }

   121     const char* getName();

   122     int         getAttributeCount();

   123     void        getAttributeInfo(int, AttrInfo*);

   124     const char* getText();

   125     bool        isWhitespace();

   127 protected:

   128     virtual bool onEntityReplacement(const char name[],

   129                                      SkString* replacement);

   131 public:

   132     struct Curr {

   133         EventType   fEventType;

   134         const char* fName;

   135         AttrInfo*   fAttrInfos;

   136         int         fAttrInfoCount;

   137         bool        fIsWhitespace;

   138     };

   140 private:

   141     // implemented in the porting layer

   142     bool        onInit();   // return false on failure

   143     EventType   onNextToken();

   144     void        onExit();

   146     SkStream*   fStream;

   147     Curr        fCurr;

   148     int         fDepth;

   150     struct Impl;

   151     Impl*   fImpl;

   152 };

   153 #endif

   155 #endif

The Tor Browser / file revision

gfx/skia/trunk/include/xml/SkXMLParser.h@129ffea94266

gfx/skia/trunk/include/xml/SkXMLParser.h