Rename WebKit namespace to blink

Source/web/StorageAreaProxy.cpp

 /*
  * Copyright (C) 2009 Google Inc. All Rights Reserved.
  *           (C) 2008 Apple Inc.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 33 matching lines @@
 
 #include "WebFrameImpl.h"
 #include "WebPermissionClient.h"
 #include "WebViewImpl.h"
 #include "public/platform/WebStorageArea.h"
 #include "public/platform/WebString.h"
 #include "public/platform/WebURL.h"
 
 namespace WebCore {
 
-StorageAreaProxy::StorageAreaProxy(PassOwnPtr<WebKit::WebStorageArea> storageArea, StorageType storageType)
+StorageAreaProxy::StorageAreaProxy(PassOwnPtr<blink::WebStorageArea> storageArea, StorageType storageType)
     : m_storageArea(storageArea)
     , m_storageType(storageType)
     , m_canAccessStorageCachedResult(false)
     , m_canAccessStorageCachedFrame(0)
 {
 }
 
 StorageAreaProxy::~StorageAreaProxy()
 {
 }
@@ skipping 24 matching lines @@
     }
     return m_storageArea->getItem(key);
 }
 
 void StorageAreaProxy::setItem(const String& key, const String& value, ExceptionState& es, Frame* frame)
 {
     if (!canAccessStorage(frame)) {
         es.throwSecurityError(ExceptionMessages::failedToExecute("setItem", "Storage", "access is denied for this document."));
         return;
     }
-    WebKit::WebStorageArea::Result result = WebKit::WebStorageArea::ResultOK;
+    blink::WebStorageArea::Result result = blink::WebStorageArea::ResultOK;
     m_storageArea->setItem(key, value, frame->document()->url(), result);
-    if (result != WebKit::WebStorageArea::ResultOK)
+    if (result != blink::WebStorageArea::ResultOK)
         es.throwDOMException(QuotaExceededError, ExceptionMessages::failedToExecute("setItem", "Storage", "Setting the value of '" + key + "' exceeded the quota."));
 }
 
 void StorageAreaProxy::removeItem(const String& key, ExceptionState& es, Frame* frame)
 {
     if (!canAccessStorage(frame)) {
         es.throwSecurityError(ExceptionMessages::failedToExecute("removeItem", "Storage", "access is denied for this document."));
         return;
     }
     m_storageArea->removeItem(key, frame->document()->url());
@@ skipping 16 matching lines @@
     }
     return !getItem(key, es, frame).isNull();
 }
 
 bool StorageAreaProxy::canAccessStorage(Frame* frame)
 {
     if (!frame || !frame->page())
         return false;
     if (m_canAccessStorageCachedFrame == frame)
         return m_canAccessStorageCachedResult;
-    WebKit::WebFrameImpl* webFrame = WebKit::WebFrameImpl::fromFrame(frame);
-    WebKit::WebViewImpl* webView = webFrame->viewImpl();
+    blink::WebFrameImpl* webFrame = blink::WebFrameImpl::fromFrame(frame);
+    blink::WebViewImpl* webView = webFrame->viewImpl();
     bool result = !webView->permissionClient() || webView->permissionClient()->allowStorage(webFrame, m_storageType == LocalStorage);
     m_canAccessStorageCachedFrame = frame;
     m_canAccessStorageCachedResult = result;
     return result;
 }
 
 size_t StorageAreaProxy::memoryBytesUsedByCache()
 {
     return m_storageArea->memoryBytesUsedByCache();
 }
 
 void StorageAreaProxy::dispatchLocalStorageEvent(const String& key, const String& oldValue, const String& newValue,
-                                                 SecurityOrigin* securityOrigin, const KURL& pageURL, WebKit::WebStorageArea* sourceAreaInstance, bool originatedInProcess)
+                                                 SecurityOrigin* securityOrigin, const KURL& pageURL, blink::WebStorageArea* sourceAreaInstance, bool originatedInProcess)
 {
     // FIXME: This looks suspicious. Why doesn't this use allPages instead?
     const HashSet<Page*>& pages = PageGroup::sharedGroup()->pages();
     for (HashSet<Page*>::const_iterator it = pages.begin(); it != pages.end(); ++it) {
         for (Frame* frame = (*it)->mainFrame(); frame; frame = frame->tree().traverseNext()) {
             Storage* storage = frame->domWindow()->optionalLocalStorage();
             if (storage && frame->document()->securityOrigin()->equal(securityOrigin) && !isEventSource(storage, sourceAreaInstance))
                 frame->domWindow()->enqueueWindowEvent(StorageEvent::create(EventTypeNames::storage, key, oldValue, newValue, pageURL, storage));
         }
         InspectorInstrumentation::didDispatchDOMStorageEvent(*it, key, oldValue, newValue, LocalStorage, securityOrigin);
     }
 }
 
-static Page* findPageWithSessionStorageNamespace(const WebKit::WebStorageNamespace& sessionNamespace)
+static Page* findPageWithSessionStorageNamespace(const blink::WebStorageNamespace& sessionNamespace)
 {
     // FIXME: This looks suspicious. Why doesn't this use allPages instead?
     const HashSet<Page*>& pages = PageGroup::sharedGroup()->pages();
     for (HashSet<Page*>::const_iterator it = pages.begin(); it != pages.end(); ++it) {
         const bool dontCreateIfMissing = false;
         StorageNamespaceProxy* proxy = static_cast<StorageNamespaceProxy*>((*it)->sessionStorage(dontCreateIfMissing));
         if (proxy && proxy->isSameNamespace(sessionNamespace))
             return *it;
     }
     return 0;
 }
 
 void StorageAreaProxy::dispatchSessionStorageEvent(const String& key, const String& oldValue, const String& newValue,
-                                                   SecurityOrigin* securityOrigin, const KURL& pageURL, const WebKit::WebStorageNamespace& sessionNamespace,
-                                                   WebKit::WebStorageArea* sourceAreaInstance, bool originatedInProcess)
+                                                   SecurityOrigin* securityOrigin, const KURL& pageURL, const blink::WebStorageNamespace& sessionNamespace,
+                                                   blink::WebStorageArea* sourceAreaInstance, bool originatedInProcess)
 {
     Page* page = findPageWithSessionStorageNamespace(sessionNamespace);
     if (!page)
         return;
 
     for (Frame* frame = page->mainFrame(); frame; frame = frame->tree().traverseNext()) {
         Storage* storage = frame->domWindow()->optionalSessionStorage();
         if (storage && frame->document()->securityOrigin()->equal(securityOrigin) && !isEventSource(storage, sourceAreaInstance))
             frame->domWindow()->enqueueWindowEvent(StorageEvent::create(EventTypeNames::storage, key, oldValue, newValue, pageURL, storage));
     }
     InspectorInstrumentation::didDispatchDOMStorageEvent(page, key, oldValue, newValue, SessionStorage, securityOrigin);
 }
 
-bool StorageAreaProxy::isEventSource(Storage* storage, WebKit::WebStorageArea* sourceAreaInstance)
+bool StorageAreaProxy::isEventSource(Storage* storage, blink::WebStorageArea* sourceAreaInstance)
 {
     ASSERT(storage);
     StorageAreaProxy* areaProxy = static_cast<StorageAreaProxy*>(storage->area());
     return areaProxy->m_storageArea == sourceAreaInstance;
 }
 
 } // namespace WebCore