Start using OStreams.

src/log.cc

 // Copyright 2011 the V8 project 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 <stdarg.h>
 
 #include "src/v8.h"
 
 #include "src/base/platform/platform.h"
 #include "src/bootstrapper.h"
@@ skipping 1954 matching lines @@
       PROFILE(isolate_, GetterCallbackEvent(name, getter_entry));
     }
     Address setter_entry = v8::ToCData<Address>(ai->setter());
     if (setter_entry != 0) {
       PROFILE(isolate_, SetterCallbackEvent(name, setter_entry));
     }
   }
 }
 
 
-static void AddIsolateIdIfNeeded(Isolate* isolate, StringStream* stream) {
-  if (FLAG_logfile_per_isolate) stream->Add("isolate-%p-", isolate);
+static void AddIsolateIdIfNeeded(OStream& os,  // NOLINT
+                                 Isolate* isolate) {
+  if (FLAG_logfile_per_isolate) os << "isolate-" << isolate << "-";
 }
 
 
-static SmartArrayPointer<const char> PrepareLogFileName(
-    Isolate* isolate, const char* file_name) {
-  HeapStringAllocator allocator;
-  StringStream stream(&allocator);
-  AddIsolateIdIfNeeded(isolate, &stream);
+static void PrepareLogFileName(OStream& os,  // NOLINT
+                               Isolate* isolate, const char* file_name) {
+  AddIsolateIdIfNeeded(os, isolate);
   for (const char* p = file_name; *p; p++) {
     if (*p == '%') {
       p++;
       switch (*p) {
         case '\0':
           // If there's a % at the end of the string we back up
           // one character so we can escape the loop properly.
           p--;
           break;
         case 'p':
-          stream.Add("%d", base::OS::GetCurrentProcessId());
+          os << base::OS::GetCurrentProcessId();
           break;
-        case 't': {
+        case 't':
           // %t expands to the current time in milliseconds.
-          double time = base::OS::TimeCurrentMillis();
-          stream.Add("%.0f", FmtElm(time));
+          os << static_cast<int64_t>(base::OS::TimeCurrentMillis());
           break;
-        }
         case '%':
           // %% expands (contracts really) to %.
-          stream.Put('%');
+          os << '%';
           break;
         default:
           // All other %'s expand to themselves.
-          stream.Put('%');
-          stream.Put(*p);
+          os << '%' << *p;
           break;
       }
     } else {
-      stream.Put(*p);
+      os << *p;
     }
   }
-  return SmartArrayPointer<const char>(stream.ToCString());
 }
 
 
 bool Logger::SetUp(Isolate* isolate) {
   // Tests and EnsureInitialize() can call this twice in a row. It's harmless.
   if (is_initialized_) return true;
   is_initialized_ = true;
 
   // --ll-prof implies --log-code and --log-snapshot-positions.
   if (FLAG_ll_prof) {
     FLAG_log_snapshot_positions = true;
   }
 
-  SmartArrayPointer<const char> log_file_name =
-      PrepareLogFileName(isolate, FLAG_logfile);
-  log_->Initialize(log_file_name.get());
+  OStringStream log_file_name;
+  PrepareLogFileName(log_file_name, isolate, FLAG_logfile);
+  log_->Initialize(log_file_name.c_str());
 
 
   if (FLAG_perf_basic_prof) {
     perf_basic_logger_ = new PerfBasicLogger();
     addCodeEventListener(perf_basic_logger_);
   }
 
   if (FLAG_perf_jit_prof) {
     perf_jit_logger_ = new PerfJitLogger();
     addCodeEventListener(perf_jit_logger_);
   }
 
   if (FLAG_ll_prof) {
-    ll_logger_ = new LowLevelLogger(log_file_name.get());
+    ll_logger_ = new LowLevelLogger(log_file_name.c_str());
     addCodeEventListener(ll_logger_);
   }
 
   ticker_ = new Ticker(isolate, kSamplingIntervalMs);
 
   if (Log::InitLogAtStart()) {
     is_logging_ = true;
   }
 
   if (FLAG_prof) {
@@ skipping 68 matching lines @@
   if (jit_logger_) {
     removeCodeEventListener(jit_logger_);
     delete jit_logger_;
     jit_logger_ = NULL;
   }
 
   return log_->Close();
 }
 
 } }  // namespace v8::internal