Upstream version 9.38.198.0

[platform/framework/web/crosswalk.git] / src / content / browser / service_worker / service_worker_context_wrapper.cc

diff --git a/src/content/browser/service_worker/service_worker_context_wrapper.cc b/src/content/browser/service_worker/service_worker_context_wrapper.cc
index 460f6df..d3f776d 100644 (file)
--- a/src/content/browser/service_worker/service_worker_context_wrapper.cc
+++ b/src/content/browser/service_worker/service_worker_context_wrapper.cc
@@ -4,12 +4,19 @@
 
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 
+#include <map>
+
 #include "base/files/file_path.h"
+#include "base/logging.h"
 #include "base/threading/sequenced_worker_pool.h"
+#include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_observer.h"
 #include "content/browser/service_worker/service_worker_process_manager.h"
+#include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_thread.h"
+#include "net/url_request/url_request_context_getter.h"
+#include "webkit/browser/blob/blob_storage_context.h"
 #include "webkit/browser/quota/quota_manager_proxy.h"
 
 namespace content {
@@ -18,7 +25,8 @@ ServiceWorkerContextWrapper::ServiceWorkerContextWrapper(
     BrowserContext* browser_context)
     : observer_list_(
           new ObserverListThreadSafe<ServiceWorkerContextObserver>()),
-      process_manager_(new ServiceWorkerProcessManager(browser_context)) {
+      process_manager_(new ServiceWorkerProcessManager(browser_context)),
+      is_incognito_(false) {
 }
 
 ServiceWorkerContextWrapper::~ServiceWorkerContextWrapper() {
@@ -27,6 +35,7 @@ ServiceWorkerContextWrapper::~ServiceWorkerContextWrapper() {
 void ServiceWorkerContextWrapper::Init(
     const base::FilePath& user_data_directory,
     quota::QuotaManagerProxy* quota_manager_proxy) {
+  is_incognito_ = user_data_directory.empty();
   scoped_refptr<base::SequencedTaskRunner> database_task_runner =
       BrowserThread::GetBlockingPool()->
           GetSequencedTaskRunnerWithShutdownBehavior(
@@ -34,8 +43,16 @@ void ServiceWorkerContextWrapper::Init(
               base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
   scoped_refptr<base::MessageLoopProxy> disk_cache_thread =
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE);
-  InitInternal(user_data_directory, database_task_runner,
-               disk_cache_thread, quota_manager_proxy);
+  scoped_refptr<base::SequencedTaskRunner> cache_task_runner =
+      BrowserThread::GetBlockingPool()
+          ->GetSequencedTaskRunnerWithShutdownBehavior(
+              BrowserThread::GetBlockingPool()->GetSequenceToken(),
+              base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+  InitInternal(user_data_directory,
+               cache_task_runner,
+               database_task_runner,
+               disk_cache_thread,
+               quota_manager_proxy);
 }
 
 void ServiceWorkerContextWrapper::Shutdown() {
@@ -47,6 +64,12 @@ void ServiceWorkerContextWrapper::Shutdown() {
       base::Bind(&ServiceWorkerContextWrapper::ShutdownOnIO, this));
 }
 
+void ServiceWorkerContextWrapper::DeleteAndStartOver() {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  context_core_->DeleteAndStartOver(
+      base::Bind(&ServiceWorkerContextWrapper::DidDeleteAndStartOver, this));
+}
+
 ServiceWorkerContextCore* ServiceWorkerContextWrapper::context() {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   return context_core_.get();
@@ -122,6 +145,77 @@ void ServiceWorkerContextWrapper::Terminate() {
   process_manager_->Shutdown();
 }
 
+void ServiceWorkerContextWrapper::GetAllOriginsInfo(
+    const GetUsageInfoCallback& callback) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  context_core_->storage()->GetAllRegistrations(base::Bind(
+      &ServiceWorkerContextWrapper::DidGetAllRegistrationsForGetAllOrigins,
+      this,
+      callback));
+}
+
+void ServiceWorkerContextWrapper::DidGetAllRegistrationsForGetAllOrigins(
+    const GetUsageInfoCallback& callback,
+    const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  std::vector<ServiceWorkerUsageInfo> usage_infos;
+
+  std::map<GURL, ServiceWorkerUsageInfo> origins;
+  for (std::vector<ServiceWorkerRegistrationInfo>::const_iterator it =
+           registrations.begin();
+       it != registrations.end();
+       ++it) {
+    const ServiceWorkerRegistrationInfo& registration_info = *it;
+    GURL origin = registration_info.script_url.GetOrigin();
+
+    ServiceWorkerUsageInfo& usage_info = origins[origin];
+    if (usage_info.origin.is_empty())
+      usage_info.origin = origin;
+    usage_info.scopes.push_back(registration_info.pattern);
+  }
+
+  for (std::map<GURL, ServiceWorkerUsageInfo>::const_iterator it =
+           origins.begin();
+       it != origins.end();
+       ++it) {
+    usage_infos.push_back(it->second);
+  }
+
+  callback.Run(usage_infos);
+}
+
+namespace {
+
+void EmptySuccessCallback(bool success) {
+}
+
+}  // namespace
+
+void ServiceWorkerContextWrapper::DeleteForOrigin(const GURL& origin_url) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  context_core_->storage()->GetAllRegistrations(base::Bind(
+      &ServiceWorkerContextWrapper::DidGetAllRegistrationsForDeleteForOrigin,
+      this,
+      origin_url));
+}
+
+void ServiceWorkerContextWrapper::DidGetAllRegistrationsForDeleteForOrigin(
+    const GURL& origin,
+    const std::vector<ServiceWorkerRegistrationInfo>& registrations) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  for (std::vector<ServiceWorkerRegistrationInfo>::const_iterator it =
+           registrations.begin();
+       it != registrations.end();
+       ++it) {
+    const ServiceWorkerRegistrationInfo& registration_info = *it;
+    if (origin == registration_info.script_url.GetOrigin()) {
+      UnregisterServiceWorker(registration_info.pattern,
+                              base::Bind(&EmptySuccessCallback));
+    }
+  }
+}
+
 void ServiceWorkerContextWrapper::AddObserver(
     ServiceWorkerContextObserver* observer) {
   observer_list_->AddObserver(observer);
@@ -132,8 +226,21 @@ void ServiceWorkerContextWrapper::RemoveObserver(
   observer_list_->RemoveObserver(observer);
 }
 
+void ServiceWorkerContextWrapper::SetBlobParametersForCache(
+    net::URLRequestContextGetter* request_context,
+    ChromeBlobStorageContext* blob_storage_context) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+
+  if (context_core_ && request_context && blob_storage_context) {
+    context_core_->SetBlobParametersForCache(
+        request_context->GetURLRequestContext(),
+        blob_storage_context->context()->AsWeakPtr());
+  }
+}
+
 void ServiceWorkerContextWrapper::InitInternal(
     const base::FilePath& user_data_directory,
+    base::SequencedTaskRunner* stores_task_runner,
     base::SequencedTaskRunner* database_task_runner,
     base::MessageLoopProxy* disk_cache_thread,
     quota::QuotaManagerProxy* quota_manager_proxy) {
@@ -144,6 +251,7 @@ void ServiceWorkerContextWrapper::InitInternal(
         base::Bind(&ServiceWorkerContextWrapper::InitInternal,
                    this,
                    user_data_directory,
+                   make_scoped_refptr(stores_task_runner),
                    make_scoped_refptr(database_task_runner),
                    make_scoped_refptr(disk_cache_thread),
                    make_scoped_refptr(quota_manager_proxy)));
@@ -151,6 +259,7 @@ void ServiceWorkerContextWrapper::InitInternal(
   }
   DCHECK(!context_core_);
   context_core_.reset(new ServiceWorkerContextCore(user_data_directory,
+                                                   stores_task_runner,
                                                    database_task_runner,
                                                    disk_cache_thread,
                                                    quota_manager_proxy,
@@ -163,4 +272,15 @@ void ServiceWorkerContextWrapper::ShutdownOnIO() {
   context_core_.reset();
 }
 
+void ServiceWorkerContextWrapper::DidDeleteAndStartOver(
+    ServiceWorkerStatusCode status) {
+  DCHECK_CURRENTLY_ON(BrowserThread::IO);
+  if (status != SERVICE_WORKER_OK) {
+    context_core_.reset();
+    return;
+  }
+  context_core_.reset(new ServiceWorkerContextCore(context_core_.get(), this));
+  DVLOG(1) << "Restarted ServiceWorkerContextCore successfully.";
+}
+
 }  // namespace content