Preparation CL for adding crash metrics UMA counters to ChromeFrame. Basicall...

chrome/browser/metrics/metrics_service.h

 // Copyright (c) 2010 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 <list>
 #include <map>
 #include <set>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
 #include "base/histogram.h"
 #include "base/scoped_ptr.h"
 #include "base/values.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/common/child_process_info.h"
+#include "chrome/common/metrics_helpers.h"
 #include "chrome/common/net/url_fetcher.h"
 #include "chrome/common/notification_registrar.h"
 #include "webkit/glue/plugins/webplugininfo.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/external_metrics.h"
 #endif
 
 class BookmarkModel;
 class BookmarkNode;
@@ skipping 29 matching lines @@
 
   // The number of instances of this child process that have been created.
   // An instance is a DOM object rendered by this child process during a page
   // load.
   int instances;
 
   ChildProcessInfo::ProcessType process_type;
 };
 
 class MetricsService : public NotificationObserver,
-                       public URLFetcher::Delegate {
+                       public URLFetcher::Delegate,
+                       public MetricsServiceBase {
  public:
   MetricsService();
   virtual ~MetricsService();
 
   // Sets whether the user permits uploading.  The argument of this function
   // should match the checkbox in Options.
   void SetUserPermitsUpload(bool enabled);
 
   // Start/stop the metrics recording and uploading machine.  These should be
   // used on startup and when the user clicks the checkbox in the prefs.
@@ skipping 59 matching lines @@
   enum State {
     INITIALIZED,            // Constructor was called.
     INIT_TASK_SCHEDULED,    // Waiting for deferred init tasks to complete.
     INIT_TASK_DONE,         // Waiting for timer to send initial log.
     INITIAL_LOG_READY,      // Initial log generated, and waiting for reply.
     SEND_OLD_INITIAL_LOGS,  // Sending unsent logs from previous session.
     SENDING_OLD_LOGS,       // Sending unsent logs from previous session.
     SENDING_CURRENT_LOGS,   // Sending standard current logs as they acrue.
   };
 
-  // Maintain a map of histogram names to the sample stats we've sent.
-  typedef std::map<std::string, Histogram::SampleSet> LoggedSampleMap;
-
   class InitTask;
   class InitTaskComplete;
 
   // Callback to let us know that the init task is done.
   void OnInitTaskComplete(
       const std::string& hardware_class,
       const std::vector<WebPluginInfo>& plugins);
 
   // When we start a new version of Chromium (different from our last run), we
   // need to discard the old crash stats so that we don't attribute crashes etc.
@@ skipping 45 matching lines @@
   // make a change, call ScheduleNextStateSave() instead.
   void SaveLocalState();
 
   // Called to start recording user experience metrics.
   // Constructs a new, empty current_log_.
   void StartRecording();
 
   // Called to stop recording user experience metrics.  The caller takes
   // ownership of the resulting MetricsLog object via the log parameter,
   // or passes in NULL to indicate that the log should simply be deleted.
-  void StopRecording(MetricsLog** log);
+  void StopRecording(MetricsLogBase** log);
 
   // Deletes pending_log_ and current_log_, and pushes their text into the
   // appropriate unsent_log vectors.  Called when Chrome shuts down.
   void PushPendingLogsToUnsentLists();
 
   // Save the pending_log_text_ persistently in a pref for transmission when we
   // next run.  Note that IF this text is "too large," we just dicard it.
   void PushPendingLogTextToUnsentOngoingLogs();
 
   // Start timer for next log transmission.
@@ skipping 11 matching lines @@
   // Takes whatever log should be uploaded next (according to the state_)
   // and makes it the pending log.  If pending_log_ is not NULL,
   // MakePendingLog does nothing and returns.
   void MakePendingLog();
 
   // Determines from state_ and permissions set out by the server and by
   // the user whether the pending_log_ should be sent or discarded.  Called by
   // TryToStartTransmission.
   bool TransmissionPermitted() const;
 
-  // Check to see if there is a log that needs to be, or is being, transmitted.
-  bool pending_log() const {
-    return pending_log_ || !pending_log_text_.empty();
-  }
   // Check to see if there are any unsent logs from previous sessions.
   bool unsent_logs() const {
     return !unsent_initial_logs_.empty() || !unsent_ongoing_logs_.empty();
   }
   // Record stats, client ID, Session ID, etc. in a special "first" log.
   void PrepareInitialLog();
   // Pull copies of unsent logs from prefs into instance variables.
   void RecallUnsentLogs();
   // Convert pending_log_ to XML in pending_log_text_ for transmission.
   void PreparePendingLogText();
 
   // Convert pending_log_ to XML, compress it, and prepare to pass to server.
   // Upon return, current_fetch_ should be reset with its upload data set to
   // a compressed copy of the pending log.
   void PrepareFetchWithPendingLog();
 
-  // Discard pending_log_, and clear pending_log_text_. Called after processing
-  // of this log is complete.
-  void DiscardPendingLog();
-  // Compress the report log in input using bzip2, store the result in output.
-  bool Bzip2Compress(const std::string& input, std::string* output);
   // Implementation of URLFetcher::Delegate. Called after transmission
   // completes (either successfully or with failure).
   virtual void OnURLFetchComplete(const URLFetcher* source,
                                   const GURL& url,
                                   const URLRequestStatus& status,
                                   int response_code,
                                   const ResponseCookies& cookies,
                                   const std::string& data);
 
   // Called by OnURLFetchComplete to handle the case when the server returned
@@ skipping 92 matching lines @@
   void RecordPluginChanges(PrefService* pref);
 
   // Records state that should be periodically saved, like uptime and
   // buffered plugin stability statistics.
   void RecordCurrentState(PrefService* pref);
 
   // Requests all renderers to send their histograms back for
   // collecting stats from renderers.
   void CollectRendererHistograms();
 
-  // Record complete list of histograms into the current log.
-  // Called when we close a log.
-  void RecordCurrentHistograms();
-
-  // Record a specific histogram .
-  void RecordHistogram(const Histogram& histogram);
-
   // Logs the initiation of a page load
   void LogLoadStarted();
 
   // Records a page load notification.
   void LogLoadComplete(NotificationType type,
                        const NotificationSource& source,
                        const NotificationDetails& details);
 
   // Checks whether a notification can be logged.
   bool CanLogNotification(NotificationType type,
@@ skipping 27 matching lines @@
 
   // 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<WebPluginInfo> plugins_;
 
-  // A log that we are currently transmiting, or about to try to transmit.
-  MetricsLog* pending_log_;
-
-  // An alternate form of pending_log_.  We persistently save this text version
-  // into prefs if we can't transmit it.  As a result, sometimes all we have is
-  // the text version (recalled from a previous session).
-  std::string pending_log_text_;
-
   // The outstanding transmission appears as a URL Fetch operation.
   scoped_ptr<URLFetcher> current_fetch_;
 
-  // The log that we are still appending to.
-  MetricsLog* current_log_;
-
   // The URL for the metrics server.
   std::wstring server_url_;
 
   // The identifier that's sent to the server with the log reports.
   std::string client_id_;
 
   // Whether the MetricsService object has received any notifications since
   // the last time a transmission was sent.
   bool idle_since_last_transmission_;
 
@@ skipping 21 matching lines @@
   // ChildProcessStats documentation above for more details.
   std::map<std::wstring, ChildProcessStats> child_process_stats_buffer_;
 
   ScopedRunnableMethodFactory<MetricsService> log_sender_factory_;
   ScopedRunnableMethodFactory<MetricsService> state_saver_factory_;
 
   // Dictionary containing all the profile specific metrics. This is set
   // at creation time from the prefs.
   scoped_ptr<DictionaryValue> profile_dictionary_;
 
-  // For histograms, record what we've already logged (as a sample for each
-  // histogram) so that we can send only the delta with the next log.
-  MetricsService::LoggedSampleMap logged_samples_;
-
   // The interval between consecutive log transmissions (to avoid hogging the
   // outbound network link).  This is usually also the duration for which we
   // build up a log, but if other unsent-logs from previous sessions exist, we
   // quickly transmit those unsent logs while we continue to build a log.
   base::TimeDelta interlog_duration_;
 
   // The maximum number of events which get transmitted in a log.  This defaults
   // to a constant and otherwise is provided by the UMA server in the server
   // response data.
   int log_event_limit_;
@@ skipping 14 matching lines @@
 #endif
 
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, ClientIdGeneratesAllZeroes);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, ClientIdGeneratesCorrectly);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, ClientIdCorrectlyFormatted);
 
   DISALLOW_COPY_AND_ASSIGN(MetricsService);
 };
 
 #endif  // CHROME_BROWSER_METRICS_METRICS_SERVICE_H_