| // 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 "base/callback.h" |
| #include "base/memory/ref_counted.h" |
| #include "content/browser/devtools/embedded_worker_devtools_manager.h" |
| #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/shared_worker/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 { |
| |
| WorkerService* WorkerService::GetInstance() { |
| return SharedWorkerServiceImpl::GetInstance(); |
| } |
| |
| namespace { |
| |
| class ScopedWorkerDependencyChecker { |
| public: |
| explicit ScopedWorkerDependencyChecker(SharedWorkerServiceImpl* service) |
| : service_(service) {} |
| ScopedWorkerDependencyChecker(SharedWorkerServiceImpl* service, |
| base::Closure done_closure) |
| : service_(service), done_closure_(done_closure) {} |
| ~ScopedWorkerDependencyChecker() { |
| service_->CheckWorkerDependency(); |
| if (!done_closure_.is_null()) |
| done_closure_.Run(); |
| } |
| |
| private: |
| SharedWorkerServiceImpl* service_; |
| base::Closure done_closure_; |
| 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)); |
| } |
| |
| void DecrementWorkerRefCount(int process_id) { |
| if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) { |
| BrowserThread::PostTask(BrowserThread::UI, |
| FROM_HERE, |
| base::Bind(&DecrementWorkerRefCount, process_id)); |
| return; |
| } |
| RenderProcessHostImpl* render_process_host_impl = |
| static_cast<RenderProcessHostImpl*>( |
| RenderProcessHost::FromID(process_id)); |
| if (render_process_host_impl) |
| render_process_host_impl->DecrementWorkerRefCount(); |
| } |
| |
| bool TryIncrementWorkerRefCount(int worker_process_id) { |
| RenderProcessHostImpl* render_process = static_cast<RenderProcessHostImpl*>( |
| RenderProcessHost::FromID(worker_process_id)); |
| if (!render_process || render_process->FastShutdownStarted()) { |
| return false; |
| } |
| render_process->IncrementWorkerRefCount(); |
| return true; |
| } |
| |
| } // namespace |
| |
| class SharedWorkerServiceImpl::SharedWorkerPendingInstance { |
| public: |
| struct SharedWorkerPendingRequest { |
| SharedWorkerPendingRequest(SharedWorkerMessageFilter* filter, |
| int route_id, |
| unsigned long long document_id, |
| int render_process_id, |
| int render_frame_route_id) |
| : filter(filter), |
| route_id(route_id), |
| document_id(document_id), |
| render_process_id(render_process_id), |
| render_frame_route_id(render_frame_route_id) {} |
| SharedWorkerMessageFilter* const filter; |
| const int route_id; |
| const unsigned long long document_id; |
| const int render_process_id; |
| const int render_frame_route_id; |
| }; |
| |
| typedef ScopedVector<SharedWorkerPendingRequest> SharedWorkerPendingRequests; |
| |
| explicit SharedWorkerPendingInstance( |
| scoped_ptr<SharedWorkerInstance> instance) |
| : instance_(instance.Pass()) {} |
| ~SharedWorkerPendingInstance() {} |
| SharedWorkerInstance* instance() { return instance_.get(); } |
| SharedWorkerInstance* release_instance() { return instance_.release(); } |
| SharedWorkerPendingRequests* requests() { return &requests_; } |
| SharedWorkerMessageFilter* FindFilter(int process_id) { |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| if (requests_[i]->render_process_id == process_id) |
| return requests_[i]->filter; |
| } |
| return NULL; |
| } |
| void AddRequest(scoped_ptr<SharedWorkerPendingRequest> request_info) { |
| requests_.push_back(request_info.release()); |
| } |
| void RemoveRequest(int process_id) { |
| for (SharedWorkerPendingRequests::iterator request_itr = requests_.begin(); |
| request_itr != requests_.end();) { |
| if ((*request_itr)->render_process_id == process_id) |
| request_itr = requests_.erase(request_itr); |
| else |
| ++request_itr; |
| } |
| } |
| void RegisterToSharedWorkerHost(SharedWorkerHost* host) { |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| SharedWorkerPendingRequest* request = requests_[i]; |
| host->AddFilter(request->filter, request->route_id); |
| host->worker_document_set()->Add(request->filter, |
| request->document_id, |
| request->render_process_id, |
| request->render_frame_route_id); |
| } |
| } |
| void SendWorkerCreatedMessages() { |
| for (size_t i = 0; i < requests_.size(); ++i) { |
| SharedWorkerPendingRequest* request = requests_[i]; |
| request->filter->Send(new ViewMsg_WorkerCreated(request->route_id)); |
| } |
| } |
| |
| private: |
| scoped_ptr<SharedWorkerInstance> instance_; |
| SharedWorkerPendingRequests requests_; |
| DISALLOW_COPY_AND_ASSIGN(SharedWorkerPendingInstance); |
| }; |
| |
| class SharedWorkerServiceImpl::SharedWorkerReserver |
| : public base::RefCountedThreadSafe<SharedWorkerReserver> { |
| public: |
| SharedWorkerReserver(int pending_instance_id, |
| int worker_process_id, |
| int worker_route_id, |
| bool is_new_worker, |
| const SharedWorkerInstance& instance) |
| : worker_process_id_(worker_process_id), |
| worker_route_id_(worker_route_id), |
| is_new_worker_(is_new_worker), |
| instance_(instance) {} |
| |
| void TryReserve(const base::Callback<void(bool)>& success_cb, |
| const base::Closure& failure_cb, |
| bool (*try_increment_worker_ref_count)(int)) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI)); |
| if (!try_increment_worker_ref_count(worker_process_id_)) { |
| BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, failure_cb); |
| return; |
| } |
| bool pause_on_start = false; |
| if (is_new_worker_) { |
| pause_on_start = |
| EmbeddedWorkerDevToolsManager::GetInstance()->SharedWorkerCreated( |
| worker_process_id_, worker_route_id_, instance_); |
| } |
| BrowserThread::PostTask( |
| BrowserThread::IO, FROM_HERE, base::Bind(success_cb, pause_on_start)); |
| } |
| |
| private: |
| friend class base::RefCountedThreadSafe<SharedWorkerReserver>; |
| ~SharedWorkerReserver() {} |
| |
| const int worker_process_id_; |
| const int worker_route_id_; |
| const bool is_new_worker_; |
| const SharedWorkerInstance instance_; |
| }; |
| |
| // static |
| bool (*SharedWorkerServiceImpl::s_try_increment_worker_ref_count_)(int) = |
| TryIncrementWorkerRefCount; |
| |
| SharedWorkerServiceImpl* SharedWorkerServiceImpl::GetInstance() { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| return Singleton<SharedWorkerServiceImpl>::get(); |
| } |
| |
| SharedWorkerServiceImpl::SharedWorkerServiceImpl() |
| : update_worker_dependency_(UpdateWorkerDependency), |
| next_pending_instance_id_(0) { |
| } |
| |
| SharedWorkerServiceImpl::~SharedWorkerServiceImpl() {} |
| |
| void SharedWorkerServiceImpl::ResetForTesting() { |
| last_worker_depended_renderers_.clear(); |
| worker_hosts_.clear(); |
| observers_.Clear(); |
| update_worker_dependency_ = UpdateWorkerDependency; |
| s_try_increment_worker_ref_count_ = TryIncrementWorkerRefCount; |
| } |
| |
| 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; |
| } |
| |
| std::vector<WorkerService::WorkerInfo> SharedWorkerServiceImpl::GetWorkers() { |
| std::vector<WorkerService::WorkerInfo> results; |
| for (WorkerHostMap::const_iterator iter = worker_hosts_.begin(); |
| iter != worker_hosts_.end(); |
| ++iter) { |
| SharedWorkerHost* host = iter->second; |
| const SharedWorkerInstance* instance = host->instance(); |
| if (instance) { |
| WorkerService::WorkerInfo info; |
| info.url = instance->url(); |
| info.name = instance->name(); |
| info.route_id = host->worker_route_id(); |
| info.process_id = host->process_id(); |
| info.handle = host->container_render_filter()->PeerHandle(); |
| results.push_back(info); |
| } |
| } |
| return results; |
| } |
| |
| void SharedWorkerServiceImpl::AddObserver(WorkerServiceObserver* observer) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| observers_.AddObserver(observer); |
| } |
| |
| void SharedWorkerServiceImpl::RemoveObserver(WorkerServiceObserver* observer) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| observers_.RemoveObserver(observer); |
| } |
| |
| void SharedWorkerServiceImpl::CreateWorker( |
| const ViewHostMsg_CreateWorker_Params& params, |
| int route_id, |
| SharedWorkerMessageFilter* filter, |
| ResourceContext* resource_context, |
| const WorkerStoragePartitionId& partition_id, |
| bool* url_mismatch) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| *url_mismatch = false; |
| scoped_ptr<SharedWorkerInstance> instance( |
| new SharedWorkerInstance(params.url, |
| params.name, |
| params.content_security_policy, |
| params.security_policy_type, |
| resource_context, |
| partition_id)); |
| scoped_ptr<SharedWorkerPendingInstance::SharedWorkerPendingRequest> request( |
| new SharedWorkerPendingInstance::SharedWorkerPendingRequest( |
| filter, |
| route_id, |
| params.document_id, |
| filter->render_process_id(), |
| params.render_frame_route_id)); |
| if (SharedWorkerPendingInstance* pending = FindPendingInstance(*instance)) { |
| if (params.url != pending->instance()->url()) { |
| *url_mismatch = true; |
| return; |
| } |
| pending->AddRequest(request.Pass()); |
| return; |
| } |
| scoped_ptr<SharedWorkerPendingInstance> pending_instance( |
| new SharedWorkerPendingInstance(instance.Pass())); |
| pending_instance->AddRequest(request.Pass()); |
| ReserveRenderProcessToCreateWorker(pending_instance.Pass(), url_mismatch); |
| } |
| |
| void SharedWorkerServiceImpl::ForwardToWorker( |
| const IPC::Message& message, |
| SharedWorkerMessageFilter* filter) { |
| for (WorkerHostMap::const_iterator iter = worker_hosts_.begin(); |
| 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, |
| int worker_route_id, |
| SharedWorkerMessageFilter* filter) { |
| if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id)) |
| host->WorkerConnected(message_port_id); |
| } |
| |
| void SharedWorkerServiceImpl::AllowDatabase( |
| int worker_route_id, |
| const GURL& url, |
| const base::string16& name, |
| const base::string16& display_name, |
| unsigned long estimated_size, |
| bool* result, |
| SharedWorkerMessageFilter* filter) { |
| if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id)) |
| host->AllowDatabase(url, name, display_name, estimated_size, result); |
| } |
| |
| void SharedWorkerServiceImpl::AllowFileSystem( |
| int worker_route_id, |
| const GURL& url, |
| IPC::Message* reply_msg, |
| SharedWorkerMessageFilter* filter) { |
| if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id)) { |
| host->AllowFileSystem(url, make_scoped_ptr(reply_msg)); |
| } else { |
| filter->Send(reply_msg); |
| return; |
| } |
| } |
| |
| void SharedWorkerServiceImpl::AllowIndexedDB( |
| int worker_route_id, |
| 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) { |
| scoped_ptr<SharedWorkerHost> host = |
| worker_hosts_.take_and_erase(remove_list[i]); |
| } |
| |
| std::vector<int> remove_pending_instance_list; |
| for (PendingInstaneMap::iterator iter = pending_instances_.begin(); |
| iter != pending_instances_.end(); |
| ++iter) { |
| iter->second->RemoveRequest(filter->render_process_id()); |
| if (!iter->second->requests()->size()) |
| remove_pending_instance_list.push_back(iter->first); |
| } |
| for (size_t i = 0; i < remove_pending_instance_list.size(); ++i) |
| pending_instances_.take_and_erase(remove_pending_instance_list[i]); |
| } |
| |
| void SharedWorkerServiceImpl::NotifyWorkerDestroyed(int worker_process_id, |
| int worker_route_id) { |
| FOR_EACH_OBSERVER(WorkerServiceObserver, |
| observers_, |
| WorkerDestroyed(worker_process_id, worker_route_id)); |
| } |
| |
| void SharedWorkerServiceImpl::ReserveRenderProcessToCreateWorker( |
| scoped_ptr<SharedWorkerPendingInstance> pending_instance, |
| bool* url_mismatch) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| DCHECK(!FindPendingInstance(*pending_instance->instance())); |
| if (url_mismatch) |
| *url_mismatch = false; |
| if (!pending_instance->requests()->size()) |
| return; |
| int worker_process_id = -1; |
| int worker_route_id = MSG_ROUTING_NONE; |
| bool is_new_worker = true; |
| SharedWorkerHost* host = FindSharedWorkerHost(*pending_instance->instance()); |
| if (host) { |
| if (pending_instance->instance()->url() != host->instance()->url()) { |
| if (url_mismatch) |
| *url_mismatch = true; |
| return; |
| } |
| worker_process_id = host->process_id(); |
| worker_route_id = host->worker_route_id(); |
| is_new_worker = false; |
| } else { |
| SharedWorkerMessageFilter* first_filter = |
| (*pending_instance->requests()->begin())->filter; |
| worker_process_id = first_filter->render_process_id(); |
| worker_route_id = first_filter->GetNextRoutingID(); |
| } |
| const int pending_instance_id = next_pending_instance_id_++; |
| scoped_refptr<SharedWorkerReserver> reserver( |
| new SharedWorkerReserver(pending_instance_id, |
| worker_process_id, |
| worker_route_id, |
| is_new_worker, |
| *pending_instance->instance())); |
| BrowserThread::PostTask( |
| BrowserThread::UI, |
| FROM_HERE, |
| base::Bind( |
| &SharedWorkerReserver::TryReserve, |
| reserver, |
| base::Bind(&SharedWorkerServiceImpl::RenderProcessReservedCallback, |
| base::Unretained(this), |
| pending_instance_id, |
| worker_process_id, |
| worker_route_id, |
| is_new_worker), |
| base::Bind( |
| &SharedWorkerServiceImpl::RenderProcessReserveFailedCallback, |
| base::Unretained(this), |
| pending_instance_id, |
| worker_process_id, |
| worker_route_id, |
| is_new_worker), |
| s_try_increment_worker_ref_count_)); |
| pending_instances_.set(pending_instance_id, pending_instance.Pass()); |
| } |
| |
| void SharedWorkerServiceImpl::RenderProcessReservedCallback( |
| int pending_instance_id, |
| int worker_process_id, |
| int worker_route_id, |
| bool is_new_worker, |
| bool pause_on_start) { |
| DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO)); |
| // To offset the TryIncrementWorkerRefCount called for the reservation, |
| // calls DecrementWorkerRefCount after CheckWorkerDependency in |
| // ScopeWorkerDependencyChecker's destructor. |
| ScopedWorkerDependencyChecker checker( |
| this, base::Bind(&DecrementWorkerRefCount, worker_process_id)); |
| scoped_ptr<SharedWorkerPendingInstance> pending_instance = |
| pending_instances_.take_and_erase(pending_instance_id); |
| if (!pending_instance) |
| return; |
| if (!is_new_worker) { |
| SharedWorkerHost* existing_host = |
| worker_hosts_.get(std::make_pair(worker_process_id, worker_route_id)); |
| if (!existing_host) { |
| // Retry reserving a renderer process if the existed Shared Worker was |
| // destroyed on IO thread while reserving the renderer process on UI |
| // thread. |
| ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL); |
| return; |
| } |
| pending_instance->RegisterToSharedWorkerHost(existing_host); |
| pending_instance->SendWorkerCreatedMessages(); |
| return; |
| } |
| SharedWorkerMessageFilter* filter = |
| pending_instance->FindFilter(worker_process_id); |
| if (!filter) { |
| pending_instance->RemoveRequest(worker_process_id); |
| // Retry reserving a renderer process if the requested renderer process was |
| // destroyed on IO thread while reserving the renderer process on UI thread. |
| ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL); |
| return; |
| } |
| scoped_ptr<SharedWorkerHost> host(new SharedWorkerHost( |
| pending_instance->release_instance(), filter, worker_route_id)); |
| pending_instance->RegisterToSharedWorkerHost(host.get()); |
| const GURL url = host->instance()->url(); |
| const base::string16 name = host->instance()->name(); |
| host->Start(pause_on_start); |
| worker_hosts_.set(std::make_pair(worker_process_id, worker_route_id), |
| host.Pass()); |
| FOR_EACH_OBSERVER( |
| WorkerServiceObserver, |
| observers_, |
| WorkerCreated(url, name, worker_process_id, worker_route_id)); |
| } |
| |
| void SharedWorkerServiceImpl::RenderProcessReserveFailedCallback( |
| int pending_instance_id, |
| int worker_process_id, |
| int worker_route_id, |
| bool is_new_worker) { |
| worker_hosts_.take_and_erase( |
| std::make_pair(worker_process_id, worker_route_id)); |
| scoped_ptr<SharedWorkerPendingInstance> pending_instance = |
| pending_instances_.take_and_erase(pending_instance_id); |
| if (!pending_instance) |
| return; |
| pending_instance->RemoveRequest(worker_process_id); |
| // Retry reserving a renderer process. |
| ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL); |
| } |
| |
| SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost( |
| SharedWorkerMessageFilter* filter, |
| int worker_route_id) { |
| return worker_hosts_.get(std::make_pair(filter->render_process_id(), |
| worker_route_id)); |
| } |
| |
| SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost( |
| const SharedWorkerInstance& instance) { |
| for (WorkerHostMap::const_iterator iter = worker_hosts_.begin(); |
| iter != worker_hosts_.end(); |
| ++iter) { |
| SharedWorkerHost* host = iter->second; |
| if (host->instance() && !host->closed() && |
| host->instance()->Matches(instance)) { |
| return iter->second; |
| } |
| } |
| return NULL; |
| } |
| |
| SharedWorkerServiceImpl::SharedWorkerPendingInstance* |
| SharedWorkerServiceImpl::FindPendingInstance( |
| const SharedWorkerInstance& instance) { |
| for (PendingInstaneMap::iterator iter = pending_instances_.begin(); |
| iter != pending_instances_.end(); |
| ++iter) { |
| if (iter->second->instance()->Matches(instance)) |
| return iter->second; |
| } |
| 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; |
| if (host_iter->second->instance() && |
| host_iter->second->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 = base::STLSetDifference<std::vector<int> >( |
| current_worker_depended_renderers, last_worker_depended_renderers_); |
| std::vector<int> removed_items = base::STLSetDifference<std::vector<int> >( |
| last_worker_depended_renderers_, current_worker_depended_renderers); |
| 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; |
| } |
| |
| void SharedWorkerServiceImpl::ChangeTryIncrementWorkerRefCountFuncForTesting( |
| bool (*new_func)(int)) { |
| s_try_increment_worker_ref_count_ = new_func; |
| } |
| |
| } // namespace content |
