Remove support for logging into a memory buffer.

src/runtime.cc

 // Copyright 2011 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 12135 matching lines @@
   return isolate->heap()->undefined_value();
 }
 
 
 RUNTIME_FUNCTION(MaybeObject*, Runtime_ProfilerPause) {
   NoHandleAllocation ha;
   v8::V8::PauseProfiler();
   return isolate->heap()->undefined_value();
 }
 
+
+static v8::Handle<v8::Value> EmptyMethod(const v8::Arguments& args) {
+  return v8::Handle<v8::Value>();
+}
+

[Søren Thygesen Gjesse, 2011/07/07 11:59:53]

I don't think that specialized testing functions like CreateClassWithCallback
and CreateClassWithGetterAndSetter realy belong in runtime.cc. Please rewrite
the tests using these as cctests.

[mnaganov (inactive), 2011/07/07 20:19:57]

Those tests were cctests initially. Two reasons I've converted them into mjsunit
tests (and moved utility code into runtime): 1) parsing logs in JS is much
easier that in C++ code; 2) I already have implemented support for passing logs
data into mjsunit tests, so I thought it would be a good idea to reuse it for
these two tests.

Perhaps, we can generalize them to make more useful for runtime? Something
similar to CreateApiFunction? What do you think?

+RUNTIME_FUNCTION(MaybeObject*, Runtime_CreateClassWithCallback) {
+  ASSERT(args.length() == 2);
+  CONVERT_ARG_CHECKED(String, className, 0);
+  CONVERT_ARG_CHECKED(String, methodName, 1);
+  v8::HandleScope scope;
+  v8::Handle<v8::FunctionTemplate> obj = v8::FunctionTemplate::New();
+  obj->SetClassName(v8::Handle<v8::String>(ToApi<v8::String>(className)));
+  v8::Handle<v8::ObjectTemplate> proto(obj->PrototypeTemplate());
+  v8::Local<v8::Signature> signature = v8::Signature::New(obj);
+  proto->Set(
+      v8::Handle<v8::String>(ToApi<v8::String>(methodName)),
+      v8::FunctionTemplate::New(EmptyMethod,
+                                v8::Handle<v8::Value>(),
+                                signature),
+      static_cast<v8::PropertyAttribute>(v8::DontDelete));
+  return *Utils::OpenHandle(*obj->GetFunction());
+}
+
+
+static v8::Handle<v8::Value> EmptyGetter(v8::Local<v8::String> property,
+                                         const v8::AccessorInfo& info) {
+  return v8::Handle<v8::Value>();
+}
+
+static void EmptySetter(v8::Local<v8::String> property,
+                         v8::Local<v8::Value> value,
+                         const v8::AccessorInfo& info) {
+}
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_CreateClassWithGetterAndSetter) {
+  ASSERT(args.length() == 3);
+  CONVERT_ARG_CHECKED(String, className, 0);
+  CONVERT_ARG_CHECKED(String, property1Name, 1);
+  CONVERT_ARG_CHECKED(String, property2Name, 2);
+  v8::HandleScope scope;
+  v8::Handle<v8::FunctionTemplate> obj = v8::FunctionTemplate::New();
+  obj->SetClassName(v8::Handle<v8::String>(ToApi<v8::String>(className)));
+  v8::Handle<v8::ObjectTemplate> inst = obj->InstanceTemplate();
+  inst->SetAccessor(v8::Handle<v8::String>(ToApi<v8::String>(property1Name)),
+                    EmptyGetter,
+                    EmptySetter);
+  inst->SetAccessor(v8::Handle<v8::String>(ToApi<v8::String>(property2Name)),
+                    EmptyGetter);
+  return *Utils::OpenHandle(*obj->GetFunction());
+}
+
+RUNTIME_FUNCTION(MaybeObject*, Runtime_LogCompiledFunctions) {
+  bool old_log_code = FLAG_log_code;
+  FLAG_log_code = true;
+  isolate->logger()->LogCompiledFunctions();
+  isolate->logger()->LogAccessorCallbacks();
+  FLAG_log_code = old_log_code;
+  return isolate->heap()->undefined_value();
+}
+
+// Doesn't require debugger context.
+RUNTIME_FUNCTION(MaybeObject*, Runtime_CollectGarbage2) {

[Søren Thygesen Gjesse, 2011/07/07 11:59:53]

I don't see any difference between this and the existing Runtime_CollectGarbage.

[mnaganov (inactive), 2011/07/07 20:19:57]

My bad. I was receiving "illegal access" error, and wrongly attributed it to the
fact that the function is declared in "debugger support" list, and thus requires
to be called from some special context. But then I found that it simply requires
one argument which it doesn't actually use.

Removed.

+  isolate->heap()->CollectAllGarbage(true);
+  return isolate->heap()->undefined_value();
+}
+
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 // Finds the script object from the script data. NOTE: This operation uses
 // heap traversal to find the function generated for the source position
 // for the requested break point. For lazily compiled functions several heap
 // traversals might be required rendering this operation as a rather slow
 // operation. However for setting break points which is normally done through
 // some kind of user interaction the performance is not crucial.
 static Handle<Object> Runtime_GetScriptFromScriptName(
     Handle<String> script_name) {
@@ skipping 440 matching lines @@
   } else {
     // Handle last resort GC and make sure to allow future allocations
     // to grow the heap without causing GCs (if possible).
     isolate->counters()->gc_last_resort_from_js()->Increment();
     isolate->heap()->CollectAllGarbage(false);
   }
 }
 
 
 } }  // namespace v8::internal