Let CSP-mode-flag be available as a foreign_helper constant.

sdk/lib/_internal/compiler/js_lib/js_helper.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library _js_helper;
 
 import 'dart:_async_await_error_codes' as async_error_codes;
 
 import 'dart:_js_embedded_names' show
     JsGetName,
@@ skipping 2241 matching lines @@
       return JS(
           '',
           'function(f,s){'
             'return function(){'
               'return f.apply(s(this),arguments)'
             '}'
           '}(#,#)', function, getSelf);
     }
   }
 
-  static bool get isCsp => JS('bool', 'typeof dart_precompiled == "function"');
+  static bool get isCsp => JS_GET_FLAG("USE_CONTENT_SECURITY_POLICY");
 
   static forwardCallTo(receiver, function, bool isIntercepted) {
     if (isIntercepted) return forwardInterceptedCallTo(receiver, function);
     String stubName = JS('String|Null', '#.\$stubName', function);
     int arity = JS('int', '#.length', function);
     var lookedUpFunction = JS("", "#[#]", receiver, stubName);
     // The receiver[stubName] may not be equal to the function if we try to
     // forward to a super-method. Especially when we create a bound closure
     // of a super-call we need to make sure that we don't forward back to the
     // dynamically looked up function.
@@ skipping 96 matching lines @@
             '}'
           '}(#,#,#)', function, getSelf, getReceiver);
     }
   }
 
   static forwardInterceptedCallTo(receiver, function) {
     String selfField = BoundClosure.selfFieldName();
     String receiverField = BoundClosure.receiverFieldName();
     String stubName = JS('String|Null', '#.\$stubName', function);
     int arity = JS('int', '#.length', function);
-    bool isCsp = JS('bool', 'typeof dart_precompiled == "function"');
+    bool isCsp = JS_GET_FLAG("USE_CONTENT_SECURITY_POLICY");
     var lookedUpFunction = JS("", "#[#]", receiver, stubName);
     // The receiver[stubName] may not be equal to the function if we try to
     // forward to a super-method. Especially when we create a bound closure
     // of a super-call we need to make sure that we don't forward back to the
     // dynamically looked up function.
     bool isSuperCall = !identical(function, lookedUpFunction);
 
     if (isCsp || isSuperCall || arity >= 28) {
       return cspForwardInterceptedCall(arity, isSuperCall, stubName,
                                        function);
@@ skipping 1489 matching lines @@
   // This is a function that will return a helper function that does the
   // iteration of the sync*.
   //
   // Each invocation should give a body with fresh state.
   final dynamic /* js function */ _outerHelper;
 
   SyncStarIterable(this._outerHelper);
 
   Iterator get iterator => new SyncStarIterator(JS('', '#()', _outerHelper));
 }