Clean up CodeObservers

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_debugger_api.h"
 
 #include "bin/builtin.h"
 #include "bin/dartutils.h"
 #include "bin/dbg_connection.h"
 #include "bin/directory.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 "platform/globals.h"
 
 // snapshot_buffer points to a snapshot if we link in a snapshot otherwise
 // it is initialized to NULL.
 extern const uint8_t* snapshot_buffer;
 
-// Global state that indicates whether pprof symbol information is
-// to be generated or not.
-static const char* generate_pprof_symbols_filename = NULL;
-
 
 // Global state that stores a pointer to the application script snapshot.
 static bool use_script_snapshot = false;
 static File* snapshot_file = 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;
@@ skipping 97 matching lines @@
   if (debug_port == 0) {
     Log::PrintErr("unrecognized --debug option syntax. "
                     "Use --debug[:<port number>]\n");
     return false;
   }
   breakpoint_at = "main";
   start_debugger = true;
   return true;
 }
 
-static bool ProcessPprofOption(const char* filename) {
-  ASSERT(filename != NULL);
-  generate_pprof_symbols_filename = filename;
-  return true;
-}
-
 
 static bool ProcessScriptSnapshotOption(const char* filename) {
   if (filename != NULL && strlen(filename) != 0) {
     use_script_snapshot = true;
     snapshot_file = File::Open(filename, File::kRead);
   }
   return true;
 }
 
 
 static struct {
   const char* option_name;
   bool (*process)(const char* option);
 } main_options[] = {
   // Standard options shared with dart2js.
   { "--version", ProcessVersionOption },
   { "--help", ProcessHelpOption },
   { "-h", ProcessHelpOption },
   { "--verbose", ProcessVerboseOption },
   { "-v", ProcessVerboseOption },
   { "--package-root=", ProcessPackageRootOption },
   { "-p", ProcessPackageRootOption },
   // VM specific options to the standalone dart program.
   { "--break_at=", ProcessBreakpointOption },
   { "--compile_all", ProcessCompileAllOption },
   { "--debug", ProcessDebugOption },
-  { "--generate_pprof_symbols=", ProcessPprofOption },
   { "--use_script_snapshot=", ProcessScriptSnapshotOption },
   { NULL, NULL }
 };
 
 
 static bool ProcessMainOptions(const char* option) {
   int i = 0;
   const char* name = main_options[0].option_name;
   while (name != NULL) {
     int length = strlen(name);
@@ skipping 76 matching lines @@
       const char* kPrintFlags2 = "--print_flags";
       if ((strncmp(argv[i], kPrintFlags1, strlen(kPrintFlags1)) == 0) ||
           (strncmp(argv[i], kPrintFlags2, strlen(kPrintFlags2)) == 0)) {
         *print_flags_seen = true;
       }
       vm_options->AddArgument(argv[i]);
       i++;
     }
   }
 
-  if (generate_pprof_symbols_filename != NULL) {
-    Dart_InitPprofSupport();
-  }
 
   // Get the script name.
   if (i < argc) {
     *script_name = argv[i];
     i++;
   } else {
     return -1;
   }
 
   // Parse out options to be passed to dart main.
@@ skipping 74 matching lines @@
   }
   Dart_Handle native_name = DartUtils::NewString("_nativeArguments");
   if (Dart_IsError(native_name)) {
     return native_name;
   }
 
   return Dart_SetField(runtime_options_class, native_name, dart_arguments);
 }
 
 
-static void DumpPprofSymbolInfo() {
-  if (generate_pprof_symbols_filename != NULL) {
-    Dart_EnterScope();
-    File* pprof_file =
-        File::Open(generate_pprof_symbols_filename, File::kWriteTruncate);
-    ASSERT(pprof_file != NULL);
-    void* buffer;
-    int buffer_size;
-    Dart_GetPprofSymbolInfo(&buffer, &buffer_size);
-    if (buffer_size > 0) {
-      ASSERT(buffer != NULL);
-      pprof_file->WriteFully(buffer, buffer_size);
-    }
-    delete pprof_file;  // Closes the file.
-    Dart_ExitScope();
-  }
-}
-
-
 #define CHECK_RESULT(result)                                                   \
   if (Dart_IsError(result)) {                                                  \
     *error = strdup(Dart_GetError(result));                                    \
     Dart_ExitScope();                                                          \
     Dart_ShutdownIsolate();                                                    \
     return false;                                                              \
   }                                                                            \
 
 
 // Returns true on success, false on failure.
@@ skipping 337 matching lines @@
   if (Dart_IsError(result)) {
     return ErrorExit("%s\n", Dart_GetError(result));
   }
   // Keep handling messages until the last active receive port is closed.
   result = Dart_RunLoop();
   if (Dart_IsError(result)) {
     return ErrorExit("%s\n", Dart_GetError(result));
   }
 
   Dart_ExitScope();
-  // Dump symbol information for the profiler.
-  DumpPprofSymbolInfo();
   // Shutdown the isolate.
   Dart_ShutdownIsolate();
   // Terminate process exit-code handler.
   Process::TerminateExitCodeHandler();
   // Free copied argument strings if converted.
   if (argv_converted) {
     for (int i = 0; i < argc; i++) free(argv[i]);
   }
 
   return Process::GlobalExitCode();
 }