mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 1

app: api to clear data from different storage types

Browse source
This commit is contained in:
Robo 2015-07-02 19:42:18 +05:30
parent d661099322
commit 628fb5f5e9
5 changed files with 150 additions and 6 deletions
Download patch file Download diff file Expand all files Collapse all files

96
atom/browser/api/atom_api_session.cc
View file

@ -10,17 +10,67 @@
#include "atom/browser/atom_browser_context.h"
#include "atom/common/native_mate_converters/gurl_converter.h"
#include "base/thread_task_runner_handle.h"
#include "base/strings/string_util.h"
#include "content/public/browser/browser_thread.h"
#include "content/public/browser/storage_partition.h"
#include "native_mate/callback.h"
#include "native_mate/object_template_builder.h"
#include "net/base/load_flags.h"
#include "net/disk_cache/disk_cache.h"
#include "net/proxy/proxy_service.h"
#include "net/url_request/url_request_context.h"
#include "net/url_request/url_request_context_getter.h"
#include "atom/common/node_includes.h"
using content::BrowserThread;
using content::StoragePartition;
namespace {
int GetStorageMask(const std::vector<std::string>& storage_types) {
int storage_mask = 0;
for (auto &it : storage_types) {
auto type = base::StringToLowerASCII(it);
if (type == "appcache") {
storage_mask |= StoragePartition::REMOVE_DATA_MASK_APPCACHE;
} else if (type == "cookies") {
storage_mask |= StoragePartition::REMOVE_DATA_MASK_COOKIES;
} else if (type == "filesystem") {
storage_mask |= StoragePartition::REMOVE_DATA_MASK_FILE_SYSTEMS;
} else if (type == "indexdb") {
storage_mask |= StoragePartition::REMOVE_DATA_MASK_INDEXEDDB;
} else if (type == "localstorage") {
storage_mask |= StoragePartition::REMOVE_DATA_MASK_LOCAL_STORAGE;
} else if (type == "shadercache") {
storage_mask |= StoragePartition::REMOVE_DATA_MASK_SHADER_CACHE;
} else if (type == "websql") {
storage_mask |= StoragePartition::REMOVE_DATA_MASK_WEBSQL;
} else if (type == "serviceworkers") {
storage_mask |= StoragePartition::REMOVE_DATA_MASK_SERVICE_WORKERS;
}
}
return storage_mask;
}
int GetQuotaMask(const std::vector<std::string>& quota_types) {
int quota_mask = 0;
for (auto &type : quota_types) {
if (type == "temporary") {
quota_mask |= StoragePartition::QUOTA_MANAGED_STORAGE_MASK_TEMPORARY;
} else if (type == "persistent") {
quota_mask |= StoragePartition::QUOTA_MANAGED_STORAGE_MASK_PERSISTENT;
}
}
return quota_mask;
}
} // namespace
namespace atom {
namespace api {
@ -80,6 +130,30 @@ class ResolveProxyHelper {
DISALLOW_COPY_AND_ASSIGN(ResolveProxyHelper);
};
void Noop(int result) {
DCHECK(result == net::OK);
}
void DoClearCache(disk_cache::Backend** cache_ptr,
int result) {
DCHECK(result == net::OK);
if (cache_ptr && *cache_ptr)
(*cache_ptr)->DoomAllEntries(base::Bind(&Noop));
}
void ClearHttpCacheOnIO(net::URLRequestContextGetter* getter) {
typedef disk_cache::Backend* Backendptr;
Backendptr* cache_ptr = new Backendptr(nullptr);
auto request_context = getter->GetURLRequestContext();
net::CompletionCallback callback(base::Bind(&DoClearCache,
base::Owned(cache_ptr)));
auto http_cache = request_context->http_transaction_factory()->GetCache();
int rv = http_cache->GetBackend(cache_ptr, callback);
if (rv != net::ERR_IO_PENDING)
callback.Run(net::OK);
}
} // namespace
Session::Session(AtomBrowserContext* browser_context)
@ -94,6 +168,26 @@ void Session::ResolveProxy(const GURL& url, ResolveProxyCallback callback) {
new ResolveProxyHelper(browser_context_, url, callback);
}
void Session::ClearCache(const base::Closure& callback) {
auto getter = browser_context_->GetRequestContext();
BrowserThread::PostTaskAndReply(BrowserThread::IO, FROM_HERE,
base::Bind(&ClearHttpCacheOnIO,
base::Unretained(getter)),
callback);
}
void Session::ClearStorageData(const GURL& origin,
const std::vector<std::string>& storage_types,
const std::vector<std::string>& quota_types,
const base::Closure& callback) {
auto storage_partition =
content::BrowserContext::GetStoragePartition(browser_context_, nullptr);
storage_partition->ClearData(
GetStorageMask(storage_types), GetQuotaMask(quota_types), origin,
content::StoragePartition::OriginMatcherFunction(),
base::Time(), base::Time::Max(), callback);
}
v8::Local<v8::Value> Session::Cookies(v8::Isolate* isolate) {
if (cookies_.IsEmpty()) {
auto handle = atom::api::Cookies::Create(isolate, browser_context_);
@ -106,6 +200,8 @@ mate::ObjectTemplateBuilder Session::GetObjectTemplateBuilder(
v8::Isolate* isolate) {
return mate::ObjectTemplateBuilder(isolate)
.SetMethod("resolveProxy", &Session::ResolveProxy)
.SetMethod("clearCache", &Session::ClearCache)
.SetMethod("clearStorageData", &Session::ClearStorageData)
.SetProperty("cookies", &Session::Cookies);
}

6
atom/browser/api/atom_api_session.h
View file

@ -6,6 +6,7 @@
#define ATOM_BROWSER_API_ATOM_API_SESSION_H_
#include <string>
#include <vector>
#include "atom/browser/api/trackable_object.h"
#include "base/callback.h"
@ -37,6 +38,11 @@ class Session: public mate::TrackableObject<Session> {
private:
void ResolveProxy(const GURL& url, ResolveProxyCallback callback);
void ClearCache(const base::Closure& callback);
void ClearStorageData(const GURL& origin,
const std::vector<std::string>& storage_types,
const std::vector<std::string>& quota_types,
const base::Closure& callback);
v8::Local<v8::Value> Cookies(v8::Isolate* isolate);
v8::Global<v8::Value> cookies_;