Patch for allowing several V8 instances in process:...

src/log-utils.h

 // Copyright 2006-2009 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 69 matching lines @@
   const int max_size_;
   const char* seal_;
   const int seal_size_;
   ScopedVector<char*> blocks_;
   int write_pos_;
   int block_index_;
   int block_write_pos_;
   bool is_sealed_;
 };
 
+class LogData {
+  // Whether logging is stopped (e.g. due to insufficient resources).
+  bool is_stopped_;
+
+  // When logging is active, either output_handle_ or output_buffer_ is used
+  // to store a pointer to log destination. If logging was opened via OpenStdout
+  // or OpenFile, then output_handle_ is used. If logging was opened
+  // via OpenMemoryBuffer, then output_buffer_ is used.
+  // mutex_ should be acquired before using output_handle_ or output_buffer_.
+  FILE* output_handle_;
+
+  LogDynamicBuffer* output_buffer_;
+
+  // mutex_ is a Mutex used for enforcing exclusive
+  // access to the formatting buffer and the log file or log memory buffer.
+  Mutex* mutex_;
+
+  // Buffer used for formatting log messages. This is a singleton buffer and
+  // mutex_ should be acquired before using it.
+  char* message_buffer_;
+
+  typedef int (*WritePtr)(const char* msg, int length);
+  // Write functions assume that mutex_ is acquired by the caller.
+  WritePtr Write;
+
+  // A handler that is called when Log::Write fails.
+  typedef void (*WriteFailureHandler)();
+
+  WriteFailureHandler write_failure_handler;
+
+  void set_write_failure_handler(WriteFailureHandler handler) {
+    write_failure_handler = handler;
+  }
+
+  friend class V8Context;
+  friend class Log;
+  friend class Logger;
+  friend class LogMessageBuilder;
+
+  LogData();
+  DISALLOW_COPY_AND_ASSIGN(LogData);
+};
 
 // Functions and data for performing output of log messages.
 class Log : public AllStatic {
  public:
   // Opens stdout for logging.
   static void OpenStdout();
 
   // Opens file for logging.
   static void OpenFile(const char* name);
 
   // Opens memory buffer for logging.
   static void OpenMemoryBuffer();
 
   // Disables logging, but preserves acquired resources.
-  static void stop() { is_stopped_ = true; }
+  static void stop() {
+    v8_context()->log_data_.is_stopped_ = true;
+  }
 
   // Frees all resources acquired in Open... functions.
   static void Close();
 
   // See description in include/v8.h.
   static int GetLogLines(int from_pos, char* dest_buf, int max_size);
 
   // Returns whether logging is enabled.
   static bool IsEnabled() {
-    return !is_stopped_ && (output_handle_ != NULL || output_buffer_ != NULL);
+    LogData& log_data = v8_context()->log_data_;
+    return !log_data.is_stopped_ &&
+      (log_data.output_handle_ != NULL || log_data.output_buffer_ != NULL);
   }
 
   // Size of buffer used for formatting log messages.
   static const int kMessageBufferSize = 2048;
 
  private:
-  typedef int (*WritePtr)(const char* msg, int length);
-
   // Initialization function called from Open... functions.
   static void Init();
 
-  // Write functions assume that mutex_ is acquired by the caller.
-  static WritePtr Write;
-
   // Implementation of writing to a log file.
   static int WriteToFile(const char* msg, int length) {
-    ASSERT(output_handle_ != NULL);
-    size_t rv = fwrite(msg, 1, length, output_handle_);
+    LogData& log_data = v8_context()->log_data_;
+    ASSERT(log_data.output_handle_ != NULL);
+    size_t rv = fwrite(msg, 1, length, log_data.output_handle_);
     ASSERT(static_cast<size_t>(length) == rv);
     USE(rv);
     return length;
   }
 
   // Implementation of writing to a memory buffer.
   static int WriteToMemory(const char* msg, int length) {
-    ASSERT(output_buffer_ != NULL);
-    return output_buffer_->Write(msg, length);
+    LogData& log_data = v8_context()->log_data_;
+    ASSERT(log_data.output_buffer_ != NULL);
+    return log_data.output_buffer_->Write(msg, length);
   }
 
-  // Whether logging is stopped (e.g. due to insufficient resources).
-  static bool is_stopped_;
-
-  // When logging is active, either output_handle_ or output_buffer_ is used
-  // to store a pointer to log destination. If logging was opened via OpenStdout
-  // or OpenFile, then output_handle_ is used. If logging was opened
-  // via OpenMemoryBuffer, then output_buffer_ is used.
-  // mutex_ should be acquired before using output_handle_ or output_buffer_.
-  static FILE* output_handle_;
-
-  static LogDynamicBuffer* output_buffer_;
-
-  // Size of dynamic buffer block (and dynamic buffer initial size).
+// Size of dynamic buffer block (and dynamic buffer initial size).
   static const int kDynamicBufferBlockSize = 65536;
 
   // Maximum size of dynamic buffer.
   static const int kMaxDynamicBufferSize = 50 * 1024 * 1024;
 
   // Message to "seal" dynamic buffer with.
-  static const char* kDynamicBufferSeal;
-
-  // mutex_ is a Mutex used for enforcing exclusive
-  // access to the formatting buffer and the log file or log memory buffer.
-  static Mutex* mutex_;
-
-  // Buffer used for formatting log messages. This is a singleton buffer and
-  // mutex_ should be acquired before using it.
-  static char* message_buffer_;
+  static const char kDynamicBufferSeal[];
 
   friend class LogMessageBuilder;
   friend class LogRecordCompressor;
 };
 
 
 // An utility class for performing backward reference compression
 // of string ends. It operates using a window of previous strings.
 class LogRecordCompressor {
  public:
@@ skipping 82 matching lines @@
   // Does the same at the version without arguments, and sets a prefix.
   bool RetrieveCompressedPrevious(LogRecordCompressor* compressor,
                                   const char* prefix);
 
   // Write the log message to the log file currently opened.
   void WriteToLogFile();
 
   // Write a null-terminated string to to the log file currently opened.
   void WriteCStringToLogFile(const char* str);
 
-  // A handler that is called when Log::Write fails.
-  typedef void (*WriteFailureHandler)();
-
-  static void set_write_failure_handler(WriteFailureHandler handler) {
-    write_failure_handler = handler;
-  }
-
  private:
-  static WriteFailureHandler write_failure_handler;
-
+  LogData& log_data_;
   ScopedLock sl;
   int pos_;
 };
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 } }  // namespace v8::internal
 
 #endif  // V8_LOG_UTILS_H_