- Remove the legacy debug protocol.

runtime/bin/main.cc

 // Copyright (c) 2012, 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 <stdlib.h>
 #include <string.h>
 #include <stdio.h>
 
 #include "include/dart_api.h"
 #include "include/dart_tools_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
-#include "bin/dbg_connection.h"
 #include "bin/directory.h"
 #include "bin/embedded_dart_io.h"
 #include "bin/eventhandler.h"
 #include "bin/extensions.h"
 #include "bin/file.h"
 #include "bin/isolate_data.h"
 #include "bin/log.h"
 #include "bin/platform.h"
 #include "bin/process.h"
 #include "bin/thread.h"
+#include "bin/utils.h"
 #include "bin/vmservice_impl.h"
 #include "platform/globals.h"
 #include "platform/hashmap.h"
+#include "platform/text_buffer.h"
 
 namespace dart {
 namespace bin {
 
 // vm_isolate_snapshot_buffer points to a snapshot for the vm isolate if we
 // link in a snapshot otherwise it is initialized to NULL.
 extern const uint8_t* vm_isolate_snapshot_buffer;
 
 // isolate_snapshot_buffer points to a snapshot for an isolate if we link in a
 // snapshot otherwise it is initialized to NULL.
 extern const uint8_t* isolate_snapshot_buffer;
 
 // Global state that stores a pointer to the application script snapshot.
 static bool generate_script_snapshot = false;
 static bool generate_script_snapshot_after_run = false;
 static const char* snapshot_filename = NULL;
 
 
-// Global state that indicates whether there is a debug breakpoint.
-// This pointer points into an argv buffer and does not need to be
-// free'd.
-static const char* breakpoint_at = NULL;

[hausner, 2015/12/04 00:23:11]

I was hoping that the Observatory debugger could pick up this convenient way of
specifying a breakpoint from the command line. I guess it's ok to remove this
now. 

-
-
-// Global state that indicates whether we should open a connection
-// and listen for a debugger to connect.
-static bool start_debugger = false;
-static const char* debug_ip = NULL;
-static int debug_port = -1;
-static const char* DEFAULT_DEBUG_IP = "127.0.0.1";
-static const int DEFAULT_DEBUG_PORT = 5858;
-
 // Value of the --package-root flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_package_root = NULL;
 
 // Value of the --packages flag.
 // (This pointer points into an argv buffer and does not need to be
 // free'd.)
 static const char* commandline_packages_file = NULL;
 
@@ skipping 66 matching lines @@
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   char* error = Dart_Cleanup();
   if (error != NULL) {
     Log::PrintErr("VM cleanup failed: %s\n", error);
     free(error);
   }
 
   if (do_vm_shutdown) {
-    DebuggerConnectionHandler::StopHandler();
     EventHandler::Stop();
   }
   Platform::Exit(exit_code);
 }
 
 
 // The environment provided through the command line using -D options.
 static dart::HashMap* environment = NULL;
 
 static bool IsValidFlag(const char* name,
@@ skipping 30 matching lines @@
 static bool ProcessVerboseOption(const char* arg,
                                  CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
   has_verbose_option = true;
   return true;
 }
 
 
-static bool ProcessBreakpointOption(const char* funcname,
-                                    CommandLineOptions* vm_options) {
-  ASSERT(funcname != NULL);
-  if (*funcname == '\0') {
-    return false;
-  }
-  breakpoint_at = funcname;
-  return true;
-}
-
-
 static bool ProcessPackageRootOption(const char* arg,
                                      CommandLineOptions* vm_options) {
   ASSERT(arg != NULL);
   if (*arg == '\0' || *arg == '-') {
     return false;
   }
   commandline_package_root = arg;
   return true;
 }
 
@@ skipping 145 matching lines @@
   ASSERT(arg != NULL);
   if (*arg != '\0') {
     return false;
   }
   has_noopt = true;
   vm_options->AddArgument("--precompilation");
   return true;
 }
 
 
-static bool ProcessDebugOption(const char* option_value,
-                               CommandLineOptions* vm_options) {
-  ASSERT(option_value != NULL);
-  if (!ExtractPortAndIP(option_value, &debug_port, &debug_ip,
-                        DEFAULT_DEBUG_PORT, DEFAULT_DEBUG_IP)) {
-    Log::PrintErr("unrecognized --debug option syntax. "
-                  "Use --debug[:<port number>[/<IPv4 address>]]\n");
-    return false;
-  }
-
-  breakpoint_at = "main";
-  start_debugger = true;
-  return true;
-}
-
-
 static bool ProcessScriptSnapshotOptionHelper(const char* filename,
                                               bool* snapshot_option) {
   *snapshot_option = false;
   if ((filename != NULL) && (strlen(filename) != 0)) {
     // Ensure that we are already running using a full snapshot.
     if (isolate_snapshot_buffer == NULL) {
       Log::PrintErr("Script snapshots cannot be generated in this version of"
                     " dart\n");
       return false;
     }
@@ skipping 53 matching lines @@
     Log::PrintErr("unrecognized --observe option syntax. "
                   "Use --observe[:<port number>[/<IPv4 address>]]\n");
     return false;
   }
 
   vm_options->AddArgument("--pause-isolates-on-exit");
   return true;
 }
 
 
-extern bool trace_debug_protocol;
-static bool ProcessTraceDebugProtocolOption(const char* arg,
-                                            CommandLineOptions* vm_options) {
-  if (*arg != '\0') {
-    return false;
-  }
-  trace_debug_protocol = true;
-  return true;
-}
-
-
 static bool ProcessTraceLoadingOption(const char* arg,
                                       CommandLineOptions* vm_options) {
   if (*arg != '\0') {
     return false;
   }
   has_trace_loading = true;
   return true;
 }
 
 
@@ skipping 33 matching lines @@
   { "-D", ProcessEnvironmentOption },
   { "-h", ProcessHelpOption },
   { "--help", ProcessHelpOption },
   { "--packages=", ProcessPackagesOption },
   { "--package-root=", ProcessPackageRootOption },
   { "-v", ProcessVerboseOption },
   { "--verbose", ProcessVerboseOption },
   { "--version", ProcessVersionOption },
 
   // VM specific options to the standalone dart program.
-  { "--break-at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
-  { "--debug", ProcessDebugOption },
   { "--enable-vm-service", ProcessEnableVmServiceOption },
   { "--gen-precompiled-snapshot", ProcessGenPrecompiledSnapshotOption },
   { "--noopt", ProcessNooptOption },
   { "--observe", ProcessObserveOption },
   { "--run-precompiled-snapshot", ProcessRunPrecompiledSnapshotOption },
   { "--shutdown", ProcessShutdownOption },
   { "--snapshot=", ProcessScriptSnapshotOption },
   { "--snapshot-after-run=", ProcessScriptSnapshotAfterRunOption },
-  { "--trace-debug-protocol", ProcessTraceDebugProtocolOption },
   { "--trace-loading", ProcessTraceLoadingOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option,
                                CommandLineOptions* vm_options) {
   int i = 0;
   const char* name = main_options[0].option_name;
   int option_length = strlen(option);
@@ skipping 409 matching lines @@
 "  (default port number is 8181)\n"
 "\n"
 "The following options are only used for VM development and may\n"
 "be changed in any future version:\n");
     const char* print_flags = "--print_flags";
     Dart_SetVMFlags(1, &print_flags);
   }
 }
 
 
