Split a MetricsLogStore object out of MetricsLogManager.

components/metrics/persisted_logs.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.
 
 #ifndef COMPONENTS_METRICS_PERSISTED_LOGS_H_
 #define COMPONENTS_METRICS_PERSISTED_LOGS_H_
 
 #include <stddef.h>
 
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/values.h"
+#include "components/metrics/log_store.h"
 
 class PrefService;
 
 namespace metrics {
 
 class PersistedLogsMetrics;
 
 // Maintains a list of unsent logs that are written and restored from disk.
-class PersistedLogs {
+class PersistedLogs : public LogStore {
  public:
-  // Used to produce a histogram that keeps track of the status of recalling
-  // persisted per logs.
-  enum LogReadStatus {
-    RECALL_SUCCESS,         // We were able to correctly recall a persisted log.
-    LIST_EMPTY,             // Attempting to recall from an empty list.
-    LIST_SIZE_MISSING,      // Failed to recover list size using GetAsInteger().
-    LIST_SIZE_TOO_SMALL,    // Too few elements in the list (less than 3).
-    LIST_SIZE_CORRUPTION,   // List size is not as expected.
-    LOG_STRING_CORRUPTION,  // Failed to recover log string using GetAsString().
-    CHECKSUM_CORRUPTION,    // Failed to verify checksum.
-    CHECKSUM_STRING_CORRUPTION,  // Failed to recover checksum string using
-                                 // GetAsString().
-    DECODE_FAIL,            // Failed to decode log.
-    DEPRECATED_XML_PROTO_MISMATCH,  // The XML and protobuf logs have
-                                    // inconsistent data.
-    END_RECALL_STATUS       // Number of bins to use to create the histogram.
-  };
-
   // Constructs a PersistedLogs that stores data in |local_state| under the
   // preference |pref_name|.
   // Calling code is responsible for ensuring that the lifetime of |local_state|
   // is longer than the lifetime of PersistedLogs.
   //
   // When saving logs to disk, stores either the first |min_log_count| logs, or
   // at least |min_log_bytes| bytes of logs, whichever is greater.
   //
   // If the optional |max_log_size| parameter is non-zero, all logs larger than
   // that limit will be skipped when writing to disk.
   PersistedLogs(std::unique_ptr<PersistedLogsMetrics> metrics,
                 PrefService* local_state,
                 const char* pref_name,
                 size_t min_log_count,
                 size_t min_log_bytes,
                 size_t max_log_size);
   ~PersistedLogs();
 
-  // Write list to storage.
-  void SerializeLogs() const;
-
-  // Reads the list from the preference.
-  LogReadStatus DeserializeLogs();
+  // LogStore:

[bcwhite, 2017/02/22 16:25:09]

metrics::LogStore:

[Steven Holte, 2017/02/22 20:35:50]

Done.

+  bool has_unsent_logs() const override;
+  bool has_staged_log() const override;
+  const std::string& staged_log() const override;
+  const std::string& staged_log_hash() const override;
+  void StageNextLog() override;
+  void DiscardStagedLog() override;
+  void PersistUnsentLogs() const override;
+  void LoadPersistedUnsentLogs() override;
 
   // Adds a log to the list.
   void StoreLog(const std::string& log_data);
 
-  // Stages the most recent log.  The staged_log will remain the same even if
-  // additional logs are added.
-  void StageLog();
-
-  // Remove the staged log.
-  void DiscardStagedLog();
-
   // Delete all logs, in memory and on disk.
   void Purge();
 
-  // True if a log has been staged.
-  bool has_staged_log() const { return staged_log_index_ != -1; }
-
-  // Returns the element in the front of the list.
-  const std::string& staged_log() const {
-    DCHECK(has_staged_log());
-    return list_[staged_log_index_].compressed_log_data;
-  }
-
-  // Returns the element in the front of the list.
-  const std::string& staged_log_hash() const {
-    DCHECK(has_staged_log());
-    return list_[staged_log_index_].hash;
-  }
-
   // Returns the timestamp of the element in the front of the list.
-  const std::string& staged_log_timestamp() const {
-    DCHECK(has_staged_log());
-    return list_[staged_log_index_].timestamp;
-  }
+  const std::string& staged_log_timestamp() const;
 
   // The number of elements currently stored.
   size_t size() const { return list_.size(); }
 
-  // True if there are no stored logs.
-  bool empty() const { return list_.empty(); }
-
  private:
   // Writes the list to the ListValue.
   void WriteLogsToPrefList(base::ListValue* list) const;
 
   // Reads the list from the ListValue.
-  LogReadStatus ReadLogsFromPrefList(const base::ListValue& list);
+  void ReadLogsFromPrefList(const base::ListValue& list);
 
   // An object for recording UMA metrics.
   std::unique_ptr<PersistedLogsMetrics> metrics_;
 
   // A weak pointer to the PrefService object to read and write the preference
   // from.  Calling code should ensure this object continues to exist for the
   // lifetime of the PersistedLogs object.
   PrefService* local_state_;
 
   // The name of the preference to serialize logs to/from.
@@ skipping 32 matching lines @@
   // The index and type of the log staged for upload. If nothing has been
   // staged, the index will be -1.
   int staged_log_index_;
 
   DISALLOW_COPY_AND_ASSIGN(PersistedLogs);
 };
 
 }  // namespace metrics
 
 #endif  // COMPONENTS_METRICS_PERSISTED_LOGS_H_