Bug 980180 - remove principals as an argument to compilation, part 1 (r=terrence)

--HG--
extra : rebase_source : 8bf0ff6974870d6772021aafa88dd8fd5132fc70

content/base/src/nsFrameMessageManager.cpp

@@ -1494,8 +1494,7 @@ nsFrameScriptExecutor::TryCacheLoadAndCompileScript(const nsAString& aURL,
     if (global) {
       JSAutoCompartment ac(cx, global);
       JS::CompileOptions options(cx);
-      options.setFileAndLine(url.get(), 1)
+      options.setFileAndLine(url.get(), 1);
-             .setPrincipals(nsJSPrincipals::get(mPrincipal));
       JS::Rooted<JSScript*> script(cx);
       JS::Rooted<JSObject*> funobj(cx);
       if (aRunInGlobalScope) {

content/xul/content/src/nsXULElement.cpp

@@ -2643,8 +2643,7 @@ nsXULPrototypeScript::Compile(const char16_t* aText,
     // Ok, compile it to create a prototype script object!
     NS_ENSURE_TRUE(JSVersion(mLangVersion) != JSVERSION_UNKNOWN, NS_OK);
     JS::CompileOptions options(cx);
-    options.setPrincipals(nsJSPrincipals::get(aDocument->NodePrincipal()))
+    options.setFileAndLine(urlspec.get(), aLineNo)
-           .setFileAndLine(urlspec.get(), aLineNo)
            .setVersion(JSVersion(mLangVersion));
     // If the script was inline, tell the JS parser to save source for
     // Function.prototype.toSource(). If it's out of line, we retrieve the

dom/base/nsJSUtils.cpp

@@ -151,12 +151,6 @@ nsJSUtils::CompileFunction(JSContext* aCx,
   mozilla::DebugOnly<nsIScriptContext*> ctx = GetScriptContextFromJSContext(aCx);
   MOZ_ASSERT_IF(ctx, ctx->IsContextInitialized());
 
-  // Since aTarget and aCx are same-compartment, there should be no distinction
-  // between the object principal and the cx principal.
-  // However, aTarget may be null in the wacky aShared case. So use the cx.
-  JSPrincipals* p = JS_GetCompartmentPrincipals(js::GetContextCompartment(aCx));
-  aOptions.setPrincipals(p);
-
   // Do the junk Gecko is supposed to do before calling into JSAPI.
   if (aTarget) {
     JS::ExposeObjectToActiveJS(aTarget);
@@ -205,9 +199,6 @@ nsJSUtils::EvaluateString(JSContext* aCx,
   nsAutoMicroTask mt;
   nsresult rv = NS_OK;
 
-  JSPrincipals* p = JS_GetCompartmentPrincipals(js::GetObjectCompartment(aScopeObject));
-  aCompileOptions.setPrincipals(p);
-
   bool ok = false;
   nsIScriptSecurityManager* ssm = nsContentUtils::GetSecurityManager();
   NS_ENSURE_TRUE(ssm->ScriptAllowed(js::GetGlobalForObjectCrossCompartment(aScopeObject)), NS_OK);

dom/workers/ScriptLoader.cpp

@@ -699,9 +699,6 @@ ScriptExecutorRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
   JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
   NS_ASSERTION(global, "Must have a global by now!");
 
-  JSPrincipals* principal = GetWorkerPrincipal();
-  NS_ASSERTION(principal, "This should never be null!");
-
   for (uint32_t index = mFirstIndex; index <= mLastIndex; index++) {
     ScriptLoadInfo& loadInfo = loadInfos.ElementAt(index);
 
@@ -718,8 +715,7 @@ ScriptExecutorRunnable::WorkerRun(JSContext* aCx, WorkerPrivate* aWorkerPrivate)
     NS_ConvertUTF16toUTF8 filename(loadInfo.mURL);
 
     JS::CompileOptions options(aCx);
-    options.setPrincipals(principal)
+    options.setFileAndLine(filename.get(), 1);
-           .setFileAndLine(filename.get(), 1);
     if (!JS::Evaluate(aCx, global, options, loadInfo.mScriptText.get(),
                       loadInfo.mScriptText.Length(), nullptr)) {
       return true;

dom/workers/WorkerPrivate.cpp

@@ -5369,7 +5369,6 @@ WorkerPrivate::RunExpiredTimeouts(JSContext* aCx)
 
   AutoPtrComparator<TimeoutInfo> comparator = GetAutoPtrComparator(mTimeouts);
   JS::Rooted<JSObject*> global(aCx, JS::CurrentGlobalOrNull(aCx));
-  JSPrincipals* principal = GetWorkerPrincipal();
 
   // We want to make sure to run *something*, even if the timer fired a little
   // early. Fudge the value of now to at least include the first timeout.
@@ -5415,8 +5414,7 @@ WorkerPrivate::RunExpiredTimeouts(JSContext* aCx)
       nsString expression = info->mTimeoutString;
 
       JS::CompileOptions options(aCx);
-      options.setPrincipals(principal)
+      options.setFileAndLine(info->mFilename.get(), info->mLineNumber);
-        .setFileAndLine(info->mFilename.get(), info->mLineNumber);
 
       if ((expression.IsEmpty() ||
            !JS::Evaluate(aCx, global, options, expression.get(),

ipc/testshell/XPCShellEnvironment.cpp

@@ -164,8 +164,7 @@ Load(JSContext *cx,
         Rooted<JSObject*> global(cx, JS::CurrentGlobalOrNull(cx));
         JS::CompileOptions options(cx);
         options.setUTF8(true)
-               .setFileAndLine(filename.ptr(), 1)
+               .setFileAndLine(filename.ptr(), 1);
-               .setPrincipals(Environment(global)->GetPrincipal());
         JS::RootedObject rootedObj(cx, obj);
         JSScript *script = JS::Compile(cx, rootedObj, options, file);
         fclose(file);
@@ -333,8 +332,7 @@ XPCShellEnvironment::ProcessFile(JSContext *cx,
 
         JS::CompileOptions options(cx);
         options.setUTF8(true)
-               .setFileAndLine(filename, 1)
+               .setFileAndLine(filename, 1);
-               .setPrincipals(env->GetPrincipal());
         JSScript* script = JS::Compile(cx, obj, options, file);
         if (script)
             (void)JS_ExecuteScript(cx, obj, script, result.address());
@@ -371,8 +369,7 @@ XPCShellEnvironment::ProcessFile(JSContext *cx,
         /* Clear any pending exception from previous failed compiles.  */
         JS_ClearPendingException(cx);
         JS::CompileOptions options(cx);
-        options.setFileAndLine("typein", startline)
+        options.setFileAndLine("typein", startline);
-               .setPrincipals(env->GetPrincipal());
         script = JS_CompileScript(cx, obj, buffer, strlen(buffer), options);
         if (script) {
             JSErrorReporter older;
@@ -580,8 +577,7 @@ XPCShellEnvironment::EvaluateString(const nsString& aString,
   JSAutoCompartment ac(cx, global);
 
   JS::CompileOptions options(cx);
-  options.setFileAndLine("typein", 0)
+  options.setFileAndLine("typein", 0);
-         .setPrincipals(GetPrincipal());
   JSScript* script = JS_CompileUCScript(cx, global, aString.get(),
                                         aString.Length(), options);
   if (!script) {

js/src/builtin/Eval.cpp

@@ -287,8 +287,6 @@ EvalKernel(JSContext *cx, const CallArgs &args, EvalType evalType, AbstractFrame
     size_t length = flatStr->length();
     ConstTwoByteChars chars(flatStr->chars(), length);
 
-    JSPrincipals *principals = PrincipalsForCompiledCode(args, cx);
-
     RootedScript callerScript(cx, caller ? caller.script() : nullptr);
     EvalJSONResult ejr = TryEvalJSON(cx, callerScript, chars, length, args.rval());
     if (ejr != EvalJSON_NotJSON)
@@ -320,7 +318,6 @@ EvalKernel(JSContext *cx, const CallArgs &args, EvalType evalType, AbstractFrame
                .setCompileAndGo(true)
                .setForEval(true)
                .setNoScriptRval(false)
-               .setPrincipals(principals)
                .setOriginPrincipals(originPrincipals)
                .setIntroductionInfo(introducerFilename, "eval", lineno, maybeScript, pcOffset);
         JSScript *compiled = frontend::CompileScript(cx, &cx->tempLifoAlloc(),
@@ -369,9 +366,6 @@ js::DirectEvalStringFromIon(JSContext *cx,
 
     EvalScriptGuard esg(cx);
 
-    // Ion will not perform cross compartment direct eval calls.
-    JSPrincipals *principals = cx->compartment()->principals;
-
     esg.lookupInEvalCache(flatStr, callerScript, pc);
 
     if (!esg.foundScript()) {
@@ -392,7 +386,6 @@ js::DirectEvalStringFromIon(JSContext *cx,
                .setCompileAndGo(true)
                .setForEval(true)
                .setNoScriptRval(false)
-               .setPrincipals(principals)
                .setOriginPrincipals(originPrincipals)
                .setIntroductionInfo(introducerFilename, "eval", lineno, maybeScript, pcOffset);
         JSScript *compiled = frontend::CompileScript(cx, &cx->tempLifoAlloc(),
@@ -460,27 +453,3 @@ js::IsAnyBuiltinEval(JSFunction *fun)
 {
     return fun->maybeNative() == IndirectEval;
 }
-
-JSPrincipals *
-js::PrincipalsForCompiledCode(const CallReceiver &call, JSContext *cx)
-{
-    JSObject &callee = call.callee();
-    JS_ASSERT(IsAnyBuiltinEval(&callee.as<JSFunction>()) ||
-              callee.as<JSFunction>().isBuiltinFunctionConstructor());
-
-    // To compute the principals of the compiled eval/Function code, we simply
-    // use the callee's principals. To see why the caller's principals are
-    // ignored, consider first that, in the capability-model we assume, the
-    // high-privileged eval/Function should never have escaped to the
-    // low-privileged caller. (For the Mozilla embedding, this is brute-enforced
-    // by explicit filtering by wrappers.) Thus, the caller's privileges should
-    // subsume the callee's.
-    //
-    // In the converse situation, where the callee has lower privileges than the
-    // caller, we might initially guess that the caller would want to retain
-    // their higher privileges in the generated code. However, since the
-    // compiled code will be run with the callee's scope chain, this would make
-    // fp->script()->compartment() != fp->compartment().
-
-    return callee.compartment()->principals;
-}

js/src/builtin/Eval.h

@@ -42,10 +42,5 @@ DirectEvalValueFromIon(JSContext *cx,
 extern bool
 IsAnyBuiltinEval(JSFunction *fun);
 
-// Return the principals to assign to code compiled for a call to
-// eval or the Function constructor.
-extern JSPrincipals *
-PrincipalsForCompiledCode(const CallReceiver &call, JSContext *cx);
-
 }  // namespace js
 #endif /* builtin_Eval_h */

js/src/frontend/BytecodeCompiler.cpp

@@ -431,8 +431,7 @@ frontend::CompileLazyFunction(JSContext *cx, Handle<LazyScript*> lazy, const jsc
     JS_ASSERT(cx->compartment() == lazy->functionNonDelazifying()->compartment());
 
     CompileOptions options(cx, lazy->version());
-    options.setPrincipals(cx->compartment()->principals)
+    options.setOriginPrincipals(lazy->originPrincipals())
-           .setOriginPrincipals(lazy->originPrincipals())
            .setFileAndLine(lazy->source()->filename(), lazy->lineno())
            .setColumn(lazy->column())
            .setCompileAndGo(true)

js/src/frontend/BytecodeEmitter.cpp

@@ -4850,8 +4850,7 @@ EmitFunc(ExclusiveContext *cx, BytecodeEmitter *bce, ParseNode *pn)
             // Inherit most things (principals, version, etc) from the parent.
             Rooted<JSScript*> parent(cx, bce->script);
             CompileOptions options(cx, bce->parser->options());
-            options.setPrincipals(parent->principals())
+            options.setOriginPrincipals(parent->originPrincipals())
-                   .setOriginPrincipals(parent->originPrincipals())
                    .setCompileAndGo(parent->compileAndGo())
                    .setSelfHostingMode(parent->selfHosted())
                    .setNoScriptRval(false)

js/src/frontend/TokenStream.cpp

@@ -277,14 +277,12 @@ TokenStream::TokenStream(ExclusiveContext *cx, const ReadOnlyCompileOptions &opt
     sourceMapURL_(nullptr),
     tokenbuf(cx),
     cx(cx),
-    originPrincipals(options.originPrincipals()),
+    originPrincipals(options.originPrincipals(cx)),
     strictModeGetter(smg),
     tokenSkip(cx, &tokens),
     linebaseSkip(cx, &linebase),
     prevLinebaseSkip(cx, &prevLinebase)
 {
-    JS_ASSERT_IF(options.principals(), options.originPrincipals());
-
     // The caller must ensure that a reference is held on the supplied principals
     // throughout compilation.
     JS_ASSERT_IF(originPrincipals, originPrincipals->refcount > 0);

js/src/jit/AsmJSLink.cpp

@@ -455,8 +455,7 @@ HandleDynamicLinkFailure(JSContext *cx, CallArgs args, AsmJSModule &module, Hand
         formals.infallibleAppend(module.bufferArgumentName());
 
     CompileOptions options(cx);
-    options.setPrincipals(cx->compartment()->principals)
+    options.setOriginPrincipals(module.scriptSource()->originPrincipals())
-           .setOriginPrincipals(module.scriptSource()->originPrincipals())
            .setCompileAndGo(false)
            .setNoScriptRval(false);
 

js/src/jsapi-tests/testChromeBuffer.cpp

@@ -65,8 +65,7 @@ BEGIN_TEST(testChromeBuffer)
             const char *bytes = "return x ? 1 + trusted(x-1) : 0";
             JS::HandleObject global = JS::HandleObject::fromMarkedLocation(&trusted_glob);
             JS::CompileOptions options(cx);
-            options.setFileAndLine("", 0)
+            options.setFileAndLine("", 0);
-                   .setPrincipals(&system_principals);
             CHECK(fun = JS_CompileFunction(cx, global, "trusted", 1, &paramName,
                                            bytes, strlen(bytes), options));
             trusted_fun = JS_GetFunctionObject(fun);
@@ -112,8 +111,7 @@ BEGIN_TEST(testChromeBuffer)
                                 "}                                      ";
             JS::HandleObject global = JS::HandleObject::fromMarkedLocation(&trusted_glob);
             JS::CompileOptions options(cx);
-            options.setFileAndLine("", 0)
+            options.setFileAndLine("", 0);
-                   .setPrincipals(&system_principals);
             CHECK(fun = JS_CompileFunction(cx, global, "trusted", 1, &paramName,
                                            bytes, strlen(bytes), options));
             trusted_fun = JS_GetFunctionObject(fun);
@@ -150,8 +148,7 @@ BEGIN_TEST(testChromeBuffer)
             const char *bytes = "return 42";
             JS::HandleObject global = JS::HandleObject::fromMarkedLocation(&trusted_glob);
             JS::CompileOptions options(cx);
-            options.setFileAndLine("", 0)
+            options.setFileAndLine("", 0);
-                   .setPrincipals(&system_principals);
             CHECK(fun = JS_CompileFunction(cx, global, "trusted", 0, nullptr,
                                            bytes, strlen(bytes), options));
             trusted_fun = JS_GetFunctionObject(fun);

js/src/jsapi-tests/testCloneScript.cpp

@@ -107,8 +107,7 @@ BEGIN_TEST(test_cloneScriptWithPrincipals)
     {
         JSAutoCompartment a(cx, A);
         JS::CompileOptions options(cx);
-        options.setFileAndLine(__FILE__, 1)
+        options.setFileAndLine(__FILE__, 1);
-               .setPrincipals(principalsA);
         JS::RootedFunction fun(cx, JS_CompileFunction(cx, A, "f",
                 mozilla::ArrayLength(argnames), argnames, source,
                 strlen(source), options));

js/src/jsapi-tests/testScriptObject.cpp

@@ -58,8 +58,7 @@ END_FIXTURE_TEST(ScriptObjectFixture, bug438633_CompileScript_empty)
 BEGIN_FIXTURE_TEST(ScriptObjectFixture, bug438633_CompileScriptForPrincipals)
 {
     JS::CompileOptions options(cx);
-    options.setFileAndLine(__FILE__, __LINE__)
+    options.setFileAndLine(__FILE__, __LINE__);
-           .setPrincipals(nullptr);
     return tryScript(global, JS_CompileScript(cx, global, code, code_size,
                                               options));
 }
@@ -86,8 +85,7 @@ END_FIXTURE_TEST(ScriptObjectFixture, bug438633_JS_CompileUCScript_empty)
 BEGIN_FIXTURE_TEST(ScriptObjectFixture, bug438633_JS_CompileUCScriptForPrincipals)
 {
     JS::CompileOptions options(cx);
-    options.setFileAndLine(__FILE__, __LINE__)
+    options.setFileAndLine(__FILE__, __LINE__);
-           .setPrincipals(nullptr);
     return tryScript(global, JS_CompileUCScript(cx, global, uc_code, code_size,
                                                 options));
 }
@@ -153,8 +151,7 @@ BEGIN_FIXTURE_TEST(ScriptObjectFixture, bug438633_JS_CompileFileHandleForPrincip
     CHECK(fputs(code, script_stream) != EOF);
     CHECK(fseek(script_stream, 0, SEEK_SET) != EOF);
     JS::CompileOptions options(cx);
-    options.setFileAndLine("temporary file", 1)
+    options.setFileAndLine("temporary file", 1);
-           .setPrincipals(nullptr);
     return tryScript(global, JS::Compile(cx, global, options, script_stream));
 }
 END_FIXTURE_TEST(ScriptObjectFixture, bug438633_JS_CompileFileHandleForPrincipals)

js/src/jsapi-tests/testXDR.cpp

@@ -14,7 +14,7 @@
 
 static JSScript *
 CompileScriptForPrincipalsVersionOrigin(JSContext *cx, JS::HandleObject obj,
-                                        JSPrincipals *principals, JSPrincipals *originPrincipals,
+                                        JSPrincipals *originPrincipals,
                                         const char *bytes, size_t nbytes,
                                         const char *filename, unsigned lineno,
                                         JSVersion version)
@@ -27,8 +27,7 @@ CompileScriptForPrincipalsVersionOrigin(JSContext *cx, JS::HandleObject obj,
         return nullptr;
     JS_ALWAYS_TRUE(JS_DecodeBytes(cx, bytes, nbytes, chars, &nchars));
     JS::CompileOptions options(cx);
-    options.setPrincipals(principals)
+    options.setOriginPrincipals(originPrincipals)
-           .setOriginPrincipals(originPrincipals)
            .setFileAndLine(filename, lineno)
            .setVersion(version);
     JSScript *script = JS::Compile(cx, obj, options, chars, nchars);
@@ -87,17 +86,17 @@ BEGIN_TEST(testXDR_principals)
         // Appease the new JSAPI assertions. The stuff being tested here is
         // going away anyway.
         JS_SetCompartmentPrincipals(compartment, &testPrincipal0);
-        script = createScriptViaXDR(&testPrincipal0, nullptr, i);
+        script = createScriptViaXDR(nullptr, i);
         CHECK(script);
         CHECK(JS_GetScriptPrincipals(script) == &testPrincipal0);
         CHECK(JS_GetScriptOriginPrincipals(script) == &testPrincipal0);
 
-        script = createScriptViaXDR(&testPrincipal0, &testPrincipal0, i);
+        script = createScriptViaXDR(&testPrincipal0, i);
         CHECK(script);
         CHECK(JS_GetScriptPrincipals(script) == &testPrincipal0);
         CHECK(JS_GetScriptOriginPrincipals(script) == &testPrincipal0);
 
-        script = createScriptViaXDR(&testPrincipal0, &testPrincipal1, i);
+        script = createScriptViaXDR(&testPrincipal1, i);
         CHECK(script);
         CHECK(JS_GetScriptPrincipals(script) == &testPrincipal0);
         CHECK(JS_GetScriptOriginPrincipals(script) == &testPrincipal1);
@@ -114,14 +113,14 @@ enum TestCase {
     TEST_END
 };
 
-JSScript *createScriptViaXDR(JSPrincipals *prin, JSPrincipals *orig, int testCase)
+JSScript *createScriptViaXDR(JSPrincipals *orig, int testCase)
 {
     const char src[] =
         "function f() { return 1; }\n"
         "f;\n";
 
     JS::RootedObject global(cx, JS::CurrentGlobalOrNull(cx));
-    JS::RootedScript script(cx, CompileScriptForPrincipalsVersionOrigin(cx, global, prin, orig,
+    JS::RootedScript script(cx, CompileScriptForPrincipalsVersionOrigin(cx, global, orig,
                                                                         src, strlen(src), "test", 1,
                                                                         JSVERSION_DEFAULT));
     if (!script)

js/src/jsapi.cpp

@@ -4327,9 +4327,9 @@ JS::ReadOnlyCompileOptions::copyPODOptions(const ReadOnlyCompileOptions &rhs)
 }
 
 JSPrincipals *
-JS::ReadOnlyCompileOptions::originPrincipals() const
+JS::ReadOnlyCompileOptions::originPrincipals(ExclusiveContext *cx) const
 {
-    return NormalizeOriginPrincipals(principals_, originPrincipals_);
+    return NormalizeOriginPrincipals(cx->compartment()->principals, originPrincipals_);
 }
 
 JS::OwningCompileOptions::OwningCompileOptions(JSContext *cx)
@@ -4343,8 +4343,6 @@ JS::OwningCompileOptions::OwningCompileOptions(JSContext *cx)
 
 JS::OwningCompileOptions::~OwningCompileOptions()
 {
-    if (principals_)
-        JS_DropPrincipals(runtime, principals_);
     if (originPrincipals_)
         JS_DropPrincipals(runtime, originPrincipals_);
 
@@ -4359,8 +4357,7 @@ JS::OwningCompileOptions::copy(JSContext *cx, const ReadOnlyCompileOptions &rhs)
 {
     copyPODOptions(rhs);
 
-    setPrincipals(rhs.principals());
+    setOriginPrincipals(rhs.originPrincipals(cx));
-    setOriginPrincipals(rhs.originPrincipals());
     setElement(rhs.element());
     setElementAttributeName(rhs.elementAttributeName());
     setIntroductionScript(rhs.introductionScript());
@@ -4499,7 +4496,6 @@ JS::Compile(JSContext *cx, HandleObject obj, const ReadOnlyCompileOptions &optio
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, obj);
-    JS_ASSERT_IF(options.principals(), cx->compartment()->principals == options.principals());
     AutoLastFrameCheck lfc(cx);
 
     return frontend::CompileScript(cx, &cx->tempLifoAlloc(), obj, NullPtr(), options, chars, length);
@@ -4664,7 +4660,6 @@ JS::CompileFunction(JSContext *cx, HandleObject obj, const ReadOnlyCompileOption
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, obj);
-    JS_ASSERT_IF(options.principals(), cx->compartment()->principals == options.principals());
     AutoLastFrameCheck lfc(cx);
 
     RootedAtom funAtom(cx);
@@ -4824,7 +4819,6 @@ JS::Evaluate(JSContext *cx, HandleObject obj, const ReadOnlyCompileOptions &opti
     AssertHeapIsIdle(cx);
     CHECK_REQUEST(cx);
     assertSameCompartment(cx, obj);
-    JS_ASSERT_IF(options.principals(), cx->compartment()->principals == options.principals());
 
     AutoLastFrameCheck lfc(cx);
 
@@ -4897,9 +4891,10 @@ JS_EvaluateUCScriptForPrincipals(JSContext *cx, HandleObject obj,
                                  const char *filename, unsigned lineno,
                                  MutableHandleValue rval)
 {
+    JS_ASSERT(principals == cx->compartment()->principals);
+
     CompileOptions options(cx);
-    options.setPrincipals(principals)
+    options.setFileAndLine(filename, lineno);
-           .setFileAndLine(filename, lineno);
 
     return Evaluate(cx, obj, options, chars, length, rval.address());
 }
@@ -4911,9 +4906,10 @@ JS_EvaluateUCScriptForPrincipalsVersion(JSContext *cx, HandleObject obj,
                                         const char *filename, unsigned lineno,
                                         MutableHandleValue rval, JSVersion version)
 {
+    JS_ASSERT(principals == cx->compartment()->principals);
+
     CompileOptions options(cx);
-    options.setPrincipals(principals)
+    options.setFileAndLine(filename, lineno)
-           .setFileAndLine(filename, lineno)
            .setVersion(version);
 
     return Evaluate(cx, obj, options, chars, length, rval.address());
@@ -4927,9 +4923,10 @@ JS_EvaluateUCScriptForPrincipalsVersionOrigin(JSContext *cx, HandleObject obj,
                                               const char *filename, unsigned lineno,
                                               MutableHandleValue rval, JSVersion version)
 {
+    JS_ASSERT(principals == cx->compartment()->principals);
+
     CompileOptions options(cx);
-    options.setPrincipals(principals)
+    options.setOriginPrincipals(originPrincipals)
-           .setOriginPrincipals(originPrincipals)
            .setFileAndLine(filename, lineno)
            .setVersion(version);
 
@@ -4952,10 +4949,11 @@ JS_EvaluateScriptForPrincipals(JSContext *cx, JSObject *objArg, JSPrincipals *pr
                                const char *bytes, unsigned nbytes,
                                const char *filename, unsigned lineno, jsval *rval)
 {
+    JS_ASSERT(principals == cx->compartment()->principals);
+
     RootedObject obj(cx, objArg);
     CompileOptions options(cx);
-    options.setPrincipals(principals)
+    options.setFileAndLine(filename, lineno);
-           .setFileAndLine(filename, lineno);
 
     return Evaluate(cx, obj, options, bytes, nbytes, rval);
 }
@@ -4966,10 +4964,11 @@ JS_EvaluateScriptForPrincipalsVersion(JSContext *cx, JSObject *objArg, JSPrincip
                                       const char *filename, unsigned lineno, jsval *rval,
                                       JSVersion version)
 {
+    JS_ASSERT(principals == cx->compartment()->principals);
+
     RootedObject obj(cx, objArg);
     CompileOptions options(cx);
-    options.setPrincipals(principals)
+    options.setVersion(version)
-           .setVersion(version)
            .setFileAndLine(filename, lineno);
 
     return Evaluate(cx, obj, options, bytes, nbytes, rval);

js/src/jsapi.h

@@ -3459,8 +3459,9 @@ namespace JS {
  */
 class JS_FRIEND_API(ReadOnlyCompileOptions)
 {
+    friend class CompileOptions;
+
   protected:
-    JSPrincipals *principals_;
     JSPrincipals *originPrincipals_;
     const char *filename_;
     const char *introducerFilename_;
@@ -3471,8 +3472,7 @@ class JS_FRIEND_API(ReadOnlyCompileOptions)
     // classes' constructors take care of that, in ways appropriate to their
     // purpose.
     ReadOnlyCompileOptions()
-      : principals_(nullptr),
+      : originPrincipals_(nullptr),
-        originPrincipals_(nullptr),
         filename_(nullptr),
         introducerFilename_(nullptr),
         sourceMapURL_(nullptr),
@@ -3506,8 +3506,7 @@ class JS_FRIEND_API(ReadOnlyCompileOptions)
   public:
     // Read-only accessors for non-POD options. The proper way to set these
     // depends on the derived type.
-    JSPrincipals *principals() const { return principals_; }
+    JSPrincipals *originPrincipals(js::ExclusiveContext *cx) const;
-    JSPrincipals *originPrincipals() const;
     const char *filename() const { return filename_; }
     const char *introducerFilename() const { return introducerFilename_; }
     const jschar *sourceMapURL() const { return sourceMapURL_; }
@@ -3609,12 +3608,6 @@ class JS_FRIEND_API(OwningCompileOptions) : public ReadOnlyCompileOptions
         introductionScriptRoot = s;
         return *this;
     }
-    OwningCompileOptions &setPrincipals(JSPrincipals *p) {
-        if (p) JS_HoldPrincipals(p);
-        if (principals_) JS_DropPrincipals(runtime, principals_);
-        principals_ = p;
-        return *this;
-    }
     OwningCompileOptions &setOriginPrincipals(JSPrincipals *p) {
         if (p) JS_HoldPrincipals(p);
         if (originPrincipals_) JS_DropPrincipals(runtime, originPrincipals_);
@@ -3649,6 +3642,9 @@ class JS_FRIEND_API(OwningCompileOptions) : public ReadOnlyCompileOptions
     }
 
     virtual bool wrap(JSContext *cx, JSCompartment *compartment) MOZ_OVERRIDE;
+
+  private:
+    void operator=(const CompileOptions &rhs) MOZ_DELETE;
 };
 
 /*
@@ -3672,8 +3668,7 @@ class MOZ_STACK_CLASS JS_FRIEND_API(CompileOptions) : public ReadOnlyCompileOpti
     {
         copyPODOptions(rhs);
 
-        principals_ = rhs.principals();
+        originPrincipals_ = rhs.originPrincipals_;
-        originPrincipals_ = rhs.originPrincipals();
         filename_ = rhs.filename();
         sourceMapURL_ = rhs.sourceMapURL();
         elementRoot = rhs.element();
@@ -3700,10 +3695,6 @@ class MOZ_STACK_CLASS JS_FRIEND_API(CompileOptions) : public ReadOnlyCompileOpti
         introductionScriptRoot = s;
         return *this;
     }
-    CompileOptions &setPrincipals(JSPrincipals *p) {
-        principals_ = p;
-        return *this;
-    }
     CompileOptions &setOriginPrincipals(JSPrincipals *p) {
         originPrincipals_ = p;
         return *this;
@@ -3735,6 +3726,9 @@ class MOZ_STACK_CLASS JS_FRIEND_API(CompileOptions) : public ReadOnlyCompileOpti
     }
 
     virtual bool wrap(JSContext *cx, JSCompartment *compartment) MOZ_OVERRIDE;
+
+  private:
+    void operator=(const CompileOptions &rhs) MOZ_DELETE;
 };
 
 extern JS_PUBLIC_API(JSScript *)

js/src/jsfun.cpp

@@ -1432,8 +1432,6 @@ FunctionConstructor(JSContext *cx, unsigned argc, Value *vp, GeneratorKind gener
     DescribeScriptedCallerForCompilation(cx, &maybeScript, &filename, &lineno, &pcOffset,
                                          &originPrincipals);
 
-    JSPrincipals *principals = PrincipalsForCompiledCode(args, cx);
-
     const char *introductionType = "Function";
     if (generatorKind != NotGenerator)
         introductionType = "GeneratorFunction";
@@ -1443,8 +1441,7 @@ FunctionConstructor(JSContext *cx, unsigned argc, Value *vp, GeneratorKind gener
         introducerFilename = maybeScript->scriptSource()->introducerFilename();
 
     CompileOptions options(cx);
-    options.setPrincipals(principals)
+    options.setOriginPrincipals(originPrincipals)
-           .setOriginPrincipals(originPrincipals)
            .setFileAndLine(filename, 1)
            .setNoScriptRval(false)
            .setCompileAndGo(true)

js/src/jsscript.cpp

@@ -1824,7 +1824,7 @@ ScriptSource::initFromOptions(ExclusiveContext *cx, const ReadOnlyCompileOptions
     JS_ASSERT(!filename_);
     JS_ASSERT(!introducerFilename_);
 
-    originPrincipals_ = options.originPrincipals();
+    originPrincipals_ = options.originPrincipals(cx);
     if (originPrincipals_)
         JS_HoldPrincipals(originPrincipals_);
 
@@ -2907,8 +2907,7 @@ js::CloneScript(JSContext *cx, HandleObject enclosingScope, HandleFunction fun,
     /* Now that all fallible allocation is complete, create the GC thing. */
 
     CompileOptions options(cx);
-    options.setPrincipals(cx->compartment()->principals)
+    options.setOriginPrincipals(src->originPrincipals())
-           .setOriginPrincipals(src->originPrincipals())
            .setCompileAndGo(src->compileAndGo())
            .setSelfHostingMode(src->selfHosted())
            .setNoScriptRval(src->noScriptRval())

js/src/shell/js.cpp

@@ -1181,8 +1181,8 @@ Evaluate(JSContext *cx, unsigned argc, jsval *vp)
             }
 
             if (loadBytecode) {
-                script = JS_DecodeScript(cx, loadBuffer, loadLength, options.principals(),
+                script = JS_DecodeScript(cx, loadBuffer, loadLength, cx->compartment()->principals,
-                                         options.originPrincipals());
+                                         options.originPrincipals(cx));
             } else {
                 script = JS::Compile(cx, global, options, codeChars, codeLength);
             }

js/src/vm/Debugger.cpp

@@ -4468,8 +4468,7 @@ js::EvaluateInEnv(JSContext *cx, Handle<Env*> env, HandleValue thisv, AbstractFr
      * static level will suffice.
      */
     CompileOptions options(cx);
-    options.setPrincipals(env->compartment()->principals)
+    options.setCompileAndGo(true)
-           .setCompileAndGo(true)
            .setForEval(true)
            .setNoScriptRval(false)
            .setFileAndLine(filename, lineno)

js/xpconnect/loader/mozJSComponentLoader.cpp

@@ -807,8 +807,7 @@ mozJSComponentLoader::ObjectForLocation(nsIFile *aComponentFile,
             ContextOptionsRef(cx).setDontReportUncaught(true);
 
         CompileOptions options(cx);
-        options.setPrincipals(nsJSPrincipals::get(mSystemPrincipal))
+        options.setNoScriptRval(mReuseLoaderGlobal ? false : true)
-               .setNoScriptRval(mReuseLoaderGlobal ? false : true)
                .setVersion(JSVERSION_LATEST)
                .setFileAndLine(nativePath.get(), 1)
                .setSourcePolicy(mReuseLoaderGlobal ?

js/xpconnect/loader/mozJSSubScriptLoader.cpp

@@ -139,8 +139,7 @@ mozJSSubScriptLoader::ReadScript(nsIURI *uri, JSContext *cx, JSObject *targetObj
     JSErrorReporter er = JS_SetErrorReporter(cx, xpc::SystemErrorReporter);
 
     JS::CompileOptions options(cx);
-    options.setPrincipals(nsJSPrincipals::get(principal))
+    options.setFileAndLine(uriStr, 1);
-           .setFileAndLine(uriStr, 1);
     if (!charset.IsVoid()) {
         nsString script;
         rv = nsScriptLoader::ConvertToUTF16(nullptr, reinterpret_cast<const uint8_t*>(buf.get()), len,

js/xpconnect/src/Sandbox.cpp

@@ -1682,8 +1682,7 @@ xpc::EvalInSandbox(JSContext *cx, HandleObject sandboxArg, const nsAString& sour
         JSAutoCompartment ac(sandcx, sandbox);
 
         JS::CompileOptions options(sandcx);
-        options.setPrincipals(nsJSPrincipals::get(prin))
+        options.setFileAndLine(filenameBuf.get(), lineNo);
-               .setFileAndLine(filenameBuf.get(), lineNo);
         if (jsVersion != JSVERSION_DEFAULT)
                options.setVersion(jsVersion);
         JS::RootedObject rootedSandbox(sandcx, sandbox);

js/xpconnect/src/XPCShellImpl.cpp

@@ -338,8 +338,7 @@ Load(JSContext *cx, unsigned argc, jsval *vp)
         }
         JS::CompileOptions options(cx);
         options.setUTF8(true)
-               .setFileAndLine(filename.ptr(), 1)
+               .setFileAndLine(filename.ptr(), 1);
-               .setPrincipals(gJSPrincipals);
         JS::RootedObject rootedObj(cx, obj);
         JSScript *script = JS::Compile(cx, rootedObj, options, file);
         fclose(file);
@@ -924,8 +923,7 @@ ProcessFile(JSContext *cx, JS::Handle<JSObject*> obj, const char *filename, FILE
 
         JS::CompileOptions options(cx);
         options.setUTF8(true)
-               .setFileAndLine(filename, 1)
+               .setFileAndLine(filename, 1);
-               .setPrincipals(gJSPrincipals);
         script = JS::Compile(cx, obj, options, file);
         if (script && !compileOnly)
             (void)JS_ExecuteScript(cx, obj, script, result.address());
@@ -961,8 +959,7 @@ ProcessFile(JSContext *cx, JS::Handle<JSObject*> obj, const char *filename, FILE
         /* Clear any pending exception from previous failed compiles.  */
         JS_ClearPendingException(cx);
         JS::CompileOptions options(cx);
-        options.setFileAndLine("typein", startline)
+        options.setFileAndLine("typein", startline);
-               .setPrincipals(gJSPrincipals);
         script = JS_CompileScript(cx, obj, buffer, strlen(buffer), options);
         if (script) {
             JSErrorReporter older;