Disallow off-heap containers containing raw on-heap pointers.

third_party/WebKit/Source/core/frame/csp/SourceListDirective.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/SourceListDirective.h"
 
 #include "core/frame/csp/CSPSource.h"
 #include "core/frame/csp/ContentSecurityPolicy.h"
 #include "platform/network/ContentSecurityPolicyParsers.h"
 #include "platform/weborigin/KURL.h"
@@ skipping 541 matching lines @@
   m_nonces.add(nonce);
 }
 
 void SourceListDirective::addSourceHash(
     const ContentSecurityPolicyHashAlgorithm& algorithm,
     const DigestValue& hash) {
   m_hashes.add(CSPHashValue(algorithm, hash));
   m_hashAlgorithmsUsed |= algorithm;
 }
 
-void SourceListDirective::addSourceToMap(HashMap<String, CSPSource*>& hashMap,
-                                         CSPSource* source) {
+void SourceListDirective::addSourceToMap(
+    HeapHashMap<String, Member<CSPSource>>& hashMap,
+    CSPSource* source) {
   hashMap.add(source->getScheme(), source);
   if (source->getScheme() == "http")
     hashMap.add("https", source);
   else if (source->getScheme() == "ws")
     hashMap.add("wss", source);
 }
 
 bool SourceListDirective::hasSourceMatchInList(
     const KURL& url,
     ResourceRequest::RedirectStatus redirectStatus) const {
@@ skipping 61 matching lines @@
         allowInlineOther && !isHashOrNoncePresentOther &&
         (type != ContentSecurityPolicy::DirectiveType::ScriptSrc ||
          !allowDynamicOther);
     if (!allowAllInline() && allowAllInlineOther)
       return false;
   }
 
   return CSPSource::firstSubsumesSecond(normalizedA, normalizedB);
 }
 
-HashMap<String, CSPSource*> SourceListDirective::getIntersectSchemesOnly(
+HeapHashMap<String, Member<CSPSource>>
+SourceListDirective::getIntersectSchemesOnly(
     HeapVector<Member<CSPSource>> other) {
-  HashMap<String, CSPSource*> schemesA;
+  HeapHashMap<String, Member<CSPSource>> schemesA;
   for (const auto& sourceA : m_list) {
     if (sourceA->isSchemeOnly())
       addSourceToMap(schemesA, sourceA);
   }
   // Add schemes only sources if they are present in both `this` and `other`,
   // allowing upgrading `http` to `https` and `ws` to `wss`.
-  HashMap<String, CSPSource*> intersect;
+  HeapHashMap<String, Member<CSPSource>> intersect;
   for (const auto& sourceB : other) {
     if (sourceB->isSchemeOnly()) {
       if (schemesA.contains(sourceB->getScheme()))
         addSourceToMap(intersect, sourceB);
       else if (sourceB->getScheme() == "http" && schemesA.contains("https"))
         intersect.add("https", schemesA.get("https"));
       else if (sourceB->getScheme() == "ws" && schemesA.contains("wss"))
         intersect.add("wss", schemesA.get("wss"));
     }
   }
 
   return intersect;
 }
 
 HeapVector<Member<CSPSource>> SourceListDirective::getIntersectCSPSources(
     HeapVector<Member<CSPSource>> other) {
-  HashMap<String, CSPSource*> schemesMap = getIntersectSchemesOnly(other);
+  auto schemesMap = getIntersectSchemesOnly(other);
   HeapVector<Member<CSPSource>> normalized;
   // Add all normalized scheme source expressions.
-  for (auto it = schemesMap.begin(); it != schemesMap.end(); ++it) {
+  for (const auto& it : schemesMap) {
     // We do not add secure versions if insecure schemes are present.
-    if ((it->key != "https" || !schemesMap.contains("http")) &&
-        (it->key != "wss" || !schemesMap.contains("ws"))) {
-      normalized.append(it->value);
+    if ((it.key != "https" || !schemesMap.contains("http")) &&
+        (it.key != "wss" || !schemesMap.contains("ws"))) {
+      normalized.append(it.value);
     }
   }
 
   HeapVector<Member<CSPSource>> thisVector = m_list;
   if (m_allowSelf)
     thisVector.append(m_policy->getSelfSource());
   for (const auto& sourceA : thisVector) {
     if (schemesMap.contains(sourceA->getScheme()))
       continue;
 
@@ skipping 23 matching lines @@
   return normalized;
 }
 
 DEFINE_TRACE(SourceListDirective) {
   visitor->trace(m_policy);
   visitor->trace(m_list);
   CSPDirective::trace(visitor);
 }
 
 }  // namespace blink