Attachment 356465 Details for Bug 192352 – Patch

[patch] Patch

bug-192352-20181204145957.patch (text/plain), 59.47 KB, created by Fujii Hironori on 2018-12-03 21:59:59 PST

(hide)

Description:

Filename:

MIME Type:

Creator: Fujii Hironori

Created: 2018-12-03 21:59:59 PST

Size: 59.47 KB

patch

obsolete

>Subversion Revision: 238835
>diff --git a/Source/WebKit/ChangeLog b/Source/WebKit/ChangeLog
>index b9c03493004af1babf4cbcb2d795ee6960021f97..d9e76c51ff45f27680e48f501eb7e67151ca02f3 100644
>--- a/Source/WebKit/ChangeLog
>+++ b/Source/WebKit/ChangeLog
>@@ -1,3 +1,41 @@
>+2018-12-03  Fujii Hironori  <Hironori.Fujii@sony.com>
>+
>+        Remove using namespace WebCore and WebKit under WebKit/Shared/API
>+        https://bugs.webkit.org/show_bug.cgi?id=192352
>+
>+        Reviewed by NOBODY (OOPS!).
>+
>+        Removed using namespace statements, and use namespace prefix
>+        instead.
>+
>+        * Shared/API/APIURLRequest.cpp:
>+        * Shared/API/APIURLResponse.cpp:
>+        * Shared/API/c/WKArray.cpp:
>+        * Shared/API/c/WKCertificateInfo.cpp:
>+        * Shared/API/c/WKConnectionRef.cpp:
>+        * Shared/API/c/WKContextMenuItem.cpp:
>+        * Shared/API/c/WKData.cpp:
>+        * Shared/API/c/WKDictionary.cpp:
>+        * Shared/API/c/WKErrorRef.cpp:
>+        * Shared/API/c/WKGeometry.cpp:
>+        * Shared/API/c/WKImage.cpp:
>+        * Shared/API/c/WKMutableArray.cpp:
>+        * Shared/API/c/WKMutableDictionary.cpp:
>+        * Shared/API/c/WKNumber.cpp:
>+        * Shared/API/c/WKPluginInformation.cpp:
>+        * Shared/API/c/WKRenderLayer.cpp:
>+        * Shared/API/c/WKRenderObject.cpp:
>+        * Shared/API/c/WKSecurityOriginRef.cpp:
>+        * Shared/API/c/WKSerializedScriptValue.cpp:
>+        * Shared/API/c/WKString.cpp:
>+        * Shared/API/c/WKType.cpp:
>+        * Shared/API/c/WKURL.cpp:
>+        * Shared/API/c/WKURLRequest.cpp:
>+        * Shared/API/c/WKURLResponse.cpp:
>+        * Shared/API/c/WKUserContentURLPattern.cpp:
>+        * Shared/API/c/cairo/WKImageCairo.cpp:
>+        * Shared/API/c/curl/WKCertificateInfoCurl.cpp:
>+
> 2018-12-03  Tim Horton  <timothy_horton@apple.com>
> 
>         Make it possible to disable animated keyboard scrolling behavior
>diff --git a/Source/WebKit/Shared/API/APIURLRequest.cpp b/Source/WebKit/Shared/API/APIURLRequest.cpp
>index ac904d409c21510cf56c73801a95fa5f1af5195b..3e5022e1d8a17a1b7dcec76f96bcad72339d36b7 100644
>--- a/Source/WebKit/Shared/API/APIURLRequest.cpp
>+++ b/Source/WebKit/Shared/API/APIURLRequest.cpp
>@@ -29,27 +29,24 @@
> #include "WebCoreArgumentCoders.h"
> #include "WebProcessPool.h"
> 
>-using namespace WebCore;
>-using namespace WebKit;
>-
> namespace API {
> 
>-URLRequest::URLRequest(const ResourceRequest& request)
>+URLRequest::URLRequest(const WebCore::ResourceRequest& request)
>     : m_request(request)
> {
> }
> 
> double URLRequest::defaultTimeoutInterval()
> {
>-    return ResourceRequest::defaultTimeoutInterval();
>+    return WebCore::ResourceRequest::defaultTimeoutInterval();
> }
> 
> // FIXME: This function should really be on WebProcessPool or WebPageProxy.
> void URLRequest::setDefaultTimeoutInterval(double timeoutInterval)
> {
>-    ResourceRequest::setDefaultTimeoutInterval(timeoutInterval);
>+    WebCore::ResourceRequest::setDefaultTimeoutInterval(timeoutInterval);
> 
>-    for (auto* processPool : WebProcessPool::allProcessPools())
>+    for (auto* processPool : WebKit::WebProcessPool::allProcessPools())
>         processPool->setDefaultRequestTimeoutInterval(timeoutInterval);
> }
> 
>@@ -60,7 +57,7 @@ void URLRequest::encode(IPC::Encoder& encoder) const
> 
> bool URLRequest::decode(IPC::Decoder& decoder, RefPtr<Object>& result)
> {
>-    ResourceRequest request;
>+    WebCore::ResourceRequest request;
>     if (!decoder.decode(request))
>         return false;
>     
>diff --git a/Source/WebKit/Shared/API/APIURLResponse.cpp b/Source/WebKit/Shared/API/APIURLResponse.cpp
>index 1d93b62d38fac2b8837b81acba5020aac14f82b7..ba13758d8b2dd62f63f106a6cde6d1fc5922586a 100644
>--- a/Source/WebKit/Shared/API/APIURLResponse.cpp
>+++ b/Source/WebKit/Shared/API/APIURLResponse.cpp
>@@ -28,8 +28,6 @@
> 
> #include "WebCoreArgumentCoders.h"
> 
>-using namespace WebCore;
>-
> namespace API {
> 
> URLResponse::URLResponse(const WebCore::ResourceResponse& response)
>@@ -44,7 +42,7 @@ void URLResponse::encode(IPC::Encoder& encoder) const
> 
> bool URLResponse::decode(IPC::Decoder& decoder, RefPtr<Object>& result)
> {
>-    ResourceResponse response;
>+    WebCore::ResourceResponse response;
>     if (!decoder.decode(response))
>         return false;
>     
>diff --git a/Source/WebKit/Shared/API/c/WKArray.cpp b/Source/WebKit/Shared/API/c/WKArray.cpp
>index 844161124217af4d353eb6b29bf917e04d8be5a9..c9786f4ba460a0e18ae68996f91bfdf6ddcca98e 100644
>--- a/Source/WebKit/Shared/API/c/WKArray.cpp
>+++ b/Source/WebKit/Shared/API/c/WKArray.cpp
>@@ -29,11 +29,9 @@
> #include "APIArray.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKArrayGetTypeID()
> {
>-    return toAPI(API::Array::APIType);
>+    return WebKit::toAPI(API::Array::APIType);
> }
> 
> WKArrayRef WKArrayCreate(WKTypeRef* values, size_t numberOfValues)
>@@ -42,9 +40,9 @@ WKArrayRef WKArrayCreate(WKTypeRef* values, size_t numberOfValues)
>     elements.reserveInitialCapacity(numberOfValues);
> 
>     for (size_t i = 0; i < numberOfValues; ++i)
>-        elements.uncheckedAppend(toImpl(values[i]));
>+        elements.uncheckedAppend(WebKit::toImpl(values[i]));
> 
>-    return toAPI(&API::Array::create(WTFMove(elements)).leakRef());
>+    return WebKit::toAPI(&API::Array::create(WTFMove(elements)).leakRef());
> }
> 
> WKArrayRef WKArrayCreateAdoptingValues(WKTypeRef* values, size_t numberOfValues)
>@@ -53,17 +51,17 @@ WKArrayRef WKArrayCreateAdoptingValues(WKTypeRef* values, size_t numberOfValues)
>     elements.reserveInitialCapacity(numberOfValues);
> 
>     for (size_t i = 0; i < numberOfValues; ++i)
>-        elements.uncheckedAppend(adoptRef(toImpl(values[i])));
>+        elements.uncheckedAppend(adoptRef(WebKit::toImpl(values[i])));
> 
>-    return toAPI(&API::Array::create(WTFMove(elements)).leakRef());
>+    return WebKit::toAPI(&API::Array::create(WTFMove(elements)).leakRef());
> }
> 
> WKTypeRef WKArrayGetItemAtIndex(WKArrayRef arrayRef, size_t index)
> {
>-    return toAPI(toImpl(arrayRef)->at(index));
>+    return WebKit::toAPI(WebKit::toImpl(arrayRef)->at(index));
> }
> 
> size_t WKArrayGetSize(WKArrayRef arrayRef)
> {
>-    return toImpl(arrayRef)->size();
>+    return WebKit::toImpl(arrayRef)->size();
> }
>diff --git a/Source/WebKit/Shared/API/c/WKCertificateInfo.cpp b/Source/WebKit/Shared/API/c/WKCertificateInfo.cpp
>index 45ec62751a713c723afdaaee1f2793264857dcff..2b717e572f996aa8e39ded9e9e66092b8cea6eb8 100644
>--- a/Source/WebKit/Shared/API/c/WKCertificateInfo.cpp
>+++ b/Source/WebKit/Shared/API/c/WKCertificateInfo.cpp
>@@ -29,9 +29,7 @@
> #include "WebCertificateInfo.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKCertificateInfoGetTypeID()
> {
>-    return toAPI(WebCertificateInfo::APIType);
>+    return WebKit::toAPI(WebKit::WebCertificateInfo::APIType);
> }
>diff --git a/Source/WebKit/Shared/API/c/WKConnectionRef.cpp b/Source/WebKit/Shared/API/c/WKConnectionRef.cpp
>index 9fa7042c29ee3103e17214eeb3bb64084fc838fb..25564f9f878c9acfe0fefb3f54821d4eba5d4d7e 100644
>--- a/Source/WebKit/Shared/API/c/WKConnectionRef.cpp
>+++ b/Source/WebKit/Shared/API/c/WKConnectionRef.cpp
>@@ -29,20 +29,18 @@
> #include "WKAPICast.h"
> #include "WebConnection.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKConnectionGetTypeID()
> {
>-    return toAPI(WebConnection::APIType);
>+    return WebKit::toAPI(WebKit::WebConnection::APIType);
> }
> 
> void WKConnectionSetConnectionClient(WKConnectionRef connectionRef, const WKConnectionClientBase* wkClient)
> {
>-    toImpl(connectionRef)->initializeConnectionClient(wkClient);
>+    WebKit::toImpl(connectionRef)->initializeConnectionClient(wkClient);
> }
> 
> void WKConnectionPostMessage(WKConnectionRef connectionRef, WKStringRef messageNameRef, WKTypeRef messageBodyRef)
> {
>-    toImpl(connectionRef)->postMessage(toImpl(messageNameRef)->string(), toImpl(messageBodyRef));
>+    WebKit::toImpl(connectionRef)->postMessage(WebKit::toImpl(messageNameRef)->string(), WebKit::toImpl(messageBodyRef));
> }
> 
>diff --git a/Source/WebKit/Shared/API/c/WKContextMenuItem.cpp b/Source/WebKit/Shared/API/c/WKContextMenuItem.cpp
>index 1cf05e505c2472484515e98f0706790472c58c97..7cd38be3f020e313fbf231e01292fe53ed54f34f 100644
>--- a/Source/WebKit/Shared/API/c/WKContextMenuItem.cpp
>+++ b/Source/WebKit/Shared/API/c/WKContextMenuItem.cpp
>@@ -32,22 +32,19 @@
> #include "WKAPICast.h"
> #include "WKContextMenuItemTypes.h"
> 
>-using namespace WebCore;
>-using namespace WebKit;
>-
> WKTypeID WKContextMenuItemGetTypeID()
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(WebContextMenuItem::APIType);
>+    return WebKit::toAPI(WebKit::WebContextMenuItem::APIType);
> #else
>-    return toAPI(API::Object::Type::Null);
>+    return WebKit::toAPI(API::Object::Type::Null);
> #endif
> }
> 
> WKContextMenuItemRef WKContextMenuItemCreateAsAction(WKContextMenuItemTag tag, WKStringRef title, bool enabled)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(&WebContextMenuItem::create(WebContextMenuItemData(ActionType, toImpl(tag), toImpl(title)->string(), enabled, false)).leakRef());
>+    return WebKit::toAPI(&WebKit::WebContextMenuItem::create(WebKit::WebContextMenuItemData(WebCore::ActionType, WebKit::toImpl(tag), WebKit::toImpl(title)->string(), enabled, false)).leakRef());
> #else
>     UNUSED_PARAM(tag);
>     UNUSED_PARAM(title);
>@@ -59,7 +56,7 @@ WKContextMenuItemRef WKContextMenuItemCreateAsAction(WKContextMenuItemTag tag, W
> WKContextMenuItemRef WKContextMenuItemCreateAsCheckableAction(WKContextMenuItemTag tag, WKStringRef title, bool enabled, bool checked)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(&WebContextMenuItem::create(WebContextMenuItemData(CheckableActionType, toImpl(tag), toImpl(title)->string(), enabled, checked)).leakRef());
>+    return WebKit::toAPI(&WebKit::WebContextMenuItem::create(WebKit::WebContextMenuItemData(WebCore::CheckableActionType, WebKit::toImpl(tag), WebKit::toImpl(title)->string(), enabled, checked)).leakRef());
> #else
>     UNUSED_PARAM(tag);
>     UNUSED_PARAM(title);
>@@ -72,7 +69,7 @@ WKContextMenuItemRef WKContextMenuItemCreateAsCheckableAction(WKContextMenuItemT
> WKContextMenuItemRef WKContextMenuItemCreateAsSubmenu(WKStringRef title, bool enabled, WKArrayRef submenuItems)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(&WebContextMenuItem::create(toImpl(title)->string(), enabled, toImpl(submenuItems)).leakRef());
>+    return WebKit::toAPI(&WebKit::WebContextMenuItem::create(WebKit::toImpl(title)->string(), enabled, WebKit::toImpl(submenuItems)).leakRef());
> #else
>     UNUSED_PARAM(title);
>     UNUSED_PARAM(enabled);
>@@ -84,7 +81,7 @@ WKContextMenuItemRef WKContextMenuItemCreateAsSubmenu(WKStringRef title, bool en
> WKContextMenuItemRef WKContextMenuItemSeparatorItem()
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(WebContextMenuItem::separatorItem());
>+    return WebKit::toAPI(WebKit::WebContextMenuItem::separatorItem());
> #else
>     return nullptr;
> #endif
>@@ -93,7 +90,7 @@ WKContextMenuItemRef WKContextMenuItemSeparatorItem()
> WKContextMenuItemTag WKContextMenuItemGetTag(WKContextMenuItemRef itemRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(toImpl(itemRef)->data().action());
>+    return WebKit::toAPI(WebKit::toImpl(itemRef)->data().action());
> #else
>     UNUSED_PARAM(itemRef);
>     return toAPI(ContextMenuItemTagNoAction);
>@@ -103,7 +100,7 @@ WKContextMenuItemTag WKContextMenuItemGetTag(WKContextMenuItemRef itemRef)
> WKContextMenuItemType WKContextMenuItemGetType(WKContextMenuItemRef itemRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(toImpl(itemRef)->data().type());
>+    return WebKit::toAPI(WebKit::toImpl(itemRef)->data().type());
> #else
>     UNUSED_PARAM(itemRef);
>     return toAPI(ActionType);
>@@ -113,7 +110,7 @@ WKContextMenuItemType WKContextMenuItemGetType(WKContextMenuItemRef itemRef)
> WKStringRef WKContextMenuItemCopyTitle(WKContextMenuItemRef itemRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toCopiedAPI(toImpl(itemRef)->data().title().impl());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(itemRef)->data().title().impl());
> #else
>     UNUSED_PARAM(itemRef);
>     return 0;
>@@ -123,7 +120,7 @@ WKStringRef WKContextMenuItemCopyTitle(WKContextMenuItemRef itemRef)
> bool WKContextMenuItemGetEnabled(WKContextMenuItemRef itemRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toImpl(itemRef)->data().enabled();
>+    return WebKit::toImpl(itemRef)->data().enabled();
> #else
>     UNUSED_PARAM(itemRef);
>     return false;
>@@ -133,7 +130,7 @@ bool WKContextMenuItemGetEnabled(WKContextMenuItemRef itemRef)
> bool WKContextMenuItemGetChecked(WKContextMenuItemRef itemRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toImpl(itemRef)->data().checked();
>+    return WebKit::toImpl(itemRef)->data().checked();
> #else
>     UNUSED_PARAM(itemRef);
>     return false;
>@@ -143,7 +140,7 @@ bool WKContextMenuItemGetChecked(WKContextMenuItemRef itemRef)
> WKArrayRef WKContextMenuCopySubmenuItems(WKContextMenuItemRef itemRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(&toImpl(itemRef)->submenuItemsAsAPIArray().leakRef());
>+    return WebKit::toAPI(&WebKit::toImpl(itemRef)->submenuItemsAsAPIArray().leakRef());
> #else
>     UNUSED_PARAM(itemRef);
>     return 0;
>@@ -153,7 +150,7 @@ WKArrayRef WKContextMenuCopySubmenuItems(WKContextMenuItemRef itemRef)
> WKTypeRef WKContextMenuItemGetUserData(WKContextMenuItemRef itemRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    return toAPI(toImpl(itemRef)->userData());
>+    return WebKit::toAPI(WebKit::toImpl(itemRef)->userData());
> #else
>     UNUSED_PARAM(itemRef);
>     return 0;
>@@ -163,7 +160,7 @@ WKTypeRef WKContextMenuItemGetUserData(WKContextMenuItemRef itemRef)
> void WKContextMenuItemSetUserData(WKContextMenuItemRef itemRef, WKTypeRef userDataRef)
> {
> #if ENABLE(CONTEXT_MENUS)
>-    toImpl(itemRef)->setUserData(toImpl(userDataRef));
>+    WebKit::toImpl(itemRef)->setUserData(WebKit::toImpl(userDataRef));
> #else
>     UNUSED_PARAM(itemRef);
>     UNUSED_PARAM(userDataRef);
>diff --git a/Source/WebKit/Shared/API/c/WKData.cpp b/Source/WebKit/Shared/API/c/WKData.cpp
>index fdbca73dcb9eeb369850205ce9f8840c0a32d461..13f79d9216d4b62f3165d949c3f34c6efe886d35 100644
>--- a/Source/WebKit/Shared/API/c/WKData.cpp
>+++ b/Source/WebKit/Shared/API/c/WKData.cpp
>@@ -29,24 +29,22 @@
> #include "APIData.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKDataGetTypeID()
> {
>-    return toAPI(API::Data::APIType);
>+    return WebKit::toAPI(API::Data::APIType);
> }
> 
> WKDataRef WKDataCreate(const unsigned char* bytes, size_t size)
> {
>-    return toAPI(&API::Data::create(bytes, size).leakRef());
>+    return WebKit::toAPI(&API::Data::create(bytes, size).leakRef());
> }
> 
> const unsigned char* WKDataGetBytes(WKDataRef dataRef)
> {
>-    return toImpl(dataRef)->bytes();
>+    return WebKit::toImpl(dataRef)->bytes();
> }
> 
> size_t WKDataGetSize(WKDataRef dataRef)
> {
>-    return toImpl(dataRef)->size();
>+    return WebKit::toImpl(dataRef)->size();
> }
>diff --git a/Source/WebKit/Shared/API/c/WKDictionary.cpp b/Source/WebKit/Shared/API/c/WKDictionary.cpp
>index 654e1e61e06f0b0f7e83fd6c27daabf31e138cde..2f5a00e048a4b213924b61c68521e8d1b1c8700e 100644
>--- a/Source/WebKit/Shared/API/c/WKDictionary.cpp
>+++ b/Source/WebKit/Shared/API/c/WKDictionary.cpp
>@@ -30,33 +30,31 @@
> #include "APIDictionary.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKDictionaryGetTypeID()
> {
>-    return toAPI(API::Dictionary::APIType);
>+    return WebKit::toAPI(API::Dictionary::APIType);
> }
> 
> WK_EXPORT WKDictionaryRef WKDictionaryCreate(const WKStringRef* keys, const WKTypeRef* values, size_t numberOfValues)
> {
>     API::Dictionary::MapType map;
>     for (size_t i = 0; i < numberOfValues; ++i)
>-        map.add(toImpl(keys[i])->string(), toImpl(values[i]));
>+        map.add(WebKit::toImpl(keys[i])->string(), WebKit::toImpl(values[i]));
> 
>-    return toAPI(&API::Dictionary::create(WTFMove(map)).leakRef());
>+    return WebKit::toAPI(&API::Dictionary::create(WTFMove(map)).leakRef());
> }
> 
> WKTypeRef WKDictionaryGetItemForKey(WKDictionaryRef dictionaryRef, WKStringRef key)
> {
>-    return toAPI(toImpl(dictionaryRef)->get(toImpl(key)->string()));
>+    return WebKit::toAPI(WebKit::toImpl(dictionaryRef)->get(WebKit::toImpl(key)->string()));
> }
> 
> size_t WKDictionaryGetSize(WKDictionaryRef dictionaryRef)
> {
>-    return toImpl(dictionaryRef)->size();
>+    return WebKit::toImpl(dictionaryRef)->size();
> }
> 
> WKArrayRef WKDictionaryCopyKeys(WKDictionaryRef dictionaryRef)
> {
>-    return toAPI(&toImpl(dictionaryRef)->keys().leakRef());
>+    return WebKit::toAPI(&WebKit::toImpl(dictionaryRef)->keys().leakRef());
> }
>diff --git a/Source/WebKit/Shared/API/c/WKErrorRef.cpp b/Source/WebKit/Shared/API/c/WKErrorRef.cpp
>index c9415120b85309c0503a752314a2a57721162c8f..4793a57fd2f154fec71d984b78fb48ad8492912e 100644
>--- a/Source/WebKit/Shared/API/c/WKErrorRef.cpp
>+++ b/Source/WebKit/Shared/API/c/WKErrorRef.cpp
>@@ -29,26 +29,24 @@
> #include "APIError.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKErrorGetTypeID()
> {
>-    return toAPI(API::Error::APIType);
>+    return WebKit::toAPI(API::Error::APIType);
> }
> 
> WKStringRef WKErrorCopyWKErrorDomain()
> {
>-    return toCopiedAPI(API::Error::webKitErrorDomain());
>+    return WebKit::toCopiedAPI(API::Error::webKitErrorDomain());
> }
> 
> WKStringRef WKErrorCopyDomain(WKErrorRef errorRef)
> {
>-    return toCopiedAPI(toImpl(errorRef)->domain());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(errorRef)->domain());
> }
> 
> int WKErrorGetErrorCode(WKErrorRef errorRef)
> {
>-    auto errorCode = toImpl(errorRef)->errorCode();
>+    auto errorCode = WebKit::toImpl(errorRef)->errorCode();
>     switch (errorCode) {
>     case API::Error::Policy::CannotShowMIMEType:
>         return kWKErrorCodeCannotShowMIMEType;
>@@ -83,10 +81,10 @@ int WKErrorGetErrorCode(WKErrorRef errorRef)
> 
> WKURLRef WKErrorCopyFailingURL(WKErrorRef errorRef)
> {
>-    return toCopiedURLAPI(toImpl(errorRef)->failingURL());
>+    return WebKit::toCopiedURLAPI(WebKit::toImpl(errorRef)->failingURL());
> }
> 
> WKStringRef WKErrorCopyLocalizedDescription(WKErrorRef errorRef)
> {
>-    return toCopiedAPI(toImpl(errorRef)->localizedDescription());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(errorRef)->localizedDescription());
> }
>diff --git a/Source/WebKit/Shared/API/c/WKGeometry.cpp b/Source/WebKit/Shared/API/c/WKGeometry.cpp
>index 4cd5e3da4700c756f6b70a3df38e3fe8e5ea9ed7..2a8b630579c1769b096fb5dcee9191cbf68f86e5 100644
>--- a/Source/WebKit/Shared/API/c/WKGeometry.cpp
>+++ b/Source/WebKit/Shared/API/c/WKGeometry.cpp
>@@ -29,50 +29,48 @@
> #include "APIGeometry.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKSizeGetTypeID(void)
> {
>-    return toAPI(API::Size::APIType);
>+    return WebKit::toAPI(API::Size::APIType);
> }
> 
> WKTypeID WKPointGetTypeID(void)
> {
>-    return toAPI(API::Point::APIType);
>+    return WebKit::toAPI(API::Point::APIType);
> }
> 
> WKTypeID WKRectGetTypeID(void)
> {
>-    return toAPI(API::Rect::APIType);
>+    return WebKit::toAPI(API::Rect::APIType);
> }
> 
> WKPointRef WKPointCreate(WKPoint point)
> {
>-    return toAPI(&API::Point::create(point).leakRef());
>+    return WebKit::toAPI(&API::Point::create(point).leakRef());
> }
> 
> WKSizeRef WKSizeCreate(WKSize size)
> {
>-    return toAPI(&API::Size::create(size).leakRef());
>+    return WebKit::toAPI(&API::Size::create(size).leakRef());
> }
> 
> WKRectRef WKRectCreate(WKRect rect)
> {
>-    return toAPI(&API::Rect::create(rect).leakRef());
>+    return WebKit::toAPI(&API::Rect::create(rect).leakRef());
> }
> 
> WKSize WKSizeGetValue(WKSizeRef size)
> {
>-    return toImpl(size)->size();
>+    return WebKit::toImpl(size)->size();
> }
> 
> WKPoint WKPointGetValue(WKPointRef point)
> {
>-    return toImpl(point)->point();
>+    return WebKit::toImpl(point)->point();
> }
> 
> WKRect WKRectGetValue(WKRectRef rect)
> {
>-    return toImpl(rect)->rect();
>+    return WebKit::toImpl(rect)->rect();
> }
> 
>diff --git a/Source/WebKit/Shared/API/c/WKImage.cpp b/Source/WebKit/Shared/API/c/WKImage.cpp
>index 68e6381d8c18947feed5a6cd73c29e21f1bc7b79..31b6daeb838fca3cbe65be3b7096919f5c0200a7 100644
>--- a/Source/WebKit/Shared/API/c/WKImage.cpp
>+++ b/Source/WebKit/Shared/API/c/WKImage.cpp
>@@ -29,20 +29,18 @@
> #include "WKSharedAPICast.h"
> #include "WebImage.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKImageGetTypeID(void)
> {
>-    return toAPI(WebImage::APIType);
>+    return WebKit::toAPI(WebKit::WebImage::APIType);
> }
> 
> WKImageRef WKImageCreate(WKSize size, WKImageOptions options)
> {
>-    auto webImage = WebImage::create(toIntSize(size), toImageOptions(options));
>+    auto webImage = WebKit::WebImage::create(WebKit::toIntSize(size), WebKit::toImageOptions(options));
>     return toAPI(webImage.leakRef());
> }
> 
> WKSize WKImageGetSize(WKImageRef imageRef)
> {
>-    return toAPI(toImpl(imageRef)->size());
>+    return WebKit::toAPI(WebKit::toImpl(imageRef)->size());
> }
>diff --git a/Source/WebKit/Shared/API/c/WKMutableArray.cpp b/Source/WebKit/Shared/API/c/WKMutableArray.cpp
>index 5dc85260fadbae32d98b01485c937f4dc6cb18a4..9a931cc622a0cbdf74f08b53c0335bfc083616ed 100644
>--- a/Source/WebKit/Shared/API/c/WKMutableArray.cpp
>+++ b/Source/WebKit/Shared/API/c/WKMutableArray.cpp
>@@ -29,20 +29,18 @@
> #include "APIArray.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKMutableArrayRef WKMutableArrayCreate()
> {
>-    return const_cast<WKMutableArrayRef>(toAPI(&API::Array::create().leakRef()));
>+    return const_cast<WKMutableArrayRef>(WebKit::toAPI(&API::Array::create().leakRef()));
> }
> 
> void WKArrayAppendItem(WKMutableArrayRef arrayRef, WKTypeRef itemRef)
> {
>-    toImpl(arrayRef)->elements().append(toImpl(itemRef));
>+    WebKit::toImpl(arrayRef)->elements().append(WebKit::toImpl(itemRef));
> }
> 
> void WKArrayRemoveItemAtIndex(WKMutableArrayRef arrayRef, size_t index)
> {
>-    toImpl(arrayRef)->elements().remove(index);
>+    WebKit::toImpl(arrayRef)->elements().remove(index);
> }
> 
>diff --git a/Source/WebKit/Shared/API/c/WKMutableDictionary.cpp b/Source/WebKit/Shared/API/c/WKMutableDictionary.cpp
>index 96b89bd456484d51c0a7fb3a579c9e5d9cda847d..7db211680e287f485ba136a91c17c8a9f8d57503 100644
>--- a/Source/WebKit/Shared/API/c/WKMutableDictionary.cpp
>+++ b/Source/WebKit/Shared/API/c/WKMutableDictionary.cpp
>@@ -29,15 +29,13 @@
> #include "APIDictionary.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKMutableDictionaryRef WKMutableDictionaryCreate()
> {
>-    return const_cast<WKMutableDictionaryRef>(toAPI(&API::Dictionary::create().leakRef()));
>+    return const_cast<WKMutableDictionaryRef>(WebKit::toAPI(&API::Dictionary::create().leakRef()));
> }
> 
> bool WKDictionarySetItem(WKMutableDictionaryRef dictionaryRef, WKStringRef keyRef, WKTypeRef itemRef)
> {
>-    return toImpl(dictionaryRef)->set(toImpl(keyRef)->string(), toImpl(itemRef));
>+    return WebKit::toImpl(dictionaryRef)->set(WebKit::toImpl(keyRef)->string(), WebKit::toImpl(itemRef));
> }
> 
>diff --git a/Source/WebKit/Shared/API/c/WKNumber.cpp b/Source/WebKit/Shared/API/c/WKNumber.cpp
>index 418e029ea67dbf3a6a1fecc075387cc6a2174d86..19f9ee0796c3c4a762a8e16d3daf3d0e247bfbe3 100644
>--- a/Source/WebKit/Shared/API/c/WKNumber.cpp
>+++ b/Source/WebKit/Shared/API/c/WKNumber.cpp
>@@ -29,52 +29,50 @@
> #include "APINumber.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKBooleanGetTypeID()
> {
>-    return toAPI(API::Boolean::APIType);
>+    return WebKit::toAPI(API::Boolean::APIType);
> }
> 
> WKBooleanRef WKBooleanCreate(bool value)
> {
>     auto booleanObject = API::Boolean::create(value);
>-    return toAPI(&booleanObject.leakRef());
>+    return WebKit::toAPI(&booleanObject.leakRef());
> }
> 
> bool WKBooleanGetValue(WKBooleanRef booleanRef)
> {
>-    return toImpl(booleanRef)->value();
>+    return WebKit::toImpl(booleanRef)->value();
> }
> 
> WKTypeID WKDoubleGetTypeID()
> {
>-    return toAPI(API::Double::APIType);
>+    return WebKit::toAPI(API::Double::APIType);
> }
> 
> WKDoubleRef WKDoubleCreate(double value)
> {
>     auto doubleObject = API::Double::create(value);
>-    return toAPI(&doubleObject.leakRef());
>+    return WebKit::toAPI(&doubleObject.leakRef());
> }
> 
> double WKDoubleGetValue(WKDoubleRef doubleRef)
> {
>-    return toImpl(doubleRef)->value();
>+    return WebKit::toImpl(doubleRef)->value();
> }
> 
> WKTypeID WKUInt64GetTypeID()
> {
>-    return toAPI(API::UInt64::APIType);
>+    return WebKit::toAPI(API::UInt64::APIType);
> }
> 
> WKUInt64Ref WKUInt64Create(uint64_t value)
> {
>     auto uint64Object = API::UInt64::create(value);
>-    return toAPI(&uint64Object.leakRef());
>+    return WebKit::toAPI(&uint64Object.leakRef());
> }
> 
> uint64_t WKUInt64GetValue(WKUInt64Ref uint64Ref)
> {
>-    return toImpl(uint64Ref)->value();
>+    return WebKit::toImpl(uint64Ref)->value();
> }
>diff --git a/Source/WebKit/Shared/API/c/WKPluginInformation.cpp b/Source/WebKit/Shared/API/c/WKPluginInformation.cpp
>index e3ae4f5f03258aa10a6ab5abab34c6af0bdd3309..0930992446866372efd4a4a5233f2a8506a65f12 100644
>--- a/Source/WebKit/Shared/API/c/WKPluginInformation.cpp
>+++ b/Source/WebKit/Shared/API/c/WKPluginInformation.cpp
>@@ -30,13 +30,11 @@
> #include "PluginInformation.h"
> #include "WKSharedAPICast.h"
> 
>-using namespace WebKit;
>-
> WKStringRef WKPluginInformationBundleIdentifierKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationBundleIdentifierKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationBundleIdentifierKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -45,8 +43,8 @@ WKStringRef WKPluginInformationBundleIdentifierKey()
> WKStringRef WKPluginInformationBundleVersionKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationBundleVersionKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationBundleVersionKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -55,8 +53,8 @@ WKStringRef WKPluginInformationBundleVersionKey()
> WKStringRef WKPluginInformationBundleShortVersionKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationBundleShortVersionKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationBundleShortVersionKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -65,8 +63,8 @@ WKStringRef WKPluginInformationBundleShortVersionKey()
> WKStringRef WKPluginInformationPathKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationPathKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationPathKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -75,8 +73,8 @@ WKStringRef WKPluginInformationPathKey()
> WKStringRef WKPluginInformationDisplayNameKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationDisplayNameKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationDisplayNameKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -85,8 +83,8 @@ WKStringRef WKPluginInformationDisplayNameKey()
> WKStringRef WKPluginInformationDefaultLoadPolicyKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationDefaultLoadPolicyKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationDefaultLoadPolicyKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -95,8 +93,8 @@ WKStringRef WKPluginInformationDefaultLoadPolicyKey()
> WKStringRef WKPluginInformationUpdatePastLastBlockedVersionIsKnownAvailableKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationUpdatePastLastBlockedVersionIsKnownAvailableKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationUpdatePastLastBlockedVersionIsKnownAvailableKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -105,8 +103,8 @@ WKStringRef WKPluginInformationUpdatePastLastBlockedVersionIsKnownAvailableKey()
> WKStringRef WKPluginInformationHasSandboxProfileKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationHasSandboxProfileKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationHasSandboxProfileKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -115,8 +113,8 @@ WKStringRef WKPluginInformationHasSandboxProfileKey()
> WKStringRef WKPluginInformationFrameURLKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationFrameURLKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationFrameURLKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -125,8 +123,8 @@ WKStringRef WKPluginInformationFrameURLKey()
> WKStringRef WKPluginInformationMIMETypeKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationMIMETypeKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationMIMETypeKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -135,8 +133,8 @@ WKStringRef WKPluginInformationMIMETypeKey()
> WKStringRef WKPluginInformationPageURLKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationPageURLKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationPageURLKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -145,8 +143,8 @@ WKStringRef WKPluginInformationPageURLKey()
> WKStringRef WKPluginInformationPluginspageAttributeURLKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationPluginspageAttributeURLKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationPluginspageAttributeURLKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -155,8 +153,8 @@ WKStringRef WKPluginInformationPluginspageAttributeURLKey()
> WKStringRef WKPluginInformationPluginURLKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(pluginInformationPluginURLKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::pluginInformationPluginURLKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>@@ -165,8 +163,8 @@ WKStringRef WKPluginInformationPluginURLKey()
> WKStringRef WKPlugInInformationReplacementObscuredKey()
> {
> #if ENABLE(NETSCAPE_PLUGIN_API)
>-    static API::String& key = API::String::create(plugInInformationReplacementObscuredKey()).leakRef();
>-    return toAPI(&key);
>+    static API::String& key = API::String::create(WebCore::plugInInformationReplacementObscuredKey()).leakRef();
>+    return WebKit::toAPI(&key);
> #else
>     return 0;
> #endif
>diff --git a/Source/WebKit/Shared/API/c/WKRenderLayer.cpp b/Source/WebKit/Shared/API/c/WKRenderLayer.cpp
>index 20726f4ee292d97a0aef5c4ba2a6a3fe240a094d..94c85e913f9cd505a43b4380f03693927274a7d2 100644
>--- a/Source/WebKit/Shared/API/c/WKRenderLayer.cpp
>+++ b/Source/WebKit/Shared/API/c/WKRenderLayer.cpp
>@@ -30,80 +30,77 @@
> #include "WKAPICast.h"
> #include "WebRenderLayer.h"
> 
>-using namespace WebCore;
>-using namespace WebKit;
>-
> WKTypeID WKRenderLayerGetTypeID()
> {
>-    return toAPI(WebRenderLayer::APIType);
>+    return WebKit::toAPI(WebKit::WebRenderLayer::APIType);
> }
> 
> WKRenderObjectRef WKRenderLayerGetRenderer(WKRenderLayerRef renderLayerRef)
> {
>-    return toAPI(toImpl(renderLayerRef)->renderer());
>+    return toAPI(WebKit::toImpl(renderLayerRef)->renderer());
> }
> 
> WKStringRef WKRenderLayerCopyRendererName(WKRenderLayerRef renderLayerRef)
> {
>-    return toCopiedAPI(toImpl(renderLayerRef)->renderer()->name());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(renderLayerRef)->renderer()->name());
> }
> 
> WKStringRef WKRenderLayerCopyElementTagName(WKRenderLayerRef renderLayerRef)
> {
>-    WebRenderLayer* renderLayer = toImpl(renderLayerRef);
>+    WebKit::WebRenderLayer* renderLayer = WebKit::toImpl(renderLayerRef);
>     if (!renderLayer->renderer()->elementTagName().isNull())
>-        return toCopiedAPI(renderLayer->renderer()->elementTagName());
>+        return WebKit::toCopiedAPI(renderLayer->renderer()->elementTagName());
> 
>     return nullptr;
> }
> 
> WKStringRef WKRenderLayerCopyElementID(WKRenderLayerRef renderLayerRef)
> {
>-    WebRenderLayer* renderLayer = toImpl(renderLayerRef);
>+    WebKit::WebRenderLayer* renderLayer = WebKit::toImpl(renderLayerRef);
>     if (!renderLayer->renderer()->elementID().isNull())
>-        return toCopiedAPI(renderLayer->renderer()->elementID());
>+        return WebKit::toCopiedAPI(renderLayer->renderer()->elementID());
> 
>     return nullptr;
> }
> 
> WKArrayRef WKRenderLayerGetElementClassNames(WKRenderLayerRef renderLayerRef)
> {
>-    return toAPI(toImpl(renderLayerRef)->renderer()->elementClassNames());
>+    return WebKit::toAPI(WebKit::toImpl(renderLayerRef)->renderer()->elementClassNames());
> }
> 
> WKRect WKRenderLayerGetAbsoluteBounds(WKRenderLayerRef renderLayerRef)
> {
>-    IntRect bounds = toImpl(renderLayerRef)->absoluteBoundingBox();
>+    WebCore::IntRect bounds = WebKit::toImpl(renderLayerRef)->absoluteBoundingBox();
>     return WKRectMake(bounds.x(), bounds.y(), bounds.width(), bounds.height());
> }
> 
> bool WKRenderLayerIsClipping(WKRenderLayerRef renderLayerRef)
> {
>-    return toImpl(renderLayerRef)->isClipping();
>+    return WebKit::toImpl(renderLayerRef)->isClipping();
> }
> 
> bool WKRenderLayerIsClipped(WKRenderLayerRef renderLayerRef)
> {
>-    return toImpl(renderLayerRef)->isClipped();
>+    return WebKit::toImpl(renderLayerRef)->isClipped();
> }
> 
> bool WKRenderLayerIsReflection(WKRenderLayerRef renderLayerRef)
> {
>-    return toImpl(renderLayerRef)->isReflection();
>+    return WebKit::toImpl(renderLayerRef)->isReflection();
> }
> 
> WKCompositingLayerType WKRenderLayerGetCompositingLayerType(WKRenderLayerRef renderLayerRef)
> {
>-    switch (toImpl(renderLayerRef)->compositingLayerType()) {
>-    case WebRenderLayer::None:
>+    switch (WebKit::toImpl(renderLayerRef)->compositingLayerType()) {
>+    case WebKit::WebRenderLayer::None:
>         return kWKCompositingLayerTypeNone;
>-    case WebRenderLayer::Normal:
>+    case WebKit::WebRenderLayer::Normal:
>         return kWKCompositingLayerTypeNormal;
>-    case WebRenderLayer::Tiled:
>+    case WebKit::WebRenderLayer::Tiled:
>         return kWKCompositingLayerTypeTiled;
>-    case WebRenderLayer::Media:
>+    case WebKit::WebRenderLayer::Media:
>         return kWKCompositingLayerTypeMedia;
>-    case WebRenderLayer::Container:
>+    case WebKit::WebRenderLayer::Container:
>         return kWKCompositingLayerTypeContainer;
>     }
> 
>@@ -113,25 +110,25 @@ WKCompositingLayerType WKRenderLayerGetCompositingLayerType(WKRenderLayerRef ren
> 
> WK_EXPORT double WKRenderLayerGetBackingStoreMemoryEstimate(WKRenderLayerRef renderLayerRef)
> {
>-    return toImpl(renderLayerRef)->backingStoreMemoryEstimate();
>+    return WebKit::toImpl(renderLayerRef)->backingStoreMemoryEstimate();
> }
> 
> WKArrayRef WKRenderLayerGetNegativeZOrderList(WKRenderLayerRef renderLayerRef)
> {
>-    return toAPI(toImpl(renderLayerRef)->negativeZOrderList());
>+    return WebKit::toAPI(WebKit::toImpl(renderLayerRef)->negativeZOrderList());
> }
> 
> WKArrayRef WKRenderLayerGetNormalFlowList(WKRenderLayerRef renderLayerRef)
> {
>-    return toAPI(toImpl(renderLayerRef)->normalFlowList());
>+    return WebKit::toAPI(WebKit::toImpl(renderLayerRef)->normalFlowList());
> }
> 
> WKArrayRef WKRenderLayerGetPositiveZOrderList(WKRenderLayerRef renderLayerRef)
> {
>-    return toAPI(toImpl(renderLayerRef)->positiveZOrderList());
>+    return WebKit::toAPI(WebKit::toImpl(renderLayerRef)->positiveZOrderList());
> }
> 
> WKRenderLayerRef WKRenderLayerGetFrameContentsLayer(WKRenderLayerRef renderLayerRef)
> {
>-    return toAPI(toImpl(renderLayerRef)->frameContentsLayer());
>+    return toAPI(WebKit::toImpl(renderLayerRef)->frameContentsLayer());
> }
>diff --git a/Source/WebKit/Shared/API/c/WKRenderObject.cpp b/Source/WebKit/Shared/API/c/WKRenderObject.cpp
>index cff71c7cd8688f51437aed74a38475aa62f78cb2..ba12390b632871aa4ca1a536fb88faad6135a405 100644
>--- a/Source/WebKit/Shared/API/c/WKRenderObject.cpp
>+++ b/Source/WebKit/Shared/API/c/WKRenderObject.cpp
>@@ -30,69 +30,66 @@
> #include "WKAPICast.h"
> #include "WebRenderObject.h"
> 
>-using namespace WebCore;
>-using namespace WebKit;
>-
> WKTypeID WKRenderObjectGetTypeID()
> {
>-    return toAPI(WebRenderObject::APIType);
>+    return WebKit::toAPI(WebKit::WebRenderObject::APIType);
> }
> 
> WKStringRef WKRenderObjectCopyName(WKRenderObjectRef renderObjectRef)
> {
>-    return toCopiedAPI(toImpl(renderObjectRef)->name());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(renderObjectRef)->name());
> }
> 
> WKStringRef WKRenderObjectCopyTextSnippet(WKRenderObjectRef renderObjectRef)
> {
>-    WebRenderObject* renderObject = toImpl(renderObjectRef);
>+    WebKit::WebRenderObject* renderObject = WebKit::toImpl(renderObjectRef);
>     if (!renderObject->textSnippet().isNull())
>-        return toCopiedAPI(renderObject->textSnippet());
>+        return WebKit::toCopiedAPI(renderObject->textSnippet());
> 
>     return nullptr;
> }
> 
> unsigned WKRenderObjectGetTextLength(WKRenderObjectRef renderObjectRef)
> {
>-    return toImpl(renderObjectRef)->textLength();
>+    return WebKit::toImpl(renderObjectRef)->textLength();
> }
> 
> WKStringRef WKRenderObjectCopyElementTagName(WKRenderObjectRef renderObjectRef)
> {
>-    WebRenderObject* renderObject = toImpl(renderObjectRef);
>+    WebKit::WebRenderObject* renderObject = WebKit::toImpl(renderObjectRef);
>     if (!renderObject->elementTagName().isNull())
>-        return toCopiedAPI(renderObject->elementTagName());
>+        return WebKit::toCopiedAPI(renderObject->elementTagName());
> 
>     return nullptr;
> }
> 
> WKStringRef WKRenderObjectCopyElementID(WKRenderObjectRef renderObjectRef)
> {
>-    WebRenderObject* renderObject = toImpl(renderObjectRef);
>+    WebKit::WebRenderObject* renderObject = WebKit::toImpl(renderObjectRef);
>     if (!renderObject->elementID().isNull())
>-        return toCopiedAPI(renderObject->elementID());
>+        return WebKit::toCopiedAPI(renderObject->elementID());
> 
>     return nullptr;
> }
> 
> WKArrayRef WKRenderObjectGetElementClassNames(WKRenderObjectRef renderObjectRef)
> {
>-    return toAPI(toImpl(renderObjectRef)->elementClassNames());
>+    return WebKit::toAPI(WebKit::toImpl(renderObjectRef)->elementClassNames());
> }
> 
> WKPoint WKRenderObjectGetAbsolutePosition(WKRenderObjectRef renderObjectRef)
> {
>-    IntPoint absolutePosition = toImpl(renderObjectRef)->absolutePosition();
>+    WebCore::IntPoint absolutePosition = WebKit::toImpl(renderObjectRef)->absolutePosition();
>     return WKPointMake(absolutePosition.x(), absolutePosition.y());
> }
> 
> WKRect WKRenderObjectGetFrameRect(WKRenderObjectRef renderObjectRef)
> {
>-    IntRect frameRect = toImpl(renderObjectRef)->frameRect();
>+    WebCore::IntRect frameRect = WebKit::toImpl(renderObjectRef)->frameRect();
>     return WKRectMake(frameRect.x(), frameRect.y(), frameRect.width(), frameRect.height());
> }
> 
> WKArrayRef WKRenderObjectGetChildren(WKRenderObjectRef renderObjectRef)
> {
>-    return toAPI(toImpl(renderObjectRef)->children());
>+    return WebKit::toAPI(WebKit::toImpl(renderObjectRef)->children());
> }
>diff --git a/Source/WebKit/Shared/API/c/WKSecurityOriginRef.cpp b/Source/WebKit/Shared/API/c/WKSecurityOriginRef.cpp
>index bcf955a66cb7680542c2cfcadcc4f3f0bd53d151..5e6be74b8da6d4b93603790ca4ad176d1f662c66 100644
>--- a/Source/WebKit/Shared/API/c/WKSecurityOriginRef.cpp
>+++ b/Source/WebKit/Shared/API/c/WKSecurityOriginRef.cpp
>@@ -30,53 +30,51 @@
> #include "WKAPICast.h"
> #include <WebCore/SecurityOriginData.h>
> 
>-using namespace WebKit;
>-
> WKTypeID WKSecurityOriginGetTypeID()
> {
>-    return toAPI(API::SecurityOrigin::APIType);
>+    return WebKit::toAPI(API::SecurityOrigin::APIType);
> }
> 
> WKSecurityOriginRef WKSecurityOriginCreateFromString(WKStringRef string)
> {
>-    return toAPI(&API::SecurityOrigin::create(WebCore::SecurityOrigin::createFromString(toImpl(string)->string())).leakRef());
>+    return WebKit::toAPI(&API::SecurityOrigin::create(WebCore::SecurityOrigin::createFromString(WebKit::toImpl(string)->string())).leakRef());
> }
> 
> WKSecurityOriginRef WKSecurityOriginCreateFromDatabaseIdentifier(WKStringRef identifier)
> {
>-    auto origin = WebCore::SecurityOriginData::fromDatabaseIdentifier(toImpl(identifier)->string());
>+    auto origin = WebCore::SecurityOriginData::fromDatabaseIdentifier(WebKit::toImpl(identifier)->string());
>     if (!origin)
>         return nullptr;
>-    return toAPI(&API::SecurityOrigin::create(origin.value().securityOrigin()).leakRef());
>+    return WebKit::toAPI(&API::SecurityOrigin::create(origin.value().securityOrigin()).leakRef());
> }
> 
> WKSecurityOriginRef WKSecurityOriginCreate(WKStringRef protocol, WKStringRef host, int port)
> {
>-    auto securityOrigin = API::SecurityOrigin::create(toImpl(protocol)->string(), toImpl(host)->string(), port);
>-    return toAPI(&securityOrigin.leakRef());
>+    auto securityOrigin = API::SecurityOrigin::create(WebKit::toImpl(protocol)->string(), WebKit::toImpl(host)->string(), port);
>+    return WebKit::toAPI(&securityOrigin.leakRef());
> }
> 
> WKStringRef WKSecurityOriginCopyDatabaseIdentifier(WKSecurityOriginRef securityOrigin)
> {
>-    return toCopiedAPI(toImpl(securityOrigin)->securityOrigin().data().databaseIdentifier());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(securityOrigin)->securityOrigin().data().databaseIdentifier());
> }
> 
> WKStringRef WKSecurityOriginCopyToString(WKSecurityOriginRef securityOrigin)
> {
>-    return toCopiedAPI(toImpl(securityOrigin)->securityOrigin().toString());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(securityOrigin)->securityOrigin().toString());
> }
> 
> WKStringRef WKSecurityOriginCopyProtocol(WKSecurityOriginRef securityOrigin)
> {
>-    return toCopiedAPI(toImpl(securityOrigin)->securityOrigin().protocol());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(securityOrigin)->securityOrigin().protocol());
> }
> 
> WKStringRef WKSecurityOriginCopyHost(WKSecurityOriginRef securityOrigin)
> {
>-    return toCopiedAPI(toImpl(securityOrigin)->securityOrigin().host());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(securityOrigin)->securityOrigin().host());
> }
> 
> unsigned short WKSecurityOriginGetPort(WKSecurityOriginRef securityOrigin)
> {
>-    return toImpl(securityOrigin)->securityOrigin().port().value_or(0);
>+    return WebKit::toImpl(securityOrigin)->securityOrigin().port().value_or(0);
> }
>diff --git a/Source/WebKit/Shared/API/c/WKSerializedScriptValue.cpp b/Source/WebKit/Shared/API/c/WKSerializedScriptValue.cpp
>index aad8eae447ea13123a96f2686ffe66e496fd39d8..c4dcba3fea4df5c52392b771c007c3a902977151 100644
>--- a/Source/WebKit/Shared/API/c/WKSerializedScriptValue.cpp
>+++ b/Source/WebKit/Shared/API/c/WKSerializedScriptValue.cpp
>@@ -29,20 +29,18 @@
> #include "APISerializedScriptValue.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKSerializedScriptValueGetTypeID()
> {
>-    return toAPI(API::SerializedScriptValue::APIType);
>+    return WebKit::toAPI(API::SerializedScriptValue::APIType);
> }
> 
> WKSerializedScriptValueRef WKSerializedScriptValueCreate(JSContextRef context, JSValueRef value, JSValueRef* exception)
> {
>     auto serializedValue = API::SerializedScriptValue::create(context, value, exception);
>-    return toAPI(serializedValue.leakRef());
>+    return WebKit::toAPI(serializedValue.leakRef());
> }
> 
> JSValueRef WKSerializedScriptValueDeserialize(WKSerializedScriptValueRef scriptValueRef, JSContextRef contextRef, JSValueRef* exception)
> {
>-    return toImpl(scriptValueRef)->deserialize(contextRef, exception);
>+    return WebKit::toImpl(scriptValueRef)->deserialize(contextRef, exception);
> }
>diff --git a/Source/WebKit/Shared/API/c/WKString.cpp b/Source/WebKit/Shared/API/c/WKString.cpp
>index 767aa8d914b0cf75196e20c363b80638ffd7d3d9..02aa4cc0f0b6673e236a07a81c46fe39eab7feda 100644
>--- a/Source/WebKit/Shared/API/c/WKString.cpp
>+++ b/Source/WebKit/Shared/API/c/WKString.cpp
>@@ -31,26 +31,24 @@
> #include <JavaScriptCore/InitializeThreading.h>
> #include <JavaScriptCore/OpaqueJSString.h>
> 
>-using namespace WebKit;
>-
> WKTypeID WKStringGetTypeID()
> {
>-    return toAPI(API::String::APIType);
>+    return WebKit::toAPI(API::String::APIType);
> }
> 
> WKStringRef WKStringCreateWithUTF8CString(const char* string)
> {
>-    return toAPI(&API::String::create(WTF::String::fromUTF8(string)).leakRef());
>+    return WebKit::toAPI(&API::String::create(WTF::String::fromUTF8(string)).leakRef());
> }
> 
> bool WKStringIsEmpty(WKStringRef stringRef)
> {
>-    return toImpl(stringRef)->stringView().isEmpty();
>+    return WebKit::toImpl(stringRef)->stringView().isEmpty();
> }
> 
> size_t WKStringGetLength(WKStringRef stringRef)
> {
>-    return toImpl(stringRef)->stringView().length();
>+    return WebKit::toImpl(stringRef)->stringView().length();
> }
> 
> size_t WKStringGetCharacters(WKStringRef stringRef, WKChar* buffer, size_t bufferLength)
>@@ -58,7 +56,7 @@ size_t WKStringGetCharacters(WKStringRef stringRef, WKChar* buffer, size_t buffe
>     static_assert(sizeof(WKChar) == sizeof(UChar), "Size of WKChar must match size of UChar");
> 
>     unsigned unsignedBufferLength = std::min<size_t>(bufferLength, std::numeric_limits<unsigned>::max());
>-    auto substring = toImpl(stringRef)->stringView().substring(0, unsignedBufferLength);
>+    auto substring = WebKit::toImpl(stringRef)->stringView().substring(0, unsignedBufferLength);
> 
>     substring.getCharactersWithUpconvert(reinterpret_cast<UChar*>(buffer));
>     return substring.length();
>@@ -66,7 +64,7 @@ size_t WKStringGetCharacters(WKStringRef stringRef, WKChar* buffer, size_t buffe
> 
> size_t WKStringGetMaximumUTF8CStringSize(WKStringRef stringRef)
> {
>-    return toImpl(stringRef)->stringView().length() * 3 + 1;
>+    return WebKit::toImpl(stringRef)->stringView().length() * 3 + 1;
> }
> 
> enum StrictType { NonStrict = false, Strict = true };
>@@ -77,7 +75,7 @@ size_t WKStringGetUTF8CStringImpl(WKStringRef stringRef, char* buffer, size_t bu
>     if (!bufferSize)
>         return 0;
> 
>-    auto stringView = toImpl(stringRef)->stringView();
>+    auto stringView = WebKit::toImpl(stringRef)->stringView();
> 
>     char* p = buffer;
>     WTF::Unicode::ConversionResult result;
>@@ -109,32 +107,32 @@ size_t WKStringGetUTF8CStringNonStrict(WKStringRef stringRef, char* buffer, size
> 
> bool WKStringIsEqual(WKStringRef aRef, WKStringRef bRef)
> {
>-    return toImpl(aRef)->stringView() == toImpl(bRef)->stringView();
>+    return WebKit::toImpl(aRef)->stringView() == WebKit::toImpl(bRef)->stringView();
> }
> 
> bool WKStringIsEqualToUTF8CString(WKStringRef aRef, const char* b)
> {
>     // FIXME: Should we add a fast path that avoids memory allocation when the string is all ASCII?
>     // FIXME: We can do even the general case more efficiently if we write a function in StringView that understands UTF-8 C strings.
>-    return toImpl(aRef)->stringView() == WTF::String::fromUTF8(b);
>+    return WebKit::toImpl(aRef)->stringView() == WTF::String::fromUTF8(b);
> }
> 
> bool WKStringIsEqualToUTF8CStringIgnoringCase(WKStringRef aRef, const char* b)
> {
>     // FIXME: Should we add a fast path that avoids memory allocation when the string is all ASCII?
>     // FIXME: We can do even the general case more efficiently if we write a function in StringView that understands UTF-8 C strings.
>-    return equalIgnoringASCIICase(toImpl(aRef)->stringView(), WTF::String::fromUTF8(b));
>+    return equalIgnoringASCIICase(WebKit::toImpl(aRef)->stringView(), WTF::String::fromUTF8(b));
> }
> 
> WKStringRef WKStringCreateWithJSString(JSStringRef jsStringRef)
> {
>     auto apiString = jsStringRef ? API::String::create(jsStringRef->string()) : API::String::createNull();
> 
>-    return toAPI(&apiString.leakRef());
>+    return WebKit::toAPI(&apiString.leakRef());
> }
> 
> JSStringRef WKStringCopyJSString(WKStringRef stringRef)
> {
>     JSC::initializeThreading();
>-    return OpaqueJSString::tryCreate(toImpl(stringRef)->string()).leakRef();
>+    return OpaqueJSString::tryCreate(WebKit::toImpl(stringRef)->string()).leakRef();
> }
>diff --git a/Source/WebKit/Shared/API/c/WKType.cpp b/Source/WebKit/Shared/API/c/WKType.cpp
>index fd20e6fff1e04f04a7e99cd55d486a4d13f9a691..4169da84fe7c74ef584e5f2ec591b9ee4de6fda5 100644
>--- a/Source/WebKit/Shared/API/c/WKType.cpp
>+++ b/Source/WebKit/Shared/API/c/WKType.cpp
>@@ -29,21 +29,19 @@
> #include "APIObject.h"
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKGetTypeID(WKTypeRef typeRef)
> {
>-    return toAPI(toImpl(typeRef)->type());
>+    return WebKit::toAPI(WebKit::toImpl(typeRef)->type());
> }
> 
> WKTypeRef WKRetain(WKTypeRef typeRef)
> {
>-    toImpl(typeRef)->ref();
>+    WebKit::toImpl(typeRef)->ref();
> 
>     return typeRef;
> }
> 
> void WKRelease(WKTypeRef typeRef)
> {
>-    toImpl(typeRef)->deref();
>+    WebKit::toImpl(typeRef)->deref();
> }
>diff --git a/Source/WebKit/Shared/API/c/WKURL.cpp b/Source/WebKit/Shared/API/c/WKURL.cpp
>index f1a1ea54682081713123b1720fb34bfee25d5cc8..17c9a62d3178d1b050f1d7d169157840d9609b4b 100644
>--- a/Source/WebKit/Shared/API/c/WKURL.cpp
>+++ b/Source/WebKit/Shared/API/c/WKURL.cpp
>@@ -28,49 +28,47 @@
> 
> #include "WKAPICast.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKURLGetTypeID()
> {
>-    return toAPI(API::URL::APIType);
>+    return WebKit::toAPI(API::URL::APIType);
> }
> 
> WKURLRef WKURLCreateWithUTF8CString(const char* string)
> {
>-    return toAPI(&API::URL::create(String::fromUTF8(string)).leakRef());
>+    return WebKit::toAPI(&API::URL::create(String::fromUTF8(string)).leakRef());
> }
> 
> WKURLRef WKURLCreateWithBaseURL(WKURLRef baseURL, const char* relative)
> {
>-    return toAPI(&API::URL::create(toImpl(baseURL), String::fromUTF8(relative)).leakRef());
>+    return WebKit::toAPI(&API::URL::create(WebKit::toImpl(baseURL), String::fromUTF8(relative)).leakRef());
> }
> 
> WKStringRef WKURLCopyString(WKURLRef url)
> {
>-    return toCopiedAPI(toImpl(url)->string());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(url)->string());
> }
> 
> bool WKURLIsEqual(WKURLRef a, WKURLRef b)
> {
>-    return API::URL::equals(*toImpl(a), *toImpl(b));
>+    return API::URL::equals(*WebKit::toImpl(a), *WebKit::toImpl(b));
> }
> 
> WKStringRef WKURLCopyHostName(WKURLRef url)
> {
>-    return toCopiedAPI(toImpl(url)->host());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(url)->host());
> }
> 
> WKStringRef WKURLCopyScheme(WKURLRef url)
> {
>-    return toCopiedAPI(toImpl(url)->protocol());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(url)->protocol());
> }
> 
> WK_EXPORT WKStringRef WKURLCopyPath(WKURLRef url)
> {
>-    return toCopiedAPI(toImpl(url)->path());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(url)->path());
> }
> 
> WKStringRef WKURLCopyLastPathComponent(WKURLRef url)
> {
>-    return toCopiedAPI(toImpl(url)->lastPathComponent());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(url)->lastPathComponent());
> }
>diff --git a/Source/WebKit/Shared/API/c/WKURLRequest.cpp b/Source/WebKit/Shared/API/c/WKURLRequest.cpp
>index 1499563e39ae7b986de1734767885f6aad928d32..296caf7c3275e0253dfea6d688669302cba80a56 100644
>--- a/Source/WebKit/Shared/API/c/WKURLRequest.cpp
>+++ b/Source/WebKit/Shared/API/c/WKURLRequest.cpp
>@@ -31,39 +31,36 @@
> #include "WKData.h"
> #include <wtf/URL.h>
> 
>-using namespace WebCore;
>-using namespace WebKit;
>-
> WKTypeID WKURLRequestGetTypeID()
> {
>-    return toAPI(API::URLRequest::APIType);
>+    return WebKit::toAPI(API::URLRequest::APIType);
> }
> 
> WKURLRequestRef WKURLRequestCreateWithWKURL(WKURLRef url)
> {
>-    return toAPI(&API::URLRequest::create(URL(URL(), toImpl(url)->string())).leakRef());
>+    return WebKit::toAPI(&API::URLRequest::create(URL(URL(), WebKit::toImpl(url)->string())).leakRef());
> }
> 
> WKURLRef WKURLRequestCopyURL(WKURLRequestRef requestRef)
> {
>-    return toCopiedURLAPI(toImpl(requestRef)->resourceRequest().url());
>+    return WebKit::toCopiedURLAPI(WebKit::toImpl(requestRef)->resourceRequest().url());
> }
> 
> WKURLRef WKURLRequestCopyFirstPartyForCookies(WKURLRequestRef requestRef)
> {
>-    return toCopiedURLAPI(toImpl(requestRef)->resourceRequest().firstPartyForCookies());
>+    return WebKit::toCopiedURLAPI(WebKit::toImpl(requestRef)->resourceRequest().firstPartyForCookies());
> }
> 
> WKStringRef WKURLRequestCopyHTTPMethod(WKURLRequestRef requestRef)
> {
>-    return toCopiedAPI(toImpl(requestRef)->resourceRequest().httpMethod());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(requestRef)->resourceRequest().httpMethod());
> }
> 
> WKURLRequestRef WKURLRequestCopySettingHTTPBody(WKURLRequestRef requestRef, WKDataRef body)
> {
>-    WebCore::ResourceRequest requestCopy(toImpl(requestRef)->resourceRequest());
>-    requestCopy.setHTTPBody(FormData::create(WKDataGetBytes(body), WKDataGetSize(body)));
>-    return toAPI(&API::URLRequest::create(requestCopy).leakRef());
>+    WebCore::ResourceRequest requestCopy(WebKit::toImpl(requestRef)->resourceRequest());
>+    requestCopy.setHTTPBody(WebCore::FormData::create(WKDataGetBytes(body), WKDataGetSize(body)));
>+    return WebKit::toAPI(&API::URLRequest::create(requestCopy).leakRef());
> }
> 
> void WKURLRequestSetDefaultTimeoutInterval(double timeoutInterval)
>diff --git a/Source/WebKit/Shared/API/c/WKURLResponse.cpp b/Source/WebKit/Shared/API/c/WKURLResponse.cpp
>index 8f1fa9ad6e36e98ac413eba9ef9553cad40638cf..1990c033ed85ca6af45a07e961af0e2481d4374a 100644
>--- a/Source/WebKit/Shared/API/c/WKURLResponse.cpp
>+++ b/Source/WebKit/Shared/API/c/WKURLResponse.cpp
>@@ -30,39 +30,37 @@
> #include "WKAPICast.h"
> #include <wtf/URL.h>
> 
>-using namespace WebKit;
>-
> WKTypeID WKURLResponseGetTypeID()
> {
>-    return toAPI(API::URLResponse::APIType);
>+    return WebKit::toAPI(API::URLResponse::APIType);
> }
> 
> WKURLRef WKURLResponseCopyURL(WKURLResponseRef responseRef)
> {
>-    return toCopiedURLAPI(toImpl(responseRef)->resourceResponse().url());
>+    return WebKit::toCopiedURLAPI(WebKit::toImpl(responseRef)->resourceResponse().url());
> }
> 
> WKStringRef WKURLResponseCopyMIMEType(WKURLResponseRef responseRef)
> {
>-    return toCopiedAPI(toImpl(responseRef)->resourceResponse().mimeType());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(responseRef)->resourceResponse().mimeType());
> }
> 
> int32_t WKURLResponseHTTPStatusCode(WKURLResponseRef responseRef)
> {
>-    return toImpl(responseRef)->resourceResponse().httpStatusCode();
>+    return WebKit::toImpl(responseRef)->resourceResponse().httpStatusCode();
> }
> 
> WKStringRef WKURLResponseCopySuggestedFilename(WKURLResponseRef responseRef)
> {
>-    return toCopiedAPI(toImpl(responseRef)->resourceResponse().suggestedFilename());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(responseRef)->resourceResponse().suggestedFilename());
> }
> 
> bool WKURLResponseIsAttachment(WKURLResponseRef responseRef)
> {
>-    return toImpl(responseRef)->resourceResponse().isAttachment();
>+    return WebKit::toImpl(responseRef)->resourceResponse().isAttachment();
> }
> 
> uint32_t WKURLResponseGetExpectedContentLength(WKURLResponseRef responseRef)
> {
>-    return toImpl(responseRef)->resourceResponse().expectedContentLength();
>+    return WebKit::toImpl(responseRef)->resourceResponse().expectedContentLength();
> }
>diff --git a/Source/WebKit/Shared/API/c/WKUserContentURLPattern.cpp b/Source/WebKit/Shared/API/c/WKUserContentURLPattern.cpp
>index ceedc7696331307062394af57572e69ef444e888..fdeba797105a782631952acdab7b3bb883ccef8b 100644
>--- a/Source/WebKit/Shared/API/c/WKUserContentURLPattern.cpp
>+++ b/Source/WebKit/Shared/API/c/WKUserContentURLPattern.cpp
>@@ -30,39 +30,37 @@
> #include "WKAPICast.h"
> #include "WKString.h"
> 
>-using namespace WebKit;
>-
> WKTypeID WKUserContentURLPatternGetTypeID()
> {
>-    return toAPI(API::UserContentURLPattern::APIType);
>+    return WebKit::toAPI(API::UserContentURLPattern::APIType);
> }
> 
> WKUserContentURLPatternRef WKUserContentURLPatternCreate(WKStringRef patternRef)
> {
>-    return toAPI(&API::UserContentURLPattern::create(toImpl(patternRef)->string()).leakRef());
>+    return WebKit::toAPI(&API::UserContentURLPattern::create(WebKit::toImpl(patternRef)->string()).leakRef());
> }
> 
> WKStringRef WKUserContentURLPatternCopyHost(WKUserContentURLPatternRef urlPatternRef)
> {
>-    return toCopiedAPI(toImpl(urlPatternRef)->host());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(urlPatternRef)->host());
> }
> 
> WKStringRef WKUserContentURLPatternCopyScheme(WKUserContentURLPatternRef urlPatternRef)
> {
>-    return toCopiedAPI(toImpl(urlPatternRef)->scheme());
>+    return WebKit::toCopiedAPI(WebKit::toImpl(urlPatternRef)->scheme());
> }
> 
> bool WKUserContentURLPatternIsValid(WKUserContentURLPatternRef urlPatternRef)
> {
>-    return toImpl(urlPatternRef)->isValid();
>+    return WebKit::toImpl(urlPatternRef)->isValid();
> }
> 
> bool WKUserContentURLPatternMatchesURL(WKUserContentURLPatternRef urlPatternRef, WKURLRef urlRef)
> {
>-    return toImpl(urlPatternRef)->matchesURL(toWTFString(urlRef));
>+    return WebKit::toImpl(urlPatternRef)->matchesURL(WebKit::toWTFString(urlRef));
> }
> 
> bool WKUserContentURLPatternMatchesSubdomains(WKUserContentURLPatternRef urlPatternRef)
> {
>-    return toImpl(urlPatternRef)->matchesSubdomains();
>+    return WebKit::toImpl(urlPatternRef)->matchesSubdomains();
> }
>diff --git a/Source/WebKit/Shared/API/c/cairo/WKImageCairo.cpp b/Source/WebKit/Shared/API/c/cairo/WKImageCairo.cpp
>index 30af4dfa41f720a1a95b5728d3f82f8c03876872..ccfcc668f1f5417f500c0b248a35489966f91e1a 100644
>--- a/Source/WebKit/Shared/API/c/cairo/WKImageCairo.cpp
>+++ b/Source/WebKit/Shared/API/c/cairo/WKImageCairo.cpp
>@@ -34,19 +34,16 @@
> #include <WebCore/PlatformContextCairo.h>
> #include <cairo.h>
> 
>-using namespace WebKit;
>-using namespace WebCore;
>-
> cairo_surface_t* WKImageCreateCairoSurface(WKImageRef imageRef)
> {
>     // We cannot pass a RefPtr through the API here, so we just leak the reference.
>-    return toImpl(imageRef)->bitmap().createCairoSurface().leakRef();
>+    return WebKit::toImpl(imageRef)->bitmap().createCairoSurface().leakRef();
> }
> 
> WKImageRef WKImageCreateFromCairoSurface(cairo_surface_t* surface, WKImageOptions options)
> {
>-    IntSize imageSize(cairo_image_surface_get_width(surface), cairo_image_surface_get_height(surface));
>-    auto webImage = WebImage::create(imageSize, toImageOptions(options));
>+    WebCore::IntSize imageSize(cairo_image_surface_get_width(surface), cairo_image_surface_get_height(surface));
>+    auto webImage = WebKit::WebImage::create(imageSize, WebKit::toImageOptions(options));
>     auto graphicsContext = webImage->bitmap().createGraphicsContext();
> 
>     cairo_t* cr = graphicsContext->platformContext()->cr();
>diff --git a/Source/WebKit/Shared/API/c/curl/WKCertificateInfoCurl.cpp b/Source/WebKit/Shared/API/c/curl/WKCertificateInfoCurl.cpp
>index 77f02ff2baf9785ad73e30f0fec12fa50e15bbef..64d30192a35ba29494b35a67f01bb3b80e023774 100644
>--- a/Source/WebKit/Shared/API/c/curl/WKCertificateInfoCurl.cpp
>+++ b/Source/WebKit/Shared/API/c/curl/WKCertificateInfoCurl.cpp
>@@ -34,8 +34,6 @@
> 
> #include <WebCore/CertificateInfo.h>
> 
>-using namespace WebKit;
>-
> using Certificate = Vector<uint8_t>;
> using CertificateChain = Vector<Certificate>;
> 
>@@ -55,19 +53,19 @@ WKCertificateInfoRef WKCertificateInfoCreateWithCertficateChain(WKArrayRef certi
> 
> int WKCertificateInfoGetVerificationError(WKCertificateInfoRef certificateInfoRef)
> {
>-    return toImpl(certificateInfoRef)->certificateInfo().verificationError();
>+    return WebKit::toImpl(certificateInfoRef)->certificateInfo().verificationError();
> }
> 
> size_t WKCertificateInfoGetCertificateChainSize(WKCertificateInfoRef certificateInfoRef)
> {
>-    return toImpl(certificateInfoRef)->certificateInfo().certificateChain().size();
>+    return WebKit::toImpl(certificateInfoRef)->certificateInfo().certificateChain().size();
> }
> 
> WKDataRef WKCertificateInfoCopyCertificateAtIndex(WKCertificateInfoRef certificateInfoRef, size_t index)
> {
>-    if (toImpl(certificateInfoRef)->certificateInfo().certificateChain().size() <= index)
>+    if (WebKit::toImpl(certificateInfoRef)->certificateInfo().certificateChain().size() <= index)
>         return WebKit::toAPI(&API::Data::create(nullptr, 0).leakRef());
> 
>-    const auto& certificate = toImpl(certificateInfoRef)->certificateInfo().certificateChain().at(index);
>+    const auto& certificate = WebKit::toImpl(certificateInfoRef)->certificateInfo().certificateChain().at(index);
>     return WebKit::toAPI(&API::Data::create(reinterpret_cast<const unsigned char*>(certificate.data()), certificate.size()).leakRef());
> }

Actions: View | Formatted Diff | Diff

Attachments on bug 192352: 356464 | 356465 | 356467 | 356472 | 356473 | 356566