Plumb Push API permission request through Blink using Frame.

This follows the pattern of NotificationPermissionClient.

This is part of a series of changes in both Blink and Chromium.

BUG=389194

TEST=PushMessagingBrowserTest*
TEST=LayoutTests/push_messaging/*

Review URL: https://codereview.chromium.org/707833002

git-svn-id: svn://svn.chromium.org/blink/trunk@184923 bbb929c8-8fbe-4397-9dbb-9b2b20218538

third_party/WebKit/Source/modules/modules.gypi

@@ -702,6 +702,10 @@
       'push_messaging/PushEvent.h',
       'push_messaging/PushManager.cpp',
       'push_messaging/PushManager.h',
+      'push_messaging/PushPermissionClient.cpp',
+      'push_messaging/PushPermissionClient.h',
+      'push_messaging/PushPermissionRequestCallback.cpp',
+      'push_messaging/PushPermissionRequestCallback.h',
       'push_messaging/PushPermissionStatusCallback.cpp',
       'push_messaging/PushPermissionStatusCallback.h',
       'push_messaging/PushRegistration.cpp',

third_party/WebKit/Source/modules/push_messaging/PushManager.cpp

@@ -16,6 +16,8 @@
 #include "core/frame/LocalDOMWindow.h"
 #include "modules/push_messaging/PushController.h"
 #include "modules/push_messaging/PushError.h"
+#include "modules/push_messaging/PushPermissionClient.h"
+#include "modules/push_messaging/PushPermissionRequestCallback.h"
 #include "modules/push_messaging/PushPermissionStatusCallback.h"
 #include "modules/push_messaging/PushRegistration.h"
 #include "modules/serviceworkers/NavigatorServiceWorker.h"
@@ -43,12 +45,21 @@ ScriptPromise PushManager::registerPushMessaging(ScriptState* scriptState)
     if (!serviceWorkerProvider)
         return ScriptPromise::rejectWithDOMException(scriptState, DOMException::create(AbortError, "No Service Worker installed for this document."));
 
+    // FIXME: Once everything except permission request goes through platform,
+    // delete WebPushClient and usage such as this one.
+    // See crbug.com/389194
     WebPushClient* client = PushController::clientFrom(document->page());
     ASSERT(client);
 
     RefPtr<ScriptPromiseResolver> resolver = ScriptPromiseResolver::create(scriptState);
     ScriptPromise promise = resolver->promise();
-    client->registerPushMessaging(new CallbackPromiseAdapter<PushRegistration, PushError>(resolver), serviceWorkerProvider);
+
+    PushPermissionClient* permissionClient = PushPermissionClient::from(scriptState->executionContext());
+    if (permissionClient)
+        permissionClient->requestPermission(scriptState->executionContext(), new PushPermissionRequestCallback(this, client, resolver, serviceWorkerProvider));
+    else
+        doRegister(client, resolver, serviceWorkerProvider);
+
     return promise;
 }
 
@@ -76,4 +87,9 @@ ScriptPromise PushManager::hasPermission(ScriptState* scriptState)
     return resolver->promise();
 }
 
+void PushManager::doRegister(WebPushClient* client, PassRefPtr<ScriptPromiseResolver> resolver, WebServiceWorkerProvider* serviceWorkerProvider)
+{
+    client->registerPushMessaging(new CallbackPromiseAdapter<PushRegistration, PushError>(resolver), serviceWorkerProvider);
+}
+
 } // namespace blink

third_party/WebKit/Source/modules/push_messaging/PushManager.h

@@ -7,11 +7,15 @@
 
 #include "bindings/core/v8/ScriptWrappable.h"
 #include "platform/heap/Handle.h"
+#include "wtf/PassRefPtr.h"
 
 namespace blink {
 
 class ScriptPromise;
 class ScriptState;
+class ScriptPromiseResolver;
+class WebPushClient;
+class WebServiceWorkerProvider;
 
 class PushManager final : public GarbageCollected<PushManager>, public ScriptWrappable {
     DEFINE_WRAPPERTYPEINFO();
@@ -24,6 +28,8 @@ public:
     ScriptPromise registerPushMessaging(ScriptState*);
     ScriptPromise hasPermission(ScriptState*);
 
+    void doRegister(WebPushClient*, PassRefPtr<ScriptPromiseResolver>, WebServiceWorkerProvider*);
+
     void trace(Visitor*) { }
 
 private:

third_party/WebKit/Source/modules/push_messaging/PushPermissionClient.cpp

+// Copyright 2014 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 "config.h"
+#include "modules/push_messaging/PushPermissionClient.h"
+
+#include "core/dom/Document.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/frame/LocalFrame.h"
+
+namespace blink {
+
+const char* PushPermissionClient::supplementName()
+{
+    return "PushPermissionClient";
+}
+
+PushPermissionClient* PushPermissionClient::from(ExecutionContext* context)
+{
+    if (!context->isDocument())
+        return nullptr;
+
+    const Document* document = toDocument(context);
+    ASSERT(document->frame());
+
+    if (!document->frame()->isLocalFrame())
+        return nullptr;
+
+    return static_cast<PushPermissionClient*>(WillBeHeapSupplement<LocalFrame>::from(document->frame(), supplementName()));
+}
+
+void providePushPermissionClientTo(LocalFrame& frame, PassOwnPtrWillBeRawPtr<PushPermissionClient> client)
+{
+    frame.provideSupplement(PushPermissionClient::supplementName(), client);
+}
+
+}

third_party/WebKit/Source/modules/push_messaging/PushPermissionClient.h

+// Copyright 2014 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.
+
+#ifndef PushPermissionClient_h
+#define PushPermissionClient_h
+
+#include "platform/Supplementable.h"
+#include "public/platform/WebCallback.h"
+#include "wtf/PassOwnPtr.h"
+
+namespace blink {
+
+class ExecutionContext;
+class LocalFrame;
+
+class PushPermissionClient : public WillBeHeapSupplement<LocalFrame> {
+public:
+    virtual ~PushPermissionClient() { }
+
+    // Requests user permission to use the Push API from the origin of the
+    // current frame. The provided callback will be run when a decision has been
+    // made.
+    virtual void requestPermission(ExecutionContext*, WebCallback*) = 0;
+
+    // WillBeHeapSupplement requirements.
+    static const char* supplementName();
+    static PushPermissionClient* from(ExecutionContext*);
+};
+
+void providePushPermissionClientTo(LocalFrame&, PassOwnPtrWillBeRawPtr<PushPermissionClient>);
+
+} // namespace blink
+
+#endif // PushPermissionClient_h

third_party/WebKit/Source/modules/push_messaging/PushPermissionRequestCallback.cpp

+// Copyright 2014 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 "config.h"
+#include "modules/push_messaging/PushPermissionRequestCallback.h"
+
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "modules/push_messaging/PushManager.h"
+
+namespace blink {
+
+PushPermissionRequestCallback::PushPermissionRequestCallback(PushManager* manager, WebPushClient* client, PassRefPtr<ScriptPromiseResolver> resolver, WebServiceWorkerProvider* serviceWorkerProvider)
+    : m_manager(manager)
+    , m_client(client)
+    , m_resolver(resolver)
+    , m_serviceWorkerProvider(serviceWorkerProvider)
+{
+}
+
+PushPermissionRequestCallback::~PushPermissionRequestCallback()
+{
+}
+
+void PushPermissionRequestCallback::run()
+{
+    m_manager->doRegister(m_client, m_resolver, m_serviceWorkerProvider);
+}
+
+} // namespace blink

third_party/WebKit/Source/modules/push_messaging/PushPermissionRequestCallback.h

+// Copyright 2014 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.
+
+#ifndef PushPermissionRequestCallback_h
+#define PushPermissionRequestCallback_h
+
+#include "platform/heap/Handle.h"
+#include "public/platform/WebCallback.h"
+#include "wtf/Noncopyable.h"
+#include "wtf/PassRefPtr.h"
+#include "wtf/RefPtr.h"
+
+namespace blink {
+
+class PushManager;
+class ScriptPromiseResolver;
+class WebPushClient;
+class WebServiceWorkerProvider;
+
+class PushPermissionRequestCallback final : public WebCallback {
+    WTF_MAKE_NONCOPYABLE(PushPermissionRequestCallback);
+
+public:
+    // Since |PushManager| is oilpan garbage collected this will keep it alive.
+    // Does not take ownership of |WebPushClient|.
+    // Since |ScriptPromiseResolver| is ref counted this will keep it alive.
+    // Does not take ownership of |WebServiceWorkerProvider|.
+    PushPermissionRequestCallback(PushManager*, WebPushClient*, PassRefPtr<ScriptPromiseResolver>, WebServiceWorkerProvider*);
+    ~PushPermissionRequestCallback() override;
+
+    void run() override;
+
+private:
+    Persistent<PushManager> m_manager;
+    WebPushClient* m_client;
+    RefPtr<ScriptPromiseResolver> m_resolver;
+    WebServiceWorkerProvider* m_serviceWorkerProvider;
+};
+
+} // namespace blink
+
+#endif // PushPermissionRequestCallback_h

third_party/WebKit/Source/web/PushPermissionClientImpl.cpp

+// Copyright 2014 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 "config.h"
+#include "web/PushPermissionClientImpl.h"
+
+#include "core/dom/Document.h"
+#include "core/dom/ExecutionContext.h"
+#include "public/web/WebFrameClient.h"
+#include "web/WebLocalFrameImpl.h"
+
+namespace blink {
+
+PassOwnPtrWillBeRawPtr<PushPermissionClientImpl> PushPermissionClientImpl::create()
+{
+    return adoptPtrWillBeNoop(new PushPermissionClientImpl());
+}
+
+PushPermissionClientImpl::PushPermissionClientImpl()
+{
+}
+
+PushPermissionClientImpl::~PushPermissionClientImpl()
+{
+}
+
+void PushPermissionClientImpl::requestPermission(ExecutionContext* context, WebCallback* callback)
+{
+    ASSERT(context && context->isDocument());
+
+    Document* document = toDocument(context);
+    WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(document->frame());
+
+    webFrame->client()->requestPushPermission(callback);
+}
+
+} // namespace blink

third_party/WebKit/Source/web/PushPermissionClientImpl.h

+// Copyright 2014 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.
+
+#ifndef PushPermissionClientImpl_h
+#define PushPermissionClientImpl_h
+
+#include "modules/push_messaging/PushPermissionClient.h"
+
+namespace blink {
+
+class PushPermissionClientImpl : public NoBaseWillBeGarbageCollectedFinalized<PushPermissionClientImpl>, public PushPermissionClient {
+    WILL_BE_USING_GARBAGE_COLLECTED_MIXIN(PushPermissionClientImpl);
+public:
+    static PassOwnPtrWillBeRawPtr<PushPermissionClientImpl> create();
+
+    ~PushPermissionClientImpl() override;
+
+    // PushPermissionClient implementation.
+    void requestPermission(ExecutionContext*, WebCallback*) override;
+
+    // NoBaseWillBeGarbageCollectedFinalized implementation.
+    void trace(Visitor* visitor) override { PushPermissionClient::trace(visitor); }
+
+private:
+    PushPermissionClientImpl();
+};
+
+} // namespace blink
+
+#endif // PushPermissionClientImpl_h

third_party/WebKit/Source/web/web.gypi

@@ -80,6 +80,8 @@
       'PopupMenuChromium.h',
       'PrerendererClientImpl.cpp',
       'PrerendererClientImpl.h',
+      'PushPermissionClientImpl.cpp',
+      'PushPermissionClientImpl.h',
       'RemoteFrameClientImpl.cpp',
       'RemoteFrameClientImpl.h',
       'ScrollbarGroup.cpp',

third_party/WebKit/public/platform/WebCallback.h

+// Copyright 2014 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.
+
+#ifndef WebCallback_h
+#define WebCallback_h
+
+namespace blink {
+
+class WebCallback {
+public:
+    virtual ~WebCallback() { };
+    virtual void run() { };
+};
+
+} // namespace blink
+
+#endif // WebCallback_h

third_party/WebKit/public/web/WebFrameClient.h

@@ -57,6 +57,7 @@ namespace blink {
 class WebApplicationCacheHost;
 class WebApplicationCacheHostClient;
 class WebCachedURLRequest;
+class WebCallback;
 class WebColorChooser;
 class WebColorChooserClient;
 class WebContentDecryptionModule;
@@ -325,6 +326,12 @@ public:
     virtual WebNotificationPresenter* notificationPresenter() { return 0; }
 
 
+    // Push API ---------------------------------------------------
+
+    // Requests permission to use the Push API in the origin of this frame.
+    virtual void requestPushPermission(WebCallback* callback) { }
+
+
     // Editing -------------------------------------------------------------
 
     // These methods allow the client to intercept and overrule editing