Sync libimage_io to CL #222429857

- Update to match libdynamic_depth

Test: m image_io
Change-Id: I3496312b0e6c0159fb25d586cac772f847352379

15 files changed, 2 insertions, 935 deletions

diff --git a/METADATA b/METADATA
index e887ec6..33a5f87 100644
--- a/METADATA
+++ b/METADATA
@@ -7,11 +7,11 @@ third_party {
     type: PIPER
     value: "http://google3/photos/editing/formats/image_io"
   }
-  version: "221162778"
+  version: "222429857"
   last_upgrade_date {
     year: 2018
     month: 11
-    day: 12
+    day: 21
   }
   license_type: NOTICE
 }
diff --git a/includes/image_io/extras/string_view_data_source.h b/includes/image_io/extras/string_view_data_source.h
deleted file mode 100644
index 0a90b44..0000000
--- a/includes/image_io/extras/string_view_data_source.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef IMAGE_IO_EXTRAS_STRING_VIEW_DATA_SOURCE_H_  // NOLINT
-#define IMAGE_IO_EXTRAS_STRING_VIEW_DATA_SOURCE_H_  // NOLINT
-
-#include "image_io/base/data_destination.h"
-#include "image_io/base/data_range.h"
-#include "image_io/base/data_segment_data_source.h"
-
-#include "third_party/absl/strings/string_view.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// A DataSource that reads bytes from a string_view. The underlying string data
-/// must have a lifetime that exceeds the lifetime of this data source, and the
-/// string contents must not change while the data source is referencing it.
-class StringViewDataSource : public DataSegmentDataSource {
- public:
-  /// Constructs a StringViewDataSource using the given string_view.
-  /// @param str The string_view to read from.
-  explicit StringViewDataSource(absl::string_view string_src);
-
-  /// Returns the string view being used as the data source.
-  absl::string_view GetStringView() const { return string_src_; }
-
- private:
-  /// The string_view to read from.
-  absl::string_view string_src_;
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_EXTRAS_STRING_VIEW_DATA_SOURCE_H_  // NOLINT
diff --git a/includes/image_io/tools/image_tool_function.h b/includes/image_io/tools/image_tool_function.h
deleted file mode 100644
index f730359..0000000
--- a/includes/image_io/tools/image_tool_function.h
+++ /dev/null
@@ -1,28 +0,0 @@
-#ifndef IMAGE_IO_TOOLS_IMAGE_TOOL_FUNCTION_H_  // NOLINT
-#define IMAGE_IO_TOOLS_IMAGE_TOOL_FUNCTION_H_  // NOLINT
-
-#include <functional>
-#include <string>
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// All output of the ImageTool() function and the underlying image_io functions
-/// are sent to this type of function that is passed to ImageTool(). Client code
-/// can use a function that writes the line to stdout or to a log file. The
-/// str parameter may have embedded new line characters in it. The function
-/// should not write its own new line at the end of the str.
-using ImageToolOutputter = std::function<void(const std::string& str)>;
-
-/// The ImageTool entry point, easily callable from a main() type function.
-/// @param argc The number of strings in the argv array.
-/// @param argv The options and values used in the command line.
-/// @param outputter A function to output the strings produced by ImageTool().
-/// @return A zero value for successful, non-zero for an error.
-int ImageTool(int argc, const char* argv[],
-              const ImageToolOutputter& outputter);
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_TOOLS_IMAGE_TOOL_FUNCTION_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_action.h b/includes/image_io/xml/xml_action.h
deleted file mode 100644
index dce6c7d..0000000
--- a/includes/image_io/xml/xml_action.h
+++ /dev/null
@@ -1,57 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_ACTION_H_  // NOLINT
-#define IMAGE_IO_XML_XML_ACTION_H_  // NOLINT
-
-#include <functional>
-
-#include "image_io/base/data_match_result.h"
-#include "image_io/xml/xml_handler_context.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-class XmlActionContext;
-class XmlTerminal;
-
-/// The definition for an action function associated with an XmlTerminal.
-/// If the action does not need to change the result of the terminal, it can
-/// simply return the value from XmlActionContext::GetResult().
-using XmlAction =
-    std::function<DataMatchResult(const XmlActionContext& context)>;
-
-/// The data context passed from an XmlTerminal to its action function.
-class XmlActionContext : public XmlHandlerContext {
- public:
-  XmlActionContext(const XmlHandlerContext& context, XmlTerminal* terminal,
-                   const DataMatchResult& result)
-      : XmlHandlerContext(context), terminal_(terminal), result_(result) {}
-  XmlActionContext(size_t location, const DataRange& range,
-                   const DataSegment& segment, const DataLineMap& data_line_map,
-                   XmlHandler* handler, XmlTerminal* terminal,
-                   const DataMatchResult& result)
-      : XmlHandlerContext(location, range, segment, data_line_map, handler),
-        terminal_(terminal),
-        result_(result) {}
-
-  /// @return The terminal associated with the context.
-  XmlTerminal* GetTerminal() const { return terminal_; }
-
-  /// @return The result associated with the constext.
-  const DataMatchResult& GetResult() const { return result_; }
-
-  /// @param bytes_consumed The value to set in the returned result.
-  /// @return A result based on the context's action, but with its bytes
-  /// consumed value set to the given value.
-  DataMatchResult GetResultWithBytesConsumed(size_t bytes_consumed) const {
-    auto result = result_;
-    return result.SetBytesConsumed(bytes_consumed);
-  }
-
- private:
-  XmlTerminal* terminal_;
-  DataMatchResult result_;
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_ACTION_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_attribute_rule.h b/includes/image_io/xml/xml_attribute_rule.h
deleted file mode 100644
index 564af07..0000000
--- a/includes/image_io/xml/xml_attribute_rule.h
+++ /dev/null
@@ -1,33 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_ATTRIBUTE_RULE_H_  // NOLINT
-#define IMAGE_IO_XML_XML_ATTRIBUTE_RULE_H_  // NOLINT
-
-#include "image_io/xml/xml_rule.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// The XmlAttributeRule parses the following syntax:
-/// S? Name S? = S? 'Value'
-/// S? Name S? = S? "Value"
-class XmlAttributeRule : public XmlRule {
- public:
-  XmlAttributeRule();
-
- private:
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's AttributeName() function.
-  /// @param context The action context from the name terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandleName(const XmlActionContext& context);
-
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's AttributeValue() function.
-  /// @param context The action context from the quoted string terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandleValue(const XmlActionContext& context);
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_ATTRIBUTE_RULE_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_cdata_and_comment_rules.h b/includes/image_io/xml/xml_cdata_and_comment_rules.h
deleted file mode 100644
index 0cc2e50..0000000
--- a/includes/image_io/xml/xml_cdata_and_comment_rules.h
+++ /dev/null
@@ -1,69 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_CDATA_AND_COMMENT_RULES_H_  // NOLINT
-#define IMAGE_IO_XML_XML_CDATA_AND_COMMENT_RULES_H_  // NOLINT
-
-#include "image_io/xml/xml_rule.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// The XmlCdataRule parses the following syntax "<![CDATA[ ... ]]>".
-/// As mentioned in the comments for the XmlHandler::Cdata() function, the token
-/// value that is passed to the handler never includes the leading "<![CDATA["
-/// syntax and always includes the trailing "]]>" syntax. This considerably
-/// simplifies the parsing task. The alternate start point constructor is used
-/// by the XmlCdataOrCommentRule.
-class XmlCdataRule : public XmlRule {
- public:
-  XmlCdataRule();
-  explicit XmlCdataRule(StartPoint start_point);
-
- private:
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's Cdata() function.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandleCdataValue(const XmlActionContext& context);
-};
-
-/// The XmlCommentRule parses the following syntax "<!-- ... -->".
-/// As mentioned in the comments for the XmlHandler::Comment() function, the
-/// token value that is passed to the handler never includes the leading "<!--"
-/// syntax and always includes the trailing "-->" syntax. This considerably
-/// simplifies the parsing task.  The alternate start point constructor is used
-/// by the XmlCdataOrCommentRule.
-class XmlCommentRule : public XmlRule {
- public:
-  XmlCommentRule();
-  explicit XmlCommentRule(StartPoint start_point);
-
- private:
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's Comment() function.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandleCommentValue(const XmlActionContext& context);
-};
-
-/// This rule will use chain delegation to start either the XmlCdataRule or the
-/// XmlCommentRule, depending on the text being parsed. The syntax for XML is
-/// pretty poor here - the parser needs to look ahead two characters from the <
-/// character to determine what to do.  The alternate start point constructor is
-/// used by the XmlElementContentRule.
-class XmlCdataOrCommentRule : public XmlRule {
- public:
-  XmlCdataOrCommentRule();
-  explicit XmlCdataOrCommentRule(StartPoint start_point);
-
- private:
-  /// Builds an XmlTokenContext from the XmlActionContext and creates the
-  /// XmlCdataRule or XmlCommentRule to chain to depending on what character
-  /// follows the exclamation point of the "<!" syntax.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value from the action context.
-  DataMatchResult HandlePostBangChar(const XmlActionContext& context);
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_CDATA_AND_COMMENT_RULES_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_element_rules.h b/includes/image_io/xml/xml_element_rules.h
deleted file mode 100644
index f40f370..0000000
--- a/includes/image_io/xml/xml_element_rules.h
+++ /dev/null
@@ -1,92 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_ELEMENT_RULES_H_  // NOLINT
-#define IMAGE_IO_XML_XML_ELEMENT_RULES_H_  // NOLINT
-
-#include "image_io/xml/xml_rule.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// The XmlElementRule parses the following syntax:
-/// Element ::= EmptyElemTag  | STag content ETag
-/// EmptyElemTag ::=  '<' Name (S Attribute)* S? '/>'
-/// STag         ::=  '<' Name (S Attribute)* S? '>'
-/// ETag         ::=  '</' Name S? '>'
-/// The Attribute syntax is parsed by XmlAttributeRule, which this rule
-/// delegates to as a child rule. The EmptyElemTag type syntax is handled by
-/// this rule. The STag part of the syntax is handled by this rule, but the
-/// element contents and the ETag syntax is handled by the XmlElementContentRule
-/// that is chained to by this rule.
-class XmlElementRule : public XmlRule {
- public:
-  XmlElementRule();
-  explicit XmlElementRule(StartPoint start_point);
-
- private:
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's StartElement() function.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandleName(const XmlActionContext& context);
-
-  /// Handles the book keeping after parsing the whitespace following the name
-  /// of the element, basically looking ahead to see if an XmlAttributeRule has
-  /// to be delegated to as a child rule, or if the element ends.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value action context.
-  DataMatchResult HandlePostWhitespaceChar(const XmlActionContext& context);
-
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's FinishElement() function in response to the final literal in
-  /// the EmptyElemTag type sytax. As written in the comment for the XmlHandler
-  /// FinishElement() function, the token context passed to the handler in this
-  /// case will have an invalid range and a XmlPortion value of kNone - i.e.,
-  /// the element name is not available tfor this form of the element syntax.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandleEmptyElemTagEnd(const XmlActionContext& context);
-
-  /// Handles the book keeping after parsing the final ">" literal of the STag
-  /// syntax of the rule, creating an XmlElementContentRule for use as a chained
-  /// to rule.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value action context.
-  DataMatchResult HandleSTagEnd(const XmlActionContext& context);
-};
-
-/// The XmlElementContentRule parses the following syntax:
-/// (c? Element | PI | CDATA | Comment )+ ETag
-/// The "c?" syntax represents the character data passed to the XmlHandler's
-/// ElementContent() function. The syntax for Element, PI, CDATA and Comment
-/// all cause a child rule to be created and delegated to. The ETag syntax will
-/// cause this element to be finished with a DataMatchResult type of kFull.
-class XmlElementContentRule : public XmlRule {
- public:
-  XmlElementContentRule();
-
- private:
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's ElementContent() function.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandleContent(const XmlActionContext& context);
-
-  /// Handles the book keeping after parsing the element's content characters,
-  /// and the first character literal ("<") of the Element, PI, CDATA or Comment
-  /// syntax, creating an appropriate child rule to delegate the processing to.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value action context.
-  DataMatchResult HandlePostOpenChar(const XmlActionContext& context);
-
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's FinishElement() function. No check is done by the rule to verify
-  /// that the element name matches the one that was passed to the handler's
-  /// StartElement.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandleEndTag(const XmlActionContext& context);
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_ELEMENT_RULES_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_handler.h b/includes/image_io/xml/xml_handler.h
deleted file mode 100644
index cdf3d30..0000000
--- a/includes/image_io/xml/xml_handler.h
+++ /dev/null
@@ -1,107 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_HANDLER_H_  // NOLINT
-#define IMAGE_IO_XML_XML_HANDLER_H_  // NOLINT
-
-#include "image_io/base/data_match_result.h"
-#include "image_io/xml/xml_token_context.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// The handler that is called by XmlRule instances as they parse XML syntax
-/// and produce tokens defined in the XmlTokenContext. Each handler function
-/// may be called multiple times with different XmlPortion values. The first
-/// time the XmlPortion::kBegin bit will be set. The last time, XmlPortion::kEnd
-/// will be set. In between, XmlPortion::kMiddle will be set. If the entire
-/// token value is available for the handler, all three bits will be set.
-/// The implementation of each function in this base class returns the
-/// DataMatchResult value that the context provides. The function overrides in
-/// subclasses can return the same context value, or a copy that is modified
-/// with a different result type, message and "can continue" flag.
-class XmlHandler {
- public:
-  virtual ~XmlHandler() = default;
-
-  /// This function is called to start an XML element. Once started, any of
-  /// the other handler functions may be called.
-  /// @param context The token context used to specify the element name.
-  /// @return The match result from the context, or one that is modified to
-  /// contain an error message if needed.
-  virtual DataMatchResult StartElement(const XmlTokenContext& context);
-
-  /// This function is called to finish an XML element. Each call to this
-  /// function should be paired with a call to a StartElement function.
-  /// @param context The token context used to obtain the match result for
-  /// returning. For this function, the context might not have a valid token
-  /// value: the XmlPortion will always be kNone and the token range invalid.
-  /// This is the case if the syntax parsed is an empty element like this:
-  /// "<SomeElement [Attribute=Name]... />". For non empty elements with syntax:
-  /// "<SomeElement>...</SomeElement>", the value will be the element name.
-  /// @return The match result from the context, or one that is modified to
-  /// contain an error message if needed.
-  virtual DataMatchResult FinishElement(const XmlTokenContext& context);
-
-  /// This function is called to define an attribute name. This function will
-  /// never be called unless an element has been started with a prior call to
-  /// the StartElement() function.
-  /// @param context The token context used to specify the attribute name.
-  /// @return The match result from the context, or one that is modified to
-  /// contain an error message if needed.
-  virtual DataMatchResult AttributeName(const XmlTokenContext& context);
-
-  /// This function is called to define an attribute value. The token value
-  /// passed to this function always includes the quote marks at the begin and
-  /// end of the token value. The quote marks always match and may be either a
-  /// single quote (') or a double quote ("). Sometimes attribute values can be
-  /// very long, so implementations of this function should use care if they
-  /// retain the value as a string for later processing. This function will
-  /// never be called unless an element has been started with a prior call to
-  /// the StartElement() and AttributeName() functions.
-  /// @param context The token context used to specify the attribute value.
-  /// @return The match result from the context, or one that is modified to
-  /// contain an error message if needed.
-  virtual DataMatchResult AttributeValue(const XmlTokenContext& context);
-
-  /// This function is called to define a block of characters in the body of
-  /// an element. This function may be called multiple times for a given
-  /// element. Handlers that are interested in the character content for an
-  /// element should concatenate the token values from all calls to obtain the
-  /// full value for the element.
-  /// @param context The token context used to specify the content value.
-  /// @return The match result from the context, or one that is modified to
-  /// contain an error message if needed.
-  virtual DataMatchResult ElementContent(const XmlTokenContext& context);
-
-  /// This function is called to inform the handler of a comment. A comment in
-  /// XML has the syntax "<!--...-->". In order to simplify the XML parsing
-  /// task, the tokens passed to this function never include the leading "<!--"
-  /// characters, but always include the trailing "-->".
-  /// @param context The token context used to specify the comment.
-  /// @return The match result from the context, or one that is modified to
-  /// contain an error message if needed.
-  virtual DataMatchResult Comment(const XmlTokenContext& context);
-
-  /// This function is called to inform the handler CDATA block. A CDATA block
-  /// in XML has the syntax "<![CDATA[...]]>". In order to simplify the XML
-  /// parsing task, the tokens passed to this function never include the leading
-  /// "<![CDATA[" characters, but always include the trailing "]]".
-  /// @param context The token context used to specify the CDATA block.
-  /// @return The match result from the context, or one that is modified to
-  /// contain an error message if needed.
-  virtual DataMatchResult Cdata(const XmlTokenContext& context);
-
-  /// This function is called to define a processing instruction. Processing
-  /// instructions have an XML syntax "<?...?>". In order to simplify the XML
-  /// parsing task, no parsing of the processing instruction is done: handlers
-  /// that need the contents parsed are on their own. Also, again to simplify
-  /// the XML parsing task, the tokens passed to this function never include the
-  /// leading "<?" characters, but always include the trailing "?>".
-  /// @param context The token context used to specify the processing data.
-  /// @return The match result from the context, or one that is modified to
-  /// contain an error message if needed.
-  virtual DataMatchResult Pi(const XmlTokenContext& context);
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_HANDLER_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_handler_context.h b/includes/image_io/xml/xml_handler_context.h
deleted file mode 100644
index 5595118..0000000
--- a/includes/image_io/xml/xml_handler_context.h
+++ /dev/null
@@ -1,31 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_HANDLER_CONTEXT_H_  // NOLINT
-#define IMAGE_IO_XML_XML_HANDLER_CONTEXT_H_  // NOLINT
-
-#include "image_io/base/data_context.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-class XmlHandler;
-
-class XmlHandlerContext : public DataContext {
- public:
-  XmlHandlerContext(const DataContext& context, XmlHandler* handler)
-      : DataContext(context), handler_(handler) {}
-
-  XmlHandlerContext(size_t location, const DataRange& range,
-                    const DataSegment& segment,
-                    const DataLineMap& data_line_map, XmlHandler* handler)
-      : DataContext(location, range, segment, data_line_map),
-        handler_(handler) {}
-
-  XmlHandler* GetHandler() const { return handler_; }
-
- private:
-  XmlHandler* handler_;
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_HANDLER_CONTEXT_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_pi_rule.h b/includes/image_io/xml/xml_pi_rule.h
deleted file mode 100644
index 674a3fa..0000000
--- a/includes/image_io/xml/xml_pi_rule.h
+++ /dev/null
@@ -1,32 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_PI_RULE_H_  // NOLINT
-#define IMAGE_IO_XML_XML_PI_RULE_H_  // NOLINT
-
-#include "image_io/xml/xml_rule.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// The XmlPiRule parses the processing information syntax: "<?...?>". This
-/// syntax is considerably simplified from the official XML specification. As
-/// documented in the comments for the XmlHandler Pi() function, The leading
-/// "<?" syntax is never sent to the handler, while the trailing "?>" literal
-/// is always sent as part of the processing content token. This approach makes
-/// it much easier to parse XML syntax. The alternate start point constructor
-/// is used by the XmlElementContentRule.
-class XmlPiRule : public XmlRule {
- public:
-  XmlPiRule();
-  explicit XmlPiRule(StartPoint start_point);
-
- private:
-  /// Builds an XmlTokenContext from the XmlActionContext and calls the
-  /// handler's Pi() function.
-  /// @param context The action context from the rule's terminal.
-  /// @return The result value from the handler's function.
-  DataMatchResult HandlePiValue(const XmlActionContext& context);
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_PI_RULE_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_portion.h b/includes/image_io/xml/xml_portion.h
deleted file mode 100644
index 673c958..0000000
--- a/includes/image_io/xml/xml_portion.h
+++ /dev/null
@@ -1,48 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_PORTION_H_  // NOLINT
-#define IMAGE_IO_XML_XML_PORTION_H_  // NOLINT
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// An bit-type enum for indicating what part of an entity is defined: the
-/// begin, middle and or end. Bitwise "and" and "or" operators are defined to
-/// combine and test values.
-enum class XmlPortion {
-  kNone = 0,
-  kBegin = 1,
-  kMiddle = 2,
-  kEnd = 4,
-};
-
-/// @return The value that results from the bitwise "and" of given portions.
-inline XmlPortion operator&(XmlPortion lhs, XmlPortion rhs) {
-  int lhs_value = static_cast<int>(lhs);
-  int rhs_value = static_cast<int>(rhs);
-  return static_cast<XmlPortion>(lhs_value & rhs_value);
-}
-
-/// @return The value that results from the bitwise "or"  of given portions.
-inline XmlPortion operator|(XmlPortion lhs, XmlPortion rhs) {
-  int lhs_value = static_cast<int>(lhs);
-  int rhs_value = static_cast<int>(rhs);
-  return static_cast<XmlPortion>(lhs_value | rhs_value);
-}
-
-/// @param value The value to use for the test.
-/// @param mask The mask to use for the test.
-/// @return Whether any of the bits in the mask are set in the value.
-inline bool ContainsAny(XmlPortion value, XmlPortion mask) {
-  return (value & mask) != XmlPortion::kNone;
-}
-
-/// @param value The value to use for the test.
-/// @param mask The mask to use for the test.
-/// @return Whether all of the bits in the mask are set in the value.
-inline bool ContainsAll(XmlPortion value, XmlPortion mask) {
-  return (value & mask) == mask;
-}
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_PORTION_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_reader.h b/includes/image_io/xml/xml_reader.h
deleted file mode 100644
index 9a42b74..0000000
--- a/includes/image_io/xml/xml_reader.h
+++ /dev/null
@@ -1,105 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_READER_H_  // NOLINT
-#define IMAGE_IO_XML_XML_READER_H_  // NOLINT
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "image_io/base/data_line_map.h"
-#include "image_io/base/data_match_result.h"
-#include "image_io/base/message.h"
-#include "image_io/xml/xml_handler_context.h"
-#include "image_io/xml/xml_rule.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// A class for reading and parsing the text of a data segment, resulting in the
-/// functions of an XmlHandler to be called. This reader's Parse() function can
-/// be called multiple times for text that spans multiple data segments. Errors
-/// are reported to the message handler as they are encountered. In general,
-/// there will be three types of errors: internal (programming), syntax, and
-/// value errors. Internal errors can come from any where in this code base;
-/// Only one such error is permitted per StartParse/Parse... sequence. Syntax
-/// errors are usually issued by XmlRule instances; like internal errors, only
-/// one such error is tolerated per StartParse/Parse... sequence. XmlHandler
-/// functions may issue value errors; multiple such value errors are tolerated.
-class XmlReader {
- public:
-  explicit XmlReader(XmlHandler* handler)
-      : handler_(handler),
-        bytes_parsed_(0),
-        has_internal_or_syntax_error_(false),
-        has_errors_(false) {}
-
-  /// Sets up the reader for parsing data segment text using the given XmlRule.
-  /// @param rule The top level rule to use when parsing the data segment text.
-  /// @return Whether the reader was set up propertly.
-  bool StartParse(std::unique_ptr<XmlRule> rule);
-
-  /// Parses the text portion of the data segment starting at a location. This
-  /// function may be called multiple times for text that spans multiple data
-  /// segments.
-  /// @param start_location The location at which to start reading/parsing.
-  /// This location must be contained in the range parameter.
-  /// @param range The portion of the data segment to parse. This range value
-  /// must be contained in the range returned by DataSegment::GetRange()
-  /// @param segment The segment containing the text to parse.
-  /// @return Whether the parsing was successful.
-  bool Parse(size_t start_location, const DataRange& range,
-             const DataSegment& segment);
-
-  /// Finishes up the reading/parsing process. The rule passed to StartParse()
-  /// must have consumed all the text of the segments and be "done", otherwise
-  /// this function will issue an error message.
-  /// @param Whether the reading/parsing operation was completed successfully.
-  bool FinishParse();
-
-  /// @return The total number of bytes of text that have been read/parsed.
-  size_t GetBytesParsed() const { return bytes_parsed_; }
-
-  /// @return Whether errors have been encountered in reading/parsing the text.
-  bool HasErrors() const { return has_errors_; }
-
-  /// @return The handler that handles the output of the parsing operations.
-  XmlHandler* GetHandler() const { return handler_; }
-
- private:
-  /// Sets up the context's name list that is used when creating error message.
-  /// @parma context The context to set up.
-  void InitializeContextNameList(XmlHandlerContext* context);
-
-  /// Reports the message indicated in the result to the message handler and
-  /// updates the data boolean data members indicating errors.
-  /// @param result The result value for an XmlRule::Parse function.
-  /// @param context The context for generating an error message if needed.
-  void ReportError(const DataMatchResult& result, const DataContext& context);
-
-  /// Reports the message to the message handler and updates the data boolean
-  /// data members indicating errors.
-  /// @param message The message to send to the message handler.
-  void ReportError(const Message& message);
-
-  /// The reader's handler.
-  XmlHandler* handler_;
-
-  /// A data line map used for error message creation.
-  DataLineMap data_line_map_;
-
-  /// The pending and active rules.
-  std::vector<std::unique_ptr<XmlRule>> rule_stack_;
-
-  /// The total number of bytes that have been parsed.
-  size_t bytes_parsed_;
-
-  /// Whether an internal or syntax error has occurred.
-  bool has_internal_or_syntax_error_;
-
-  /// Whether any type of error has occurred.
-  bool has_errors_;
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_READER_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_rule.h b/includes/image_io/xml/xml_rule.h
deleted file mode 100644
index c76f87c..0000000
--- a/includes/image_io/xml/xml_rule.h
+++ /dev/null
@@ -1,175 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_RULE_H_  // NOLINT
-#define IMAGE_IO_XML_XML_RULE_H_  // NOLINT
-
-#include <memory>
-#include <string>
-#include <vector>
-
-#include "image_io/base/data_match_result.h"
-#include "image_io/xml/xml_handler_context.h"
-#include "image_io/xml/xml_terminal.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// A rule represents a sequence of terminals to match text from a DataSource,
-/// and the state needed to keep track the parsing operation in case the text
-/// is split across multiple DataSegments. XmlRules collaborate with an instance
-/// of XmlHandler to process the token values the terminals produce.
-///
-/// Terminals are added in the constructors of the rule subclasses, and are
-/// not typically accessed directly from the clients of an XmlRule. Instead,
-/// XmlRule clients normally just call the rule's Parse function and take action
-/// based on the DataMatchResult value that is returned. The functions of the
-/// XmlHandler are called internally by the rule's terminals as they parse the
-/// text in the data segment.
-///
-/// Normally, the terminals are parsed by the Parse() function in a sequential
-/// manner until they are exhausted. At which time the Parse function returns
-/// with a DataMatchResult that has a type equal to kFull. If the DataSegment
-/// runs out of data before the end of the final terminal, the result type will
-/// be kPartialOutOfData. Of course if any of the terminals' scanners detect an
-/// error the result type will be kError.
-///
-/// Rules may decide to delegate the parsing process to another rule. There are
-/// two types of delegation:
-/// 1. Rule chaining - in this case a rule decides that another rule should
-///    be used instead to continue the parsing process. This situation is
-///    indicated when the result type is kFull and the rule's HasNextRule()
-///    function returns true. The chained-to rule is obtained by calling the
-///    rule's GetNextRule() function. The current rule can be discarded.
-/// 2. Child rules - in this case a "parent" rule decides that the next set of
-///    syntax should be parsed by another "child" rule, and after that rule
-///    completes, the parsing task should be returned to the parent rule. This
-///    situaltion is indicated when the result type is kPartial and the rule's
-///    HasNextRule() returns true. The child rule is obtained by calling the
-///    rule's GetNextRule() function. The current parent rule should be placed
-///    on a stack until the child rule is done, and then the child discarded and
-///    the parent rule used for the next Parse operation.
-/// The action functions associated with a terminal are typically used to create
-/// the next rule and set the result type and thus initiate the delegation
-/// process. When the XmlRule::Parse function detects a delegation has been
-/// requested, it returns to its caller so that the caller can handle the
-/// delegation in the appropriate fashion. For an example, see the XmlReader's
-/// Parse() function.
-///
-/// In addition to delegation the action functions associated with a terminal
-/// can change the order of the terminals processed from a strictly sequential
-/// order to whatever the rule so desires. This is done by calling the rule's
-/// SetTerminalIndex() function. Terminals can be identified by name using the
-/// GetTerminalIndexFromName() function if the rule's terminals were
-/// constructed with names.  If the terminal index of a rule is set to a
-/// terminal that has already been used, the terminal's scanners state must be
-/// reset in order for it to parse successfully again.  Sometimes the entire
-/// rule is "restarted" in which case the ResetTerminalScanners() function can
-/// be called to reset the scanners of all the rules terminals.
-///
-/// Finally, because of the look-ahead needs of the XML grammar, some rules
-/// support alternate "starting points", allowing them to skip some set of
-/// initial terminals when the rule's Parse() function is called. Rules that
-/// support this feature will have a constructor with an StartPoint parameter.
-class XmlRule {
- public:
-  /// For rules that support alternate starting points, this enum provides the
-  /// values at which a rule's Parse() function can begin.
-  enum StartPoint {
-    /// Start parsing at the first terminal position.
-    kFirstStartPoint,
-
-    /// STart parsing at a second (alternative) position.
-    kSecondStartPoint,
-  };
-
-  virtual ~XmlRule() = default;
-  explicit XmlRule(const std::string& name);
-
-  /// @return The name of the rule.
-  const std::string& GetName() const { return name_; }
-
-  /// Parse the text indicated in the context's data segment and range and call
-  /// the context's XmlHandler functions as needed. The implementation of this
-  /// function makes use of the terminals contained by the rule, but it is
-  /// declared virtual so that subclasses can customize as needed.
-  /// @param context The context describing the text to parse and the handler
-  /// to call.
-  /// @param A result that indicates the type of match that occurred, the number
-  /// of bytes consumed and an error message if needed.
-  virtual DataMatchResult Parse(XmlHandlerContext context);
-
-  /// Adds a literal terminal to the rule.
-  /// @param literal The literal value to scan for.
-  /// @return The terminal, enabling direct calls to WithName()/WithAction().
-  XmlTerminal& AddLiteralTerminal(const std::string& literal);
-
-  /// Adds a name terminal to the rule.
-  /// @return The terminal, enabling direct calls to WithName()/WithAction().
-  XmlTerminal& AddNameTerminal();
-
-  /// Adds a quoted string terminal to the rule.
-  /// @return The terminal, enabling direct calls to WithName()/WithAction().
-  XmlTerminal& AddQuotedStringTerminal();
-
-  /// Adds a sentinel terminal to the rule.
-  /// @param sentinels The sentinel values to scan for.
-  /// @return The terminal, enabling direct calls to WithName()/WithAction().
-  XmlTerminal& AddSentinelTerminal(const std::string& sentinels);
-
-  /// Adds a scan through literal terminal to the rule.
-  /// @param literal The literal value to scan through.
-  /// @return The terminal, enabling direct calls to WithName()/WithAction().
-  XmlTerminal& AddThroughLiteralTerminal(const std::string& literal);
-
-  /// Adds a whitespace terminal to the rule.
-  /// @return The terminal, enabling direct calls to WithName()/WithAction().
-  XmlTerminal& AddWhitespaceTerminal();
-
-  /// Adds an optional whitespace terminal to the rule.
-  /// @return The terminal, enabling direct calls to WithName()/WithAction().
-  XmlTerminal& AddOptionalWhitespaceTerminal();
-
-  /// @return The number of terminals in the rule.
-  size_t GetTerminalCount() const { return terminals_.size(); }
-
-  /// @return The index of the terminal currently parsing text.
-  size_t GetTerminalIndex() const { return terminal_index_; }
-
-  /// @param name The name of the terminal to look for.
-  /// @return The index of the terminal with the given name, or the value
-  /// returned by the rule's GetTerminalCount() if not found.
-  size_t GetTerminalIndexFromName(const std::string name) const;
-
-  /// @param terminal_index The index of the terminal that should next be used
-  /// for parsing the input text.
-  void SetTerminalIndex(size_t terminal_index);
-
-  /// @return The terminal currently parsing text, or nullptr if there is none.
-  XmlTerminal* GetCurrentTerminal();
-
-  /// @param index The index of the terminal to get.
-  /// @return The terminal at the given index, or nullptr if index is invalid.
-  XmlTerminal* GetTerminal(size_t index);
-
-  /// Resets the scanner's state of all the terminals in the rule.
-  void ResetTerminalScanners();
-
-  /// @return Whether the rule has a next rule for delegation.
-  bool HasNextRule() const;
-
-  /// @return Returns the next rule to the caller. If there is no next rule,
-  /// the get function of the returned unique_ptr will return nullptr.
-  std::unique_ptr<XmlRule> ReleaseNextRule();
-
-  /// @param next_rule The new rule to use for delegation purposes.
-  void SetNextRule(std::unique_ptr<XmlRule> next_rule);
-
- private:
-  std::string name_;
-  std::vector<XmlTerminal> terminals_;
-  std::unique_ptr<XmlRule> next_rule_;
-  size_t terminal_index_;
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_RULE_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_terminal.h b/includes/image_io/xml/xml_terminal.h
deleted file mode 100644
index 7d999f0..0000000
--- a/includes/image_io/xml/xml_terminal.h
+++ /dev/null
@@ -1,61 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_TERMINAL_H_  // NOLINT
-#define IMAGE_IO_XML_XML_TERMINAL_H_  // NOLINT
-
-#include <string>
-
-#include "image_io/base/data_scanner.h"
-#include "image_io/xml/xml_action.h"
-#include "image_io/xml/xml_token_context.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-/// A terminal represents a part of a rule that uses a DataScanner to match
-/// zero or more characters from a DataSource. A terminal can also have a name
-/// that can be be used in error messages and also used to identify it in a
-/// rule. A terminal can also have an action function associated with it that it
-/// can use to validate the token produced by the terminal/scanner, and do
-/// further processing with the token. Finally, the terminal's action function
-/// can manipulate the DataMatchResult that was produced by the terminal's
-/// scanner and accessible via the action function's XmlActionContext param.
-class XmlTerminal {
- public:
-  explicit XmlTerminal(const DataScanner& scanner) : scanner_(scanner){}
-
-  /// Sets the name of the terminal. Looks best with an XmlRule::AddTerminal
-  /// function: AddWhitespaceTerminal().WithName("SomeName");
-  /// @param name The name to give to the terminal.
-  /// @return A reference to the terminal.
-  XmlTerminal& WithName(const std::string& name) {
-    name_ = name;
-    return *this;
-  }
-
-  /// Sets the action of the terminal. Looks best with an XmlRule::AddTerminal
-  /// function: AddWhitespaceTerminal().WithAction(SomeAction);
-  /// @param action The action to give to the terminal.
-  /// @return A reference to the terminal.
-  XmlTerminal& WithAction(const XmlAction& action) {
-    action_ = action;
-    return *this;
-  }
-
-  /// @return The terminal's scanner.
-  DataScanner* GetScanner() { return &scanner_; }
-
-  /// @return The terminal's name.
-  const std::string& GetName() const { return name_; }
-
-  /// @return The terminal's action function.
-  const XmlAction& GetAction() const { return action_; }
-
- private:
-  DataScanner scanner_;
-  XmlAction action_;
-  std::string name_;
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_TERMINAL_H_  // NOLINT
diff --git a/includes/image_io/xml/xml_token_context.h b/includes/image_io/xml/xml_token_context.h
deleted file mode 100644
index cceca5c..0000000
--- a/includes/image_io/xml/xml_token_context.h
+++ /dev/null
@@ -1,62 +0,0 @@
-#ifndef IMAGE_IO_XML_XML_TOKEN_CONTEXT_H_  // NOLINT
-#define IMAGE_IO_XML_XML_TOKEN_CONTEXT_H_  // NOLINT
-
-#include <string>
-
-#include "image_io/base/data_context.h"
-#include "image_io/base/data_match_result.h"
-#include "image_io/base/data_range.h"
-#include "image_io/xml/xml_portion.h"
-
-namespace photos_editing_formats {
-namespace image_io {
-
-class XmlActionContext;
-
-/// A token context is passed from the action of an XmlTerminal to an XmlHandler
-/// associated with the XmlActionContext used to call the action function.
-class XmlTokenContext : public DataContext {
- public:
-  explicit XmlTokenContext(const XmlActionContext& context);
-  XmlTokenContext(size_t location, const DataRange& range,
-                  const DataSegment& segment, const DataLineMap& data_line_map,
-                  const DataMatchResult& result, const DataRange& token_range,
-                  const XmlPortion& token_portion);
-
-  /// @return The result associated with the context.
-  const DataMatchResult& GetResult() const { return result_; }
-
-  /// @return The token range for the token. Note that the token range may not
-  /// be a subrange of the context's GetRange() or even the context's segment's
-  /// data range. Such would be the case when a token's value is split across
-  /// two or more data segments.
-  const DataRange& GetTokenRange() const { return token_range_; }
-
-  /// @return The portion of the token that this context represents. This
-  /// portion value can be the bitwise or of any of the XmlPortion bit values.
-  const XmlPortion& GetTokenPortion() const { return token_portion_; }
-
-  /// Builds the string value of the token. If the context's token portion has
-  /// the XmlPortion::kBegin bit set, the string value is first cleared. Then
-  /// the string is extracted from the context's data source and appended onto
-  /// the value. Remember that some token values (especially attribute values)
-  /// can be quite long so care should be excercised when obtaining values with
-  /// this function.
-  /// @param value The value of the token being built.
-  /// @return Whether the token value is complete (i.e., the context's portion
-  /// had the XmlPortion::kEnd bit set).
-  bool BuildTokenValue(std::string* value) const;
-
-  static XmlPortion ComputeTokenPortion(size_t token_scan_count,
-                                        DataMatchResult::Type result_type);
-
- private:
-  DataMatchResult result_;
-  DataRange token_range_;
-  XmlPortion token_portion_;
-};
-
-}  // namespace image_io
-}  // namespace photos_editing_formats
-
-#endif // IMAGE_IO_XML_XML_TOKEN_CONTEXT_H_  // NOLINT