Lower the priority of shared workers

content/browser/worker_host/worker_service_impl.cc

 // Copyright (c) 2012 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/worker_host/worker_service_impl.h"
 
 #include <string>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/threading/thread.h"
 #include "content/browser/devtools/worker_devtools_manager.h"
+#include "content/browser/renderer_host/render_widget_host_impl.h"
 #include "content/browser/worker_host/worker_message_filter.h"
 #include "content/browser/worker_host/worker_process_host.h"
 #include "content/common/view_messages.h"
 #include "content/common/worker_messages.h"
 #include "content/public/browser/child_process_data.h"
+#include "content/public/browser/notification_service.h"
+#include "content/public/browser/notification_types.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_view_host.h"
+#include "content/public/browser/render_widget_host.h"
+#include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/resource_context.h"
+#include "content/public/browser/web_contents.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/content_switches.h"
 #include "content/public/common/process_type.h"
 
 namespace content {
 
 const int WorkerServiceImpl::kMaxWorkersWhenSeparate = 64;
 const int WorkerServiceImpl::kMaxWorkersPerTabWhenSeparate = 16;
 
+class WorkerPrioritySetter
+    : public NotificationObserver,
+      public base::RefCountedThreadSafe<WorkerPrioritySetter,
+                                        BrowserThread::DeleteOnUIThread> {
+ public:
+  WorkerPrioritySetter();
+
+  // Posts a task to the UI thread to register to receive notifications.
+  void PostRegisterObserverTask();
+
+  // Invoked by WorkerServiceImpl when a worker process is created.
+  void NotifyWorkerProcessCreated();
+
+ private:
+  friend class base::RefCountedThreadSafe<WorkerPrioritySetter>;
+  friend struct BrowserThread::DeleteOnThread<BrowserThread::UI>;
+  friend class base::DeleteHelper<WorkerPrioritySetter>;
+  virtual ~WorkerPrioritySetter();
+
+  // Posts a task to perform a worker priority update.
+  void PostTaskToGatherAndUpdateWorkerPriorities();
+
+  // Gathers up a list of the visible tabs and then updates priorities for
+  // all the shared workers.
+  void GatherVisibleIDsAndUpdateWorkerPriorities();
+
+  // Registers as an observer to receive notifications about
+  // widgets being shown.
+  void RegisterObserver();
+
+  // Sets priorities for shared workers given a set of visible tabs (as a
+  // std::set of std::pair<render_process, render_view> ids.
+  void UpdateWorkerPrioritiesFromVisibleSet(
+      const std::set<std::pair<int, int> >* visible);
+
+  // Called to refresh worker priorities when focus changes between tabs.
+  void OnRenderWidgetVisibilityChanged(std::pair<int, int>);
+
+  // NotificationObserver implementation.
+  virtual void Observe(int type,
+                       const NotificationSource& source,
+                       const NotificationDetails& details) OVERRIDE;
+
+  NotificationRegistrar registrar_;
+};
+
+WorkerPrioritySetter::WorkerPrioritySetter() {
+}
+
+WorkerPrioritySetter::~WorkerPrioritySetter() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+}
+
+void WorkerPrioritySetter::PostRegisterObserverTask() {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(&WorkerPrioritySetter::RegisterObserver, this));
+}
+
+void WorkerPrioritySetter::NotifyWorkerProcessCreated() {
+  PostTaskToGatherAndUpdateWorkerPriorities();
+}
+
+void WorkerPrioritySetter::PostTaskToGatherAndUpdateWorkerPriorities() {
+  BrowserThread::PostTask(
+      BrowserThread::UI, FROM_HERE,
+      base::Bind(
+          &WorkerPrioritySetter::GatherVisibleIDsAndUpdateWorkerPriorities,
+          this));
+}
+
+void WorkerPrioritySetter::GatherVisibleIDsAndUpdateWorkerPriorities() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  std::set<std::pair<int, int> >* visible_renderer_ids =
+      new std::set<std::pair<int, int> >();
+
+  // Gather up all the visible renderer process/view pairs
+  for (RenderProcessHost::iterator it =
+       RenderProcessHost::AllHostsIterator();
+       !it.IsAtEnd(); it.Advance()) {
+    RenderProcessHost* render_process_host = it.GetCurrentValue();
+    if (render_process_host->VisibleWidgetCount()) {
+      for (RenderProcessHost::RenderWidgetHostsIterator rit =
+           render_process_host->GetRenderWidgetHostsIterator(); !rit.IsAtEnd();
+           rit.Advance()) {
+        RenderWidgetHost* render_widget =
+            render_process_host->GetRenderWidgetHostByID(rit.GetCurrentKey());
+        if (render_widget) {
+          RenderWidgetHostView* render_view = render_widget->GetView();
+          if (render_view && render_view->IsShowing()) {
+            visible_renderer_ids->insert(
+                std::pair<int, int>(render_process_host->GetID(),
+                                    render_widget->GetRoutingID()));
+          }
+        }
+      }
+    }
+  }
+
+  BrowserThread::PostTask(
+      BrowserThread::IO, FROM_HERE,
+      base::Bind(&WorkerPrioritySetter::UpdateWorkerPrioritiesFromVisibleSet,
+                 this, base::Owned(visible_renderer_ids)));
+}
+
+void WorkerPrioritySetter::UpdateWorkerPrioritiesFromVisibleSet(
+    const std::set<std::pair<int, int> >* visible_renderer_ids) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+
+  for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
+    if (!iter->process_launched())
+      continue;
+    bool throttle = true;
+
+    for (WorkerProcessHost::Instances::const_iterator instance =
+        iter->instances().begin(); instance != iter->instances().end();
+        ++instance) {
+
+      // This code assumes one worker per process
+      WorkerProcessHost::Instances::const_iterator first_instance =
+          iter->instances().begin();
+      if (first_instance == iter->instances().end())
+        continue;
+
+      WorkerDocumentSet::DocumentInfoSet::const_iterator info =
+          first_instance->worker_document_set()->documents().begin();
+
+      for (; info != first_instance->worker_document_set()->documents().end();
+          ++info) {
+        std::pair<int, int> id(
+            info->render_process_id(), info->render_view_id());
+        if (visible_renderer_ids->find(id) != visible_renderer_ids->end()) {
+          throttle = false;
+          break;
+        }
+      }
+
+      if (!throttle ) {
+        break;
+      }
+    }
+
+    iter->SetBackgrounded(throttle);
+  }
+}
+
+void WorkerPrioritySetter::OnRenderWidgetVisibilityChanged(
+    std::pair<int, int> id) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
+  std::set<std::pair<int, int> > visible_renderer_ids;
+
+  visible_renderer_ids.insert(id);
+
+  UpdateWorkerPrioritiesFromVisibleSet(&visible_renderer_ids);
+}
+
+void WorkerPrioritySetter::RegisterObserver() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  registrar_.Add(this, NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED,
+                 NotificationService::AllBrowserContextsAndSources());
+  registrar_.Add(this, NOTIFICATION_RENDERER_PROCESS_CREATED,
+                 NotificationService::AllBrowserContextsAndSources());
+}
+
+void WorkerPrioritySetter::Observe(int type,
+    const NotificationSource& source, const NotificationDetails& details) {
+  if (type == NOTIFICATION_RENDER_WIDGET_VISIBILITY_CHANGED) {
+    bool visible = *Details<bool>(details).ptr();
+
+    if (visible) {
+      int render_widget_id =
+          Source<RenderWidgetHost>(source).ptr()->GetRoutingID();
+      int render_process_pid =
+          Source<RenderWidgetHost>(source).ptr()->GetProcess()->GetID();
+
+      BrowserThread::PostTask(
+          BrowserThread::IO, FROM_HERE,
+          base::Bind(&WorkerPrioritySetter::OnRenderWidgetVisibilityChanged,
+              this, std::pair<int, int>(render_process_pid, render_widget_id)));
+    }
+  }
+  else if (type == NOTIFICATION_RENDERER_PROCESS_CREATED) {
+    PostTaskToGatherAndUpdateWorkerPriorities();
+  }
+}
+
 WorkerService* WorkerService::GetInstance() {
   return WorkerServiceImpl::GetInstance();
 }
 
 WorkerServiceImpl* WorkerServiceImpl::GetInstance() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
   return Singleton<WorkerServiceImpl>::get();
 }
 
