DevTools: Add CSS.getPlatformFontsForNode in protocol.json

Source/core/inspector/InspectorCSSAgent.cpp

 /*
  * Copyright (C) 2010, 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:
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
  *     notice, this list of conditions and the following disclaimer in the
@@ skipping 40 matching lines @@
 #include "core/dom/NodeList.h"
 #include "core/html/HTMLHeadElement.h"
 #include "core/inspector/InspectorDOMAgent.h"
 #include "core/inspector/InspectorHistory.h"
 #include "core/inspector/InspectorPageAgent.h"
 #include "core/inspector/InspectorState.h"
 #include "core/inspector/InstrumentingAgents.h"
 #include "core/loader/DocumentLoader.h"
 #include "core/page/ContentSecurityPolicy.h"
 #include "core/platform/JSONValues.h"
+#include "core/platform/graphics/Font.h"
+#include "core/platform/graphics/GlyphBuffer.h"
+#include "core/platform/graphics/TextRun.h"
+#include "core/platform/graphics/WidthIterator.h"
+#include "core/rendering/InlineTextBox.h"
+#include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderRegion.h"
+#include "core/rendering/RenderText.h"
+#include "core/rendering/RenderTextFragment.h"
 #include "wtf/CurrentTime.h"
 #include "wtf/HashSet.h"
 #include "wtf/Vector.h"
 #include "wtf/text/CString.h"
 #include "wtf/text/StringConcatenate.h"
 
 namespace CSSAgentState {
 static const char cssAgentEnabled[] = "cssAgentEnabled";
 }
 
@@ skipping 960 matching lines @@
 {
     Node* node = m_domAgent->assertNode(errorString, nodeId);
     if (!node)
         return;
 
     RefPtr<CSSComputedStyleDeclaration> computedStyleInfo = CSSComputedStyleDeclaration::create(node, true);
     RefPtr<InspectorStyle> inspectorStyle = InspectorStyle::create(InspectorCSSId(), computedStyleInfo, 0);
     style = inspectorStyle->buildArrayForComputedStyle();
 }
 
+void InspectorCSSAgent::collectPlatformFontsForRenderer(RenderText* renderer, HashMap<String, int>* fontStats)
+{
+    for (InlineTextBox* box = renderer->firstTextBox(); box; box = box->nextTextBox()) {
+        RenderStyle* style = renderer->style(box->isFirstLineStyle());
+        const Font& font = style->font();
+        TextRun run = box->constructTextRunForInspector(style, font);
+        WidthIterator it(&font, run, 0, false);
+        GlyphBuffer glyphBuffer;
+        it.advance(run.length(), &glyphBuffer);
+        for (int i = 0; i < glyphBuffer.size(); ++i) {
+            String familyName = glyphBuffer.fontDataAt(i)->platformData().fontFamilyName();
+            int value = fontStats->contains(familyName) ? fontStats->get(familyName) : 0;
+            fontStats->set(familyName, value + 1);
+        }
+    }
+}
+
+void InspectorCSSAgent::getPlatformFontsForNode(ErrorString* errorString, int nodeId,
+    RefPtr<TypeBuilder::Array<TypeBuilder::CSS::PlatformFontUsage> >& platformFontUsage)
+{
+    Node* node = m_domAgent->assertNode(errorString, nodeId);
+    if (!node)
+        return;
+    Vector<Node*> textNodes;
+    if (node->nodeType() == Node::TEXT_NODE) {
+        if (node->renderer())
+            textNodes.append(node);
+    } else {
+        for (Node* child = node->firstChild(); child; child = child->nextSibling()) {
+            if (child->nodeType() == Node::TEXT_NODE && child->renderer())
+                textNodes.append(child);
+        }
+    }
+
+    HashMap<String, int> fontStats;
+    for (size_t i = 0; i < textNodes.size(); ++i) {
+        RenderText* renderer = toRenderText(textNodes[i]->renderer());
+        collectPlatformFontsForRenderer(renderer, &fontStats);
+        if (renderer->isTextFragment()) {
+            RenderTextFragment* textFragment = toRenderTextFragment(renderer);
+            if (textFragment->firstLetter()) {
+                RenderObject* firstLetter = textFragment->firstLetter();
+                for (RenderObject* current = firstLetter->firstChild(); current; current = current->nextSibling()) {
+                    if (current->isText())
+                        collectPlatformFontsForRenderer(toRenderText(current), &fontStats);
+                }
+            }
+        }
+    }
+
+    platformFontUsage = TypeBuilder::Array<TypeBuilder::CSS::PlatformFontUsage>::create();
+    for (HashMap<String, int>::iterator it = fontStats.begin(), end = fontStats.end(); it != end; ++it) {
+        RefPtr<TypeBuilder::CSS::PlatformFontUsage> platformFont = TypeBuilder::CSS::PlatformFontUsage::create()
+            .setFamilyName(it->key)
+            .setGlyphCount(it->value);
+        platformFontUsage->addItem(platformFont);
+    }
+}
+
 void InspectorCSSAgent::getAllStyleSheets(ErrorString*, RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader> >& styleInfos)
 {
     styleInfos = TypeBuilder::Array<TypeBuilder::CSS::CSSStyleSheetHeader>::create();
     Vector<InspectorStyleSheet*> styleSheets;
     collectAllStyleSheets(styleSheets);
     for (size_t i = 0; i < styleSheets.size(); ++i)
         styleInfos->addItem(styleSheets.at(i)->buildObjectForStyleSheetInfo());
 }
 
 void InspectorCSSAgent::getStyleSheet(ErrorString* errorString, const String& styleSheetId, RefPtr<TypeBuilder::CSS::CSSStyleSheetBody>& styleSheetObject)
@@ skipping 654 matching lines @@
             documentsToChange.add(element->ownerDocument());
     }
 
     m_nodeIdToForcedPseudoState.clear();
     for (HashSet<Document*>::iterator it = documentsToChange.begin(), end = documentsToChange.end(); it != end; ++it)
         (*it)->setNeedsStyleRecalc();
 }
 
 } // namespace WebCore