#include "ChromiumBridge.h"
#endif
+#ifdef ANDROID
+#include "DOMWindow.h"
+#include "FileSystem.h"
+#endif
+
namespace WebCore {
static unsigned getUniqueIdentifier()
#endif
}
+#if ENABLE(DOM_STORAGE) && defined(ANDROID)
+void PageGroup::clearDomStorage()
+{
+ if (!pageGroups)
+ return;
+
+
+ PageGroupMap::iterator end = pageGroups->end();
+
+ for (PageGroupMap::iterator it = pageGroups->begin(); it != end; ++it) {
+ String basePath = "";
+
+ // This is being called as a result of the user explicitly
+ // asking to clear all stored data (e.g. through a settings
+ // dialog. We need a page in the page group to fire a
+ // StorageEvent. There isn't really a correct page to use
+ // as the source (as the clear request hasn't come from a
+ // particular page). One thing we should ensure though is that
+ // we don't try to clear a private browsing mode page as that has no concept
+ // of DOM storage..
+
+ HashSet<Page*> pages = it->second->pages();
+ HashSet<Page*>::iterator pagesEnd = pages.end();
+ Page* page = 0;
+ for(HashSet<Page*>::iterator pit = pages.begin(); pit != pagesEnd; ++pit) {
+ Page* p = *pit;
+
+ // Grab the storage location from an arbitrary page. This is set
+ // to the same value on all private browsing and "normal" pages,
+ // so we can get it from anything.
+ if (basePath.isEmpty())
+ basePath = p->settings()->localStorageDatabasePath();
+
+ // DOM storage is disabled in private browsing pages, so nothing to do if
+ // this is such a page.
+ if (p->settings()->privateBrowsingEnabled())
+ continue;
+
+ // Clear session storage.
+ StorageNamespace* sessionStorage = p->sessionStorage(false);
+ if (sessionStorage)
+ sessionStorage->clear(p);
+
+ // Save this page so we can clear local storage.
+ page = p;
+ }
+
+ // If page is still null at this point, then the only pages that are
+ // open are private browsing pages. Hence no pages are currently using local
+ // storage, so we don't need a page pointer to send any events and the
+ // clear function will handle a 0 input.
+ it->second->localStorage()->clear(page);
+ it->second->localStorage()->close();
+
+ // Closing the storage areas will stop the background thread and so
+ // we need to remove the local storage ref here so that next time
+ // we come to a site that uses it the thread will get started again.
+ it->second->removeLocalStorage();
+
+ // At this point, active local and session storage have been cleared and the
+ // StorageAreas for this PageGroup closed. The final sync will have taken
+ // place. All that is left is to purge the database files.
+ if (!basePath.isEmpty()) {
+ Vector<String> files = listDirectory(basePath, "*.localstorage");
+ Vector<String>::iterator filesEnd = files.end();
+ for (Vector<String>::iterator it = files.begin(); it != filesEnd; ++it)
+ deleteFile(*it);
+ }
+ }
+}
+
+void PageGroup::removeLocalStorage()
+{
+ HashSet<Page*> pages = this->pages();
+ HashSet<Page*>::iterator pagesEnd = pages.end();
+ for(HashSet<Page*>::iterator pit = pages.begin(); pit != pagesEnd; ++pit) {
+ Page* p = *pit;
+ for (Frame* frame = p->mainFrame(); frame; frame = frame->tree()->traverseNext())
+ frame->document()->domWindow()->clearDOMStorage();
+ }
+
+ m_localStorage = 0;
+}
+#endif
+
void PageGroup::addPage(Page* page)
{
ASSERT(page);
#include <wtf/StdLibExtras.h>
#include <wtf/text/StringHash.h>
+#ifdef ANDROID
+#include "Page.h"
+#endif
+
namespace WebCore {
typedef HashMap<String, StorageNamespace*> LocalStorageNamespaceMap;
m_isShutdown = true;
}
+#ifdef ANDROID
+void StorageNamespaceImpl::clear(Page* page)
+{
+ ASSERT(isMainThread());
+ if (m_isShutdown)
+ return;
+
+ // Clear all the keys for each of the storage areas.
+ StorageAreaMap::iterator end = m_storageAreaMap.end();
+ for (StorageAreaMap::iterator it = m_storageAreaMap.begin(); it != end; ++it) {
+ // if there is no page provided, then the user tried to clear storage
+ // with only pages in private browsing mode open. So we do not need to
+ // provide a Frame* here (as the frame is only used to dispatch storage events
+ // and private browsing pages won't be using them).
+ it->second->clear(page ? page->mainFrame() : 0);
+ }
+}
+#endif
+
void StorageNamespaceImpl::unlock()
{
// Because there's a single event loop per-process, this is a no-op.
#include "JavaSharedClient.h"
#include "KURL.h"
+#include "PageGroup.h"
#include "WebCoreJni.h"
#include <JNIHelp.h>
int size = manifestUrls.size();
for (int i = 0; i < size; ++i)
WebCore::cacheStorage().deleteCacheGroup(manifestUrls[i]);
+
+ // FIXME: this is a workaround for eliminating any DOM Storage data (both
+ // session and local storage) as there is no functionality inside WebKit at the
+ // moment to do it. That functionality is a WIP in https://bugs.webkit.org/show_bug.cgi?id=51878
+ // and when that patch lands and we merge it, we should move towards that approach instead.
+ WebCore::PageGroup::clearDomStorage();
}
static void SetAppCacheMaximumSize(JNIEnv* env, jobject obj, unsigned long long size)
OSDN Git Service
