Rename feature policy classes.

third_party/WebKit/Source/platform/feature_policy/FeaturePolicy.cpp

 // Copyright 2016 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 "platform/feature_policy/FeaturePolicy.h"
 
 #include "platform/json/JSONValues.h"
 #include "platform/network/HTTPParsers.h"
 #include "platform/weborigin/KURL.h"
 #include "platform/weborigin/SecurityOrigin.h"
@@ skipping 43 matching lines @@
     "sync-xhr", FeaturePolicy::FeatureDefault::EnableForAll};
 const FeaturePolicy::Feature kUsermedia{
     "usermedia", FeaturePolicy::FeatureDefault::EnableForAll};
 const FeaturePolicy::Feature kVibrateFeature{
     "vibrate", FeaturePolicy::FeatureDefault::EnableForSelf};
 const FeaturePolicy::Feature kWebRTC{
     "webrtc", FeaturePolicy::FeatureDefault::EnableForAll};
 
 // static
 std::unique_ptr<FeaturePolicy::Whitelist> FeaturePolicy::Whitelist::from(
-    const WebFeaturePolicy::ParsedWhitelist& parsedWhitelist) {
+    const WebParsedFeaturePolicyDeclaration& parsedDeclaration) {
   std::unique_ptr<Whitelist> whitelist(new FeaturePolicy::Whitelist);
-  if (parsedWhitelist.matchesAllOrigins) {
+  if (parsedDeclaration.matchesAllOrigins) {
     whitelist->addAll();
   } else {
-    for (const WebSecurityOrigin& origin : parsedWhitelist.origins)
+    for (const WebSecurityOrigin& origin : parsedDeclaration.origins)
       whitelist->add(static_cast<WTF::PassRefPtr<SecurityOrigin>>(origin));
   }
   return whitelist;
 }
 
 FeaturePolicy::Whitelist::Whitelist() : m_matchesAllOrigins(false) {}
 
 void FeaturePolicy::Whitelist::addAll() {
   m_matchesAllOrigins = true;
 }
@@ skipping 61 matching lines @@
 
 // static
 std::unique_ptr<FeaturePolicy> FeaturePolicy::createFromParentPolicy(
     const FeaturePolicy* parent,
     RefPtr<SecurityOrigin> currentOrigin) {
   return createFromParentPolicy(parent, std::move(currentOrigin),
                                 getDefaultFeatureList());
 }
 
 // static
-WebParsedFeaturePolicy FeaturePolicy::parseFeaturePolicy(
+WebParsedFeaturePolicyHeader FeaturePolicy::parseFeaturePolicy(
     const String& policy,
     RefPtr<SecurityOrigin> origin,
     Vector<String>* messages) {
-  Vector<WebFeaturePolicy::ParsedWhitelist> whitelists;
+  Vector<WebParsedFeaturePolicyDeclaration> whitelists;
 
   // Use a reasonable parse depth limit; the actual maximum depth is only going
   // to be 4 for a valid policy, but we'll give the featurePolicyParser a chance
   // to report more specific errors, unless the string is really invalid.
   std::unique_ptr<JSONArray> policyItems = parseJSONHeader(policy, 50);
   if (!policyItems) {
     if (messages)
       messages->push_back("Unable to parse header");
     return whitelists;
   }
 
   for (size_t i = 0; i < policyItems->size(); ++i) {
     JSONObject* item = JSONObject::cast(policyItems->at(i));
     if (!item) {
       if (messages)
         messages->push_back("Policy is not an object");
       continue;  // Array element is not an object; skip
     }
 
     for (size_t j = 0; j < item->size(); ++j) {
       JSONObject::Entry entry = item->at(j);
       String featureName = entry.first;
       JSONArray* targets = JSONArray::cast(entry.second);
       if (!targets) {
         if (messages)
           messages->push_back("Whitelist is not an array of strings.");
         continue;
       }
 
-      WebFeaturePolicy::ParsedWhitelist whitelist;
+      WebParsedFeaturePolicyDeclaration whitelist;
       whitelist.featureName = featureName;
       Vector<WebSecurityOrigin> origins;
       String targetString;
       for (size_t j = 0; j < targets->size(); ++j) {
         if (targets->at(j)->asString(&targetString)) {
           if (equalIgnoringCase(targetString, "self")) {
             if (!origin->isUnique())
               origins.push_back(origin);
           } else if (targetString == "*") {
             whitelist.matchesAllOrigins = true;
           } else {
             WebSecurityOrigin targetOrigin =
                 WebSecurityOrigin::createFromString(targetString);
             if (!targetOrigin.isNull() && !targetOrigin.isUnique())
               origins.push_back(targetOrigin);
           }
         } else {
           if (messages)
             messages->push_back("Whitelist is not an array of strings.");
         }
       }
       whitelist.origins = origins;
       whitelists.push_back(whitelist);
     }
   }
   return whitelists;
 }
 
-void FeaturePolicy::setHeaderPolicy(const WebParsedFeaturePolicy& policy) {
+void FeaturePolicy::setHeaderPolicy(
+    const WebParsedFeaturePolicyHeader& policy) {
   DCHECK(m_headerWhitelists.isEmpty());
-  for (const WebFeaturePolicy::ParsedWhitelist& parsedWhitelist : policy) {
+  for (const WebParsedFeaturePolicyDeclaration& parsedDeclaration : policy) {
     const FeaturePolicy::Feature* feature =
-        featureForName(parsedWhitelist.featureName, m_features);
+        featureForName(parsedDeclaration.featureName, m_features);
     if (!feature)
       continue;
-    m_headerWhitelists.set(feature, Whitelist::from(parsedWhitelist));
+    m_headerWhitelists.set(feature, Whitelist::from(parsedDeclaration));
   }
 }
 
 bool FeaturePolicy::isFeatureEnabledForOrigin(
     const FeaturePolicy::Feature& feature,
     const SecurityOrigin& origin) const {
   DCHECK(m_inheritedFeatures.contains(&feature));
   if (!m_inheritedFeatures.get(&feature)) {
     return false;
   }
@@ skipping 37 matching lines @@
     sb.append("  ");
     sb.append(whitelist.key->featureName);
     sb.append(": ");
     sb.append(whitelist.value->toString());
     sb.append("\n");
   }
   return sb.toString();
 }
 
 }  // namespace blink