Changed the debugger message API to receive an object instead of a JSON string

src/debug.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 23 matching lines @@
 #include "compiler.h"
 #include "debug.h"
 #include "execution.h"
 #include "global-handles.h"
 #include "ic.h"
 #include "ic-inl.h"
 #include "natives.h"
 #include "stub-cache.h"
 #include "log.h"
 
+#include "../include/v8-debug.h"
+
 namespace v8 { namespace internal {
 
 #ifdef ENABLE_DEBUGGER_SUPPORT
 static void PrintLn(v8::Local<v8::Value> value) {
   v8::Local<v8::String> s = value->ToString();
   char* data = NewArray<char>(s->Length() + 1);
   if (data == NULL) {
     V8::FatalProcessOutOfMemory("PrintLn");
     return;
   }
@@ skipping 316 matching lines @@
     // Patch the code to invoke the builtin debug break function matching the
     // calling convention used by the call site.
     Handle<Code> dbgbrk_code(Debug::FindDebugBreak(code, mode));
     rinfo()->set_target_address(dbgbrk_code->entry());
 
     // For stubs that refer back to an inlined version clear the cached map for
     // the inlined case to always go through the IC. As long as the break point
     // is set the patching performed by the runtime system will take place in
     // the code copy and will therefore have no effect on the running code
     // keeping it from using the inlined code.
-    if (code->is_keyed_load_stub()) KeyedLoadIC::ClearInlinedVersion(pc());
+    if (code->is_keyed_load_stub() && KeyedLoadIC::HasInlinedVersion(pc())) {
+      KeyedLoadIC::ClearInlinedVersion(pc());
+    }
   }
 }
 
 
 void BreakLocationIterator::ClearDebugBreakAtIC() {
   // Patch the code to the original invoke.
   rinfo()->set_target_address(original_rinfo()->target_address());
 }
 
 
@@ skipping 1154 matching lines @@
   Handle<Object> event_data;
   if (!caught_exception) {
     event_data = MakeExceptionEvent(exec_state, exception, uncaught,
                                     &caught_exception);
   }
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
 
-  // Process debug event
-  ProcessDebugEvent(v8::Exception, event_data, false);
+  // Process debug event.
+  ProcessDebugEvent(v8::Exception, Handle<JSObject>::cast(event_data), false);
   // Return to continue execution from where the exception was thrown.
 }
 
 
 void Debugger::OnDebugBreak(Handle<Object> break_points_hit,
                             bool auto_continue) {
   HandleScope scope;
 
   // Debugger has already been entered by caller.
   ASSERT(Top::context() == *Debug::debug_context());
@@ skipping 10 matching lines @@
   Handle<Object> event_data;
   if (!caught_exception) {
     event_data = MakeBreakEvent(exec_state, break_points_hit,
                                 &caught_exception);
   }
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
 
-  // Process debug event
-  ProcessDebugEvent(v8::Break, event_data, auto_continue);
+  // Process debug event.
+  ProcessDebugEvent(v8::Break,
+                    Handle<JSObject>::cast(event_data),
+                    auto_continue);
 }
 
 
 void Debugger::OnBeforeCompile(Handle<Script> script) {
   HandleScope scope;
 
   // Bail out based on state or if there is no listener for this event
   if (Debug::InDebugger()) return;
   if (compiling_natives()) return;
   if (!EventActive(v8::BeforeCompile)) return;
 
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter()) return;
 
   // Create the event data object.
   bool caught_exception = false;
   Handle<Object> event_data = MakeCompileEvent(script, true, &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
 
-  // Process debug event
-  ProcessDebugEvent(v8::BeforeCompile, event_data, true);
+  // Process debug event.
+  ProcessDebugEvent(v8::BeforeCompile,
+                    Handle<JSObject>::cast(event_data),
+                    true);
 }
 
 
 // Handle debugger actions when a new script is compiled.
 void Debugger::OnAfterCompile(Handle<Script> script, Handle<JSFunction> fun) {
   HandleScope scope;
 
   // No compile events while compiling natives.
   if (compiling_natives()) return;
 
@@ skipping 39 matching lines @@
   if (!Debugger::EventActive(v8::AfterCompile)) return;
 
   // Create the compile state object.
   Handle<Object> event_data = MakeCompileEvent(script,
                                                false,
                                                &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
-  // Process debug event
-  ProcessDebugEvent(v8::AfterCompile, event_data, true);
+  // Process debug event.
+  ProcessDebugEvent(v8::AfterCompile,
+                    Handle<JSObject>::cast(event_data),
+                    true);
 }
 
 
 void Debugger::OnNewFunction(Handle<JSFunction> function) {
   return;
   HandleScope scope;
 
   // Bail out based on state or if there is no listener for this event
   if (Debug::InDebugger()) return;
   if (compiling_natives()) return;
   if (!Debugger::EventActive(v8::NewFunction)) return;
 
   // Enter the debugger.
   EnterDebugger debugger;
   if (debugger.FailedToEnter()) return;
 
   // Create the event object.
   bool caught_exception = false;
   Handle<Object> event_data = MakeNewFunctionEvent(function, &caught_exception);
   // Bail out and don't call debugger if exception.
   if (caught_exception) {
     return;
   }
   // Process debug event.
-  ProcessDebugEvent(v8::NewFunction, event_data, true);
+  ProcessDebugEvent(v8::NewFunction, Handle<JSObject>::cast(event_data), true);
 }
 
 
 void Debugger::ProcessDebugEvent(v8::DebugEvent event,
-                                 Handle<Object> event_data,
+                                 Handle<JSObject> event_data,
                                  bool auto_continue) {
   HandleScope scope;
 
   // Create the execution state.
   bool caught_exception = false;
   Handle<Object> exec_state = MakeExecutionState(&caught_exception);
   if (caught_exception) {
     return;
   }
   // First notify the message handler if any.
   if (message_handler_ != NULL) {
-    NotifyMessageHandler(event, exec_state, event_data, auto_continue);
+    NotifyMessageHandler(event,
+                         Handle<JSObject>::cast(exec_state),
+                         event_data,
+                         auto_continue);
   }
   // Notify registered debug event listener. This can be either a C or a
   // JavaScript function.
   if (!event_listener_.is_null()) {
     if (event_listener_->IsProxy()) {
       // C debug event listener.
       Handle<Proxy> callback_obj(Handle<Proxy>::cast(event_listener_));
       v8::Debug::EventCallback callback =
             FUNCTION_CAST<v8::Debug::EventCallback>(callback_obj->proxy());
       callback(event,
                v8::Utils::ToLocal(Handle<JSObject>::cast(exec_state)),
-               v8::Utils::ToLocal(Handle<JSObject>::cast(event_data)),
+               v8::Utils::ToLocal(event_data),
                v8::Utils::ToLocal(Handle<Object>::cast(event_listener_data_)));
     } else {
       // JavaScript debug event listener.
       ASSERT(event_listener_->IsJSFunction());
       Handle<JSFunction> fun(Handle<JSFunction>::cast(event_listener_));
 
       // Invoke the JavaScript debug event listener.
       const int argc = 4;
       Object** argv[argc] = { Handle<Object>(Smi::FromInt(event)).location(),
                               exec_state.location(),
-                              event_data.location(),
+                              Handle<Object>::cast(event_data).location(),
                               event_listener_data_.location() };
       Handle<Object> result = Execution::TryCall(fun, Top::global(),
                                                  argc, argv, &caught_exception);
       if (caught_exception) {
         // Silently ignore exceptions from debug event listeners.
       }
     }
   }
 
   // Clear the mirror cache.
   Debug::ClearMirrorCache();
 }
 
 
 void Debugger::UnloadDebugger() {
   // Make sure that there are no breakpoints left.
   Debug::ClearAllBreakPoints();
 
   // Unload the debugger if feasible.
   if (!never_unload_debugger_) {
     Debug::Unload();
   }
 
   // Clear the flag indicating that the message handler was recently cleared.
   message_handler_cleared_ = false;
 }
 
 
 void Debugger::NotifyMessageHandler(v8::DebugEvent event,
-                                    Handle<Object> exec_state,
-                                    Handle<Object> event_data,
+                                    Handle<JSObject> exec_state,
+                                    Handle<JSObject> event_data,
                                     bool auto_continue) {
   HandleScope scope;
 
   if (!Debug::Load()) return;
 
   // Process the individual events.
   bool sendEventMessage = false;
   switch (event) {
     case v8::Break:
       sendEventMessage = !auto_continue;
@@ skipping 14 matching lines @@
 
   // The debug command interrupt flag might have been set when the command was
   // added. It should be enough to clear the flag only once while we are in the
   // debugger.
   ASSERT(Debug::InDebugger());
   StackGuard::Continue(DEBUGCOMMAND);
 
   // Notify the debugger that a debug event has occurred unless auto continue is
   // active in which case no event is send.
   if (sendEventMessage) {
-    InvokeMessageHandlerWithEvent(event_data);
+    MessageImpl message = MessageImpl::NewEvent(
+        event,
+        auto_continue,
+        Handle<JSObject>::cast(exec_state),
+        Handle<JSObject>::cast(event_data));
+    InvokeMessageHandler(message);
   }
   if (auto_continue && !HasCommands()) {
     return;
   }
 
   // Get the DebugCommandProcessor.
   v8::Local<v8::Object> api_exec_state =
       v8::Utils::ToLocal(Handle<JSObject>::cast(exec_state));
   v8::Local<v8::String> fun_name =
       v8::String::New("debugCommandProcessor");
@@ skipping 34 matching lines @@
     // Invoke JavaScript to process the debug request.
     v8::Local<v8::String> fun_name;
     v8::Local<v8::Function> fun;
     v8::Local<v8::Value> request;
     v8::TryCatch try_catch;
     fun_name = v8::String::New("processDebugRequest");
     fun = v8::Function::Cast(*cmd_processor->Get(fun_name));
 
     request = v8::String::New(command.text().start(),
                               command.text().length());
-    command.text().Dispose();
     static const int kArgc = 1;
     v8::Handle<Value> argv[kArgc] = { request };
     v8::Local<v8::Value> response_val = fun->Call(cmd_processor, kArgc, argv);
 
     // Get the response.
     v8::Local<v8::String> response;
     bool running = false;
     if (!try_catch.HasCaught()) {
       // Get response string.
       if (!response_val->IsUndefined()) {
@@ skipping 16 matching lines @@
       v8::Local<v8::Value> running_val = fun->Call(cmd_processor, kArgc, argv);
       if (!try_catch.HasCaught()) {
         running = running_val->ToBoolean()->Value();
       }
     } else {
       // In case of failure the result text is the exception text.
       response = try_catch.Exception()->ToString();
     }
 
     // Return the result.
-    InvokeMessageHandler(response, command.client_data());
+    MessageImpl message = MessageImpl::NewResponse(
+        event,
+        running,
+        Handle<JSObject>::cast(exec_state),
+        Handle<JSObject>::cast(event_data),
+        Handle<String>(Utils::OpenHandle(*response)),
+        command.client_data());
+    InvokeMessageHandler(message);
+    command.Dispose();
 
     // Return from debug event processing if either the VM is put into the
     // runnning state (through a continue command) or auto continue is active
     // and there are no more commands queued.
     if (running || (auto_continue && !HasCommands())) {
       return;
     }
   }
 }
 
@@ skipping 50 matching lines @@
 
 
 void Debugger::SetHostDispatchHandler(v8::Debug::HostDispatchHandler handler,
                                       int period) {
   host_dispatch_handler_ = handler;
   host_dispatch_micros_ = period * 1000;
 }
 
 
 // Calls the registered debug message handler. This callback is part of the
-// public API. Messages are kept internally as Vector<uint16_t> strings, which
-// are allocated in various places and deallocated by the calling function
-// sometime after this call.
-void Debugger::InvokeMessageHandler(v8::Handle<v8::String> output,
-                                    v8::Debug::ClientData* data) {
+// public API.
+void Debugger::InvokeMessageHandler(MessageImpl message) {
   ScopedLock with(debugger_access_);
 
   if (message_handler_ != NULL) {
-    Vector<uint16_t> text = Vector<uint16_t>::New(output->Length());
-    output->Write(text.start(), 0, output->Length());
-
-    message_handler_(text.start(),
-                     text.length(),
-                     data);
-
-    text.Dispose();
+    message_handler_(message);
   }
-  delete data;
-}
-
-
-bool Debugger::InvokeMessageHandlerWithEvent(Handle<Object> event_data) {
-  v8::HandleScope scope;
-  // Call toJSONProtocol on the debug event object.
-  v8::Local<v8::Object> api_event_data =
-      v8::Utils::ToLocal(Handle<JSObject>::cast(event_data));
-  v8::Local<v8::String> fun_name = v8::String::New("toJSONProtocol");
-  v8::Local<v8::Function> fun =
-      v8::Function::Cast(*api_event_data->Get(fun_name));
-  v8::TryCatch try_catch;
-  v8::Local<v8::Value> json_event = *fun->Call(api_event_data, 0, NULL);
-  v8::Local<v8::String> json_event_string;
-  if (!try_catch.HasCaught()) {
-    if (!json_event->IsUndefined()) {
-      json_event_string = json_event->ToString();
-      if (FLAG_trace_debug_json) {
-        PrintLn(json_event_string);
-      }
-      InvokeMessageHandler(json_event_string,
-                           NULL /* no user data since there was no request */);
-    } else {
-      InvokeMessageHandler(v8::String::Empty(), NULL);
-    }
-  } else {
-    PrintLn(try_catch.Exception());
-    return false;
-  }
-  return true;
 }
 
 
 // Puts a command coming from the public API on the queue.  Creates
 // a copy of the command string managed by the debugger.  Up to this
 // point, the command data was managed by the API client.  Called
 // by the API client thread.
 void Debugger::ProcessCommand(Vector<const uint16_t> command,
                               v8::Debug::ClientData* client_data) {
   // Need to cast away const.
@@ skipping 65 matching lines @@
 void Debugger::StopAgent() {
   if (agent_ != NULL) {
     agent_->Shutdown();
     agent_->Join();
     delete agent_;
     agent_ = NULL;
   }
 }
 
 
+MessageImpl MessageImpl::NewEvent(DebugEvent event,
+                                  bool running,
+                                  Handle<JSObject> exec_state,
+                                  Handle<JSObject> event_data) {
+  MessageImpl message(true, event, running,
+                      exec_state, event_data, Handle<String>(), NULL);
+  return message;
+}
+
+
+MessageImpl MessageImpl::NewResponse(DebugEvent event,
+                                     bool running,
+                                     Handle<JSObject> exec_state,
+                                     Handle<JSObject> event_data,
+                                     Handle<String> response_json,
+                                     v8::Debug::ClientData* client_data) {
+  MessageImpl message(false, event, running,
+                      exec_state, event_data, response_json, client_data);
+  return message;
+}
+
+
+MessageImpl::MessageImpl(bool is_event,
+                         DebugEvent event,
+                         bool running,
+                         Handle<JSObject> exec_state,
+                         Handle<JSObject> event_data,
+                         Handle<String> response_json,
+                         v8::Debug::ClientData* client_data)
+    : is_event_(is_event),
+      event_(event),
+      running_(running),
+      exec_state_(exec_state),
+      event_data_(event_data),
+      response_json_(response_json),
+      client_data_(client_data) {}
+
+
+bool MessageImpl::IsEvent() const {
+  return is_event_;
+}
+
+
+bool MessageImpl::IsResponse() const {
+  return !is_event_;
+}
+
+
+DebugEvent MessageImpl::GetEvent() const {
+  return event_;
+}
+
+
+bool MessageImpl::WillStartRunning() const {
+  return running_;
+}
+
+
+v8::Handle<v8::Object> MessageImpl::GetExecutionState() const {
+  return v8::Utils::ToLocal(exec_state_);
+}
+
+
+v8::Handle<v8::Object> MessageImpl::GetEventData() const {
+  return v8::Utils::ToLocal(event_data_);
+}
+
+
+v8::Handle<v8::String> MessageImpl::GetJSON() const {
+  v8::HandleScope scope;
+
+  if (IsEvent()) {
+    // Call toJSONProtocol on the debug event object.
+    Handle<Object> fun = GetProperty(event_data_, "toJSONProtocol");
+    if (!fun->IsJSFunction()) {
+      return v8::Handle<v8::String>();
+    }
+    bool caught_exception;
+    Handle<Object> json = Execution::TryCall(Handle<JSFunction>::cast(fun),
+                                             event_data_,
+                                             0, NULL, &caught_exception);
+    if (caught_exception || !json->IsString()) {
+      return v8::Handle<v8::String>();
+    }
+    return scope.Close(v8::Utils::ToLocal(Handle<String>::cast(json)));
+  } else {
+    return v8::Utils::ToLocal(response_json_);
+  }
+}
+
+
+v8::Handle<v8::Context> MessageImpl::GetEventContext() const {
+  return v8::Handle<v8::Context>();
+}
+
+
+v8::Debug::ClientData* MessageImpl::GetClientData() const {
+  return client_data_;
+}
+
+
 CommandMessage::CommandMessage() : text_(Vector<uint16_t>::empty()),
                                    client_data_(NULL) {
 }
 
 
 CommandMessage::CommandMessage(const Vector<uint16_t>& text,
                                v8::Debug::ClientData* data)
     : text_(text),
       client_data_(data) {
 }
@@ skipping 95 matching lines @@
 
 
 void LockingCommandMessageQueue::Clear() {
   ScopedLock sl(lock_);
   queue_.Clear();
 }
 
 #endif  // ENABLE_DEBUGGER_SUPPORT
 
 } }  // namespace v8::internal