Oilpan: move core/workers to oilpan's heap.

Source/bindings/v8/WorkerScriptController.cpp

 /*
  * Copyright (C) 2009, 2012 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 143 matching lines @@
         contextType = &V8ServiceWorkerGlobalScope::wrapperTypeInfo;
     else if (!m_workerGlobalScope.isDedicatedWorkerGlobalScope())
         contextType = &V8SharedWorkerGlobalScope::wrapperTypeInfo;
     v8::Handle<v8::Function> workerGlobalScopeConstructor = m_perContextData->constructorForType(contextType);
     v8::Local<v8::Object> jsWorkerGlobalScope = V8ObjectConstructor::newInstance(workerGlobalScopeConstructor);
     if (jsWorkerGlobalScope.IsEmpty()) {
         disposeContext();
         return false;
     }
 
-    V8DOMWrapper::associateObjectWithWrapper<V8WorkerGlobalScope>(PassRefPtr<WorkerGlobalScope>(m_workerGlobalScope), contextType, jsWorkerGlobalScope, isolate(), WrapperConfiguration::Dependent);
+    V8DOMWrapper::associateObjectWithWrapper<V8WorkerGlobalScope>(PassRefPtrWillBeRawPtr<WorkerGlobalScope>(&m_workerGlobalScope), contextType, jsWorkerGlobalScope, isolate(), WrapperConfiguration::Dependent);

[Mads Ager (chromium), 2014/02/24 13:27:53]

It seems like a lot of stuff has moved to references instead of pointers in the
code base. If PassRefPtr has a constructor from "const U&" we probably should
have that for RawPtr as well so we don't have to explicitly write the & here.

The lifetime is a little bit nasty here. When there is a reference to an object
somewhere (like the reference to a WorkerGlobalScope from
WorkerScriptController) there is the assumption that it is kept alive by
something else. I would be more comfortable if we always traced these pointers
to guarantee that there are no use-after-free bugs hiding. However, that would
get us back where it is not clear whether or not something can be NULL. Another
option would be to teach our visitor more about references and always trace
references if the are referencing something that is garbage collected.
Currently, if you trace a reference that does not mark the object itself, it
only calls the trace method.

This is fine for now, but we need to consider how to best handle these
references.

 
     // Insert the object instance as the prototype of the shadow object.
     v8::Handle<v8::Object> globalObject = v8::Handle<v8::Object>::Cast(m_contextHolder->context()->Global()->GetPrototype());
     globalObject->SetPrototype(jsWorkerGlobalScope);
 
     return true;
 }
 
 ScriptValue WorkerScriptController::evaluate(const String& script, const String& fileName, const TextPosition& scriptStartPosition, WorkerGlobalScopeExecutionState* state)
 {
@@ skipping 112 matching lines @@
     v8::Handle<v8::Object> global = context->Global();
     global = global->FindInstanceInPrototypeChain(V8WorkerGlobalScope::domTemplate(isolate, WorkerWorld));
     // Return 0 if the current executing context is not the worker context.
     if (global.IsEmpty())
         return 0;
     WorkerGlobalScope* workerGlobalScope = V8WorkerGlobalScope::toNative(global);
     return workerGlobalScope->script();
 }
 
 } // namespace WebCore