Create PluginMetricsProvider class.

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_
 
@@ skipping 23 matching lines @@
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/user_metrics.h"
 #include "net/url_request/url_fetcher_delegate.h"
 
 class ChromeBrowserMetricsServiceObserver;
 class GoogleUpdateMetricsProviderWin;
 class MetricsReportingScheduler;
 class PrefService;
 class PrefRegistrySimple;
 class Profile;
+class PluginMetricsProvider;
 class TemplateURLService;
 
 namespace {
 class CrashesDOMHandler;
 class FlashDOMHandler;
 }
 
 namespace base {
 class DictionaryValue;
 class MessageLoopProxy;
 }
 
 namespace variations {
 struct ActiveGroupId;
 }
 
 namespace content {
 class RenderProcessHost;
 class WebContents;
-struct WebPluginInfo;
 }
 
 namespace extensions {
 class ExtensionDownloader;
 class ManifestFetchData;
 class MetricsPrivateGetIsCrashReportingEnabledFunction;
 }
 
 namespace metrics {
 class MetricsServiceClient;
@@ skipping 111 matching lines @@
   // 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;
 
   // This should be called when the application is not idle, i.e. the user seems
   // to be interacting with the application.
   void OnApplicationNotIdle();
 
@@ skipping 78 matching lines @@
     SENDING_INITIAL_METRICS_LOG,    // Initial metrics log being sent.
     SENDING_OLD_LOGS,               // Sending unsent logs from last session.
     SENDING_CURRENT_LOGS,           // Sending ongoing logs as they accrue.
   };
 
   enum ShutdownCleanliness {
     CLEANLY_SHUTDOWN = 0xdeadbeef,
     NEED_TO_SHUTDOWN = ~CLEANLY_SHUTDOWN
   };
 
-  struct ChildProcessStats;
-
   typedef std::vector<SyntheticTrialGroup> SyntheticTrialGroups;
 
   // 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
-  // launching a task to gather Google Update statistics.
-  void OnInitTaskGotPluginInfo(
-      const std::vector<content::WebPluginInfo>& plugins);
+  // Called after the Plugin init task has been completed that continues the
+  // init task by launching a task to gather Google Update statistics.
+  void OnInitTaskGotPluginInfo();
 
   // Called after GoogleUpdate init task has been completed that continues the
   // init task by loading profiler data.
   void OnInitTaskGotGoogleUpdateData();
 
   void OnUserAction(const std::string& action);
 
   // TrackingSynchronizerObserver:
   virtual void ReceivedProfilerData(
       const tracked_objects::ProcessDataSnapshot& process_data,
@@ skipping 103 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();
 
-  // Returns reference to ChildProcessStats corresponding to |data|.
-  ChildProcessStats& GetChildProcessStats(
-      const content::ChildProcessData& data);
-
-  // 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.
   void RecordCurrentState(PrefService* pref);
 
   // Logs the initiation of a page load and uses |web_contents| to do
   // additional logging of the type of page loaded.
   void LogLoadStarted(content::WebContents* web_contents);
 
   // Checks whether events should currently be logged.
   bool ShouldLogEvents();
@@ skipping 41 matching lines @@
 
   // Whether the initial stability log has been recorded during startup.
   bool has_initial_stability_log_;
 
   // Chrome OS hardware class (e.g., hardware qualification ID). This
   // class identifies the configured system components such as CPU,
   // WiFi adapter, etc.  For non Chrome OS hosts, this will be an
   // empty string.
   std::string hardware_class_;
 
-  // The list of plugins which was retrieved on the file thread.
-  std::vector<content::WebPluginInfo> plugins_;
+#if defined(ENABLE_PLUGINS)
+  PluginMetricsProvider* plugin_metrics_provider_;
+#endif
 
 #if defined(OS_WIN)
   GoogleUpdateMetricsProviderWin* google_update_metrics_provider_;
 #endif
 
   // The initial metrics log, used to record startup metrics (histograms and
   // profiler data). Note that if a crash occurred in the previous session, an
   // initial stability log may be sent before this.
   scoped_ptr<MetricsLog> initial_metrics_log_;
 
   // The outstanding transmission appears as a URL Fetch operation.
   scoped_ptr<net::URLFetcher> current_fetch_;
 
   // Whether the MetricsService object has received any notifications since
   // the last time a transmission was sent.
   bool idle_since_last_transmission_;
 
   // 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.
-  std::map<base::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_;
 
   // The scheduler for determining when uploads should happen.
   scoped_ptr<MetricsReportingScheduler> scheduler_;
@@ skipping 67 matching lines @@
 
   // Registers/unregisters |observer| to receive MetricsLog notifications
   // from metrics service.
   static void AddMetricsServiceObserver(MetricsServiceObserver* observer);
   static void RemoveMetricsServiceObserver(MetricsServiceObserver* observer);
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MetricsServiceHelper);
 };
 
 #endif  // CHROME_BROWSER_METRICS_METRICS_SERVICE_H_