Allow origin trials to be enabled by script

third_party/WebKit/Source/bindings/core/v8/ConditionalFeatures.h

 // 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.
 
 #ifndef ConditionalFeatures_h
 #define ConditionalFeatures_h
 
 #include "bindings/core/v8/DOMWrapperWorld.h"
 #include "core/CoreExport.h"
 #include "platform/feature_policy/FeaturePolicy.h"
+#include "wtf/HashSet.h"
 #include <v8.h>
 
 namespace blink {
 
 class ScriptState;
 class LocalFrame;
 
 using InstallConditionalFeaturesFunction = void (*)(const WrapperTypeInfo*,
                                                     const ScriptState*,
                                                     v8::Local<v8::Object>,
                                                     v8::Local<v8::Function>);
 
+using InstallConditionalFeaturesIfNeededFunction =
+    bool (*)(const WrapperTypeInfo*, const ScriptState*);
+
+using GetAffectedTypesForConditionalFeatureFunction =
+    void (*)(const String&, HashSet<const WrapperTypeInfo*>*);
+
 // Installs all of the conditionally enabled V8 bindings for the given type, in
 // a specific context. This is called in V8PerContextData, after the constructor
 // and prototype for the type have been created. It indirectly calls the
 // function set by |setInstallConditionalFeaturesFunction|.
 CORE_EXPORT void installConditionalFeatures(const WrapperTypeInfo*,
                                             const ScriptState*,
                                             v8::Local<v8::Object>,
                                             v8::Local<v8::Function>);
 
 // Sets the function to be called by |installConditionalFeatures|. The function
 // is initially set to the private |installConditionalFeaturesCore| function,
 // but can be overridden by this function. A pointer to the previously set
 // function is returned, so that functions can be chained.
 CORE_EXPORT InstallConditionalFeaturesFunction
     setInstallConditionalFeaturesFunction(InstallConditionalFeaturesFunction);
+CORE_EXPORT InstallConditionalFeaturesIfNeededFunction

[iclelland, 2017/01/20 14:31:19]

One way to get rid of the three parallel function pointers might be to
encapsulate them in a struct, which could be statically initialized in each
file, and then have one "registerOriginTrialsHandler(const struct)" method to
install all three at the same time. That would make it clear that all three (or
more in the future) are required, and ensure that either all or none are called.

If we store the struct explicitly in ConditionalFeatures.cpp, then there is one
additional lookup required for each call; one of the reasons for the function
pointers was to minimize the overhead of calling these for each prototype
instantiation; it's probably a micro-optimization to insist on it, though.

That would still require cooperative chaining of function calls. If we want to
avoid that, and didn't care how long it took to run the installation functions,
we could store a vector of structs (or three parallel vectors) and have a method
that iterates through it each time. I'm not sure if that's worth the complexity,
though, especially if these methods are going to be generated anyway.

[chasej, 2017/01/25 19:58:20]

I've simplified the approach, so that there's only two function
pointers (existing + new one). For just two pointers, I don't see
much point in doing anything like you suggested.

+    setInstallConditionalFeaturesIfNeededFunction(
+        InstallConditionalFeaturesIfNeededFunction);
+CORE_EXPORT GetAffectedTypesForConditionalFeatureFunction
+    setGetAffectedTypesForConditionalFeatureFunction(
+        GetAffectedTypesForConditionalFeatureFunction);
 
 // Installs all of the conditionally enabled V8 bindings on the Window object.
 // This is called separately from other objects so that attributes and
 // interfaces which need to be visible on the global object are installed even
 // when the V8 context is reused (i.e., after navigation)
 CORE_EXPORT void installPendingConditionalFeaturesOnWindow(const ScriptState*);
 
+// Installs all of the conditionally enabled V8 bindings for a feature, if
+// needed. This is called to install a newly-enabled feature on any existing
+// objects. If the target object hasn't been created, nothing is installed. The
+// enabled feature will be instead be installed when the object is created
+// (avoids forcing the creation of objects prematurely).
+// Returns true to indicate the feature is installed (either on existing objects
+// or deferred until object creation).

[iclelland, 2017/01/20 14:31:19]

I'm confused about what returning false from this function means.It looks like
it would be an error, and we should be DCHECKing that it never happens, but
maybe there are other possibilities with different kinds of trials that I'm not
seeing.

[chasej, 2017/01/25 19:58:20]

You're right. Ultimately, this function should never return false. It does now
in some cases, but only because I haven't implemented the handling for all the
various trials/features/types. I'll change it to void. 

+CORE_EXPORT bool installPendingConditionalFeature(const ScriptState*,
+                                                  const String&);
+
 CORE_EXPORT bool isFeatureEnabledInFrame(const FeaturePolicy::Feature&,
                                          const LocalFrame*);
 
 }  // namespace blink
 
 #endif  // ConditionalFeatures_h