...

chrome/common/metrics_helpers.cc

 // Copyright (c) 2009 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/common/metrics_helpers.h"
 
 #if defined(USE_SYSTEM_LIBBZ2)
 #include <bzlib.h>
 #else
 #include "third_party/bzip2/bzlib.h"
 #endif
 
 #include "base/base64.h"
 #include "base/time.h"
 #include "base/basictypes.h"
 #include "base/file_util.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/common/logging_chrome.h"
 #include "googleurl/src/gurl.h"
 
 #define OPEN_ELEMENT_FOR_SCOPE(name) ScopedElement scoped_element(this, name)
 
@@ skipping 12 matching lines @@
 inline const unsigned char* UnsignedChar(const char* input) {
   return reinterpret_cast<const unsigned char*>(input);
 }
 
 MetricsLogBase::MetricsLogBase(const std::string& client_id, int session_id,
                                const std::string& version_string)
     : 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", version_string);
 
   DCHECK_GE(result, 0);
 }
 
 MetricsLogBase::~MetricsLogBase() {
+  FreeDocWriter();
+
   if (writer_)
     xmlFreeTextWriter(writer_);
 
-  if (buffer_)
+  if (buffer_) {
     xmlBufferFree(buffer_);
+    buffer_ = NULL;
+  }
 }
 
 void MetricsLogBase::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 MetricsLogBase::GetEncodedLogSize() {
   DCHECK(locked_);
   return buffer_->use;
 }
 
 bool MetricsLogBase::GetEncodedLog(char* buffer, int buffer_size) {
   DCHECK(locked_);
   if (buffer_size < GetEncodedLogSize())
@@ skipping 181 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 MetricsLogBase::FreeDocWriter() {
+  if (writer_) {
+    xmlFreeTextWriter(writer_);
+    writer_ = NULL;
+  }
+
+  if (doc_) {
+    xmlFreeDoc(doc_);
+    doc_ = NULL;
+  }
+}
+
 void MetricsLogBase::StartElement(const char* name) {
   DCHECK(!locked_);
   DCHECK(name);
 
   int result = xmlTextWriterStartElement(writer_, UnsignedChar(name));
   DCHECK_GE(result, 0);
 }
 
 void MetricsLogBase::EndElement() {
   DCHECK(!locked_);
@@ skipping 149 matching lines @@
 }
 
 void MetricsServiceBase::DiscardPendingLog() {
   if (pending_log_) {  // Shutdown might have deleted it!
     delete pending_log_;
     pending_log_ = NULL;
   }
   pending_log_text_.clear();
 }