Adds tracing to MHTML generation call chain.

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 42 matching lines @@
 #include "core/html/HTMLFrameElementBase.h"
 #include "core/html/HTMLImageElement.h"
 #include "core/html/HTMLInputElement.h"
 #include "core/html/HTMLLinkElement.h"
 #include "core/html/HTMLMetaElement.h"
 #include "core/html/HTMLStyleElement.h"
 #include "core/html/ImageDocument.h"
 #include "core/style/StyleFetchedImage.h"
 #include "core/style/StyleImage.h"
 #include "platform/SerializedResource.h"
+#include "platform/TraceEvent.h"
 #include "platform/graphics/Image.h"
 #include "platform/heap/Handle.h"
 #include "wtf/HashSet.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringBuilder.h"
 #include "wtf/text/TextEncoding.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
@@ skipping 168 matching lines @@
 FrameSerializer::FrameSerializer(
     Vector<SerializedResource>& resources,
     Delegate& delegate)
     : m_resources(&resources)
     , m_delegate(delegate)
 {
 }
 
 void FrameSerializer::serializeFrame(const LocalFrame& frame)
 {
+    TRACE_EVENT0("page-serialization", "FrameSerializer::serializeFrame");
     ASSERT(frame.document());
     Document& document = *frame.document();
     KURL url = document.url();
 
     // If frame is an image document, add the image and don't continue
     if (document.isImageDocument()) {
         ImageDocument& imageDocument = toImageDocument(document);
         addImageToResources(imageDocument.cachedImage(), url);
         return;
     }
 
+    TRACE_EVENT_BEGIN0("page-serialization", "FrameSerializer::serializeFrame HTML");
     HeapVector<Member<Node>> serializedNodes;
     SerializerMarkupAccumulator accumulator(m_delegate, document, serializedNodes);
     String text = serializeNodes<EditingStrategy>(accumulator, document, IncludeNode);
 
     CString frameHTML = document.encoding().encode(text, WTF::EntitiesForUnencodables);
     m_resources->append(SerializedResource(url, document.suggestedMIMEType(), SharedBuffer::create(frameHTML.data(), frameHTML.length())));
+    TRACE_EVENT_END0("page-serialization", "FrameSerializer::serializeFrame HTML");
 
     for (Node* node: serializedNodes) {
         ASSERT(node);
         if (!node->isElementNode())
             continue;
 
         Element& element = toElement(*node);
         // We have to process in-line style as it might contain some resources (typically background images).
         if (element.isStyledElement()) {
             retrieveResourcesForProperties(element.inlineStyle(), document);
@@ skipping 21 matching lines @@
         } else if (isHTMLStyleElement(element)) {
             HTMLStyleElement& styleElement = toHTMLStyleElement(element);
             if (CSSStyleSheet* sheet = styleElement.sheet())
                 serializeCSSStyleSheet(*sheet, KURL());
         }
     }
 }
 
 void FrameSerializer::serializeCSSStyleSheet(CSSStyleSheet& styleSheet, const KURL& url)
 {
+    TRACE_EVENT2("page-serialization", "FrameSerializer::serializeCSSStyleSheet",
+        "type", "CSS", "url", url.elidedString().utf8().data());
     StringBuilder cssText;
     cssText.append("@charset \"");
     cssText.append(styleSheet.contents()->charset().lower());
     cssText.append("\";\n\n");
 
     for (unsigned i = 0; i < styleSheet.length(); ++i) {
         CSSRule* rule = styleSheet.item(i);
         String itemText = rule->cssText();
         if (!itemText.isEmpty()) {
             cssText.append(itemText);
@@ skipping 80 matching lines @@
     String mimeType = resource.response().mimeType();
     m_resources->append(SerializedResource(url, mimeType, std::move(data)));
     m_resourceURLs.add(url);
 }
 
 void FrameSerializer::addImageToResources(ImageResource* image, const KURL& url)
 {
     if (!image || !image->hasImage() || image->errorOccurred() || !shouldAddURL(url))
         return;
 
+    TRACE_EVENT2("page-serialization", "FrameSerializer::addImageToResources",
+        "type", "image", "url", url.elidedString().utf8().data());
     RefPtr<const SharedBuffer> data = image->getImage()->data();
     addToResources(*image, data, url);
 }
 
 void FrameSerializer::addFontToResources(FontResource* font)
 {
     if (!font || !font->isLoaded() || !font->resourceBuffer() || !shouldAddURL(font->url()))
         return;
 
     RefPtr<const SharedBuffer> data(font->resourceBuffer());
@@ skipping 57 matching lines @@
             continue;
         }
         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