Oilpan: Enable oilpan for callback classes

BUG= Review URL: https://codereview.chromium.org/563703002 git-svn-id: svn://svn.chromium.org/blink/trunk@182656 bbb929c8-8fbe-4397-9dbb-9b2b20218538
author: keishi@chromium.org <keishi@chromium.org> 2014-09-25 08:15:52 +0000
committer: keishi@chromium.org <keishi@chromium.org> 2014-09-25 08:15:52 +0000
commit: 95fef1d9ab7ace2ce21e8bfa9bb5db4e708922cd (patch)
tree: 50930f05ccd472213f0e969e62e86b664656a303
parent: 798ff6e74aa1cd77ebf17fa8f3b8b161aafb3cfc (diff)
download: chromium_src-95fef1d9ab7ace2ce21e8bfa9bb5db4e708922cd.zip
chromium_src-95fef1d9ab7ace2ce21e8bfa9bb5db4e708922cd.tar.gz
chromium_src-95fef1d9ab7ace2ce21e8bfa9bb5db4e708922cd.tar.bz2
136 files changed, 484 insertions, 483 deletions
diff --git a/third_party/WebKit/Source/bindings/modules/v8/custom/V8SQLTransactionCustom.cpp b/third_party/WebKit/Source/bindings/modules/v8/custom/V8SQLTransactionCustom.cpp
index c07bcd5..2871bec 100644
--- a/third_party/WebKit/Source/bindings/modules/v8/custom/V8SQLTransactionCustom.cpp
+++ b/third_party/WebKit/Source/bindings/modules/v8/custom/V8SQLTransactionCustom.cpp
@@ -90,27 +90,31 @@ void V8SQLTransaction::executeSqlMethodCustom(const v8::FunctionCallbackInfo<v8:
     }
 
     SQLTransaction* transaction = V8SQLTransaction::toImpl(info.Holder());
