[vm, gardening] Move --trace-service output to stderr.

runtime/vm/service_isolate.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/service_isolate.h"
 
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
 #include "vm/isolate.h"
@@ skipping 181 matching lines @@
   const String& name = String::Handle(String::New(isolate->name()));
   ASSERT(!name.IsNull());
   const Array& list = Array::Handle(MakeServiceControlMessage(
       Dart_GetMainPortId(), VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID, name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
-    OS::Print("vm-service: Isolate %s %" Pd64 " registered.\n",
-              name.ToCString(), Dart_GetMainPortId());
+    OS::PrintErr("vm-service: Isolate %s %" Pd64 " registered.\n",
+                 name.ToCString(), Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 bool ServiceIsolate::SendIsolateShutdownMessage() {
   if (!IsRunning()) {
     return false;
   }
   Thread* thread = Thread::Current();
   Isolate* isolate = thread->isolate();
   if (IsServiceIsolateDescendant(isolate)) {
     return false;
   }
   ASSERT(isolate != NULL);
   HANDLESCOPE(thread);
   const String& name = String::Handle(String::New(isolate->name()));
   ASSERT(!name.IsNull());
   const Array& list = Array::Handle(MakeServiceControlMessage(
       Dart_GetMainPortId(), VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID, name));
   ASSERT(!list.IsNull());
   uint8_t* data = NULL;
   MessageWriter writer(&data, &malloc_allocator, &malloc_deallocator, false);
   writer.WriteMessage(list);
   intptr_t len = writer.BytesWritten();
   if (FLAG_trace_service) {
-    OS::Print("vm-service: Isolate %s %" Pd64 " deregistered.\n",
-              name.ToCString(), Dart_GetMainPortId());
+    OS::PrintErr("vm-service: Isolate %s %" Pd64 " deregistered.\n",
+                 name.ToCString(), Dart_GetMainPortId());
   }
   return PortMap::PostMessage(
       new Message(port_, data, len, Message::kNormalPriority));
 }
 
 void ServiceIsolate::SendServiceExitMessage() {
   if (!IsRunning()) {
     return;
   }
   if ((exit_message_ == NULL) || (exit_message_length_ == 0)) {
     return;
   }
   if (FLAG_trace_service) {
-    OS::Print("vm-service: sending service exit message.\n");
+    OS::PrintErr("vm-service: sending service exit message.\n");
   }
   PortMap::PostMessage(new Message(port_, exit_message_, exit_message_length_,
                                    Message::kNormalPriority));
 }
 
 void ServiceIsolate::SetServicePort(Dart_Port port) {
   MonitorLocker ml(monitor_);
   port_ = port;
 }
 
@@ skipping 103 matching lines @@
 
     ServiceIsolate::FinishedInitializing();
 
     isolate->message_handler()->Run(Dart::thread_pool(), NULL, ShutdownIsolate,
                                     reinterpret_cast<uword>(isolate));
   }
 
  protected:
   static void ShutdownIsolate(uword parameter) {
     if (FLAG_trace_service) {
-      OS::Print("vm-service: ShutdownIsolate\n");
+      OS::PrintErr("vm-service: ShutdownIsolate\n");
     }
     Isolate* I = reinterpret_cast<Isolate*>(parameter);
     ASSERT(ServiceIsolate::IsServiceIsolate(I));
     ServiceIsolate::SetServiceIsolate(NULL);
     ServiceIsolate::SetServicePort(ILLEGAL_PORT);
     I->WaitForOutstandingSpawns();
     {
       // Print the error if there is one.  This may execute dart code to
       // print the exception object, so we need to use a StartIsolateScope.
       ASSERT(Isolate::Current() == NULL);
       StartIsolateScope start_scope(I);
       Thread* T = Thread::Current();
       ASSERT(I == T->isolate());
       StackZone zone(T);
       HandleScope handle_scope(T);
       Error& error = Error::Handle(Z);
       error = T->sticky_error();
       if (!error.IsNull() && !error.IsUnwindError()) {
         OS::PrintErr("vm-service: Error: %s\n", error.ToErrorCString());
       }
       error = I->sticky_error();
       if (!error.IsNull() && !error.IsUnwindError()) {
         OS::PrintErr("vm-service: Error: %s\n", error.ToErrorCString());
       }
       Dart::RunShutdownCallback();
     }
     // Shut the isolate down.
     Dart::ShutdownIsolate(I);
     if (FLAG_trace_service) {
-      OS::Print("vm-service: Shutdown.\n");
+      OS::PrintErr("vm-service: Shutdown.\n");
     }
     ServiceIsolate::FinishedExiting();
   }
 
   bool RunMain(Isolate* I) {
     Thread* T = Thread::Current();
     ASSERT(I == T->isolate());
     StackZone zone(T);
     HANDLESCOPE(T);
     // Invoke main which will return the loadScriptPort.
     const Library& root_library =
         Library::Handle(Z, I->object_store()->root_library());
     if (root_library.IsNull()) {
       if (FLAG_trace_service) {
-        OS::Print("vm-service: Embedder did not install a script.");
+        OS::PrintErr("vm-service: Embedder did not install a script.");
       }
       // Service isolate is not supported by embedder.
       return false;
     }
     ASSERT(!root_library.IsNull());
     const String& entry_name = String::Handle(Z, String::New("main"));
     ASSERT(!entry_name.IsNull());
     const Function& entry = Function::Handle(
         Z, root_library.LookupFunctionAllowPrivate(entry_name));
     if (entry.IsNull()) {
       // Service isolate is not supported by embedder.
       if (FLAG_trace_service) {
-        OS::Print("vm-service: Embedder did not provide a main function.");
+        OS::PrintErr("vm-service: Embedder did not provide a main function.");
       }
       return false;
     }
     ASSERT(!entry.IsNull());
     const Object& result = Object::Handle(
         Z, DartEntry::InvokeFunction(entry, Object::empty_array()));
     ASSERT(!result.IsNull());
     if (result.IsError()) {
       // Service isolate did not initialize properly.
       if (FLAG_trace_service) {
         const Error& error = Error::Cast(result);
-        OS::Print("vm-service: Calling main resulted in an error: %s",
-                  error.ToErrorCString());
+        OS::PrintErr("vm-service: Calling main resulted in an error: %s",
+                     error.ToErrorCString());
       }
       if (result.IsUnwindError()) {
         return true;
       }
       return false;
     }
     ASSERT(result.IsReceivePort());
     const ReceivePort& rp = ReceivePort::Cast(result);
     ServiceIsolate::SetLoadPort(rp.Id());
     return false;
@@ skipping 72 matching lines @@
   if (result.IsReceivePort()) {
     port = ReceivePort::Cast(result).Id();
   }
   ASSERT(port != ILLEGAL_PORT);
   ServiceIsolate::SetServicePort(port);
 }
 
 void ServiceIsolate::VisitObjectPointers(ObjectPointerVisitor* visitor) {}
 
 }  // namespace dart