[FeaturePolicy] Initial implementation of Feature Policy

third_party/WebKit/Source/bindings/core/v8/ConditionalFeatures.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 "bindings/core/v8/ConditionalFeatures.h"
 
 #include "bindings/core/v8/ScriptState.h"
+#include "bindings/core/v8/V8Document.h"
 #include "bindings/core/v8/V8HTMLLinkElement.h"
 #include "bindings/core/v8/V8Navigator.h"
 #include "bindings/core/v8/V8Window.h"
 #include "core/dom/ExecutionContext.h"
+#include "core/frame/Frame.h"
+#include "core/frame/LocalFrame.h"
 #include "core/origin_trials/OriginTrialContext.h"
+#include "platform/feature_policy/FeaturePolicy.h"
 
 namespace blink {
 
 void installConditionalFeaturesCore(const WrapperTypeInfo* wrapperTypeInfo,
                                     const ScriptState* scriptState,
                                     v8::Local<v8::Object> prototypeObject,
                                     v8::Local<v8::Function> interfaceObject) {
   // TODO(iclelland): Generate all of this logic at compile-time, based on the
   // configuration of origin trial enabled attibutes and interfaces in IDL
   // files. (crbug.com/615060)
   ExecutionContext* executionContext = scriptState->getExecutionContext();
   if (!executionContext)
     return;
   OriginTrialContext* originTrialContext = OriginTrialContext::from(
       executionContext, OriginTrialContext::DontCreateIfNotExists);
+  v8::Isolate* isolate = scriptState->isolate();
+  const DOMWrapperWorld& world = scriptState->world();
   if (wrapperTypeInfo == &V8HTMLLinkElement::wrapperTypeInfo) {
     if (RuntimeEnabledFeatures::linkServiceWorkerEnabled() ||
         (originTrialContext &&
          originTrialContext->isTrialEnabled("ForeignFetch"))) {
       V8HTMLLinkElement::installLinkServiceWorker(
-          scriptState->isolate(), scriptState->world(), v8::Local<v8::Object>(),
-          prototypeObject, interfaceObject);
+          isolate, world, v8::Local<v8::Object>(), prototypeObject,
+          interfaceObject);
+    }
+  }
+
+  // Install feature-policy-controlled features
+  LocalFrame* frame = nullptr;
+  if (executionContext->isDocument())
+    frame = toDocument(executionContext)->executingFrame();
+
+  if (wrapperTypeInfo == &V8Document::wrapperTypeInfo) {
+    if (isFeatureEnabledInFrame(&blink::kDocumentCookie, frame)) {
+      V8Document::installDocumentCookie(isolate, world, v8::Local<v8::Object>(),
+                                        prototypeObject, interfaceObject);
+    }
+    if (isFeatureEnabledInFrame(&blink::kDocumentDomain, frame)) {
+      V8Document::installDocumentDomain(isolate, world, v8::Local<v8::Object>(),
+                                        prototypeObject, interfaceObject);
+    }
+    if (isFeatureEnabledInFrame(&blink::kDocumentWrite, frame)) {
+      V8Document::installDocumentWrite(isolate, world, v8::Local<v8::Object>(),
+                                       prototypeObject, interfaceObject);
     }
   }
 }
 
 namespace {
 
 InstallConditionalFeaturesFunction s_installConditionalFeaturesFunction =
     &installConditionalFeaturesCore;
 }
 
 InstallConditionalFeaturesFunction setInstallConditionalFeaturesFunction(
     InstallConditionalFeaturesFunction newInstallConditionalFeaturesFunction) {
   InstallConditionalFeaturesFunction originalFunction =
       s_installConditionalFeaturesFunction;
   s_installConditionalFeaturesFunction = newInstallConditionalFeaturesFunction;
   return originalFunction;
 }
 
 void installConditionalFeatures(const WrapperTypeInfo* type,
                                 const ScriptState* scriptState,
                                 v8::Local<v8::Object> prototypeObject,
                                 v8::Local<v8::Function> interfaceObject) {
   (*s_installConditionalFeaturesFunction)(type, scriptState, prototypeObject,
                                           interfaceObject);
 }
 
+bool isFeatureEnabledInFrame(const FeaturePolicyFeature* feature,
+                             const Frame* frame) {

[dcheng, 2016/10/20 17:41:44]

Make this a LocalFrame.

[iclelland, 2016/10/21 13:38:25]

Done.

+  // If there is no frame, or if feature policy is disabled, use defaults.
+  bool enabledByDefault =
+      (feature->defaultPolicy != kDisableFeatureForAllOrigins);
+  if (!RuntimeEnabledFeatures::featurePolicyEnabled() || !frame)
+    return enabledByDefault;
+  FeaturePolicy* featurePolicy = frame->getFeaturePolicy();
+  if (!featurePolicy)
+    return enabledByDefault;
+
+  // Otherwise, check policy.
+  return featurePolicy->isFeatureEnabled(feature);
+}
+
 }  // namespace blink