-    OwnPtrWillBeRawPtr<SQLStatementCallback> callback = nullptr;
-    if (info.Length() > 2 && !isUndefinedOrNull(info[2])) {
+    SQLStatementCallback* callback;
+    if (!isUndefinedOrNull(info[2])) {
         if (!info[2]->IsFunction()) {
             exceptionState.throwDOMException(TypeMismatchError, "The 'callback' (2nd) argument provided is not a function.");
             exceptionState.throwIfNeeded();
             return;
         }
         callback = V8SQLStatementCallback::create(v8::Handle<v8::Function>::Cast(info[2]), ScriptState::current(info.GetIsolate()));
+    } else {
+        callback = nullptr;
     }
 
-    OwnPtrWillBeRawPtr<SQLStatementErrorCallback> errorCallback = nullptr;
-    if (info.Length() > 3 && !isUndefinedOrNull(info[3])) {
+    SQLStatementErrorCallback* errorCallback;
+    if (!isUndefinedOrNull(info[3])) {
         if (!info[3]->IsFunction()) {
             exceptionState.throwDOMException(TypeMismatchError, "The 'errorCallback' (3rd) argument provided is not a function.");
             exceptionState.throwIfNeeded();
             return;
         }
         errorCallback = V8SQLStatementErrorCallback::create(v8::Handle<v8::Function>::Cast(info[3]), ScriptState::current(info.GetIsolate()));
+    } else {
+        errorCallback = nullptr;
     }
 
-    transaction->executeSQL(statement, sqlValues, callback.release(), errorCallback.release(), exceptionState);
+    transaction->executeSQL(statement, sqlValues, callback, errorCallback, exceptionState);
     exceptionState.throwIfNeeded();
 }
 
diff --git a/third_party/WebKit/Source/bindings/scripts/v8_methods.py b/third_party/WebKit/Source/bindings/scripts/v8_methods.py
index e787919..6fb5346 100644
--- a/third_party/WebKit/Source/bindings/scripts/v8_methods.py
+++ b/third_party/WebKit/Source/bindings/scripts/v8_methods.py
@@ -296,8 +296,7 @@ def cpp_value(interface, method, number_of_arguments):
             return argument.name
         if idl_type.is_dictionary:
             return '*%s' % argument.name
-        if (idl_type.is_callback_interface or
-            idl_type.name in ['NodeFilter', 'NodeFilterOrNull',
+        if (idl_type.name in ['NodeFilter', 'NodeFilterOrNull',
                               'XPathNSResolver', 'XPathNSResolverOrNull']):
             # FIXME: remove this special case
             return '%s.release()' % argument.name
diff --git a/third_party/WebKit/Source/bindings/templates/callback_interface.h b/third_party/WebKit/Source/bindings/templates/callback_interface.h
index bab148a..41b631e 100644
--- a/third_party/WebKit/Source/bindings/templates/callback_interface.h
+++ b/third_party/WebKit/Source/bindings/templates/callback_interface.h
@@ -16,9 +16,9 @@ namespace blink {
 
 class {{v8_class}} FINAL : public {{cpp_class}}, public ActiveDOMCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<{{v8_class}}> create(v8::Handle<v8::Function> callback, ScriptState* scriptState)
+    static {{v8_class}}* create(v8::Handle<v8::Function> callback, ScriptState* scriptState)
     {
-        return adoptPtrWillBeNoop(new {{v8_class}}(callback, scriptState));
+        return new {{v8_class}}(callback, scriptState);
     }
 
     virtual ~{{v8_class}}();
diff --git a/third_party/WebKit/Source/bindings/templates/methods.cpp b/third_party/WebKit/Source/bindings/templates/methods.cpp
index 36b7f56..1d94710 100644
--- a/third_party/WebKit/Source/bindings/templates/methods.cpp
+++ b/third_party/WebKit/Source/bindings/templates/methods.cpp
@@ -84,16 +84,12 @@ static void {{method.name}}{{method.overload_index}}Method{{world_suffix}}(const
 
 {######################################}
 {% macro generate_argument_var_declaration(argument) %}
-{% if argument.is_callback_interface %}
 {# FIXME: remove EventListener special case #}
 {% if argument.idl_type == 'EventListener' %}
 RefPtr<{{argument.idl_type}}> {{argument.name}}
 {%- else %}
-OwnPtrWillBeRawPtr<{{argument.idl_type}}> {{argument.name}} = nullptr;
-{%- endif %}{# argument.idl_type == 'EventListener' #}
-{%- else %}
 {{argument.cpp_type}} {{argument.name}}
-{%- endif %}
+{%- endif %}{# argument.idl_type == 'EventListener' #}
 {% endmacro %}
 
 
@@ -140,7 +136,7 @@ if (info.Length() > {{argument.index}} && {% if argument.is_nullable %}!isUndefi
 {# Callback functions must be functions:
    http://www.w3.org/TR/WebIDL/#es-callback-function #}
 {% if argument.is_optional %}
-if (info.Length() > {{argument.index}} && !isUndefinedOrNull(info[{{argument.index}}])) {
+if (!isUndefinedOrNull(info[{{argument.index}}])) {
     if (!info[{{argument.index}}]->IsFunction()) {
         {{throw_type_error(method,
               '"The callback provided as parameter %s is not a function."' %
@@ -148,6 +144,8 @@ if (info.Length() > {{argument.index}} && !isUndefinedOrNull(info[{{argument.ind
         return;
     }
     {{argument.name}} = V8{{argument.idl_type}}::create(v8::Handle<v8::Function>::Cast(info[{{argument.index}}]), ScriptState::current(info.GetIsolate()));
+} else {
+    {{argument.name}} = nullptr;
 }
 {% else %}{# argument.is_optional #}
 if (info.Length() <= {{argument.index}} || !{% if argument.is_nullable %}(info[{{argument.index}}]->IsFunction() || info[{{argument.index}}]->IsNull()){% else %}info[{{argument.index}}]->IsFunction(){% endif %}) {
diff --git a/third_party/WebKit/Source/bindings/tests/results/core/V8TestCallbackInterface.h b/third_party/WebKit/Source/bindings/tests/results/core/V8TestCallbackInterface.h
index 2a76b2b..0756bfc 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/V8TestCallbackInterface.h
+++ b/third_party/WebKit/Source/bindings/tests/results/core/V8TestCallbackInterface.h
@@ -16,9 +16,9 @@ namespace blink {
 
 class V8TestCallbackInterface FINAL : public TestCallbackInterface, public ActiveDOMCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<V8TestCallbackInterface> create(v8::Handle<v8::Function> callback, ScriptState* scriptState)
+    static V8TestCallbackInterface* create(v8::Handle<v8::Function> callback, ScriptState* scriptState)
     {
-        return adoptPtrWillBeNoop(new V8TestCallbackInterface(callback, scriptState));
+        return new V8TestCallbackInterface(callback, scriptState);
     }
 
     virtual ~V8TestCallbackInterface();
diff --git a/third_party/WebKit/Source/bindings/tests/results/core/V8TestObject.cpp b/third_party/WebKit/Source/bindings/tests/results/core/V8TestObject.cpp
index a3237aa..6318689 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/V8TestObject.cpp
+++ b/third_party/WebKit/Source/bindings/tests/results/core/V8TestObject.cpp
@@ -6444,7 +6444,7 @@ static void voidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackI
         return;
     }
     TestObject* impl = V8TestObject::toImpl(info.Holder());
-    OwnPtrWillBeRawPtr<TestCallbackInterface> testCallbackInterfaceArg = nullptr;;
+    TestCallbackInterface* testCallbackInterfaceArg;
     {
         if (info.Length() <= 0 || !info[0]->IsFunction()) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
@@ -6452,7 +6452,7 @@ static void voidMethodTestCallbackInterfaceArgMethod(const v8::FunctionCallbackI
         }
         testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), ScriptState::current(info.GetIsolate()));
     }
-    impl->voidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg.release());
+    impl->voidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg);
 }
 
 static void voidMethodTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ -6465,17 +6465,19 @@ static void voidMethodTestCallbackInterfaceArgMethodCallback(const v8::FunctionC
 static void voidMethodOptionalTestCallbackInterfaceArgMethod(const v8::FunctionCallbackInfo<v8::Value>& info)
 {
     TestObject* impl = V8TestObject::toImpl(info.Holder());
-    OwnPtrWillBeRawPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg = nullptr;;
+    TestCallbackInterface* optionalTestCallbackInterfaceArg;
     {
-        if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
+        if (!isUndefinedOrNull(info[0])) {
             if (!info[0]->IsFunction()) {
                 V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("voidMethodOptionalTestCallbackInterfaceArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
                 return;
             }
             optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), ScriptState::current(info.GetIsolate()));
+        } else {
+            optionalTestCallbackInterfaceArg = nullptr;
         }
     }
-    impl->voidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg.release());
+    impl->voidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg);
 }
 
 static void voidMethodOptionalTestCallbackInterfaceArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ -6492,7 +6494,7 @@ static void voidMethodTestCallbackInterfaceOrNullArgMethod(const v8::FunctionCal
         return;
     }
     TestObject* impl = V8TestObject::toImpl(info.Holder());
-    OwnPtrWillBeRawPtr<TestCallbackInterface> testCallbackInterfaceArg = nullptr;;
+    TestCallbackInterface* testCallbackInterfaceArg;
     {
         if (info.Length() <= 0 || !(info[0]->IsFunction() || info[0]->IsNull())) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceOrNullArg", "TestObject", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
@@ -6500,7 +6502,7 @@ static void voidMethodTestCallbackInterfaceOrNullArgMethod(const v8::FunctionCal
         }
         testCallbackInterfaceArg = info[0]->IsNull() ? nullptr : V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), ScriptState::current(info.GetIsolate()));
     }
-    impl->voidMethodTestCallbackInterfaceOrNullArg(testCallbackInterfaceArg.release());
+    impl->voidMethodTestCallbackInterfaceOrNullArg(testCallbackInterfaceArg);
 }
 
 static void voidMethodTestCallbackInterfaceOrNullArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
@@ -9312,7 +9314,7 @@ static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(const v8::Fu
         return;
     }
     TestObject* impl = V8TestObject::toImpl(info.Holder());
-    OwnPtrWillBeRawPtr<TestCallbackInterface> testCallbackInterfaceArg = nullptr;;
+    TestCallbackInterface* testCallbackInterfaceArg;
     {
         if (info.Length() <= 0 || !info[0]->IsFunction()) {
             exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
@@ -9321,7 +9323,7 @@ static void raisesExceptionVoidMethodTestCallbackInterfaceArgMethod(const v8::Fu
         }
         testCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), ScriptState::current(info.GetIsolate()));
     }
-    impl->raisesExceptionVoidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg.release(), exceptionState);
+    impl->raisesExceptionVoidMethodTestCallbackInterfaceArg(testCallbackInterfaceArg, exceptionState);
     if (exceptionState.hadException()) {
         exceptionState.throwIfNeeded();
         return;
@@ -9339,18 +9341,20 @@ static void raisesExceptionVoidMethodOptionalTestCallbackInterfaceArgMethod(cons
 {
     ExceptionState exceptionState(ExceptionState::ExecutionContext, "raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg", "TestObject", info.Holder(), info.GetIsolate());
     TestObject* impl = V8TestObject::toImpl(info.Holder());
-    OwnPtrWillBeRawPtr<TestCallbackInterface> optionalTestCallbackInterfaceArg = nullptr;;
+    TestCallbackInterface* optionalTestCallbackInterfaceArg;
     {
-        if (info.Length() > 0 && !isUndefinedOrNull(info[0])) {
+        if (!isUndefinedOrNull(info[0])) {
             if (!info[0]->IsFunction()) {
                 exceptionState.throwTypeError("The callback provided as parameter 1 is not a function.");
                 exceptionState.throwIfNeeded();
                 return;
             }
             optionalTestCallbackInterfaceArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), ScriptState::current(info.GetIsolate()));
+        } else {
+            optionalTestCallbackInterfaceArg = nullptr;
         }
     }
-    impl->raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg.release(), exceptionState);
+    impl->raisesExceptionVoidMethodOptionalTestCallbackInterfaceArg(optionalTestCallbackInterfaceArg, exceptionState);
     if (exceptionState.hadException()) {
         exceptionState.throwIfNeeded();
         return;
diff --git a/third_party/WebKit/Source/bindings/tests/results/core/V8TestTypedefs.cpp b/third_party/WebKit/Source/bindings/tests/results/core/V8TestTypedefs.cpp
index 67c113a..f04ee14 100644
--- a/third_party/WebKit/Source/bindings/tests/results/core/V8TestTypedefs.cpp
+++ b/third_party/WebKit/Source/bindings/tests/results/core/V8TestTypedefs.cpp
@@ -140,7 +140,7 @@ static void voidMethodTestCallbackInterfaceTypeArgMethod(const v8::FunctionCallb
         return;
     }
     TestTypedefs* impl = V8TestTypedefs::toImpl(info.Holder());
-    OwnPtrWillBeRawPtr<TestCallbackInterface> testCallbackInterfaceTypeArg = nullptr;;
+    TestCallbackInterface* testCallbackInterfaceTypeArg;
     {
         if (info.Length() <= 0 || !info[0]->IsFunction()) {
             V8ThrowException::throwTypeError(ExceptionMessages::failedToExecute("voidMethodTestCallbackInterfaceTypeArg", "TestTypedefs", "The callback provided as parameter 1 is not a function."), info.GetIsolate());
@@ -148,7 +148,7 @@ static void voidMethodTestCallbackInterfaceTypeArgMethod(const v8::FunctionCallb
         }
         testCallbackInterfaceTypeArg = V8TestCallbackInterface::create(v8::Handle<v8::Function>::Cast(info[0]), ScriptState::current(info.GetIsolate()));
     }
-    impl->voidMethodTestCallbackInterfaceTypeArg(testCallbackInterfaceTypeArg.release());
+    impl->voidMethodTestCallbackInterfaceTypeArg(testCallbackInterfaceTypeArg);
 }
 
 static void voidMethodTestCallbackInterfaceTypeArgMethodCallback(const v8::FunctionCallbackInfo<v8::Value>& info)
diff --git a/third_party/WebKit/Source/core/clipboard/DataTransferItem.cpp b/third_party/WebKit/Source/core/clipboard/DataTransferItem.cpp
index 2ee71f0..ece862f 100644
--- a/third_party/WebKit/Source/core/clipboard/DataTransferItem.cpp
+++ b/third_party/WebKit/Source/core/clipboard/DataTransferItem.cpp
@@ -69,7 +69,7 @@ String DataTransferItem::type() const
     return m_item->type();
 }
 
-void DataTransferItem::getAsString(ExecutionContext* context, PassOwnPtrWillBeRawPtr<StringCallback> callback) const
+void DataTransferItem::getAsString(ExecutionContext* context, StringCallback* callback) const
 {
     if (!m_dataTransfer->canReadData())
         return;
diff --git a/third_party/WebKit/Source/core/clipboard/DataTransferItem.h b/third_party/WebKit/Source/core/clipboard/DataTransferItem.h
index 1f82622..5bbf933 100644
--- a/third_party/WebKit/Source/core/clipboard/DataTransferItem.h
+++ b/third_party/WebKit/Source/core/clipboard/DataTransferItem.h
@@ -55,7 +55,7 @@ public:
     String kind() const;
     String type() const;
 
-    void getAsString(ExecutionContext*, PassOwnPtrWillBeRawPtr<StringCallback>) const;
+    void getAsString(ExecutionContext*, StringCallback*) const;
     PassRefPtrWillBeRawPtr<Blob> getAsFile() const;
 
     DataTransfer* dataTransfer() { return m_dataTransfer.get(); }
diff --git a/third_party/WebKit/Source/core/css/FontFaceSet.cpp b/third_party/WebKit/Source/core/css/FontFaceSet.cpp
index b30a902..af6d135 100644
--- a/third_party/WebKit/Source/core/css/FontFaceSet.cpp
+++ b/third_party/WebKit/Source/core/css/FontFaceSet.cpp
@@ -356,17 +356,17 @@ bool FontFaceSet::isCSSConnectedFontFace(FontFace* fontFace) const
     return cssConnectedFontFaceList().contains(fontFace);
 }
 
-void FontFaceSet::forEach(PassOwnPtrWillBeRawPtr<FontFaceSetForEachCallback> callback, const ScriptValue& thisArg) const
+void FontFaceSet::forEach(FontFaceSetForEachCallback* callback, const ScriptValue& thisArg) const
 {
     forEachInternal(callback, &thisArg);
 }
 
-void FontFaceSet::forEach(PassOwnPtrWillBeRawPtr<FontFaceSetForEachCallback> callback) const
+void FontFaceSet::forEach(FontFaceSetForEachCallback* callback) const
 {
     forEachInternal(callback, 0);
 }
 
-void FontFaceSet::forEachInternal(PassOwnPtrWillBeRawPtr<FontFaceSetForEachCallback> callback, const ScriptValue* thisArg) const
+void FontFaceSet::forEachInternal(FontFaceSetForEachCallback* callback, const ScriptValue* thisArg) const
 {
     if (!inActiveDocumentContext())
         return;
diff --git a/third_party/WebKit/Source/core/css/FontFaceSet.h b/third_party/WebKit/Source/core/css/FontFaceSet.h
index 6a33487..babeb2d 100644
--- a/third_party/WebKit/Source/core/css/FontFaceSet.h
+++ b/third_party/WebKit/Source/core/css/FontFaceSet.h
@@ -81,8 +81,8 @@ public:
     void add(FontFace*, ExceptionState&);
     void clear();
     bool remove(FontFace*, ExceptionState&);
-    void forEach(PassOwnPtrWillBeRawPtr<FontFaceSetForEachCallback>, const ScriptValue& thisArg) const;
-    void forEach(PassOwnPtrWillBeRawPtr<FontFaceSetForEachCallback>) const;
+    void forEach(FontFaceSetForEachCallback*, const ScriptValue& thisArg) const;
+    void forEach(FontFaceSetForEachCallback*) const;
     bool has(FontFace*, ExceptionState&) const;
 
     unsigned long size() const;
@@ -137,7 +137,7 @@ private:
     bool hasLoadedFonts() const { return !m_loadedFonts.isEmpty() || !m_failedFonts.isEmpty(); }
 
     bool inActiveDocumentContext() const;
-    void forEachInternal(PassOwnPtrWillBeRawPtr<FontFaceSetForEachCallback>, const ScriptValue* thisArg) const;
+    void forEachInternal(FontFaceSetForEachCallback*, const ScriptValue* thisArg) const;
     void addToLoadingFonts(PassRefPtrWillBeRawPtr<FontFace>);
     void removeFromLoadingFonts(PassRefPtrWillBeRawPtr<FontFace>);
     void fireLoadingEvent();
diff --git a/third_party/WebKit/Source/core/css/FontFaceSetForEachCallback.h b/third_party/WebKit/Source/core/css/FontFaceSetForEachCallback.h
index fdfe263..588cbe5 100644
--- a/third_party/WebKit/Source/core/css/FontFaceSetForEachCallback.h
+++ b/third_party/WebKit/Source/core/css/FontFaceSetForEachCallback.h
@@ -34,7 +34,7 @@ namespace blink {
 class FontFace;
 class FontFaceSet;
 
-class FontFaceSetForEachCallback : public NoBaseWillBeGarbageCollectedFinalized<FontFaceSetForEachCallback> {
+class FontFaceSetForEachCallback : public GarbageCollectedFinalized<FontFaceSetForEachCallback> {
 public:
     virtual ~FontFaceSetForEachCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/core/dom/Document.cpp b/third_party/WebKit/Source/core/dom/Document.cpp
index d6d984b..be81d14 100644
--- a/third_party/WebKit/Source/core/dom/Document.cpp
+++ b/third_party/WebKit/Source/core/dom/Document.cpp
@@ -5211,7 +5211,7 @@ ScriptedAnimationController& Document::ensureScriptedAnimationController()
     return *m_scriptedAnimationController;
 }
 
-int Document::requestAnimationFrame(PassOwnPtrWillBeRawPtr<RequestAnimationFrameCallback> callback)
+int Document::requestAnimationFrame(RequestAnimationFrameCallback* callback)
 {
     return ensureScriptedAnimationController().registerCallback(callback);
 }
diff --git a/third_party/WebKit/Source/core/dom/Document.h b/third_party/WebKit/Source/core/dom/Document.h
index a0891fe..dc9f9fa 100644
--- a/third_party/WebKit/Source/core/dom/Document.h
+++ b/third_party/WebKit/Source/core/dom/Document.h
@@ -935,7 +935,7 @@ public:
 
     const DocumentTiming& timing() const { return m_documentTiming; }
 
-    int requestAnimationFrame(PassOwnPtrWillBeRawPtr<RequestAnimationFrameCallback>);
+    int requestAnimationFrame(RequestAnimationFrameCallback*);
     void cancelAnimationFrame(int id);
     void serviceScriptedAnimations(double monotonicAnimationStartTime);
 
diff --git a/third_party/WebKit/Source/core/dom/RequestAnimationFrameCallback.h b/third_party/WebKit/Source/core/dom/RequestAnimationFrameCallback.h
index bb773ae..2eee23e 100644
--- a/third_party/WebKit/Source/core/dom/RequestAnimationFrameCallback.h
+++ b/third_party/WebKit/Source/core/dom/RequestAnimationFrameCallback.h
@@ -35,7 +35,7 @@
 
 namespace blink {
 
-class RequestAnimationFrameCallback : public NoBaseWillBeGarbageCollectedFinalized<RequestAnimationFrameCallback> {
+class RequestAnimationFrameCallback : public GarbageCollectedFinalized<RequestAnimationFrameCallback> {
 public:
     virtual ~RequestAnimationFrameCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/core/dom/ScriptedAnimationController.cpp b/third_party/WebKit/Source/core/dom/ScriptedAnimationController.cpp
index 2b7bc91..1b1f7d5 100644
--- a/third_party/WebKit/Source/core/dom/ScriptedAnimationController.cpp
+++ b/third_party/WebKit/Source/core/dom/ScriptedAnimationController.cpp
@@ -81,7 +81,7 @@ void ScriptedAnimationController::resume()
     scheduleAnimationIfNeeded();
 }
 
-ScriptedAnimationController::CallbackId ScriptedAnimationController::registerCallback(PassOwnPtrWillBeRawPtr<RequestAnimationFrameCallback> callback)
+ScriptedAnimationController::CallbackId ScriptedAnimationController::registerCallback(RequestAnimationFrameCallback* callback)
 {
     ScriptedAnimationController::CallbackId id = ++m_nextCallbackId;
     callback->m_cancelled = false;
diff --git a/third_party/WebKit/Source/core/dom/ScriptedAnimationController.h b/third_party/WebKit/Source/core/dom/ScriptedAnimationController.h
index 383636a..524ac0e 100644
--- a/third_party/WebKit/Source/core/dom/ScriptedAnimationController.h
+++ b/third_party/WebKit/Source/core/dom/ScriptedAnimationController.h
@@ -53,7 +53,7 @@ public:
 
     typedef int CallbackId;
 
-    int registerCallback(PassOwnPtrWillBeRawPtr<RequestAnimationFrameCallback>);
+    int registerCallback(RequestAnimationFrameCallback*);
     void cancelCallback(CallbackId);
     void serviceScriptedAnimations(double monotonicTimeNow);
 
@@ -73,7 +73,7 @@ private:
     void executeCallbacks(double monotonicTimeNow);
     void callMediaQueryListListeners();
 
-    typedef WillBeHeapVector<OwnPtrWillBeMember<RequestAnimationFrameCallback> > CallbackList;
+    typedef PersistentHeapVectorWillBeHeapVector<Member<RequestAnimationFrameCallback> > CallbackList;
     CallbackList m_callbacks;
     CallbackList m_callbacksToInvoke; // only non-empty while inside executeCallbacks
 
diff --git a/third_party/WebKit/Source/core/dom/StringCallback.cpp b/third_party/WebKit/Source/core/dom/StringCallback.cpp
index 0718182..7a95cee 100644
--- a/third_party/WebKit/Source/core/dom/StringCallback.cpp
+++ b/third_party/WebKit/Source/core/dom/StringCallback.cpp
@@ -41,7 +41,7 @@ namespace {
 
 class DispatchCallbackTask FINAL : public ExecutionContextTask {
 public:
-    static PassOwnPtr<DispatchCallbackTask> create(PassOwnPtrWillBeRawPtr<StringCallback> callback, const String& data, const String& taskName)
+    static PassOwnPtr<DispatchCallbackTask> create(StringCallback* callback, const String& data, const String& taskName)
     {
         return adoptPtr(new DispatchCallbackTask(callback, data, taskName));
     }
@@ -57,21 +57,21 @@ public:
     }
 
 private:
-    DispatchCallbackTask(PassOwnPtrWillBeRawPtr<StringCallback> callback, const String& data, const String& taskName)
+    DispatchCallbackTask(StringCallback* callback, const String& data, const String& taskName)
         : m_callback(callback)
         , m_data(data)
         , m_taskName(taskName)
     {
     }
 
-    OwnPtrWillBePersistent<StringCallback> m_callback;
+    Persistent<StringCallback> m_callback;
     const String m_data;
     const String m_taskName;
 };
 
 } // namespace
 
-void StringCallback::scheduleCallback(PassOwnPtrWillBeRawPtr<StringCallback> callback, ExecutionContext* context, const String& data, const String& instrumentationName)
+void StringCallback::scheduleCallback(StringCallback* callback, ExecutionContext* context, const String& data, const String& instrumentationName)
 {
     context->postTask(DispatchCallbackTask::create(callback, data, instrumentationName));
 }
diff --git a/third_party/WebKit/Source/core/dom/StringCallback.h b/third_party/WebKit/Source/core/dom/StringCallback.h
index 174ef05..1e0f8e7 100644
--- a/third_party/WebKit/Source/core/dom/StringCallback.h
+++ b/third_party/WebKit/Source/core/dom/StringCallback.h
@@ -38,14 +38,14 @@ namespace blink {
 
 class ExecutionContext;
 
-class StringCallback : public NoBaseWillBeGarbageCollectedFinalized<StringCallback> {
+class StringCallback : public GarbageCollectedFinalized<StringCallback> {
 public:
     virtual ~StringCallback() { }
     virtual void trace(Visitor*) { }
     virtual void handleEvent(const String& data) = 0;
 
     // Helper to post callback task.
-    static void scheduleCallback(PassOwnPtrWillBeRawPtr<StringCallback>, ExecutionContext*, const String& data, const String& instrumentationName);
+    static void scheduleCallback(StringCallback*, ExecutionContext*, const String& data, const String& instrumentationName);
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/core/frame/LocalDOMWindow.cpp b/third_party/WebKit/Source/core/frame/LocalDOMWindow.cpp
index df435a5..db38383 100644
--- a/third_party/WebKit/Source/core/frame/LocalDOMWindow.cpp
+++ b/third_party/WebKit/Source/core/frame/LocalDOMWindow.cpp
@@ -1454,7 +1454,7 @@ void LocalDOMWindow::resizeTo(float width, float height) const
     host->chrome().setWindowRect(adjustWindowRect(*m_frame, update));
 }
 
-int LocalDOMWindow::requestAnimationFrame(PassOwnPtrWillBeRawPtr<RequestAnimationFrameCallback> callback)
+int LocalDOMWindow::requestAnimationFrame(RequestAnimationFrameCallback* callback)
 {
     callback->m_useLegacyTimeBase = false;
     if (Document* d = document())
@@ -1462,7 +1462,7 @@ int LocalDOMWindow::requestAnimationFrame(PassOwnPtrWillBeRawPtr<RequestAnimatio
     return 0;
 }
 
-int LocalDOMWindow::webkitRequestAnimationFrame(PassOwnPtrWillBeRawPtr<RequestAnimationFrameCallback> callback)
+int LocalDOMWindow::webkitRequestAnimationFrame(RequestAnimationFrameCallback* callback)
 {
     callback->m_useLegacyTimeBase = true;
     if (Document* d = document())
diff --git a/third_party/WebKit/Source/core/frame/LocalDOMWindow.h b/third_party/WebKit/Source/core/frame/LocalDOMWindow.h
index 9684cfa..90f4755 100644
--- a/third_party/WebKit/Source/core/frame/LocalDOMWindow.h
+++ b/third_party/WebKit/Source/core/frame/LocalDOMWindow.h
@@ -236,8 +236,8 @@ public:
     void resizeTo(float width, float height) const;
 
     // WebKit animation extensions
-    int requestAnimationFrame(PassOwnPtrWillBeRawPtr<RequestAnimationFrameCallback>);
-    int webkitRequestAnimationFrame(PassOwnPtrWillBeRawPtr<RequestAnimationFrameCallback>);
+    int requestAnimationFrame(RequestAnimationFrameCallback*);
+    int webkitRequestAnimationFrame(RequestAnimationFrameCallback*);
     void cancelAnimationFrame(int id);
 
     DOMWindowCSS& css() const;
diff --git a/third_party/WebKit/Source/core/html/VoidCallback.h b/third_party/WebKit/Source/core/html/VoidCallback.h
index 78f5fd6..5388132 100644
--- a/third_party/WebKit/Source/core/html/VoidCallback.h
+++ b/third_party/WebKit/Source/core/html/VoidCallback.h
@@ -30,7 +30,7 @@
 
 namespace blink {
 
-class VoidCallback : public NoBaseWillBeGarbageCollectedFinalized<VoidCallback> {
+class VoidCallback : public GarbageCollectedFinalized<VoidCallback> {
 public:
     virtual ~VoidCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp b/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
index ce19843..02ccb56 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorCSSAgent.cpp
@@ -461,7 +461,7 @@ void InspectorCSSAgent::enable(ErrorString*, PassRefPtrWillBeRawPtr<EnableCallba
         prpCallback->sendSuccess();
         return;
     }
-    m_pageAgent->resourceContentLoader()->ensureResourcesContentLoaded(adoptPtrWillBeNoop(new InspectorCSSAgent::InspectorResourceContentLoaderCallback(this, prpCallback)));
+    m_pageAgent->resourceContentLoader()->ensureResourcesContentLoaded(new InspectorCSSAgent::InspectorResourceContentLoaderCallback(this, prpCallback));
 }
 
 void InspectorCSSAgent::wasEnabled()
diff --git a/third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp b/third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp
index bb82a89..9439d3f 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorPageAgent.cpp
@@ -752,7 +752,7 @@ void InspectorPageAgent::getResourceContent(ErrorString* errorString, const Stri
         callback->sendFailure("Agent is not enabled.");
         return;
     }
-    m_inspectorResourceContentLoader->ensureResourcesContentLoaded(adoptPtrWillBeNoop(new GetResourceContentLoadListener(this, frameId, url, callback)));
+    m_inspectorResourceContentLoader->ensureResourcesContentLoaded(new GetResourceContentLoadListener(this, frameId, url, callback));
 }
 
 static bool textContentForResource(Resource* cachedResource, String* result)
diff --git a/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.cpp b/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.cpp
index cc8a1f5..ec78c6e 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.cpp
+++ b/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.cpp
@@ -145,7 +145,7 @@ void InspectorResourceContentLoader::start()
     checkDone();
 }
 
-void InspectorResourceContentLoader::ensureResourcesContentLoaded(PassOwnPtrWillBeRawPtr<VoidCallback> callback)
+void InspectorResourceContentLoader::ensureResourcesContentLoaded(VoidCallback* callback)
 {
     if (!m_started)
         start();
@@ -189,9 +189,9 @@ void InspectorResourceContentLoader::checkDone()
 {
     if (!hasFinished())
         return;
-    WillBeHeapVector<OwnPtrWillBeMember<VoidCallback> > callbacks;
+    PersistentHeapVectorWillBeHeapVector<Member<VoidCallback> > callbacks;
     callbacks.swap(m_callbacks);
-    for (WillBeHeapVector<OwnPtrWillBeMember<VoidCallback> >::const_iterator it = callbacks.begin(); it != callbacks.end(); ++it)
+    for (PersistentHeapVectorWillBeHeapVector<Member<VoidCallback> >::const_iterator it = callbacks.begin(); it != callbacks.end(); ++it)
         (*it)->handleEvent();
 }
 
diff --git a/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.h b/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.h
index 573cab5..ccee28b 100644
--- a/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.h
+++ b/third_party/WebKit/Source/core/inspector/InspectorResourceContentLoader.h
@@ -21,7 +21,7 @@ class InspectorResourceContentLoader FINAL : public NoBaseWillBeGarbageCollected
     WTF_MAKE_FAST_ALLOCATED_WILL_BE_REMOVED;
 public:
     explicit InspectorResourceContentLoader(Page*);
-    void ensureResourcesContentLoaded(PassOwnPtrWillBeRawPtr<VoidCallback>);
+    void ensureResourcesContentLoaded(VoidCallback*);
     ~InspectorResourceContentLoader();
     void trace(Visitor*);
     void dispose();
@@ -35,7 +35,7 @@ private:
     void checkDone();
     void start();
 
-    WillBeHeapVector<OwnPtrWillBeMember<VoidCallback> > m_callbacks;
+    PersistentHeapVectorWillBeHeapVector<Member<VoidCallback> > m_callbacks;
     bool m_allRequestsStarted;
     bool m_started;
     RawPtrWillBeMember<Page> m_page;
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMFileSystem.cpp b/third_party/WebKit/Source/modules/filesystem/DOMFileSystem.cpp
index 59f60d7..4b2d151 100644
--- a/third_party/WebKit/Source/modules/filesystem/DOMFileSystem.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/DOMFileSystem.cpp
@@ -113,7 +113,7 @@ bool DOMFileSystem::hasPendingActivity() const
     return m_numberOfPendingCallbacks;
 }
 
-void DOMFileSystem::reportError(PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, PassRefPtrWillBeRawPtr<FileError> fileError)
+void DOMFileSystem::reportError(ErrorCallback* errorCallback, PassRefPtrWillBeRawPtr<FileError> fileError)
 {
     scheduleCallback(errorCallback, fileError);
 }
@@ -122,9 +122,9 @@ namespace {
 
 class ConvertToFileWriterCallback : public FileWriterBaseCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<ConvertToFileWriterCallback> create(PassOwnPtrWillBeRawPtr<FileWriterCallback> callback)
+    static ConvertToFileWriterCallback* create(FileWriterCallback* callback)
     {
-        return adoptPtrWillBeNoop(new ConvertToFileWriterCallback(callback));
+        return new ConvertToFileWriterCallback(callback);
     }
 
     void trace(Visitor* visitor)
@@ -138,16 +138,16 @@ public:
         m_callback->handleEvent(static_cast<FileWriter*>(fileWriterBase));
     }
 private:
-    explicit ConvertToFileWriterCallback(PassOwnPtrWillBeRawPtr<FileWriterCallback> callback)
+    explicit ConvertToFileWriterCallback(FileWriterCallback* callback)
         : m_callback(callback)
     {
     }
-    OwnPtrWillBeMember<FileWriterCallback> m_callback;
+    Member<FileWriterCallback> m_callback;
 };
 
 }
 
-void DOMFileSystem::createWriter(const FileEntry* fileEntry, PassOwnPtrWillBeRawPtr<FileWriterCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void DOMFileSystem::createWriter(const FileEntry* fileEntry, FileWriterCallback* successCallback, ErrorCallback* errorCallback)
 {
     ASSERT(fileEntry);
 
@@ -157,12 +157,12 @@ void DOMFileSystem::createWriter(const FileEntry* fileEntry, PassOwnPtrWillBeRaw
     }
 
     FileWriter* fileWriter = FileWriter::create(executionContext());
-    OwnPtrWillBeRawPtr<FileWriterBaseCallback> conversionCallback = ConvertToFileWriterCallback::create(successCallback);
-    OwnPtr<AsyncFileSystemCallbacks> callbacks = FileWriterBaseCallbacks::create(fileWriter, conversionCallback.release(), errorCallback, m_context);
+    FileWriterBaseCallback* conversionCallback = ConvertToFileWriterCallback::create(successCallback);
+    OwnPtr<AsyncFileSystemCallbacks> callbacks = FileWriterBaseCallbacks::create(fileWriter, conversionCallback, errorCallback, m_context);
     fileSystem()->createFileWriter(createFileSystemURL(fileEntry), fileWriter, callbacks.release());
 }
 
-void DOMFileSystem::createFile(const FileEntry* fileEntry, PassOwnPtrWillBeRawPtr<FileCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void DOMFileSystem::createFile(const FileEntry* fileEntry, FileCallback* successCallback, ErrorCallback* errorCallback)
 {
     KURL fileSystemURL = createFileSystemURL(fileEntry);
     if (!fileSystem()) {
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMFileSystem.h b/third_party/WebKit/Source/modules/filesystem/DOMFileSystem.h
index 3b02eb5..9a52953 100644
--- a/third_party/WebKit/Source/modules/filesystem/DOMFileSystem.h
+++ b/third_party/WebKit/Source/modules/filesystem/DOMFileSystem.h
@@ -60,45 +60,45 @@ public:
     // DOMFileSystemBase overrides.
     virtual void addPendingCallbacks() OVERRIDE;
     virtual void removePendingCallbacks() OVERRIDE;
-    virtual void reportError(PassOwnPtrWillBeRawPtr<ErrorCallback>, PassRefPtrWillBeRawPtr<FileError>) OVERRIDE;
+    virtual void reportError(ErrorCallback*, PassRefPtrWillBeRawPtr<FileError>) OVERRIDE;
 
     // ActiveDOMObject overrides.
     virtual bool hasPendingActivity() const OVERRIDE;
 
-    void createWriter(const FileEntry*, PassOwnPtrWillBeRawPtr<FileWriterCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>);
-    void createFile(const FileEntry*, PassOwnPtrWillBeRawPtr<FileCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>);
+    void createWriter(const FileEntry*, FileWriterCallback*, ErrorCallback*);
+    void createFile(const FileEntry*, FileCallback*, ErrorCallback*);
 
     // Schedule a callback. This should not cross threads (should be called on the same context thread).
     // FIXME: move this to a more generic place.
     template <typename CB, typename CBArg>
-    static void scheduleCallback(ExecutionContext*, PassOwnPtrWillBeRawPtr<CB>, PassRefPtrWillBeRawPtr<CBArg>);
+    static void scheduleCallback(ExecutionContext*, CB*, PassRefPtrWillBeRawPtr<CBArg>);
 
     template <typename CB, typename CBArg>
-    static void scheduleCallback(ExecutionContext*, PassOwnPtrWillBeRawPtr<CB>, CBArg*);
+    static void scheduleCallback(ExecutionContext*, CB*, CBArg*);
 
     template <typename CB, typename CBArg>
-    static void scheduleCallback(ExecutionContext*, PassOwnPtrWillBeRawPtr<CB>, const HeapVector<CBArg>&);
+    static void scheduleCallback(ExecutionContext*, CB*, const HeapVector<CBArg>&);
 
     template <typename CB, typename CBArg>
-    static void scheduleCallback(ExecutionContext*, PassOwnPtrWillBeRawPtr<CB>, const CBArg&);
+    static void scheduleCallback(ExecutionContext*, CB*, const CBArg&);
 
     template <typename CB>
-    static void scheduleCallback(ExecutionContext*, PassOwnPtrWillBeRawPtr<CB>);
+    static void scheduleCallback(ExecutionContext*, CB*);
 
     template <typename CB, typename CBArg>
-    void scheduleCallback(PassOwnPtrWillBeRawPtr<CB> callback, PassRefPtrWillBeRawPtr<CBArg> callbackArg)
+    void scheduleCallback(CB* callback, PassRefPtrWillBeRawPtr<CBArg> callbackArg)
     {
         scheduleCallback(executionContext(), callback, callbackArg);
     }
 
     template <typename CB, typename CBArg>
-    void scheduleCallback(PassOwnPtrWillBeRawPtr<CB> callback, CBArg* callbackArg)
+    void scheduleCallback(CB* callback, CBArg* callbackArg)
     {
         scheduleCallback(executionContext(), callback, callbackArg);
     }
 
     template <typename CB, typename CBArg>
-    void scheduleCallback(PassOwnPtrWillBeRawPtr<CB> callback, const CBArg& callbackArg)
+    void scheduleCallback(CB* callback, const CBArg& callbackArg)
     {
         scheduleCallback(executionContext(), callback, callbackArg);
     }
@@ -126,7 +126,7 @@ private:
     template <typename CB, typename CBArg>
     class DispatchCallbackRefPtrArgTask FINAL : public DispatchCallbackTaskBase {
     public:
-        DispatchCallbackRefPtrArgTask(PassOwnPtrWillBeRawPtr<CB> callback, PassRefPtrWillBeRawPtr<CBArg> arg)
+        DispatchCallbackRefPtrArgTask(CB* callback, PassRefPtrWillBeRawPtr<CBArg> arg)
             : m_callback(callback)
             , m_callbackArg(arg)
         {
@@ -138,14 +138,14 @@ private:
         }
 
     private:
-        OwnPtrWillBePersistent<CB> m_callback;
+        Persistent<CB> m_callback;
         RefPtrWillBePersistent<CBArg> m_callbackArg;
     };
 
     template <typename CB, typename CBArg>
     class DispatchCallbackPtrArgTask FINAL : public DispatchCallbackTaskBase {
     public:
-        DispatchCallbackPtrArgTask(PassOwnPtrWillBeRawPtr<CB> callback, CBArg* arg)
+        DispatchCallbackPtrArgTask(CB* callback, CBArg* arg)
             : m_callback(callback)
             , m_callbackArg(arg)
         {
@@ -157,14 +157,14 @@ private:
         }
 
     private:
-        OwnPtrWillBePersistent<CB> m_callback;
+        Persistent<CB> m_callback;
         Persistent<CBArg> m_callbackArg;
     };
 
     template <typename CB, typename CBArg>
     class DispatchCallbackNonPtrArgTask FINAL : public DispatchCallbackTaskBase {
     public:
-        DispatchCallbackNonPtrArgTask(PassOwnPtrWillBeRawPtr<CB> callback, const CBArg& arg)
+        DispatchCallbackNonPtrArgTask(CB* callback, const CBArg& arg)
             : m_callback(callback)
             , m_callbackArg(arg)
         {
@@ -176,14 +176,14 @@ private:
         }
 
     private:
-        OwnPtrWillBePersistent<CB> m_callback;
+        Persistent<CB> m_callback;
         CBArg m_callbackArg;
     };
 
     template <typename CB>
     class DispatchCallbackNoArgTask FINAL : public DispatchCallbackTaskBase {
     public:
-        DispatchCallbackNoArgTask(PassOwnPtrWillBeRawPtr<CB> callback)
+        DispatchCallbackNoArgTask(CB* callback)
             : m_callback(callback)
         {
         }
@@ -194,14 +194,14 @@ private:
         }
 
     private:
-        OwnPtrWillBePersistent<CB> m_callback;
+        Persistent<CB> m_callback;
     };
 
     int m_numberOfPendingCallbacks;
 };
 
 template <typename CB, typename CBArg>
-void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwnPtrWillBeRawPtr<CB> callback, PassRefPtrWillBeRawPtr<CBArg> arg)
+void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, CB* callback, PassRefPtrWillBeRawPtr<CBArg> arg)
 {
     ASSERT(executionContext->isContextThread());
     if (callback)
@@ -209,7 +209,7 @@ void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwn
 }
 
 template <typename CB, typename CBArg>
-void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwnPtrWillBeRawPtr<CB> callback, CBArg* arg)
+void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, CB* callback, CBArg* arg)
 {
     ASSERT(executionContext->isContextThread());
     if (callback)
@@ -217,7 +217,7 @@ void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwn
 }
 
 template <typename CB, typename CBArg>
-void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwnPtrWillBeRawPtr<CB> callback, const HeapVector<CBArg>& arg)
+void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, CB* callback, const HeapVector<CBArg>& arg)
 {
     ASSERT(executionContext->isContextThread());
     if (callback)
@@ -225,7 +225,7 @@ void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwn
 }
 
 template <typename CB, typename CBArg>
-void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwnPtrWillBeRawPtr<CB> callback, const CBArg& arg)
+void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, CB* callback, const CBArg& arg)
 {
     ASSERT(executionContext->isContextThread());
     if (callback)
@@ -233,7 +233,7 @@ void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwn
 }
 
 template <typename CB>
-void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, PassOwnPtrWillBeRawPtr<CB> callback)
+void DOMFileSystem::scheduleCallback(ExecutionContext* executionContext, CB* callback)
 {
     ASSERT(executionContext->isContextThread());
     if (callback)
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.cpp b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.cpp
index 2456097..77cfe56 100644
--- a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.cpp
@@ -208,7 +208,7 @@ PassRefPtrWillBeRawPtr<File> DOMFileSystemBase::createFile(const FileMetadata& m
     return File::createForFileSystemFile(fileSystemURL, metadata);
 }
 
-void DOMFileSystemBase::getMetadata(const EntryBase* entry, PassOwnPtrWillBeRawPtr<MetadataCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
+void DOMFileSystemBase::getMetadata(const EntryBase* entry, MetadataCallback* successCallback, ErrorCallback* errorCallback, SynchronousType synchronousType)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
@@ -249,7 +249,7 @@ static bool verifyAndGetDestinationPathForCopyOrMove(const EntryBase* source, En
     return true;
 }
 
-void DOMFileSystemBase::move(const EntryBase* source, EntryBase* parent, const String& newName, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
+void DOMFileSystemBase::move(const EntryBase* source, EntryBase* parent, const String& newName, EntryCallback* successCallback, ErrorCallback* errorCallback, SynchronousType synchronousType)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
@@ -268,7 +268,7 @@ void DOMFileSystemBase::move(const EntryBase* source, EntryBase* parent, const S
     fileSystem()->move(createFileSystemURL(source), parent->filesystem()->createFileSystemURL(destinationPath), callbacks.release());
 }
 
-void DOMFileSystemBase::copy(const EntryBase* source, EntryBase* parent, const String& newName, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
+void DOMFileSystemBase::copy(const EntryBase* source, EntryBase* parent, const String& newName, EntryCallback* successCallback, ErrorCallback* errorCallback, SynchronousType synchronousType)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
@@ -287,7 +287,7 @@ void DOMFileSystemBase::copy(const EntryBase* source, EntryBase* parent, const S
     fileSystem()->copy(createFileSystemURL(source), parent->filesystem()->createFileSystemURL(destinationPath), callbacks.release());
 }
 
-void DOMFileSystemBase::remove(const EntryBase* entry, PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
+void DOMFileSystemBase::remove(const EntryBase* entry, VoidCallback* successCallback, ErrorCallback* errorCallback, SynchronousType synchronousType)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
@@ -307,7 +307,7 @@ void DOMFileSystemBase::remove(const EntryBase* entry, PassOwnPtrWillBeRawPtr<Vo
     fileSystem()->remove(createFileSystemURL(entry), callbacks.release());
 }
 
-void DOMFileSystemBase::removeRecursively(const EntryBase* entry, PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
+void DOMFileSystemBase::removeRecursively(const EntryBase* entry, VoidCallback* successCallback, ErrorCallback* errorCallback, SynchronousType synchronousType)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
@@ -327,7 +327,7 @@ void DOMFileSystemBase::removeRecursively(const EntryBase* entry, PassOwnPtrWill
     fileSystem()->removeRecursively(createFileSystemURL(entry), callbacks.release());
 }
 
-void DOMFileSystemBase::getParent(const EntryBase* entry, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void DOMFileSystemBase::getParent(const EntryBase* entry, EntryCallback* successCallback, ErrorCallback* errorCallback)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
@@ -340,7 +340,7 @@ void DOMFileSystemBase::getParent(const EntryBase* entry, PassOwnPtrWillBeRawPtr
     fileSystem()->directoryExists(createFileSystemURL(path), EntryCallbacks::create(successCallback, errorCallback, m_context, this, path, true));
 }
 
-void DOMFileSystemBase::getFile(const EntryBase* entry, const String& path, const FileSystemFlags& flags, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
+void DOMFileSystemBase::getFile(const EntryBase* entry, const String& path, const FileSystemFlags& flags, EntryCallback* successCallback, ErrorCallback* errorCallback, SynchronousType synchronousType)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
@@ -362,7 +362,7 @@ void DOMFileSystemBase::getFile(const EntryBase* entry, const String& path, cons
         fileSystem()->fileExists(createFileSystemURL(absolutePath), callbacks.release());
 }
 
-void DOMFileSystemBase::getDirectory(const EntryBase* entry, const String& path, const FileSystemFlags& flags, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
+void DOMFileSystemBase::getDirectory(const EntryBase* entry, const String& path, const FileSystemFlags& flags, EntryCallback* successCallback, ErrorCallback* errorCallback, SynchronousType synchronousType)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
@@ -384,7 +384,7 @@ void DOMFileSystemBase::getDirectory(const EntryBase* entry, const String& path,
         fileSystem()->directoryExists(createFileSystemURL(absolutePath), callbacks.release());
 }
 
-int DOMFileSystemBase::readDirectory(DirectoryReaderBase* reader, const String& path, PassOwnPtrWillBeRawPtr<EntriesCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, SynchronousType synchronousType)
+int DOMFileSystemBase::readDirectory(DirectoryReaderBase* reader, const String& path, EntriesCallback* successCallback, ErrorCallback* errorCallback, SynchronousType synchronousType)
 {
     if (!fileSystem()) {
         reportError(errorCallback, FileError::create(FileError::ABORT_ERR));
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.h b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.h
index f488837..a8b5d76 100644
--- a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.h
+++ b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemBase.h
@@ -81,7 +81,7 @@ public:
     virtual void removePendingCallbacks() { }
 
     // Overridden by subclasses to handle sync vs async error-handling.
-    virtual void reportError(PassOwnPtrWillBeRawPtr<ErrorCallback>, PassRefPtrWillBeRawPtr<FileError>) = 0;
+    virtual void reportError(ErrorCallback*, PassRefPtrWillBeRawPtr<FileError>) = 0;
 
     const String& name() const { return m_name; }
     FileSystemType type() const { return m_type; }
@@ -106,15 +106,15 @@ public:
     static PassRefPtrWillBeRawPtr<File> createFile(const FileMetadata&, const KURL& fileSystemURL, FileSystemType, const String name);
 
     // Actual FileSystem API implementations. All the validity checks on virtual paths are done at this level.
-    void getMetadata(const EntryBase*, PassOwnPtrWillBeRawPtr<MetadataCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, SynchronousType = Asynchronous);
-    void move(const EntryBase* source, EntryBase* parent, const String& name, PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, SynchronousType = Asynchronous);
-    void copy(const EntryBase* source, EntryBase* parent, const String& name, PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, SynchronousType = Asynchronous);
-    void remove(const EntryBase*, PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, SynchronousType = Asynchronous);
-    void removeRecursively(const EntryBase*, PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, SynchronousType = Asynchronous);
-    void getParent(const EntryBase*, PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>);
-    void getFile(const EntryBase*, const String& path, const FileSystemFlags&, PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, SynchronousType = Asynchronous);
-    void getDirectory(const EntryBase*, const String& path, const FileSystemFlags&, PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, SynchronousType = Asynchronous);
-    int readDirectory(DirectoryReaderBase*, const String& path, PassOwnPtrWillBeRawPtr<EntriesCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, SynchronousType = Asynchronous);
+    void getMetadata(const EntryBase*, MetadataCallback*, ErrorCallback*, SynchronousType = Asynchronous);
+    void move(const EntryBase* source, EntryBase* parent, const String& name, EntryCallback*, ErrorCallback*, SynchronousType = Asynchronous);
+    void copy(const EntryBase* source, EntryBase* parent, const String& name, EntryCallback*, ErrorCallback*, SynchronousType = Asynchronous);
+    void remove(const EntryBase*, VoidCallback*, ErrorCallback*, SynchronousType = Asynchronous);
+    void removeRecursively(const EntryBase*, VoidCallback*, ErrorCallback*, SynchronousType = Asynchronous);
+    void getParent(const EntryBase*, EntryCallback*, ErrorCallback*);
+    void getFile(const EntryBase*, const String& path, const FileSystemFlags&, EntryCallback*, ErrorCallback*, SynchronousType = Asynchronous);
+    void getDirectory(const EntryBase*, const String& path, const FileSystemFlags&, EntryCallback*, ErrorCallback*, SynchronousType = Asynchronous);
+    int readDirectory(DirectoryReaderBase*, const String& path, EntriesCallback*, ErrorCallback*, SynchronousType = Asynchronous);
     bool waitForAdditionalResult(int callbacksId);
 
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.cpp b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.cpp
index 0ec12e7..4eaf97f 100644
--- a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.cpp
@@ -64,7 +64,7 @@ DOMFileSystemSync::~DOMFileSystemSync()
 {
 }
 
-void DOMFileSystemSync::reportError(PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, PassRefPtrWillBeRawPtr<FileError> fileError)
+void DOMFileSystemSync::reportError(ErrorCallback* errorCallback, PassRefPtrWillBeRawPtr<FileError> fileError)
 {
     errorCallback->handleEvent(fileError.get());
 }
@@ -165,9 +165,9 @@ namespace {
 
 class ReceiveFileWriterCallback FINAL : public FileWriterBaseCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<ReceiveFileWriterCallback> create()
+    static ReceiveFileWriterCallback* create()
     {
-        return adoptPtrWillBeNoop(new ReceiveFileWriterCallback());
+        return new ReceiveFileWriterCallback();
     }
 
     virtual void handleEvent(FileWriterBase*) OVERRIDE
@@ -182,9 +182,9 @@ private:
 
 class LocalErrorCallback FINAL : public ErrorCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<LocalErrorCallback> create(FileError::ErrorCode& errorCode)
+    static LocalErrorCallback* create(FileError::ErrorCode& errorCode)
     {
-        return adoptPtrWillBeNoop(new LocalErrorCallback(errorCode));
+        return new LocalErrorCallback(errorCode);
     }
 
     virtual void handleEvent(FileError* error) OVERRIDE
@@ -209,11 +209,11 @@ FileWriterSync* DOMFileSystemSync::createWriter(const FileEntrySync* fileEntry,
     ASSERT(fileEntry);
 
     FileWriterSync* fileWriter = FileWriterSync::create();
-    OwnPtrWillBeRawPtr<ReceiveFileWriterCallback> successCallback = ReceiveFileWriterCallback::create();
+    ReceiveFileWriterCallback* successCallback = ReceiveFileWriterCallback::create();
     FileError::ErrorCode errorCode = FileError::OK;
-    OwnPtrWillBeRawPtr<LocalErrorCallback> errorCallback = LocalErrorCallback::create(errorCode);
+    LocalErrorCallback* errorCallback = LocalErrorCallback::create(errorCode);
 
-    OwnPtr<AsyncFileSystemCallbacks> callbacks = FileWriterBaseCallbacks::create(fileWriter, successCallback.release(), errorCallback.release(), m_context);
+    OwnPtr<AsyncFileSystemCallbacks> callbacks = FileWriterBaseCallbacks::create(fileWriter, successCallback, errorCallback, m_context);
     callbacks->setShouldBlockUntilCompletion(true);
 
     fileSystem()->createFileWriter(createFileSystemURL(fileEntry), fileWriter, callbacks.release());
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.h b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.h
index b2e035e..43e9fca 100644
--- a/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.h
+++ b/third_party/WebKit/Source/modules/filesystem/DOMFileSystemSync.h
@@ -55,7 +55,7 @@ public:
 
     virtual ~DOMFileSystemSync();
 
-    virtual void reportError(PassOwnPtrWillBeRawPtr<ErrorCallback>, PassRefPtrWillBeRawPtr<FileError>) OVERRIDE;
+    virtual void reportError(ErrorCallback*, PassRefPtrWillBeRawPtr<FileError>) OVERRIDE;
 
     DirectoryEntrySync* root();
 
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMWindowFileSystem.cpp b/third_party/WebKit/Source/modules/filesystem/DOMWindowFileSystem.cpp
index f78b085..bc49129 100644
--- a/third_party/WebKit/Source/modules/filesystem/DOMWindowFileSystem.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/DOMWindowFileSystem.cpp
@@ -48,7 +48,7 @@ DOMWindowFileSystem::~DOMWindowFileSystem()
 {
 }
 
-void DOMWindowFileSystem::webkitRequestFileSystem(LocalDOMWindow& window, int type, long long size, PassOwnPtrWillBeRawPtr<FileSystemCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void DOMWindowFileSystem::webkitRequestFileSystem(LocalDOMWindow& window, int type, long long size, FileSystemCallback* successCallback, ErrorCallback* errorCallback)
 {
     if (!window.isCurrentlyDisplayedInFrame())
         return;
@@ -71,7 +71,7 @@ void DOMWindowFileSystem::webkitRequestFileSystem(LocalDOMWindow& window, int ty
     LocalFileSystem::from(*document)->requestFileSystem(document, fileSystemType, size, FileSystemCallbacks::create(successCallback, errorCallback, document, fileSystemType));
 }
 
-void DOMWindowFileSystem::webkitResolveLocalFileSystemURL(LocalDOMWindow& window, const String& url, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void DOMWindowFileSystem::webkitResolveLocalFileSystemURL(LocalDOMWindow& window, const String& url, EntryCallback* successCallback, ErrorCallback* errorCallback)
 {
     if (!window.isCurrentlyDisplayedInFrame())
         return;
diff --git a/third_party/WebKit/Source/modules/filesystem/DOMWindowFileSystem.h b/third_party/WebKit/Source/modules/filesystem/DOMWindowFileSystem.h
index 917e4df..535ae17 100644
--- a/third_party/WebKit/Source/modules/filesystem/DOMWindowFileSystem.h
+++ b/third_party/WebKit/Source/modules/filesystem/DOMWindowFileSystem.h
@@ -38,8 +38,8 @@ class FileSystemCallback;
 
 class DOMWindowFileSystem {
 public:
-    static void webkitRequestFileSystem(LocalDOMWindow&, int type, long long size, PassOwnPtrWillBeRawPtr<FileSystemCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>);
-    static void webkitResolveLocalFileSystemURL(LocalDOMWindow&, const String&, PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>);
+    static void webkitRequestFileSystem(LocalDOMWindow&, int type, long long size, FileSystemCallback*, ErrorCallback*);
+    static void webkitResolveLocalFileSystemURL(LocalDOMWindow&, const String&, EntryCallback*, ErrorCallback*);
 
     // They are placed here and in all capital letters so they can be checked against the constants in the
     // IDL at compile time.
diff --git a/third_party/WebKit/Source/modules/filesystem/DirectoryEntry.cpp b/third_party/WebKit/Source/modules/filesystem/DirectoryEntry.cpp
index 8adec65..d001f50 100644
--- a/third_party/WebKit/Source/modules/filesystem/DirectoryEntry.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/DirectoryEntry.cpp
@@ -49,19 +49,19 @@ DirectoryReader* DirectoryEntry::createReader()
     return DirectoryReader::create(m_fileSystem, m_fullPath);
 }
 
-void DirectoryEntry::getFile(const String& path, const Dictionary& options, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void DirectoryEntry::getFile(const String& path, const Dictionary& options, EntryCallback* successCallback, ErrorCallback* errorCallback)
 {
     FileSystemFlags flags(options);
     m_fileSystem->getFile(this, path, flags, successCallback, errorCallback);
 }
 
-void DirectoryEntry::getDirectory(const String& path, const Dictionary& options, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void DirectoryEntry::getDirectory(const String& path, const Dictionary& options, EntryCallback* successCallback, ErrorCallback* errorCallback)
 {
     FileSystemFlags flags(options);
     m_fileSystem->getDirectory(this, path, flags, successCallback, errorCallback);
 }
 
-void DirectoryEntry::removeRecursively(PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback) const
+void DirectoryEntry::removeRecursively(VoidCallback* successCallback, ErrorCallback* errorCallback) const
 {
     m_fileSystem->removeRecursively(this, successCallback, errorCallback);
 }
diff --git a/third_party/WebKit/Source/modules/filesystem/DirectoryEntry.h b/third_party/WebKit/Source/modules/filesystem/DirectoryEntry.h
index aeeb220..e450704 100644
--- a/third_party/WebKit/Source/modules/filesystem/DirectoryEntry.h
+++ b/third_party/WebKit/Source/modules/filesystem/DirectoryEntry.h
@@ -54,9 +54,9 @@ public:
     virtual bool isDirectory() const OVERRIDE { return true; }
 
     DirectoryReader* createReader();
-    void getFile(const String& path, const Dictionary&, PassOwnPtrWillBeRawPtr<EntryCallback> = nullptr, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr);
-    void getDirectory(const String& path, const Dictionary&, PassOwnPtrWillBeRawPtr<EntryCallback> = nullptr, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr);
-    void removeRecursively(PassOwnPtrWillBeRawPtr<VoidCallback> successCallback = nullptr, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr) const;
+    void getFile(const String& path, const Dictionary&, EntryCallback* = nullptr, ErrorCallback* = nullptr);
+    void getDirectory(const String& path, const Dictionary&, EntryCallback* = nullptr, ErrorCallback* = nullptr);
+    void removeRecursively(VoidCallback* successCallback = nullptr, ErrorCallback* = nullptr) const;
 
     virtual void trace(Visitor*) OVERRIDE;
 
diff --git a/third_party/WebKit/Source/modules/filesystem/DirectoryReader.cpp b/third_party/WebKit/Source/modules/filesystem/DirectoryReader.cpp
index 7aa7325..706c7b9 100644
--- a/third_party/WebKit/Source/modules/filesystem/DirectoryReader.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/DirectoryReader.cpp
@@ -57,8 +57,8 @@ public:
     }
 
 private:
-    // FIXME: This Persistent keeps the reader alive until all of the readDirectory results are received. crbug.com/350285
-    PersistentWillBeMember<DirectoryReader> m_reader;
+    // FIXME: This Member keeps the reader alive until all of the readDirectory results are received. crbug.com/350285
+    Member<DirectoryReader> m_reader;
 };
 
 class DirectoryReader::ErrorCallbackHelper FINAL : public ErrorCallback {
@@ -80,7 +80,7 @@ public:
     }
 
 private:
-    PersistentWillBeMember<DirectoryReader> m_reader;
+    Member<DirectoryReader> m_reader;
 };
 
 DirectoryReader::DirectoryReader(DOMFileSystemBase* fileSystem, const String& fullPath)
@@ -93,11 +93,11 @@ DirectoryReader::~DirectoryReader()
 {
 }
 
-void DirectoryReader::readEntries(PassOwnPtrWillBeRawPtr<EntriesCallback> entriesCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void DirectoryReader::readEntries(EntriesCallback* entriesCallback, ErrorCallback* errorCallback)
 {
     if (!m_isReading) {
         m_isReading = true;
-        filesystem()->readDirectory(this, m_fullPath, adoptPtrWillBeNoop(new EntriesCallbackHelper(this)), adoptPtrWillBeNoop(new ErrorCallbackHelper(this)));
+        filesystem()->readDirectory(this, m_fullPath, new EntriesCallbackHelper(this), new ErrorCallbackHelper(this));
     }
 
     if (m_error) {
@@ -126,7 +126,7 @@ void DirectoryReader::addEntries(const EntryHeapVector& entries)
     m_entries.appendVector(entries);
     m_errorCallback = nullptr;
     if (m_entriesCallback) {
-        OwnPtrWillBeRawPtr<EntriesCallback> entriesCallback = m_entriesCallback.release();
+        EntriesCallback* entriesCallback = m_entriesCallback.release();
         EntryHeapVector entries;
         entries.swap(m_entries);
         entriesCallback->handleEvent(entries);
@@ -138,7 +138,7 @@ void DirectoryReader::onError(FileError* error)
     m_error = error;
     m_entriesCallback = nullptr;
     if (m_errorCallback) {
-        OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = m_errorCallback.release();
+        ErrorCallback* errorCallback = m_errorCallback.release();
         errorCallback->handleEvent(error);
     }
 }
diff --git a/third_party/WebKit/Source/modules/filesystem/DirectoryReader.h b/third_party/WebKit/Source/modules/filesystem/DirectoryReader.h
index cdf5261..6e097e1 100644
--- a/third_party/WebKit/Source/modules/filesystem/DirectoryReader.h
+++ b/third_party/WebKit/Source/modules/filesystem/DirectoryReader.h
@@ -52,7 +52,7 @@ public:
 
     virtual ~DirectoryReader();
 
-    void readEntries(PassOwnPtrWillBeRawPtr<EntriesCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr);
+    void readEntries(EntriesCallback*, ErrorCallback* = nullptr);
 
     DOMFileSystem* filesystem() const { return static_cast<DOMFileSystem*>(m_fileSystem.get()); }
 
@@ -71,8 +71,8 @@ private:
     bool m_isReading;
     EntryHeapVector m_entries;
     RefPtrWillBeMember<FileError> m_error;
-    OwnPtrWillBeMember<EntriesCallback> m_entriesCallback;
-    OwnPtrWillBeMember<ErrorCallback> m_errorCallback;
+    Member<EntriesCallback> m_entriesCallback;
+    Member<ErrorCallback> m_errorCallback;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/modules/filesystem/DirectoryReaderSync.cpp b/third_party/WebKit/Source/modules/filesystem/DirectoryReaderSync.cpp
index 70d683ed..cc8e9fb 100644
--- a/third_party/WebKit/Source/modules/filesystem/DirectoryReaderSync.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/DirectoryReaderSync.cpp
@@ -65,7 +65,7 @@ public:
     }
 
 private:
-    PersistentWillBeMember<DirectoryReaderSync> m_reader;
+    Member<DirectoryReaderSync> m_reader;
 };
 
 class DirectoryReaderSync::ErrorCallbackHelper FINAL : public ErrorCallback {
@@ -87,7 +87,7 @@ public:
     }
 
 private:
-    PersistentWillBeMember<DirectoryReaderSync> m_reader;
+    Member<DirectoryReaderSync> m_reader;
 };
 
 DirectoryReaderSync::DirectoryReaderSync(DOMFileSystemBase* fileSystem, const String& fullPath)
@@ -104,7 +104,7 @@ DirectoryReaderSync::~DirectoryReaderSync()
 EntrySyncHeapVector DirectoryReaderSync::readEntries(ExceptionState& exceptionState)
 {
     if (!m_callbacksId) {
-        m_callbacksId = filesystem()->readDirectory(this, m_fullPath, adoptPtrWillBeNoop(new EntriesCallbackHelper(this)), adoptPtrWillBeNoop(new ErrorCallbackHelper(this)), DOMFileSystemBase::Synchronous);
+        m_callbacksId = filesystem()->readDirectory(this, m_fullPath, new EntriesCallbackHelper(this), new ErrorCallbackHelper(this), DOMFileSystemBase::Synchronous);
     }
 
     if (m_errorCode == FileError::OK && m_hasMoreEntries && m_entries.isEmpty())
diff --git a/third_party/WebKit/Source/modules/filesystem/EntriesCallback.h b/third_party/WebKit/Source/modules/filesystem/EntriesCallback.h
index 8b8f281..4cc2518 100644
--- a/third_party/WebKit/Source/modules/filesystem/EntriesCallback.h
+++ b/third_party/WebKit/Source/modules/filesystem/EntriesCallback.h
@@ -38,7 +38,7 @@ namespace blink {
 class Entry;
 typedef HeapVector<Member<Entry> > EntryHeapVector;
 
-class EntriesCallback : public NoBaseWillBeGarbageCollectedFinalized<EntriesCallback> {
+class EntriesCallback : public GarbageCollectedFinalized<EntriesCallback> {
 public:
     virtual ~EntriesCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/Entry.cpp b/third_party/WebKit/Source/modules/filesystem/Entry.cpp
index e8f2ba9..464f37e 100644
--- a/third_party/WebKit/Source/modules/filesystem/Entry.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/Entry.cpp
@@ -48,27 +48,27 @@ Entry::Entry(DOMFileSystemBase* fileSystem, const String& fullPath)
 {
 }
 
-void Entry::getMetadata(PassOwnPtrWillBeRawPtr<MetadataCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void Entry::getMetadata(MetadataCallback* successCallback, ErrorCallback* errorCallback)
 {
     m_fileSystem->getMetadata(this, successCallback, errorCallback);
 }
 
-void Entry::moveTo(DirectoryEntry* parent, const String& name, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback) const
+void Entry::moveTo(DirectoryEntry* parent, const String& name, EntryCallback* successCallback, ErrorCallback* errorCallback) const
 {
     m_fileSystem->move(this, parent, name, successCallback, errorCallback);
 }
 
-void Entry::copyTo(DirectoryEntry* parent, const String& name, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback) const
+void Entry::copyTo(DirectoryEntry* parent, const String& name, EntryCallback* successCallback, ErrorCallback* errorCallback) const
 {
     m_fileSystem->copy(this, parent, name, successCallback, errorCallback);
 }
 
-void Entry::remove(PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback) const
+void Entry::remove(VoidCallback* successCallback, ErrorCallback* errorCallback) const
 {
     m_fileSystem->remove(this, successCallback, errorCallback);
 }
 
-void Entry::getParent(PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback) const
+void Entry::getParent(EntryCallback* successCallback, ErrorCallback* errorCallback) const
 {
     m_fileSystem->getParent(this, successCallback, errorCallback);
 }
diff --git a/third_party/WebKit/Source/modules/filesystem/Entry.h b/third_party/WebKit/Source/modules/filesystem/Entry.h
index f118efa..4d5305c 100644
--- a/third_party/WebKit/Source/modules/filesystem/Entry.h
+++ b/third_party/WebKit/Source/modules/filesystem/Entry.h
@@ -50,11 +50,11 @@ class Entry : public EntryBase, public ScriptWrappable {
 public:
     DOMFileSystem* filesystem() const { return static_cast<DOMFileSystem*>(m_fileSystem.get()); }
 
-    void getMetadata(PassOwnPtrWillBeRawPtr<MetadataCallback> successCallback = nullptr, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr);
-    void moveTo(DirectoryEntry* parent, const String& name = String(), PassOwnPtrWillBeRawPtr<EntryCallback> successCallback = nullptr, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr) const;
-    void copyTo(DirectoryEntry* parent, const String& name = String(), PassOwnPtrWillBeRawPtr<EntryCallback> successCallback = nullptr, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr) const;
-    void remove(PassOwnPtrWillBeRawPtr<VoidCallback> successCallback = nullptr, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr) const;
-    void getParent(PassOwnPtrWillBeRawPtr<EntryCallback> successCallback = nullptr, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr) const;
+    void getMetadata(MetadataCallback* successCallback = nullptr, ErrorCallback* = nullptr);
+    void moveTo(DirectoryEntry* parent, const String& name = String(), EntryCallback* successCallback = nullptr, ErrorCallback* = nullptr) const;
+    void copyTo(DirectoryEntry* parent, const String& name = String(), EntryCallback* successCallback = nullptr, ErrorCallback* = nullptr) const;
+    void remove(VoidCallback* successCallback = nullptr, ErrorCallback* = nullptr) const;
+    void getParent(EntryCallback* successCallback = nullptr, ErrorCallback* = nullptr) const;
 
     virtual void trace(Visitor*) OVERRIDE;
 
diff --git a/third_party/WebKit/Source/modules/filesystem/EntryCallback.h b/third_party/WebKit/Source/modules/filesystem/EntryCallback.h
index c82512c..091a317 100644
--- a/third_party/WebKit/Source/modules/filesystem/EntryCallback.h
+++ b/third_party/WebKit/Source/modules/filesystem/EntryCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class Entry;
 
-class EntryCallback : public NoBaseWillBeGarbageCollectedFinalized<EntryCallback> {
+class EntryCallback : public GarbageCollectedFinalized<EntryCallback> {
 public:
     virtual ~EntryCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/ErrorCallback.h b/third_party/WebKit/Source/modules/filesystem/ErrorCallback.h
index 4c6eac2..f394d72 100644
--- a/third_party/WebKit/Source/modules/filesystem/ErrorCallback.h
+++ b/third_party/WebKit/Source/modules/filesystem/ErrorCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class FileError;
 
-class ErrorCallback : public NoBaseWillBeGarbageCollectedFinalized<ErrorCallback> {
+class ErrorCallback : public GarbageCollectedFinalized<ErrorCallback> {
 public:
     virtual ~ErrorCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/FileCallback.h b/third_party/WebKit/Source/modules/filesystem/FileCallback.h
index ec1056a..0ccd90a 100644
--- a/third_party/WebKit/Source/modules/filesystem/FileCallback.h
+++ b/third_party/WebKit/Source/modules/filesystem/FileCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class File;
 
-class FileCallback : public NoBaseWillBeGarbageCollectedFinalized<FileCallback> {
+class FileCallback : public GarbageCollectedFinalized<FileCallback> {
 public:
     virtual ~FileCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/FileEntry.cpp b/third_party/WebKit/Source/modules/filesystem/FileEntry.cpp
index 6056e50..909ce24 100644
--- a/third_party/WebKit/Source/modules/filesystem/FileEntry.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/FileEntry.cpp
@@ -44,12 +44,12 @@ FileEntry::FileEntry(DOMFileSystemBase* fileSystem, const String& fullPath)
 {
 }
 
-void FileEntry::createWriter(PassOwnPtrWillBeRawPtr<FileWriterCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void FileEntry::createWriter(FileWriterCallback* successCallback, ErrorCallback* errorCallback)
 {
     filesystem()->createWriter(this, successCallback, errorCallback);
 }
 
-void FileEntry::file(PassOwnPtrWillBeRawPtr<FileCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void FileEntry::file(FileCallback* successCallback, ErrorCallback* errorCallback)
 {
     filesystem()->createFile(this, successCallback, errorCallback);
 }
diff --git a/third_party/WebKit/Source/modules/filesystem/FileEntry.h b/third_party/WebKit/Source/modules/filesystem/FileEntry.h
index 9ba26d7..1186de7 100644
--- a/third_party/WebKit/Source/modules/filesystem/FileEntry.h
+++ b/third_party/WebKit/Source/modules/filesystem/FileEntry.h
@@ -48,8 +48,8 @@ public:
         return new FileEntry(fileSystem, fullPath);
     }
 
-    void createWriter(PassOwnPtrWillBeRawPtr<FileWriterCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr);
-    void file(PassOwnPtrWillBeRawPtr<FileCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback> = nullptr);
+    void createWriter(FileWriterCallback*, ErrorCallback* = nullptr);
+    void file(FileCallback*, ErrorCallback* = nullptr);
 
     virtual bool isFile() const OVERRIDE { return true; }
 
diff --git a/third_party/WebKit/Source/modules/filesystem/FileSystemCallback.h b/third_party/WebKit/Source/modules/filesystem/FileSystemCallback.h
index 8cdb666..236e392 100644
--- a/third_party/WebKit/Source/modules/filesystem/FileSystemCallback.h
+++ b/third_party/WebKit/Source/modules/filesystem/FileSystemCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class DOMFileSystem;
 
-class FileSystemCallback : public NoBaseWillBeGarbageCollectedFinalized<FileSystemCallback> {
+class FileSystemCallback : public GarbageCollectedFinalized<FileSystemCallback> {
 public:
     virtual ~FileSystemCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.cpp b/third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.cpp
index e54bee5..20e0f70 100644
--- a/third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.cpp
@@ -56,7 +56,7 @@
 
 namespace blink {
 
-FileSystemCallbacksBase::FileSystemCallbacksBase(PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, DOMFileSystemBase* fileSystem, ExecutionContext* context)
+FileSystemCallbacksBase::FileSystemCallbacksBase(ErrorCallback* errorCallback, DOMFileSystemBase* fileSystem, ExecutionContext* context)
     : m_errorCallback(errorCallback)
     , m_fileSystem(fileSystem)
     , m_executionContext(context)
@@ -89,19 +89,19 @@ bool FileSystemCallbacksBase::shouldScheduleCallback() const
 
 #if !ENABLE(OILPAN)
 template <typename CB, typename CBArg>
-void FileSystemCallbacksBase::handleEventOrScheduleCallback(PassOwnPtrWillBeRawPtr<CB> callback, RawPtr<CBArg> arg)
+void FileSystemCallbacksBase::handleEventOrScheduleCallback(RawPtr<CB> callback, RawPtr<CBArg> arg)
 {
     handleEventOrScheduleCallback(callback, arg.get());
 }
 #endif
 
 template <typename CB, typename CBArg>
-void FileSystemCallbacksBase::handleEventOrScheduleCallback(PassOwnPtrWillBeRawPtr<CB> callback, CBArg* arg)
+void FileSystemCallbacksBase::handleEventOrScheduleCallback(RawPtr<CB> callback, CBArg* arg)
 {
-    ASSERT(callback.get());
+    ASSERT(callback);
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncOperationCompletedCallbackStarting(m_executionContext.get(), m_asyncOperationId);
     if (shouldScheduleCallback())
-        DOMFileSystem::scheduleCallback(m_executionContext.get(), callback, arg);
+        DOMFileSystem::scheduleCallback(m_executionContext.get(), callback.get(), arg);
     else if (callback)
         callback->handleEvent(arg);
     m_executionContext.clear();
@@ -109,12 +109,12 @@ void FileSystemCallbacksBase::handleEventOrScheduleCallback(PassOwnPtrWillBeRawP
 }
 
 template <typename CB, typename CBArg>
-void FileSystemCallbacksBase::handleEventOrScheduleCallback(PassOwnPtrWillBeRawPtr<CB> callback, PassRefPtrWillBeRawPtr<CBArg> arg)
+void FileSystemCallbacksBase::handleEventOrScheduleCallback(RawPtr<CB> callback, PassRefPtrWillBeRawPtr<CBArg> arg)
 {
-    ASSERT(callback.get());
+    ASSERT(callback);
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncOperationCompletedCallbackStarting(m_executionContext.get(), m_asyncOperationId);
     if (shouldScheduleCallback())
-        DOMFileSystem::scheduleCallback(m_executionContext.get(), callback, arg);
+        DOMFileSystem::scheduleCallback(m_executionContext.get(), callback.get(), arg);
     else if (callback)
         callback->handleEvent(arg.get());
     m_executionContext.clear();
@@ -122,12 +122,12 @@ void FileSystemCallbacksBase::handleEventOrScheduleCallback(PassOwnPtrWillBeRawP
 }
 
 template <typename CB>
-void FileSystemCallbacksBase::handleEventOrScheduleCallback(PassOwnPtrWillBeRawPtr<CB> callback)
+void FileSystemCallbacksBase::handleEventOrScheduleCallback(RawPtr<CB> callback)
 {
-    ASSERT(callback.get());
+    ASSERT(callback);
     InspectorInstrumentationCookie cookie = InspectorInstrumentation::traceAsyncOperationCompletedCallbackStarting(m_executionContext.get(), m_asyncOperationId);
     if (shouldScheduleCallback())
-        DOMFileSystem::scheduleCallback(m_executionContext.get(), callback);
+        DOMFileSystem::scheduleCallback(m_executionContext.get(), callback.get());
     else if (callback)
         callback->handleEvent();
     m_executionContext.clear();
@@ -136,12 +136,12 @@ void FileSystemCallbacksBase::handleEventOrScheduleCallback(PassOwnPtrWillBeRawP
 
 // EntryCallbacks -------------------------------------------------------------
 
-PassOwnPtr<AsyncFileSystemCallbacks> EntryCallbacks::create(PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem, const String& expectedPath, bool isDirectory)
+PassOwnPtr<AsyncFileSystemCallbacks> EntryCallbacks::create(EntryCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem, const String& expectedPath, bool isDirectory)
 {
     return adoptPtr(new EntryCallbacks(successCallback, errorCallback, context, fileSystem, expectedPath, isDirectory));
 }
 
-EntryCallbacks::EntryCallbacks(PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem, const String& expectedPath, bool isDirectory)
+EntryCallbacks::EntryCallbacks(EntryCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem, const String& expectedPath, bool isDirectory)
     : FileSystemCallbacksBase(errorCallback, fileSystem, context)
     , m_successCallback(successCallback)
     , m_expectedPath(expectedPath)
@@ -161,12 +161,12 @@ void EntryCallbacks::didSucceed()
 
 // EntriesCallbacks -----------------------------------------------------------
 
-PassOwnPtr<AsyncFileSystemCallbacks> EntriesCallbacks::create(PassOwnPtrWillBeRawPtr<EntriesCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, DirectoryReaderBase* directoryReader, const String& basePath)
+PassOwnPtr<AsyncFileSystemCallbacks> EntriesCallbacks::create(EntriesCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, DirectoryReaderBase* directoryReader, const String& basePath)
 {
     return adoptPtr(new EntriesCallbacks(successCallback, errorCallback, context, directoryReader, basePath));
 }
 
-EntriesCallbacks::EntriesCallbacks(PassOwnPtrWillBeRawPtr<EntriesCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, DirectoryReaderBase* directoryReader, const String& basePath)
+EntriesCallbacks::EntriesCallbacks(EntriesCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, DirectoryReaderBase* directoryReader, const String& basePath)
     : FileSystemCallbacksBase(errorCallback, directoryReader->filesystem(), context)
     , m_successCallback(successCallback)
     , m_directoryReader(directoryReader)
@@ -199,12 +199,12 @@ void EntriesCallbacks::didReadDirectoryEntries(bool hasMore)
 
 // FileSystemCallbacks --------------------------------------------------------
 
-PassOwnPtr<AsyncFileSystemCallbacks> FileSystemCallbacks::create(PassOwnPtrWillBeRawPtr<FileSystemCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, FileSystemType type)
+PassOwnPtr<AsyncFileSystemCallbacks> FileSystemCallbacks::create(FileSystemCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, FileSystemType type)
 {
     return adoptPtr(new FileSystemCallbacks(successCallback, errorCallback, context, type));
 }
 
-FileSystemCallbacks::FileSystemCallbacks(PassOwnPtrWillBeRawPtr<FileSystemCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, FileSystemType type)
+FileSystemCallbacks::FileSystemCallbacks(FileSystemCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, FileSystemType type)
     : FileSystemCallbacksBase(errorCallback, nullptr, context)
     , m_successCallback(successCallback)
     , m_type(type)
@@ -219,12 +219,12 @@ void FileSystemCallbacks::didOpenFileSystem(const String& name, const KURL& root
 
 // ResolveURICallbacks --------------------------------------------------------
 
-PassOwnPtr<AsyncFileSystemCallbacks> ResolveURICallbacks::create(PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context)
+PassOwnPtr<AsyncFileSystemCallbacks> ResolveURICallbacks::create(EntryCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context)
 {
     return adoptPtr(new ResolveURICallbacks(successCallback, errorCallback, context));
 }
 
-ResolveURICallbacks::ResolveURICallbacks(PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context)
+ResolveURICallbacks::ResolveURICallbacks(EntryCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context)
     : FileSystemCallbacksBase(errorCallback, nullptr, context)
     , m_successCallback(successCallback)
 {
@@ -249,12 +249,12 @@ void ResolveURICallbacks::didResolveURL(const String& name, const KURL& rootURL,
 
 // MetadataCallbacks ----------------------------------------------------------
 
-PassOwnPtr<AsyncFileSystemCallbacks> MetadataCallbacks::create(PassOwnPtrWillBeRawPtr<MetadataCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem)
+PassOwnPtr<AsyncFileSystemCallbacks> MetadataCallbacks::create(MetadataCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem)
 {
     return adoptPtr(new MetadataCallbacks(successCallback, errorCallback, context, fileSystem));
 }
 
-MetadataCallbacks::MetadataCallbacks(PassOwnPtrWillBeRawPtr<MetadataCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem)
+MetadataCallbacks::MetadataCallbacks(MetadataCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem)
     : FileSystemCallbacksBase(errorCallback, fileSystem, context)
     , m_successCallback(successCallback)
 {
@@ -268,12 +268,12 @@ void MetadataCallbacks::didReadMetadata(const FileMetadata& metadata)
 
 // FileWriterBaseCallbacks ----------------------------------------------------
 
-PassOwnPtr<AsyncFileSystemCallbacks> FileWriterBaseCallbacks::create(PassRefPtrWillBeRawPtr<FileWriterBase> fileWriter, PassOwnPtrWillBeRawPtr<FileWriterBaseCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context)
+PassOwnPtr<AsyncFileSystemCallbacks> FileWriterBaseCallbacks::create(PassRefPtrWillBeRawPtr<FileWriterBase> fileWriter, FileWriterBaseCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context)
 {
     return adoptPtr(new FileWriterBaseCallbacks(fileWriter, successCallback, errorCallback, context));
 }
 
-FileWriterBaseCallbacks::FileWriterBaseCallbacks(PassRefPtrWillBeRawPtr<FileWriterBase> fileWriter, PassOwnPtrWillBeRawPtr<FileWriterBaseCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context)
+FileWriterBaseCallbacks::FileWriterBaseCallbacks(PassRefPtrWillBeRawPtr<FileWriterBase> fileWriter, FileWriterBaseCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context)
     : FileSystemCallbacksBase(errorCallback, nullptr, context)
     , m_fileWriter(fileWriter.get())
     , m_successCallback(successCallback)
@@ -289,12 +289,12 @@ void FileWriterBaseCallbacks::didCreateFileWriter(PassOwnPtr<WebFileWriter> file
 
 // SnapshotFileCallback -------------------------------------------------------
 
-PassOwnPtr<AsyncFileSystemCallbacks> SnapshotFileCallback::create(DOMFileSystemBase* filesystem, const String& name, const KURL& url, PassOwnPtrWillBeRawPtr<FileCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context)
+PassOwnPtr<AsyncFileSystemCallbacks> SnapshotFileCallback::create(DOMFileSystemBase* filesystem, const String& name, const KURL& url, FileCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context)
 {
     return adoptPtr(new SnapshotFileCallback(filesystem, name, url, successCallback, errorCallback, context));
 }
 
-SnapshotFileCallback::SnapshotFileCallback(DOMFileSystemBase* filesystem, const String& name, const KURL& url, PassOwnPtrWillBeRawPtr<FileCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context)
+SnapshotFileCallback::SnapshotFileCallback(DOMFileSystemBase* filesystem, const String& name, const KURL& url, FileCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context)
     : FileSystemCallbacksBase(errorCallback, filesystem, context)
     , m_name(name)
     , m_url(url)
@@ -317,12 +317,12 @@ void SnapshotFileCallback::didCreateSnapshotFile(const FileMetadata& metadata, P
 
 // VoidCallbacks --------------------------------------------------------------
 
-PassOwnPtr<AsyncFileSystemCallbacks> VoidCallbacks::create(PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem)
+PassOwnPtr<AsyncFileSystemCallbacks> VoidCallbacks::create(VoidCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem)
 {
     return adoptPtr(new VoidCallbacks(successCallback, errorCallback, context, fileSystem));
 }
 
-VoidCallbacks::VoidCallbacks(PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem)
+VoidCallbacks::VoidCallbacks(VoidCallback* successCallback, ErrorCallback* errorCallback, ExecutionContext* context, DOMFileSystemBase* fileSystem)
     : FileSystemCallbacksBase(errorCallback, fileSystem, context)
     , m_successCallback(successCallback)
 {
diff --git a/third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.h b/third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.h
index b76c614..80de6a6 100644
--- a/third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.h
+++ b/third_party/WebKit/Source/modules/filesystem/FileSystemCallbacks.h
@@ -63,25 +63,25 @@ public:
     // Other callback methods are implemented by each subclass.
 
 protected:
-    FileSystemCallbacksBase(PassOwnPtrWillBeRawPtr<ErrorCallback>, DOMFileSystemBase*, ExecutionContext*);
+    FileSystemCallbacksBase(ErrorCallback*, DOMFileSystemBase*, ExecutionContext*);
 
     bool shouldScheduleCallback() const;
 
 #if !ENABLE(OILPAN)
     template <typename CB, typename CBArg>
-    void handleEventOrScheduleCallback(PassOwnPtr<CB>, RawPtr<CBArg>);
+    void handleEventOrScheduleCallback(RawPtr<CB>, RawPtr<CBArg>);
 #endif
 
     template <typename CB, typename CBArg>
-    void handleEventOrScheduleCallback(PassOwnPtrWillBeRawPtr<CB>, CBArg*);
+    void handleEventOrScheduleCallback(RawPtr<CB>, CBArg*);
 
     template <typename CB, typename CBArg>
-    void handleEventOrScheduleCallback(PassOwnPtrWillBeRawPtr<CB>, PassRefPtrWillBeRawPtr<CBArg>);
+    void handleEventOrScheduleCallback(RawPtr<CB>, PassRefPtrWillBeRawPtr<CBArg>);
 
     template <typename CB>
-    void handleEventOrScheduleCallback(PassOwnPtrWillBeRawPtr<CB>);
+    void handleEventOrScheduleCallback(RawPtr<CB>);
 
-    OwnPtrWillBePersistent<ErrorCallback> m_errorCallback;
+    Persistent<ErrorCallback> m_errorCallback;
     Persistent<DOMFileSystemBase> m_fileSystem;
     RefPtrWillBePersistent<ExecutionContext> m_executionContext;
     int m_asyncOperationId;
@@ -91,25 +91,25 @@ protected:
 
 class EntryCallbacks FINAL : public FileSystemCallbacksBase {
 public:
-    static PassOwnPtr<AsyncFileSystemCallbacks> create(PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, DOMFileSystemBase*, const String& expectedPath, bool isDirectory);
+    static PassOwnPtr<AsyncFileSystemCallbacks> create(EntryCallback*, ErrorCallback*, ExecutionContext*, DOMFileSystemBase*, const String& expectedPath, bool isDirectory);
     virtual void didSucceed() OVERRIDE;
 
 private:
-    EntryCallbacks(PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, DOMFileSystemBase*, const String& expectedPath, bool isDirectory);
-    OwnPtrWillBePersistent<EntryCallback> m_successCallback;
+    EntryCallbacks(EntryCallback*, ErrorCallback*, ExecutionContext*, DOMFileSystemBase*, const String& expectedPath, bool isDirectory);
+    Persistent<EntryCallback> m_successCallback;
     String m_expectedPath;
     bool m_isDirectory;
 };
 
 class EntriesCallbacks FINAL : public FileSystemCallbacksBase {
 public:
-    static PassOwnPtr<AsyncFileSystemCallbacks> create(PassOwnPtrWillBeRawPtr<EntriesCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, DirectoryReaderBase*, const String& basePath);
+    static PassOwnPtr<AsyncFileSystemCallbacks> create(EntriesCallback*, ErrorCallback*, ExecutionContext*, DirectoryReaderBase*, const String& basePath);
     virtual void didReadDirectoryEntry(const String& name, bool isDirectory) OVERRIDE;
     virtual void didReadDirectoryEntries(bool hasMore) OVERRIDE;
 
 private:
-    EntriesCallbacks(PassOwnPtrWillBeRawPtr<EntriesCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, DirectoryReaderBase*, const String& basePath);
-    OwnPtrWillBePersistent<EntriesCallback> m_successCallback;
+    EntriesCallbacks(EntriesCallback*, ErrorCallback*, ExecutionContext*, DirectoryReaderBase*, const String& basePath);
+    Persistent<EntriesCallback> m_successCallback;
     Persistent<DirectoryReaderBase> m_directoryReader;
     String m_basePath;
     PersistentHeapVector<Member<Entry> > m_entries;
@@ -117,66 +117,66 @@ private:
 
 class FileSystemCallbacks FINAL : public FileSystemCallbacksBase {
 public:
-    static PassOwnPtr<AsyncFileSystemCallbacks> create(PassOwnPtrWillBeRawPtr<FileSystemCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, FileSystemType);
+    static PassOwnPtr<AsyncFileSystemCallbacks> create(FileSystemCallback*, ErrorCallback*, ExecutionContext*, FileSystemType);
     virtual void didOpenFileSystem(const String& name, const KURL& rootURL) OVERRIDE;
 
 private:
-    FileSystemCallbacks(PassOwnPtrWillBeRawPtr<FileSystemCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, FileSystemType);
-    OwnPtrWillBePersistent<FileSystemCallback> m_successCallback;
+    FileSystemCallbacks(FileSystemCallback*, ErrorCallback*, ExecutionContext*, FileSystemType);
+    Persistent<FileSystemCallback> m_successCallback;
     FileSystemType m_type;
 };
 
 class ResolveURICallbacks FINAL : public FileSystemCallbacksBase {
 public:
-    static PassOwnPtr<AsyncFileSystemCallbacks> create(PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*);
+    static PassOwnPtr<AsyncFileSystemCallbacks> create(EntryCallback*, ErrorCallback*, ExecutionContext*);
     virtual void didResolveURL(const String& name, const KURL& rootURL, FileSystemType, const String& filePath, bool isDirectry) OVERRIDE;
 
 private:
-    ResolveURICallbacks(PassOwnPtrWillBeRawPtr<EntryCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*);
-    OwnPtrWillBePersistent<EntryCallback> m_successCallback;
+    ResolveURICallbacks(EntryCallback*, ErrorCallback*, ExecutionContext*);
+    Persistent<EntryCallback> m_successCallback;
 };
 
 class MetadataCallbacks FINAL : public FileSystemCallbacksBase {
 public:
-    static PassOwnPtr<AsyncFileSystemCallbacks> create(PassOwnPtrWillBeRawPtr<MetadataCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, DOMFileSystemBase*);
+    static PassOwnPtr<AsyncFileSystemCallbacks> create(MetadataCallback*, ErrorCallback*, ExecutionContext*, DOMFileSystemBase*);
     virtual void didReadMetadata(const FileMetadata&) OVERRIDE;
 
 private:
-    MetadataCallbacks(PassOwnPtrWillBeRawPtr<MetadataCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, DOMFileSystemBase*);
-    OwnPtrWillBePersistent<MetadataCallback> m_successCallback;
+    MetadataCallbacks(MetadataCallback*, ErrorCallback*, ExecutionContext*, DOMFileSystemBase*);
+    Persistent<MetadataCallback> m_successCallback;
 };
 
 class FileWriterBaseCallbacks FINAL : public FileSystemCallbacksBase {
 public:
-    static PassOwnPtr<AsyncFileSystemCallbacks> create(PassRefPtrWillBeRawPtr<FileWriterBase>, PassOwnPtrWillBeRawPtr<FileWriterBaseCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*);
+    static PassOwnPtr<AsyncFileSystemCallbacks> create(PassRefPtrWillBeRawPtr<FileWriterBase>, FileWriterBaseCallback*, ErrorCallback*, ExecutionContext*);
     virtual void didCreateFileWriter(PassOwnPtr<WebFileWriter>, long long length) OVERRIDE;
 
 private:
-    FileWriterBaseCallbacks(PassRefPtrWillBeRawPtr<FileWriterBase>, PassOwnPtrWillBeRawPtr<FileWriterBaseCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*);
+    FileWriterBaseCallbacks(PassRefPtrWillBeRawPtr<FileWriterBase>, FileWriterBaseCallback*, ErrorCallback*, ExecutionContext*);
     Persistent<FileWriterBase> m_fileWriter;
-    OwnPtrWillBePersistent<FileWriterBaseCallback> m_successCallback;
+    Persistent<FileWriterBaseCallback> m_successCallback;
 };
 
 class SnapshotFileCallback FINAL : public FileSystemCallbacksBase {
 public:
-    static PassOwnPtr<AsyncFileSystemCallbacks> create(DOMFileSystemBase*, const String& name, const KURL&, PassOwnPtrWillBeRawPtr<FileCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*);
+    static PassOwnPtr<AsyncFileSystemCallbacks> create(DOMFileSystemBase*, const String& name, const KURL&, FileCallback*, ErrorCallback*, ExecutionContext*);
     virtual void didCreateSnapshotFile(const FileMetadata&, PassRefPtr<BlobDataHandle> snapshot);
 
 private:
-    SnapshotFileCallback(DOMFileSystemBase*, const String& name, const KURL&, PassOwnPtrWillBeRawPtr<FileCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*);
+    SnapshotFileCallback(DOMFileSystemBase*, const String& name, const KURL&, FileCallback*, ErrorCallback*, ExecutionContext*);
     String m_name;
     KURL m_url;
-    OwnPtrWillBePersistent<FileCallback> m_successCallback;
+    Persistent<FileCallback> m_successCallback;
 };
 
 class VoidCallbacks FINAL : public FileSystemCallbacksBase {
 public:
-    static PassOwnPtr<AsyncFileSystemCallbacks> create(PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, DOMFileSystemBase*);
+    static PassOwnPtr<AsyncFileSystemCallbacks> create(VoidCallback*, ErrorCallback*, ExecutionContext*, DOMFileSystemBase*);
     virtual void didSucceed() OVERRIDE;
 
 private:
-    VoidCallbacks(PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<ErrorCallback>, ExecutionContext*, DOMFileSystemBase*);
-    OwnPtrWillBePersistent<VoidCallback> m_successCallback;
+    VoidCallbacks(VoidCallback*, ErrorCallback*, ExecutionContext*, DOMFileSystemBase*);
+    Persistent<VoidCallback> m_successCallback;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/modules/filesystem/FileWriterBaseCallback.h b/third_party/WebKit/Source/modules/filesystem/FileWriterBaseCallback.h
index 7e98cc7..df32b00 100644
--- a/third_party/WebKit/Source/modules/filesystem/FileWriterBaseCallback.h
+++ b/third_party/WebKit/Source/modules/filesystem/FileWriterBaseCallback.h
@@ -35,7 +35,7 @@ namespace blink {
 
 class FileWriterBase;
 
-class FileWriterBaseCallback : public NoBaseWillBeGarbageCollectedFinalized<FileWriterBaseCallback> {
+class FileWriterBaseCallback : public GarbageCollectedFinalized<FileWriterBaseCallback> {
 public:
     virtual ~FileWriterBaseCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/FileWriterCallback.h b/third_party/WebKit/Source/modules/filesystem/FileWriterCallback.h
index dcd5ce2..a85c751 100644
--- a/third_party/WebKit/Source/modules/filesystem/FileWriterCallback.h
+++ b/third_party/WebKit/Source/modules/filesystem/FileWriterCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class FileWriter;
 
-class FileWriterCallback : public NoBaseWillBeGarbageCollectedFinalized<FileWriterCallback> {
+class FileWriterCallback : public GarbageCollectedFinalized<FileWriterCallback> {
 public:
     virtual ~FileWriterCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp b/third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp
index 485e31b..df9f4c1 100644
--- a/third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/InspectorFileSystemAgent.cpp
@@ -85,9 +85,9 @@ class CallbackDispatcher FINAL : public BaseCallback {
 public:
     typedef bool (Handler::*HandlingMethod)(Argument);
 
-    static PassOwnPtrWillBeRawPtr<CallbackDispatcher> create(PassRefPtr<Handler> handler, HandlingMethod handlingMethod)
+    static CallbackDispatcher* create(PassRefPtr<Handler> handler, HandlingMethod handlingMethod)
     {
-        return adoptPtrWillBeNoop(new CallbackDispatcher(handler, handlingMethod));
+        return new CallbackDispatcher(handler, handlingMethod);
     }
 
     virtual void handleEvent(Argument argument) OVERRIDE
@@ -108,7 +108,7 @@ template<typename BaseCallback>
 class CallbackDispatcherFactory {
 public:
     template<typename Handler, typename Argument>
-    static PassOwnPtrWillBeRawPtr<CallbackDispatcher<BaseCallback, Handler, Argument> > create(Handler* handler, bool (Handler::*handlingMethod)(Argument))
+    static CallbackDispatcher<BaseCallback, Handler, Argument>* create(Handler* handler, bool (Handler::*handlingMethod)(Argument))
     {
         return CallbackDispatcher<BaseCallback, Handler, Argument>::create(PassRefPtr<Handler>(handler), handlingMethod);
     }
@@ -150,7 +150,7 @@ void FileSystemRootRequest::start(ExecutionContext* executionContext)
 {
     ASSERT(executionContext);
 
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileSystemRootRequest::didHitError);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileSystemRootRequest::didHitError);
 
     FileSystemType type;
     if (!DOMFileSystemBase::pathPrefixToFileSystemType(m_type, type)) {
@@ -164,8 +164,8 @@ void FileSystemRootRequest::start(ExecutionContext* executionContext)
         return;
     }
 
-    OwnPtrWillBeRawPtr<EntryCallback> successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &FileSystemRootRequest::didGetEntry);
-    OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback.release(), errorCallback.release(), executionContext);
+    EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &FileSystemRootRequest::didGetEntry);
+    OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, rootURL, fileSystemCallbacks.release());
 }
 
@@ -225,10 +225,10 @@ void DirectoryContentRequest::start(ExecutionContext* executionContext)
 {
     ASSERT(executionContext);
 
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
-    OwnPtrWillBeRawPtr<EntryCallback> successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &DirectoryContentRequest::didGetEntry);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
+    EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &DirectoryContentRequest::didGetEntry);
 
-    OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback.release(), errorCallback.release(), executionContext);
+    OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
 
     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, m_url, fileSystemCallbacks.release());
 }
@@ -253,9 +253,9 @@ void DirectoryContentRequest::readDirectoryEntries()
         return;
     }
 
-    OwnPtrWillBeRawPtr<EntriesCallback> successCallback = CallbackDispatcherFactory<EntriesCallback>::create(this, &DirectoryContentRequest::didReadDirectoryEntries);
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
-    m_directoryReader->readEntries(successCallback.release(), errorCallback.release());
+    EntriesCallback* successCallback = CallbackDispatcherFactory<EntriesCallback>::create(this, &DirectoryContentRequest::didReadDirectoryEntries);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DirectoryContentRequest::didHitError);
+    m_directoryReader->readEntries(successCallback, errorCallback);
 }
 
 bool DirectoryContentRequest::didReadDirectoryEntries(const EntryHeapVector& entries)
@@ -343,9 +343,9 @@ void MetadataRequest::start(ExecutionContext* executionContext)
 {
     ASSERT(executionContext);
 
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &MetadataRequest::didHitError);
-    OwnPtrWillBeRawPtr<EntryCallback> successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &MetadataRequest::didGetEntry);
-    OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback.release(), errorCallback.release(), executionContext);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &MetadataRequest::didHitError);
+    EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &MetadataRequest::didGetEntry);
+    OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, m_url, fileSystemCallbacks.release());
 }
 
@@ -356,9 +356,9 @@ bool MetadataRequest::didGetEntry(Entry* entry)
         return true;
     }
 
-    OwnPtrWillBeRawPtr<MetadataCallback> successCallback = CallbackDispatcherFactory<MetadataCallback>::create(this, &MetadataRequest::didGetMetadata);
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &MetadataRequest::didHitError);
-    entry->getMetadata(successCallback.release(), errorCallback.release());
+    MetadataCallback* successCallback = CallbackDispatcherFactory<MetadataCallback>::create(this, &MetadataRequest::didGetMetadata);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &MetadataRequest::didHitError);
+    entry->getMetadata(successCallback, errorCallback);
     m_isDirectory = entry->isDirectory();
     return true;
 }
@@ -441,10 +441,10 @@ void FileContentRequest::start(ExecutionContext* executionContext)
 {
     ASSERT(executionContext);
 
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileContentRequest::didHitError);
-    OwnPtrWillBeRawPtr<EntryCallback> successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &FileContentRequest::didGetEntry);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileContentRequest::didHitError);
+    EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &FileContentRequest::didGetEntry);
 
-    OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback.release(), errorCallback.release(), executionContext);
+    OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
     LocalFileSystem::from(*executionContext)->resolveURL(executionContext, m_url, fileSystemCallbacks.release());
 }
 
@@ -460,9 +460,9 @@ bool FileContentRequest::didGetEntry(Entry* entry)
         return true;
     }
 
-    OwnPtrWillBeRawPtr<FileCallback> successCallback = CallbackDispatcherFactory<FileCallback>::create(this, &FileContentRequest::didGetFile);
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileContentRequest::didHitError);
-    toFileEntry(entry)->file(successCallback.release(), errorCallback.release());
+    FileCallback* successCallback = CallbackDispatcherFactory<FileCallback>::create(this, &FileContentRequest::didGetFile);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &FileContentRequest::didHitError);
+    toFileEntry(entry)->file(successCallback, errorCallback);
 
     m_reader = FileReader::create(entry->filesystem()->executionContext());
     m_mimeType = MIMETypeRegistry::getMIMETypeForPath(entry->name());
@@ -555,7 +555,7 @@ void DeleteEntryRequest::start(ExecutionContext* executionContext)
 {
     ASSERT(executionContext);
 
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DeleteEntryRequest::didHitError);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DeleteEntryRequest::didHitError);
 
     FileSystemType type;
     String path;
@@ -565,25 +565,25 @@ void DeleteEntryRequest::start(ExecutionContext* executionContext)
     }
 
     if (path == "/") {
-        OwnPtrWillBeRawPtr<VoidCallback> successCallback = adoptPtrWillBeNoop(new VoidCallbackImpl(this));
-        OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = VoidCallbacks::create(successCallback.release(), errorCallback.release(), executionContext, nullptr);
+        VoidCallback* successCallback = new VoidCallbackImpl(this);
+        OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = VoidCallbacks::create(successCallback, errorCallback, executionContext, nullptr);
         LocalFileSystem::from(*executionContext)->deleteFileSystem(executionContext, type, fileSystemCallbacks.release());
     } else {
-        OwnPtrWillBeRawPtr<EntryCallback> successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &DeleteEntryRequest::didGetEntry);
-        OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback.release(), errorCallback.release(), executionContext);
+        EntryCallback* successCallback = CallbackDispatcherFactory<EntryCallback>::create(this, &DeleteEntryRequest::didGetEntry);
+        OwnPtr<AsyncFileSystemCallbacks> fileSystemCallbacks = ResolveURICallbacks::create(successCallback, errorCallback, executionContext);
         LocalFileSystem::from(*executionContext)->resolveURL(executionContext, m_url, fileSystemCallbacks.release());
     }
 }
 
 bool DeleteEntryRequest::didGetEntry(Entry* entry)
 {
-    OwnPtrWillBeRawPtr<VoidCallback> successCallback = adoptPtrWillBeNoop(new VoidCallbackImpl(this));
-    OwnPtrWillBeRawPtr<ErrorCallback> errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DeleteEntryRequest::didHitError);
+    VoidCallback* successCallback = new VoidCallbackImpl(this);
+    ErrorCallback* errorCallback = CallbackDispatcherFactory<ErrorCallback>::create(this, &DeleteEntryRequest::didHitError);
     if (entry->isDirectory()) {
         DirectoryEntry* directoryEntry = toDirectoryEntry(entry);
-        directoryEntry->removeRecursively(successCallback.release(), errorCallback.release());
+        directoryEntry->removeRecursively(successCallback, errorCallback);
     } else {
-        entry->remove(successCallback.release(), errorCallback.release());
+        entry->remove(successCallback, errorCallback);
     }
     return true;
 }
diff --git a/third_party/WebKit/Source/modules/filesystem/MetadataCallback.h b/third_party/WebKit/Source/modules/filesystem/MetadataCallback.h
index 820c17e..367db6d 100644
--- a/third_party/WebKit/Source/modules/filesystem/MetadataCallback.h
+++ b/third_party/WebKit/Source/modules/filesystem/MetadataCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class Metadata;
 
-class MetadataCallback : public NoBaseWillBeGarbageCollectedFinalized<MetadataCallback> {
+class MetadataCallback : public GarbageCollectedFinalized<MetadataCallback> {
 public:
     virtual ~MetadataCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/filesystem/SyncCallbackHelper.h b/third_party/WebKit/Source/modules/filesystem/SyncCallbackHelper.h
index 9fecc2a..42999ac 100644
--- a/third_party/WebKit/Source/modules/filesystem/SyncCallbackHelper.h
+++ b/third_party/WebKit/Source/modules/filesystem/SyncCallbackHelper.h
@@ -83,8 +83,8 @@ public:
         return m_result;
     }
 
-    PassOwnPtrWillBeRawPtr<SuccessCallback> successCallback() { return SuccessCallbackImpl::create(this); }
-    PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback() { return ErrorCallbackImpl::create(this); }
+    SuccessCallback* successCallback() { return SuccessCallbackImpl::create(this); }
+    ErrorCallback* errorCallback() { return ErrorCallbackImpl::create(this); }
 
     void trace(Visitor* visitor)
     {
@@ -100,9 +100,9 @@ private:
 
     class SuccessCallbackImpl FINAL : public SuccessCallback {
     public:
-        static PassOwnPtrWillBeRawPtr<SuccessCallbackImpl> create(HelperType* helper)
+        static SuccessCallbackImpl* create(HelperType* helper)
         {
-            return adoptPtrWillBeNoop(new SuccessCallbackImpl(helper));
+            return new SuccessCallbackImpl(helper);
         }
 
         virtual void handleEvent()
@@ -125,9 +125,9 @@ private:
 
     class ErrorCallbackImpl FINAL : public ErrorCallback {
     public:
-        static PassOwnPtrWillBeRawPtr<ErrorCallbackImpl> create(HelperType* helper)
+        static ErrorCallbackImpl* create(HelperType* helper)
         {
-            return adoptPtrWillBeNoop(new ErrorCallbackImpl(helper));
+            return new ErrorCallbackImpl(helper);
         }
 
         virtual void handleEvent(FileError* error) OVERRIDE
diff --git a/third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.cpp b/third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.cpp
index a9e5984..4abb865 100644
--- a/third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.cpp
+++ b/third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.cpp
@@ -45,7 +45,7 @@
 
 namespace blink {
 
-void WorkerGlobalScopeFileSystem::webkitRequestFileSystem(WorkerGlobalScope& worker, int type, long long size, PassOwnPtrWillBeRawPtr<FileSystemCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void WorkerGlobalScopeFileSystem::webkitRequestFileSystem(WorkerGlobalScope& worker, int type, long long size, FileSystemCallback* successCallback, ErrorCallback* errorCallback)
 {
     ExecutionContext* secureContext = worker.executionContext();
     if (!secureContext->securityOrigin()->canAccessFileSystem()) {
@@ -84,7 +84,7 @@ DOMFileSystemSync* WorkerGlobalScopeFileSystem::webkitRequestFileSystemSync(Work
     return helper->getResult(exceptionState);
 }
 
-void WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemURL(WorkerGlobalScope& worker, const String& url, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback> errorCallback)
+void WorkerGlobalScopeFileSystem::webkitResolveLocalFileSystemURL(WorkerGlobalScope& worker, const String& url, EntryCallback* successCallback, ErrorCallback* errorCallback)
 {
     KURL completedURL = worker.completeURL(url);
     ExecutionContext* secureContext = worker.executionContext();
diff --git a/third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.h b/third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.h
index 57d0cd7..84a0d0f 100644
--- a/third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.h
+++ b/third_party/WebKit/Source/modules/filesystem/WorkerGlobalScopeFileSystem.h
@@ -46,9 +46,9 @@ public:
         PERSISTENT,
     };
 
-    static void webkitRequestFileSystem(WorkerGlobalScope&, int type, long long size, PassOwnPtrWillBeRawPtr<FileSystemCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback>);
+    static void webkitRequestFileSystem(WorkerGlobalScope&, int type, long long size, FileSystemCallback* successCallback, ErrorCallback*);
     static DOMFileSystemSync* webkitRequestFileSystemSync(WorkerGlobalScope&, int type, long long size, ExceptionState&);
-    static void webkitResolveLocalFileSystemURL(WorkerGlobalScope&, const String& url, PassOwnPtrWillBeRawPtr<EntryCallback> successCallback, PassOwnPtrWillBeRawPtr<ErrorCallback>);
+    static void webkitResolveLocalFileSystemURL(WorkerGlobalScope&, const String& url, EntryCallback* successCallback, ErrorCallback*);
     static EntrySync* webkitResolveLocalFileSystemSyncURL(WorkerGlobalScope&, const String& url, ExceptionState&);
 
 private:
diff --git a/third_party/WebKit/Source/modules/geolocation/GeoNotifier.cpp b/third_party/WebKit/Source/modules/geolocation/GeoNotifier.cpp
index bf9629e..f54f211 100644
--- a/third_party/WebKit/Source/modules/geolocation/GeoNotifier.cpp
+++ b/third_party/WebKit/Source/modules/geolocation/GeoNotifier.cpp
@@ -11,7 +11,7 @@
 
 namespace blink {
 
-GeoNotifier::GeoNotifier(Geolocation* geolocation, PassOwnPtrWillBeRawPtr<PositionCallback> successCallback, PassOwnPtrWillBeRawPtr<PositionErrorCallback> errorCallback, PositionOptions* options)
+GeoNotifier::GeoNotifier(Geolocation* geolocation, PositionCallback* successCallback, PositionErrorCallback* errorCallback, PositionOptions* options)
     // FIXME : m_geolocation should be removed, it makes circular dependancy.
     : m_geolocation(geolocation)
     , m_successCallback(successCallback)
diff --git a/third_party/WebKit/Source/modules/geolocation/GeoNotifier.h b/third_party/WebKit/Source/modules/geolocation/GeoNotifier.h
index a1471c9..d0c6178 100644
--- a/third_party/WebKit/Source/modules/geolocation/GeoNotifier.h
+++ b/third_party/WebKit/Source/modules/geolocation/GeoNotifier.h
@@ -19,7 +19,7 @@ class PositionOptions;
 
 class GeoNotifier : public GarbageCollectedFinalized<GeoNotifier> {
 public:
-    static GeoNotifier* create(Geolocation* geolocation, PassOwnPtrWillBeRawPtr<PositionCallback> positionCallback, PassOwnPtrWillBeRawPtr<PositionErrorCallback> positionErrorCallback, PositionOptions* options)
+    static GeoNotifier* create(Geolocation* geolocation, PositionCallback* positionCallback, PositionErrorCallback* positionErrorCallback, PositionOptions* options)
     {
         return new GeoNotifier(geolocation, positionCallback, positionErrorCallback, options);
     }
@@ -49,11 +49,11 @@ public:
     void timerFired(Timer<GeoNotifier>*);
 
 private:
-    GeoNotifier(Geolocation*, PassOwnPtrWillBeRawPtr<PositionCallback>, PassOwnPtrWillBeRawPtr<PositionErrorCallback>, PositionOptions*);
+    GeoNotifier(Geolocation*, PositionCallback*, PositionErrorCallback*, PositionOptions*);
 
     Member<Geolocation> m_geolocation;
-    OwnPtrWillBeMember<PositionCallback> m_successCallback;
-    OwnPtrWillBeMember<PositionErrorCallback> m_errorCallback;
+    Member<PositionCallback> m_successCallback;
+    Member<PositionErrorCallback> m_errorCallback;
     Member<PositionOptions> m_options;
     Timer<GeoNotifier> m_timer;
     Member<PositionError> m_fatalError;
diff --git a/third_party/WebKit/Source/modules/geolocation/Geolocation.cpp b/third_party/WebKit/Source/modules/geolocation/Geolocation.cpp
index 3406e6f..1aa1d4f 100644
--- a/third_party/WebKit/Source/modules/geolocation/Geolocation.cpp
+++ b/third_party/WebKit/Source/modules/geolocation/Geolocation.cpp
@@ -137,7 +137,7 @@ Geoposition* Geolocation::lastPosition()
     return m_lastPosition.get();
 }
 
-void Geolocation::getCurrentPosition(PassOwnPtrWillBeRawPtr<PositionCallback> successCallback, PassOwnPtrWillBeRawPtr<PositionErrorCallback> errorCallback, const Dictionary& options)
+void Geolocation::getCurrentPosition(PositionCallback* successCallback, PositionErrorCallback* errorCallback, const Dictionary& options)
 {
     if (!frame())
         return;
@@ -148,7 +148,7 @@ void Geolocation::getCurrentPosition(PassOwnPtrWillBeRawPtr<PositionCallback> su
     m_oneShots.add(notifier);
 }
 
-int Geolocation::watchPosition(PassOwnPtrWillBeRawPtr<PositionCallback> successCallback, PassOwnPtrWillBeRawPtr<PositionErrorCallback> errorCallback, const Dictionary& options)
+int Geolocation::watchPosition(PositionCallback* successCallback, PositionErrorCallback* errorCallback, const Dictionary& options)
 {
     if (!frame())
         return 0;
diff --git a/third_party/WebKit/Source/modules/geolocation/Geolocation.h b/third_party/WebKit/Source/modules/geolocation/Geolocation.h
index 8e322d3..bb15240 100644
--- a/third_party/WebKit/Source/modules/geolocation/Geolocation.h
+++ b/third_party/WebKit/Source/modules/geolocation/Geolocation.h
@@ -65,11 +65,11 @@ public:
 
     // Creates a oneshot and attempts to obtain a position that meets the
     // constraints of the options.
-    void getCurrentPosition(PassOwnPtrWillBeRawPtr<PositionCallback>, PassOwnPtrWillBeRawPtr<PositionErrorCallback>, const Dictionary&);
+    void getCurrentPosition(PositionCallback*, PositionErrorCallback*, const Dictionary&);
 
     // Creates a watcher that will be notified whenever a new position is
     // available that meets the constraints of the options.
-    int watchPosition(PassOwnPtrWillBeRawPtr<PositionCallback>, PassOwnPtrWillBeRawPtr<PositionErrorCallback>, const Dictionary&);
+    int watchPosition(PositionCallback*, PositionErrorCallback*, const Dictionary&);
 
     // Removes all references to the watcher, it will not be updated again.
     void clearWatch(int watchID);
diff --git a/third_party/WebKit/Source/modules/geolocation/PositionCallback.h b/third_party/WebKit/Source/modules/geolocation/PositionCallback.h
index 99ccc72..a0ab8b2 100644
--- a/third_party/WebKit/Source/modules/geolocation/PositionCallback.h
+++ b/third_party/WebKit/Source/modules/geolocation/PositionCallback.h
@@ -32,7 +32,7 @@ namespace blink {
 
     class Geoposition;
 
-    class PositionCallback : public NoBaseWillBeGarbageCollectedFinalized<PositionCallback> {
+    class PositionCallback : public GarbageCollectedFinalized<PositionCallback> {
     public:
         virtual ~PositionCallback() { }
         virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/geolocation/PositionErrorCallback.h b/third_party/WebKit/Source/modules/geolocation/PositionErrorCallback.h
index 1388c9b..846b921 100644
--- a/third_party/WebKit/Source/modules/geolocation/PositionErrorCallback.h
+++ b/third_party/WebKit/Source/modules/geolocation/PositionErrorCallback.h
@@ -32,7 +32,7 @@ namespace blink {
 
     class PositionError;
 
-    class PositionErrorCallback : public NoBaseWillBeGarbageCollectedFinalized<PositionErrorCallback> {
+    class PositionErrorCallback : public GarbageCollectedFinalized<PositionErrorCallback> {
     public:
         virtual ~PositionErrorCallback() { }
         virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaDeviceInfoCallback.h b/third_party/WebKit/Source/modules/mediastream/MediaDeviceInfoCallback.h
index 3ed636e..eadac87 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaDeviceInfoCallback.h
+++ b/third_party/WebKit/Source/modules/mediastream/MediaDeviceInfoCallback.h
@@ -31,7 +31,7 @@
 
 namespace blink {
 
-class MediaDeviceInfoCallback : public NoBaseWillBeGarbageCollectedFinalized<MediaDeviceInfoCallback> {
+class MediaDeviceInfoCallback : public GarbageCollectedFinalized<MediaDeviceInfoCallback> {
 public:
     virtual ~MediaDeviceInfoCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaDevicesRequest.cpp b/third_party/WebKit/Source/modules/mediastream/MediaDevicesRequest.cpp
index 73570c5..cc436ab 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaDevicesRequest.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/MediaDevicesRequest.cpp
@@ -33,14 +33,14 @@
 
 namespace blink {
 
-MediaDevicesRequest* MediaDevicesRequest::create(ExecutionContext* context, UserMediaController* controller, PassOwnPtrWillBeRawPtr<MediaDeviceInfoCallback> callback, ExceptionState& exceptionState)
+MediaDevicesRequest* MediaDevicesRequest::create(ExecutionContext* context, UserMediaController* controller, MediaDeviceInfoCallback* callback, ExceptionState& exceptionState)
 {
     MediaDevicesRequest* request = new MediaDevicesRequest(context, controller, callback);
     request->suspendIfNeeded();
     return request;
 }
 
-MediaDevicesRequest::MediaDevicesRequest(ExecutionContext* context, UserMediaController* controller, PassOwnPtrWillBeRawPtr<MediaDeviceInfoCallback> callback)
+MediaDevicesRequest::MediaDevicesRequest(ExecutionContext* context, UserMediaController* controller, MediaDeviceInfoCallback* callback)
     : ActiveDOMObject(context)
     , m_controller(controller)
     , m_callback(callback)
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaDevicesRequest.h b/third_party/WebKit/Source/modules/mediastream/MediaDevicesRequest.h
index f923c25..6e60b5a 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaDevicesRequest.h
+++ b/third_party/WebKit/Source/modules/mediastream/MediaDevicesRequest.h
@@ -41,7 +41,7 @@ class UserMediaController;
 
 class MediaDevicesRequest FINAL : public GarbageCollectedFinalized<MediaDevicesRequest>, public ActiveDOMObject {
 public:
-    static MediaDevicesRequest* create(ExecutionContext*, UserMediaController*, PassOwnPtrWillBeRawPtr<MediaDeviceInfoCallback>, ExceptionState&);
+    static MediaDevicesRequest* create(ExecutionContext*, UserMediaController*, MediaDeviceInfoCallback*, ExceptionState&);
     virtual ~MediaDevicesRequest();
 
     MediaDeviceInfoCallback* callback() const { return m_callback.get(); }
@@ -57,11 +57,11 @@ public:
     void trace(Visitor*);
 
 private:
-    MediaDevicesRequest(ExecutionContext*, UserMediaController*, PassOwnPtrWillBeRawPtr<MediaDeviceInfoCallback>);
+    MediaDevicesRequest(ExecutionContext*, UserMediaController*, MediaDeviceInfoCallback*);
 
     UserMediaController* m_controller;
 
-    OwnPtrWillBeMember<MediaDeviceInfoCallback> m_callback;
+    Member<MediaDeviceInfoCallback> m_callback;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.cpp b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.cpp
index 3843cb8..263abef 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.cpp
@@ -128,7 +128,7 @@ String MediaStreamTrack::readyState() const
     return String();
 }
 
-void MediaStreamTrack::getSources(ExecutionContext* context, PassOwnPtrWillBeRawPtr<MediaStreamTrackSourcesCallback> callback, ExceptionState& exceptionState)
+void MediaStreamTrack::getSources(ExecutionContext* context, MediaStreamTrackSourcesCallback* callback, ExceptionState& exceptionState)
 {
     LocalFrame* frame = toDocument(context)->frame();
     UserMediaController* userMedia = UserMediaController::from(frame);
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.h b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.h
index 98733af..e5ac858 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.h
+++ b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrack.h
@@ -63,7 +63,7 @@ public:
 
     String readyState() const;
 
-    static void getSources(ExecutionContext*, PassOwnPtrWillBeRawPtr<MediaStreamTrackSourcesCallback>, ExceptionState&);
+    static void getSources(ExecutionContext*, MediaStreamTrackSourcesCallback*, ExceptionState&);
     void stopTrack(ExceptionState&);
     MediaStreamTrack* clone(ExecutionContext*);
 
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesCallback.h b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesCallback.h
index 4895bcf..9382a12 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesCallback.h
+++ b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesCallback.h
@@ -31,7 +31,7 @@ namespace blink {
 
 class MediaStreamTrackSourcesResponse;
 
-class MediaStreamTrackSourcesCallback : public NoBaseWillBeGarbageCollectedFinalized<MediaStreamTrackSourcesCallback> {
+class MediaStreamTrackSourcesCallback : public GarbageCollectedFinalized<MediaStreamTrackSourcesCallback> {
 public:
     virtual ~MediaStreamTrackSourcesCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesRequestImpl.cpp b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesRequestImpl.cpp
index b8a79a4..c1dd5c1 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesRequestImpl.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesRequestImpl.cpp
@@ -36,12 +36,12 @@
 
 namespace blink {
 
-MediaStreamTrackSourcesRequestImpl* MediaStreamTrackSourcesRequestImpl::create(ExecutionContext& context, PassOwnPtrWillBeRawPtr<MediaStreamTrackSourcesCallback> callback)
+MediaStreamTrackSourcesRequestImpl* MediaStreamTrackSourcesRequestImpl::create(ExecutionContext& context, MediaStreamTrackSourcesCallback* callback)
 {
     return new MediaStreamTrackSourcesRequestImpl(context, callback);
 }
 
-MediaStreamTrackSourcesRequestImpl::MediaStreamTrackSourcesRequestImpl(ExecutionContext& context, PassOwnPtrWillBeRawPtr<MediaStreamTrackSourcesCallback> callback)
+MediaStreamTrackSourcesRequestImpl::MediaStreamTrackSourcesRequestImpl(ExecutionContext& context, MediaStreamTrackSourcesCallback* callback)
     : m_callback(callback)
     , m_executionContext(&context)
 {
diff --git a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesRequestImpl.h b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesRequestImpl.h
index 1ea604f..9ea54cb 100644
--- a/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesRequestImpl.h
+++ b/third_party/WebKit/Source/modules/mediastream/MediaStreamTrackSourcesRequestImpl.h
@@ -38,7 +38,7 @@ template<typename T> class WebVector;
 
 class MediaStreamTrackSourcesRequestImpl FINAL : public MediaStreamTrackSourcesRequest {
 public:
-    static MediaStreamTrackSourcesRequestImpl* create(ExecutionContext&, PassOwnPtrWillBeRawPtr<MediaStreamTrackSourcesCallback>);
+    static MediaStreamTrackSourcesRequestImpl* create(ExecutionContext&, MediaStreamTrackSourcesCallback*);
     ~MediaStreamTrackSourcesRequestImpl();
 
     virtual String origin() OVERRIDE;
@@ -47,11 +47,11 @@ public:
     virtual void trace(Visitor*) OVERRIDE;
 
 private:
-    MediaStreamTrackSourcesRequestImpl(ExecutionContext&, PassOwnPtrWillBeRawPtr<MediaStreamTrackSourcesCallback>);
+    MediaStreamTrackSourcesRequestImpl(ExecutionContext&, MediaStreamTrackSourcesCallback*);
 
     void performCallback();
 
-    OwnPtrWillBeMember<MediaStreamTrackSourcesCallback> m_callback;
+    Member<MediaStreamTrackSourcesCallback> m_callback;
     RefPtrWillBeMember<ExecutionContext> m_executionContext;
     SourceInfoVector m_sourceInfos;
 };
diff --git a/third_party/WebKit/Source/modules/mediastream/NavigatorMediaStream.cpp b/third_party/WebKit/Source/modules/mediastream/NavigatorMediaStream.cpp
index 70b3054..3429c95 100644
--- a/third_party/WebKit/Source/modules/mediastream/NavigatorMediaStream.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/NavigatorMediaStream.cpp
@@ -47,7 +47,7 @@ NavigatorMediaStream::~NavigatorMediaStream()
 {
 }
 
-void NavigatorMediaStream::webkitGetUserMedia(Navigator& navigator, const Dictionary& options, PassOwnPtrWillBeRawPtr<NavigatorUserMediaSuccessCallback> successCallback, PassOwnPtrWillBeRawPtr<NavigatorUserMediaErrorCallback> errorCallback, ExceptionState& exceptionState)
+void NavigatorMediaStream::webkitGetUserMedia(Navigator& navigator, const Dictionary& options, NavigatorUserMediaSuccessCallback* successCallback, NavigatorUserMediaErrorCallback* errorCallback, ExceptionState& exceptionState)
 {
     if (!successCallback)
         return;
@@ -67,7 +67,7 @@ void NavigatorMediaStream::webkitGetUserMedia(Navigator& navigator, const Dictio
     request->start();
 }
 
-void NavigatorMediaStream::getMediaDevices(Navigator& navigator, PassOwnPtrWillBeRawPtr<MediaDeviceInfoCallback> callback, ExceptionState& exceptionState)
+void NavigatorMediaStream::getMediaDevices(Navigator& navigator, MediaDeviceInfoCallback* callback, ExceptionState& exceptionState)
 {
     UserMediaController* userMedia = UserMediaController::from(navigator.frame());
     if (!userMedia) {
diff --git a/third_party/WebKit/Source/modules/mediastream/NavigatorMediaStream.h b/third_party/WebKit/Source/modules/mediastream/NavigatorMediaStream.h
index c824978..44e4350 100644
--- a/third_party/WebKit/Source/modules/mediastream/NavigatorMediaStream.h
+++ b/third_party/WebKit/Source/modules/mediastream/NavigatorMediaStream.h
@@ -35,9 +35,9 @@ class NavigatorUserMediaSuccessCallback;
 
 class NavigatorMediaStream {
 public:
-    static void webkitGetUserMedia(Navigator&, const Dictionary&, PassOwnPtrWillBeRawPtr<NavigatorUserMediaSuccessCallback>, PassOwnPtrWillBeRawPtr<NavigatorUserMediaErrorCallback>, ExceptionState&);
+    static void webkitGetUserMedia(Navigator&, const Dictionary&, NavigatorUserMediaSuccessCallback*, NavigatorUserMediaErrorCallback*, ExceptionState&);
 
-    static void getMediaDevices(Navigator&, PassOwnPtrWillBeRawPtr<MediaDeviceInfoCallback>, ExceptionState&);
+    static void getMediaDevices(Navigator&, MediaDeviceInfoCallback*, ExceptionState&);
 
 private:
     NavigatorMediaStream();
diff --git a/third_party/WebKit/Source/modules/mediastream/NavigatorUserMediaErrorCallback.h b/third_party/WebKit/Source/modules/mediastream/NavigatorUserMediaErrorCallback.h
index 1e59536..6c8d053 100644
--- a/third_party/WebKit/Source/modules/mediastream/NavigatorUserMediaErrorCallback.h
+++ b/third_party/WebKit/Source/modules/mediastream/NavigatorUserMediaErrorCallback.h
@@ -30,7 +30,7 @@
 
 namespace blink {
 
-class NavigatorUserMediaErrorCallback : public NoBaseWillBeGarbageCollectedFinalized<NavigatorUserMediaErrorCallback> {
+class NavigatorUserMediaErrorCallback : public GarbageCollectedFinalized<NavigatorUserMediaErrorCallback> {
 public:
     virtual ~NavigatorUserMediaErrorCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/mediastream/NavigatorUserMediaSuccessCallback.h b/third_party/WebKit/Source/modules/mediastream/NavigatorUserMediaSuccessCallback.h
index 6ade17a..f6d1c37 100644
--- a/third_party/WebKit/Source/modules/mediastream/NavigatorUserMediaSuccessCallback.h
+++ b/third_party/WebKit/Source/modules/mediastream/NavigatorUserMediaSuccessCallback.h
@@ -31,7 +31,7 @@ namespace blink {
 
 class MediaStream;
 
-class NavigatorUserMediaSuccessCallback : public NoBaseWillBeGarbageCollectedFinalized<NavigatorUserMediaSuccessCallback> {
+class NavigatorUserMediaSuccessCallback : public GarbageCollectedFinalized<NavigatorUserMediaSuccessCallback> {
 public:
     virtual ~NavigatorUserMediaSuccessCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCErrorCallback.h b/third_party/WebKit/Source/modules/mediastream/RTCErrorCallback.h
index 13a6042..2bd83d5 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCErrorCallback.h
+++ b/third_party/WebKit/Source/modules/mediastream/RTCErrorCallback.h
@@ -36,7 +36,7 @@
 
 namespace blink {
 
-class RTCErrorCallback : public NoBaseWillBeGarbageCollectedFinalized<RTCErrorCallback> {
+class RTCErrorCallback : public GarbageCollectedFinalized<RTCErrorCallback> {
 public:
     virtual ~RTCErrorCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp b/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp
index 72bcb3a..6b30e82 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.cpp
@@ -270,7 +270,7 @@ RTCPeerConnection::~RTCPeerConnection()
     ASSERT(m_closed || m_stopped);
 }
 
-void RTCPeerConnection::createOffer(PassOwnPtrWillBeRawPtr<RTCSessionDescriptionCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback, const Dictionary& rtcOfferOptions, ExceptionState& exceptionState)
+void RTCPeerConnection::createOffer(RTCSessionDescriptionCallback* successCallback, RTCErrorCallback* errorCallback, const Dictionary& rtcOfferOptions, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
@@ -294,7 +294,7 @@ void RTCPeerConnection::createOffer(PassOwnPtrWillBeRawPtr<RTCSessionDescription
     }
 }
 
-void RTCPeerConnection::createAnswer(PassOwnPtrWillBeRawPtr<RTCSessionDescriptionCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback, const Dictionary& mediaConstraints, ExceptionState& exceptionState)
+void RTCPeerConnection::createAnswer(RTCSessionDescriptionCallback* successCallback, RTCErrorCallback* errorCallback, const Dictionary& mediaConstraints, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
@@ -309,7 +309,7 @@ void RTCPeerConnection::createAnswer(PassOwnPtrWillBeRawPtr<RTCSessionDescriptio
     m_peerHandler->createAnswer(request, constraints);
 }
 
-void RTCPeerConnection::setLocalDescription(RTCSessionDescription* sessionDescription, PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback, ExceptionState& exceptionState)
+void RTCPeerConnection::setLocalDescription(RTCSessionDescription* sessionDescription, VoidCallback* successCallback, RTCErrorCallback* errorCallback, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
@@ -332,7 +332,7 @@ RTCSessionDescription* RTCPeerConnection::localDescription(ExceptionState& excep
     return RTCSessionDescription::create(webSessionDescription);
 }
 
-void RTCPeerConnection::setRemoteDescription(RTCSessionDescription* sessionDescription, PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback, ExceptionState& exceptionState)
+void RTCPeerConnection::setRemoteDescription(RTCSessionDescription* sessionDescription, VoidCallback* successCallback, RTCErrorCallback* errorCallback, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
@@ -388,7 +388,7 @@ void RTCPeerConnection::addIceCandidate(RTCIceCandidate* iceCandidate, Exception
         exceptionState.throwDOMException(SyntaxError, "The ICE candidate could not be added.");
 }
 
-void RTCPeerConnection::addIceCandidate(RTCIceCandidate* iceCandidate, PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback, ExceptionState& exceptionState)
+void RTCPeerConnection::addIceCandidate(RTCIceCandidate* iceCandidate, VoidCallback* successCallback, RTCErrorCallback* errorCallback, ExceptionState& exceptionState)
 {
     if (throwExceptionIfSignalingStateClosed(m_signalingState, exceptionState))
         return;
@@ -535,7 +535,7 @@ MediaStream* RTCPeerConnection::getStreamById(const String& streamId)
     return 0;
 }
 
-void RTCPeerConnection::getStats(PassOwnPtrWillBeRawPtr<RTCStatsCallback> successCallback, MediaStreamTrack* selector)
+void RTCPeerConnection::getStats(RTCStatsCallback* successCallback, MediaStreamTrack* selector)
 {
     RTCStatsRequest* statsRequest = RTCStatsRequestImpl::create(executionContext(), this, successCallback, selector);
     // FIXME: Add passing selector as part of the statsRequest.
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.h b/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.h
index 922db61..5bb52a6 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.h
+++ b/third_party/WebKit/Source/modules/mediastream/RTCPeerConnection.h
@@ -67,14 +67,14 @@ public:
     static RTCPeerConnection* create(ExecutionContext*, const Dictionary&, const Dictionary&, ExceptionState&);
     virtual ~RTCPeerConnection();
 
-    void createOffer(PassOwnPtrWillBeRawPtr<RTCSessionDescriptionCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>, const Dictionary&, ExceptionState&);
+    void createOffer(RTCSessionDescriptionCallback*, RTCErrorCallback*, const Dictionary&, ExceptionState&);
 
-    void createAnswer(PassOwnPtrWillBeRawPtr<RTCSessionDescriptionCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>, const Dictionary&, ExceptionState&);
+    void createAnswer(RTCSessionDescriptionCallback*, RTCErrorCallback*, const Dictionary&, ExceptionState&);
 
-    void setLocalDescription(RTCSessionDescription*, PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>, ExceptionState&);
+    void setLocalDescription(RTCSessionDescription*, VoidCallback*, RTCErrorCallback*, ExceptionState&);
     RTCSessionDescription* localDescription(ExceptionState&);
 
-    void setRemoteDescription(RTCSessionDescription*, PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>, ExceptionState&);
+    void setRemoteDescription(RTCSessionDescription*, VoidCallback*, RTCErrorCallback*, ExceptionState&);
     RTCSessionDescription* remoteDescription(ExceptionState&);
 
     String signalingState() const;
@@ -84,7 +84,7 @@ public:
     // DEPRECATED
     void addIceCandidate(RTCIceCandidate*, ExceptionState&);
 
-    void addIceCandidate(RTCIceCandidate*, PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>, ExceptionState&);
+    void addIceCandidate(RTCIceCandidate*, VoidCallback*, RTCErrorCallback*, ExceptionState&);
 
     String iceGatheringState() const;
 
@@ -100,7 +100,7 @@ public:
 
     void removeStream(MediaStream*, ExceptionState&);
 
-    void getStats(PassOwnPtrWillBeRawPtr<RTCStatsCallback> successCallback, MediaStreamTrack* selector);
+    void getStats(RTCStatsCallback* successCallback, MediaStreamTrack* selector);
 
     RTCDataChannel* createDataChannel(String label, const Dictionary& dataChannelDict, ExceptionState&);
 
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionCallback.h b/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionCallback.h
index b0ea270..775c847 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionCallback.h
+++ b/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class RTCSessionDescription;
 
-class RTCSessionDescriptionCallback : public NoBaseWillBeGarbageCollectedFinalized<RTCSessionDescriptionCallback> {
+class RTCSessionDescriptionCallback : public GarbageCollectedFinalized<RTCSessionDescriptionCallback> {
 public:
     virtual ~RTCSessionDescriptionCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionRequestImpl.cpp b/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionRequestImpl.cpp
index 19df54e..6634cb6 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionRequestImpl.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionRequestImpl.cpp
@@ -41,14 +41,14 @@
 
 namespace blink {
 
-RTCSessionDescriptionRequestImpl* RTCSessionDescriptionRequestImpl::create(ExecutionContext* context, RTCPeerConnection* requester, PassOwnPtrWillBeRawPtr<RTCSessionDescriptionCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback)
+RTCSessionDescriptionRequestImpl* RTCSessionDescriptionRequestImpl::create(ExecutionContext* context, RTCPeerConnection* requester, RTCSessionDescriptionCallback* successCallback, RTCErrorCallback* errorCallback)
 {
     RTCSessionDescriptionRequestImpl* request = new RTCSessionDescriptionRequestImpl(context, requester, successCallback, errorCallback);
     request->suspendIfNeeded();
     return request;
 }
 
-RTCSessionDescriptionRequestImpl::RTCSessionDescriptionRequestImpl(ExecutionContext* context, RTCPeerConnection* requester, PassOwnPtrWillBeRawPtr<RTCSessionDescriptionCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback)
+RTCSessionDescriptionRequestImpl::RTCSessionDescriptionRequestImpl(ExecutionContext* context, RTCPeerConnection* requester, RTCSessionDescriptionCallback* successCallback, RTCErrorCallback* errorCallback)
     : ActiveDOMObject(context)
     , m_successCallback(successCallback)
     , m_errorCallback(errorCallback)
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionRequestImpl.h b/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionRequestImpl.h
index 4f6e088..5477200 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionRequestImpl.h
+++ b/third_party/WebKit/Source/modules/mediastream/RTCSessionDescriptionRequestImpl.h
@@ -46,7 +46,7 @@ class WebRTCSessionDescription;
 
 class RTCSessionDescriptionRequestImpl FINAL : public RTCSessionDescriptionRequest, public ActiveDOMObject {
 public:
-    static RTCSessionDescriptionRequestImpl* create(ExecutionContext*, RTCPeerConnection*, PassOwnPtrWillBeRawPtr<RTCSessionDescriptionCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>);
+    static RTCSessionDescriptionRequestImpl* create(ExecutionContext*, RTCPeerConnection*, RTCSessionDescriptionCallback*, RTCErrorCallback*);
     virtual ~RTCSessionDescriptionRequestImpl();
 
     virtual void requestSucceeded(const WebRTCSessionDescription&) OVERRIDE;
@@ -58,12 +58,12 @@ public:
     virtual void trace(Visitor*) OVERRIDE;
 
 private:
-    RTCSessionDescriptionRequestImpl(ExecutionContext*, RTCPeerConnection*, PassOwnPtrWillBeRawPtr<RTCSessionDescriptionCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>);
+    RTCSessionDescriptionRequestImpl(ExecutionContext*, RTCPeerConnection*, RTCSessionDescriptionCallback*, RTCErrorCallback*);
 
     void clear();
 
-    OwnPtrWillBeMember<RTCSessionDescriptionCallback> m_successCallback;
-    OwnPtrWillBeMember<RTCErrorCallback> m_errorCallback;
+    Member<RTCSessionDescriptionCallback> m_successCallback;
+    Member<RTCErrorCallback> m_errorCallback;
     Member<RTCPeerConnection> m_requester;
 };
 
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCStatsCallback.h b/third_party/WebKit/Source/modules/mediastream/RTCStatsCallback.h
index 94651fc..688d4f0 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCStatsCallback.h
+++ b/third_party/WebKit/Source/modules/mediastream/RTCStatsCallback.h
@@ -31,7 +31,7 @@ namespace blink {
 
 class RTCStatsResponse;
 
-class RTCStatsCallback : public NoBaseWillBeGarbageCollectedFinalized<RTCStatsCallback> {
+class RTCStatsCallback : public GarbageCollectedFinalized<RTCStatsCallback> {
 public:
     virtual ~RTCStatsCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.cpp b/third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.cpp
index 56351dd..bd38dfd 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.cpp
@@ -31,14 +31,14 @@
 
 namespace blink {
 
-RTCStatsRequestImpl* RTCStatsRequestImpl::create(ExecutionContext* context, RTCPeerConnection* requester, PassOwnPtrWillBeRawPtr<RTCStatsCallback> callback, MediaStreamTrack* selector)
+RTCStatsRequestImpl* RTCStatsRequestImpl::create(ExecutionContext* context, RTCPeerConnection* requester, RTCStatsCallback* callback, MediaStreamTrack* selector)
 {
     RTCStatsRequestImpl* request = new RTCStatsRequestImpl(context, requester, callback, selector);
     request->suspendIfNeeded();
     return request;
 }
 
-RTCStatsRequestImpl::RTCStatsRequestImpl(ExecutionContext* context, RTCPeerConnection* requester, PassOwnPtrWillBeRawPtr<RTCStatsCallback> callback, MediaStreamTrack* selector)
+RTCStatsRequestImpl::RTCStatsRequestImpl(ExecutionContext* context, RTCPeerConnection* requester, RTCStatsCallback* callback, MediaStreamTrack* selector)
     : ActiveDOMObject(context)
     , m_successCallback(callback)
     , m_component(selector ? selector->component() : 0)
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.h b/third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.h
index 4b5e58c..b0215c6 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.h
+++ b/third_party/WebKit/Source/modules/mediastream/RTCStatsRequestImpl.h
@@ -40,7 +40,7 @@ class RTCStatsCallback;
 
 class RTCStatsRequestImpl FINAL : public RTCStatsRequest, public ActiveDOMObject {
 public:
-    static RTCStatsRequestImpl* create(ExecutionContext*, RTCPeerConnection*, PassOwnPtrWillBeRawPtr<RTCStatsCallback>, MediaStreamTrack*);
+    static RTCStatsRequestImpl* create(ExecutionContext*, RTCPeerConnection*, RTCStatsCallback*, MediaStreamTrack*);
     virtual ~RTCStatsRequestImpl();
 
     virtual RTCStatsResponseBase* createResponse() OVERRIDE;
@@ -55,11 +55,11 @@ public:
     virtual void trace(Visitor*) OVERRIDE;
 
 private:
-    RTCStatsRequestImpl(ExecutionContext*, RTCPeerConnection*, PassOwnPtrWillBeRawPtr<RTCStatsCallback>, MediaStreamTrack*);
+    RTCStatsRequestImpl(ExecutionContext*, RTCPeerConnection*, RTCStatsCallback*, MediaStreamTrack*);
 
     void clear();
 
-    OwnPtrWillBeMember<RTCStatsCallback> m_successCallback;
+    Member<RTCStatsCallback> m_successCallback;
     RefPtr<MediaStreamComponent> m_component;
     Member<RTCPeerConnection> m_requester;
 };
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCVoidRequestImpl.cpp b/third_party/WebKit/Source/modules/mediastream/RTCVoidRequestImpl.cpp
index 8075467..24b0cd1 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCVoidRequestImpl.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/RTCVoidRequestImpl.cpp
@@ -37,14 +37,14 @@
 
 namespace blink {
 
-RTCVoidRequestImpl* RTCVoidRequestImpl::create(ExecutionContext* context, RTCPeerConnection* requester, PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback)
+RTCVoidRequestImpl* RTCVoidRequestImpl::create(ExecutionContext* context, RTCPeerConnection* requester, VoidCallback* successCallback, RTCErrorCallback* errorCallback)
 {
     RTCVoidRequestImpl* request = new RTCVoidRequestImpl(context, requester, successCallback, errorCallback);
     request->suspendIfNeeded();
     return request;
 }
 
-RTCVoidRequestImpl::RTCVoidRequestImpl(ExecutionContext* context, RTCPeerConnection* requester, PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<RTCErrorCallback> errorCallback)
+RTCVoidRequestImpl::RTCVoidRequestImpl(ExecutionContext* context, RTCPeerConnection* requester, VoidCallback* successCallback, RTCErrorCallback* errorCallback)
     : ActiveDOMObject(context)
     , m_successCallback(successCallback)
     , m_errorCallback(errorCallback)
diff --git a/third_party/WebKit/Source/modules/mediastream/RTCVoidRequestImpl.h b/third_party/WebKit/Source/modules/mediastream/RTCVoidRequestImpl.h
index d5b1066..90d82c7 100644
--- a/third_party/WebKit/Source/modules/mediastream/RTCVoidRequestImpl.h
+++ b/third_party/WebKit/Source/modules/mediastream/RTCVoidRequestImpl.h
@@ -43,7 +43,7 @@ class VoidCallback;
 
 class RTCVoidRequestImpl FINAL : public RTCVoidRequest, public ActiveDOMObject {
 public:
-    static RTCVoidRequestImpl* create(ExecutionContext*, RTCPeerConnection*, PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>);
+    static RTCVoidRequestImpl* create(ExecutionContext*, RTCPeerConnection*, VoidCallback*, RTCErrorCallback*);
     virtual ~RTCVoidRequestImpl();
 
     // RTCVoidRequest
@@ -56,12 +56,12 @@ public:
     virtual void trace(Visitor*) OVERRIDE;
 
 private:
-    RTCVoidRequestImpl(ExecutionContext*, RTCPeerConnection*, PassOwnPtrWillBeRawPtr<VoidCallback>, PassOwnPtrWillBeRawPtr<RTCErrorCallback>);
+    RTCVoidRequestImpl(ExecutionContext*, RTCPeerConnection*, VoidCallback*, RTCErrorCallback*);
 
     void clear();
 
-    OwnPtrWillBeMember<VoidCallback> m_successCallback;
-    OwnPtrWillBeMember<RTCErrorCallback> m_errorCallback;
+    Member<VoidCallback> m_successCallback;
+    Member<RTCErrorCallback> m_errorCallback;
     Member<RTCPeerConnection> m_requester;
 };
 
diff --git a/third_party/WebKit/Source/modules/mediastream/UserMediaRequest.cpp b/third_party/WebKit/Source/modules/mediastream/UserMediaRequest.cpp
index b540f67..fbdf3f7 100644
--- a/third_party/WebKit/Source/modules/mediastream/UserMediaRequest.cpp
+++ b/third_party/WebKit/Source/modules/mediastream/UserMediaRequest.cpp
@@ -65,7 +65,7 @@ static WebMediaConstraints parseOptions(const Dictionary& options, const String&
     return constraints;
 }
 
-UserMediaRequest* UserMediaRequest::create(ExecutionContext* context, UserMediaController* controller, const Dictionary& options, PassOwnPtrWillBeRawPtr<NavigatorUserMediaSuccessCallback> successCallback, PassOwnPtrWillBeRawPtr<NavigatorUserMediaErrorCallback> errorCallback, ExceptionState& exceptionState)
+UserMediaRequest* UserMediaRequest::create(ExecutionContext* context, UserMediaController* controller, const Dictionary& options, NavigatorUserMediaSuccessCallback* successCallback, NavigatorUserMediaErrorCallback* errorCallback, ExceptionState& exceptionState)
 {
     WebMediaConstraints audio = parseOptions(options, "audio", exceptionState);
     if (exceptionState.hadException())
@@ -83,7 +83,7 @@ UserMediaRequest* UserMediaRequest::create(ExecutionContext* context, UserMediaC
     return new UserMediaRequest(context, controller, audio, video, successCallback, errorCallback);
 }
 
-UserMediaRequest::UserMediaRequest(ExecutionContext* context, UserMediaController* controller, WebMediaConstraints audio, WebMediaConstraints video, PassOwnPtrWillBeRawPtr<NavigatorUserMediaSuccessCallback> successCallback, PassOwnPtrWillBeRawPtr<NavigatorUserMediaErrorCallback> errorCallback)
+UserMediaRequest::UserMediaRequest(ExecutionContext* context, UserMediaController* controller, WebMediaConstraints audio, WebMediaConstraints video, NavigatorUserMediaSuccessCallback* successCallback, NavigatorUserMediaErrorCallback* errorCallback)
     : ContextLifecycleObserver(context)
     , m_audio(audio)
     , m_video(video)
diff --git a/third_party/WebKit/Source/modules/mediastream/UserMediaRequest.h b/third_party/WebKit/Source/modules/mediastream/UserMediaRequest.h
index c4f2129..824ae87 100644
--- a/third_party/WebKit/Source/modules/mediastream/UserMediaRequest.h
+++ b/third_party/WebKit/Source/modules/mediastream/UserMediaRequest.h
@@ -49,7 +49,7 @@ class UserMediaController;
 
 class UserMediaRequest FINAL : public GarbageCollectedFinalized<UserMediaRequest>, public ContextLifecycleObserver {
 public:
-    static UserMediaRequest* create(ExecutionContext*, UserMediaController*, const Dictionary& options, PassOwnPtrWillBeRawPtr<NavigatorUserMediaSuccessCallback>, PassOwnPtrWillBeRawPtr<NavigatorUserMediaErrorCallback>, ExceptionState&);
+    static UserMediaRequest* create(ExecutionContext*, UserMediaController*, const Dictionary& options, NavigatorUserMediaSuccessCallback*, NavigatorUserMediaErrorCallback*, ExceptionState&);
     virtual ~UserMediaRequest();
 
     NavigatorUserMediaSuccessCallback* successCallback() const { return m_successCallback.get(); }
@@ -74,15 +74,15 @@ public:
     void trace(Visitor*);
 
 private:
-    UserMediaRequest(ExecutionContext*, UserMediaController*, WebMediaConstraints audio, WebMediaConstraints video, PassOwnPtrWillBeRawPtr<NavigatorUserMediaSuccessCallback>, PassOwnPtrWillBeRawPtr<NavigatorUserMediaErrorCallback>);
+    UserMediaRequest(ExecutionContext*, UserMediaController*, WebMediaConstraints audio, WebMediaConstraints video, NavigatorUserMediaSuccessCallback*, NavigatorUserMediaErrorCallback*);
 
     WebMediaConstraints m_audio;
     WebMediaConstraints m_video;
 
     UserMediaController* m_controller;
 
-    OwnPtrWillBeMember<NavigatorUserMediaSuccessCallback> m_successCallback;
-    OwnPtrWillBeMember<NavigatorUserMediaErrorCallback> m_errorCallback;
+    Member<NavigatorUserMediaSuccessCallback> m_successCallback;
+    Member<NavigatorUserMediaErrorCallback> m_errorCallback;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/modules/notifications/Notification.cpp b/third_party/WebKit/Source/modules/notifications/Notification.cpp
index f0964c3..d2ef647 100644
--- a/third_party/WebKit/Source/modules/notifications/Notification.cpp
+++ b/third_party/WebKit/Source/modules/notifications/Notification.cpp
@@ -159,7 +159,7 @@ const String& Notification::permission(ExecutionContext* context)
     return permissionString(NotificationController::clientFrom(context).checkPermission(context));
 }
 
-void Notification::requestPermission(ExecutionContext* context, PassOwnPtrWillBeRawPtr<NotificationPermissionCallback> callback)
+void Notification::requestPermission(ExecutionContext* context, NotificationPermissionCallback* callback)
 {
     // FIXME: Assert that this code-path will only be reached for Document environments
     // when Blink supports [Exposed] annotations on class members in IDL definitions.
diff --git a/third_party/WebKit/Source/modules/notifications/Notification.h b/third_party/WebKit/Source/modules/notifications/Notification.h
index b368a53..69252bd 100644
--- a/third_party/WebKit/Source/modules/notifications/Notification.h
+++ b/third_party/WebKit/Source/modules/notifications/Notification.h
@@ -80,7 +80,7 @@ public:
 
     static const String& permissionString(NotificationClient::Permission);
     static const String& permission(ExecutionContext*);
-    static void requestPermission(ExecutionContext*, PassOwnPtrWillBeRawPtr<NotificationPermissionCallback> = nullptr);
+    static void requestPermission(ExecutionContext*, NotificationPermissionCallback* = nullptr);
 
     // EventTarget interface.
     virtual ExecutionContext* executionContext() const OVERRIDE FINAL { return ActiveDOMObject::executionContext(); }
diff --git a/third_party/WebKit/Source/modules/notifications/NotificationPermissionCallback.h b/third_party/WebKit/Source/modules/notifications/NotificationPermissionCallback.h
index c46eb83..f0ea884 100644
--- a/third_party/WebKit/Source/modules/notifications/NotificationPermissionCallback.h
+++ b/third_party/WebKit/Source/modules/notifications/NotificationPermissionCallback.h
@@ -31,7 +31,7 @@
 
 namespace blink {
 
-class NotificationPermissionCallback : public NoBaseWillBeGarbageCollectedFinalized<NotificationPermissionCallback> {
+class NotificationPermissionCallback : public GarbageCollectedFinalized<NotificationPermissionCallback> {
 public:
     virtual ~NotificationPermissionCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/notifications/NotificationPermissionClient.h b/third_party/WebKit/Source/modules/notifications/NotificationPermissionClient.h
index 29f5650..30d0020 100644
--- a/third_party/WebKit/Source/modules/notifications/NotificationPermissionClient.h
+++ b/third_party/WebKit/Source/modules/notifications/NotificationPermissionClient.h
@@ -21,7 +21,7 @@ public:
     // Requests user permission to show platform notifications from the origin
     // of the current frame. The provided callback will be ran when the user
     // has made a decision.
-    virtual void requestPermission(ExecutionContext*, PassOwnPtrWillBeRawPtr<NotificationPermissionCallback>) = 0;
+    virtual void requestPermission(ExecutionContext*, NotificationPermissionCallback*) = 0;
 
     // WillBeHeapSupplement requirements.
     static const char* supplementName();
diff --git a/third_party/WebKit/Source/modules/quota/DeprecatedStorageInfo.cpp b/third_party/WebKit/Source/modules/quota/DeprecatedStorageInfo.cpp
index 2421616..cb29f42 100644
--- a/third_party/WebKit/Source/modules/quota/DeprecatedStorageInfo.cpp
+++ b/third_party/WebKit/Source/modules/quota/DeprecatedStorageInfo.cpp
@@ -45,7 +45,7 @@ DeprecatedStorageInfo::DeprecatedStorageInfo()
 {
 }
 
-void DeprecatedStorageInfo::queryUsageAndQuota(ExecutionContext* executionContext, int storageType, PassOwnPtrWillBeRawPtr<StorageUsageCallback> successCallback, PassOwnPtrWillBeRawPtr<StorageErrorCallback> errorCallback)
+void DeprecatedStorageInfo::queryUsageAndQuota(ExecutionContext* executionContext, int storageType, StorageUsageCallback* successCallback, StorageErrorCallback* errorCallback)
 {
     // Dispatching the request to DeprecatedStorageQuota, as this interface is deprecated in favor of DeprecatedStorageQuota.
     DeprecatedStorageQuota* storageQuota = getStorageQuota(storageType);
@@ -57,7 +57,7 @@ void DeprecatedStorageInfo::queryUsageAndQuota(ExecutionContext* executionContex
     storageQuota->queryUsageAndQuota(executionContext, successCallback, errorCallback);
 }
 
-void DeprecatedStorageInfo::requestQuota(ExecutionContext* executionContext, int storageType, unsigned long long newQuotaInBytes, PassOwnPtrWillBeRawPtr<StorageQuotaCallback> successCallback, PassOwnPtrWillBeRawPtr<StorageErrorCallback> errorCallback)
+void DeprecatedStorageInfo::requestQuota(ExecutionContext* executionContext, int storageType, unsigned long long newQuotaInBytes, StorageQuotaCallback* successCallback, StorageErrorCallback* errorCallback)
 {
     // Dispatching the request to DeprecatedStorageQuota, as this interface is deprecated in favor of DeprecatedStorageQuota.
     DeprecatedStorageQuota* storageQuota = getStorageQuota(storageType);
diff --git a/third_party/WebKit/Source/modules/quota/DeprecatedStorageInfo.h b/third_party/WebKit/Source/modules/quota/DeprecatedStorageInfo.h
index b434f75a..56d34af 100644
--- a/third_party/WebKit/Source/modules/quota/DeprecatedStorageInfo.h
+++ b/third_party/WebKit/Source/modules/quota/DeprecatedStorageInfo.h
@@ -56,9 +56,9 @@ public:
         return new DeprecatedStorageInfo();
     }
 
-    void queryUsageAndQuota(ExecutionContext*, int storageType, PassOwnPtrWillBeRawPtr<StorageUsageCallback>, PassOwnPtrWillBeRawPtr<StorageErrorCallback>);
+    void queryUsageAndQuota(ExecutionContext*, int storageType, StorageUsageCallback*, StorageErrorCallback*);
 
-    void requestQuota(ExecutionContext*, int storageType, unsigned long long newQuotaInBytes, PassOwnPtrWillBeRawPtr<StorageQuotaCallback>, PassOwnPtrWillBeRawPtr<StorageErrorCallback>);
+    void requestQuota(ExecutionContext*, int storageType, unsigned long long newQuotaInBytes, StorageQuotaCallback*, StorageErrorCallback*);
 
     void trace(Visitor*);
 
diff --git a/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuota.cpp b/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuota.cpp
index 543385c..8282210 100644
--- a/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuota.cpp
+++ b/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuota.cpp
@@ -51,7 +51,7 @@ DeprecatedStorageQuota::DeprecatedStorageQuota(Type type)
 {
 }
 
-void DeprecatedStorageQuota::queryUsageAndQuota(ExecutionContext* executionContext, PassOwnPtrWillBeRawPtr<StorageUsageCallback> successCallback, PassOwnPtrWillBeRawPtr<StorageErrorCallback> errorCallback)
+void DeprecatedStorageQuota::queryUsageAndQuota(ExecutionContext* executionContext, StorageUsageCallback* successCallback, StorageErrorCallback* errorCallback)
 {
     ASSERT(executionContext);
 
@@ -73,7 +73,7 @@ void DeprecatedStorageQuota::queryUsageAndQuota(ExecutionContext* executionConte
     Platform::current()->queryStorageUsageAndQuota(storagePartition, storageType, callbacks.release());
 }
 
-void DeprecatedStorageQuota::requestQuota(ExecutionContext* executionContext, unsigned long long newQuotaInBytes, PassOwnPtrWillBeRawPtr<StorageQuotaCallback> successCallback, PassOwnPtrWillBeRawPtr<StorageErrorCallback> errorCallback)
+void DeprecatedStorageQuota::requestQuota(ExecutionContext* executionContext, unsigned long long newQuotaInBytes, StorageQuotaCallback* successCallback, StorageErrorCallback* errorCallback)
 {
     ASSERT(executionContext);
 
diff --git a/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuota.h b/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuota.h
index 21c6c1e..592563c 100644
--- a/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuota.h
+++ b/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuota.h
@@ -55,9 +55,9 @@ public:
         return new DeprecatedStorageQuota(type);
     }
 
-    void queryUsageAndQuota(ExecutionContext*, PassOwnPtrWillBeRawPtr<StorageUsageCallback>, PassOwnPtrWillBeRawPtr<StorageErrorCallback>);
+    void queryUsageAndQuota(ExecutionContext*, StorageUsageCallback*, StorageErrorCallback*);
 
-    void requestQuota(ExecutionContext*, unsigned long long newQuotaInBytes, PassOwnPtrWillBeRawPtr<StorageQuotaCallback>, PassOwnPtrWillBeRawPtr<StorageErrorCallback>);
+    void requestQuota(ExecutionContext*, unsigned long long newQuotaInBytes, StorageQuotaCallback*, StorageErrorCallback*);
 
     void trace(Visitor*) { }
 
diff --git a/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuotaCallbacksImpl.cpp b/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuotaCallbacksImpl.cpp
index 4d7dd1b..a3992ff 100644
--- a/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuotaCallbacksImpl.cpp
+++ b/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuotaCallbacksImpl.cpp
@@ -36,13 +36,13 @@
 
 namespace blink {
 
-DeprecatedStorageQuotaCallbacksImpl::DeprecatedStorageQuotaCallbacksImpl(PassOwnPtrWillBeRawPtr<StorageUsageCallback> usageCallback, PassOwnPtrWillBeRawPtr<StorageErrorCallback> errorCallback)
+DeprecatedStorageQuotaCallbacksImpl::DeprecatedStorageQuotaCallbacksImpl(StorageUsageCallback* usageCallback, StorageErrorCallback* errorCallback)
     : m_usageCallback(usageCallback)
     , m_errorCallback(errorCallback)
 {
 }
 
-DeprecatedStorageQuotaCallbacksImpl::DeprecatedStorageQuotaCallbacksImpl(PassOwnPtrWillBeRawPtr<StorageQuotaCallback> quotaCallback, PassOwnPtrWillBeRawPtr<StorageErrorCallback> errorCallback)
+DeprecatedStorageQuotaCallbacksImpl::DeprecatedStorageQuotaCallbacksImpl(StorageQuotaCallback* quotaCallback, StorageErrorCallback* errorCallback)
     : m_quotaCallback(quotaCallback)
     , m_errorCallback(errorCallback)
 {
diff --git a/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuotaCallbacksImpl.h b/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuotaCallbacksImpl.h
index fd25cf7..8cf9525 100644
--- a/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuotaCallbacksImpl.h
+++ b/third_party/WebKit/Source/modules/quota/DeprecatedStorageQuotaCallbacksImpl.h
@@ -43,12 +43,12 @@ namespace blink {
 
 class DeprecatedStorageQuotaCallbacksImpl FINAL : public StorageQuotaCallbacks {
 public:
-    static PassOwnPtrWillBeRawPtr<DeprecatedStorageQuotaCallbacksImpl> create(PassOwnPtrWillBeRawPtr<StorageUsageCallback> success, PassOwnPtrWillBeRawPtr<StorageErrorCallback> error)
+    static PassOwnPtrWillBeRawPtr<DeprecatedStorageQuotaCallbacksImpl> create(StorageUsageCallback* success, StorageErrorCallback* error)
     {
         return adoptPtrWillBeNoop(new DeprecatedStorageQuotaCallbacksImpl(success, error));
     }
 
-    static PassOwnPtrWillBeRawPtr<DeprecatedStorageQuotaCallbacksImpl> create(PassOwnPtrWillBeRawPtr<StorageQuotaCallback> success, PassOwnPtrWillBeRawPtr<StorageErrorCallback> error)
+    static PassOwnPtrWillBeRawPtr<DeprecatedStorageQuotaCallbacksImpl> create(StorageQuotaCallback* success, StorageErrorCallback* error)
     {
         return adoptPtrWillBeNoop(new DeprecatedStorageQuotaCallbacksImpl(success, error));
     }
@@ -61,12 +61,12 @@ public:
     virtual void didFail(WebStorageQuotaError) OVERRIDE;
 
 private:
-    DeprecatedStorageQuotaCallbacksImpl(PassOwnPtrWillBeRawPtr<StorageUsageCallback>, PassOwnPtrWillBeRawPtr<StorageErrorCallback>);
-    DeprecatedStorageQuotaCallbacksImpl(PassOwnPtrWillBeRawPtr<StorageQuotaCallback>, PassOwnPtrWillBeRawPtr<StorageErrorCallback>);
+    DeprecatedStorageQuotaCallbacksImpl(StorageUsageCallback*, StorageErrorCallback*);
+    DeprecatedStorageQuotaCallbacksImpl(StorageQuotaCallback*, StorageErrorCallback*);
 
-    OwnPtrWillBeMember<StorageUsageCallback> m_usageCallback;
-    OwnPtrWillBeMember<StorageQuotaCallback> m_quotaCallback;
-    OwnPtrWillBeMember<StorageErrorCallback> m_errorCallback;
+    PersistentWillBeMember<StorageUsageCallback> m_usageCallback;
+    PersistentWillBeMember<StorageQuotaCallback> m_quotaCallback;
+    PersistentWillBeMember<StorageErrorCallback> m_errorCallback;
 };
 
 } // namespace blink
diff --git a/third_party/WebKit/Source/modules/quota/StorageErrorCallback.cpp b/third_party/WebKit/Source/modules/quota/StorageErrorCallback.cpp
index 94d6ca3..cbb49d4 100644
--- a/third_party/WebKit/Source/modules/quota/StorageErrorCallback.cpp
+++ b/third_party/WebKit/Source/modules/quota/StorageErrorCallback.cpp
@@ -36,7 +36,7 @@
 
 namespace blink {
 
-StorageErrorCallback::CallbackTask::CallbackTask(PassOwnPtrWillBeRawPtr<StorageErrorCallback> callback, ExceptionCode ec)
+StorageErrorCallback::CallbackTask::CallbackTask(StorageErrorCallback* callback, ExceptionCode ec)
     : m_callback(callback)
     , m_ec(ec)
 {
diff --git a/third_party/WebKit/Source/modules/quota/StorageErrorCallback.h b/third_party/WebKit/Source/modules/quota/StorageErrorCallback.h
index b5d0d79..1b40da9 100644
--- a/third_party/WebKit/Source/modules/quota/StorageErrorCallback.h
+++ b/third_party/WebKit/Source/modules/quota/StorageErrorCallback.h
@@ -42,7 +42,7 @@ class DOMError;
 
 typedef int ExceptionCode;
 
-class StorageErrorCallback : public NoBaseWillBeGarbageCollectedFinalized<StorageErrorCallback> {
+class StorageErrorCallback : public GarbageCollectedFinalized<StorageErrorCallback> {
 public:
     virtual ~StorageErrorCallback() { }
     virtual void trace(Visitor*) { }
@@ -50,7 +50,7 @@ public:
 
     class CallbackTask FINAL : public ExecutionContextTask {
     public:
-        static PassOwnPtr<CallbackTask> create(PassOwnPtrWillBeRawPtr<StorageErrorCallback> callback, ExceptionCode ec)
+        static PassOwnPtr<CallbackTask> create(StorageErrorCallback* callback, ExceptionCode ec)
         {
             return adoptPtr(new CallbackTask(callback, ec));
         }
@@ -58,9 +58,9 @@ public:
         virtual void performTask(ExecutionContext*) OVERRIDE;
 
     private:
-        CallbackTask(PassOwnPtrWillBeRawPtr<StorageErrorCallback>, ExceptionCode);
+        CallbackTask(StorageErrorCallback*, ExceptionCode);
 
-        OwnPtrWillBePersistent<StorageErrorCallback> m_callback;
+        Persistent<StorageErrorCallback> m_callback;
         ExceptionCode m_ec;
     };
 };
diff --git a/third_party/WebKit/Source/modules/quota/StorageQuotaCallback.h b/third_party/WebKit/Source/modules/quota/StorageQuotaCallback.h
index 1a81849..1979f94 100644
--- a/third_party/WebKit/Source/modules/quota/StorageQuotaCallback.h
+++ b/third_party/WebKit/Source/modules/quota/StorageQuotaCallback.h
@@ -35,7 +35,7 @@
 
 namespace blink {
 
-class StorageQuotaCallback : public NoBaseWillBeGarbageCollectedFinalized<StorageQuotaCallback> {
+class StorageQuotaCallback : public GarbageCollectedFinalized<StorageQuotaCallback> {
 public:
     virtual ~StorageQuotaCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/quota/StorageQuotaClient.h b/third_party/WebKit/Source/modules/quota/StorageQuotaClient.h
index 20551d6..b0c1798 100644
--- a/third_party/WebKit/Source/modules/quota/StorageQuotaClient.h
+++ b/third_party/WebKit/Source/modules/quota/StorageQuotaClient.h
@@ -51,7 +51,7 @@ public:
     StorageQuotaClient() { }
     virtual ~StorageQuotaClient() { }
 
-    virtual void requestQuota(ExecutionContext*, WebStorageQuotaType, unsigned long long newQuotaInBytes, PassOwnPtrWillBeRawPtr<StorageQuotaCallback>, PassOwnPtrWillBeRawPtr<StorageErrorCallback>) = 0;
+    virtual void requestQuota(ExecutionContext*, WebStorageQuotaType, unsigned long long newQuotaInBytes, StorageQuotaCallback*, StorageErrorCallback*) = 0;
     virtual ScriptPromise requestPersistentQuota(ScriptState*, unsigned long long newQuotaInBytes) = 0;
 
     static const char* supplementName();
diff --git a/third_party/WebKit/Source/modules/quota/StorageUsageCallback.h b/third_party/WebKit/Source/modules/quota/StorageUsageCallback.h
index bbd4703..24a6cfd 100644
--- a/third_party/WebKit/Source/modules/quota/StorageUsageCallback.h
+++ b/third_party/WebKit/Source/modules/quota/StorageUsageCallback.h
@@ -35,7 +35,7 @@
 
 namespace blink {
 
-class StorageUsageCallback : public NoBaseWillBeGarbageCollectedFinalized<StorageUsageCallback> {
+class StorageUsageCallback : public GarbageCollectedFinalized<StorageUsageCallback> {
 public:
     virtual ~StorageUsageCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/serviceworkers/Headers.cpp b/third_party/WebKit/Source/modules/serviceworkers/Headers.cpp
index ea86990d..664ea21 100644
--- a/third_party/WebKit/Source/modules/serviceworkers/Headers.cpp
+++ b/third_party/WebKit/Source/modules/serviceworkers/Headers.cpp
@@ -208,12 +208,12 @@ void Headers::set(const String& name, const String& value, ExceptionState& excep
     m_headerList->set(name, value);
 }
 
-void Headers::forEach(PassOwnPtrWillBeRawPtr<HeadersForEachCallback> callback, const ScriptValue& thisArg)
+void Headers::forEach(HeadersForEachCallback* callback, const ScriptValue& thisArg)
 {
     forEachInternal(callback, &thisArg);
 }
 
-void Headers::forEach(PassOwnPtrWillBeRawPtr<HeadersForEachCallback> callback)
+void Headers::forEach(HeadersForEachCallback* callback)
 {
     forEachInternal(callback, 0);
 }
@@ -305,7 +305,7 @@ Headers::Headers(FetchHeaderList* headerList)
 {
 }
 
-void Headers::forEachInternal(PassOwnPtrWillBeRawPtr<HeadersForEachCallback> callback, const ScriptValue* thisArg)
+void Headers::forEachInternal(HeadersForEachCallback* callback, const ScriptValue* thisArg)
 {
     TrackExceptionState exceptionState;
     for (size_t i = 0; i < m_headerList->size(); ++i) {
diff --git a/third_party/WebKit/Source/modules/serviceworkers/Headers.h b/third_party/WebKit/Source/modules/serviceworkers/Headers.h
index 7234dc8..48f0632 100644
--- a/third_party/WebKit/Source/modules/serviceworkers/Headers.h
+++ b/third_party/WebKit/Source/modules/serviceworkers/Headers.h
@@ -41,8 +41,8 @@ public:
     bool has(const String& key, ExceptionState&);
     void set(const String& key, const String& value, ExceptionState&);
     unsigned long size() const;
-    void forEach(PassOwnPtrWillBeRawPtr<HeadersForEachCallback>, const ScriptValue&);
-    void forEach(PassOwnPtrWillBeRawPtr<HeadersForEachCallback>);
+    void forEach(HeadersForEachCallback*, const ScriptValue&);
+    void forEach(HeadersForEachCallback*);
 
     void setGuard(Guard guard) { m_guard = guard; }
     Guard guard() const { return m_guard; }
@@ -57,7 +57,7 @@ private:
     Headers();
     // Shares the FetchHeaderList. Called when creating a Request or Response.
     explicit Headers(FetchHeaderList*);
-    void forEachInternal(PassOwnPtrWillBeRawPtr<HeadersForEachCallback>, const ScriptValue*);
+    void forEachInternal(HeadersForEachCallback*, const ScriptValue*);
 
     Member<FetchHeaderList> m_headerList;
     Guard m_guard;
diff --git a/third_party/WebKit/Source/modules/serviceworkers/HeadersForEachCallback.h b/third_party/WebKit/Source/modules/serviceworkers/HeadersForEachCallback.h
index 60fe225..285fdef 100644
--- a/third_party/WebKit/Source/modules/serviceworkers/HeadersForEachCallback.h
+++ b/third_party/WebKit/Source/modules/serviceworkers/HeadersForEachCallback.h
@@ -12,7 +12,7 @@ namespace blink {
 
 class Headers;
 
-class HeadersForEachCallback : public NoBaseWillBeGarbageCollectedFinalized<HeadersForEachCallback> {
+class HeadersForEachCallback : public GarbageCollectedFinalized<HeadersForEachCallback> {
 public:
     virtual ~HeadersForEachCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/serviceworkers/Request.cpp b/third_party/WebKit/Source/modules/serviceworkers/Request.cpp
index 04320a4..1e9d1a5 100644
--- a/third_party/WebKit/Source/modules/serviceworkers/Request.cpp
+++ b/third_party/WebKit/Source/modules/serviceworkers/Request.cpp
@@ -328,7 +328,7 @@ void Request::populateWebServiceWorkerRequest(WebServiceWorkerRequest& webReques
 {
     webRequest.setMethod(method());
     webRequest.setURL(m_request->url());
-    m_headers->forEach(adoptPtrWillBeNoop(new FillWebRequestHeaders(&webRequest)));
+    m_headers->forEach(new FillWebRequestHeaders(&webRequest));
     webRequest.setReferrer(m_request->referrer().referrer().referrer, static_cast<WebReferrerPolicy>(m_request->referrer().referrer().referrerPolicy));
     // FIXME: How can we set isReload properly? What is the correct place to load it in to the Request object? We should investigate the right way
     // to plumb this information in to here.
diff --git a/third_party/WebKit/Source/modules/webaudio/AsyncAudioDecoder.cpp b/third_party/WebKit/Source/modules/webaudio/AsyncAudioDecoder.cpp
index e36c9ca..5e7701f 100644
--- a/third_party/WebKit/Source/modules/webaudio/AsyncAudioDecoder.cpp
+++ b/third_party/WebKit/Source/modules/webaudio/AsyncAudioDecoder.cpp
@@ -49,7 +49,7 @@ AsyncAudioDecoder::~AsyncAudioDecoder()
 {
 }
 
-void AsyncAudioDecoder::decodeAsync(ArrayBuffer* audioData, float sampleRate, PassOwnPtrWillBeRawPtr<AudioBufferCallback> successCallback, PassOwnPtrWillBeRawPtr<AudioBufferCallback> errorCallback)
+void AsyncAudioDecoder::decodeAsync(ArrayBuffer* audioData, float sampleRate, AudioBufferCallback* successCallback, AudioBufferCallback* errorCallback)
 {
     ASSERT(isMainThread());
     ASSERT(audioData);
@@ -60,7 +60,7 @@ void AsyncAudioDecoder::decodeAsync(ArrayBuffer* audioData, float sampleRate, Pa
     RefPtr<ArrayBuffer> audioDataRef(audioData);
 
     // The leak references to successCallback and errorCallback are picked up on notifyComplete.
-    m_thread->postTask(new Task(WTF::bind(&AsyncAudioDecoder::decode, audioDataRef.release().leakRef(), sampleRate, successCallback.leakPtr(), errorCallback.leakPtr())));
+    m_thread->postTask(new Task(WTF::bind(&AsyncAudioDecoder::decode, audioDataRef.release().leakRef(), sampleRate, successCallback, errorCallback)));
 }
 
 void AsyncAudioDecoder::decode(ArrayBuffer* audioData, float sampleRate, AudioBufferCallback* successCallback, AudioBufferCallback* errorCallback)
@@ -76,10 +76,6 @@ void AsyncAudioDecoder::notifyComplete(ArrayBuffer* audioData, AudioBufferCallba
 {
     // Adopt references, so everything gets correctly dereffed.
     RefPtr<ArrayBuffer> audioDataRef = adoptRef(audioData);
-#if !ENABLE(OILPAN)
-    OwnPtr<AudioBufferCallback> successCallbackPtr = adoptPtr(successCallback);
-    OwnPtr<AudioBufferCallback> errorCallbackPtr = adoptPtr(errorCallback);
-#endif
     RefPtr<AudioBus> audioBusRef = adoptRef(audioBus);
 
     AudioBuffer* audioBuffer = AudioBuffer::createFromAudioBus(audioBus);
diff --git a/third_party/WebKit/Source/modules/webaudio/AsyncAudioDecoder.h b/third_party/WebKit/Source/modules/webaudio/AsyncAudioDecoder.h
index 93d2fbc..3187b46 100644
--- a/third_party/WebKit/Source/modules/webaudio/AsyncAudioDecoder.h
+++ b/third_party/WebKit/Source/modules/webaudio/AsyncAudioDecoder.h
@@ -46,7 +46,7 @@ public:
     ~AsyncAudioDecoder();
 
     // Must be called on the main thread.
-    void decodeAsync(ArrayBuffer* audioData, float sampleRate, PassOwnPtrWillBeRawPtr<AudioBufferCallback> successCallback, PassOwnPtrWillBeRawPtr<AudioBufferCallback> errorCallback);
+    void decodeAsync(ArrayBuffer* audioData, float sampleRate, AudioBufferCallback* successCallback, AudioBufferCallback* errorCallback);
 
 private:
     AudioBuffer* createAudioBufferFromAudioBus(AudioBus*);
diff --git a/third_party/WebKit/Source/modules/webaudio/AudioBufferCallback.h b/third_party/WebKit/Source/modules/webaudio/AudioBufferCallback.h
index 098a335..2dc542d 100644
--- a/third_party/WebKit/Source/modules/webaudio/AudioBufferCallback.h
+++ b/third_party/WebKit/Source/modules/webaudio/AudioBufferCallback.h
@@ -33,7 +33,7 @@ namespace blink {
 
 class AudioBuffer;
 
-class AudioBufferCallback : public NoBaseWillBeGarbageCollectedFinalized<AudioBufferCallback> {
+class AudioBufferCallback : public GarbageCollectedFinalized<AudioBufferCallback> {
 public:
     virtual ~AudioBufferCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/webaudio/AudioContext.cpp b/third_party/WebKit/Source/modules/webaudio/AudioContext.cpp
index 68dc0a3..646be22 100644
--- a/third_party/WebKit/Source/modules/webaudio/AudioContext.cpp
+++ b/third_party/WebKit/Source/modules/webaudio/AudioContext.cpp
@@ -234,7 +234,7 @@ AudioBuffer* AudioContext::createBuffer(unsigned numberOfChannels, size_t number
     return AudioBuffer::create(numberOfChannels, numberOfFrames, sampleRate, exceptionState);
 }
 
-void AudioContext::decodeAudioData(ArrayBuffer* audioData, PassOwnPtrWillBeRawPtr<AudioBufferCallback> successCallback, PassOwnPtrWillBeRawPtr<AudioBufferCallback> errorCallback, ExceptionState& exceptionState)
+void AudioContext::decodeAudioData(ArrayBuffer* audioData, AudioBufferCallback* successCallback, AudioBufferCallback* errorCallback, ExceptionState& exceptionState)
 {
     if (!audioData) {
         exceptionState.throwDOMException(
diff --git a/third_party/WebKit/Source/modules/webaudio/AudioContext.h b/third_party/WebKit/Source/modules/webaudio/AudioContext.h
index 7f5b649..f37fd04 100644
--- a/third_party/WebKit/Source/modules/webaudio/AudioContext.h
+++ b/third_party/WebKit/Source/modules/webaudio/AudioContext.h
@@ -99,7 +99,7 @@ public:
     AudioBuffer* createBuffer(unsigned numberOfChannels, size_t numberOfFrames, float sampleRate, ExceptionState&);
 
     // Asynchronous audio file data decoding.
-    void decodeAudioData(ArrayBuffer*, PassOwnPtrWillBeRawPtr<AudioBufferCallback>, PassOwnPtrWillBeRawPtr<AudioBufferCallback>, ExceptionState&);
+    void decodeAudioData(ArrayBuffer*, AudioBufferCallback*, AudioBufferCallback*, ExceptionState&);
 
     AudioListener* listener() { return m_listener.get(); }
 
diff --git a/third_party/WebKit/Source/modules/webdatabase/DOMWindowWebDatabase.cpp b/third_party/WebKit/Source/modules/webdatabase/DOMWindowWebDatabase.cpp
index 591e016..960d71d 100644
--- a/third_party/WebKit/Source/modules/webdatabase/DOMWindowWebDatabase.cpp
+++ b/third_party/WebKit/Source/modules/webdatabase/DOMWindowWebDatabase.cpp
@@ -40,7 +40,7 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<Database> DOMWindowWebDatabase::openDatabase(LocalDOMWindow& window, const String& name, const String& version, const String& displayName, unsigned long estimatedSize, PassOwnPtrWillBeRawPtr<DatabaseCallback> creationCallback, ExceptionState& exceptionState)
+PassRefPtrWillBeRawPtr<Database> DOMWindowWebDatabase::openDatabase(LocalDOMWindow& window, const String& name, const String& version, const String& displayName, unsigned long estimatedSize, DatabaseCallback* creationCallback, ExceptionState& exceptionState)
 {
     if (!window.isCurrentlyDisplayedInFrame())
         return nullptr;
diff --git a/third_party/WebKit/Source/modules/webdatabase/DOMWindowWebDatabase.h b/third_party/WebKit/Source/modules/webdatabase/DOMWindowWebDatabase.h
index 5068074..7f1ae23 100644
--- a/third_party/WebKit/Source/modules/webdatabase/DOMWindowWebDatabase.h
+++ b/third_party/WebKit/Source/modules/webdatabase/DOMWindowWebDatabase.h
@@ -41,7 +41,7 @@ class LocalFrame;
 
 class DOMWindowWebDatabase {
 public:
-    static PassRefPtrWillBeRawPtr<Database> openDatabase(LocalDOMWindow&, const String& name, const String& version, const String& displayName, unsigned long estimatedSize, PassOwnPtrWillBeRawPtr<DatabaseCallback> creationCallback, ExceptionState&);
+    static PassRefPtrWillBeRawPtr<Database> openDatabase(LocalDOMWindow&, const String& name, const String& version, const String& displayName, unsigned long estimatedSize, DatabaseCallback* creationCallback, ExceptionState&);
 
 private:
     DOMWindowWebDatabase() { };
diff --git a/third_party/WebKit/Source/modules/webdatabase/Database.cpp b/third_party/WebKit/Source/modules/webdatabase/Database.cpp
index dedc365..869cd01 100644
--- a/third_party/WebKit/Source/modules/webdatabase/Database.cpp
+++ b/third_party/WebKit/Source/modules/webdatabase/Database.cpp
@@ -792,40 +792,40 @@ void Database::closeImmediately()
 void Database::changeVersion(
     const String& oldVersion,
     const String& newVersion,
-    PassOwnPtrWillBeRawPtr<SQLTransactionCallback> callback,
-    PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback,
-    PassOwnPtrWillBeRawPtr<VoidCallback> successCallback)
+    SQLTransactionCallback* callback,
+    SQLTransactionErrorCallback* errorCallback,
+    VoidCallback* successCallback)
 {
     ChangeVersionData data(oldVersion, newVersion);
     runTransaction(callback, errorCallback, successCallback, false, &data);
 }
 
 void Database::transaction(
-    PassOwnPtrWillBeRawPtr<SQLTransactionCallback> callback,
-    PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback,
-    PassOwnPtrWillBeRawPtr<VoidCallback> successCallback)
+    SQLTransactionCallback* callback,
+    SQLTransactionErrorCallback* errorCallback,
+    VoidCallback* successCallback)
 {
     runTransaction(callback, errorCallback, successCallback, false);
 }
 
 void Database::readTransaction(
-    PassOwnPtrWillBeRawPtr<SQLTransactionCallback> callback,
-    PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback,
-    PassOwnPtrWillBeRawPtr<VoidCallback> successCallback)
+    SQLTransactionCallback* callback,
+    SQLTransactionErrorCallback* errorCallback,
+    VoidCallback* successCallback)
 {
     runTransaction(callback, errorCallback, successCallback, true);
 }
 
-static void callTransactionErrorCallback(ExecutionContext*, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> callback, PassOwnPtr<SQLErrorData> errorData)
+static void callTransactionErrorCallback(ExecutionContext*, SQLTransactionErrorCallback* callback, PassOwnPtr<SQLErrorData> errorData)
 {
     RefPtrWillBeRawPtr<SQLError> error = SQLError::create(*errorData);
     callback->handleEvent(error.get());
 }
 
 void Database::runTransaction(
-    PassOwnPtrWillBeRawPtr<SQLTransactionCallback> callback,
-    PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback,
-    PassOwnPtrWillBeRawPtr<VoidCallback> successCallback,
+    SQLTransactionCallback* callback,
+    SQLTransactionErrorCallback* errorCallback,
+    VoidCallback* successCallback,
     bool readOnly,
     const ChangeVersionData* changeVersionData)
 {
@@ -834,16 +834,16 @@ void Database::runTransaction(
     // into Database so that we only create the SQLTransaction if we're
     // actually going to run it.
 #if ENABLE(ASSERT)
-    SQLTransactionErrorCallback* originalErrorCallback = errorCallback.get();
+    SQLTransactionErrorCallback* originalErrorCallback = errorCallback;
 #endif
     RefPtrWillBeRawPtr<SQLTransaction> transaction = SQLTransaction::create(this, callback, successCallback, errorCallback, readOnly);
     RefPtrWillBeRawPtr<SQLTransactionBackend> transactionBackend = runTransaction(transaction, readOnly, changeVersionData);
     if (!transactionBackend) {
-        OwnPtrWillBeRawPtr<SQLTransactionErrorCallback> callback = transaction->releaseErrorCallback();
+        SQLTransactionErrorCallback* callback = transaction->releaseErrorCallback();
         ASSERT(callback == originalErrorCallback);
         if (callback) {
             OwnPtr<SQLErrorData> error = SQLErrorData::create(SQLError::UNKNOWN_ERR, "database has been closed");
-            executionContext()->postTask(createCrossThreadTask(&callTransactionErrorCallback, callback.release(), error.release()));
+            executionContext()->postTask(createCrossThreadTask(&callTransactionErrorCallback, callback, error.release()));
         }
     }
 }
diff --git a/third_party/WebKit/Source/modules/webdatabase/Database.h b/third_party/WebKit/Source/modules/webdatabase/Database.h
index 71cd236..a9f7f03 100644
--- a/third_party/WebKit/Source/modules/webdatabase/Database.h
+++ b/third_party/WebKit/Source/modules/webdatabase/Database.h
@@ -70,17 +70,17 @@ public:
     void changeVersion(
         const String& oldVersion,
         const String& newVersion,
-        PassOwnPtrWillBeRawPtr<SQLTransactionCallback>,
-        PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback>,
-        PassOwnPtrWillBeRawPtr<VoidCallback> successCallback);
+        SQLTransactionCallback*,
+        SQLTransactionErrorCallback*,
+        VoidCallback* successCallback);
     void transaction(
-        PassOwnPtrWillBeRawPtr<SQLTransactionCallback>,
-        PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback>,
-        PassOwnPtrWillBeRawPtr<VoidCallback> successCallback);
+        SQLTransactionCallback*,
+        SQLTransactionErrorCallback*,
+        VoidCallback* successCallback);
     void readTransaction(
-        PassOwnPtrWillBeRawPtr<SQLTransactionCallback>,
-        PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback>,
-        PassOwnPtrWillBeRawPtr<VoidCallback> successCallback);
+        SQLTransactionCallback*,
+        SQLTransactionErrorCallback*,
+        VoidCallback* successCallback);
 
     bool opened() const { return m_opened; }
     bool isNew() const { return m_new; }
@@ -132,9 +132,9 @@ private:
     bool getActualVersionForTransaction(String& version);
 
     void runTransaction(
-        PassOwnPtrWillBeRawPtr<SQLTransactionCallback>,
-        PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback>,
-        PassOwnPtrWillBeRawPtr<VoidCallback> successCallback,
+        SQLTransactionCallback*,
+        SQLTransactionErrorCallback*,
+        VoidCallback* successCallback,
         bool readOnly,
         const ChangeVersionData* = 0);
     Vector<String> performGetTableNames();
diff --git a/third_party/WebKit/Source/modules/webdatabase/DatabaseCallback.h b/third_party/WebKit/Source/modules/webdatabase/DatabaseCallback.h
index 24d6c6d..32f4bde 100644
--- a/third_party/WebKit/Source/modules/webdatabase/DatabaseCallback.h
+++ b/third_party/WebKit/Source/modules/webdatabase/DatabaseCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class Database;
 
-class DatabaseCallback : public NoBaseWillBeGarbageCollectedFinalized<DatabaseCallback> {
+class DatabaseCallback : public GarbageCollectedFinalized<DatabaseCallback> {
 public:
     virtual ~DatabaseCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/webdatabase/DatabaseManager.cpp b/third_party/WebKit/Source/modules/webdatabase/DatabaseManager.cpp
index b7130a9..e3e0953 100644
--- a/third_party/WebKit/Source/modules/webdatabase/DatabaseManager.cpp
+++ b/third_party/WebKit/Source/modules/webdatabase/DatabaseManager.cpp
@@ -65,7 +65,7 @@ DatabaseManager::~DatabaseManager()
 
 class DatabaseCreationCallbackTask FINAL : public ExecutionContextTask {
 public:
-    static PassOwnPtr<DatabaseCreationCallbackTask> create(PassRefPtrWillBeRawPtr<Database> database, PassOwnPtrWillBeRawPtr<DatabaseCallback> creationCallback)
+    static PassOwnPtr<DatabaseCreationCallbackTask> create(PassRefPtrWillBeRawPtr<Database> database, DatabaseCallback* creationCallback)
     {
         return adoptPtr(new DatabaseCreationCallbackTask(database, creationCallback));
     }
@@ -76,14 +76,14 @@ public:
     }
 
 private:
-    DatabaseCreationCallbackTask(PassRefPtrWillBeRawPtr<Database> database, PassOwnPtrWillBeRawPtr<DatabaseCallback> callback)
+    DatabaseCreationCallbackTask(PassRefPtrWillBeRawPtr<Database> database, DatabaseCallback* callback)
         : m_database(database)
         , m_creationCallback(callback)
     {
     }
 
     RefPtrWillBePersistent<Database> m_database;
-    OwnPtrWillBePersistent<DatabaseCallback> m_creationCallback;
+    Persistent<DatabaseCallback> m_creationCallback;
 };
 
 DatabaseContext* DatabaseManager::existingDatabaseContextFor(ExecutionContext* context)
@@ -189,7 +189,7 @@ PassRefPtrWillBeRawPtr<Database> DatabaseManager::openDatabaseInternal(Execution
 
 PassRefPtrWillBeRawPtr<Database> DatabaseManager::openDatabase(ExecutionContext* context,
     const String& name, const String& expectedVersion, const String& displayName,
-    unsigned long estimatedSize, PassOwnPtrWillBeRawPtr<DatabaseCallback> creationCallback,
+    unsigned long estimatedSize, DatabaseCallback* creationCallback,
     DatabaseError& error, String& errorMessage)
 {
     ASSERT(error == DatabaseError::None);
@@ -203,7 +203,7 @@ PassRefPtrWillBeRawPtr<Database> DatabaseManager::openDatabase(ExecutionContext*
     databaseContextFor(context)->setHasOpenDatabases();
     DatabaseClient::from(context)->didOpenDatabase(database, context->securityOrigin()->host(), name, expectedVersion);
 
-    if (database->isNew() && creationCallback.get()) {
+    if (database->isNew() && creationCallback) {
         WTF_LOG(StorageAPI, "Scheduling DatabaseCreationCallbackTask for database %p\n", database.get());
         database->executionContext()->postTask(DatabaseCreationCallbackTask::create(database, creationCallback));
     }
diff --git a/third_party/WebKit/Source/modules/webdatabase/DatabaseManager.h b/third_party/WebKit/Source/modules/webdatabase/DatabaseManager.h
index 59ccd03..12d4c0a 100644
--- a/third_party/WebKit/Source/modules/webdatabase/DatabaseManager.h
+++ b/third_party/WebKit/Source/modules/webdatabase/DatabaseManager.h
@@ -63,7 +63,7 @@ public:
 
     static void throwExceptionForDatabaseError(DatabaseError, const String& errorMessage, ExceptionState&);
 
-    PassRefPtrWillBeRawPtr<Database> openDatabase(ExecutionContext*, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, PassOwnPtrWillBeRawPtr<DatabaseCallback>, DatabaseError&, String& errorMessage);
+    PassRefPtrWillBeRawPtr<Database> openDatabase(ExecutionContext*, const String& name, const String& expectedVersion, const String& displayName, unsigned long estimatedSize, DatabaseCallback*, DatabaseError&, String& errorMessage);
 
     String fullPathForDatabase(SecurityOrigin*, const String& name, bool createIfDoesNotExist = true);
 
diff --git a/third_party/WebKit/Source/modules/webdatabase/InspectorDatabaseAgent.cpp b/third_party/WebKit/Source/modules/webdatabase/InspectorDatabaseAgent.cpp
index c1dee6a..cb7817d 100644
--- a/third_party/WebKit/Source/modules/webdatabase/InspectorDatabaseAgent.cpp
+++ b/third_party/WebKit/Source/modules/webdatabase/InspectorDatabaseAgent.cpp
@@ -69,9 +69,9 @@ void reportTransactionFailed(ExecuteSQLCallback* requestCallback, SQLError* erro
 
 class StatementCallback FINAL : public SQLStatementCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<StatementCallback> create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
+    static StatementCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
-        return adoptPtrWillBeNoop(new StatementCallback(requestCallback));
+        return new StatementCallback(requestCallback);
     }
 
     virtual ~StatementCallback() { }
@@ -113,9 +113,9 @@ private:
 
 class StatementErrorCallback FINAL : public SQLStatementErrorCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<StatementErrorCallback> create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
+    static StatementErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
-        return adoptPtrWillBeNoop(new StatementErrorCallback(requestCallback));
+        return new StatementErrorCallback(requestCallback);
     }
 
     virtual ~StatementErrorCallback() { }
@@ -140,9 +140,9 @@ private:
 
 class TransactionCallback FINAL : public SQLTransactionCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<TransactionCallback> create(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
+    static TransactionCallback* create(const String& sqlStatement, PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
-        return adoptPtrWillBeNoop(new TransactionCallback(sqlStatement, requestCallback));
+        return new TransactionCallback(sqlStatement, requestCallback);
     }
 
     virtual ~TransactionCallback() { }
@@ -159,9 +159,9 @@ public:
             return true;
 
         Vector<SQLValue> sqlValues;
-        OwnPtrWillBeRawPtr<SQLStatementCallback> callback(StatementCallback::create(m_requestCallback.get()));
-        OwnPtrWillBeRawPtr<SQLStatementErrorCallback> errorCallback(StatementErrorCallback::create(m_requestCallback.get()));
-        transaction->executeSQL(m_sqlStatement, sqlValues, callback.release(), errorCallback.release(), IGNORE_EXCEPTION);
+        SQLStatementCallback* callback = StatementCallback::create(m_requestCallback.get());
+        SQLStatementErrorCallback* errorCallback = StatementErrorCallback::create(m_requestCallback.get());
+        transaction->executeSQL(m_sqlStatement, sqlValues, callback, errorCallback, IGNORE_EXCEPTION);
         return true;
     }
 private:
@@ -174,9 +174,9 @@ private:
 
 class TransactionErrorCallback FINAL : public SQLTransactionErrorCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<TransactionErrorCallback> create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
+    static TransactionErrorCallback* create(PassRefPtrWillBeRawPtr<ExecuteSQLCallback> requestCallback)
     {
-        return adoptPtrWillBeNoop(new TransactionErrorCallback(requestCallback));
+        return new TransactionErrorCallback(requestCallback);
     }
 
     virtual ~TransactionErrorCallback() { }
@@ -200,9 +200,9 @@ private:
 
 class TransactionSuccessCallback FINAL : public VoidCallback {
 public:
-    static PassOwnPtrWillBeRawPtr<TransactionSuccessCallback> create()
+    static TransactionSuccessCallback* create()
     {
-        return adoptPtrWillBeNoop(new TransactionSuccessCallback());
+        return new TransactionSuccessCallback();
     }
 
     virtual ~TransactionSuccessCallback() { }
@@ -314,10 +314,10 @@ void InspectorDatabaseAgent::executeSQL(ErrorString*, const String& databaseId,
         return;
     }
 
-    OwnPtrWillBeRawPtr<SQLTransactionCallback> callback(TransactionCallback::create(query, requestCallback.get()));
-    OwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback(TransactionErrorCallback::create(requestCallback.get()));
-    OwnPtrWillBeRawPtr<VoidCallback> successCallback(TransactionSuccessCallback::create());
-    database->transaction(callback.release(), errorCallback.release(), successCallback.release());
+    SQLTransactionCallback* callback = TransactionCallback::create(query, requestCallback.get());
+    SQLTransactionErrorCallback* errorCallback = TransactionErrorCallback::create(requestCallback.get());
+    VoidCallback* successCallback = TransactionSuccessCallback::create();
+    database->transaction(callback, errorCallback, successCallback);
 }
 
 InspectorDatabaseResource* InspectorDatabaseAgent::findByFileName(const String& fileName)
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLCallbackWrapper.h b/third_party/WebKit/Source/modules/webdatabase/SQLCallbackWrapper.h
index ecee88c..04cd2f3 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLCallbackWrapper.h
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLCallbackWrapper.h
@@ -44,7 +44,7 @@ namespace blink {
 template<typename T> class SQLCallbackWrapper {
     DISALLOW_ALLOCATION();
 public:
-    SQLCallbackWrapper(PassOwnPtrWillBeRawPtr<T> callback, ExecutionContext* executionContext)
+    SQLCallbackWrapper(T* callback, ExecutionContext* executionContext)
         : m_callback(callback)
         , m_executionContext(m_callback ? executionContext : 0)
     {
@@ -75,7 +75,6 @@ public:
         m_executionContext.clear();
 #else
         ExecutionContext* context;
-        OwnPtr<T> callback;
         {
             MutexLocker locker(m_mutex);
             if (!m_callback) {
@@ -88,13 +87,12 @@ public:
                 return;
             }
             context = m_executionContext.release().leakRef();
-            callback = m_callback.release();
         }
-        context->postTask(SafeReleaseTask::create(callback.release()));
+        context->postTask(SafeReleaseTask::create(m_callback));
 #endif
     }
 
-    PassOwnPtrWillBeRawPtr<T> unwrap()
+    T* unwrap()
     {
         MutexLocker locker(m_mutex);
         ASSERT(!m_callback || m_executionContext->isContextThread());
@@ -109,7 +107,7 @@ private:
 #if !ENABLE(OILPAN)
     class SafeReleaseTask : public ExecutionContextTask {
     public:
-        static PassOwnPtr<SafeReleaseTask> create(PassOwnPtr<T> callbackToRelease)
+        static PassOwnPtr<SafeReleaseTask> create(T* callbackToRelease)
         {
             return adoptPtr(new SafeReleaseTask(callbackToRelease));
         }
@@ -124,17 +122,17 @@ private:
         virtual bool isCleanupTask() const { return true; }
 
     private:
-        explicit SafeReleaseTask(PassOwnPtr<T> callbackToRelease)
+        explicit SafeReleaseTask(T* callbackToRelease)
             : m_callbackToRelease(callbackToRelease)
         {
         }
 
-        OwnPtr<T> m_callbackToRelease;
+        CrossThreadPersistent<T> m_callbackToRelease;
     };
 #endif
 
     Mutex m_mutex;
-    OwnPtrWillBeMember<T> m_callback;
+    CrossThreadPersistentWillBeMember<T> m_callback;
     RefPtrWillBeMember<ExecutionContext> m_executionContext;
 };
 
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLStatement.cpp b/third_party/WebKit/Source/modules/webdatabase/SQLStatement.cpp
index 468af96..df25b76 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLStatement.cpp
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLStatement.cpp
@@ -43,13 +43,13 @@
 namespace blink {
 
 PassOwnPtrWillBeRawPtr<SQLStatement> SQLStatement::create(Database* database,
-    PassOwnPtrWillBeRawPtr<SQLStatementCallback> callback, PassOwnPtrWillBeRawPtr<SQLStatementErrorCallback> errorCallback)
+    SQLStatementCallback* callback, SQLStatementErrorCallback* errorCallback)
 {
     return adoptPtrWillBeNoop(new SQLStatement(database, callback, errorCallback));
 }
 
-SQLStatement::SQLStatement(Database* database, PassOwnPtrWillBeRawPtr<SQLStatementCallback> callback,
-    PassOwnPtrWillBeRawPtr<SQLStatementErrorCallback> errorCallback)
+SQLStatement::SQLStatement(Database* database, SQLStatementCallback* callback,
+    SQLStatementErrorCallback* errorCallback)
     : m_statementCallbackWrapper(callback, database->executionContext())
     , m_statementErrorCallbackWrapper(errorCallback, database->executionContext())
 {
@@ -88,8 +88,8 @@ bool SQLStatement::performCallback(SQLTransaction* transaction)
 
     bool callbackError = false;
 
-    OwnPtrWillBeRawPtr<SQLStatementCallback> callback = m_statementCallbackWrapper.unwrap();
-    OwnPtrWillBeRawPtr<SQLStatementErrorCallback> errorCallback = m_statementErrorCallbackWrapper.unwrap();
+    SQLStatementCallback* callback = m_statementCallbackWrapper.unwrap();
+    SQLStatementErrorCallback* errorCallback = m_statementErrorCallbackWrapper.unwrap();
     SQLErrorData* error = m_backend->sqlError();
 
     // Call the appropriate statement callback and track if it resulted in an error,
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLStatement.h b/third_party/WebKit/Source/modules/webdatabase/SQLStatement.h
index 9b878df..0b81f00 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLStatement.h
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLStatement.h
@@ -46,7 +46,7 @@ class SQLTransaction;
 class SQLStatement FINAL : public NoBaseWillBeGarbageCollectedFinalized<SQLStatement> {
 public:
     static PassOwnPtrWillBeRawPtr<SQLStatement> create(Database*,
-        PassOwnPtrWillBeRawPtr<SQLStatementCallback>, PassOwnPtrWillBeRawPtr<SQLStatementErrorCallback>);
+        SQLStatementCallback*, SQLStatementErrorCallback*);
     ~SQLStatement();
     void trace(Visitor*);
 
@@ -58,7 +58,7 @@ public:
     bool hasErrorCallback();
 
 private:
-    SQLStatement(Database*, PassOwnPtrWillBeRawPtr<SQLStatementCallback>, PassOwnPtrWillBeRawPtr<SQLStatementErrorCallback>);
+    SQLStatement(Database*, SQLStatementCallback*, SQLStatementErrorCallback*);
 
     // The SQLStatementBackend owns the SQLStatement. Hence, the backend is
     // guaranteed to be outlive the SQLStatement, and it is safe for us to refer
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLStatementCallback.h b/third_party/WebKit/Source/modules/webdatabase/SQLStatementCallback.h
index c77e0e5..0c4382d 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLStatementCallback.h
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLStatementCallback.h
@@ -35,7 +35,7 @@ namespace blink {
 class SQLTransaction;
 class SQLResultSet;
 
-class SQLStatementCallback : public NoBaseWillBeGarbageCollectedFinalized<SQLStatementCallback> {
+class SQLStatementCallback : public GarbageCollectedFinalized<SQLStatementCallback> {
 public:
     virtual ~SQLStatementCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLStatementErrorCallback.h b/third_party/WebKit/Source/modules/webdatabase/SQLStatementErrorCallback.h
index 0b04d88..ad8ab80 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLStatementErrorCallback.h
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLStatementErrorCallback.h
@@ -36,7 +36,7 @@ namespace blink {
 class SQLTransaction;
 class SQLError;
 
-class SQLStatementErrorCallback : public NoBaseWillBeGarbageCollectedFinalized<SQLStatementErrorCallback> {
+class SQLStatementErrorCallback : public GarbageCollectedFinalized<SQLStatementErrorCallback> {
 public:
     virtual ~SQLStatementErrorCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLTransaction.cpp b/third_party/WebKit/Source/modules/webdatabase/SQLTransaction.cpp
index 1731aa7..b3f96fd 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLTransaction.cpp
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLTransaction.cpp
@@ -48,15 +48,15 @@
 
 namespace blink {
 
-PassRefPtrWillBeRawPtr<SQLTransaction> SQLTransaction::create(Database* db, PassOwnPtrWillBeRawPtr<SQLTransactionCallback> callback,
-    PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback,
+PassRefPtrWillBeRawPtr<SQLTransaction> SQLTransaction::create(Database* db, SQLTransactionCallback* callback,
+    VoidCallback* successCallback, SQLTransactionErrorCallback* errorCallback,
     bool readOnly)
 {
     return adoptRefWillBeNoop(new SQLTransaction(db, callback, successCallback, errorCallback, readOnly));
 }
 
-SQLTransaction::SQLTransaction(Database* db, PassOwnPtrWillBeRawPtr<SQLTransactionCallback> callback,
-    PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback,
+SQLTransaction::SQLTransaction(Database* db, SQLTransactionCallback* callback,
+    VoidCallback* successCallback, SQLTransactionErrorCallback* errorCallback,
     bool readOnly)
     : m_database(db)
     , m_callbackWrapper(callback, db->executionContext())
@@ -152,7 +152,7 @@ SQLTransactionState SQLTransaction::deliverTransactionCallback()
     bool shouldDeliverErrorCallback = false;
 
     // Spec 4.3.2 4: Invoke the transaction callback with the new SQLTransaction object
-    OwnPtrWillBeRawPtr<SQLTransactionCallback> callback = m_callbackWrapper.unwrap();
+    SQLTransactionCallback* callback = m_callbackWrapper.unwrap();
     if (callback) {
         m_executeSqlAllowed = true;
         shouldDeliverErrorCallback = !callback->handleEvent(this);
@@ -174,7 +174,7 @@ SQLTransactionState SQLTransaction::deliverTransactionErrorCallback()
 {
     // Spec 4.3.2.10: If exists, invoke error callback with the last
     // error to have occurred in this transaction.
-    OwnPtrWillBeRawPtr<SQLTransactionErrorCallback> errorCallback = m_errorCallbackWrapper.unwrap();
+    SQLTransactionErrorCallback* errorCallback = m_errorCallbackWrapper.unwrap();
     if (errorCallback) {
         // If we get here with an empty m_transactionError, then the backend
         // must be waiting in the idle state waiting for this state to finish.
@@ -231,7 +231,7 @@ SQLTransactionState SQLTransaction::deliverQuotaIncreaseCallback()
 SQLTransactionState SQLTransaction::deliverSuccessCallback()
 {
     // Spec 4.3.2.8: Deliver success callback.
-    OwnPtrWillBeRawPtr<VoidCallback> successCallback = m_successCallbackWrapper.unwrap();
+    VoidCallback* successCallback = m_successCallbackWrapper.unwrap();
     if (successCallback)
         successCallback->handleEvent();
 
@@ -264,7 +264,7 @@ void SQLTransaction::performPendingCallback()
     runStateMachine();
 }
 
-void SQLTransaction::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, PassOwnPtrWillBeRawPtr<SQLStatementCallback> callback, PassOwnPtrWillBeRawPtr<SQLStatementErrorCallback> callbackError, ExceptionState& exceptionState)
+void SQLTransaction::executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments, SQLStatementCallback* callback, SQLStatementErrorCallback* callbackError, ExceptionState& exceptionState)
 {
     if (!m_executeSqlAllowed) {
         exceptionState.throwDOMException(InvalidStateError, "SQL execution is disallowed.");
@@ -317,7 +317,7 @@ void SQLTransaction::clearCallbackWrappers()
     m_errorCallbackWrapper.clear();
 }
 
-PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> SQLTransaction::releaseErrorCallback()
+SQLTransactionErrorCallback* SQLTransaction::releaseErrorCallback()
 {
     return m_errorCallbackWrapper.unwrap();
 }
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLTransaction.h b/third_party/WebKit/Source/modules/webdatabase/SQLTransaction.h
index 79f37b9..64665f8 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLTransaction.h
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLTransaction.h
@@ -56,8 +56,8 @@ class SQLTransaction FINAL
     , public ScriptWrappable {
     DEFINE_WRAPPERTYPEINFO();
 public:
-    static PassRefPtrWillBeRawPtr<SQLTransaction> create(Database*, PassOwnPtrWillBeRawPtr<SQLTransactionCallback>,
-        PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback>,
+    static PassRefPtrWillBeRawPtr<SQLTransaction> create(Database*, SQLTransactionCallback*,
+        VoidCallback* successCallback, SQLTransactionErrorCallback*,
         bool readOnly);
     ~SQLTransaction();
     void trace(Visitor*);
@@ -65,11 +65,11 @@ public:
     void performPendingCallback();
 
     void executeSQL(const String& sqlStatement, const Vector<SQLValue>& arguments,
-        PassOwnPtrWillBeRawPtr<SQLStatementCallback>, PassOwnPtrWillBeRawPtr<SQLStatementErrorCallback>, ExceptionState&);
+        SQLStatementCallback*, SQLStatementErrorCallback*, ExceptionState&);
 
     Database* database() { return m_database.get(); }
 
-    PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback> releaseErrorCallback();
+    SQLTransactionErrorCallback* releaseErrorCallback();
 
     // APIs called from the backend published:
     void requestTransitToState(SQLTransactionState);
@@ -79,8 +79,8 @@ public:
     void setBackend(SQLTransactionBackend*);
 
 private:
-    SQLTransaction(Database*, PassOwnPtrWillBeRawPtr<SQLTransactionCallback>,
-        PassOwnPtrWillBeRawPtr<VoidCallback> successCallback, PassOwnPtrWillBeRawPtr<SQLTransactionErrorCallback>,
+    SQLTransaction(Database*, SQLTransactionCallback*,
+        VoidCallback* successCallback, SQLTransactionErrorCallback*,
         bool readOnly);
 
     void clearCallbackWrappers();
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLTransactionCallback.h b/third_party/WebKit/Source/modules/webdatabase/SQLTransactionCallback.h
index b704eb1..15bcbc5 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLTransactionCallback.h
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLTransactionCallback.h
@@ -35,7 +35,7 @@ namespace blink {
 
 class SQLTransaction;
 
-class SQLTransactionCallback : public NoBaseWillBeGarbageCollectedFinalized<SQLTransactionCallback> {
+class SQLTransactionCallback : public GarbageCollectedFinalized<SQLTransactionCallback> {
 public:
     virtual ~SQLTransactionCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/webdatabase/SQLTransactionErrorCallback.h b/third_party/WebKit/Source/modules/webdatabase/SQLTransactionErrorCallback.h
index aa151c9..36c7d4c 100644
--- a/third_party/WebKit/Source/modules/webdatabase/SQLTransactionErrorCallback.h
+++ b/third_party/WebKit/Source/modules/webdatabase/SQLTransactionErrorCallback.h
@@ -35,7 +35,7 @@ namespace blink {
 
 class SQLError;
 
-class SQLTransactionErrorCallback : public NoBaseWillBeGarbageCollectedFinalized<SQLTransactionErrorCallback> {
+class SQLTransactionErrorCallback : public GarbageCollectedFinalized<SQLTransactionErrorCallback> {
 public:
     virtual ~SQLTransactionErrorCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/webmidi/MIDIErrorCallback.h b/third_party/WebKit/Source/modules/webmidi/MIDIErrorCallback.h
index 58de1d9..827e7ee 100644
--- a/third_party/WebKit/Source/modules/webmidi/MIDIErrorCallback.h
+++ b/third_party/WebKit/Source/modules/webmidi/MIDIErrorCallback.h
@@ -37,7 +37,7 @@ namespace blink {
 
 class DOMError;
 
-class MIDIErrorCallback : public NoBaseWillBeGarbageCollectedFinalized<MIDIErrorCallback> {
+class MIDIErrorCallback : public GarbageCollectedFinalized<MIDIErrorCallback> {
 public:
     virtual ~MIDIErrorCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/modules/webmidi/MIDISuccessCallback.h b/third_party/WebKit/Source/modules/webmidi/MIDISuccessCallback.h
index 18a5fb3..01275f4 100644
--- a/third_party/WebKit/Source/modules/webmidi/MIDISuccessCallback.h
+++ b/third_party/WebKit/Source/modules/webmidi/MIDISuccessCallback.h
@@ -38,7 +38,7 @@ namespace blink {
 
 class MIDIAccess;
 
-class MIDISuccessCallback : public NoBaseWillBeGarbageCollectedFinalized<MIDISuccessCallback> {
+class MIDISuccessCallback : public GarbageCollectedFinalized<MIDISuccessCallback> {
 public:
     virtual ~MIDISuccessCallback() { }
     virtual void trace(Visitor*) { }
diff --git a/third_party/WebKit/Source/platform/heap/Handle.h b/third_party/WebKit/Source/platform/heap/Handle.h
index 2c59513..fb05f86 100644
--- a/third_party/WebKit/Source/platform/heap/Handle.h
+++ b/third_party/WebKit/Source/platform/heap/Handle.h
@@ -1013,6 +1013,7 @@ template<typename T, typename U> inline bool operator!=(const Persistent<T>& a,
 #define ThreadSafeRefCountedWillBeGarbageCollectedFinalized blink::GarbageCollectedFinalized
 #define ThreadSafeRefCountedWillBeThreadSafeRefCountedGarbageCollected blink::ThreadSafeRefCountedGarbageCollected
 #define PersistentWillBeMember blink::Member
+#define CrossThreadPersistentWillBeMember blink::Member
 #define RefPtrWillBePersistent blink::Persistent
 #define RefPtrWillBeRawPtr WTF::RawPtr
 #define RefPtrWillBeMember blink::Member
@@ -1130,6 +1131,7 @@ public:
 #define ThreadSafeRefCountedWillBeGarbageCollectedFinalized WTF::ThreadSafeRefCounted
 #define ThreadSafeRefCountedWillBeThreadSafeRefCountedGarbageCollected WTF::ThreadSafeRefCounted
 #define PersistentWillBeMember blink::Persistent
+#define CrossThreadPersistentWillBeMember blink::CrossThreadPersistent
 #define RefPtrWillBePersistent WTF::RefPtr
 #define RefPtrWillBeRawPtr WTF::RefPtr
 #define RefPtrWillBeMember WTF::RefPtr
diff --git a/third_party/WebKit/Source/web/NotificationPermissionClientImpl.cpp b/third_party/WebKit/Source/web/NotificationPermissionClientImpl.cpp
index 3142600..b4c3182 100644
--- a/third_party/WebKit/Source/web/NotificationPermissionClientImpl.cpp
+++ b/third_party/WebKit/Source/web/NotificationPermissionClientImpl.cpp
@@ -18,7 +18,7 @@ namespace {
 
 class WebNotificationPermissionCallbackImpl : public WebNotificationPermissionCallback {
 public:
-    WebNotificationPermissionCallbackImpl(PassOwnPtrWillBeRawPtr<NotificationPermissionCallback> callback)
+    WebNotificationPermissionCallbackImpl(NotificationPermissionCallback* callback)
         : m_callback(callback)
     {
     }
@@ -32,7 +32,7 @@ public:
     }
 
 private:
-    OwnPtrWillBePersistent<NotificationPermissionCallback> m_callback;
+    Persistent<NotificationPermissionCallback> m_callback;
 };
 
 } // namespace
@@ -50,7 +50,7 @@ NotificationPermissionClientImpl::~NotificationPermissionClientImpl()
 {
 }
 
-void NotificationPermissionClientImpl::requestPermission(ExecutionContext* context, PassOwnPtrWillBeRawPtr<NotificationPermissionCallback> callback)
+void NotificationPermissionClientImpl::requestPermission(ExecutionContext* context, NotificationPermissionCallback* callback)
 {
     ASSERT(context && context->isDocument());
 
diff --git a/third_party/WebKit/Source/web/NotificationPermissionClientImpl.h b/third_party/WebKit/Source/web/NotificationPermissionClientImpl.h
index b17ed2d..e334289 100644
--- a/third_party/WebKit/Source/web/NotificationPermissionClientImpl.h
+++ b/third_party/WebKit/Source/web/NotificationPermissionClientImpl.h
@@ -17,7 +17,7 @@ public:
     virtual ~NotificationPermissionClientImpl();
 
     // NotificationPermissionClient implementation.
-    virtual void requestPermission(ExecutionContext*, PassOwnPtrWillBeRawPtr<NotificationPermissionCallback>) OVERRIDE;
+    virtual void requestPermission(ExecutionContext*, NotificationPermissionCallback*) OVERRIDE;
 
     // NoBaseWillBeGarbageCollectedFinalized implementation.
     virtual void trace(Visitor* visitor) OVERRIDE { NotificationPermissionClient::trace(visitor); }
diff --git a/third_party/WebKit/Source/web/StorageQuotaClientImpl.cpp b/third_party/WebKit/Source/web/StorageQuotaClientImpl.cpp
index 6a905e4..ca888c8 100644
--- a/third_party/WebKit/Source/web/StorageQuotaClientImpl.cpp
+++ b/third_party/WebKit/Source/web/StorageQuotaClientImpl.cpp
@@ -59,7 +59,7 @@ StorageQuotaClientImpl::~StorageQuotaClientImpl()
 {
 }
 
-void StorageQuotaClientImpl::requestQuota(ExecutionContext* executionContext, WebStorageQuotaType storageType, unsigned long long newQuotaInBytes, PassOwnPtrWillBeRawPtr<StorageQuotaCallback> successCallback, PassOwnPtrWillBeRawPtr<StorageErrorCallback> errorCallback)
+void StorageQuotaClientImpl::requestQuota(ExecutionContext* executionContext, WebStorageQuotaType storageType, unsigned long long newQuotaInBytes, StorageQuotaCallback* successCallback, StorageErrorCallback* errorCallback)
 {
     ASSERT(executionContext);
 
diff --git a/third_party/WebKit/Source/web/StorageQuotaClientImpl.h b/third_party/WebKit/Source/web/StorageQuotaClientImpl.h
index 9095495..41ab28b 100644
--- a/third_party/WebKit/Source/web/StorageQuotaClientImpl.h
+++ b/third_party/WebKit/Source/web/StorageQuotaClientImpl.h
@@ -43,7 +43,7 @@ public:
 
     virtual ~StorageQuotaClientImpl();
 
-    virtual void requestQuota(ExecutionContext*, WebStorageQuotaType, unsigned long long newQuotaInBytes, PassOwnPtrWillBeRawPtr<StorageQuotaCallback>, PassOwnPtrWillBeRawPtr<StorageErrorCallback>) OVERRIDE;
+    virtual void requestQuota(ExecutionContext*, WebStorageQuotaType, unsigned long long newQuotaInBytes, StorageQuotaCallback*, StorageErrorCallback*) OVERRIDE;
     virtual ScriptPromise requestPersistentQuota(ScriptState*, unsigned long long newQuotaInBytes) OVERRIDE;
 
     virtual void trace(Visitor* visitor) OVERRIDE { StorageQuotaClient::trace(visitor); }
author	keishi@chromium.org <keishi@chromium.org>	2014-09-25 08:15:52 +0000
committer	keishi@chromium.org <keishi@chromium.org>	2014-09-25 08:15:52 +0000
commit	95fef1d9ab7ace2ce21e8bfa9bb5db4e708922cd (patch)
tree	50930f05ccd472213f0e969e62e86b664656a303
parent	798ff6e74aa1cd77ebf17fa8f3b8b161aafb3cfc (diff)
download	chromium_src-95fef1d9ab7ace2ce21e8bfa9bb5db4e708922cd.zip chromium_src-95fef1d9ab7ace2ce21e8bfa9bb5db4e708922cd.tar.gz chromium_src-95fef1d9ab7ace2ce21e8bfa9bb5db4e708922cd.tar.bz2