-WorkerServiceImpl::WorkerServiceImpl() : next_worker_route_id_(0) {
+WorkerServiceImpl::WorkerServiceImpl()
+    : priority_setter_(new WorkerPrioritySetter()),
+      next_worker_route_id_(0) {
+  priority_setter_->PostRegisterObserverTask();

[darin (slow to review), 2013/05/17 00:33:26]

nit: You might consider a more generic name for this method like "Initialize". 
from the point of view of the WorkerServiceImpl, it doesn't really care what
this method does other than that it is the second part of setting up the
WorkerPrioritySetter.

[shatch, 2013/05/17 21:00:46]

Done.

 }
 
 WorkerServiceImpl::~WorkerServiceImpl() {
   // The observers in observers_ can't be used here because they might be
   // gone already.
 }
 
 void WorkerServiceImpl::OnWorkerMessageFilterClosing(
     WorkerMessageFilter* filter) {
   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
@@ skipping 402 matching lines @@
 
 void WorkerServiceImpl::NotifyWorkerDestroyed(
     WorkerProcessHost* process,
     int worker_route_id) {
   WorkerDevToolsManager::GetInstance()->WorkerDestroyed(
       process, worker_route_id);
   FOR_EACH_OBSERVER(WorkerServiceObserver, observers_,
                     WorkerDestroyed(process->GetData().id, worker_route_id));
 }
 
+void WorkerServiceImpl::NotifyWorkerProcessCreated() {
+  priority_setter_->NotifyWorkerProcessCreated();
+}
+
 WorkerProcessHost::WorkerInstance* WorkerServiceImpl::FindSharedWorkerInstance(
     const GURL& url,
     const string16& name,
     const WorkerStoragePartition& partition,
     ResourceContext* resource_context) {
   for (WorkerProcessHostIterator iter; !iter.Done(); ++iter) {
     for (WorkerProcessHost::Instances::iterator instance_iter =
              iter->mutable_instances().begin();
          instance_iter != iter->mutable_instances().end();
          ++instance_iter) {
@@ skipping 50 matching lines @@
     return instance;
 
   // No existing pending worker - create a new one.
   WorkerProcessHost::WorkerInstance pending(
       url, true, name, resource_context, partition);
   pending_shared_workers_.push_back(pending);
   return &pending_shared_workers_.back();
 }
 
 }  // namespace content