Revert 256305 "Add SharedWorkerServiceImpl::CheckWorkerDependenc..."

trunk/src/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()
-    : 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;
+SharedWorkerServiceImpl::~SharedWorkerServiceImpl() {
 }
 
 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