Merge 49197 - Submitting CL http://codereview.chromium.org/2324001 on behalf ...

chrome/browser/metrics/metrics_log.cc

-// Copyright (c) 2009 The Chromium Authors. All rights reserved.
+// Copyright (c) 2010 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.h"
 
 #include "base/base64.h"
 #include "base/time.h"
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/md5.h"
+#include "base/perftimer.h"
 #include "base/scoped_ptr.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/utf_string_conversions.h"
 #include "base/third_party/nspr/prtime.h"
 #include "chrome/app/chrome_version_info.h"
 #include "chrome/browser/autocomplete/autocomplete.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/pref_service.h"
 #include "chrome/common/logging_chrome.h"
@@ skipping 21 matching lines @@
 // static
 void MetricsLog::RegisterPrefs(PrefService* local_state) {
   local_state->RegisterListPref(prefs::kStabilityPluginStats);
 }
 
 MetricsLog::MetricsLog(const std::string& client_id, int session_id)
     : start_time_(Time::Now()),
       client_id_(client_id),
       session_id_(IntToString(session_id)),
       locked_(false),
+      doc_(NULL),
       buffer_(NULL),
       writer_(NULL),
       num_events_(0) {
 
   buffer_ = xmlBufferCreate();
   DCHECK(buffer_);
 
-  writer_ = xmlNewTextWriterMemory(buffer_, 0);
+#if defined(OS_CHROMEOS)
+  writer_ = xmlNewTextWriterDoc(&doc_, /* compression */ 0);
+#else
+  writer_ = xmlNewTextWriterMemory(buffer_, /* compression */ 0);
+#endif  // OS_CHROMEOS
   DCHECK(writer_);
 
   int result = xmlTextWriterSetIndent(writer_, 2);
   DCHECK_EQ(0, result);
 
   StartElement("log");
   WriteAttribute("clientid", client_id_);
   WriteInt64Attribute("buildtime", GetBuildTime());
   WriteAttribute("appversion", GetVersionString());
-
-  DCHECK_GE(result, 0);
 }
 
 MetricsLog::~MetricsLog() {
-  if (writer_)
-    xmlFreeTextWriter(writer_);
+  FreeDocWriter();
 
-  if (buffer_)
+  if (buffer_) {
     xmlBufferFree(buffer_);
+    buffer_ = NULL;
+  }
 }
 
 void MetricsLog::CloseLog() {
   DCHECK(!locked_);
   locked_ = true;
 
   int result = xmlTextWriterEndDocument(writer_);
   DCHECK_GE(result, 0);
 
   result = xmlTextWriterFlush(writer_);
   DCHECK_GE(result, 0);
+
+#if defined(OS_CHROMEOS)
+  xmlNodePtr root = xmlDocGetRootElement(doc_);
+  if (!hardware_class_.empty()) {
+    // The hardware class is determined after the first ongoing log is
+    // constructed, so this adds the root element's "hardwareclass"
+    // attribute when the log is closed instead.
+    xmlNewProp(root, UnsignedChar("hardwareclass"),
+               UnsignedChar(hardware_class_.c_str()));
+  }
+
+  // Flattens the XML tree into a character buffer.
+  PerfTimer dump_timer;
+  result = xmlNodeDump(buffer_, doc_, root, /* level */ 0, /* format */ 1);
+  DCHECK_GE(result, 0);
+  UMA_HISTOGRAM_TIMES("UMA.XMLNodeDumpTime", dump_timer.Elapsed());
+
+  PerfTimer free_timer;
+  FreeDocWriter();
+  UMA_HISTOGRAM_TIMES("UMA.XMLWriterDestructionTime", free_timer.Elapsed());
+#endif  // OS_CHROMEOS
 }
 
 int MetricsLog::GetEncodedLogSize() {
   DCHECK(locked_);
   return buffer_->use;
 }
 
 bool MetricsLog::GetEncodedLog(char* buffer, int buffer_size) {
   DCHECK(locked_);
   if (buffer_size < GetEncodedLogSize())
@@ skipping 176 matching lines @@
     case WINDOW_CLOSE:   return "close";
     case WINDOW_DESTROY: return "destroy";
 
     default:
       NOTREACHED();
       return "unknown";  // Can't return NULL as this is used in a required
                          // attribute.
   }
 }
 
+void MetricsLog::FreeDocWriter() {
+  if (writer_) {
+    xmlFreeTextWriter(writer_);
+    writer_ = NULL;
+  }
+
+  if (doc_) {
+    xmlFreeDoc(doc_);
+    doc_ = NULL;
+  }
+}
+
 void MetricsLog::StartElement(const char* name) {
   DCHECK(!locked_);
   DCHECK(name);
 
   int result = xmlTextWriterStartElement(writer_, UnsignedChar(name));
   DCHECK_GE(result, 0);
 }
 
 void MetricsLog::EndElement() {
   DCHECK(!locked_);
@@ skipping 437 matching lines @@
 
   for (size_t i = 0; i < histogram.bucket_count(); i++) {
     if (snapshot.counts(i)) {
       OPEN_ELEMENT_FOR_SCOPE("histogrambucket");
       WriteIntAttribute("min", histogram.ranges(i));
       WriteIntAttribute("max", histogram.ranges(i + 1));
       WriteIntAttribute("count", snapshot.counts(i));
     }
   }
 }