Remove hidden elements from MHTML

third_party/WebKit/Source/core/frame/FrameSerializer.cpp

 /*
  * Copyright (C) 2011 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 61 matching lines @@
 
 namespace {
 
 const int32_t secondsToMicroseconds = 1000 * 1000;
 const int32_t maxSerializationTimeUmaMicroseconds = 10 * secondsToMicroseconds;
 
 }  // namespace
 
 namespace blink {
 
-static bool shouldIgnoreElement(const Element& element) {
-  if (isHTMLScriptElement(element))
-    return true;
-  if (isHTMLNoScriptElement(element))
-    return true;
-  return isHTMLMetaElement(element) &&
-         toHTMLMetaElement(element).computeEncoding().isValid();
-}
-
 class SerializerMarkupAccumulator : public MarkupAccumulator {
   STACK_ALLOCATED();
 
  public:
   SerializerMarkupAccumulator(FrameSerializer::Delegate&,
                               const Document&,
                               HeapVector<Member<Node>>&);
   ~SerializerMarkupAccumulator() override;
 
  protected:
   void appendText(StringBuilder& out, Text&) override;
   bool shouldIgnoreAttribute(const Element&, const Attribute&) override;
   void appendElement(StringBuilder& out, Element&, Namespaces*) override;
   void appendAttribute(StringBuilder& out,
                        const Element&,
                        const Attribute&,
                        Namespaces*) override;
   void appendStartTag(Node&, Namespaces* = nullptr) override;
   void appendEndTag(const Element&) override;
 
  private:
+  bool shouldIgnoreElement(const Element&) const;
   void appendAttributeValue(StringBuilder& out, const String& attributeValue);
   void appendRewrittenAttribute(StringBuilder& out,
                                 const Element&,
                                 const String& attributeName,
                                 const String& attributeValue);
 
   FrameSerializer::Delegate& m_delegate;
   Member<const Document> m_document;
 
   // FIXME: |FrameSerializer| uses |m_nodes| for collecting nodes in document
@@ skipping 90 matching lines @@
                                                  Namespaces* namespaces) {
   MarkupAccumulator::appendStartTag(node, namespaces);
   m_nodes.append(&node);
 }
 
 void SerializerMarkupAccumulator::appendEndTag(const Element& element) {
   if (!shouldIgnoreElement(element))
     MarkupAccumulator::appendEndTag(element);
 }
 
+bool SerializerMarkupAccumulator::shouldIgnoreElement(
+    const Element& element) const {
+  if (isHTMLScriptElement(element))
+    return true;
+  if (isHTMLNoScriptElement(element))
+    return true;
+  if (isHTMLMetaElement(element) &&
+      toHTMLMetaElement(element).computeEncoding().isValid()) {
+    return true;
+  }
+  return m_delegate.shouldIgnoreElement(element);

[carlosk, 2016/11/30 23:30:22]

This might be a dumb question but why is this logic split between this method
and the delegate's? Are these checks here for cases that should always be
ignored when serializing and the ones in the delegate only for format-specific
cases (assuming MHTML is not the only format)?

[jianli, 2016/12/01 02:19:38]

It seems that this is useful in supporting multiple formats. I think we need to
have some discussions to understand what we want to support here.

+}
+
 void SerializerMarkupAccumulator::appendAttributeValue(
     StringBuilder& out,
     const String& attributeValue) {
   MarkupFormatter::appendAttributeValue(out, attributeValue,
                                         m_document->isHTMLDocument());
 }
 
 void SerializerMarkupAccumulator::appendRewrittenAttribute(
     StringBuilder& out,
     const Element& element,
@@ skipping 328 matching lines @@
     emitsMinus = ch == '-';
     builder.append(ch);
   }
   CString escapedUrl = builder.toString().ascii();
   return String::format("saved from url=(%04d)%s",
                         static_cast<int>(escapedUrl.length()),
                         escapedUrl.data());
 }
 
 }  // namespace blink