Make 'any'-typed attributes of events available in isolated worlds

Source/bindings/v8/custom/V8PopStateEventCustom.cpp

 /*
  * Copyright (C) 2010 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:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
  *     * Redistributions in binary form must reproduce the above
@@ skipping 40 matching lines @@
     v8::Handle<v8::Value> result = info.Holder()->GetHiddenValue(V8HiddenPropertyName::state());
 
     if (!result.IsEmpty()) {
         v8SetReturnValue(info, result);
         return;
     }
 
     PopStateEvent* event = V8PopStateEvent::toNative(info.Holder());
     History* history = event->history();
     if (!history || !event->serializedState()) {
-        v8SetReturnValue(info, cacheState(info.Holder(), v8::Null(info.GetIsolate())));
+        if (!event->serializedState()) {
+            // If we're in an isolated world and the event was created in the main world,
+            // we need to find the 'state' property on the main world wrapper and clone it.
+            v8::Local<v8::Value> mainWorldState = getHiddenValueFromMainWorldWrapper(info.GetIsolate(), event, V8HiddenPropertyName::state());
+            if (!mainWorldState.IsEmpty())
+                event->setSerializedState(SerializedScriptValue::createAndSwallowExceptions(mainWorldState, info.GetIsolate()));
+        }
+        if (event->serializedState())
+            result = event->serializedState()->deserialize();
+        else
+            result = v8::Null(info.GetIsolate());
+        v8SetReturnValue(info, cacheState(info.Holder(), result));
         return;

[haraken, 2014/05/01 14:22:27]

This code implements lazy serialization in order to optimize a case where the
main world accesses |state|. However, I don't quite understand how it's
optimized.

For example, imagine the following flow:

(1) the main world sets |state|.
(2) the main world gets |state|.
(3) an isolated world gets |state|.

Currently, the serialization of |state| happens at (2), not (3). Is this
expected? I thought that the lazy serialization is intended to delay the
serialization until any isolated world gets |state| (i.e., (3)).

If my understanding is wrong and the lazy serialization is intended just to
delay the serialization until any world (including the main world) gets |state|
(i.e., (2)), would the optimization be worth doing?

[adamk, 2014/05/02 18:33:35]

I don't think this analysis is correct. Note that in the constructor, we store
the main world state as a HiddenValue on the main world wrapper (see
PopStateEventV8Internal::constructor). And then at the top of this function we
retrieve the HiddenValue. So no serialization is done if we're still in the main
world.

Do you have some reason to believe that setting/getting the hidden value is not
working as described?

[haraken, 2014/05/03 12:35:10]

Makes sense, thanks for the clarification! I was overlooking the code at line 51
- 56.

     }
 
     // There's no cached value from a previous invocation, nor a state value was provided by the
     // event, but there is a history object, so first we need to see if the state object has been
     // deserialized through the history object already.
     // The current history state object might've changed in the meantime, so we need to take care
     // of using the correct one, and always share the same deserialization with history.state.
 
     bool isSameState = history->isSameAsCurrentState(event->serializedState());
 
     if (isSameState) {
         v8::Handle<v8::Object> v8History = toV8Fast(history, info, event).As<v8::Object>();
         if (!history->stateChanged()) {
             result = v8History->GetHiddenValue(V8HiddenPropertyName::state());
             if (!result.IsEmpty()) {
                 v8SetReturnValue(info, cacheState(info.Holder(), result));
                 return;
             }
         }
         result = event->serializedState()->deserialize(info.GetIsolate());
         v8History->SetHiddenValue(V8HiddenPropertyName::state(), result);
-    } else
+    } else {
         result = event->serializedState()->deserialize(info.GetIsolate());
+    }
 
     v8SetReturnValue(info, cacheState(info.Holder(), result));
 }
 
 } // namespace WebCore