| /* |
| * 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 |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY GOOGLE INC. ``AS IS'' AND ANY |
| * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR |
| * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GOOGLE INC. OR |
| * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, |
| * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, |
| * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR |
| * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY |
| * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "modules/storage/StorageArea.h" |
| |
| #include "bindings/core/v8/ExceptionState.h" |
| #include "core/dom/Document.h" |
| #include "core/dom/ExceptionCode.h" |
| #include "core/frame/LocalDOMWindow.h" |
| #include "core/frame/LocalFrame.h" |
| #include "core/page/Page.h" |
| #include "modules/storage/DOMWindowStorage.h" |
| #include "modules/storage/InspectorDOMStorageAgent.h" |
| #include "modules/storage/Storage.h" |
| #include "modules/storage/StorageClient.h" |
| #include "modules/storage/StorageEvent.h" |
| #include "modules/storage/StorageNamespace.h" |
| #include "modules/storage/StorageNamespaceController.h" |
| #include "platform/weborigin/SecurityOrigin.h" |
| #include "public/platform/WebStorageArea.h" |
| #include "public/platform/WebString.h" |
| #include "public/platform/WebURL.h" |
| #include <memory> |
| |
| namespace blink { |
| |
| StorageArea* StorageArea::create(std::unique_ptr<WebStorageArea> storageArea, |
| StorageType storageType) { |
| return new StorageArea(std::move(storageArea), storageType); |
| } |
| |
| StorageArea::StorageArea(std::unique_ptr<WebStorageArea> storageArea, |
| StorageType storageType) |
| : m_storageArea(std::move(storageArea)), |
| m_storageType(storageType), |
| m_frameUsedForCanAccessStorage(nullptr), |
| m_canAccessStorageCachedResult(false) {} |
| |
| StorageArea::~StorageArea() {} |
| |
| DEFINE_TRACE(StorageArea) { |
| visitor->trace(m_frameUsedForCanAccessStorage); |
| } |
| |
| unsigned StorageArea::length(ExceptionState& exceptionState, |
| LocalFrame* frame) { |
| if (!canAccessStorage(frame)) { |
| exceptionState.throwSecurityError("access is denied for this document."); |
| return 0; |
| } |
| return m_storageArea->length(); |
| } |
| |
| String StorageArea::key(unsigned index, |
| ExceptionState& exceptionState, |
| LocalFrame* frame) { |
| if (!canAccessStorage(frame)) { |
| exceptionState.throwSecurityError("access is denied for this document."); |
| return String(); |
| } |
| return m_storageArea->key(index); |
| } |
| |
| String StorageArea::getItem(const String& key, |
| ExceptionState& exceptionState, |
| LocalFrame* frame) { |
| if (!canAccessStorage(frame)) { |
| exceptionState.throwSecurityError("access is denied for this document."); |
| return String(); |
| } |
| return m_storageArea->getItem(key); |
| } |
| |
| void StorageArea::setItem(const String& key, |
| const String& value, |
| ExceptionState& exceptionState, |
| LocalFrame* frame) { |
| if (!canAccessStorage(frame)) { |
| exceptionState.throwSecurityError("access is denied for this document."); |
| return; |
| } |
| WebStorageArea::Result result = WebStorageArea::ResultOK; |
| m_storageArea->setItem(key, value, frame->document()->url(), result); |
| if (result != WebStorageArea::ResultOK) |
| exceptionState.throwDOMException( |
| QuotaExceededError, |
| "Setting the value of '" + key + "' exceeded the quota."); |
| } |
| |
| void StorageArea::removeItem(const String& key, |
| ExceptionState& exceptionState, |
| LocalFrame* frame) { |
| if (!canAccessStorage(frame)) { |
| exceptionState.throwSecurityError("access is denied for this document."); |
| return; |
| } |
| m_storageArea->removeItem(key, frame->document()->url()); |
| } |
| |
| void StorageArea::clear(ExceptionState& exceptionState, LocalFrame* frame) { |
| if (!canAccessStorage(frame)) { |
| exceptionState.throwSecurityError("access is denied for this document."); |
| return; |
| } |
| m_storageArea->clear(frame->document()->url()); |
| } |
| |
| bool StorageArea::contains(const String& key, |
| ExceptionState& exceptionState, |
| LocalFrame* frame) { |
| if (!canAccessStorage(frame)) { |
| exceptionState.throwSecurityError("access is denied for this document."); |
| return false; |
| } |
| return !getItem(key, exceptionState, frame).isNull(); |
| } |
| |
| bool StorageArea::canAccessStorage(LocalFrame* frame) { |
| if (!frame || !frame->page()) |
| return false; |
| |
| // Should the LocalFrame die before this StorageArea does, |
| // that cached reference will be cleared. |
| if (m_frameUsedForCanAccessStorage == frame) |
| return m_canAccessStorageCachedResult; |
| StorageNamespaceController* controller = |
| StorageNamespaceController::from(frame->page()); |
| if (!controller) |
| return false; |
| bool result = |
| controller->getStorageClient()->canAccessStorage(frame, m_storageType); |
| // Move attention to the new LocalFrame. |
| m_frameUsedForCanAccessStorage = frame; |
| m_canAccessStorageCachedResult = result; |
| return result; |
| } |
| |
| void StorageArea::dispatchLocalStorageEvent( |
| const String& key, |
| const String& oldValue, |
| const String& newValue, |
| SecurityOrigin* securityOrigin, |
| const KURL& pageURL, |
| WebStorageArea* sourceAreaInstance) { |
| // Iterate over all pages that have a StorageNamespaceController supplement. |
| for (Page* page : Page::ordinaryPages()) { |
| for (Frame* frame = page->mainFrame(); frame; |
| frame = frame->tree().traverseNext()) { |
| // FIXME: We do not yet have a way to dispatch events to out-of-process |
| // frames. |
| if (!frame->isLocalFrame()) |
| continue; |
| LocalFrame* localFrame = toLocalFrame(frame); |
| LocalDOMWindow* localWindow = localFrame->localDOMWindow(); |
| Storage* storage = |
| DOMWindowStorage::from(*localWindow).optionalLocalStorage(); |
| if (storage && |
| localFrame->document()->getSecurityOrigin()->canAccess( |
| securityOrigin) && |
| !isEventSource(storage, sourceAreaInstance)) |
| localFrame->localDOMWindow()->enqueueWindowEvent( |
| StorageEvent::create(EventTypeNames::storage, key, oldValue, |
| newValue, pageURL, storage)); |
| } |
| if (InspectorDOMStorageAgent* agent = |
| StorageNamespaceController::from(page)->inspectorAgent()) |
| agent->didDispatchDOMStorageEvent(key, oldValue, newValue, LocalStorage, |
| securityOrigin); |
| } |
| } |
| |
| static Page* findPageWithSessionStorageNamespace( |
| const WebStorageNamespace& sessionNamespace) { |
| // Iterate over all pages that have a StorageNamespaceController supplement. |
| for (Page* page : Page::ordinaryPages()) { |
| const bool dontCreateIfMissing = false; |
| StorageNamespace* storageNamespace = |
| StorageNamespaceController::from(page)->sessionStorage( |
| dontCreateIfMissing); |
| if (storageNamespace && storageNamespace->isSameNamespace(sessionNamespace)) |
| return page; |
| } |
| return nullptr; |
| } |
| |
| void StorageArea::dispatchSessionStorageEvent( |
| const String& key, |
| const String& oldValue, |
| const String& newValue, |
| SecurityOrigin* securityOrigin, |
| const KURL& pageURL, |
| const WebStorageNamespace& sessionNamespace, |
| WebStorageArea* sourceAreaInstance) { |
| Page* page = findPageWithSessionStorageNamespace(sessionNamespace); |
| if (!page) |
| return; |
| |
| for (Frame* frame = page->mainFrame(); frame; |
| frame = frame->tree().traverseNext()) { |
| // FIXME: We do not yet have a way to dispatch events to out-of-process |
| // frames. |
| if (!frame->isLocalFrame()) |
| continue; |
| LocalFrame* localFrame = toLocalFrame(frame); |
| LocalDOMWindow* localWindow = localFrame->localDOMWindow(); |
| Storage* storage = |
| DOMWindowStorage::from(*localWindow).optionalSessionStorage(); |
| if (storage && |
| localFrame->document()->getSecurityOrigin()->canAccess( |
| securityOrigin) && |
| !isEventSource(storage, sourceAreaInstance)) |
| localFrame->localDOMWindow()->enqueueWindowEvent(StorageEvent::create( |
| EventTypeNames::storage, key, oldValue, newValue, pageURL, storage)); |
| } |
| if (InspectorDOMStorageAgent* agent = |
| StorageNamespaceController::from(page)->inspectorAgent()) |
| agent->didDispatchDOMStorageEvent(key, oldValue, newValue, SessionStorage, |
| securityOrigin); |
| } |
| |
| bool StorageArea::isEventSource(Storage* storage, |
| WebStorageArea* sourceAreaInstance) { |
| ASSERT(storage); |
| StorageArea* area = storage->area(); |
| return area->m_storageArea.get() == sourceAreaInstance; |
| } |
| |
| } // namespace blink |