-static Dart_Handle SetBreakpoint(const char* breakpoint_at,
-                                 Dart_Handle library) {
-  char* bpt_function = strdup(breakpoint_at);
-  Dart_Handle class_name;
-  Dart_Handle function_name;
-  char* dot = strchr(bpt_function, '.');
-  if (dot == NULL) {
-    class_name = DartUtils::NewString("");
-    function_name = DartUtils::NewString(breakpoint_at);
-  } else {
-    *dot = '\0';
-    class_name = DartUtils::NewString(bpt_function);
-    function_name = DartUtils::NewString(dot + 1);
-  }
-  free(bpt_function);
-  return Dart_OneTimeBreakAtEntry(library, class_name, function_name);
-}
-
-
 char* BuildIsolateName(const char* script_name,
                        const char* func_name) {
   // Skip past any slashes in the script name.
   const char* last_slash = strrchr(script_name, '/');
   if (last_slash != NULL) {
     script_name = last_slash + 1;
   }
 
   const char* kFormat = "%s/%s";
   intptr_t len = strlen(script_name) + strlen(func_name) + 2;
@@ skipping 26 matching lines @@
 
 static const char* ServiceGetIOHandler(
     const char* method,
     const char** param_keys,
     const char** param_values,
     intptr_t num_params,
     void* user_data) {
   DartScope scope;
   // TODO(ajohnsen): Store the library/function in isolate data or user_data.
   Dart_Handle dart_io_str = Dart_NewStringFromCString("dart:io");
-  if (Dart_IsError(dart_io_str)) return ServiceRequestError(dart_io_str);
+  if (Dart_IsError(dart_io_str)) {
+    return ServiceRequestError(dart_io_str);
+  }
+
   Dart_Handle io_lib = Dart_LookupLibrary(dart_io_str);
-  if (Dart_IsError(io_lib)) return ServiceRequestError(io_lib);
+  if (Dart_IsError(io_lib)) {
+    return ServiceRequestError(io_lib);
+  }
+
   Dart_Handle handler_function_name =
       Dart_NewStringFromCString("_serviceObjectHandler");
   if (Dart_IsError(handler_function_name)) {
     return ServiceRequestError(handler_function_name);
   }
+
   // TODO(johnmccutchan): paths is no longer used.  Update the io
   // _serviceObjectHandler function to use json rpc.
   Dart_Handle paths = Dart_NewList(0);
   Dart_Handle keys = Dart_NewList(num_params);
   Dart_Handle values = Dart_NewList(num_params);
   for (int i = 0; i < num_params; i++) {
     Dart_ListSetAt(keys, i, Dart_NewStringFromCString(param_keys[i]));
     Dart_ListSetAt(values, i, Dart_NewStringFromCString(param_values[i]));
   }
   Dart_Handle args[] = {paths, keys, values};
   Dart_Handle result = Dart_Invoke(io_lib, handler_function_name, 3, args);
-  if (Dart_IsError(result)) return ServiceRequestError(result);
+  if (Dart_IsError(result)) {
+    return ServiceRequestError(result);
+  }
+
   const char *json;
   result = Dart_StringToCString(result, &json);
-  if (Dart_IsError(result)) return ServiceRequestError(result);
+  if (Dart_IsError(result)) {
+    return ServiceRequestError(result);
+  }
   return strdup(json);
 }
 
 
 static const char* kStdoutStreamId = "Stdout";
 static const char* kStderrStreamId = "Stderr";
 
 
 static bool ServiceStreamListenCallback(const char* stream_id) {
   if (strcmp(stream_id, kStdoutStreamId) == 0) {
@@ skipping 127 matching lines @@
     Log::PrintErr("%s\n", error);
     free(error);
     error = NULL;
     Process::TerminateExitCodeHandler();
     error = Dart_Cleanup();
     if (error != NULL) {
       Log::PrintErr("VM cleanup failed: %s\n", error);
       free(error);
     }
     if (do_vm_shutdown) {
-      DebuggerConnectionHandler::StopHandler();
       EventHandler::Stop();
     }
     Platform::Exit((exit_code != 0) ? exit_code : kErrorExitCode);
   }
   delete [] isolate_name;
 
   Dart_EnterIsolate(isolate);
   ASSERT(isolate == Dart_CurrentIsolate());
   ASSERT(isolate != NULL);
   Dart_Handle result;
@@ skipping 96 matching lines @@
                   script_name);
       }
 
       // The helper function _getMainClosure creates a closure for the main
       // entry point which is either explicitly or implictly exported from the
       // root library.
       Dart_Handle main_closure = Dart_Invoke(builtin_lib,
           Dart_NewStringFromCString("_getMainClosure"), 0, NULL);
       CHECK_RESULT(main_closure);
 
