Commit abcca45f authored by nhiroki's avatar nhiroki Committed by Commit bot

ServiceWorker: Replace RegistrationCallback and GetRegistrationsCallback with...

ServiceWorker: Replace RegistrationCallback and GetRegistrationsCallback with CallbackPromiseAdapter

This is a cleanup CL and does not change behavior.

BUG=n/a

Review-Url: https://codereview.chromium.org/2564363002
Cr-Commit-Position: refs/heads/master@{#438061}
parent e4c4ef93
...@@ -8,6 +8,7 @@ ...@@ -8,6 +8,7 @@
#include <utility> #include <utility>
#include "base/lazy_instance.h" #include "base/lazy_instance.h"
#include "base/memory/ptr_util.h"
#include "base/single_thread_task_runner.h" #include "base/single_thread_task_runner.h"
#include "base/stl_util.h" #include "base/stl_util.h"
#include "base/threading/thread_local.h" #include "base/threading/thread_local.h"
...@@ -523,21 +524,15 @@ void ServiceWorkerDispatcher::OnDidGetRegistrations( ...@@ -523,21 +524,15 @@ void ServiceWorkerDispatcher::OnDidGetRegistrations(
if (!callbacks) if (!callbacks)
return; return;
typedef blink::WebVector<blink::WebServiceWorkerRegistration::Handle*> using WebServiceWorkerRegistrationHandles =
WebServiceWorkerRegistrationArray; WebServiceWorkerProvider::WebServiceWorkerRegistrationHandles;
std::unique_ptr<WebServiceWorkerRegistrationArray> registrations( std::unique_ptr<WebServiceWorkerRegistrationHandles> registrations =
new WebServiceWorkerRegistrationArray(infos.size())); base::MakeUnique<WebServiceWorkerRegistrationHandles>(infos.size());
for (size_t i = 0; i < infos.size(); ++i) { for (size_t i = 0; i < infos.size(); ++i) {
if (infos[i].handle_id != kInvalidServiceWorkerHandleId) { if (infos[i].handle_id == kInvalidServiceWorkerHandleId)
ServiceWorkerRegistrationObjectInfo info(infos[i]); continue;
ServiceWorkerVersionAttributes attr(attrs[i]); (*registrations)[i] = WebServiceWorkerRegistrationImpl::CreateHandle(
GetOrAdoptRegistration(infos[i], attrs[i]));
// WebServiceWorkerGetRegistrationsCallbacks cannot receive an array of
// std::unique_ptr<WebServiceWorkerRegistration::Handle>, so create leaky
// handles instead.
(*registrations)[i] = WebServiceWorkerRegistrationImpl::CreateLeakyHandle(
GetOrAdoptRegistration(info, attr));
}
} }
callbacks->onSuccess(std::move(registrations)); callbacks->onSuccess(std::move(registrations));
......
...@@ -200,14 +200,6 @@ WebServiceWorkerRegistrationImpl::CreateHandle( ...@@ -200,14 +200,6 @@ WebServiceWorkerRegistrationImpl::CreateHandle(
return base::MakeUnique<HandleImpl>(registration); return base::MakeUnique<HandleImpl>(registration);
} }
blink::WebServiceWorkerRegistration::Handle*
WebServiceWorkerRegistrationImpl::CreateLeakyHandle(
const scoped_refptr<WebServiceWorkerRegistrationImpl>& registration) {
if (!registration)
return nullptr;
return new HandleImpl(registration);
}
WebServiceWorkerRegistrationImpl::~WebServiceWorkerRegistrationImpl() { WebServiceWorkerRegistrationImpl::~WebServiceWorkerRegistrationImpl() {
ServiceWorkerDispatcher* dispatcher = ServiceWorkerDispatcher* dispatcher =
ServiceWorkerDispatcher::GetThreadSpecificInstance(); ServiceWorkerDispatcher::GetThreadSpecificInstance();
......
...@@ -78,13 +78,6 @@ class CONTENT_EXPORT WebServiceWorkerRegistrationImpl ...@@ -78,13 +78,6 @@ class CONTENT_EXPORT WebServiceWorkerRegistrationImpl
static std::unique_ptr<WebServiceWorkerRegistrationHandle> CreateHandle( static std::unique_ptr<WebServiceWorkerRegistrationHandle> CreateHandle(
const scoped_refptr<WebServiceWorkerRegistrationImpl>& registration); const scoped_refptr<WebServiceWorkerRegistrationImpl>& registration);
// Same with CreateHandle(), but returns a raw pointer to the handle w/ its
// ownership instead. The caller must manage the ownership. This function must
// be used only for passing the handle to Blink API that does not support
// blink::WebPassOwnPtr.
static WebServiceWorkerRegistrationHandle* CreateLeakyHandle(
const scoped_refptr<WebServiceWorkerRegistrationImpl>& registration);
private: private:
friend class base::RefCounted<WebServiceWorkerRegistrationImpl>; friend class base::RefCounted<WebServiceWorkerRegistrationImpl>;
~WebServiceWorkerRegistrationImpl() override; ~WebServiceWorkerRegistrationImpl() override;
......
...@@ -29,6 +29,7 @@ ...@@ -29,6 +29,7 @@
*/ */
#include "modules/serviceworkers/ServiceWorkerContainer.h" #include "modules/serviceworkers/ServiceWorkerContainer.h"
#include "bindings/core/v8/CallbackPromiseAdapter.h"
#include "bindings/core/v8/ScriptPromise.h" #include "bindings/core/v8/ScriptPromise.h"
#include "bindings/core/v8/ScriptPromiseResolver.h" #include "bindings/core/v8/ScriptPromiseResolver.h"
#include "bindings/core/v8/ScriptState.h" #include "bindings/core/v8/ScriptState.h"
...@@ -62,41 +63,6 @@ ...@@ -62,41 +63,6 @@
namespace blink { namespace blink {
class RegistrationCallback
: public WebServiceWorkerProvider::WebServiceWorkerRegistrationCallbacks {
public:
explicit RegistrationCallback(ScriptPromiseResolver* resolver)
: m_resolver(resolver) {}
~RegistrationCallback() override {}
void onSuccess(
std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) override {
if (!m_resolver->getExecutionContext() ||
m_resolver->getExecutionContext()->isContextDestroyed())
return;
m_resolver->resolve(ServiceWorkerRegistration::getOrCreate(
m_resolver->getExecutionContext(), WTF::wrapUnique(handle.release())));
}
void onError(const WebServiceWorkerError& error) override {
if (!m_resolver->getExecutionContext() ||
m_resolver->getExecutionContext()->isContextDestroyed())
return;
ScriptState::Scope scope(m_resolver->getScriptState());
if (error.errorType == WebServiceWorkerError::ErrorTypeType) {
m_resolver->reject(V8ThrowException::createTypeError(
m_resolver->getScriptState()->isolate(), error.message));
} else {
m_resolver->reject(
ServiceWorkerErrorForUpdate::take(m_resolver.get(), error));
}
}
private:
Persistent<ScriptPromiseResolver> m_resolver;
WTF_MAKE_NONCOPYABLE(RegistrationCallback);
};
class GetRegistrationCallback : public WebServiceWorkerProvider:: class GetRegistrationCallback : public WebServiceWorkerProvider::
WebServiceWorkerGetRegistrationCallbacks { WebServiceWorkerGetRegistrationCallbacks {
public: public:
...@@ -132,42 +98,6 @@ class GetRegistrationCallback : public WebServiceWorkerProvider:: ...@@ -132,42 +98,6 @@ class GetRegistrationCallback : public WebServiceWorkerProvider::
WTF_MAKE_NONCOPYABLE(GetRegistrationCallback); WTF_MAKE_NONCOPYABLE(GetRegistrationCallback);
}; };
class GetRegistrationsCallback : public WebServiceWorkerProvider::
WebServiceWorkerGetRegistrationsCallbacks {
public:
explicit GetRegistrationsCallback(ScriptPromiseResolver* resolver)
: m_resolver(resolver) {}
~GetRegistrationsCallback() override {}
void onSuccess(
std::unique_ptr<WebVector<WebServiceWorkerRegistration::Handle*>>
webPassRegistrations) override {
Vector<std::unique_ptr<WebServiceWorkerRegistration::Handle>> handles;
std::unique_ptr<WebVector<WebServiceWorkerRegistration::Handle*>>
webRegistrations = WTF::wrapUnique(webPassRegistrations.release());
for (auto& handle : *webRegistrations) {
handles.append(WTF::wrapUnique(handle));
}
if (!m_resolver->getExecutionContext() ||
m_resolver->getExecutionContext()->isContextDestroyed())
return;
m_resolver->resolve(
ServiceWorkerRegistrationArray::take(m_resolver.get(), &handles));
}
void onError(const WebServiceWorkerError& error) override {
if (!m_resolver->getExecutionContext() ||
m_resolver->getExecutionContext()->isContextDestroyed())
return;
m_resolver->reject(ServiceWorkerError::take(m_resolver.get(), error));
}
private:
Persistent<ScriptPromiseResolver> m_resolver;
WTF_MAKE_NONCOPYABLE(GetRegistrationsCallback);
};
class ServiceWorkerContainer::GetRegistrationForReadyCallback class ServiceWorkerContainer::GetRegistrationForReadyCallback
: public WebServiceWorkerProvider:: : public WebServiceWorkerProvider::
WebServiceWorkerGetRegistrationForReadyCallbacks { WebServiceWorkerGetRegistrationForReadyCallbacks {
...@@ -358,8 +288,11 @@ ScriptPromise ServiceWorkerContainer::registerServiceWorker( ...@@ -358,8 +288,11 @@ ScriptPromise ServiceWorkerContainer::registerServiceWorker(
patternURL = enteredExecutionContext(scriptState->isolate()) patternURL = enteredExecutionContext(scriptState->isolate())
->completeURL(options.scope()); ->completeURL(options.scope());
registerServiceWorkerImpl(executionContext, scriptURL, patternURL, registerServiceWorkerImpl(
WTF::makeUnique<RegistrationCallback>(resolver)); executionContext, scriptURL, patternURL,
WTF::makeUnique<CallbackPromiseAdapter<ServiceWorkerRegistration,
ServiceWorkerErrorForUpdate>>(
resolver));
return promise; return promise;
} }
...@@ -455,7 +388,8 @@ ScriptPromise ServiceWorkerContainer::getRegistrations( ...@@ -455,7 +388,8 @@ ScriptPromise ServiceWorkerContainer::getRegistrations(
} }
m_provider->getRegistrations( m_provider->getRegistrations(
WTF::makeUnique<GetRegistrationsCallback>(resolver)); WTF::makeUnique<CallbackPromiseAdapter<ServiceWorkerRegistrationArray,
ServiceWorkerError>>(resolver));
return promise; return promise;
} }
......
...@@ -137,6 +137,9 @@ v8::Local<v8::Value> ServiceWorkerErrorForUpdate::take( ...@@ -137,6 +137,9 @@ v8::Local<v8::Value> ServiceWorkerErrorForUpdate::take(
// a TypeError. // a TypeError.
return V8ThrowException::createTypeError( return V8ThrowException::createTypeError(
scriptState->isolate(), getExceptionParams(webError).message); scriptState->isolate(), getExceptionParams(webError).message);
case WebServiceWorkerError::ErrorTypeType:
return V8ThrowException::createTypeError(scriptState->isolate(),
webError.message);
default: default:
return toV8(ServiceWorkerError::take(resolver, webError), return toV8(ServiceWorkerError::take(resolver, webError),
scriptState->context()->Global(), scriptState->isolate()); scriptState->context()->Global(), scriptState->isolate());
......
...@@ -21,6 +21,12 @@ ...@@ -21,6 +21,12 @@
namespace blink { namespace blink {
ServiceWorkerRegistration* ServiceWorkerRegistration::take(
ScriptPromiseResolver* resolver,
std::unique_ptr<WebServiceWorkerRegistration::Handle> handle) {
return getOrCreate(resolver->getExecutionContext(), std::move(handle));
}
bool ServiceWorkerRegistration::hasPendingActivity() const { bool ServiceWorkerRegistration::hasPendingActivity() const {
return !m_stopped; return !m_stopped;
} }
......
...@@ -37,6 +37,12 @@ class ServiceWorkerRegistration final ...@@ -37,6 +37,12 @@ class ServiceWorkerRegistration final
USING_PRE_FINALIZER(ServiceWorkerRegistration, dispose); USING_PRE_FINALIZER(ServiceWorkerRegistration, dispose);
public: public:
// Called from CallbackPromiseAdapter.
using WebType = std::unique_ptr<WebServiceWorkerRegistration::Handle>;
static ServiceWorkerRegistration* take(
ScriptPromiseResolver*,
std::unique_ptr<WebServiceWorkerRegistration::Handle>);
// ScriptWrappable overrides. // ScriptWrappable overrides.
bool hasPendingActivity() const final; bool hasPendingActivity() const final;
...@@ -102,14 +108,17 @@ class ServiceWorkerRegistrationArray { ...@@ -102,14 +108,17 @@ class ServiceWorkerRegistrationArray {
STATIC_ONLY(ServiceWorkerRegistrationArray); STATIC_ONLY(ServiceWorkerRegistrationArray);
public: public:
// Called from CallbackPromiseAdapter.
using WebType = std::unique_ptr<
WebVector<std::unique_ptr<WebServiceWorkerRegistration::Handle>>>;
static HeapVector<Member<ServiceWorkerRegistration>> take( static HeapVector<Member<ServiceWorkerRegistration>> take(
ScriptPromiseResolver* resolver, ScriptPromiseResolver* resolver,
Vector<std::unique_ptr<WebServiceWorkerRegistration::Handle>>* WebType webServiceWorkerRegistrations) {
webServiceWorkerRegistrations) {
HeapVector<Member<ServiceWorkerRegistration>> registrations; HeapVector<Member<ServiceWorkerRegistration>> registrations;
for (auto& registration : *webServiceWorkerRegistrations) for (auto& registration : *webServiceWorkerRegistrations) {
registrations.append(ServiceWorkerRegistration::getOrCreate( registrations.append(
resolver->getExecutionContext(), std::move(registration))); ServiceWorkerRegistration::take(resolver, std::move(registration)));
}
return registrations; return registrations;
} }
}; };
......
...@@ -59,10 +59,11 @@ class WebServiceWorkerProvider { ...@@ -59,10 +59,11 @@ class WebServiceWorkerProvider {
WebCallbacks<std::unique_ptr<WebServiceWorkerRegistration::Handle>, WebCallbacks<std::unique_ptr<WebServiceWorkerRegistration::Handle>,
const WebServiceWorkerError&>; const WebServiceWorkerError&>;
// Each element's ownership is transferred. using WebServiceWorkerRegistrationHandles =
using WebServiceWorkerGetRegistrationsCallbacks = WebCallbacks< WebVector<std::unique_ptr<WebServiceWorkerRegistration::Handle>>;
std::unique_ptr<WebVector<WebServiceWorkerRegistration::Handle*>>, using WebServiceWorkerGetRegistrationsCallbacks =
const WebServiceWorkerError&>; WebCallbacks<std::unique_ptr<WebServiceWorkerRegistrationHandles>,
const WebServiceWorkerError&>;
using WebServiceWorkerGetRegistrationForReadyCallbacks = using WebServiceWorkerGetRegistrationForReadyCallbacks =
WebCallbacks<std::unique_ptr<WebServiceWorkerRegistration::Handle>, void>; WebCallbacks<std::unique_ptr<WebServiceWorkerRegistration::Handle>, void>;
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment