Merge MetricsLog and MetricsLogBase.

components/metrics/metrics_log.h

 // Copyright 2014 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 set of user experience metrics data recorded by
 // the MetricsService.  This is the unit of data that is sent to the server.
 
 #ifndef COMPONENTS_METRICS_METRICS_LOG_H_
 #define COMPONENTS_METRICS_METRICS_LOG_H_
 
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
-#include "components/metrics/metrics_log_base.h"
+#include "base/time/time.h"
+#include "components/metrics/proto/chrome_user_metrics_extension.pb.h"
 
 class PrefRegistrySimple;
 class PrefService;
 
 namespace base {
 class DictionaryValue;
+class HistogramSamples;
 }
 
 namespace content {
 struct WebPluginInfo;
 }
 
 namespace metrics {
 class MetricsProvider;
 class MetricsServiceClient;
 }
 
 namespace tracked_objects {
 struct ProcessDataSnapshot;
 }
 
 namespace variations {
 struct ActiveGroupId;
 }
 
-class MetricsLog : public metrics::MetricsLogBase {
+class MetricsLog {
  public:
+  enum LogType {
+    INITIAL_STABILITY_LOG,  // The initial log containing stability stats.
+    ONGOING_LOG,            // Subsequent logs in a session.
+  };
+
   // Creates a new metrics log of the specified type.
   // |client_id| is the identifier for this profile on this installation
   // |session_id| is an integer that's incremented on each application launch
   // |client| is used to interact with the embedder.
   // |local_state| is the PrefService that this instance should use.
   // Note: |this| instance does not take ownership of the |client|, but rather
   // stores a weak pointer to it. The caller should ensure that the |client| is
   // valid for the lifetime of this class.
   MetricsLog(const std::string& client_id,
              int session_id,
              LogType log_type,
              metrics::MetricsServiceClient* client,
              PrefService* local_state);
   virtual ~MetricsLog();
 
   // Registers local state prefs used by this class.
   static void RegisterPrefs(PrefRegistrySimple* registry);
 
+  // Computes the MD5 hash of the given string, and returns the first 8 bytes of
+  // the hash.
+  static uint64 Hash(const std::string& value);
+
+  // Get the GMT buildtime for the current binary, expressed in seconds since
+  // January 1, 1970 GMT.
+  // The value is used to identify when a new build is run, so that previous
+  // reliability stats, from other builds, can be abandoned.
+  static int64 GetBuildTime();
+
+  // Convenience function to return the current time at a resolution in seconds.
+  // This wraps base::TimeTicks, and hence provides an abstract time that is
+  // always incrementing for use in measuring time durations.
+  static int64 GetCurrentTime();
+
+  // Records a user-initiated action.
+  void RecordUserAction(const std::string& key);
+
+  // Record any changes in a given histogram for transmission.
+  void RecordHistogramDelta(const std::string& histogram_name,
+                            const base::HistogramSamples& snapshot);
+
   // Records the current operating environment, including metrics provided by
   // the specified set of |metrics_providers|.  Takes the list of installed
   // plugins, Google Update statistics, and synthetic trial IDs as parameters
   // because those can't be obtained synchronously from the UI thread.
   // A synthetic trial is one that is set up dynamically by code in Chrome. For
   // example, a pref may be mapped to a synthetic trial such that the group
   // is determined by the pref value.
   void RecordEnvironment(
       const std::vector<metrics::MetricsProvider*>& metrics_providers,
       const std::vector<variations::ActiveGroupId>& synthetic_trials);
@@ skipping 14 matching lines @@
   // stats.
   void RecordStabilityMetrics(
       const std::vector<metrics::MetricsProvider*>& metrics_providers,
       base::TimeDelta incremental_uptime,
       base::TimeDelta uptime);
 
   // Records general metrics based on the specified |metrics_providers|.
   void RecordGeneralMetrics(
       const std::vector<metrics::MetricsProvider*>& metrics_providers);
 
+  // Stop writing to this record and generate the encoded representation.
+  // None of the Record* methods can be called after this is called.
+  void CloseLog();
+
+  // Fills |encoded_log| with the serialized protobuf representation of the
+  // record.  Must only be called after CloseLog() has been called.
+  void GetEncodedLog(std::string* encoded_log);
+
   const base::TimeTicks& creation_time() const {
     return creation_time_;
   }
 
+  int num_events() const {
+    return uma_proto_.omnibox_event_size() +
+           uma_proto_.user_action_event_size();
+  }
+
+  LogType log_type() const { return log_type_; }
+
  protected:
-  // Exposed for the sake of mocking in test code.
+  // Exposed for the sake of mocking/accessing in test code.
 
   // Fills |field_trial_ids| with the list of initialized field trials name and
   // group ids.
   virtual void GetFieldTrialIds(
       std::vector<variations::ActiveGroupId>* field_trial_ids) const;
 
+  metrics::ChromeUserMetricsExtension* uma_proto() { return &uma_proto_; }
+  const metrics::ChromeUserMetricsExtension* uma_proto() const {
+    return &uma_proto_;
+  }
+
  private:
-  FRIEND_TEST_ALL_PREFIXES(MetricsLogTest, ChromeOSStabilityData);
-
   // Returns true if the environment has already been filled in by a call to
   // RecordEnvironment() or LoadSavedEnvironmentFromPrefs().
   bool HasEnvironment() const;
 
   // Returns true if the stability metrics have already been filled in by a
   // call to RecordStabilityMetrics().
   bool HasStabilityMetrics() const;
 
   // Within the stability group, write required attributes.
   void WriteRequiredStabilityAttributes(PrefService* pref);
 
   // Within the stability group, write attributes that need to be updated asap
   // and can't be delayed until the user decides to restart chromium.
   // Delaying these stats would bias metrics away from happy long lived
   // chromium processes (ones that don't crash, and keep on running).
   void WriteRealtimeStabilityAttributes(PrefService* pref,
                                         base::TimeDelta incremental_uptime,
                                         base::TimeDelta uptime);
 
+  bool locked() const { return locked_; }

[Ilya Sherman, 2014/06/06 19:37:01]

nit: I think we can just use the member variable directly now; no need for an
accessor.

[Alexei Svitkine (slow), 2014/06/06 21:45:42]

Done.

+
+  // locked_ is true when record has been packed up for sending, and should
+  // no longer be written to.  It is only used for sanity checking and is
+  // not a real lock.
+  bool locked_;
+
+  // The type of the log, i.e. initial or ongoing.
+  const LogType log_type_;
+
+  // Stores the protocol buffer representation for this log.
+  metrics::ChromeUserMetricsExtension uma_proto_;
+
   // Used to interact with the embedder. Weak pointer; must outlive |this|
   // instance.
   metrics::MetricsServiceClient* const client_;
 
   // The time when the current log was created.
   const base::TimeTicks creation_time_;
 
   PrefService* local_state_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsLog);
 };
 
 #endif  // COMPONENTS_METRICS_METRICS_LOG_H_