Migrate logging infrastructure Isolate->Thread

runtime/vm/log.cc

 // Copyright (c) 2015, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/log.h"
 
 #include "vm/flags.h"
 #include "vm/thread.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, force_log_flush, false, "Always flush log messages.");
 
+DEFINE_FLAG(charp, isolate_log_filter, NULL,
+            "Log isolates whose name include the filter. "
+            "Default: service isolate log messages are suppressed.");
+
 Log::Log(LogPrinter printer)
     : printer_(printer),
       manual_flush_(0),
       buffer_(0) {
 }
 
 
+Log::~Log() {
+  // Did someone enable manual flushing and then forgot to Flush?
+  ASSERT(cursor() == 0);
+}
+
+
+Log* Log::Current() {
+  Thread* thread = Thread::Current();
+  Isolate* isolate = thread->isolate();
+  if (isolate != NULL && Log::ShouldLogForIsolate(isolate)) {
+    return thread->log();
+  } else {
+    return Log::NoOpLog();
+  }
+}
+
+
 void Log::Print(const char* format, ...) {
   if (this == NoOpLog()) {
     return;
   }
 
   va_list args;
   va_start(args, format);
   VPrint(format, args);
   va_end(args);
 }
@@ skipping 54 matching lines @@
   }
   buffer_.TruncateTo(0);
 }
 
 
 intptr_t Log::cursor() const {
   return buffer_.length();
 }
 
 
+bool Log::ShouldLogForIsolate(const Isolate* isolate) {
+  if (FLAG_isolate_log_filter == NULL) {
+    if (isolate->is_service_isolate()) {
+      // By default, do not log for the service isolate.
+      return false;
+    }
+    return true;
+  }
+  const char* name = isolate->name();
+  ASSERT(name != NULL);
+  if (strstr(name, FLAG_isolate_log_filter) == NULL) {
+    // Filter does not match, do not log for this isolate.
+    return false;
+  }
+  return true;
+}
+
+
 Log Log::noop_log_;
 Log* Log::NoOpLog() {
   return &noop_log_;
 }
 
 
 void Log::TerminateString() {
   buffer_.Add('\0');
 }
 
 
 void Log::EnableManualFlush() {
   manual_flush_++;
 }
 
 
 void Log::DisableManualFlush() {
   manual_flush_--;
   ASSERT(manual_flush_ >= 0);
   if (manual_flush_ == 0) {
     Flush();
   }
 }
 
 
-LogBlock::LogBlock(Thread* thread, Log* log)
-    : StackResource(thread),
-      log_(log), cursor_(log->cursor()) {
-  CommonConstructor();
+void LogBlock::Initialize() {
+  log_->EnableManualFlush();
 }
 
 
-LogBlock::LogBlock(Isolate* isolate)
-    : StackResource(isolate),
-      log_(isolate->Log()), cursor_(isolate->Log()->cursor()) {
-  CommonConstructor();
-}
-
-
-LogBlock::LogBlock(Thread* thread)
-    : StackResource(thread),
-      log_(thread->isolate()->Log()),
-      cursor_(thread->isolate()->Log()->cursor()) {
-  CommonConstructor();
+LogBlock::~LogBlock() {
+  log_->Flush(cursor_);
+  log_->DisableManualFlush();
 }
 
 }  // namespace dart