ServiceWorker: Support includeUncontrolled option in clients.matchAll() (1/2, chromium)

content/browser/service_worker/service_worker_context_core.cc

Index: content/browser/service_worker/service_worker_context_core.cc
diff --git a/content/browser/service_worker/service_worker_context_core.cc b/content/browser/service_worker/service_worker_context_core.cc
index 60991352a81c79f3d039f3139918820416aadf0a..d4d02cf62c5673cc89fc387d42287cc48767c512 100644
--- a/content/browser/service_worker/service_worker_context_core.cc
+++ b/content/browser/service_worker/service_worker_context_core.cc
@@ -28,6 +28,7 @@
 
 namespace content {
 namespace {
+
 void SuccessCollectorCallback(const base::Closure& done_closure,
                               bool* overall_success,
                               ServiceWorkerStatusCode status) {
@@ -45,6 +46,12 @@ void SuccessReportingCallback(
   callback.Run(result ? ServiceWorkerStatusCode::SERVICE_WORKER_OK
                       : ServiceWorkerStatusCode::SERVICE_WORKER_ERROR_FAILED);
 }
+
+bool IsSameOriginProviderHost(const GURL& origin,
+                              ServiceWorkerProviderHost* host) {
+  return host->document_url().GetOrigin() == origin;
+}
+
 }  // namespace
 
 const base::FilePath::CharType
@@ -66,7 +73,7 @@ void ServiceWorkerContextCore::ProviderHostIterator::Advance() {
 
   // Advance the inner iterator. If an element is reached, we're done.
   provider_host_iterator_->Advance();
-  if (!provider_host_iterator_->IsAtEnd())
+  if (ForwardUntilMatchingProviderHost())
     return;
 
   // Advance the outer iterator until an element is reached, or end is hit.
@@ -76,7 +83,7 @@ void ServiceWorkerContextCore::ProviderHostIterator::Advance() {
       return;
     ProviderMap* provider_map = process_iterator_->GetCurrentValue();
     provider_host_iterator_.reset(new ProviderMap::iterator(provider_map));
-    if (!provider_host_iterator_->IsAtEnd())
+    if (ForwardUntilMatchingProviderHost())
       return;
   }
 }
@@ -87,8 +94,9 @@ bool ServiceWorkerContextCore::ProviderHostIterator::IsAtEnd() {
 }
 
 ServiceWorkerContextCore::ProviderHostIterator::ProviderHostIterator(
-    ProcessToProviderMap* map)
-    : map_(map) {
+    ProcessToProviderMap* map,
+    const ProviderHostPredicate& predicate)
+    : map_(map), predicate_(predicate) {
   DCHECK(map);
   Initialize();
 }
@@ -99,12 +107,23 @@ void ServiceWorkerContextCore::ProviderHostIterator::Initialize() {
   while (!process_iterator_->IsAtEnd()) {
     ProviderMap* provider_map = process_iterator_->GetCurrentValue();
     provider_host_iterator_.reset(new ProviderMap::iterator(provider_map));
-    if (!provider_host_iterator_->IsAtEnd())
+    if (ForwardUntilMatchingProviderHost())
       return;
     process_iterator_->Advance();
   }
 }
 
+bool ServiceWorkerContextCore::ProviderHostIterator::
+    ForwardUntilMatchingProviderHost() {
+  while (!provider_host_iterator_->IsAtEnd()) {
+    if (predicate_.is_null() ||
+        predicate_.Run(provider_host_iterator_->GetCurrentValue()))

[nhiroki, 2015/03/16 06:37:58]

nit: Calling ProviderHostIterator::GetProviderHost() would be simpler.

[kinuko, 2015/03/20 08:19:39]

Done.

+      return true;
+    provider_host_iterator_->Advance();
+  }
+  return false;
+}
+
 ServiceWorkerContextCore::ServiceWorkerContextCore(
     const base::FilePath& path,
     const scoped_refptr<base::SequencedTaskRunner>& cache_task_runner,
@@ -201,22 +220,37 @@ void ServiceWorkerContextCore::RemoveAllProviderHostsForProcess(
 
 scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator>
 ServiceWorkerContextCore::GetProviderHostIterator() {
-  return make_scoped_ptr(new ProviderHostIterator(providers_.get()));
+  return make_scoped_ptr(new ProviderHostIterator(
+      providers_.get(), ProviderHostIterator::ProviderHostPredicate()));
 }
 
-void ServiceWorkerContextCore::RegisterClientIDForProviderHost(
+scoped_ptr<ServiceWorkerContextCore::ProviderHostIterator>
+ServiceWorkerContextCore::GetProviderHostIteratorForOrigin(const GURL& origin) {
+  return make_scoped_ptr(new ProviderHostIterator(
+      providers_.get(), base::Bind(IsSameOriginProviderHost, origin)));
+}
+
+void ServiceWorkerContextCore::RegisterProviderHostByClientID(
     const std::string& client_uuid,
     ServiceWorkerProviderHost* provider_host) {
   DCHECK(!ContainsKey(*provider_by_uuid_, client_uuid));
   (*provider_by_uuid_)[client_uuid] = provider_host;
 }
 
-void ServiceWorkerContextCore::UnregisterClientIDForProviderHost(
+void ServiceWorkerContextCore::UnregisterProviderHostByClientID(
     const std::string& client_uuid) {
   DCHECK(ContainsKey(*provider_by_uuid_, client_uuid));
   provider_by_uuid_->erase(client_uuid);
 }
 
+ServiceWorkerProviderHost* ServiceWorkerContextCore::GetProviderHostByClientID(
+    const std::string& client_uuid) {
+  auto found = provider_by_uuid_->find(client_uuid);
+  if (found == provider_by_uuid_->end())
+    return nullptr;
+  return found->second;
+}
+
 void ServiceWorkerContextCore::RegisterServiceWorker(
     const GURL& pattern,
     const GURL& script_url,