Imported QtWebKit TP3 (git b57bc6801f1876c3220d5a4bfea33d620d477443)

Change-Id: I3b1d8a2808782c9f34d50240000e20cb38d3680f
Reviewed-by: Konstantin Tokarev <annulen@yandex.ru>

10 files changed, 121 insertions, 126 deletions

diff --git a/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequest.cpp b/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequest.cpp
index 25d37da4b..2128627c5 100644
--- a/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequest.cpp
+++ b/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequest.cpp
@@ -30,9 +30,9 @@
 
 namespace WebKit {
     
-PassRefPtr<NotificationPermissionRequest> NotificationPermissionRequest::create(WebKit::NotificationPermissionRequestManagerProxy *manager, uint64_t notificationID)
+Ref<NotificationPermissionRequest> NotificationPermissionRequest::create(WebKit::NotificationPermissionRequestManagerProxy *manager, uint64_t notificationID)
 {
-    return adoptRef(new NotificationPermissionRequest(manager, notificationID));
+    return adoptRef(*new NotificationPermissionRequest(manager, notificationID));
 }
 
 NotificationPermissionRequest::NotificationPermissionRequest(NotificationPermissionRequestManagerProxy* manager, uint64_t notificationID)
diff --git a/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequest.h b/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequest.h
index 2576a7a6f..e04840659 100644
--- a/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequest.h
+++ b/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequest.h
@@ -33,9 +33,9 @@ namespace WebKit {
 
 class NotificationPermissionRequestManagerProxy;
 
-class NotificationPermissionRequest : public TypedAPIObject<APIObject::TypeNotificationPermissionRequest> {
+class NotificationPermissionRequest : public API::ObjectImpl<API::Object::Type::NotificationPermissionRequest> {
 public:
-    static PassRefPtr<NotificationPermissionRequest> create(NotificationPermissionRequestManagerProxy*, uint64_t notificationID);
+    static Ref<NotificationPermissionRequest> create(NotificationPermissionRequestManagerProxy*, uint64_t notificationID);
 
     void allow();
     void deny();
diff --git a/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequestManagerProxy.cpp b/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequestManagerProxy.cpp
index 4a0c47529..0b2a63297 100644
--- a/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequestManagerProxy.cpp
+++ b/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequestManagerProxy.cpp
@@ -33,18 +33,16 @@
 
 namespace WebKit {
 
-NotificationPermissionRequestManagerProxy::NotificationPermissionRequestManagerProxy(WebPageProxy* page)
+NotificationPermissionRequestManagerProxy::NotificationPermissionRequestManagerProxy(WebPageProxy& page)
     : m_page(page)
 {
 }
 
 void NotificationPermissionRequestManagerProxy::invalidateRequests()
 {
-    PendingRequestMap::const_iterator it = m_pendingRequests.begin();
-    PendingRequestMap::const_iterator end = m_pendingRequests.end();
-    for (; it != end; ++it)
-        it->value->invalidate();
-    
+    for (auto& request : m_pendingRequests.values())
+        request->invalidate();
+
     m_pendingRequests.clear();
 }
 
@@ -57,14 +55,14 @@ PassRefPtr<NotificationPermissionRequest> NotificationPermissionRequestManagerPr
 
 void NotificationPermissionRequestManagerProxy::didReceiveNotificationPermissionDecision(uint64_t notificationID, bool allow)
 {
-    if (!m_page->isValid())
+    if (!m_page.isValid())
         return;
     
     RefPtr<NotificationPermissionRequest> request = m_pendingRequests.take(notificationID);
     if (!request)
         return;
     
-    m_page->process()->send(Messages::WebPage::DidReceiveNotificationPermissionDecision(notificationID, allow), m_page->pageID());
+    m_page.process().send(Messages::WebPage::DidReceiveNotificationPermissionDecision(notificationID, allow), m_page.pageID());
 }
 
 } // namespace WebKit
diff --git a/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequestManagerProxy.h b/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequestManagerProxy.h
index 12775fb06..5bc83f6f5 100644
--- a/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequestManagerProxy.h
+++ b/Source/WebKit2/UIProcess/Notifications/NotificationPermissionRequestManagerProxy.h
@@ -36,7 +36,7 @@ class WebPageProxy;
 
 class NotificationPermissionRequestManagerProxy {
 public:
-    explicit NotificationPermissionRequestManagerProxy(WebPageProxy*);
+    explicit NotificationPermissionRequestManagerProxy(WebPageProxy&);
     
     void invalidateRequests();
     
@@ -47,12 +47,10 @@ public:
     void didReceiveNotificationPermissionDecision(uint64_t notificationID, bool allow);
     
 private:
-    typedef HashMap<uint64_t, RefPtr<NotificationPermissionRequest> > PendingRequestMap;
-    PendingRequestMap m_pendingRequests;
-    WebPageProxy* m_page;
+    HashMap<uint64_t, RefPtr<NotificationPermissionRequest>> m_pendingRequests;
+    WebPageProxy& m_page;
 };
 
 } // namespace WebKit
 
-
 #endif // NotificationPermissionRequestManagerProxy_h
diff --git a/Source/WebKit2/UIProcess/Notifications/WebNotification.cpp b/Source/WebKit2/UIProcess/Notifications/WebNotification.cpp
index 3705fb064..3d7bc00fe 100644
--- a/Source/WebKit2/UIProcess/Notifications/WebNotification.cpp
+++ b/Source/WebKit2/UIProcess/Notifications/WebNotification.cpp
@@ -40,7 +40,7 @@ WebNotification::WebNotification(const String& title, const String& body, const
     , m_tag(tag)
     , m_lang(lang)
     , m_dir(dir)
-    , m_origin(WebSecurityOrigin::createFromString(originString))
+    , m_origin(API::SecurityOrigin::createFromString(originString))
     , m_notificationID(notificationID)
 {
 }
diff --git a/Source/WebKit2/UIProcess/Notifications/WebNotification.h b/Source/WebKit2/UIProcess/Notifications/WebNotification.h
index 14e905c53..5fd3da718 100644
--- a/Source/WebKit2/UIProcess/Notifications/WebNotification.h
+++ b/Source/WebKit2/UIProcess/Notifications/WebNotification.h
@@ -27,25 +27,25 @@
 #define WebNotification_h
 
 #include "APIObject.h"
-#include "WebSecurityOrigin.h"
+#include "APISecurityOrigin.h"
 #include <wtf/PassRefPtr.h>
 #include <wtf/RefPtr.h>
 #include <wtf/text/WTFString.h>
 
-namespace CoreIPC {
+namespace IPC {
 
 class ArgumentDecoder;
 class ArgumentEncoder;
 
-} // namespace CoreIPC
+} // namespace IPC
 
 namespace WebKit {
 
-class WebNotification : public TypedAPIObject<APIObject::TypeNotification> {
+class WebNotification : public API::ObjectImpl<API::Object::Type::Notification> {
 public:
-    static PassRefPtr<WebNotification> create(const String& title, const String& body, const String& iconURL, const String& tag, const String& lang, const String& dir, const String& originString, uint64_t notificationID)
+    static Ref<WebNotification> create(const String& title, const String& body, const String& iconURL, const String& tag, const String& lang, const String& dir, const String& originString, uint64_t notificationID)
     {
-        return adoptRef(new WebNotification(title, body, iconURL, tag, lang, dir, originString, notificationID));
+        return adoptRef(*new WebNotification(title, body, iconURL, tag, lang, dir, originString, notificationID));
     }
 
     const String& title() const { return m_title; }
@@ -54,7 +54,7 @@ public:
     const String& tag() const { return m_tag; }
     const String& lang() const { return m_lang; }
     const String& dir() const { return m_dir; }
-    WebSecurityOrigin* origin() const { return m_origin.get(); }
+    API::SecurityOrigin* origin() const { return m_origin.get(); }
     
     uint64_t notificationID() const { return m_notificationID; }
 
@@ -67,7 +67,7 @@ private:
     String m_tag;
     String m_lang;
     String m_dir;
-    RefPtr<WebSecurityOrigin> m_origin;
+    RefPtr<API::SecurityOrigin> m_origin;
     uint64_t m_notificationID;
 };
 
diff --git a/Source/WebKit2/UIProcess/Notifications/WebNotificationManagerProxy.cpp b/Source/WebKit2/UIProcess/Notifications/WebNotificationManagerProxy.cpp
index 5bb3db5f7..626351687 100644
--- a/Source/WebKit2/UIProcess/Notifications/WebNotificationManagerProxy.cpp
+++ b/Source/WebKit2/UIProcess/Notifications/WebNotificationManagerProxy.cpp
@@ -26,17 +26,15 @@
 #include "config.h"
 #include "WebNotificationManagerProxy.h"
 
-#include "ImmutableArray.h"
-#include "ImmutableDictionary.h"
-#include "WebContext.h"
+#include "APIArray.h"
+#include "APIDictionary.h"
+#include "APISecurityOrigin.h"
 #include "WebNotification.h"
 #include "WebNotificationManagerMessages.h"
 #include "WebPageProxy.h"
+#include "WebProcessPool.h"
 #include "WebProcessProxy.h"
-#include "WebSecurityOrigin.h"
 
-using namespace std;
-using namespace WTF;
 using namespace WebCore;
 
 namespace WebKit {
@@ -52,17 +50,17 @@ const char* WebNotificationManagerProxy::supplementName()
     return "WebNotificationManagerProxy";
 }
 
-PassRefPtr<WebNotificationManagerProxy> WebNotificationManagerProxy::create(WebContext* context)
+Ref<WebNotificationManagerProxy> WebNotificationManagerProxy::create(WebProcessPool* processPool)
 {
-    return adoptRef(new WebNotificationManagerProxy(context));
+    return adoptRef(*new WebNotificationManagerProxy(processPool));
 }
 
-WebNotificationManagerProxy::WebNotificationManagerProxy(WebContext* context)
-    : WebContextSupplement(context)
+WebNotificationManagerProxy::WebNotificationManagerProxy(WebProcessPool* processPool)
+    : WebContextSupplement(processPool)
 {
 }
 
-void WebNotificationManagerProxy::initializeProvider(const WKNotificationProvider *provider)
+void WebNotificationManagerProxy::initializeProvider(const WKNotificationProviderBase* provider)
 {
     m_provider.initialize(provider);
     m_provider.addNotificationManager(this);
@@ -70,33 +68,33 @@ void WebNotificationManagerProxy::initializeProvider(const WKNotificationProvide
 
 // WebContextSupplement
 
-void WebNotificationManagerProxy::contextDestroyed()
+void WebNotificationManagerProxy::processPoolDestroyed()
 {
     m_provider.removeNotificationManager(this);
 }
 
 void WebNotificationManagerProxy::refWebContextSupplement()
 {
-    APIObject::ref();
+    API::Object::ref();
 }
 
 void WebNotificationManagerProxy::derefWebContextSupplement()
 {
-    APIObject::deref();
+    API::Object::deref();
 }
 
 void WebNotificationManagerProxy::populateCopyOfNotificationPermissions(HashMap<String, bool>& permissions)
 {
-    RefPtr<ImmutableDictionary> knownPermissions = m_provider.notificationPermissions();
+    RefPtr<API::Dictionary> knownPermissions = m_provider.notificationPermissions();
 
     if (!knownPermissions)
         return;
 
     permissions.clear();
-    RefPtr<ImmutableArray> knownOrigins = knownPermissions->keys();
+    Ref<API::Array> knownOrigins = knownPermissions->keys();
     for (size_t i = 0; i < knownOrigins->size(); ++i) {
-        WebString* origin = knownOrigins->at<WebString>(i);
-        permissions.set(origin->string(), knownPermissions->get<WebBoolean>(origin->string())->value());
+        API::String* origin = knownOrigins->at<API::String>(i);
+        permissions.set(origin->string(), knownPermissions->get<API::Boolean>(origin->string())->value());
     }
 }
 
@@ -104,21 +102,21 @@ void WebNotificationManagerProxy::show(WebPageProxy* webPage, const String& titl
 {
     uint64_t globalNotificationID = generateGlobalNotificationID();
     RefPtr<WebNotification> notification = WebNotification::create(title, body, iconURL, tag, lang, dir, originString, globalNotificationID);
-    pair<uint64_t, uint64_t> notificationIDPair = make_pair(webPage->pageID(), pageNotificationID);
+    std::pair<uint64_t, uint64_t> notificationIDPair = std::make_pair(webPage->pageID(), pageNotificationID);
     m_globalNotificationMap.set(globalNotificationID, notificationIDPair);
-    m_notifications.set(notificationIDPair, make_pair(globalNotificationID, notification));
+    m_notifications.set(notificationIDPair, std::make_pair(globalNotificationID, notification));
     m_provider.show(webPage, notification.get());
 }
 
 void WebNotificationManagerProxy::cancel(WebPageProxy* webPage, uint64_t pageNotificationID)
 {
-    if (WebNotification* notification = m_notifications.get(make_pair(webPage->pageID(), pageNotificationID)).second.get())
+    if (WebNotification* notification = m_notifications.get(std::make_pair(webPage->pageID(), pageNotificationID)).second.get())
         m_provider.cancel(notification);
 }
     
 void WebNotificationManagerProxy::didDestroyNotification(WebPageProxy* webPage, uint64_t pageNotificationID)
 {
-    pair<uint64_t, RefPtr<WebNotification> > globalIDNotificationPair = m_notifications.take(make_pair(webPage->pageID(), pageNotificationID));
+    auto globalIDNotificationPair = m_notifications.take(std::make_pair(webPage->pageID(), pageNotificationID));
     if (uint64_t globalNotificationID = globalIDNotificationPair.first) {
         WebNotification* notification = globalIDNotificationPair.second.get();
         m_globalNotificationMap.remove(globalNotificationID);
@@ -153,28 +151,19 @@ void WebNotificationManagerProxy::clearNotifications(WebPageProxy* webPage, cons
     Vector<uint64_t> globalNotificationIDs;
     globalNotificationIDs.reserveCapacity(m_globalNotificationMap.size());
 
-    {
-        HashMap<pair<uint64_t, uint64_t>, pair<uint64_t, RefPtr<WebNotification> > >::iterator it  = m_notifications.begin();
-        HashMap<pair<uint64_t, uint64_t>, pair<uint64_t, RefPtr<WebNotification> > >::iterator end  = m_notifications.end();
-        for (; it != end; ++it) {
-            uint64_t webPageID = it->key.first;
-            uint64_t pageNotificationID = it->key.second;
-            if (!filterFunction(webPageID, pageNotificationID, targetPageID, pageNotificationIDs))
-                continue;
-
-            uint64_t globalNotificationID = it->value.first;
-            globalNotificationIDs.append(globalNotificationID);
-        }
-    }
+    for (auto it = m_notifications.begin(), end = m_notifications.end(); it != end; ++it) {
+        uint64_t webPageID = it->key.first;
+        uint64_t pageNotificationID = it->key.second;
+        if (!filterFunction(webPageID, pageNotificationID, targetPageID, pageNotificationIDs))
+            continue;
 
+        uint64_t globalNotificationID = it->value.first;
+        globalNotificationIDs.append(globalNotificationID);
+    }
 
-    {
-        Vector<uint64_t>::iterator it = globalNotificationIDs.begin();
-        Vector<uint64_t>::iterator end = globalNotificationIDs.end();
-        for (; it != end; ++it) {
-            pair<uint64_t, uint64_t> pageNotification = m_globalNotificationMap.take(*it);
-            m_notifications.remove(pageNotification);
-        }
+    for (auto it = globalNotificationIDs.begin(), end = globalNotificationIDs.end(); it != end; ++it) {
+        auto pageNotification = m_globalNotificationMap.take(*it);
+        m_notifications.remove(pageNotification);
     }
 
     m_provider.clearNotifications(globalNotificationIDs);
@@ -182,7 +171,7 @@ void WebNotificationManagerProxy::clearNotifications(WebPageProxy* webPage, cons
 
 void WebNotificationManagerProxy::providerDidShowNotification(uint64_t globalNotificationID)
 {
-    HashMap<uint64_t, pair<uint64_t, uint64_t> >::iterator it = m_globalNotificationMap.find(globalNotificationID);
+    auto it = m_globalNotificationMap.find(globalNotificationID);
     if (it == m_globalNotificationMap.end())
         return;
 
@@ -192,12 +181,12 @@ void WebNotificationManagerProxy::providerDidShowNotification(uint64_t globalNot
         return;
 
     uint64_t pageNotificationID = it->value.second;
-    webPage->process()->send(Messages::WebNotificationManager::DidShowNotification(pageNotificationID), 0);
+    webPage->process().send(Messages::WebNotificationManager::DidShowNotification(pageNotificationID), 0);
 }
 
 void WebNotificationManagerProxy::providerDidClickNotification(uint64_t globalNotificationID)
 {
-    HashMap<uint64_t, pair<uint64_t, uint64_t> >::iterator it = m_globalNotificationMap.find(globalNotificationID);
+    auto it = m_globalNotificationMap.find(globalNotificationID);
     if (it == m_globalNotificationMap.end())
         return;
     
@@ -207,26 +196,26 @@ void WebNotificationManagerProxy::providerDidClickNotification(uint64_t globalNo
         return;
 
     uint64_t pageNotificationID = it->value.second;
-    webPage->process()->send(Messages::WebNotificationManager::DidClickNotification(pageNotificationID), 0);
+    webPage->process().send(Messages::WebNotificationManager::DidClickNotification(pageNotificationID), 0);
 }
 
 
-void WebNotificationManagerProxy::providerDidCloseNotifications(ImmutableArray* globalNotificationIDs)
+void WebNotificationManagerProxy::providerDidCloseNotifications(API::Array* globalNotificationIDs)
 {
-    HashMap<WebPageProxy*, Vector<uint64_t> > pageNotificationIDs;
+    HashMap<WebPageProxy*, Vector<uint64_t>> pageNotificationIDs;
     
     size_t size = globalNotificationIDs->size();
     for (size_t i = 0; i < size; ++i) {
-        HashMap<uint64_t, pair<uint64_t, uint64_t> >::iterator it = m_globalNotificationMap.find(globalNotificationIDs->at<WebUInt64>(i)->value());
+        auto it = m_globalNotificationMap.find(globalNotificationIDs->at<API::UInt64>(i)->value());
         if (it == m_globalNotificationMap.end())
             continue;
 
         if (WebPageProxy* webPage = WebProcessProxy::webPage(it->value.first)) {
-            HashMap<WebPageProxy*, Vector<uint64_t> >::iterator pageIt = pageNotificationIDs.find(webPage);
+            auto pageIt = pageNotificationIDs.find(webPage);
             if (pageIt == pageNotificationIDs.end()) {
                 Vector<uint64_t> newVector;
                 newVector.reserveInitialCapacity(size);
-                pageIt = pageNotificationIDs.add(webPage, newVector).iterator;
+                pageIt = pageNotificationIDs.add(webPage, WTFMove(newVector)).iterator;
             }
 
             uint64_t pageNotificationID = it->value.second;
@@ -237,21 +226,21 @@ void WebNotificationManagerProxy::providerDidCloseNotifications(ImmutableArray*
         m_globalNotificationMap.remove(it);
     }
 
-    for (HashMap<WebPageProxy*, Vector<uint64_t> >::iterator it = pageNotificationIDs.begin(), end = pageNotificationIDs.end(); it != end; ++it)
-        it->key->process()->send(Messages::WebNotificationManager::DidCloseNotifications(it->value), 0);
+    for (auto it = pageNotificationIDs.begin(), end = pageNotificationIDs.end(); it != end; ++it)
+        it->key->process().send(Messages::WebNotificationManager::DidCloseNotifications(it->value), 0);
 }
 
-void WebNotificationManagerProxy::providerDidUpdateNotificationPolicy(const WebSecurityOrigin* origin, bool allowed)
+void WebNotificationManagerProxy::providerDidUpdateNotificationPolicy(const API::SecurityOrigin* origin, bool allowed)
 {
-    if (!context())
+    if (!processPool())
         return;
 
-    context()->sendToAllProcesses(Messages::WebNotificationManager::DidUpdateNotificationDecision(origin->toString(), allowed));
+    processPool()->sendToAllProcesses(Messages::WebNotificationManager::DidUpdateNotificationDecision(origin->securityOrigin().toString(), allowed));
 }
 
-void WebNotificationManagerProxy::providerDidRemoveNotificationPolicies(ImmutableArray* origins)
+void WebNotificationManagerProxy::providerDidRemoveNotificationPolicies(API::Array* origins)
 {
-    if (!context())
+    if (!processPool())
         return;
 
     size_t size = origins->size();
@@ -262,9 +251,9 @@ void WebNotificationManagerProxy::providerDidRemoveNotificationPolicies(Immutabl
     originStrings.reserveInitialCapacity(size);
     
     for (size_t i = 0; i < size; ++i)
-        originStrings.append(origins->at<WebSecurityOrigin>(i)->toString());
+        originStrings.append(origins->at<API::SecurityOrigin>(i)->securityOrigin().toString());
     
-    context()->sendToAllProcesses(Messages::WebNotificationManager::DidRemoveNotificationDecisions(originStrings));
+    processPool()->sendToAllProcesses(Messages::WebNotificationManager::DidRemoveNotificationDecisions(originStrings));
 }
 
 } // namespace WebKit
diff --git a/Source/WebKit2/UIProcess/Notifications/WebNotificationManagerProxy.h b/Source/WebKit2/UIProcess/Notifications/WebNotificationManagerProxy.h
index 98b472e82..02a2269e5 100644
--- a/Source/WebKit2/UIProcess/Notifications/WebNotificationManagerProxy.h
+++ b/Source/WebKit2/UIProcess/Notifications/WebNotificationManagerProxy.h
@@ -32,25 +32,27 @@
 #include "WebNotificationProvider.h"
 #include <WebCore/NotificationClient.h>
 #include <wtf/HashMap.h>
-#include <wtf/OwnPtr.h>
 #include <wtf/PassRefPtr.h>
 #include <wtf/text/StringHash.h>
 
+namespace API {
+class Array;
+class SecurityOrigin;
+}
+
 namespace WebKit {
 
-class ImmutableArray;
-class WebContext;
 class WebPageProxy;
-class WebSecurityOrigin;
+class WebProcessPool;
 
-class WebNotificationManagerProxy : public TypedAPIObject<APIObject::TypeNotificationManager>, public WebContextSupplement {
+class WebNotificationManagerProxy : public API::ObjectImpl<API::Object::Type::NotificationManager>, public WebContextSupplement {
 public:
 
     static const char* supplementName();
 
-    static PassRefPtr<WebNotificationManagerProxy> create(WebContext*);
+    static Ref<WebNotificationManagerProxy> create(WebProcessPool*);
 
-    void initializeProvider(const WKNotificationProvider*);
+    void initializeProvider(const WKNotificationProviderBase*);
     void populateCopyOfNotificationPermissions(HashMap<String, bool>&);
 
     void show(WebPageProxy*, const String& title, const String& body, const String& iconURL, const String& tag, const String& lang, const String& dir, const String& originString, uint64_t pageNotificationID);
@@ -61,29 +63,29 @@ public:
 
     void providerDidShowNotification(uint64_t notificationID);
     void providerDidClickNotification(uint64_t notificationID);
-    void providerDidCloseNotifications(ImmutableArray* notificationIDs);
-    void providerDidUpdateNotificationPolicy(const WebSecurityOrigin*, bool allowed);
-    void providerDidRemoveNotificationPolicies(ImmutableArray* origins);
+    void providerDidCloseNotifications(API::Array* notificationIDs);
+    void providerDidUpdateNotificationPolicy(const API::SecurityOrigin*, bool allowed);
+    void providerDidRemoveNotificationPolicies(API::Array* origins);
 
-    using APIObject::ref;
-    using APIObject::deref;
+    using API::Object::ref;
+    using API::Object::deref;
 
 private:
-    explicit WebNotificationManagerProxy(WebContext*);
+    explicit WebNotificationManagerProxy(WebProcessPool*);
 
     typedef bool (*NotificationFilterFunction)(uint64_t pageID, uint64_t pageNotificationID, uint64_t desiredPageID, const Vector<uint64_t>& desiredPageNotificationIDs);
     void clearNotifications(WebPageProxy*, const Vector<uint64_t>& pageNotificationIDs, NotificationFilterFunction);
 
     // WebContextSupplement
-    virtual void contextDestroyed() OVERRIDE;
-    virtual void refWebContextSupplement() OVERRIDE;
-    virtual void derefWebContextSupplement() OVERRIDE;
+    virtual void processPoolDestroyed() override;
+    virtual void refWebContextSupplement() override;
+    virtual void derefWebContextSupplement() override;
 
     WebNotificationProvider m_provider;
     // Pair comprised of web page ID and the web process's notification ID
-    HashMap<uint64_t, pair<uint64_t, uint64_t> > m_globalNotificationMap;
+    HashMap<uint64_t, std::pair<uint64_t, uint64_t>> m_globalNotificationMap;
     // Key pair comprised of web page ID and the web process's notification ID; value pair comprised of global notification ID, and notification object
-    HashMap<pair<uint64_t, uint64_t>, pair<uint64_t, RefPtr<WebNotification> > > m_notifications;
+    HashMap<std::pair<uint64_t, uint64_t>, std::pair<uint64_t, RefPtr<WebNotification>>> m_notifications;
 };
 
 } // namespace WebKit
diff --git a/Source/WebKit2/UIProcess/Notifications/WebNotificationProvider.cpp b/Source/WebKit2/UIProcess/Notifications/WebNotificationProvider.cpp
index 133e79aaa..a2a83ada0 100644
--- a/Source/WebKit2/UIProcess/Notifications/WebNotificationProvider.cpp
+++ b/Source/WebKit2/UIProcess/Notifications/WebNotificationProvider.cpp
@@ -26,13 +26,14 @@
 #include "config.h"
 #include "WebNotificationProvider.h"
 
-#include "ImmutableDictionary.h"
-#include "MutableArray.h"
+#include "APIArray.h"
+#include "APIDictionary.h"
+#include "APINumber.h"
+#include "APISecurityOrigin.h"
 #include "WKAPICast.h"
 #include "WebNotification.h"
 #include "WebNotificationManagerProxy.h"
-#include "WebNumber.h"
-#include "WebSecurityOrigin.h"
+#include "WebPageProxy.h"
 
 namespace WebKit {
 
@@ -41,7 +42,7 @@ void WebNotificationProvider::show(WebPageProxy* page, WebNotification* notifica
     if (!m_client.show)
         return;
     
-    m_client.show(toAPI(page), toAPI(notification), m_client.clientInfo);
+    m_client.show(toAPI(page), toAPI(notification), m_client.base.clientInfo);
 }
 
 void WebNotificationProvider::cancel(WebNotification* notification)
@@ -49,7 +50,7 @@ void WebNotificationProvider::cancel(WebNotification* notification)
     if (!m_client.cancel)
         return;
     
-    m_client.cancel(toAPI(notification), m_client.clientInfo);
+    m_client.cancel(toAPI(notification), m_client.base.clientInfo);
 }
 
 void WebNotificationProvider::didDestroyNotification(WebNotification* notification)
@@ -57,7 +58,7 @@ void WebNotificationProvider::didDestroyNotification(WebNotification* notificati
     if (!m_client.didDestroyNotification)
         return;
     
-    m_client.didDestroyNotification(toAPI(notification), m_client.clientInfo);
+    m_client.didDestroyNotification(toAPI(notification), m_client.base.clientInfo);
 }
 
 void WebNotificationProvider::clearNotifications(const Vector<uint64_t>& notificationIDs)
@@ -65,13 +66,13 @@ void WebNotificationProvider::clearNotifications(const Vector<uint64_t>& notific
     if (!m_client.clearNotifications)
         return;
 
-    RefPtr<MutableArray> arrayIDs = MutableArray::create();
-    size_t count = notificationIDs.size();
-    arrayIDs->reserveCapacity(count);
-    for (size_t i = 0; i < count; ++i)
-        arrayIDs->append(WebUInt64::create(notificationIDs[i]).leakRef());
+    Vector<RefPtr<API::Object>> arrayIDs;
+    arrayIDs.reserveInitialCapacity(notificationIDs.size());
 
-    m_client.clearNotifications(toAPI(arrayIDs.get()), m_client.clientInfo);
+    for (const auto& notificationID : notificationIDs)
+        arrayIDs.uncheckedAppend(API::UInt64::create(notificationID));
+
+    m_client.clearNotifications(toAPI(API::Array::create(WTFMove(arrayIDs)).ptr()), m_client.base.clientInfo);
 }
 
 void WebNotificationProvider::addNotificationManager(WebNotificationManagerProxy* manager)
@@ -79,7 +80,7 @@ void WebNotificationProvider::addNotificationManager(WebNotificationManagerProxy
     if (!m_client.addNotificationManager)
         return;
     
-    m_client.addNotificationManager(toAPI(manager), m_client.clientInfo);
+    m_client.addNotificationManager(toAPI(manager), m_client.base.clientInfo);
 }
 
 void WebNotificationProvider::removeNotificationManager(WebNotificationManagerProxy* manager)
@@ -87,15 +88,15 @@ void WebNotificationProvider::removeNotificationManager(WebNotificationManagerPr
     if (!m_client.removeNotificationManager)
         return;
     
-    m_client.removeNotificationManager(toAPI(manager), m_client.clientInfo);
+    m_client.removeNotificationManager(toAPI(manager), m_client.base.clientInfo);
 }
 
-PassRefPtr<ImmutableDictionary> WebNotificationProvider::notificationPermissions()
+PassRefPtr<API::Dictionary> WebNotificationProvider::notificationPermissions()
 {
     if (!m_client.notificationPermissions)
-        return ImmutableDictionary::create();
+        return API::Dictionary::create();
 
-    return adoptRef(toImpl(m_client.notificationPermissions(m_client.clientInfo)));
+    return adoptRef(toImpl(m_client.notificationPermissions(m_client.base.clientInfo)));
 }
 
 } // namespace WebKit
diff --git a/Source/WebKit2/UIProcess/Notifications/WebNotificationProvider.h b/Source/WebKit2/UIProcess/Notifications/WebNotificationProvider.h
index 574b887a4..14fabe16c 100644
--- a/Source/WebKit2/UIProcess/Notifications/WebNotificationProvider.h
+++ b/Source/WebKit2/UIProcess/Notifications/WebNotificationProvider.h
@@ -31,15 +31,22 @@
 #include <wtf/Forward.h>
 #include <wtf/Vector.h>
 
+namespace API {
+
+class Dictionary;
+
+template<> struct ClientTraits<WKNotificationProviderBase> {
+    typedef std::tuple<WKNotificationProviderV0> Versions;
+};
+}
+
 namespace WebKit {
 
-class ImmutableDictionary;
 class WebNotification;
 class WebNotificationManagerProxy;
 class WebPageProxy;
-class WebSecurityOrigin;
     
-class WebNotificationProvider : public APIClient<WKNotificationProvider, kWKNotificationProviderCurrentVersion> {
+class WebNotificationProvider : public API::Client<WKNotificationProviderBase> {
 public:
     void show(WebPageProxy*, WebNotification*);
     void cancel(WebNotification*);
@@ -49,7 +56,7 @@ public:
     void addNotificationManager(WebNotificationManagerProxy*);
     void removeNotificationManager(WebNotificationManagerProxy*);
     
-    PassRefPtr<ImmutableDictionary> notificationPermissions();
+    PassRefPtr<API::Dictionary> notificationPermissions();
 };
 
 } // namespace WebKit