Move the number conversions from string_util to a new file....

chrome/common/metrics_helpers.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/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/string_number_conversions.h"
+#include "base/string_util.h"  // TODO(brettw) remove when ASCIIToUTF16 moves.
 #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"
 #include "libxml/xmlwriter.h"
 
 #define OPEN_ELEMENT_FOR_SCOPE(name) ScopedElement scoped_element(this, name)
 
 using base::Time;
@@ skipping 62 matching lines @@
   xmlTextWriterPtr writer_;
 };
 
 // static
 std::string MetricsLogBase::version_extension_;
 
 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)),
+      session_id_(base::IntToString(session_id)),
       locked_(false),
       xml_wrapper_(new XmlWrapper),
       num_events_(0) {
 
   StartElement("log");
   WriteAttribute("clientid", client_id_);
   WriteInt64Attribute("buildtime", GetBuildTime());
   WriteAttribute("appversion", version_string);
 }
 
@@ skipping 117 matching lines @@
                                  const GURL& url,
                                  PageTransition::Type origin,
                                  int session_index,
                                  TimeDelta load_time) {
   DCHECK(!locked_);
 
   OPEN_ELEMENT_FOR_SCOPE("document");
   WriteAttribute("action", "load");
   WriteIntAttribute("docid", session_index);
   WriteIntAttribute("window", window_id);
-  WriteAttribute("loadtime", Int64ToString(load_time.InMilliseconds()));
+  WriteAttribute("loadtime", base::Int64ToString(load_time.InMilliseconds()));
 
   std::string origin_string;
 
   switch (PageTransition::StripQualifier(origin)) {
     // TODO(jhughes): Some of these mappings aren't right... we need to add
     // some values to the server's enum.
     case PageTransition::LINK:
     case PageTransition::MANUAL_SUBFRAME:
       origin_string = "link";
       break;
@@ skipping 36 matching lines @@
   ++num_events_;
 }
 
 void MetricsLogBase::RecordWindowEvent(WindowEventType type,
                                    int window_id,
                                    int parent_id) {
   DCHECK(!locked_);
 
   OPEN_ELEMENT_FOR_SCOPE("window");
   WriteAttribute("action", WindowEventTypeToString(type));
-  WriteAttribute("windowid", IntToString(window_id));
+  WriteAttribute("windowid", base::IntToString(window_id));
   if (parent_id >= 0)
-    WriteAttribute("parent", IntToString(parent_id));
+    WriteAttribute("parent", base::IntToString(parent_id));
   WriteCommonEventAttributes();
 
   ++num_events_;
 }
 
 std::string MetricsLogBase::GetCurrentTimeString() {
-  return Uint64ToString(Time::Now().ToTimeT());
+  return base::Uint64ToString(Time::Now().ToTimeT());
 }
 
 // These are the attributes that are common to every event.
 void MetricsLogBase::WriteCommonEventAttributes() {
   WriteAttribute("session", session_id_);
   WriteAttribute("time", GetCurrentTimeString());
 }
 
 void MetricsLogBase::WriteAttribute(const std::string& name,
                                 const std::string& value) {
   DCHECK(!locked_);
   DCHECK(!name.empty());
 
   int result = xmlTextWriterWriteAttribute(xml_wrapper_->writer(),
                                            UnsignedChar(name.c_str()),
                                            UnsignedChar(value.c_str()));
   DCHECK_GE(result, 0);
 }
 
 void MetricsLogBase::WriteIntAttribute(const std::string& name, int value) {
-  WriteAttribute(name, IntToString(value));
+  WriteAttribute(name, base::IntToString(value));
 }
 
 void MetricsLogBase::WriteInt64Attribute(const std::string& name, int64 value) {
-  WriteAttribute(name, Int64ToString(value));
+  WriteAttribute(name, base::Int64ToString(value));
 }
 
 // static
 const char* MetricsLogBase::WindowEventTypeToString(WindowEventType type) {
   switch (type) {
     case WINDOW_CREATE:  return "create";
     case WINDOW_OPEN:    return "open";
     case WINDOW_CLOSE:   return "close";
     case WINDOW_DESTROY: return "destroy";
 
@@ skipping 164 matching lines @@
   }
 }
 
 void MetricsServiceBase::DiscardPendingLog() {
   if (pending_log_) {  // Shutdown might have deleted it!
     delete pending_log_;
     pending_log_ = NULL;
   }
   compressed_log_.clear();
 }