content/browser/shared_worker/shared_worker_service_impl.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/shared_worker/shared_worker_service_impl.h"
   6
   7 #include <algorithm>
   8 #include <iterator>
   9 #include <set>
  10 #include <vector>
  11
  12 #include "base/callback.h"
  13 #include "base/memory/ref_counted.h"
  14 #include "content/browser/devtools/embedded_worker_devtools_manager.h"
  15 #include "content/browser/renderer_host/render_process_host_impl.h"
  16 #include "content/browser/shared_worker/shared_worker_host.h"
  17 #include "content/browser/shared_worker/shared_worker_instance.h"
  18 #include "content/browser/shared_worker/shared_worker_message_filter.h"
  19 #include "content/browser/shared_worker/worker_document_set.h"
  20 #include "content/common/view_messages.h"
  21 #include "content/common/worker_messages.h"
  22 #include "content/public/browser/browser_thread.h"
  23 #include "content/public/browser/worker_service_observer.h"
  24
  25 namespace content {
  26
  27 WorkerService* WorkerService::GetInstance() {
  28   return SharedWorkerServiceImpl::GetInstance();
  29 }
  30
  31 namespace {
  32
  33 class ScopedWorkerDependencyChecker {
  34  public:
  35   explicit ScopedWorkerDependencyChecker(SharedWorkerServiceImpl* service)
  36       : service_(service) {}
  37   ScopedWorkerDependencyChecker(SharedWorkerServiceImpl* service,
  38                                 base::Closure done_closure)
  39       : service_(service), done_closure_(done_closure) {}
  40   ~ScopedWorkerDependencyChecker() {
  41     service_->CheckWorkerDependency();
  42     if (!done_closure_.is_null())
  43       done_closure_.Run();
  44   }
  45
  46  private:
  47   SharedWorkerServiceImpl* service_;
  48   base::Closure done_closure_;
  49   DISALLOW_COPY_AND_ASSIGN(ScopedWorkerDependencyChecker);
  50 };
  51
  52 void UpdateWorkerDependencyOnUI(const std::vector<int>& added_ids,
  53                                 const std::vector<int>& removed_ids) {
  54   for (size_t i = 0; i < added_ids.size(); ++i) {
  55     RenderProcessHostImpl* render_process_host_impl =
  56         static_cast<RenderProcessHostImpl*>(
  57             RenderProcessHost::FromID(added_ids[i]));
  58     if (!render_process_host_impl)
  59       continue;
  60     render_process_host_impl->IncrementWorkerRefCount();
  61   }
  62   for (size_t i = 0; i < removed_ids.size(); ++i) {
  63     RenderProcessHostImpl* render_process_host_impl =
  64         static_cast<RenderProcessHostImpl*>(
  65             RenderProcessHost::FromID(removed_ids[i]));
  66     if (!render_process_host_impl)
  67       continue;
  68     render_process_host_impl->DecrementWorkerRefCount();
  69   }
  70 }
  71
  72 void UpdateWorkerDependency(const std::vector<int>& added_ids,
  73                             const std::vector<int>& removed_ids) {
  74   BrowserThread::PostTask(
  75       BrowserThread::UI,
  76       FROM_HERE,
  77       base::Bind(&UpdateWorkerDependencyOnUI, added_ids, removed_ids));
  78 }
  79
  80 void DecrementWorkerRefCount(int process_id) {
  81   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
  82     BrowserThread::PostTask(BrowserThread::UI,
  83                             FROM_HERE,
  84                             base::Bind(&DecrementWorkerRefCount, process_id));
  85     return;
  86   }
  87   RenderProcessHostImpl* render_process_host_impl =
  88       static_cast<RenderProcessHostImpl*>(
  89           RenderProcessHost::FromID(process_id));
  90   if (render_process_host_impl)
  91     render_process_host_impl->DecrementWorkerRefCount();
  92 }
  93
  94 bool TryIncrementWorkerRefCount(int worker_process_id) {
  95   RenderProcessHostImpl* render_process = static_cast<RenderProcessHostImpl*>(
  96       RenderProcessHost::FromID(worker_process_id));
  97   if (!render_process || render_process->FastShutdownStarted()) {
  98     return false;
  99   }
 100   render_process->IncrementWorkerRefCount();
 101   return true;
 102 }
 103
 104 }  // namespace
 105
 106 class SharedWorkerServiceImpl::SharedWorkerPendingInstance {
 107  public:
 108   struct SharedWorkerPendingRequest {
 109     SharedWorkerPendingRequest(SharedWorkerMessageFilter* filter,
 110                                int route_id,
 111                                unsigned long long document_id,
 112                                int render_process_id,
 113                                int render_frame_route_id)
 114         : filter(filter),
 115           route_id(route_id),
 116           document_id(document_id),
 117           render_process_id(render_process_id),
 118           render_frame_route_id(render_frame_route_id) {}
 119     SharedWorkerMessageFilter* const filter;
 120     const int route_id;
 121     const unsigned long long document_id;
 122     const int render_process_id;
 123     const int render_frame_route_id;
 124   };
 125
 126   typedef ScopedVector<SharedWorkerPendingRequest> SharedWorkerPendingRequests;
 127
 128   explicit SharedWorkerPendingInstance(
 129       scoped_ptr<SharedWorkerInstance> instance)
 130       : instance_(instance.Pass()) {}
 131   ~SharedWorkerPendingInstance() {}
 132   SharedWorkerInstance* instance() { return instance_.get(); }
 133   SharedWorkerInstance* release_instance() { return instance_.release(); }
 134   SharedWorkerPendingRequests* requests() { return &requests_; }
 135   SharedWorkerMessageFilter* FindFilter(int process_id) {
 136     for (size_t i = 0; i < requests_.size(); ++i) {
 137       if (requests_[i]->render_process_id == process_id)
 138         return requests_[i]->filter;
 139     }
 140     return NULL;
 141   }
 142   void AddRequest(scoped_ptr<SharedWorkerPendingRequest> request_info) {
 143     requests_.push_back(request_info.release());
 144   }
 145   void RemoveRequest(int process_id) {
 146     for (SharedWorkerPendingRequests::iterator request_itr = requests_.begin();
 147          request_itr != requests_.end();) {
 148       if ((*request_itr)->render_process_id == process_id)
 149         request_itr = requests_.erase(request_itr);
 150       else
 151         ++request_itr;
 152     }
 153   }
 154   void RegisterToSharedWorkerHost(SharedWorkerHost* host) {
 155     for (size_t i = 0; i < requests_.size(); ++i) {
 156       SharedWorkerPendingRequest* request = requests_[i];
 157       host->AddFilter(request->filter, request->route_id);
 158       host->worker_document_set()->Add(request->filter,
 159                                        request->document_id,
 160                                        request->render_process_id,
 161                                        request->render_frame_route_id);
 162     }
 163   }
 164   void SendWorkerCreatedMessages() {
 165     for (size_t i = 0; i < requests_.size(); ++i) {
 166       SharedWorkerPendingRequest* request = requests_[i];
 167       request->filter->Send(new ViewMsg_WorkerCreated(request->route_id));
 168     }
 169   }
 170
 171  private:
 172   scoped_ptr<SharedWorkerInstance> instance_;
 173   SharedWorkerPendingRequests requests_;
 174   DISALLOW_COPY_AND_ASSIGN(SharedWorkerPendingInstance);
 175 };
 176
 177 class SharedWorkerServiceImpl::SharedWorkerReserver
 178     : public base::RefCountedThreadSafe<SharedWorkerReserver> {
 179  public:
 180   SharedWorkerReserver(int pending_instance_id,
 181                        int worker_process_id,
 182                        int worker_route_id,
 183                        bool is_new_worker,
 184                        const SharedWorkerInstance& instance)
 185       : worker_process_id_(worker_process_id),
 186         worker_route_id_(worker_route_id),
 187         is_new_worker_(is_new_worker),
 188         instance_(instance) {}
 189
 190   void TryReserve(const base::Callback<void(bool)>& success_cb,
 191                   const base::Closure& failure_cb,
 192                   bool (*try_increment_worker_ref_count)(int)) {
 193     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 194     if (!try_increment_worker_ref_count(worker_process_id_)) {
 195       BrowserThread::PostTask(BrowserThread::IO, FROM_HERE, failure_cb);
 196       return;
 197     }
 198     bool pause_on_start = false;
 199     if (is_new_worker_) {
 200       pause_on_start =
 201           EmbeddedWorkerDevToolsManager::GetInstance()->SharedWorkerCreated(
 202               worker_process_id_, worker_route_id_, instance_);
 203     }
 204     BrowserThread::PostTask(
 205         BrowserThread::IO, FROM_HERE, base::Bind(success_cb, pause_on_start));
 206   }
 207
 208  private:
 209   friend class base::RefCountedThreadSafe<SharedWorkerReserver>;
 210   ~SharedWorkerReserver() {}
 211
 212   const int worker_process_id_;
 213   const int worker_route_id_;
 214   const bool is_new_worker_;
 215   const SharedWorkerInstance instance_;
 216 };
 217
 218 // static
 219 bool (*SharedWorkerServiceImpl::s_try_increment_worker_ref_count_)(int) =
 220     TryIncrementWorkerRefCount;
 221
 222 SharedWorkerServiceImpl* SharedWorkerServiceImpl::GetInstance() {
 223   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 224   return Singleton<SharedWorkerServiceImpl>::get();
 225 }
 226
 227 SharedWorkerServiceImpl::SharedWorkerServiceImpl()
 228     : update_worker_dependency_(UpdateWorkerDependency),
 229       next_pending_instance_id_(0) {
 230 }
 231
 232 SharedWorkerServiceImpl::~SharedWorkerServiceImpl() {}
 233
 234 void SharedWorkerServiceImpl::ResetForTesting() {
 235   last_worker_depended_renderers_.clear();
 236   worker_hosts_.clear();
 237   observers_.Clear();
 238   update_worker_dependency_ = UpdateWorkerDependency;
 239   s_try_increment_worker_ref_count_ = TryIncrementWorkerRefCount;
 240 }
 241
 242 bool SharedWorkerServiceImpl::TerminateWorker(int process_id, int route_id) {
 243   SharedWorkerHost* host =
 244       worker_hosts_.get(std::make_pair(process_id, route_id));
 245   if (!host || !host->instance())
 246     return false;
 247   host->TerminateWorker();
 248   return true;
 249 }
 250
 251 std::vector<WorkerService::WorkerInfo> SharedWorkerServiceImpl::GetWorkers() {
 252   std::vector<WorkerService::WorkerInfo> results;
 253   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
 254        iter != worker_hosts_.end();
 255        ++iter) {
 256     SharedWorkerHost* host = iter->second;
 257     const SharedWorkerInstance* instance = host->instance();
 258     if (instance) {
 259       WorkerService::WorkerInfo info;
 260       info.url = instance->url();
 261       info.name = instance->name();
 262       info.route_id = host->worker_route_id();
 263       info.process_id = host->process_id();
 264       info.handle = host->container_render_filter()->PeerHandle();
 265       results.push_back(info);
 266     }
 267   }
 268   return results;
 269 }
 270
 271 void SharedWorkerServiceImpl::AddObserver(WorkerServiceObserver* observer) {
 272   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 273   observers_.AddObserver(observer);
 274 }
 275
 276 void SharedWorkerServiceImpl::RemoveObserver(WorkerServiceObserver* observer) {
 277   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 278   observers_.RemoveObserver(observer);
 279 }
 280
 281 void SharedWorkerServiceImpl::CreateWorker(
 282     const ViewHostMsg_CreateWorker_Params& params,
 283     int route_id,
 284     SharedWorkerMessageFilter* filter,
 285     ResourceContext* resource_context,
 286     const WorkerStoragePartitionId& partition_id,
 287     bool* url_mismatch) {
 288   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 289   *url_mismatch = false;
 290   scoped_ptr<SharedWorkerInstance> instance(
 291       new SharedWorkerInstance(params.url,
 292                                params.name,
 293                                params.content_security_policy,
 294                                params.security_policy_type,
 295                                resource_context,
 296                                partition_id));
 297   scoped_ptr<SharedWorkerPendingInstance::SharedWorkerPendingRequest> request(
 298       new SharedWorkerPendingInstance::SharedWorkerPendingRequest(
 299           filter,
 300           route_id,
 301           params.document_id,
 302           filter->render_process_id(),
 303           params.render_frame_route_id));
 304   if (SharedWorkerPendingInstance* pending = FindPendingInstance(*instance)) {
 305     if (params.url != pending->instance()->url()) {
 306       *url_mismatch = true;
 307       return;
 308     }
 309     pending->AddRequest(request.Pass());
 310     return;
 311   }
 312   scoped_ptr<SharedWorkerPendingInstance> pending_instance(
 313       new SharedWorkerPendingInstance(instance.Pass()));
 314   pending_instance->AddRequest(request.Pass());
 315   ReserveRenderProcessToCreateWorker(pending_instance.Pass(), url_mismatch);
 316 }
 317
 318 void SharedWorkerServiceImpl::ForwardToWorker(
 319     const IPC::Message& message,
 320     SharedWorkerMessageFilter* filter) {
 321   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
 322        iter != worker_hosts_.end();
 323        ++iter) {
 324     if (iter->second->FilterMessage(message, filter))
 325       return;
 326   }
 327 }
 328
 329 void SharedWorkerServiceImpl::DocumentDetached(
 330     unsigned long long document_id,
 331     SharedWorkerMessageFilter* filter) {
 332   ScopedWorkerDependencyChecker checker(this);
 333   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
 334        iter != worker_hosts_.end();
 335        ++iter) {
 336     iter->second->DocumentDetached(filter, document_id);
 337   }
 338 }
 339
 340 void SharedWorkerServiceImpl::WorkerContextClosed(
 341     int worker_route_id,
 342     SharedWorkerMessageFilter* filter) {
 343   ScopedWorkerDependencyChecker checker(this);
 344   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
 345     host->WorkerContextClosed();
 346 }
 347
 348 void SharedWorkerServiceImpl::WorkerContextDestroyed(
 349     int worker_route_id,
 350     SharedWorkerMessageFilter* filter) {
 351   ScopedWorkerDependencyChecker checker(this);
 352   scoped_ptr<SharedWorkerHost> host =
 353       worker_hosts_.take_and_erase(std::make_pair(filter->render_process_id(),
 354                                                   worker_route_id));
 355   if (!host)
 356     return;
 357   host->WorkerContextDestroyed();
 358 }
 359
 360 void SharedWorkerServiceImpl::WorkerReadyForInspection(
 361     int worker_route_id,
 362     SharedWorkerMessageFilter* filter) {
 363   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
 364     host->WorkerReadyForInspection();
 365 }
 366
 367 void SharedWorkerServiceImpl::WorkerScriptLoaded(
 368     int worker_route_id,
 369     SharedWorkerMessageFilter* filter) {
 370   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
 371     host->WorkerScriptLoaded();
 372 }
 373
 374 void SharedWorkerServiceImpl::WorkerScriptLoadFailed(
 375     int worker_route_id,
 376     SharedWorkerMessageFilter* filter) {
 377   ScopedWorkerDependencyChecker checker(this);
 378   scoped_ptr<SharedWorkerHost> host =
 379       worker_hosts_.take_and_erase(std::make_pair(filter->render_process_id(),
 380                                                   worker_route_id));
 381   if (!host)
 382     return;
 383   host->WorkerScriptLoadFailed();
 384 }
 385
 386 void SharedWorkerServiceImpl::WorkerConnected(
 387     int message_port_id,
 388     int worker_route_id,
 389     SharedWorkerMessageFilter* filter) {
 390   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
 391     host->WorkerConnected(message_port_id);
 392 }
 393
 394 void SharedWorkerServiceImpl::AllowDatabase(
 395     int worker_route_id,
 396     const GURL& url,
 397     const base::string16& name,
 398     const base::string16& display_name,
 399     unsigned long estimated_size,
 400     bool* result,
 401     SharedWorkerMessageFilter* filter) {
 402   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
 403     host->AllowDatabase(url, name, display_name, estimated_size, result);
 404 }
 405
 406 void SharedWorkerServiceImpl::AllowFileSystem(
 407     int worker_route_id,
 408     const GURL& url,
 409     IPC::Message* reply_msg,
 410     SharedWorkerMessageFilter* filter) {
 411   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id)) {
 412     host->AllowFileSystem(url, make_scoped_ptr(reply_msg));
 413   } else {
 414     filter->Send(reply_msg);
 415     return;
 416   }
 417 }
 418
 419 void SharedWorkerServiceImpl::AllowIndexedDB(
 420     int worker_route_id,
 421     const GURL& url,
 422     const base::string16& name,
 423     bool* result,
 424     SharedWorkerMessageFilter* filter) {
 425   if (SharedWorkerHost* host = FindSharedWorkerHost(filter, worker_route_id))
 426     host->AllowIndexedDB(url, name, result);
 427 }
 428
 429 void SharedWorkerServiceImpl::OnSharedWorkerMessageFilterClosing(
 430     SharedWorkerMessageFilter* filter) {
 431   ScopedWorkerDependencyChecker checker(this);
 432   std::vector<ProcessRouteIdPair> remove_list;
 433   for (WorkerHostMap::iterator iter = worker_hosts_.begin();
 434        iter != worker_hosts_.end();
 435        ++iter) {
 436     iter->second->FilterShutdown(filter);
 437     if (iter->first.first == filter->render_process_id())
 438       remove_list.push_back(iter->first);
 439   }
 440   for (size_t i = 0; i < remove_list.size(); ++i) {
 441     scoped_ptr<SharedWorkerHost> host =
 442         worker_hosts_.take_and_erase(remove_list[i]);
 443   }
 444
 445   std::vector<int> remove_pending_instance_list;
 446   for (PendingInstaneMap::iterator iter = pending_instances_.begin();
 447        iter != pending_instances_.end();
 448        ++iter) {
 449     iter->second->RemoveRequest(filter->render_process_id());
 450     if (!iter->second->requests()->size())
 451       remove_pending_instance_list.push_back(iter->first);
 452   }
 453   for (size_t i = 0; i < remove_pending_instance_list.size(); ++i)
 454     pending_instances_.take_and_erase(remove_pending_instance_list[i]);
 455 }
 456
 457 void SharedWorkerServiceImpl::NotifyWorkerDestroyed(int worker_process_id,
 458                                                     int worker_route_id) {
 459   FOR_EACH_OBSERVER(WorkerServiceObserver,
 460                     observers_,
 461                     WorkerDestroyed(worker_process_id, worker_route_id));
 462 }
 463
 464 void SharedWorkerServiceImpl::ReserveRenderProcessToCreateWorker(
 465     scoped_ptr<SharedWorkerPendingInstance> pending_instance,
 466     bool* url_mismatch) {
 467   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 468   DCHECK(!FindPendingInstance(*pending_instance->instance()));
 469   if (url_mismatch)
 470     *url_mismatch = false;
 471   if (!pending_instance->requests()->size())
 472     return;
 473   int worker_process_id = -1;
 474   int worker_route_id = MSG_ROUTING_NONE;
 475   bool is_new_worker = true;
 476   SharedWorkerHost* host = FindSharedWorkerHost(*pending_instance->instance());
 477   if (host) {
 478     if (pending_instance->instance()->url() != host->instance()->url()) {
 479       if (url_mismatch)
 480         *url_mismatch = true;
 481       return;
 482     }
 483     worker_process_id = host->process_id();
 484     worker_route_id = host->worker_route_id();
 485     is_new_worker = false;
 486   } else {
 487     SharedWorkerMessageFilter* first_filter =
 488         (*pending_instance->requests()->begin())->filter;
 489     worker_process_id = first_filter->render_process_id();
 490     worker_route_id = first_filter->GetNextRoutingID();
 491   }
 492   const int pending_instance_id = next_pending_instance_id_++;
 493   scoped_refptr<SharedWorkerReserver> reserver(
 494       new SharedWorkerReserver(pending_instance_id,
 495                                worker_process_id,
 496                                worker_route_id,
 497                                is_new_worker,
 498                                *pending_instance->instance()));
 499   BrowserThread::PostTask(
 500       BrowserThread::UI,
 501       FROM_HERE,
 502       base::Bind(
 503           &SharedWorkerReserver::TryReserve,
 504           reserver,
 505           base::Bind(&SharedWorkerServiceImpl::RenderProcessReservedCallback,
 506                      base::Unretained(this),
 507                      pending_instance_id,
 508                      worker_process_id,
 509                      worker_route_id,
 510                      is_new_worker),
 511           base::Bind(
 512               &SharedWorkerServiceImpl::RenderProcessReserveFailedCallback,
 513               base::Unretained(this),
 514               pending_instance_id,
 515               worker_process_id,
 516               worker_route_id,
 517               is_new_worker),
 518           s_try_increment_worker_ref_count_));
 519   pending_instances_.set(pending_instance_id, pending_instance.Pass());
 520 }
 521
 522 void SharedWorkerServiceImpl::RenderProcessReservedCallback(
 523     int pending_instance_id,
 524     int worker_process_id,
 525     int worker_route_id,
 526     bool is_new_worker,
 527     bool pause_on_start) {
 528   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 529   // To offset the TryIncrementWorkerRefCount called for the reservation,
 530   // calls DecrementWorkerRefCount after CheckWorkerDependency in
 531   // ScopeWorkerDependencyChecker's destructor.
 532   ScopedWorkerDependencyChecker checker(
 533       this, base::Bind(&DecrementWorkerRefCount, worker_process_id));
 534   scoped_ptr<SharedWorkerPendingInstance> pending_instance =
 535       pending_instances_.take_and_erase(pending_instance_id);
 536   if (!pending_instance)
 537     return;
 538   if (!is_new_worker) {
 539     SharedWorkerHost* existing_host =
 540         worker_hosts_.get(std::make_pair(worker_process_id, worker_route_id));
 541     if (!existing_host) {
 542       // Retry reserving a renderer process if the existed Shared Worker was
 543       // destroyed on IO thread while reserving the renderer process on UI
 544       // thread.
 545       ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL);
 546       return;
 547     }
 548     pending_instance->RegisterToSharedWorkerHost(existing_host);
 549     pending_instance->SendWorkerCreatedMessages();
 550     return;
 551   }
 552   SharedWorkerMessageFilter* filter =
 553       pending_instance->FindFilter(worker_process_id);
 554   if (!filter) {
 555     pending_instance->RemoveRequest(worker_process_id);
 556     // Retry reserving a renderer process if the requested renderer process was
 557     // destroyed on IO thread while reserving the renderer process on UI thread.
 558     ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL);
 559     return;
 560   }
 561   scoped_ptr<SharedWorkerHost> host(new SharedWorkerHost(
 562       pending_instance->release_instance(), filter, worker_route_id));
 563   pending_instance->RegisterToSharedWorkerHost(host.get());
 564   const GURL url = host->instance()->url();
 565   const base::string16 name = host->instance()->name();
 566   host->Start(pause_on_start);
 567   worker_hosts_.set(std::make_pair(worker_process_id, worker_route_id),
 568                     host.Pass());
 569   FOR_EACH_OBSERVER(
 570       WorkerServiceObserver,
 571       observers_,
 572       WorkerCreated(url, name, worker_process_id, worker_route_id));
 573 }
 574
 575 void SharedWorkerServiceImpl::RenderProcessReserveFailedCallback(
 576     int pending_instance_id,
 577     int worker_process_id,
 578     int worker_route_id,
 579     bool is_new_worker) {
 580   worker_hosts_.take_and_erase(
 581       std::make_pair(worker_process_id, worker_route_id));
 582   scoped_ptr<SharedWorkerPendingInstance> pending_instance =
 583       pending_instances_.take_and_erase(pending_instance_id);
 584   if (!pending_instance)
 585     return;
 586   pending_instance->RemoveRequest(worker_process_id);
 587   // Retry reserving a renderer process.
 588   ReserveRenderProcessToCreateWorker(pending_instance.Pass(), NULL);
 589 }
 590
 591 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
 592     SharedWorkerMessageFilter* filter,
 593     int worker_route_id) {
 594   return worker_hosts_.get(std::make_pair(filter->render_process_id(),
 595                                           worker_route_id));
 596 }
 597
 598 SharedWorkerHost* SharedWorkerServiceImpl::FindSharedWorkerHost(
 599     const SharedWorkerInstance& instance) {
 600   for (WorkerHostMap::const_iterator iter = worker_hosts_.begin();
 601        iter != worker_hosts_.end();
 602        ++iter) {
 603     SharedWorkerHost* host = iter->second;
 604     if (host->instance() && !host->closed() &&
 605         host->instance()->Matches(instance)) {
 606       return iter->second;
 607     }
 608   }
 609   return NULL;
 610 }
 611
 612 SharedWorkerServiceImpl::SharedWorkerPendingInstance*
 613 SharedWorkerServiceImpl::FindPendingInstance(
 614     const SharedWorkerInstance& instance) {
 615   for (PendingInstaneMap::iterator iter = pending_instances_.begin();
 616        iter != pending_instances_.end();
 617        ++iter) {
 618     if (iter->second->instance()->Matches(instance))
 619       return iter->second;
 620   }
 621   return NULL;
 622 }
 623
 624 const std::set<int>
 625 SharedWorkerServiceImpl::GetRenderersWithWorkerDependency() {
 626   std::set<int> dependent_renderers;
 627   for (WorkerHostMap::iterator host_iter = worker_hosts_.begin();
 628        host_iter != worker_hosts_.end();
 629        ++host_iter) {
 630     const int process_id = host_iter->first.first;
 631     if (dependent_renderers.count(process_id))
 632       continue;
 633     if (host_iter->second->instance() &&
 634         host_iter->second->worker_document_set()->ContainsExternalRenderer(
 635             process_id)) {
 636       dependent_renderers.insert(process_id);
 637     }
 638   }
 639   return dependent_renderers;
 640 }
 641
 642 void SharedWorkerServiceImpl::CheckWorkerDependency() {
 643   const std::set<int> current_worker_depended_renderers =
 644       GetRenderersWithWorkerDependency();
 645   std::vector<int> added_items = base::STLSetDifference<std::vector<int> >(
 646       current_worker_depended_renderers, last_worker_depended_renderers_);
 647   std::vector<int> removed_items = base::STLSetDifference<std::vector<int> >(
 648       last_worker_depended_renderers_, current_worker_depended_renderers);
 649   if (!added_items.empty() || !removed_items.empty()) {
 650     last_worker_depended_renderers_ = current_worker_depended_renderers;
 651     update_worker_dependency_(added_items, removed_items);
 652   }
 653 }
 654
 655 void SharedWorkerServiceImpl::ChangeUpdateWorkerDependencyFuncForTesting(
 656     UpdateWorkerDependencyFunc new_func) {
 657   update_worker_dependency_ = new_func;
 658 }
 659
 660 void SharedWorkerServiceImpl::ChangeTryIncrementWorkerRefCountFuncForTesting(
 661     bool (*new_func)(int)) {
 662   s_try_increment_worker_ref_count_ = new_func;
 663 }
 664
 665 }  // namespace content