Revert of Remove content::NotificationPermissionDispatcher. (patchset #5...

Revert of Remove content::NotificationPermissionDispatcher. (patchset #5 id:80001 of https://codereview.chromium.org/2244913002/ )

Reason for revert:
Causing failure on Builder WebKit Linux Leak

https://build.chromium.org/p/chromium.webkit/builders/WebKit%20Linux%20Leak/builds/22036

request-permission-detached-context.html

15:25:46.371 7635 worker/0 http/tests/notifications/request-permission-detached-context.html leaked
15:25:46.371 7635   Xlib:  extension "RANDR" missing on display ":9".
15:25:46.371 7635   Xlib:  extension "RANDR" missing on display ":9".
15:25:46.374 17565 [4/95] http/tests/notifications/request-permission-detached-context.html failed unexpectedly (leak detected: ({"numberOfLiveActiveDOMObjects":[2,6],"numberOfLiveDocuments":[1,3],"numberOfLiveNodes":[4,36],"numberOfLiveResources":[0,3]}))
15:25:46.372 7635 worker/0 http/tests/notifications/request-permission-detached-context.html failed:
15:25:46.372 7635 worker/0  leak detected: ({"numberOfLiveActiveDOMObjects":[2,6],"numberOfLiveDocuments":[1,3],"numberOfLiveNodes":[4,36],"numberOfLiveResources":[0,3]})

Original issue's description:
> Remove content::NotificationPermissionDispatcher.
>
> blink::Notification can make calls to the Mojo PermissionService itself.
>
> BUG=561879
>
> Committed: https://crrev.com/be876eec511985fc0f476628b7b43dc951bd04c5
> Cr-Commit-Position: refs/heads/master@{#412636}

TBR=esprehn@chromium.org,haraken@chromium.org,johnme@chromium.org,mvanouwerkerk@chromium.org,peter@chromium.org,reillyg@chromium.org
# Skipping CQ checks because original CL landed less than 1 days ago.
NOPRESUBMIT=true
NOTREECHECKS=true
NOTRY=true
BUG=561879

Review-Url: https://codereview.chromium.org/2258673002
Cr-Commit-Position: refs/heads/master@{#412678}

content/content_renderer.gypi

@@ -385,6 +385,8 @@
       'renderer/navigation_state_impl.h',
       'renderer/net_info_helper.cc',
       'renderer/net_info_helper.h',
+      'renderer/notification_permission_dispatcher.cc',
+      'renderer/notification_permission_dispatcher.h',
       'renderer/origin_trials/web_trial_token_validator_impl.cc',
       'renderer/origin_trials/web_trial_token_validator_impl.h',
       'renderer/peripheral_content_heuristic.cc',

content/renderer/notification_permission_dispatcher.cc

+// 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 "content/renderer/notification_permission_dispatcher.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "content/public/renderer/render_frame.h"
+#include "services/shell/public/cpp/interface_provider.h"
+#include "third_party/WebKit/public/platform/WebSecurityOrigin.h"
+#include "third_party/WebKit/public/platform/WebString.h"
+#include "third_party/WebKit/public/platform/modules/permissions/permission_status.mojom.h"
+#include "third_party/WebKit/public/web/WebUserGestureIndicator.h"
+#include "third_party/WebKit/public/web/modules/notifications/WebNotificationPermissionCallback.h"
+
+using blink::WebNotificationPermissionCallback;
+
+namespace content {
+
+NotificationPermissionDispatcher::NotificationPermissionDispatcher(
+    RenderFrame* render_frame)
+    : RenderFrameObserver(render_frame) {}
+
+NotificationPermissionDispatcher::~NotificationPermissionDispatcher() {}
+
+void NotificationPermissionDispatcher::RequestPermission(
+    const blink::WebSecurityOrigin& origin,
+    WebNotificationPermissionCallback* callback) {
+  if (!permission_service_.get()) {
+    render_frame()->GetRemoteInterfaces()->GetInterface(&permission_service_);
+  }
+
+  std::unique_ptr<WebNotificationPermissionCallback> owned_callback(callback);
+
+  // base::Unretained is safe here because the Mojo channel, with associated
+  // callbacks, will be deleted before the "this" instance is deleted.
+  permission_service_->RequestPermission(
+      blink::mojom::PermissionName::NOTIFICATIONS, origin,
+      blink::WebUserGestureIndicator::isProcessingUserGesture(),
+      base::Bind(&NotificationPermissionDispatcher::OnPermissionRequestComplete,
+                 base::Unretained(this),
+                 base::Passed(std::move(owned_callback))));
+}
+
+void NotificationPermissionDispatcher::OnPermissionRequestComplete(
+    std::unique_ptr<WebNotificationPermissionCallback> callback,
+    blink::mojom::PermissionStatus status) {
+  DCHECK(callback);
+
+  // Blink can't use non-blink bindings so we need to cast to int32.
+  int32_t blink_status = static_cast<int32_t>(status);
+
+  callback->permissionRequestComplete(blink_status);
+}
+
+void NotificationPermissionDispatcher::OnDestruct() {
+  delete this;
+}
+
+}  // namespace content

content/renderer/notification_permission_dispatcher.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 CONTENT_RENDERER_NOTIFICATION_PERMISSION_DISPATCHER_H_
+#define CONTENT_RENDERER_NOTIFICATION_PERMISSION_DISPATCHER_H_
+
+#include <memory>
+
+#include "base/macros.h"
+#include "content/public/renderer/render_frame_observer.h"
+#include "third_party/WebKit/public/platform/modules/permissions/permission.mojom.h"
+
+namespace blink {
+class WebNotificationPermissionCallback;
+class WebSecurityOrigin;
+}
+
+namespace content {
+
+class RenderFrame;
+
+// Dispatcher for Web Notification permission requests.
+class NotificationPermissionDispatcher : public RenderFrameObserver {
+ public:
+  explicit NotificationPermissionDispatcher(RenderFrame* render_frame);
+  ~NotificationPermissionDispatcher() override;
+
+  // Requests permission to display Web Notifications for |origin|. The callback
+  // will be invoked when the permission status is available. This class will
+  // take ownership of |callback|.
+  void RequestPermission(const blink::WebSecurityOrigin& origin,
+                         blink::WebNotificationPermissionCallback* callback);
+
+ private:
+  // RenderFrameObserver implementation.
+  void OnDestruct() override;
+
+  void OnPermissionRequestComplete(
+      std::unique_ptr<blink::WebNotificationPermissionCallback> callback,
+      blink::mojom::PermissionStatus status);
+
+  blink::mojom::PermissionServicePtr permission_service_;
+
+  DISALLOW_COPY_AND_ASSIGN(NotificationPermissionDispatcher);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_NOTIFICATION_PERMISSION_DISPATCHER_H_

content/renderer/render_frame_impl.cc

@@ -112,6 +112,7 @@
 #include "content/renderer/mojo/interface_provider_js_wrapper.h"
 #include "content/renderer/mojo_bindings_controller.h"
 #include "content/renderer/navigation_state_impl.h"
+#include "content/renderer/notification_permission_dispatcher.h"
 #include "content/renderer/pepper/pepper_audio_controller.h"
 #include "content/renderer/pepper/plugin_instance_throttler_impl.h"
 #include "content/renderer/presentation/presentation_dispatcher.h"
@@ -1051,6 +1052,7 @@ RenderFrameImpl::RenderFrameImpl(const CreateParams& params)
       selection_text_offset_(0),
       selection_range_(gfx::Range::InvalidRange()),
       handling_select_range_(false),
+      notification_permission_dispatcher_(NULL),
       web_user_media_client_(NULL),
 #if defined(OS_ANDROID)
       media_player_manager_(NULL),
@@ -3757,6 +3759,17 @@ RenderFrameImpl::getEffectiveConnectionType() {
   return effective_connection_type_;
 }
 
+void RenderFrameImpl::requestNotificationPermission(
+    const blink::WebSecurityOrigin& origin,
+    blink::WebNotificationPermissionCallback* callback) {
+  if (!notification_permission_dispatcher_) {
+    notification_permission_dispatcher_ =
+        new NotificationPermissionDispatcher(this);
+  }
+
+  notification_permission_dispatcher_->RequestPermission(origin, callback);
+}
+
 void RenderFrameImpl::didChangeSelection(bool is_empty_selection) {
   if (!GetRenderWidget()->input_handler().handling_input_event() &&
       !handling_select_range_)

content/renderer/render_frame_impl.h

@@ -133,6 +133,7 @@ class MediaStreamRendererFactory;
 class MediaPermissionDispatcher;
 class MidiDispatcher;
 class NavigationState;
+class NotificationPermissionDispatcher;
 class PageState;
 class PepperPluginInstanceImpl;
 class PresentationDispatcher;
@@ -544,6 +545,9 @@ class CONTENT_EXPORT RenderFrameImpl
   void didChangeThemeColor() override;
   void dispatchLoad() override;
   blink::WebEffectiveConnectionType getEffectiveConnectionType() override;
+  void requestNotificationPermission(
+      const blink::WebSecurityOrigin& origin,
+      blink::WebNotificationPermissionCallback* callback) override;
   void didChangeSelection(bool is_empty_selection) override;
   blink::WebColorChooser* createColorChooser(
       blink::WebColorChooserClient* client,
@@ -1141,6 +1145,9 @@ class CONTENT_EXPORT RenderFrameImpl
   // along with the RenderFrame automatically.  This is why we just store weak
   // references.
 
+  // Dispatches permission requests for Web Notifications.
+  NotificationPermissionDispatcher* notification_permission_dispatcher_;
+
   // Destroyed via the RenderFrameObserver::OnDestruct() mechanism.
   UserMediaClientImpl* web_user_media_client_;
 

third_party/WebKit/Source/modules/modules.gypi

@@ -1369,6 +1369,8 @@
       'notifications/NotificationManager.cpp',
       'notifications/NotificationManager.h',
       'notifications/NotificationPermissionCallback.h',
+      'notifications/NotificationPermissionClient.cpp',
+      'notifications/NotificationPermissionClient.h',
       'notifications/NotificationResourcesLoader.cpp',
       'notifications/NotificationResourcesLoader.h',
       'notifications/ServiceWorkerGlobalScopeNotifications.h',

third_party/WebKit/Source/modules/notifications/DEPS

@@ -7,7 +7,6 @@ include_rules = [
     "+modules/EventTargetModules.h",
     "+modules/ModulesExport.h",
     "+modules/notifications",
-    "+modules/permissions",
     "+modules/serviceworkers",
     "+modules/vibration",
     "+platform",

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

@@ -44,14 +44,17 @@
 #include "modules/notifications/NotificationData.h"
 #include "modules/notifications/NotificationManager.h"
 #include "modules/notifications/NotificationOptions.h"
+#include "modules/notifications/NotificationPermissionClient.h"
 #include "modules/notifications/NotificationResourcesLoader.h"
 #include "platform/RuntimeEnabledFeatures.h"
 #include "platform/UserGestureIndicator.h"
 #include "public/platform/Platform.h"
 #include "public/platform/WebSecurityOrigin.h"
+#include "public/platform/WebString.h"
 #include "public/platform/modules/notifications/WebNotificationAction.h"
 #include "public/platform/modules/notifications/WebNotificationConstants.h"
 #include "public/platform/modules/notifications/WebNotificationManager.h"
+#include "public/platform/modules/permissions/permission_status.mojom-blink.h"
 #include "wtf/Assertions.h"
 #include "wtf/Functional.h"
 
@@ -351,7 +354,14 @@ String Notification::permission(ExecutionContext* context)
 
 ScriptPromise Notification::requestPermission(ScriptState* scriptState, NotificationPermissionCallback* deprecatedCallback)
 {
-    return NotificationManager::from(scriptState->getExecutionContext())->requestPermission(scriptState, deprecatedCallback);
+    ExecutionContext* context = scriptState->getExecutionContext();
+    if (NotificationPermissionClient* permissionClient = NotificationPermissionClient::from(context))
+        return permissionClient->requestPermission(scriptState, deprecatedCallback);
+
+    // The context has been detached. Return a promise that will never settle.
+    DCHECK(context->activeDOMObjectsAreStopped());
+
+    return ScriptPromise();
 }
 
 size_t Notification::maxActions()

third_party/WebKit/Source/modules/notifications/Notification.h

@@ -46,7 +46,6 @@
 #include "public/platform/WebVector.h"
 #include "public/platform/modules/notifications/WebNotificationData.h"
 #include "public/platform/modules/notifications/WebNotificationDelegate.h"
-#include "public/platform/modules/permissions/permission.mojom-blink.h"
 #include "public/platform/modules/permissions/permission_status.mojom-blink.h"
 
 namespace blink {

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

@@ -4,18 +4,10 @@
 
 #include "modules/notifications/NotificationManager.h"
 
-#include "bindings/core/v8/ScriptPromiseResolver.h"
-#include "bindings/core/v8/ScriptState.h"
-#include "modules/notifications/Notification.h"
-#include "modules/notifications/NotificationPermissionCallback.h"
-#include "modules/permissions/Permissions.h"
-#include "platform/UserGestureIndicator.h"
 #include "platform/weborigin/SecurityOrigin.h"
 #include "public/platform/InterfaceProvider.h"
 #include "public/platform/Platform.h"
-#include "public/platform/modules/permissions/permission.mojom-blink.h"
 #include "public/platform/modules/permissions/permission_status.mojom-blink.h"
-#include "wtf/Functional.h"
 
 namespace blink {
 
@@ -43,54 +35,27 @@ const char* NotificationManager::supplementName()
 NotificationManager::NotificationManager(ExecutionContext* executionContext)
     : ContextLifecycleObserver(executionContext)
 {
+    Platform::current()->interfaceProvider()->getInterface(mojo::GetProxy(&m_service));
 }
 
 NotificationManager::~NotificationManager()
 {
 }
 
-mojom::blink::PermissionStatus NotificationManager::permissionStatus()
+mojom::blink::PermissionStatus NotificationManager::permissionStatus() const
 {
-    if (!m_notificationService)
-        Platform::current()->interfaceProvider()->getInterface(mojo::GetProxy(&m_notificationService));
-
     mojom::blink::PermissionStatus permissionStatus;
-    const bool result = m_notificationService->GetPermissionStatus(getExecutionContext()->getSecurityOrigin()->toString(), &permissionStatus);
+
+    const bool result =
+        m_service->GetPermissionStatus(getExecutionContext()->getSecurityOrigin()->toString(), &permissionStatus);
     DCHECK(result);
 
     return permissionStatus;
 }
 
-ScriptPromise NotificationManager::requestPermission(ScriptState* scriptState, NotificationPermissionCallback* deprecatedCallback)
-{
-    ExecutionContext* context = scriptState->getExecutionContext();
-
-    if (!m_permissionService)
-        Permissions::connectToService(context, mojo::GetProxy(&m_permissionService));
-
-    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
-    ScriptPromise promise = resolver->promise();
-
-    m_permissionService->RequestPermission(
-        mojom::blink::PermissionName::NOTIFICATIONS, context->getSecurityOrigin(), UserGestureIndicator::processingUserGesture(),
-        convertToBaseCallback(WTF::bind(&NotificationManager::onPermissionRequestComplete, wrapPersistent(this), wrapPersistent(resolver), wrapPersistent(deprecatedCallback))));
-
-    return promise;
-}
-
 void NotificationManager::contextDestroyed()
 {
-    m_notificationService.reset();
-    m_permissionService.reset();
-}
-
-void NotificationManager::onPermissionRequestComplete(ScriptPromiseResolver* resolver, NotificationPermissionCallback* deprecatedCallback, mojom::blink::PermissionStatus status)
-{
-    String statusString = Notification::permissionString(status);
-    if (deprecatedCallback)
-        deprecatedCallback->handleEvent(statusString);
-
-    resolver->resolve(statusString);
+    m_service.reset();
 }
 
 DEFINE_TRACE(NotificationManager)

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

@@ -8,7 +8,6 @@
 #include "core/dom/ContextLifecycleObserver.h"
 #include "core/dom/ExecutionContext.h"
 #include "public/platform/modules/notifications/notification_service.mojom-blink.h"
-#include "public/platform/modules/permissions/permission.mojom-blink.h"
 #include "wtf/Noncopyable.h"
 #include "wtf/text/WTFString.h"
 
@@ -20,11 +19,6 @@ enum class PermissionStatus;
 }
 }
 
-class NotificationPermissionCallback;
-class ScriptPromise;
-class ScriptPromiseResolver;
-class ScriptState;
-
 // The notification manager, unique to the execution context, is responsible for
 // connecting and communicating with the Mojo notification service.
 //
@@ -43,9 +37,7 @@ public:
 
     // Returns the notification permission status of the current origin. This
     // method is synchronous to support the Notification.permission getter.
-    mojom::blink::PermissionStatus permissionStatus();
-
-    ScriptPromise requestPermission(ScriptState*, NotificationPermissionCallback* deprecatedCallback);
+    mojom::blink::PermissionStatus permissionStatus() const;
 
     // ContextLifecycleObserver implementation.
     void contextDestroyed() override;
@@ -55,10 +47,7 @@ public:
 private:
     explicit NotificationManager(ExecutionContext*);
 
-    void onPermissionRequestComplete(ScriptPromiseResolver*, NotificationPermissionCallback*, mojom::blink::PermissionStatus);
-
-    mojom::blink::NotificationServicePtr m_notificationService;
-    mojom::blink::PermissionServicePtr m_permissionService;
+    mojom::blink::NotificationServicePtr m_service;
 };
 
 } // namespace blink

third_party/WebKit/Source/modules/notifications/NotificationPermissionClient.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 "modules/notifications/NotificationPermissionClient.h"
+
+#include "core/dom/Document.h"
+#include "core/dom/ExecutionContext.h"
+#include "core/frame/LocalFrame.h"
+
+namespace blink {
+
+const char* NotificationPermissionClient::supplementName()
+{
+    return "NotificationPermissionClient";
+}
+
+NotificationPermissionClient* NotificationPermissionClient::from(ExecutionContext* context)
+{
+    if (!context->isDocument())
+        return nullptr;
+
+    const Document* document = toDocument(context);
+    if (!document->frame())
+        return nullptr;
+
+    return static_cast<NotificationPermissionClient*>(Supplement<LocalFrame>::from(document->frame(), supplementName()));
+}
+
+void provideNotificationPermissionClientTo(LocalFrame& frame, NotificationPermissionClient* client)
+{
+    frame.provideSupplement(NotificationPermissionClient::supplementName(), client);
+}
+
+} // namespace blink

third_party/WebKit/Source/modules/notifications/NotificationPermissionClient.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 NotificationPermissionClient_h
+#define NotificationPermissionClient_h
+
+#include "bindings/core/v8/ScriptPromise.h"
+#include "modules/ModulesExport.h"
+#include "platform/Supplementable.h"
+
+namespace blink {
+
+class ExecutionContext;
+class LocalFrame;
+class NotificationPermissionCallback;
+class ScriptState;
+
+class NotificationPermissionClient : public Supplement<LocalFrame> {
+public:
+    virtual ~NotificationPermissionClient() { }
+
+    // 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 ScriptPromise requestPermission(ScriptState*, NotificationPermissionCallback*) = 0;
+
+    // Supplement requirements.
+    static const char* supplementName();
+    static NotificationPermissionClient* from(ExecutionContext*);
+};
+
+MODULES_EXPORT void provideNotificationPermissionClientTo(LocalFrame&, NotificationPermissionClient*);
+
+} // namespace blink
+
+#endif // NotificationPermissionClient_h

third_party/WebKit/Source/web/NotificationPermissionClientImpl.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 "web/NotificationPermissionClientImpl.h"
+
+#include "bindings/core/v8/ScriptPromiseResolver.h"
+#include "bindings/core/v8/ScriptState.h"
+#include "core/dom/Document.h"
+#include "core/dom/ExecutionContext.h"
+#include "modules/notifications/Notification.h"
+#include "modules/notifications/NotificationPermissionCallback.h"
+#include "public/web/WebFrameClient.h"
+#include "public/web/modules/notifications/WebNotificationPermissionCallback.h"
+#include "web/WebLocalFrameImpl.h"
+
+namespace blink {
+
+namespace {
+
+class WebNotificationPermissionCallbackImpl : public WebNotificationPermissionCallback {
+public:
+    WebNotificationPermissionCallbackImpl(ScriptPromiseResolver* resolver, NotificationPermissionCallback* deprecatedCallback)
+        : m_resolver(resolver)
+        , m_deprecatedCallback(deprecatedCallback)
+    {
+    }
+
+    ~WebNotificationPermissionCallbackImpl() override { }
+
+    void permissionRequestComplete(int32_t permissionStatus) override
+    {
+        String permissionString = Notification::permissionString(static_cast<mojom::blink::PermissionStatus>(permissionStatus));
+        if (m_deprecatedCallback)
+            m_deprecatedCallback->handleEvent(permissionString);
+
+        m_resolver->resolve(permissionString);
+    }
+
+private:
+    Persistent<ScriptPromiseResolver> m_resolver;
+    Persistent<NotificationPermissionCallback> m_deprecatedCallback;
+};
+
+} // namespace
+
+NotificationPermissionClientImpl* NotificationPermissionClientImpl::create()
+{
+    return new NotificationPermissionClientImpl();
+}
+
+NotificationPermissionClientImpl::NotificationPermissionClientImpl()
+{
+}
+
+NotificationPermissionClientImpl::~NotificationPermissionClientImpl()
+{
+}
+
+ScriptPromise NotificationPermissionClientImpl::requestPermission(ScriptState* scriptState, NotificationPermissionCallback* deprecatedCallback)
+{
+    DCHECK(scriptState);
+
+    ExecutionContext* context = scriptState->getExecutionContext();
+    DCHECK(context);
+    DCHECK(context->isDocument());
+
+    Document* document = toDocument(context);
+    WebLocalFrameImpl* webFrame = WebLocalFrameImpl::fromFrame(document->frame());
+
+    ScriptPromiseResolver* resolver = ScriptPromiseResolver::create(scriptState);
+    ScriptPromise promise = resolver->promise();
+
+    webFrame->client()->requestNotificationPermission(WebSecurityOrigin(context->getSecurityOrigin()), new WebNotificationPermissionCallbackImpl(resolver, deprecatedCallback));
+
+    return promise;
+}
+
+} // namespace blink

third_party/WebKit/Source/web/NotificationPermissionClientImpl.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 NotificationPermissionClientImpl_h
+#define NotificationPermissionClientImpl_h
+
+#include "modules/notifications/NotificationPermissionClient.h"
+#include "platform/heap/Handle.h"
+
+namespace blink {
+
+class NotificationPermissionClientImpl : public GarbageCollectedFinalized<NotificationPermissionClientImpl>, public NotificationPermissionClient {
+    USING_GARBAGE_COLLECTED_MIXIN(NotificationPermissionClientImpl);
+public:
+    static NotificationPermissionClientImpl* create();
+
+    ~NotificationPermissionClientImpl() override;
+
+    // NotificationPermissionClient implementation.
+    ScriptPromise requestPermission(ScriptState*, NotificationPermissionCallback*) override;
+
+    // GarbageCollectedFinalized implementation.
+    DEFINE_INLINE_VIRTUAL_TRACE() { NotificationPermissionClient::trace(visitor); }
+
+private:
+    NotificationPermissionClientImpl();
+};
+
+} // namespace blink
+
+#endif // NotificationPermissionClientImpl_h

third_party/WebKit/Source/web/WebLocalFrameImpl.cpp

@@ -156,6 +156,7 @@
 #include "modules/audio_output_devices/AudioOutputDeviceClient.h"
 #include "modules/bluetooth/BluetoothSupplement.h"
 #include "modules/installedapp/InstalledAppController.h"
+#include "modules/notifications/NotificationPermissionClient.h"
 #include "modules/presentation/PresentationController.h"
 #include "modules/push_messaging/PushController.h"
 #include "modules/screen_orientation/ScreenOrientationController.h"
@@ -220,6 +221,7 @@
 #include "web/IndexedDBClientImpl.h"
 #include "web/LocalFileSystemClient.h"
 #include "web/NavigatorContentUtilsClientImpl.h"
+#include "web/NotificationPermissionClientImpl.h"
 #include "web/RemoteFrameOwner.h"
 #include "web/SharedWorkerRepositoryClientImpl.h"
 #include "web/SuspendableScriptExecutor.h"
@@ -1492,6 +1494,7 @@ void WebLocalFrameImpl::setCoreFrame(LocalFrame* frame)
         provideUserMediaTo(*m_frame, UserMediaClientImpl::create(m_client->userMediaClient()));
     }
 
+    provideNotificationPermissionClientTo(*m_frame, NotificationPermissionClientImpl::create());
     provideIndexedDBClientTo(*m_frame, IndexedDBClientImpl::create());
     provideLocalFileSystemTo(*m_frame, LocalFileSystemClient::create());
     provideNavigatorContentUtilsTo(*m_frame, NavigatorContentUtilsClientImpl::create(this));

third_party/WebKit/Source/web/web.gypi

@@ -61,6 +61,8 @@
       'MediaKeysClientImpl.h',
       'NavigatorContentUtilsClientImpl.cpp',
       'NavigatorContentUtilsClientImpl.h',
+      'NotificationPermissionClientImpl.cpp',
+      'NotificationPermissionClientImpl.h',
       'OpenedFrameTracker.cpp',
       'OpenedFrameTracker.h',
       'PageOverlay.cpp',

third_party/WebKit/public/blink_headers.gypi

@@ -483,6 +483,7 @@
       "web/linux/WebFontRendering.h",
       "web/mac/WebScrollbarTheme.h",
       "web/mac/WebSubstringUtil.h",
+      "web/modules/notifications/WebNotificationPermissionCallback.h",
       "web/modules/serviceworker/WebServiceWorkerContextClient.h",
       "web/modules/serviceworker/WebServiceWorkerContextProxy.h",
       "web/modules/serviceworker/WebServiceWorkerNetworkProvider.h",

third_party/WebKit/public/web/WebFrameClient.h

@@ -89,6 +89,7 @@ class WebMediaPlayerEncryptedMediaClient;
 class WebMediaPlayerSource;
 class WebMediaSession;
 class WebMediaStream;
+class WebNotificationPermissionCallback;
 class WebServiceWorkerProvider;
 class WebSocketHandle;
 class WebPlugin;
@@ -370,6 +371,11 @@ public:
     // Returns the effective connection type when the frame was fetched.
     virtual WebEffectiveConnectionType getEffectiveConnectionType() { return WebEffectiveConnectionType::TypeUnknown; }
 
+    // Web Notifications ---------------------------------------------------
+
+    // Requests permission to display platform notifications on the origin of this frame.
+    virtual void requestNotificationPermission(const WebSecurityOrigin&, WebNotificationPermissionCallback* callback) { }
+
 
     // Push API ---------------------------------------------------
 

third_party/WebKit/public/web/modules/notifications/OWNERS

+peter@chromium.org
\ No newline at end of file

third_party/WebKit/public/web/modules/notifications/WebNotificationPermissionCallback.h

+/*
+ * Copyright (C) 2009 Google Inc. All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are
+ * met:
+ *
+ *     * Redistributions of source code must retain the above copyright
+ * notice, this list of conditions and the following disclaimer.
+ *     * Redistributions in binary form must reproduce the above
+ * copyright notice, this list of conditions and the following disclaimer
+ * in the documentation and/or other materials provided with the
+ * distribution.
+ *     * Neither the name of Google Inc. nor the names of its
+ * contributors may be used to endorse or promote products derived from
+ * this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+ * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+ * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+ * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+ * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+ * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+ * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+ * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef WebNotificationPermissionCallback_h
+#define WebNotificationPermissionCallback_h
+
+namespace blink {
+
+// Callback object used for Web Notification permission requests.
+class WebNotificationPermissionCallback {
+public:
+    virtual ~WebNotificationPermissionCallback() { }
+
+    // Method to be invoked when the asynchronous permission request for the
+    // ability to display Web Notifications has been completed.
+    virtual void permissionRequestComplete(int32_t permissionStatus) = 0;
+};
+
+} // namespace blink
+
+#endif