Add SharedWorkerServiceImpl::CheckWorkerDependency().

content/browser/shared_worker/shared_worker_service_impl.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/shared_worker/shared_worker_service_impl.h"
 
+#include <algorithm>
+#include <iterator>
+#include <set>
+#include <vector>
+
+#include "content/browser/renderer_host/render_process_host_impl.h"
 #include "content/browser/shared_worker/shared_worker_host.h"
 #include "content/browser/shared_worker/shared_worker_instance.h"
 #include "content/browser/shared_worker/shared_worker_message_filter.h"
 #include "content/browser/worker_host/worker_document_set.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/worker_service_observer.h"
 
 namespace content {
+namespace {
+
+class ScopedWorkerDependencyChecker {
+ public:
+  explicit ScopedWorkerDependencyChecker(SharedWorkerServiceImpl* service)
+      : service_(service) {}
+  ~ScopedWorkerDependencyChecker() { service_->CheckWorkerDependency(); }
+
+ private:
+  SharedWorkerServiceImpl* service_;
+  DISALLOW_COPY_AND_ASSIGN(ScopedWorkerDependencyChecker);
+};
+
+void UpdateWorkerDependencyOnUI(const std::vector<int>& added_ids,
+                                const std::vector<int>& removed_ids) {
+  for (size_t i = 0; i < added_ids.size(); ++i) {
+    RenderProcessHostImpl* render_process_host_impl =
+        static_cast<RenderProcessHostImpl*>(
+            RenderProcessHost::FromID(added_ids[i]));
+    if (!render_process_host_impl)
+      continue;
+    render_process_host_impl->IncrementWorkerRefCount();
+  }
+  for (size_t i = 0; i < removed_ids.size(); ++i) {
+    RenderProcessHostImpl* render_process_host_impl =
+        static_cast<RenderProcessHostImpl*>(
+            RenderProcessHost::FromID(removed_ids[i]));
+    if (!render_process_host_impl)
+      continue;
+    render_process_host_impl->DecrementWorkerRefCount();
+  }
+}
+
+void UpdateWorkerDependency(const std::vector<int>& added_ids,
+                            const std::vector<int>& removed_ids) {
+  BrowserThread::PostTask(
+      BrowserThread::UI,
+      FROM_HERE,
+      base::Bind(&UpdateWorkerDependencyOnUI, added_ids, removed_ids));
+}
+
+}  // namespace
 
 SharedWorkerServiceImpl* SharedWorkerServiceImpl::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return Singleton<SharedWorkerServiceImpl>::get();
 }
 
-SharedWorkerServiceImpl::SharedWorkerServiceImpl() {
-}
+SharedWorkerServiceImpl::SharedWorkerServiceImpl()
+    : update_worker_dependency_(UpdateWorkerDependency) {}
 
