Support serializing shadow DOM to MHTML

third_party/WebKit/Source/web/WebFrameSerializer.cpp

 /*
  * Copyright (C) 2009 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 16 matching lines @@
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "public/web/WebFrameSerializer.h"
 
 #include "core/HTMLNames.h"
 #include "core/InputTypeNames.h"
 #include "core/dom/Document.h"
 #include "core/dom/Element.h"
+#include "core/dom/shadow/ElementShadow.h"
 #include "core/frame/Frame.h"
 #include "core/frame/FrameSerializer.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/RemoteFrame.h"
 #include "core/frame/WebLocalFrameBase.h"
 #include "core/html/HTMLAllCollection.h"
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLFrameOwnerElement.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
@@ skipping 26 matching lines @@
 #include "public/web/WebFrameSerializerCacheControlPolicy.h"
 #include "public/web/WebFrameSerializerClient.h"
 #include "web/WebFrameSerializerImpl.h"
 #include "web/WebRemoteFrameImpl.h"
 
 namespace blink {
 
 namespace {
 
 const int kPopupOverlayZIndexThreshold = 50;
+const char kShadowModeAttributeName[] = "shadowmode";
+const char kShadowDelegatesFocusAttributeName[] = "shadowdelegatesfocus";
 
 class MHTMLFrameSerializerDelegate final : public FrameSerializer::Delegate {
+  STACK_ALLOCATED()
   WTF_MAKE_NONCOPYABLE(MHTMLFrameSerializerDelegate);
 
  public:
-  explicit MHTMLFrameSerializerDelegate(
-      WebFrameSerializer::MHTMLPartsGenerationDelegate&);
+  MHTMLFrameSerializerDelegate(
+      WebFrameSerializer::MHTMLPartsGenerationDelegate&,
+      HeapHashSet<WeakMember<const Element>>&);
   ~MHTMLFrameSerializerDelegate() override;
   bool ShouldIgnoreElement(const Element&) override;
   bool ShouldIgnoreAttribute(const Element&, const Attribute&) override;
   bool RewriteLink(const Element&, String& rewritten_link) override;
   bool ShouldSkipResourceWithURL(const KURL&) override;
   bool ShouldSkipResource(
       FrameSerializer::ResourceHasCacheControlNoStoreHeader) override;
   Vector<Attribute> GetCustomAttributes(const Element&) override;
+  std::pair<Node*, Element*> GetAuxiliaryDOMTree(const Element&) const override;
 
  private:
   bool ShouldIgnoreHiddenElement(const Element&);
   bool ShouldIgnoreMetaElement(const Element&);
   bool ShouldIgnorePopupOverlayElement(const Element&);
   void GetCustomAttributesForImageElement(const HTMLImageElement&,
                                           Vector<Attribute>*);
   void GetCustomAttributesForFormControlElement(const Element&,
                                                 Vector<Attribute>*);
 
   WebFrameSerializer::MHTMLPartsGenerationDelegate& web_delegate_;
+  HeapHashSet<WeakMember<const Element>>& shadow_template_elements_;
   bool popup_overlays_skipped_;
 };
 
 MHTMLFrameSerializerDelegate::MHTMLFrameSerializerDelegate(
-    WebFrameSerializer::MHTMLPartsGenerationDelegate& web_delegate)
-    : web_delegate_(web_delegate), popup_overlays_skipped_(false) {}
+    WebFrameSerializer::MHTMLPartsGenerationDelegate& web_delegate,
+    HeapHashSet<WeakMember<const Element>>& shadow_template_elements)
+    : web_delegate_(web_delegate),
+      shadow_template_elements_(shadow_template_elements),
+      popup_overlays_skipped_(false) {}
 
 MHTMLFrameSerializerDelegate::~MHTMLFrameSerializerDelegate() {
   if (web_delegate_.RemovePopupOverlay()) {
     UMA_HISTOGRAM_BOOLEAN(
         "PageSerialization.MhtmlGeneration.PopupOverlaySkipped",
         popup_overlays_skipped_);
   }
 }
 
 bool MHTMLFrameSerializerDelegate::ShouldIgnoreElement(const Element& element) {
@@ skipping 70 matching lines @@
   if (attribute.LocalName() == HTMLNames::srcsetAttr)
     return true;
 
   // Do not save ping attribute since anyway the ping will be blocked from
   // MHTML.
   if (isHTMLAnchorElement(element) &&
       attribute.LocalName() == HTMLNames::pingAttr) {
     return true;
   }
 
+  // The special attribute in a template element to denote the shadow DOM
+  // should only be generated from MHTML serialization. If it is found in the
+  // original page, it should be ignored.
+  if (isHTMLTemplateElement(element) &&
+      attribute.LocalName() == kShadowModeAttributeName &&

[Mike West, 2017/06/14 07:03:59]

Should we be stripping `kShadowDelegatesFocusAttributeName` as well?

[jianli, 2017/06/14 19:06:08]

kShadowDelegatesFocusAttributeName can't take any effect by itself. So I don't
want to add additional code for this.

[Dmitry Titov, 2017/06/14 19:33:10]

Hm, stripping all attributes that feature adds might be a bit overkill, but it
can simplify the analysis of code down the road... Instead of figuring out which
attributes cause JS to run and which don't, it's easier to just know all of them
are stripped. WDYT?

[jianli, 2017/06/14 21:48:06]

Sounds reasonable. I am going to remove this attribute too.

+      !shadow_template_elements_.Contains(&element)) {
+    return true;
+  }
+
   // If srcdoc attribute for frame elements will be rewritten as src attribute
   // containing link instead of html contents, don't ignore the attribute.
   // Bail out now to avoid the check in Element::isScriptingAttribute.
   bool is_src_doc_attribute = IsHTMLFrameElementBase(element) &&
                               attribute.GetName() == HTMLNames::srcdocAttr;
   String new_link_for_the_element;
   if (is_src_doc_attribute && RewriteLink(element, new_link_for_the_element))
     return false;
 
   // Do not include attributes that contain javascript. This is because the
@@ skipping 107 matching lines @@
     Vector<Attribute>* attributes) {
   // Disable all form elements in MTHML to tell the user that the form cannot be
   // worked on. MHTML is loaded in full sandboxing mode which disable the form
   // submission and script execution.
   if (element.FastHasAttribute(HTMLNames::disabledAttr))
     return;
   Attribute disabled_attribute(HTMLNames::disabledAttr, "");
   attributes->push_back(disabled_attribute);
 }
 
+std::pair<Node*, Element*> MHTMLFrameSerializerDelegate::GetAuxiliaryDOMTree(
+    const Element& element) const {
+  const ElementShadow* shadow = element.Shadow();
+  if (!shadow)
+    return std::pair<Node*, Element*>();
+  ShadowRoot& shadow_root = shadow->OldestShadowRoot();
+
+  String shadow_mode;
+  switch (shadow_root.GetType()) {
+    case ShadowRootType::kUserAgent:
+      // No need to serialize.
+      return std::pair<Node*, Element*>();
+    case ShadowRootType::V0:
+      shadow_mode = "v0";
+      break;
+    case ShadowRootType::kOpen:
+      shadow_mode = "open";
+      break;
+    case ShadowRootType::kClosed:
+      shadow_mode = "closed";
+      break;
+  }
+
+  // Put the shadow DOM content inside a template element. A special attribute
+  // is set to tell the mode of the shadow DOM.
+  Element* template_element =
+      Element::Create(HTMLNames::templateTag, &(element.GetDocument()));
+  template_element->setAttribute(
+      QualifiedName(g_null_atom, kShadowModeAttributeName, g_null_atom),
+      AtomicString(shadow_mode));
+  if (shadow_root.GetType() != ShadowRootType::V0 &&
+      shadow_root.delegatesFocus()) {
+    template_element->setAttribute(
+        QualifiedName(g_null_atom, kShadowDelegatesFocusAttributeName,
+                      g_null_atom),
+        g_empty_atom);
+  }
+  shadow_template_elements_.insert(template_element);
+
+  return std::pair<Node*, Element*>(&shadow_root, template_element);
+}
+
 bool CacheControlNoStoreHeaderPresent(
     const WebLocalFrameBase& web_local_frame) {
   const ResourceResponse& response =
       web_local_frame.DataSource()->GetResponse().ToResourceResponse();
   if (response.CacheControlContainsNoStore())
     return true;
 
   const ResourceRequest& request =
       web_local_frame.DataSource()->GetRequest().ToResourceRequest();
   return request.CacheControlContainsNoStore();
@@ skipping 65 matching lines @@
           ? MHTMLArchive::EncodingPolicy::kUseBinaryEncoding
           : MHTMLArchive::EncodingPolicy::kUseDefaultEncoding;
 
   // Serialize.
   TRACE_EVENT_BEGIN0("page-serialization",
                      "WebFrameSerializer::generateMHTMLParts serializing");
   Deque<SerializedResource> resources;
   {
     SCOPED_BLINK_UMA_HISTOGRAM_TIMER(
         "PageSerialization.MhtmlGeneration.SerializationTime.SingleFrame");
-    MHTMLFrameSerializerDelegate core_delegate(*web_delegate);
+    HeapHashSet<WeakMember<const Element>> shadow_template_elements;
+    MHTMLFrameSerializerDelegate core_delegate(*web_delegate,
+                                               shadow_template_elements);
     FrameSerializer serializer(resources, core_delegate);
     serializer.SerializeFrame(*frame);
   }
 
   TRACE_EVENT_END1("page-serialization",
                    "WebFrameSerializer::generateMHTMLParts serializing",
                    "resource count",
                    static_cast<unsigned long long>(resources.size()));
 
   // There was an error serializing the frame (e.g. of an image resource).
@@ skipping 51 matching lines @@
     const WebString& base_target) {
   // TODO(yosin) We should call |FrameSerializer::baseTagDeclarationOf()|.
   if (base_target.IsEmpty())
     return String("<base href=\".\">");
   String base_string = "<base href=\".\" target=\"" +
                        static_cast<const String&>(base_target) + "\">";
   return base_string;
 }
 
 }  // namespace blink