Provide an API to dart:developer to control the web server hosting the Service Protocol

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 25 matching lines @@
   void* new_ptr = realloc(reinterpret_cast<void*>(ptr), new_size);
   return reinterpret_cast<uint8_t*>(new_ptr);
 }
 
 
 // These must be kept in sync with service/constants.dart
 #define VM_SERVICE_ISOLATE_EXIT_MESSAGE_ID 0
 #define VM_SERVICE_ISOLATE_STARTUP_MESSAGE_ID 1
 #define VM_SERVICE_ISOLATE_SHUTDOWN_MESSAGE_ID 2
 
+#define VM_SERVICE_WEB_SERVER_CONTROL_MESSAGE_ID 3
+#define VM_SERVICE_SERVER_INFO_MESSAGE_ID 4
+
 static RawArray* MakeServiceControlMessage(Dart_Port port_id, intptr_t code,
                                            const String& name) {
   const Array& list = Array::Handle(Array::New(4));
   ASSERT(!list.IsNull());
   const Integer& code_int = Integer::Handle(Integer::New(code));
   const Integer& port_int = Integer::Handle(Integer::New(port_id));
   const SendPort& send_port = SendPort::Handle(SendPort::New(port_id));
   list.SetAt(0, code_int);
   list.SetAt(1, port_int);
   list.SetAt(2, send_port);
   list.SetAt(3, name);
   return list.raw();
 }
 
 
+static RawArray* MakeServerControlMessage(const SendPort& sp,
+                                          intptr_t code,
+                                          bool enable = false) {
+  const Array& list = Array::Handle(Array::New(3));
+  ASSERT(!list.IsNull());
+  list.SetAt(0, Integer::Handle(Integer::New(code)));
+  list.SetAt(1, sp);
+  list.SetAt(2, Bool::Get(enable));
+  return list.raw();
+}
+
+
 static RawArray* MakeServiceExitMessage() {
   const Array& list = Array::Handle(Array::New(1));
   ASSERT(!list.IsNull());
   const intptr_t code = VM_SERVICE_ISOLATE_EXIT_MESSAGE_ID;
   const Integer& code_int = Integer::Handle(Integer::New(code));
   list.SetAt(0, code_int);
   return list.raw();
 }
 
 
 const char* ServiceIsolate::kName = "vm-service";
 Isolate* ServiceIsolate::isolate_ = NULL;
 Dart_Port ServiceIsolate::port_ = ILLEGAL_PORT;
 Dart_Port ServiceIsolate::load_port_ = ILLEGAL_PORT;
 Dart_Port ServiceIsolate::origin_ = ILLEGAL_PORT;
 Dart_IsolateCreateCallback ServiceIsolate::create_callback_ = NULL;
 uint8_t* ServiceIsolate::exit_message_ = NULL;
 intptr_t ServiceIsolate::exit_message_length_ = 0;
 Monitor* ServiceIsolate::monitor_ = NULL;
 bool ServiceIsolate::initializing_ = true;
 bool ServiceIsolate::shutting_down_ = false;
 char* ServiceIsolate::server_address_ = NULL;
 
+void ServiceIsolate::RequestServerInfo(const SendPort& sp) {
+  const Array& message =
+      Array::Handle(
+          MakeServerControlMessage(sp,
+                                   VM_SERVICE_SERVER_INFO_MESSAGE_ID,
+                                   false /* ignored */));
+  ASSERT(!message.IsNull());
+  uint8_t* data = NULL;
+  MessageWriter writer(&data, &allocator, false);
+  writer.WriteMessage(message);
+  intptr_t len = writer.BytesWritten();
+  PortMap::PostMessage(new Message(port_, data, len, Message::kNormalPriority));
+}
+
+
+void ServiceIsolate::ControlWebServer(const SendPort& sp, bool enable) {
+  const Array& message =
+      Array::Handle(
+          MakeServerControlMessage(sp,
+                                   VM_SERVICE_WEB_SERVER_CONTROL_MESSAGE_ID,
+                                   enable));
+  ASSERT(!message.IsNull());
+  uint8_t* data = NULL;
+  MessageWriter writer(&data, &allocator, false);
+  writer.WriteMessage(message);
+  intptr_t len = writer.BytesWritten();
+  PortMap::PostMessage(new Message(port_, data, len, Message::kNormalPriority));
+}
+
+
 void ServiceIsolate::SetServerAddress(const char* address) {
   if (server_address_ != NULL) {
     free(server_address_);
     server_address_ = NULL;
   }
   if (address == NULL) {
     return;
   }
   server_address_ = strdup(address);
 }
@@ skipping 431 matching lines @@
   }
   ASSERT(port != ILLEGAL_PORT);
   ServiceIsolate::SetServicePort(port);
 }
 
 
 void ServiceIsolate::VisitObjectPointers(ObjectPointerVisitor* visitor) {
 }
 
 }  // namespace dart