-SharedWorkerServiceImpl::~SharedWorkerServiceImpl() {
+SharedWorkerServiceImpl::~SharedWorkerServiceImpl() {}
+
+void SharedWorkerServiceImpl::ResetForTesting() {
+  last_worker_depended_renderers_.clear();
+  worker_hosts_.clear();
+  observers_.Clear();
+  update_worker_dependency_ = UpdateWorkerDependency;
 }
 
 bool SharedWorkerServiceImpl::TerminateWorker(int process_id, int route_id) {
   SharedWorkerHost* host =
       worker_hosts_.get(std::make_pair(process_id, route_id));
   if (!host || !host->instance())
     return false;
   host->TerminateWorker();
   return true;
 }
@@ skipping 29 matching lines @@
 }
 
 void SharedWorkerServiceImpl::CreateWorker(
     const ViewHostMsg_CreateWorker_Params& params,
     int route_id,
     SharedWorkerMessageFilter* filter,
     ResourceContext* resource_context,
     const WorkerStoragePartition& partition,
     bool* url_mismatch) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  ScopedWorkerDependencyChecker checker(this);
   *url_mismatch = false;
   SharedWorkerInstance* existing_instance =
       FindSharedWorkerInstance(
           params.url, params.name, partition, resource_context);
   if (existing_instance) {
     if (params.url != existing_instance->url()) {
       *url_mismatch = true;
       return;
     }
     if (existing_instance->load_failed()) {
@@ skipping 42 matching lines @@
        iter != worker_hosts_.end();
        ++iter) {
     if (iter->second->FilterMessage(message, filter))
       return;
   }
 }
 
 void SharedWorkerServiceImpl::DocumentDetached(
     unsigned long long document_id,
     SharedWorkerMessageFilter* filter) {
+  ScopedWorkerDependencyChecker checker(this);
   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
        iter != worker_hosts_.end();
        ++iter) {
     iter->second->DocumentDetached(filter, document_id);
   }
 }
 
 void SharedWorkerServiceImpl::WorkerContextClosed(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
+  ScopedWorkerDependencyChecker checker(this);
   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
     host->WorkerContextClosed();
 }
 
 void SharedWorkerServiceImpl::WorkerContextDestroyed(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
+  ScopedWorkerDependencyChecker checker(this);
   scoped_ptr<SharedWorkerHost> host =
       worker_hosts_.take_and_erase(std::make_pair(filter->render_process_id(),
                                                   worker_route_id));
   if (!host)
     return;
   host->WorkerContextDestroyed();
 }
 
 void SharedWorkerServiceImpl::WorkerScriptLoaded(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
     host->WorkerScriptLoaded();
 }
 
 void SharedWorkerServiceImpl::WorkerScriptLoadFailed(
     int worker_route_id,
     SharedWorkerMessageFilter* filter) {
+  ScopedWorkerDependencyChecker checker(this);
   scoped_ptr<SharedWorkerHost> host =
       worker_hosts_.take_and_erase(std::make_pair(filter->render_process_id(),
                                                   worker_route_id));
   if (!host)
     return;
   host->WorkerScriptLoadFailed();
 }
 
 void SharedWorkerServiceImpl::WorkerConnected(
     int message_port_id,
@@ skipping 29 matching lines @@
     const GURL& url,
     const base::string16& name,
     bool* result,
     SharedWorkerMessageFilter* filter) {
   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
     host->AllowIndexedDB(url, name, result);
 }
 
 void SharedWorkerServiceImpl::OnSharedWorkerMessageFilterClosing(
     SharedWorkerMessageFilter* filter) {
+  ScopedWorkerDependencyChecker checker(this);
   std::vector<ProcessRouteIdPair> remove_list;
   for (WorkerHostMap::iterator iter = worker_hosts_.begin();
        iter != worker_hosts_.end();
        ++iter) {
     iter->second->FilterShutdown(filter);
     if (iter->first.first == filter->render_process_id())
       remove_list.push_back(iter->first);
   }
   for (size_t i = 0; i < remove_list.size(); ++i)
     worker_hosts_.erase(remove_list[i]);
@@ skipping 14 matching lines @@
   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
        iter != worker_hosts_.end();
        ++iter) {
     SharedWorkerInstance* instance = iter->second->instance();
     if (instance && instance->Matches(url, name, partition, resource_context))
       return instance;
   }
   return NULL;
 }
 
+const std::set<int>
+SharedWorkerServiceImpl::GetRenderersWithWorkerDependency() {
+  std::set<int> dependent_renderers;
+  for (WorkerHostMap::iterator host_iter = worker_hosts_.begin();
+       host_iter != worker_hosts_.end();
+       ++host_iter) {
+    const int process_id = host_iter->first.first;
+    if (dependent_renderers.count(process_id))
+      continue;
+    SharedWorkerInstance* instance = host_iter->second->instance();
+    if (instance &&
+        instance->worker_document_set()->ContainsExternalRenderer(process_id)) {
+      dependent_renderers.insert(process_id);
+    }
+  }
+  return dependent_renderers;
+}
+
+void SharedWorkerServiceImpl::CheckWorkerDependency() {
+  const std::set<int> current_worker_depended_renderers =
+      GetRenderersWithWorkerDependency();
+  std::vector<int> added_items;
+  std::vector<int> removed_items;
+  std::set_difference(current_worker_depended_renderers.begin(),
+                      current_worker_depended_renderers.end(),
+                      last_worker_depended_renderers_.begin(),
+                      last_worker_depended_renderers_.end(),
+                      std::back_inserter(added_items));
+  std::set_difference(last_worker_depended_renderers_.begin(),
+                      last_worker_depended_renderers_.end(),
+                      current_worker_depended_renderers.begin(),
+                      current_worker_depended_renderers.end(),
+                      std::back_inserter(removed_items));
+  if (!added_items.empty() || !removed_items.empty()) {
+    last_worker_depended_renderers_ = current_worker_depended_renderers;
+    update_worker_dependency_(added_items, removed_items);
+  }
+}
+
+void SharedWorkerServiceImpl::ChangeUpdateWorkerDependencyFuncForTesting(
+    UpdateWorkerDependencyFunc new_func) {
+  update_worker_dependency_ = new_func;
+}
+
 }  // namespace content