DevTools: [CSS] getMatchedStylesForNode should return styles inherited through shadow boundary

LayoutTests/http/tests/inspector-protocol/css-protocol-test.js

 function initialize_cssTest()
 {
 
 InspectorTest.dumpStyleSheetText = function(styleSheetId, callback)
 {
     InspectorTest.sendCommandOrDie("CSS.getStyleSheetText", { styleSheetId: styleSheetId }, onStyleSheetText);
     function onStyleSheetText(result)
     {
         InspectorTest.log("==== Style sheet text ====");
         InspectorTest.log(result.text);
@@ skipping 39 matching lines @@
     {
         InspectorTest.sendCommandOrDie("Page.getResourceTree", {}, resourceTreeLoaded);
     }
 
     function resourceTreeLoaded(payload)
     {
         callback(payload.frameTree.frame.id);
     }
 };
 
+function indentLog(indent, string)
+{
+    var indentString = Array(indent+1).join(" ");
+    InspectorTest.log(indentString + string);
+}
+
 InspectorTest.dumpRuleMatch = function(ruleMatch)
 {
-    function log(indent, string)
-    {
-        var indentString = Array(indent+1).join(" ");
-        InspectorTest.log(indentString + string);
-    }
 
     var rule = ruleMatch.rule;
     var matchingSelectors = ruleMatch.matchingSelectors;
     var media = rule.media || [];
     var mediaLine = "";
     for (var i = 0; i < media.length; ++i)
         mediaLine += (i > 0 ? " " : "") + media[i].text;
     var baseIndent = 0;
     if (mediaLine.length) {
-        log(baseIndent, "@media " + mediaLine);
+        indentLog(baseIndent, "@media " + mediaLine);
         baseIndent += 4;
     }
     var selectorLine = "";
     var selectors = rule.selectorList.selectors;
     for (var i = 0; i < selectors.length; ++i) {
         if (i > 0)
             selectorLine += ", ";
         var matching = matchingSelectors.indexOf(i) !== -1;
         if (matching)
             selectorLine += "*";
         selectorLine += selectors[i].value;
         if (matching)
             selectorLine += "*";
     }
     selectorLine += " {";
     selectorLine += "    " + rule.origin;
-    log(baseIndent, selectorLine);
-    var style = rule.style;
+    indentLog(baseIndent, selectorLine);
+    InspectorTest.dumpStyle(rule.style, baseIndent);
+    indentLog(baseIndent, "}");
+};
+
+InspectorTest.dumpStyle = function(style, baseIndent)
+{
+    if (!style)
+        return;
     var cssProperties = style.cssProperties;
     for (var i = 0; i < cssProperties.length; ++i) {
         var cssProperty = cssProperties[i];
         var propertyLine = cssProperty.name + ": " + cssProperty.value + ";";
-        log(baseIndent + 4, propertyLine);
+        indentLog(baseIndent + 4, propertyLine);
     }
-    log(baseIndent, "}");
-};
+}
 
 InspectorTest.displayName = function(url)
 {
     return url.substr(url.lastIndexOf("/") + 1);
 };
 
 InspectorTest.loadAndDumpMatchingRulesForNode = function(nodeId, callback)
 {
     InspectorTest.sendCommandOrDie("CSS.getMatchedStylesForNode", { "nodeId": nodeId }, matchingRulesLoaded);
 
     function matchingRulesLoaded(result)
     {
         InspectorTest.log("Dumping matched rules: ");
-        var ruleMatches = result.matchedCSSRules;
-        for (var i = 0; i < ruleMatches.length; ++i) {
-            var ruleMatch = ruleMatches[i];
+        dumpRuleMatches(result.matchedCSSRules);
+        InspectorTest.log("Dumping inherited rules: ");
+        for (var inheritedEntry of result.inherited) {
+            InspectorTest.dumpStyle(inheritedEntry.inlineStyle);
+            dumpRuleMatches(inheritedEntry.matchedCSSRules);
+        }
+        callback();
+    }
+
+    function dumpRuleMatches(ruleMatches)
+    {
+        for (var ruleMatch of ruleMatches) {
             var origin = ruleMatch.rule.origin;
             if (origin !== "inspector" && origin !== "regular")
                 continue;
             InspectorTest.dumpRuleMatch(ruleMatch);
         }
-        callback();
     }
 }
 
 InspectorTest.loadAndDumpMatchingRules = function(documentNodeId, selector, callback)
 {
     InspectorTest.requestNodeId(documentNodeId, selector, nodeIdLoaded);
 
     function nodeIdLoaded(nodeId)
     {
         InspectorTest.loadAndDumpMatchingRulesForNode(nodeId, callback);
     }
 }
 
 }