Make it possible to have <object>'s scriptableObject as a v8 object instead of NPObject.

Source/bindings/core/v8/ScriptController.cpp

 /*
  * Copyright (C) 2008, 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Apple Inc. All rights reserved.
+ * Copyright (C) 2014 Opera Software ASA. 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
  * copyright notice, this list of conditions and the following disclaimer
  * in the documentation and/or other materials provided with the
@@ skipping 268 matching lines @@
     v8Context->SetErrorMessageForCodeGenerationFromStrings(v8String(m_isolate, errorMessage));
 }
 
 PassRefPtr<SharedPersistent<v8::Object> > ScriptController::createPluginWrapper(Widget* widget)
 {
     ASSERT(widget);
 
     if (!widget->isPluginView())
         return nullptr;
 
-    NPObject* npObject = toPluginView(widget)->scriptableObject();
-    if (!npObject)
+    v8::HandleScope handleScope(m_isolate);
+    v8::Local<v8::Object> scriptableObject = toPluginView(widget)->scriptableObject(m_isolate);
+
+    if (scriptableObject.IsEmpty())
         return nullptr;
 
     // LocalFrame Memory Management for NPObjects
     // -------------------------------------
     // NPObjects are treated differently than other objects wrapped by JS.
     // NPObjects can be created either by the browser (e.g. the main
     // window object) or by the plugin (the main plugin object
     // for a HTMLEmbedElement). Further, unlike most DOM Objects, the frame
     // is especially careful to ensure NPObjects terminate at frame teardown because
     // if a plugin leaks a reference, it could leak its objects (or the browser's objects).
     //
     // The LocalFrame maintains a list of plugin objects (m_pluginObjects)
     // which it can use to quickly find the wrapped embed object.
     //
     // Inside the NPRuntime, we've added a few methods for registering
     // wrapped NPObjects. The purpose of the registration is because
     // javascript garbage collection is non-deterministic, yet we need to
     // be able to tear down the plugin objects immediately. When an object
     // is registered, javascript can use it. When the object is destroyed,
     // or when the object's "owning" object is destroyed, the object will
     // be un-registered, and the javascript engine must not use it.
     //
     // Inside the javascript engine, the engine can keep a reference to the
     // NPObject as part of its wrapper. However, before accessing the object
     // it must consult the _NPN_Registry.
 
-    v8::Local<v8::Object> wrapper = createV8ObjectForNPObject(npObject, 0, m_isolate);
+    if (isWrappedNPObject(scriptableObject)) {
+        // Track the plugin object. We've been given a reference to the object.
+        m_pluginObjects.set(widget, v8ObjectToNPObject(scriptableObject));
+    }
 
-    // Track the plugin object. We've been given a reference to the object.
-    m_pluginObjects.set(widget, npObject);
-
-    return SharedPersistent<v8::Object>::create(wrapper, m_isolate);
+    return SharedPersistent<v8::Object>::create(scriptableObject, m_isolate);
 }
 
 void ScriptController::cleanupScriptObjectsForPlugin(Widget* nativeHandle)
 {
     PluginObjectMap::iterator it = m_pluginObjects.find(nativeHandle);
     if (it == m_pluginObjects.end())
         return;
     _NPN_UnregisterObject(it->value);
     _NPN_ReleaseObject(it->value);
     m_pluginObjects.remove(it);
@@ skipping 292 matching lines @@
         resultArray->Set(i, evaluationResult);
     }
 
     if (results) {
         for (size_t i = 0; i < resultArray->Length(); ++i)
             results->append(handleScope.Escape(resultArray->Get(i)));
     }
 }
 
 } // namespace blink