Upload UMA data using protocol buffers.

chrome/browser/metrics/metrics_log_serializer.cc

 // Copyright (c) 2011 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.
 
 #include "chrome/browser/metrics/metrics_log_serializer.h"
 
+#include <utility>
+
 #include "base/base64.h"
 #include "base/md5.h"
 #include "base/metrics/histogram.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/common/pref_names.h"
 
+namespace {
+
 // The number of "initial" logs we're willing to save, and hope to send during
 // a future Chrome session.  Initial logs contain crash stats, and are pretty
 // small.
-static const size_t kMaxInitialLogsPersisted = 20;
+const size_t kMaxInitialLogsPersisted = 20;
 
 // The number of ongoing logs we're willing to save persistently, and hope to
 // send during a this or future sessions.  Note that each log may be pretty
 // large, as presumably the related "initial" log wasn't sent (probably nothing
 // was, as the user was probably off-line).  As a result, the log probably kept
 // accumulating while the "initial" log was stalled, and couldn't be sent.  As a
 // result, we don't want to save too many of these mega-logs.
 // A "standard shutdown" will create a small log, including just the data that
 // was not yet been transmitted, and that is normal (to have exactly one
 // ongoing_log_ at startup).
-static const size_t kMaxOngoingLogsPersisted = 8;
+const size_t kMaxOngoingLogsPersisted = 8;
 
 // We append (2) more elements to persisted lists: the size of the list and a
 // checksum of the elements.
-static const size_t kChecksumEntryCount = 2;
+const size_t kChecksumEntryCount = 2;
 
-namespace {
 // TODO(ziadh): This is here temporarily for a side experiment. Remove later
 // on.
 enum LogStoreStatus {
   STORE_SUCCESS,    // Successfully presisted log.
   ENCODE_FAIL,      // Failed to encode log.
   COMPRESS_FAIL,    // Failed to compress log.
   END_STORE_STATUS  // Number of bins to use to create the histogram.
 };
 
 MetricsLogSerializer::LogReadStatus MakeRecallStatusHistogram(
     MetricsLogSerializer::LogReadStatus status) {
   UMA_HISTOGRAM_ENUMERATION("PrefService.PersistentLogRecall", status,
                             MetricsLogSerializer::END_RECALL_STATUS);
   return status;
 }
 
 // TODO(ziadh): Remove this when done with experiment.
 void MakeStoreStatusHistogram(LogStoreStatus status) {
   UMA_HISTOGRAM_ENUMERATION("PrefService.PersistentLogStore2", status,
                             END_STORE_STATUS);
 }
+
 }  // namespace
 
 
 MetricsLogSerializer::MetricsLogSerializer() {}
 
 MetricsLogSerializer::~MetricsLogSerializer() {}
 
-void MetricsLogSerializer::SerializeLogs(const std::vector<std::string>& logs,
-                                         MetricsLogManager::LogType log_type) {
+void MetricsLogSerializer::SerializeLogs(
+    const std::vector<std::pair<std::string, std::string> >& logs,
+    MetricsLogManager::LogType log_type) {
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
-  const char* pref = NULL;
+  const char* pref_xml = NULL;
+  const char* pref_proto = NULL;
   size_t max_store_count = 0;
   switch (log_type) {
     case MetricsLogManager::INITIAL_LOG:
-      pref = prefs::kMetricsInitialLogs;
+      pref_xml = prefs::kMetricsInitialLogsXml;
+      pref_proto = prefs::kMetricsInitialLogsProto;
       max_store_count = kMaxInitialLogsPersisted;
       break;
     case MetricsLogManager::ONGOING_LOG:
-      pref = prefs::kMetricsOngoingLogs;
+      pref_xml = prefs::kMetricsOngoingLogsXml;
+      pref_proto = prefs::kMetricsOngoingLogsProto;
       max_store_count = kMaxOngoingLogsPersisted;
       break;
     default:
       NOTREACHED();
       return;
   };
-  ListPrefUpdate update(local_state, pref);
-  ListValue* pref_list = update.Get();
-  WriteLogsToPrefList(logs, max_store_count, pref_list);
+
+  std::vector<std::string> logs_xml(logs.size());
+  std::vector<std::string> logs_proto(logs.size());
+  for (size_t i = 0; i < logs.size(); ++i) {
+    logs_xml[i] = logs[i].first;
+    logs_proto[i] = logs[i].second;
+  }
+
+  // Write the XML version.
+  ListPrefUpdate update_xml(local_state, pref_xml);
+  ListValue* pref_list_xml = update_xml.Get();
+  WriteLogsToPrefList(logs_xml, max_store_count, pref_list_xml);
+
+  // Write the protobuf version.
+  ListPrefUpdate update_proto(local_state, pref_proto);
+  ListValue* pref_list_proto = update_proto.Get();
+  WriteLogsToPrefList(logs_proto, max_store_count, pref_list_proto);
 }
 
-void MetricsLogSerializer::DeserializeLogs(MetricsLogManager::LogType log_type,
-                                           std::vector<std::string>* logs) {
+void MetricsLogSerializer::DeserializeLogs(
+    MetricsLogManager::LogType log_type,
+    std::vector<std::pair<std::string, std::string> >* logs) {
   DCHECK(logs);
   PrefService* local_state = g_browser_process->local_state();
   DCHECK(local_state);
 
-  const char* pref = (log_type == MetricsLogManager::INITIAL_LOG) ?
-      prefs::kMetricsInitialLogs : prefs::kMetricsOngoingLogs;
-  const ListValue* unsent_logs = local_state->GetList(pref);
-  ReadLogsFromPrefList(*unsent_logs, logs);
+  const char* pref_xml;
+  const char* pref_proto;
+  if (log_type == MetricsLogManager::INITIAL_LOG) {
+    pref_xml = prefs::kMetricsInitialLogsXml;
+    pref_proto = prefs::kMetricsInitialLogsProto;
+  } else {
+    pref_xml = prefs::kMetricsOngoingLogsXml;
+    pref_proto = prefs::kMetricsOngoingLogsProto;
+  }
+
+  const ListValue* unsent_logs_xml = local_state->GetList(pref_xml);
+  const ListValue* unsent_logs_proto = local_state->GetList(pref_proto);
+  std::vector<std::string> logs_xml;
+  std::vector<std::string> logs_proto;
+  // TODO(isherman): Error reporting...

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

(Will address this TODO and the others in this file in a follow-up Patch Set.)

+  ReadLogsFromPrefList(*unsent_logs_xml, &logs_xml);
+  ReadLogsFromPrefList(*unsent_logs_proto, &logs_proto);
+
+  if (logs_xml.size() != logs_proto.size()) {
+    // TODO(isherman): ...
+    return;
+  }
+
+  logs->resize(logs_xml.size());
+  for (size_t i = 0; i < logs->size(); ++i) {
+    (*logs)[i] = std::make_pair(logs_xml[i], logs_proto[i]);
+  }
 }
 
 // static
 void MetricsLogSerializer::WriteLogsToPrefList(
     const std::vector<std::string>& local_list,
     const size_t kMaxLocalListSize,
     ListValue* list) {
   list->Clear();
   size_t start = 0;
   if (local_list.size() > kMaxLocalListSize)
     start = local_list.size() - kMaxLocalListSize;
-  DCHECK(start <= local_list.size());
+  DCHECK_LE(start, local_list.size());
   if (local_list.size() <= start)
     return;
 
   // Store size at the beginning of the list.
   list->Append(Value::CreateIntegerValue(local_list.size() - start));
 
   base::MD5Context ctx;
   base::MD5Init(&ctx);
   std::string encoded_log;
   for (std::vector<std::string>::const_iterator it = local_list.begin() + start;
        it != local_list.end(); ++it) {
     // We encode the compressed log as Value::CreateStringValue() expects to
     // take a valid UTF8 string.
     if (!base::Base64Encode(*it, &encoded_log)) {
+      // TODO(isherman): Is it ok for xml and protobuf encoding failures to mix?
       MakeStoreStatusHistogram(ENCODE_FAIL);
       list->Clear();
       return;
     }
     base::MD5Update(&ctx, encoded_log);
     list->Append(Value::CreateStringValue(encoded_log));
   }
 
   // Append hash to the end of the list.
   base::MD5Digest digest;
@@ skipping 55 matching lines @@
   if (!valid) {
     local_list->clear();
     return MakeRecallStatusHistogram(CHECKSUM_STRING_CORRUPTION);
   }
   if (recovered_md5 != base::MD5DigestToBase16(digest)) {
     local_list->clear();
     return MakeRecallStatusHistogram(CHECKSUM_CORRUPTION);
   }
   return MakeRecallStatusHistogram(RECALL_SUCCESS);
 }