From 98d6d4562142f682d3bc8419c0f29a4f7fd0f263 Mon Sep 17 00:00:00 2001
From: "pilgrim@chromium.org"
<pilgrim@chromium.org@0039d316-1c4b-4281-b951-d872f2087c98>
Date: Wed, 25 Jun 2014 20:57:55 +0000
Subject: Move all remaining appcache-related code to content namespace
This introduces NO FUNCTIONAL CHANGES. It is strictly a file move and namespace change.
BUG=338338
R=michaeln@chromium.org
TBR=cevans, darin
Review URL: https://codereview.chromium.org/344493002
git-svn-id: svn://svn.chromium.org/chrome/trunk/src@279808 0039d316-1c4b-4281-b951-d872f2087c98
---
content/browser/appcache/appcache_quota_client.cc | 253 ++++++++++++++++++++++
1 file changed, 253 insertions(+)
create mode 100644 content/browser/appcache/appcache_quota_client.cc
(limited to 'content/browser/appcache/appcache_quota_client.cc')
diff --git a/content/browser/appcache/appcache_quota_client.cc b/content/browser/appcache/appcache_quota_client.cc
new file mode 100644
index 0000000..2e8c2ab
--- /dev/null
+++ b/content/browser/appcache/appcache_quota_client.cc
@@ -0,0 +1,253 @@
+// Copyright (c) 2012 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "content/browser/appcache/appcache_quota_client.h"
+
+#include <algorithm>
+#include <map>
+#include <set>
+
+#include "base/bind.h"
+#include "base/bind_helpers.h"
+#include "content/browser/appcache/appcache_service_impl.h"
+
+using quota::QuotaClient;
+
+namespace {
+quota::QuotaStatusCode NetErrorCodeToQuotaStatus(int code) {
+ if (code == net::OK)
+ return quota::kQuotaStatusOk;
+ else if (code == net::ERR_ABORTED)
+ return quota::kQuotaErrorAbort;
+ else
+ return quota::kQuotaStatusUnknown;
+}
+
+void RunFront(content::AppCacheQuotaClient::RequestQueue* queue) {
+ base::Closure request = queue->front();
+ queue->pop_front();
+ request.Run();
+}
+} // namespace
+
+namespace content {
+
+AppCacheQuotaClient::AppCacheQuotaClient(AppCacheServiceImpl* service)
+ : service_(service),
+ appcache_is_ready_(false),
+ quota_manager_is_destroyed_(false) {
+}
+
+AppCacheQuotaClient::~AppCacheQuotaClient() {
+ DCHECK(pending_batch_requests_.empty());
+ DCHECK(pending_serial_requests_.empty());
+ DCHECK(current_delete_request_callback_.is_null());
+}
+
+QuotaClient::ID AppCacheQuotaClient::id() const {
+ return kAppcache;
+}
+
+void AppCacheQuotaClient::OnQuotaManagerDestroyed() {
+ DeletePendingRequests();
+ if (!current_delete_request_callback_.is_null()) {
+ current_delete_request_callback_.Reset();
+ GetServiceDeleteCallback()->Cancel();
+ }
+
+ quota_manager_is_destroyed_ = true;
+ if (!service_)
+ delete this;
+}
+
+void AppCacheQuotaClient::GetOriginUsage(
+ const GURL& origin,
+ quota::StorageType type,
+ const GetUsageCallback& callback) {
+ DCHECK(!callback.is_null());
+ DCHECK(!quota_manager_is_destroyed_);
+
+ if (!service_) {
+ callback.Run(0);
+ return;
+ }
+
+ if (!appcache_is_ready_) {
+ pending_batch_requests_.push_back(
+ base::Bind(&AppCacheQuotaClient::GetOriginUsage,
+ base::Unretained(this), origin, type, callback));
+ return;
+ }
+
+ if (type != quota::kStorageTypeTemporary) {
+ callback.Run(0);
+ return;
+ }
+
+ const AppCacheStorage::UsageMap* map = GetUsageMap();
+ AppCacheStorage::UsageMap::const_iterator found = map->find(origin);
+ if (found == map->end()) {
+ callback.Run(0);
+ return;
+ }
+ callback.Run(found->second);
+}
+
+void AppCacheQuotaClient::GetOriginsForType(
+ quota::StorageType type,
+ const GetOriginsCallback& callback) {
+ GetOriginsHelper(type, std::string(), callback);
+}
+
+void AppCacheQuotaClient::GetOriginsForHost(
+ quota::StorageType type,
+ const std::string& host,
+ const GetOriginsCallback& callback) {
+ DCHECK(!callback.is_null());
+ if (host.empty()) {
+ callback.Run(std::set<GURL>());
+ return;
+ }
+ GetOriginsHelper(type, host, callback);
+}
+
+void AppCacheQuotaClient::DeleteOriginData(const GURL& origin,
+ quota::StorageType type,
+ const DeletionCallback& callback) {
+ DCHECK(!quota_manager_is_destroyed_);
+
+ if (!service_) {
+ callback.Run(quota::kQuotaErrorAbort);
+ return;
+ }
+
+ if (!appcache_is_ready_ || !current_delete_request_callback_.is_null()) {
+ pending_serial_requests_.push_back(
+ base::Bind(&AppCacheQuotaClient::DeleteOriginData,
+ base::Unretained(this), origin, type, callback));
+ return;
+ }
+
+ current_delete_request_callback_ = callback;
+ if (type != quota::kStorageTypeTemporary) {
+ DidDeleteAppCachesForOrigin(net::OK);
+ return;
+ }
+
+ service_->DeleteAppCachesForOrigin(
+ origin, GetServiceDeleteCallback()->callback());
+}
+
+bool AppCacheQuotaClient::DoesSupport(quota::StorageType type) const {
+ return type == quota::kStorageTypeTemporary;
+}
+
+void AppCacheQuotaClient::DidDeleteAppCachesForOrigin(int rv) {
+ DCHECK(service_);
+ if (quota_manager_is_destroyed_)
+ return;
+
+ // Finish the request by calling our callers callback.
+ current_delete_request_callback_.Run(NetErrorCodeToQuotaStatus(rv));
+ current_delete_request_callback_.Reset();
+ if (pending_serial_requests_.empty())
+ return;
+
+ // Start the next in the queue.
+ RunFront(&pending_serial_requests_);
+}
+
+void AppCacheQuotaClient::GetOriginsHelper(
+ quota::StorageType type,
+ const std::string& opt_host,
+ const GetOriginsCallback& callback) {
+ DCHECK(!callback.is_null());
+ DCHECK(!quota_manager_is_destroyed_);
+
+ if (!service_) {
+ callback.Run(std::set<GURL>());
+ return;
+ }
+
+ if (!appcache_is_ready_) {
+ pending_batch_requests_.push_back(
+ base::Bind(&AppCacheQuotaClient::GetOriginsHelper,
+ base::Unretained(this), type, opt_host, callback));
+ return;
+ }
+
+ if (type != quota::kStorageTypeTemporary) {
+ callback.Run(std::set<GURL>());
+ return;
+ }
+
+ const AppCacheStorage::UsageMap* map = GetUsageMap();
+ std::set<GURL> origins;
+ for (AppCacheStorage::UsageMap::const_iterator iter = map->begin();
+ iter != map->end(); ++iter) {
+ if (opt_host.empty() || iter->first.host() == opt_host)
+ origins.insert(iter->first);
+ }
+ callback.Run(origins);
+}
+
+void AppCacheQuotaClient::ProcessPendingRequests() {
+ DCHECK(appcache_is_ready_);
+ while (!pending_batch_requests_.empty())
+ RunFront(&pending_batch_requests_);
+
+ if (!pending_serial_requests_.empty())
+ RunFront(&pending_serial_requests_);
+}
+
+void AppCacheQuotaClient::DeletePendingRequests() {
+ pending_batch_requests_.clear();
+ pending_serial_requests_.clear();
+}
+
+const AppCacheStorage::UsageMap* AppCacheQuotaClient::GetUsageMap() {
+ DCHECK(service_);
+ return service_->storage()->usage_map();
+}
+
+net::CancelableCompletionCallback*
+AppCacheQuotaClient::GetServiceDeleteCallback() {
+ // Lazily created due to CancelableCompletionCallback's threading
+ // restrictions, there is no way to detach from the thread created on.
+ if (!service_delete_callback_) {
+ service_delete_callback_.reset(
+ new net::CancelableCompletionCallback(
+ base::Bind(&AppCacheQuotaClient::DidDeleteAppCachesForOrigin,
+ base::Unretained(this))));
+ }
+ return service_delete_callback_.get();
+}
+
+void AppCacheQuotaClient::NotifyAppCacheReady() {
+ // Can reoccur during reinitialization.
+ if (!appcache_is_ready_) {
+ appcache_is_ready_ = true;
+ ProcessPendingRequests();
+ }
+}
+
+void AppCacheQuotaClient::NotifyAppCacheDestroyed() {
+ service_ = NULL;
+ while (!pending_batch_requests_.empty())
+ RunFront(&pending_batch_requests_);
+
+ while (!pending_serial_requests_.empty())
+ RunFront(&pending_serial_requests_);
+
+ if (!current_delete_request_callback_.is_null()) {
+ current_delete_request_callback_.Run(quota::kQuotaErrorAbort);
+ current_delete_request_callback_.Reset();
+ GetServiceDeleteCallback()->Cancel();
+ }
+
+ if (quota_manager_is_destroyed_)
+ delete this;
+}
+
+} // namespace content
--
cgit v1.1