Change all V8 internal private symbols to be private own symbols.

src/messages.js

Index: src/messages.js
diff --git a/src/messages.js b/src/messages.js
index d4375ef626aeabf9f427a46b1ac000f3547ed627..4d64d1e1319a1501dc4ae2357c33131e4036ebda 100644
--- a/src/messages.js
+++ b/src/messages.js
@@ -757,10 +757,10 @@ function GetStackTraceLine(recv, fun, pos, isGlobal) {
 // ----------------------------------------------------------------------------
 // Error implementation
 
-var CallSiteReceiverKey = NEW_PRIVATE("CallSite#receiver");
-var CallSiteFunctionKey = NEW_PRIVATE("CallSite#function");
-var CallSitePositionKey = NEW_PRIVATE("CallSite#position");
-var CallSiteStrictModeKey = NEW_PRIVATE("CallSite#strict_mode");
+var CallSiteReceiverKey = NEW_PRIVATE_OWN("CallSite#receiver");
+var CallSiteFunctionKey = NEW_PRIVATE_OWN("CallSite#function");
+var CallSitePositionKey = NEW_PRIVATE_OWN("CallSite#position");
+var CallSiteStrictModeKey = NEW_PRIVATE_OWN("CallSite#strict_mode");
 
 function CallSite(receiver, fun, pos, strict_mode) {
   SET_PRIVATE(this, CallSiteReceiverKey, receiver);
@@ -1115,16 +1115,21 @@ function GetTypeName(receiver, requireConstructor) {
 
 
 var stack_trace_symbol;  // Set during bootstrapping.
-var formatted_stack_trace_symbol = NEW_PRIVATE("formatted stack trace");
+var formatted_stack_trace_symbol = NEW_PRIVATE_OWN("formatted stack trace");
 
 
 // Format the stack trace if not yet done, and return it.
 // Cache the formatted stack trace on the holder.
 var StackTraceGetter = function() {
-  var formatted_stack_trace = GET_PRIVATE(this, formatted_stack_trace_symbol);
+  var formatted_stack_trace = UNDEFINED;
+  var holder = this;
+  while (holder && IS_UNDEFINED(formatted_stack_trace)) {
+    formatted_stack_trace = GET_PRIVATE(holder, formatted_stack_trace_symbol);
+    holder = %GetPrototype(holder);

[arv (Not doing code reviews), 2014/09/23 18:31:20]

Why are we using own private symbols here? It is clear that we want  non own
here.

[Dmitry Lomov (no reviews), 2014/09/24 06:07:40]

I just wanted to remove all non-own symbols from V8 code (in a built-ins, all
private symbols should be own, so that is is clear that GET_PRIVATE never walks
the proto chain).
I also wanted to kill private non-own in general, but then realized it is useful
for the API. 
Maybe I can continue using non-own here. I have no strong opinion.

+  }
   if (IS_UNDEFINED(formatted_stack_trace)) {
-    var holder = this;
-    while (!HAS_PRIVATE(holder, stack_trace_symbol)) {
+    holder = this;
+    while (!HAS_DEFINED_PRIVATE(holder, stack_trace_symbol)) {
       holder = %GetPrototype(holder);
       if (!holder) return UNDEFINED;
     }