Revert of Limit the usage of SharedPersistent to ScriptValue only

Source/bindings/v8/ScriptController.cpp

 /*
  * Copyright (C) 2008, 2009 Google Inc. All rights reserved.
  * Copyright (C) 2009 Apple 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.
@@ skipping 327 matching lines @@
 void ScriptController::disableEval(const String& errorMessage)
 {
     if (!m_windowShell->isContextInitialized())
         return;
     v8::HandleScope handleScope(m_isolate);
     v8::Local<v8::Context> v8Context = m_windowShell->context();
     v8Context->AllowCodeGenerationFromStrings(false);
     v8Context->SetErrorMessageForCodeGenerationFromStrings(v8String(m_isolate, errorMessage));
 }
 
-ScriptValue ScriptController::createPluginWrapper(Widget* widget)
+PassRefPtr<SharedPersistent<v8::Object> > ScriptController::createPluginWrapper(Widget* widget)
 {
     ASSERT(widget);
 
     if (!widget->isPluginView())
-        return ScriptValue();
+        return 0;
 
     NPObject* npObject = toPluginView(widget)->scriptableObject();
     if (!npObject)
-        return ScriptValue();
+        return 0;
 
     // Frame 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 Frame 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::Handle<v8::Object> wrapper = createV8ObjectForNPObject(npObject, 0, m_isolate);
+    v8::Local<v8::Object> wrapper = createV8ObjectForNPObject(npObject, 0, m_isolate);
 
     // Track the plugin object. We've been given a reference to the object.
     m_pluginObjects.set(widget, npObject);
 
-    return ScriptValue(wrapper, m_isolate);
+    return SharedPersistent<v8::Object>::create(wrapper, 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 284 matching lines @@
         v8Results = evaluateHandleScope.Escape(resultArray);
     }
 
     if (results && !v8Results.IsEmpty()) {
         for (size_t i = 0; i < v8Results->Length(); ++i)
             results->append(ScriptValue(v8Results->Get(i), m_isolate));
     }
 }
 
 } // namespace WebCore