-      // Set debug breakpoint if specified on the command line before calling
-      // the main function.
-      if (breakpoint_at != NULL) {
-        result = SetBreakpoint(breakpoint_at, root_lib);
-        if (Dart_IsError(result)) {
-          ErrorExit(kErrorExitCode,
-                    "Error setting breakpoint at '%s': %s\n",
-                    breakpoint_at,
-                    Dart_GetError(result));
-        }
-      }
-
       // Call _startIsolate in the isolate library to enable dispatching the
       // initial startup message.
       const intptr_t kNumIsolateArgs = 2;
       Dart_Handle isolate_args[kNumIsolateArgs];
       isolate_args[0] = main_closure;                        // entryPoint
       isolate_args[1] = CreateRuntimeOptions(dart_options);  // args
 
       Dart_Handle isolate_lib =
           Dart_LookupLibrary(Dart_NewStringFromCString("dart:isolate"));
       result = Dart_Invoke(isolate_lib,
@@ skipping 86 matching lines @@
 
   if (generate_script_snapshot) {
     vm_options.AddArgument("--load_deferred_eagerly");
   }
 
   Dart_SetVMFlags(vm_options.count(), vm_options.arguments());
 
   // Start event handler.
   EventHandler::Start();
 
-  // Start the debugger wire protocol handler if necessary.
-  if (start_debugger) {
-    ASSERT(debug_port >= 0);
-    bool print_msg = verbose_debug_seen || (debug_port == 0);
-    debug_port = DebuggerConnectionHandler::StartHandler(debug_ip, debug_port);
-    if (print_msg) {
-      Log::Print("Debugger listening on port %d\n", debug_port);
-    }
-  } else {
-    DebuggerConnectionHandler::InitForVmService();
-  }
-
   const uint8_t* instructions_snapshot = NULL;
   if (has_run_precompiled_snapshot) {
     instructions_snapshot = reinterpret_cast<const uint8_t*>(
         LoadLibrarySymbol(kPrecompiledLibraryName, kPrecompiledSymbolName));
     ReadSnapshotFile(kPrecompiledVmIsolateName, &vm_isolate_snapshot_buffer);
     ReadSnapshotFile(kPrecompiledIsolateName, &isolate_snapshot_buffer);
   }
 
   // Initialize the Dart VM.
   char* error = Dart_Initialize(
       vm_isolate_snapshot_buffer, instructions_snapshot,
       CreateIsolateAndSetup, NULL, NULL, ShutdownIsolate,
       DartUtils::OpenFile,
       DartUtils::ReadFile,
       DartUtils::WriteFile,
       DartUtils::CloseFile,
       DartUtils::EntropySource,
       GetVMServiceAssetsArchiveCallback);
   if (error != NULL) {
     if (do_vm_shutdown) {
-      DebuggerConnectionHandler::StopHandler();
       EventHandler::Stop();
     }
     fprintf(stderr, "VM initialization failed: %s\n", error);
     fflush(stderr);
     free(error);
     Platform::Exit(kErrorExitCode);
   }
 
   Dart_RegisterIsolateServiceRequestCallback(
         "getIO", &ServiceGetIOHandler, NULL);
   Dart_SetServiceStreamCallbacks(&ServiceStreamListenCallback,
                                  &ServiceStreamCancelCallback);
 
   // Run the main isolate until we aren't told to restart.
   while (RunMainIsolate(script_name, &dart_options)) {
     Log::PrintErr("Restarting VM\n");
   }
 
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
 
   error = Dart_Cleanup();
   if (error != NULL) {
     Log::PrintErr("VM cleanup failed: %s\n", error);
     free(error);
   }
   if (do_vm_shutdown) {
-    DebuggerConnectionHandler::StopHandler();
     EventHandler::Stop();
   }
 
   // Free copied argument strings if converted.
   if (argv_converted) {
     for (int i = 0; i < argc; i++) free(argv[i]);
   }
 
   // Free environment if any.
   if (environment != NULL) {
     for (HashMap::Entry* p = environment->Start();
          p != NULL;
          p = environment->Next(p)) {
       free(p->key);
       free(p->value);
     }
     delete environment;
   }
 
   Platform::Exit(Process::GlobalExitCode());
 }
 
 }  // namespace bin
 }  // namespace dart
 
 int main(int argc, char** argv) {
   dart::bin::main(argc, argv);
   UNREACHABLE();
 }