content: convert child process notifications to observer usage

chrome/browser/metrics/metrics_service.h

 // 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.
 
 // This file defines a service that collects information about the user
 // experience in order to help improve future versions of the app.
 
 #ifndef CHROME_BROWSER_METRICS_METRICS_SERVICE_H_
 #define CHROME_BROWSER_METRICS_METRICS_SERVICE_H_
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/metrics/field_trial.h"
 #include "base/process_util.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/tracking_synchronizer_observer.h"
 #include "chrome/common/metrics/metrics_service_base.h"
 #include "chrome/installer/util/google_update_settings.h"
+#include "content/public/browser/browser_child_process_observer.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/user_metrics.h"
 #include "net/url_request/url_fetcher_delegate.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/external_metrics.h"
 #endif
 
 class MetricsReportingScheduler;
@@ skipping 27 matching lines @@
 namespace tracked_objects {
 struct ProcessDataSnapshot;
 }
 
 namespace webkit {
 struct WebPluginInfo;
 }
 
 class MetricsService
     : public chrome_browser_metrics::TrackingSynchronizerObserver,
+      public content::BrowserChildProcessObserver,
       public content::NotificationObserver,
       public net::URLFetcherDelegate,
       public MetricsServiceBase {
  public:
   MetricsService();
   virtual ~MetricsService();
 
   // Starts the metrics system, turning on recording and uploading of metrics.
   // Should be called when starting up with metrics enabled, or when metrics
   // are turned on.
@@ skipping 42 matching lines @@
   // At startup, prefs needs to be called with a list of all the pref names and
   // types we'll be using.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
   // Set up notifications which indicate that a user is performing work. This is
   // useful to allow some features to sleep, until the machine becomes active,
   // such as precluding UMA uploads unless there was recent activity.
   static void SetUpNotifications(content::NotificationRegistrar* registrar,
                                  content::NotificationObserver* observer);
 
+  // Implementation of content::BrowserChildProcessObserver
+  virtual void BrowserChildProcessHostConnected(
+      const content::ChildProcessData& data) OVERRIDE;
+  virtual void BrowserChildProcessCrashed(
+      const content::ChildProcessData& data) OVERRIDE;
+  virtual void BrowserChildProcessInstanceCreated(
+      const content::ChildProcessData& data) OVERRIDE;
+
   // Implementation of content::NotificationObserver
   virtual void Observe(int type,
                        const content::NotificationSource& source,
                        const content::NotificationDetails& details) OVERRIDE;
 
   // Invoked when we get a WM_SESSIONEND. This places a value in prefs that is
   // reset when RecordCompletedSessionEnd is invoked.
   void RecordStartOfSessionEnd();
 
   // This should be called when the application is shutting down. It records
@@ skipping 60 matching lines @@
 
   // Designates which entropy source was returned from this MetricsService.
   // This is used for testing to validate that we return the correct source
   // depending on the state of the service.
   enum EntropySourceReturned {
     LAST_ENTROPY_NONE,
     LAST_ENTROPY_LOW,
     LAST_ENTROPY_HIGH,
   };
 
+  struct ChildProcessStats;
+
   // First part of the init task. Called on the FILE thread to load hardware
   // class information.
   static void InitTaskGetHardwareClass(base::WeakPtr<MetricsService> self,
                                        base::MessageLoopProxy* target_loop);
 
   // Callback from InitTaskGetHardwareClass() that continues the init task by
   // loading plugin information.
   void OnInitTaskGotHardwareClass(const std::string& hardware_class);
 
   // Callback from PluginService::GetPlugins() that continues the init task by
@@ skipping 131 matching lines @@
   void LogRendererCrash(content::RenderProcessHost* host,
                         base::TerminationStatus status,
                         int exit_code);
 
   // Records a renderer process hang.
   void LogRendererHang();
 
   // Records that the browser was shut down cleanly.
   void LogCleanShutdown();
 
-  // Records a child process related notification.  These are recorded to an
-  // in-object buffer because these notifications are sent on page load, and we
-  // don't want to slow that down.
-  void LogChildProcessChange(int type,
-                             const content::NotificationSource& source,
-                             const content::NotificationDetails& details);
+  // Returns reference to ChildProcessStats corresponding to |data|.
+  ChildProcessStats& GetChildProcessStats(
+      const content::ChildProcessData& data);
 
   // Logs the number of keywords.
   void LogKeywordCount(size_t keyword_count);
 
   // Saves plugin-related updates from the in-object buffer to Local State
   // for retrieval next time we send a Profile log (generally next launch).
   void RecordPluginChanges(PrefService* pref);
 
   // Records state that should be periodically saved, like uptime and
   // buffered plugin stability statistics.
@@ skipping 77 matching lines @@
   // A number that identifies the how many times the app has been launched.
   int session_id_;
 
   // Maps WebContentses (corresponding to tabs) or Browsers (corresponding to
   // Windows) to a unique integer that we will use to identify them.
   // |next_window_id_| is used to track which IDs we have used so far.
   typedef std::map<uintptr_t, int> WindowMap;
   WindowMap window_map_;
   int next_window_id_;
 
-  // Buffer of child process notifications for quick access.  See
-  // ChildProcessStats documentation above for more details.
-  struct ChildProcessStats;
+  // Buffer of child process notifications for quick access.
   std::map<string16, ChildProcessStats> child_process_stats_buffer_;
 
   // Weak pointers factory used to post task on different threads. All weak
   // pointers managed by this factory have the same lifetime as MetricsService.
   base::WeakPtrFactory<MetricsService> self_ptr_factory_;
 
   // Weak pointers factory used for saving state. All weak pointers managed by
   // this factory are invalidated in ScheduleNextStateSave.
   base::WeakPtrFactory<MetricsService> state_saver_factory_;
 
@@ skipping 38 matching lines @@
   friend class extensions::ExtensionDownloader;
   friend class extensions::ManifestFetchData;
 
   // Returns true if prefs::kMetricsReportingEnabled is set.
   static bool IsMetricsReportingEnabled();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MetricsServiceHelper);
 };
 
 #endif  // CHROME_BROWSER_METRICS_METRICS_SERVICE_H_