[OriginTrials] Support OriginTrialEnabled IDL attribute on constants

third_party/WebKit/Source/bindings/core/v8/V8DOMConfiguration.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 148 matching lines @@
     if (accessor.propertyLocationConfiguration & V8DOMConfiguration::OnInterface) {
         // Attributes installed on the interface object must be static
         // attributes, so no need to specify a signature, i.e. no need to do
         // type check against a holder.
         v8::Local<FunctionOrTemplate> getter = createAccessorFunctionOrTemplate<FunctionOrTemplate>(isolate, getterCallback, data, v8::Local<v8::Signature>(), 0);
         v8::Local<FunctionOrTemplate> setter = createAccessorFunctionOrTemplate<FunctionOrTemplate>(isolate, setterCallback, data, v8::Local<v8::Signature>(), 1);
         interfaceOrTemplate->SetAccessorProperty(name, getter, setter, static_cast<v8::PropertyAttribute>(accessor.attribute), static_cast<v8::AccessControl>(accessor.settings));
     }
 }
 
-void installConstantInternal(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> interfaceTemplate, v8::Local<v8::ObjectTemplate> prototypeTemplate, const V8DOMConfiguration::ConstantConfiguration& constant)
+v8::Local<v8::Primitive> valueForConstant(v8::Isolate* isolate, const V8DOMConfiguration::ConstantConfiguration& constant)
 {
-    v8::Local<v8::String> constantName = v8AtomicString(isolate, constant.name);
-    v8::PropertyAttribute attributes =
-        static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
     v8::Local<v8::Primitive> value;
     switch (constant.type) {
     case V8DOMConfiguration::ConstantTypeShort:
     case V8DOMConfiguration::ConstantTypeLong:
     case V8DOMConfiguration::ConstantTypeUnsignedShort:
         value = v8::Integer::New(isolate, constant.ivalue);
         break;
     case V8DOMConfiguration::ConstantTypeUnsignedLong:
         value = v8::Integer::NewFromUnsigned(isolate, constant.ivalue);
         break;
     case V8DOMConfiguration::ConstantTypeFloat:
     case V8DOMConfiguration::ConstantTypeDouble:
         value = v8::Number::New(isolate, constant.dvalue);
         break;
     default:
         NOTREACHED();
     }
+    return value;
+}
+
+void installConstantInternal(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> interfaceTemplate, v8::Local<v8::ObjectTemplate> prototypeTemplate, const V8DOMConfiguration::ConstantConfiguration& constant)
+{
+    v8::Local<v8::String> constantName = v8AtomicString(isolate, constant.name);
+    v8::PropertyAttribute attributes =
+        static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
+    v8::Local<v8::Primitive> value = valueForConstant(isolate, constant);
     interfaceTemplate->Set(constantName, value, attributes);
     prototypeTemplate->Set(constantName, value, attributes);
 }
 
+void installConstantInternal(v8::Isolate* isolate, v8::Local<v8::Object> prototype, const V8DOMConfiguration::ConstantConfiguration& constant, const DOMWrapperWorld& world)

[haraken, 2016/06/13 01:12:59]

Why do you need to pass DOMWrapperWorld? It's unused.

[iclelland, 2016/06/15 14:08:40]

Not needed. removed. (Replaced with WrapperTypeInfo, to resolve Yuki's comment
below)

+{
+    v8::Local<v8::Name> name = v8AtomicString(isolate, constant.name);
+    v8::Local<v8::Primitive> value = valueForConstant(isolate, constant);
+    v8CallOrCrash(prototype->DefineOwnProperty(isolate->GetCurrentContext(), name, value));

[haraken, 2016/06/13 01:12:59]

Per the spec, constant must be defined on both prototype object and instance
object (See line 197 and 198). But this CL is defining constants only on
prototype objects.

[iclelland, 2016/06/15 12:12:04]

I'm adding them now on the object returned from constructorForType(); as far as
I can tell through reading the code, that is the interface object. Is that
correct?

Also, my test case for this would bind them to window.Internals, which according
to spec should be the defined interface object for the V8Internals, but that
doesn't appear to be defined on window. ("internals", the instance, is defined,
but not "Internals") Is that a bug?

[Yuki, 2016/06/15 12:32:11]

Yes, the function object returned by constructorForType() is an interface
object.
It's not a bug.  Not all the interface objects are required to be exposed.  The
spec defines which interface objects must be exposed and which must not.  Plus,
window.internals is Blink-specific object, not defined by the spec.  So, it's
fine.

[iclelland, 2016/06/15 14:08:41]

I see, thanks. I'm not sure how to write a proper layout test for this then,
without explicitly exposing this interface. I've done manual testing, adding
additional constants to other origin trials, and verified that it works.

+}
+
 template<class Configuration>
 void installMethodInternal(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> instanceTemplate, v8::Local<v8::ObjectTemplate> prototypeTemplate, v8::Local<v8::FunctionTemplate> interfaceTemplate, v8::Local<v8::Signature> signature, const Configuration& method, const DOMWrapperWorld& world)
 {
     if (method.exposeConfiguration == V8DOMConfiguration::OnlyExposedToPrivateScript
         && !world.isPrivateScriptIsolatedWorld())
         return;
 
     v8::Local<v8::Name> name = method.methodName(isolate);
     v8::FunctionCallback callback = method.callbackForWorld(world);
 
@@ skipping 86 matching lines @@
 {
     for (size_t i = 0; i < constantCount; ++i)
         installConstantInternal(isolate, interfaceTemplate, prototypeTemplate, constants[i]);
 }
 
 void V8DOMConfiguration::installConstant(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> interfaceTemplate, v8::Local<v8::ObjectTemplate> prototypeTemplate, const ConstantConfiguration& constant)
 {
     installConstantInternal(isolate, interfaceTemplate, prototypeTemplate, constant);
 }
 
+void V8DOMConfiguration::installConstant(v8::Isolate* isolate, const DOMWrapperWorld& world, v8::Local<v8::Object> prototype, const ConstantConfiguration& constant)
+{
+    installConstantInternal(isolate, prototype, constant, world);
+}
+
 void V8DOMConfiguration::installConstantWithGetter(v8::Isolate* isolate, v8::Local<v8::FunctionTemplate> interfaceTemplate, v8::Local<v8::ObjectTemplate> prototypeTemplate, const char* name, v8::AccessorNameGetterCallback getter)
 {
     v8::Local<v8::String> constantName = v8AtomicString(isolate, name);
     v8::PropertyAttribute attributes =
         static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontDelete);
     interfaceTemplate->SetNativeDataProperty(constantName, getter, 0, v8::Local<v8::Value>(), attributes);
     prototypeTemplate->SetNativeDataProperty(constantName, getter, 0, v8::Local<v8::Value>(), attributes);
 }
 
 void V8DOMConfiguration::installMethods(v8::Isolate* isolate, const DOMWrapperWorld& world, v8::Local<v8::ObjectTemplate> instanceTemplate, v8::Local<v8::ObjectTemplate> prototypeTemplate, v8::Local<v8::FunctionTemplate> interfaceTemplate, v8::Local<v8::Signature> signature, const MethodConfiguration* methods, size_t methodCount)
@@ skipping 52 matching lines @@
     data->setInterfaceTemplate(world, wrapperTypeInfo, result);
     return result;
 }
 
 void V8DOMConfiguration::setClassString(v8::Isolate* isolate, v8::Local<v8::ObjectTemplate> objectTemplate, const char* classString)
 {
     objectTemplate->Set(v8::Symbol::GetToStringTag(isolate), v8AtomicString(isolate, classString), static_cast<v8::PropertyAttribute>(v8::ReadOnly | v8::DontEnum));
 }
 
 } // namespace blink