Upload UMA data using protocol buffers.

chrome/common/metrics/metrics_log_manager.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.
 
 #ifndef CHROME_COMMON_METRICS_METRICS_LOG_MANAGER_H_
 #define CHROME_COMMON_METRICS_METRICS_LOG_MANAGER_H_
 #pragma once
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 
 #include <string>
+#include <utility>
 #include <vector>
 
 class MetricsLogBase;
 
 // Manages all the log objects used by a MetricsService implementation. Keeps
 // track of both an in progress log and a log that is staged for uploading as
 // text, as well as saving logs to, and loading logs from, persistent storage.
 class MetricsLogManager {
  public:
   MetricsLogManager();
   ~MetricsLogManager();
 
   // Takes ownership of |log|, and makes it the current_log.
   // This should only be called if there is not a current log.
   void BeginLoggingWithLog(MetricsLogBase* log);
 
   // Returns the in-progress log.
   MetricsLogBase* current_log() { return current_log_.get(); }
 
   // Closes |current_log| and stages it for upload, leaving |current_log| NULL.
   void StageCurrentLogForUpload();
 
   // Returns true if there is a log that needs to be, or is being, uploaded.
   // Note that this returns true even if compressing the log text failed.
   bool has_staged_log() const;
 
-  // The compressed text of the staged log. Empty if there is no staged log,
-  // or if compression of the staged log failed.
-  const std::string& staged_log_text() { return compressed_staged_log_text_; }
+  // The text of the staged log, in compressed XML or protobuf format. Empty if
+  // there is no staged log, or if compression of the staged log failed.
+  const std::string& staged_log_text_xml() const {
+    return staged_log_text_.first;
+  }
+  const std::string& staged_log_text_proto() const {
+    return staged_log_text_.second;
+  }
 
   // Discards the staged log.
   void DiscardStagedLog();
 
   // Closes and discards |current_log|.
   void DiscardCurrentLog();
 
   // Sets current_log to NULL, but saves the current log for future use with
   // ResumePausedLog(). Only one log may be paused at a time.
   // TODO(stuartmorgan): Pause/resume support is really a workaround for a
@@ skipping 32 matching lines @@
   }
 
   // Interface for a utility class to serialize and deserialize logs for
   // persistent storage.
   class LogSerializer {
    public:
     virtual ~LogSerializer() {}
 
     // Serializes |logs| to persistent storage, replacing any previously
     // serialized logs of the same type.
-    virtual void SerializeLogs(const std::vector<std::string>& logs,
-                               LogType log_type) = 0;
+    virtual void SerializeLogs(
+        const std::vector<std::pair<std::string, std::string> >& logs,
+        LogType log_type) = 0;
 
     // Populates |logs| with logs of type |log_type| deserialized from
     // persistent storage.
-    virtual void DeserializeLogs(LogType log_type,
-                                 std::vector<std::string>* logs) = 0;
+    virtual void DeserializeLogs(
+        LogType log_type,
+        std::vector<std::pair<std::string, std::string> >* logs) = 0;
   };
 
   // Sets the serializer to use for persisting and loading logs; takes ownership
   // of |serializer|.
   void set_log_serializer(LogSerializer* serializer) {
     log_serializer_.reset(serializer);
   }
 
   // Saves any unsent logs to persistent storage using the current log
   // serializer. Can only be called after set_log_serializer.
   void PersistUnsentLogs();
 
   // Loads any unsent logs from persistent storage using the current log
   // serializer. Can only be called after set_log_serializer.
   void LoadPersistedUnsentLogs();
 
  private:
-  // Compresses staged_log_ and stores the result in
-  // compressed_staged_log_text_.
+  // Compresses |staged_log_| and stores the result in
+  // |compressed_staged_xml_log_text_|.
   void CompressStagedLog();
 
   // Compresses the text in |input| using bzip2, store the result in |output|.
   static bool Bzip2Compress(const std::string& input, std::string* output);
 
   // The log that we are still appending to.
   scoped_ptr<MetricsLogBase> current_log_;
 
   // A paused, previously-current log.
   scoped_ptr<MetricsLogBase> paused_log_;
 
   // The log that we are currently transmiting, or about to try to transmit.
   // Note that when using StageNextStoredLogForUpload, this can be NULL while
-  // compressed_staged_log_text_ is non-NULL.
+  // |compressed_staged_xml_log_text_| is non-NULL.
   scoped_ptr<MetricsLogBase> staged_log_;
 
   // Helper class to handle serialization/deserialization of logs for persistent
   // storage. May be NULL.
   scoped_ptr<LogSerializer> log_serializer_;
 
-  // The compressed text of the staged log, ready for upload to the server.
-  std::string compressed_staged_log_text_;
+  // The text representations of the staged log, ready for upload to the server.
+  // The first item in the pair is the compressed XML representation; the second
+  // is the protobuf representation.
+  std::pair<std::string, std::string> staged_log_text_;
 
   // Logs from a previous session that have not yet been sent.
+  // The first item in each pair is the XML representation; the second item is
+  // the protobuf representation.
   // Note that the vector has the oldest logs listed first (early in the
   // vector), and we'll discard old logs if we have gathered too many logs.
-  std::vector<std::string> unsent_initial_logs_;
-  std::vector<std::string> unsent_ongoing_logs_;
+  std::vector<std::pair<std::string, std::string> > unsent_initial_logs_;
+  std::vector<std::pair<std::string, std::string> > unsent_ongoing_logs_;

[Ilya Sherman, 2012/01/28 08:17:20]

Storing these as a vector of pairs of strings is a little yucky -- anyone have
any bright alternative suggestions?  If not, it should be ok, since we're
planning to deprecate the XML pipeline relatively soon...

 
   size_t max_ongoing_log_store_size_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsLogManager);
 };
 
 #endif  // CHROME_COMMON_METRICS_METRICS_LOG_MANAGER_H_