Reland of [ServiceWorkerCache] Implement storage::QuotaClient

content/browser/service_worker/service_worker_cache_quota_client.cc

 // Copyright 2014 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/service_worker/service_worker_cache_quota_client.h"
+
+#include "content/browser/service_worker/service_worker_cache_storage_manager.h"
 #include "content/public/browser/browser_thread.h"
-#include "extensions/browser/guest_view/web_view/web_view_renderer_state.h"
 
-using content::BrowserThread;
+namespace content {
 
-namespace extensions {
-
-// static
-WebViewRendererState* WebViewRendererState::GetInstance() {
-  return Singleton<WebViewRendererState>::get();
+ServiceWorkerCacheQuotaClient::ServiceWorkerCacheQuotaClient(
+    base::WeakPtr<ServiceWorkerCacheStorageManager> cache_manager)
+    : cache_manager_(cache_manager) {
 }
 
-WebViewRendererState::WebViewRendererState() {
+ServiceWorkerCacheQuotaClient::~ServiceWorkerCacheQuotaClient() {
 }
 
-WebViewRendererState::~WebViewRendererState() {
+storage::QuotaClient::ID ServiceWorkerCacheQuotaClient::id() const {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  return kServiceWorkerCache;
 }
 
-bool WebViewRendererState::IsGuest(int render_process_id) {
+void ServiceWorkerCacheQuotaClient::OnQuotaManagerDestroyed() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  return webview_partition_id_map_.find(render_process_id) !=
-         webview_partition_id_map_.end();
+  delete this;
 }
 
-void WebViewRendererState::AddGuest(int guest_process_id,
-                                    int guest_routing_id,
-                                    const WebViewInfo& webview_info) {
+void ServiceWorkerCacheQuotaClient::GetOriginUsage(
+    const GURL& origin_url,
+    storage::StorageType type,
+    const GetUsageCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  RenderId render_id(guest_process_id, guest_routing_id);
-  webview_info_map_[render_id] = webview_info;
-  WebViewPartitionIDMap::iterator iter =
-      webview_partition_id_map_.find(guest_process_id);
-  if (iter != webview_partition_id_map_.end()) {
-    ++iter->second.web_view_count;
+
+  if (!cache_manager_ || !DoesSupport(type)) {
+    callback.Run(0);
     return;
   }
-  WebViewPartitionInfo partition_info(1, webview_info.partition_id);
-  webview_partition_id_map_[guest_process_id] = partition_info;
+
+  cache_manager_->GetOriginUsage(origin_url, callback);
 }
 
-void WebViewRendererState::RemoveGuest(int guest_process_id,
-                                       int guest_routing_id) {
+void ServiceWorkerCacheQuotaClient::GetOriginsForType(
+    storage::StorageType type,
+    const GetOriginsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  RenderId render_id(guest_process_id, guest_routing_id);
-  webview_info_map_.erase(render_id);
-  WebViewPartitionIDMap::iterator iter =
-      webview_partition_id_map_.find(guest_process_id);
-  if (iter != webview_partition_id_map_.end() &&
-      iter->second.web_view_count > 1) {
-    --iter->second.web_view_count;
+
+  if (!cache_manager_ || !DoesSupport(type)) {
+    callback.Run(std::set<GURL>());
     return;
   }
-  webview_partition_id_map_.erase(guest_process_id);
+
+  cache_manager_->GetOrigins(callback);
 }
 
-bool WebViewRendererState::GetInfo(int guest_process_id,
-                                   int guest_routing_id,
-                                   WebViewInfo* webview_info) {
+void ServiceWorkerCacheQuotaClient::GetOriginsForHost(
+    storage::StorageType type,
+    const std::string& host,
+    const GetOriginsCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  RenderId render_id(guest_process_id, guest_routing_id);
-  WebViewInfoMap::iterator iter = webview_info_map_.find(render_id);
-  if (iter != webview_info_map_.end()) {
-    *webview_info = iter->second;
-    return true;
+
+  if (!cache_manager_ || !DoesSupport(type)) {
+    callback.Run(std::set<GURL>());
+    return;
   }
-  return false;
+
+  cache_manager_->GetOriginsForHost(host, callback);
 }
 
-bool WebViewRendererState::GetPartitionID(int guest_process_id,
-                                          std::string* partition_id) {
+void ServiceWorkerCacheQuotaClient::DeleteOriginData(
+    const GURL& origin,
+    storage::StorageType type,
+    const DeletionCallback& callback) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
-  WebViewPartitionIDMap::iterator iter =
-      webview_partition_id_map_.find(guest_process_id);
-  if (iter != webview_partition_id_map_.end()) {
-    *partition_id = iter->second.partition_id;
-    return true;
+
+  if (!cache_manager_) {
+    callback.Run(storage::kQuotaErrorAbort);
+    return;
   }
-  return false;
+
+  if (!DoesSupport(type)) {
+    callback.Run(storage::kQuotaStatusOk);
+    return;
+  }
+
+  cache_manager_->DeleteOriginData(origin, callback);
 }
 
-}  // namespace extensions
+bool ServiceWorkerCacheQuotaClient::DoesSupport(
+    storage::StorageType type) const {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  return type == storage::kStorageTypeTemporary;
+}
+
+}  // namespace content