Introduce the Blink NotificationService, move permission checks there

third_party/WebKit/Source/modules/notifications/NotificationManager.cpp

+// Copyright 2016 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "modules/notifications/NotificationManager.h"
+
+#include "platform/weborigin/SecurityOrigin.h"
+#include "public/platform/Platform.h"
+#include "public/platform/ServiceRegistry.h"
+#include "public/platform/modules/permissions/permission_status.mojom-blink.h"
+#include "public/platform/modules/permissions/permission_status.mojom.h"
+
+namespace blink {
+
+#define STATIC_ASSERT_ENUM(a, b) \
+    static_assert(static_cast<int>(a) == static_cast<int>(b), "mismatching enum: " #a)
+
+STATIC_ASSERT_ENUM(mojom::PermissionStatus::GRANTED, mojom::blink::PermissionStatus::GRANTED);
+STATIC_ASSERT_ENUM(mojom::PermissionStatus::DENIED, mojom::blink::PermissionStatus::DENIED);
+STATIC_ASSERT_ENUM(mojom::PermissionStatus::ASK, mojom::blink::PermissionStatus::ASK);
+STATIC_ASSERT_ENUM(mojom::PermissionStatus::LAST, mojom::blink::PermissionStatus::LAST);
+
+// static
+NotificationManager* NotificationManager::from(ExecutionContext* executionContext)
+{
+    DCHECK(executionContext);
+    DCHECK(executionContext->isContextThread());
+
+    NotificationManager* manager = static_cast<NotificationManager*>(Supplement<ExecutionContext>::from(executionContext, supplementName()));
+    if (!manager) {
+        manager = new NotificationManager(executionContext);
+        Supplement<ExecutionContext>::provideTo(*executionContext, supplementName(), manager);
+    }
+
+    return manager;
+}
+
+// static
+const char* NotificationManager::supplementName()
+{
+    return "NotificationManager";
+}
+
+NotificationManager::NotificationManager(ExecutionContext* executionContext)
+    : ContextLifecycleObserver(executionContext)
+{
+    Platform::current()->serviceRegistry()->connectToRemoteService(mojo::GetProxy(&m_service));

[Peter Beverloo, 2016/05/05 16:43:53]

@sammc -

There will be one NotificationManager per ExecutionContext, and since
Notifications are available in all kinds of Web Workers this does *not* have to
be the main thread, which is different from other Mojo consumers in Blink today.

In effect, a crash happens because connectToRemoteService() is used on the wrong
thread when using the feature from a worker.

Could you share your ideas about the best way of dealing with this? (I.e. thread
jump here/when connecting, different registry, another solution?)

[Sam McNally, 2016/05/06 05:14:09]

Platform::serviceRegistry() should be the right place to connect to process-wide
services from any thread. Adding plumbing to the main thread SGTM.

However, if the service has some scoping to the particular context, it should
use a ServiceRegistry specific to that context. For frames, this is
LocalFrame::serviceRegistry(); for service workers, there's a ServiceRegistry in
content::ServiceWorkerContextClient, but it isn't exposed to Blink; for other
workers there isn't one yet. The existing worker-exposed services workaround
this by using the per-process ServiceRegistry (with plumbing to the main thread
in content/renderer) and including the context in the messages (e.g.
PermissionService).

In the longer term it may be useful to add a ServiceRegistry accessor to
something more agnostic like ExecutionContext to reduce the amount of
per-context-type boilerplate.

[Michael van Ouwerkerk, 2016/05/06 10:46:07]

This would be really useful. Where would the browser-side counterpart of an
ExecutionContext-owned endpoint live, in C++ and in Java?

+}
+
+NotificationManager::~NotificationManager()
+{
+}
+
+mojom::PermissionStatus NotificationManager::permissionStatus() const
+{
+    mojom::blink::PermissionStatus blinkPermissionStatus;
+
+    const bool result =
+        m_service->GetPermissionStatus(getOriginString(), &blinkPermissionStatus);
+    DCHECK(result);
+
+    // Both PermissionStatus enums are generated from the same source, but by using the WTF variant
+    // of the NotificationService the same variant of the enum must be used, different from other
+    // users. Static assertions for equality are included in this file.
+    return static_cast<mojom::PermissionStatus>(blinkPermissionStatus);
+}
+
+void NotificationManager::contextDestroyed()
+{
+    m_service.reset();
+}
+
+String NotificationManager::getOriginString() const
+{
+    return getExecutionContext()->getSecurityOrigin()->toString();
+}
+
+DEFINE_TRACE(NotificationManager)
+{
+    ContextLifecycleObserver::trace(visitor);
+    Supplement<ExecutionContext>::trace(visitor);
+}
+
+} // namespace blink