Part 5.2: Is policy list subsumed under subsuming policy?

third_party/WebKit/Source/core/frame/csp/MediaListDirective.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "core/frame/csp/MediaListDirective.h"
 
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "platform/network/ContentSecurityPolicyParsers.h"
 #include "wtf/HashSet.h"
 #include "wtf/text/ParsingUtilities.h"
 #include "wtf/text/WTFString.h"
 
 namespace blink {
 
 MediaListDirective::MediaListDirective(const String& name,
                                        const String& value,
                                        ContentSecurityPolicy* policy)
     : CSPDirective(name, value, policy) {
   Vector<UChar> characters;
   value.appendTo(characters);
   parse(characters.data(), characters.data() + characters.size());
 }
 
-bool MediaListDirective::allows(const String& type) {
+bool MediaListDirective::allows(const String& type) const {
   return m_pluginTypes.contains(type);
 }
 
 void MediaListDirective::parse(const UChar* begin, const UChar* end) {
   // TODO(amalika): Revisit parsing algorithm. Right now plugin types are not
   // validated when they are added to m_pluginTypes.
   const UChar* position = begin;
 
   // 'plugin-types ____;' OR 'plugin-types;'
   if (position == end) {
@@ skipping 42 matching lines @@
       policy()->reportInvalidPluginTypes(String(begin, position - begin));
       continue;
     }
     m_pluginTypes.add(String(begin, position - begin));
 
     ASSERT(position == end || isASCIISpace(*position));
   }
 }
 
 bool MediaListDirective::subsumes(
-    const std::vector<MediaListDirective*>& other) {
+    const HeapVector<Member<MediaListDirective>>& other) const {
   if (!other.size())
     return false;
 
   // Find the effective set of plugins allowed by `other`.
   HashSet<String> normalizedB = other[0]->m_pluginTypes;
   for (size_t i = 1; i < other.size(); i++)
     normalizedB = other[i]->getIntersect(normalizedB);
 
   // Empty list of plugins is equivalent to no plugins being allowed.
   if (!m_pluginTypes.size())
     return !normalizedB.size();
 
   // Check that each element of `normalizedB` is allowed by `m_pluginTypes`.
   for (auto it = normalizedB.begin(); it != normalizedB.end(); ++it) {
     if (!allows(*it))
       return false;
   }
 
   return true;
 }
 
-HashSet<String> MediaListDirective::getIntersect(const HashSet<String>& other) {
+HashSet<String> MediaListDirective::getIntersect(
+    const HashSet<String>& other) const {
   HashSet<String> normalized;
   for (const auto& type : m_pluginTypes) {
     if (other.contains(type))
       normalized.add(type);
   }
 
   return normalized;
 }
 
 }  // namespace blink