Improving the process model extension API

chrome/browser/extensions/extension_processes_api.h

 // Copyright (c) 2011 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_EXTENSION_PROCESSES_API_H__
 #define CHROME_BROWSER_EXTENSIONS_EXTENSION_PROCESSES_API_H__
 #pragma once
 
 #include <set>
 #include <string>
 
 #include "chrome/browser/extensions/extension_function.h"
 #include "chrome/browser/task_manager/task_manager.h"
 #include "content/public/browser/notification_registrar.h"
+#include "content/public/browser/render_process_host.h"
+#include "content/public/browser/render_widget_host.h"
 
 // Observes the Task Manager and routes the notifications as events to the
 // extension system.
-class ExtensionProcessesEventRouter : public TaskManagerModelObserver {
+class ExtensionProcessesEventRouter : public TaskManagerModelObserver,
+                                      public content::NotificationObserver {
  public:
   // Single instance of the event router.
   static ExtensionProcessesEventRouter* GetInstance();
 
   // Safe to call multiple times.
   void ObserveProfile(Profile* profile);
 
   // Called when an extension process wants to listen to process events.
   void ListenerAdded();
 
   // Called when an extension process with a listener exits or removes it.
   void ListenerRemoved();
 
  private:
   friend struct DefaultSingletonTraits<ExtensionProcessesEventRouter>;
 
   ExtensionProcessesEventRouter();
   virtual ~ExtensionProcessesEventRouter();
 
   // TaskManagerModelObserver methods.
   virtual void OnModelChanged() OVERRIDE {}
   virtual void OnItemsChanged(int start, int length) OVERRIDE;
-  virtual void OnItemsAdded(int start, int length) OVERRIDE {}
+  virtual void OnItemsAdded(int start, int length) OVERRIDE;
+  virtual void OnItemsToBeRemoved(int start, int length) OVERRIDE;
   virtual void OnItemsRemoved(int start, int length) OVERRIDE {}
 
+  // content::NotificationObserver implementation.
+  virtual void Observe(int type,
+                       const content::NotificationSource& source,
+                       const content::NotificationDetails& details) OVERRIDE;
+
+ private:
+  void NotifyProfiles(const char* event_name, std::string json_args);
+
   void DispatchEvent(Profile* profile,
                      const char* event_name,
                      const std::string& json_args);
 
+  // Determines whether there is a registered listener for the specified event.
+  // It helps to avoid collecing data if noone is interested in it.

[Charlie Reis, 2012/04/23 22:19:51]

Nit: noone -> no one (here and below)

[nasko, 2012/04/24 18:14:29]

Done.

+  bool HasEventListeners(std::string& event_name);
+
+  void ProcessHangEvent(content::RenderWidgetHost* widget);
+  void ProcessClosedEvent(
+      content::RenderProcessHost* rph,
+      content::RenderProcessHost::RendererClosedDetails* details);
+
   // Used for tracking registrations to process related notifications.
   content::NotificationRegistrar registrar_;
 
   // Registered profiles.
   typedef std::set<Profile*> ProfileSet;
   ProfileSet profiles_;
 
   // TaskManager to observe for updates.
   TaskManagerModel* model_;
 
+  // Count of listeners, so we avoid sending updates if noone is interested.
+  int listeners_;
+
   DISALLOW_COPY_AND_ASSIGN(ExtensionProcessesEventRouter);
 };
 
 
 // This extension function returns the Process object for the renderer process
 // currently in use by the specified Tab.
 class GetProcessIdForTabFunction : public SyncExtensionFunction {
   virtual ~GetProcessIdForTabFunction() {}
   virtual bool RunImpl() OVERRIDE;
   DECLARE_EXTENSION_FUNCTION_NAME("experimental.processes.getProcessIdForTab")
 };
 
+// Extension function that allows terminating Chrome subprocesses, by supplying
+// the unique ID for the process coming from the ChildProcess ID pool.
+// Using unique IDs instead of OS process IDs allows two advantages:
+// * guaranteed uniqueness, since OS process IDs can be reused
+// * guards against killing non-Chrome processes

[Charlie Reis, 2012/04/23 22:19:51]

Nice.

[nasko, 2012/04/24 18:14:29]

Done.

+class TerminateFunction : public SyncExtensionFunction {
+  virtual ~TerminateFunction() {}
+  virtual bool RunImpl() OVERRIDE;
+  DECLARE_EXTENSION_FUNCTION_NAME("experimental.processes.terminate")
+};
+
+// Extension function which returns a set of Process objects, containing the
+// details corresponding to the process IDs supplied as input.
+class GetProcessInfoFunction : public SyncExtensionFunction {
+  virtual ~GetProcessInfoFunction() {}
+  virtual bool RunImpl() OVERRIDE;
+  DECLARE_EXTENSION_FUNCTION_NAME("experimental.processes.getProcessInfo")
+};
+
 #endif  // CHROME_BROWSER_EXTENSIONS_EXTENSION_PROCESSES_API_H__