Begin to separate the MetricsService logic for creating vs uploading logs

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"
@@ skipping 10 matching lines @@
  public:
   MetricsLogManager();
   ~MetricsLogManager();
 
   // Stores both XML and protocol buffer serializations for a log.
   struct SerializedLog {
    public:
     // Exposed to reduce code churn as we transition from the XML pipeline to
     // the protocol buffer pipeline.
     bool empty() const;
+    void swap(SerializedLog& log);

[Ilya Sherman, 2012/02/29 18:58:51]

nit: I think the typical Chromium style is to pass |log| as a pointer rather
than as a reference; but if you prefer to keep this style to match the signature
for std::string::swap, that's probably fine too.

[stuartmorgan, 2012/02/29 19:04:01]

Yep, that was the intent. I went back and forth, and decided that since it's
temporary code designed to minimize the friction of having this class instead of
the std::string we'll be (I assume) going back to, it was easier this way.

 
     std::string xml;
     std::string proto;
   };
 
-  // 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);
+  enum LogType {
+    INITIAL_LOG,  // The first log of a session.
+    ONGOING_LOG,  // Subsequent logs in a session.
+  };
+
+  // Takes ownership of |log|, which has type |log_type|, and makes it the
+  // current_log. This should only be called if there is not a current log.
+  void BeginLoggingWithLog(MetricsLogBase* log, LogType log_type);
 
   // 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();
+  // Closes current_log(), compresses it, and stores the compressed log for
+  // later, leaving current_log() NULL.
+  void FinishCurrentLog();
+
+  // Returns true if there are any logs waiting to be uploaded.
+  bool has_unsent_logs() const {
+    return !unsent_initial_logs_.empty() || !unsent_ongoing_logs_.empty();
+  }
+
+  // Populates staged_log_text() with the next stored log to send.
+  // Should only be called if has_unsent_logs() is true.
+  void StageNextLogForUpload();
 
   // 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;
 
   // Returns true if there is a protobuf log that needs to be uploaded.
   // In the case that an XML upload needs to be re-issued due to a previous
-  // failure, |has_staged_log()| will return true while this returns false.
+  // failure, has_staged_log() will return true while this returns false.
   bool has_staged_log_proto() const;
 
   // 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 SerializedLog& staged_log_text() const {
     return staged_log_text_;
   }
 
   // Discards the staged log (both the XML and the protobuf data).
   void DiscardStagedLog();
 
   // Discards the protobuf data in the staged log.
   // This is useful to prevent needlessly re-issuing successful protobuf uploads
   // due to XML upload failures.
   void DiscardStagedLogProto();
 
   // 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
   // design issue in initial log writing; that should be fixed, and pause/resume
   // removed.
   void PauseCurrentLog();
 
-  // Restores the previously paused log (if any) to current_log.
+  // Restores the previously paused log (if any) to current_log().
   // This should only be called if there is not a current log.
   void ResumePausedLog();
 
-  // Returns true if there are any logs left over from previous sessions that
-  // need to be uploaded.
-  bool has_unsent_logs() const {
-    return !unsent_initial_logs_.empty() || !unsent_ongoing_logs_.empty();
-  }
+  // Saves the staged log, then clears staged_log().
+  // This can only be called if has_staged_log() is true.
+  void StoreStagedLogAsUnsent();
 
-  enum LogType {
-    INITIAL_LOG,  // The first log of a session.
-    ONGOING_LOG,  // Subsequent logs in a session.
-  };
-
-  // Saves the staged log as the given type (or discards it in accordance with
-  // set_max_ongoing_log_store_size), then clears the staged log.
-  // This can only be called after StageCurrentLogForUpload.
-  void StoreStagedLogAsUnsent(LogType log_type);
-
-  // Populates staged_log_text with the next stored log to send.
-  void StageNextStoredLogForUpload();
-
-  // Sets the threshold for how large an onging log can be and still be stored.
-  // Ongoing logs larger than this will be discarded. 0 is interpreted as no
-  // limit.
+  // Sets the threshold for how large an onging log can be and still be written
+  // to persistant storage. Ongoing logs larger than this will be discarded
+  // before persisting. 0 is interpreted as no limit.
   void set_max_ongoing_log_store_size(size_t max_size) {
     max_ongoing_log_store_size_ = max_size;
   }
 
   // Interface for a utility class to serialize and deserialize logs for
   // persistent storage.
   class LogSerializer {
    public:
     virtual ~LogSerializer() {}
 
@@ skipping 16 matching lines @@
 
   // 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_xml_log_text_|.
-  void CompressStagedLog();
+  // Saves |log_text| as the given type (or discards it in accordance with
+  // |max_ongoing_log_store_size_|).
+  // NOTE: This clears the contents of |log_text| (to avoid an expensive
+  // string copy), so the log should be discarded after this call.
+  void StoreLog(SerializedLog* log_text, LogType log_type);
+
+  // Compresses current_log_ into compressed_log.
+  void CompressCurrentLog(SerializedLog* compressed_log);
 
   // 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_;
+  LogType current_log_type_;
 
   // 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_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 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.
   SerializedLog staged_log_text_;
+  LogType staged_log_type_;
 
   // 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<SerializedLog> unsent_initial_logs_;
   std::vector<SerializedLog> unsent_ongoing_logs_;
 
   size_t max_ongoing_log_store_size_;
 
   DISALLOW_COPY_AND_ASSIGN(MetricsLogManager);
 };
 
 #endif  // CHROME_COMMON_METRICS_METRICS_LOG_MANAGER_H_