Removes the references to shared workers from the all documents in being deleted frames

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 <stddef.h>
 
 #include <algorithm>
 #include <iterator>
@@ skipping 139 matching lines @@
 
   void RemoveRequest(int process_id) {
     auto to_remove = std::remove_if(
         requests_.begin(), requests_.end(),
         [process_id](const std::unique_ptr<SharedWorkerPendingRequest>& r) {
           return r->render_process_id == process_id;
         });
     requests_.erase(to_remove, requests_.end());
   }
 
+  void RemoveRequestFromFrame(int process_id, int frame_id) {
+    auto to_remove = std::remove_if(
+        requests_.begin(), requests_.end(),
+        [process_id,
+         frame_id](const std::unique_ptr<SharedWorkerPendingRequest>& r) {
+          return r->render_process_id == process_id &&
+                 r->render_frame_route_id == frame_id;
+        });
+    requests_.erase(to_remove, requests_.end());
+  }
+
   void RegisterToSharedWorkerHost(SharedWorkerHost* host) {
     for (const auto& request : requests_) {
       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);
     }
   }
 
@@ skipping 262 matching lines @@
   std::vector<int> remove_pending_instance_list;
   for (const auto& it : pending_instances_) {
     it.second->RemoveRequest(filter->render_process_id());
     if (it.second->requests()->empty())
       remove_pending_instance_list.push_back(it.first);
   }
   for (int to_remove : remove_pending_instance_list)
     pending_instances_.erase(to_remove);
 }
 
+void SharedWorkerServiceImpl::RenderFrameDetached(int render_process_id,
+                                                  int render_frame_id) {
+  ScopedWorkerDependencyChecker checker(this);
+  for (const auto& it : worker_hosts_) {
+    it.second->RenderFrameDetached(render_process_id, render_frame_id);
+  }
+
+  auto it = pending_instances_.begin();
+  while (it != pending_instances_.end()) {
+    it->second->RemoveRequestFromFrame(render_process_id, render_frame_id);
+    if (it->second->requests()->empty())
+      it = pending_instances_.erase(it);
+    else
+      ++it;
+  }
+}
+
 void SharedWorkerServiceImpl::NotifyWorkerDestroyed(int worker_process_id,
                                                     int worker_route_id) {
   FOR_EACH_OBSERVER(WorkerServiceObserver,
                     observers_,
                     WorkerDestroyed(worker_process_id, worker_route_id));
 }
 
 blink::WebWorkerCreationError
 SharedWorkerServiceImpl::ReserveRenderProcessToCreateWorker(
     std::unique_ptr<SharedWorkerPendingInstance> pending_instance) {
@@ skipping 194 matching lines @@
     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