// 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/RuntimeEnabledFeatures.h"
#include "platform/json/JSONValues.h"
#include "platform/network/HTTPParsers.h"
#include "platform/weborigin/SecurityOrigin.h"
#include "platform/wtf/PtrUtil.h"

namespace blink {

namespace {

void AddAllowFeatureToList(
    WebFeaturePolicyFeature feature,
    Vector<WebParsedFeaturePolicyDeclaration>& whitelists) {
  WebParsedFeaturePolicyDeclaration whitelist;
  whitelist.feature = feature;
  whitelist.matches_all_origins = true;
  whitelists.push_back(whitelist);
}

}  // namespace

WebParsedFeaturePolicy ParseFeaturePolicy(const String& policy,
                                          RefPtr<SecurityOrigin> origin,
                                          Vector<String>* messages) {
  return ParseFeaturePolicy(policy, origin, messages,
                            GetDefaultFeatureNameMap());
}

WebParsedFeaturePolicy ParseFeaturePolicy(const String& policy,
                                          RefPtr<SecurityOrigin> origin,
                                          Vector<String>* messages,
                                          const FeatureNameMap& feature_names) {
  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> policy_items = ParseJSONHeader(policy, 50);
  if (!policy_items) {
    if (messages)
      messages->push_back("Unable to parse header.");
    return whitelists;
  }

  for (size_t i = 0; i < policy_items->size(); ++i) {
    JSONObject* item = JSONObject::Cast(policy_items->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);
      if (!feature_names.Contains(entry.first))
        continue;  // Unrecognized feature; skip
      WebFeaturePolicyFeature feature = feature_names.at(entry.first);
      JSONArray* targets = JSONArray::Cast(entry.second);
      if (!targets) {
        if (messages)
          messages->push_back("Whitelist is not an array of strings.");
        continue;
      }

      WebParsedFeaturePolicyDeclaration whitelist;
      whitelist.feature = feature;
      Vector<WebSecurityOrigin> origins;
      String target_string;
      for (size_t j = 0; j < targets->size(); ++j) {
        if (targets->at(j)->AsString(&target_string)) {
          if (EqualIgnoringASCIICase(target_string, "self")) {
            if (!origin->IsUnique())
              origins.push_back(origin);
          } else if (target_string == "*") {
            whitelist.matches_all_origins = true;
          } else {
            WebSecurityOrigin target_origin =
                WebSecurityOrigin::CreateFromString(target_string);
            if (!target_origin.IsNull() && !target_origin.IsUnique())
              origins.push_back(target_origin);
          }
        } else {
          if (messages)
            messages->push_back("Whitelist is not an array of strings.");
        }
      }
      whitelist.origins = origins;
      whitelists.push_back(whitelist);
    }
  }
  return whitelists;
}

WebParsedFeaturePolicy GetContainerPolicyFromAllowedFeatures(
    const WebVector<WebFeaturePolicyFeature>& features,
    bool allowfullscreen,
    bool allowpayment,
    RefPtr<SecurityOrigin> origin) {
  Vector<WebParsedFeaturePolicyDeclaration> whitelists;
  bool override_payment = false;
  bool override_fullscreen = false;
  for (const WebFeaturePolicyFeature feature : features) {
    // Container policy should override "allowfullscreen" and
    // "allowpaymentrequest" policies.
    if (feature == WebFeaturePolicyFeature::kPayment)
      override_payment = true;
    if (feature == WebFeaturePolicyFeature::kFullscreen)
      override_fullscreen = true;

    WebParsedFeaturePolicyDeclaration whitelist;
    whitelist.feature = feature;
    whitelist.origins = Vector<WebSecurityOrigin>(1UL, {origin});
    whitelists.push_back(whitelist);
  }
  // If allowfullscreen attribute is present and no fullscreen policy is set,
  // enable the feature for all origins; similarly for allowpaymentrequest.
  if (allowpayment && !override_payment)
    AddAllowFeatureToList(WebFeaturePolicyFeature::kPayment, whitelists);
  if (allowfullscreen && !override_fullscreen)
    AddAllowFeatureToList(WebFeaturePolicyFeature::kFullscreen, whitelists);

  return whitelists;
}

bool IsSupportedInFeaturePolicy(WebFeaturePolicyFeature feature) {
  switch (feature) {
    // TODO(lunalu): Re-enabled fullscreen in feature policy once tests have
    // been updated.
    // crbug.com/666761
    case WebFeaturePolicyFeature::kFullscreen:
      return false;
    case WebFeaturePolicyFeature::kPayment:
      return true;
    case WebFeaturePolicyFeature::kVibrate:
      return RuntimeEnabledFeatures::featurePolicyExperimentalFeaturesEnabled();
    default:
      return false;
  }
}

const FeatureNameMap& GetDefaultFeatureNameMap() {
  DEFINE_STATIC_LOCAL(FeatureNameMap, default_feature_name_map, ());
  if (default_feature_name_map.IsEmpty()) {
    default_feature_name_map.Set("fullscreen",
                                 WebFeaturePolicyFeature::kFullscreen);
    default_feature_name_map.Set("payment", WebFeaturePolicyFeature::kPayment);
    if (RuntimeEnabledFeatures::featurePolicyExperimentalFeaturesEnabled()) {
      default_feature_name_map.Set("vibrate",
                                   WebFeaturePolicyFeature::kVibrate);
      default_feature_name_map.Set("camera", WebFeaturePolicyFeature::kCamera);
      default_feature_name_map.Set("encrypted-media",
                                   WebFeaturePolicyFeature::kEme);
      default_feature_name_map.Set("microphone",
                                   WebFeaturePolicyFeature::kMicrophone);
      default_feature_name_map.Set("speaker",
                                   WebFeaturePolicyFeature::kSpeaker);
      default_feature_name_map.Set("cookie",
                                   WebFeaturePolicyFeature::kDocumentCookie);
      default_feature_name_map.Set("domain",
                                   WebFeaturePolicyFeature::kDocumentDomain);
      default_feature_name_map.Set("docwrite",
                                   WebFeaturePolicyFeature::kDocumentWrite);
      default_feature_name_map.Set("geolocation",
                                   WebFeaturePolicyFeature::kGeolocation);
      default_feature_name_map.Set("midi",
                                   WebFeaturePolicyFeature::kMidiFeature);
      default_feature_name_map.Set("notifications",
                                   WebFeaturePolicyFeature::kNotifications);
      default_feature_name_map.Set("push", WebFeaturePolicyFeature::kPush);
      default_feature_name_map.Set("sync-script",
                                   WebFeaturePolicyFeature::kSyncScript);
      default_feature_name_map.Set("sync-xhr",
                                   WebFeaturePolicyFeature::kSyncXHR);
      default_feature_name_map.Set("webrtc", WebFeaturePolicyFeature::kWebRTC);
    }
  }
  return default_feature_name_map;
}

}  // namespace blink