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

runtime/bin/vmservice_impl.cc

 // Copyright (c) 2013, 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 "bin/vmservice_impl.h"
 
 #include "include/dart_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
@@ skipping 73 matching lines @@
     return &__service_bin_resources_[0];
   }
 
   DISALLOW_ALLOCATION();
   DISALLOW_IMPLICIT_CONSTRUCTORS(Resources);
 };
 
 
 void NotifyServerState(Dart_NativeArguments args) {
   Dart_EnterScope();
-  const char* ip_chars;
-  Dart_Handle ip_arg = Dart_GetNativeArgument(args, 0);
-  if (Dart_IsError(ip_arg)) {
-    VmService::SetServerIPAndPort("", 0);
+  const char* uri_chars;
+  Dart_Handle uri_arg = Dart_GetNativeArgument(args, 0);
+  if (Dart_IsError(uri_arg)) {
+    VmService::SetServerAddress("");
     Dart_ExitScope();
     return;
   }
-  Dart_Handle result = Dart_StringToCString(ip_arg, &ip_chars);
+  Dart_Handle result = Dart_StringToCString(uri_arg, &uri_chars);
   if (Dart_IsError(result)) {
-    VmService::SetServerIPAndPort("", 0);
+    VmService::SetServerAddress("");
     Dart_ExitScope();
     return;
   }
-  Dart_Handle port_arg = Dart_GetNativeArgument(args, 1);
-  if (Dart_IsError(port_arg)) {
-    VmService::SetServerIPAndPort("", 0);
-    Dart_ExitScope();
-    return;
-  }
-  int64_t port = DartUtils::GetInt64ValueCheckRange(port_arg, 0, 65535);
-  VmService::SetServerIPAndPort(ip_chars, port);
+  VmService::SetServerAddress(uri_chars);
   Dart_ExitScope();
 }
 
 
 static void Shutdown(Dart_NativeArguments args) {
   // NO-OP.
 }
 
 
 struct VmServiceIONativeEntry {
   const char* name;
   int num_arguments;
   Dart_NativeFunction function;
 };
 
 
 static VmServiceIONativeEntry _VmServiceIONativeEntries[] = {
-  {"VMServiceIO_NotifyServerState", 2, NotifyServerState},
+  {"VMServiceIO_NotifyServerState", 1, NotifyServerState},
   {"VMServiceIO_Shutdown", 0, Shutdown },
 };
 
 
 static Dart_NativeFunction VmServiceIONativeResolver(Dart_Handle name,
                                                      int num_arguments,
                                                      bool* auto_setup_scope) {
   const char* function_name = NULL;
   Dart_Handle result = Dart_StringToCString(name, &function_name);
   ASSERT(!Dart_IsError(result));
   ASSERT(function_name != NULL);
   *auto_setup_scope = true;
   intptr_t n =
       sizeof(_VmServiceIONativeEntries) / sizeof(_VmServiceIONativeEntries[0]);
   for (intptr_t i = 0; i < n; i++) {
     VmServiceIONativeEntry entry = _VmServiceIONativeEntries[i];
     if ((strcmp(function_name, entry.name) == 0) &&
         (num_arguments == entry.num_arguments)) {
       return entry.function;
     }
   }
   return NULL;
 }
 
 
 const char* VmService::error_msg_ = NULL;
-char VmService::server_ip_[kServerIpStringBufferSize];
-intptr_t VmService::server_port_ = 0;
+char VmService::server_uri_[kServerUriStringBufferSize];
 
 
 bool VmService::LoadForGenPrecompiled() {
   Dart_Handle result;
   Dart_SetLibraryTagHandler(LibraryTagHandler);
   Dart_Handle library = LoadLibrary(kVMServiceIOLibraryScriptResourceName);
   ASSERT(library != Dart_Null());
   SHUTDOWN_ON_ERROR(library);
   result = Dart_SetNativeResolver(library, VmServiceIONativeResolver, NULL);
   SHUTDOWN_ON_ERROR(result);
   result = Dart_FinalizeLoading(false);
   SHUTDOWN_ON_ERROR(result);
   return true;
 }
 
 
 bool VmService::Setup(const char* server_ip,
                       intptr_t server_port,
                       bool running_precompiled,
                       bool dev_mode_server) {
   Dart_Isolate isolate = Dart_CurrentIsolate();
   ASSERT(isolate != NULL);
-  SetServerIPAndPort("", 0);
+  SetServerAddress("");
 
   Dart_Handle result;
 
   // Prepare builtin and its dependent libraries for use to resolve URIs.
   // Set up various closures, e.g: printing, timers etc.
   // Set up 'package root' for URI resolution.
   result = DartUtils::PrepareForScriptLoading(true, false);
   SHUTDOWN_ON_ERROR(result);
 
   if (running_precompiled) {
@@ skipping 89 matching lines @@
   SHUTDOWN_ON_ERROR(field_name);
   return true;
 }
 
 
 const char* VmService::GetErrorMessage() {
   return (error_msg_ == NULL) ? "No error." : error_msg_;
 }
 
 
-void VmService::SetServerIPAndPort(const char* ip, intptr_t port) {
-  if (ip == NULL) {
-    ip = "";
+void VmService::SetServerAddress(const char* server_uri) {
+  if (server_uri == NULL) {
+    server_uri = "";
   }
-  strncpy(server_ip_, ip, kServerIpStringBufferSize);
-  server_ip_[kServerIpStringBufferSize - 1] = '\0';
-  server_port_ = port;
+  strncpy(server_uri_, server_uri, kServerUriStringBufferSize);
+  server_uri_[kServerUriStringBufferSize - 1] = '\0';
 }
 
 
 Dart_Handle VmService::GetSource(const char* name) {
   const intptr_t kBufferSize = 512;
   char buffer[kBufferSize];
   snprintf(&buffer[0], kBufferSize-1, "%s/%s", kLibrarySourceNamePrefix, name);
   const char* vmservice_source = NULL;
   int r = Resources::ResourceLookup(buffer, &vmservice_source);
   if (r == Resources::kNoSuchInstance) {
@@ skipping 57 matching lines @@
   Dart_Handle source = GetSource(url_string);
   if (Dart_IsError(source)) {
     return source;
   }
   return Dart_LoadSource(library, url, Dart_Null(), source, 0, 0);
 }
 
 
 }  // namespace bin
 }  // namespace dart