Revert of Add d8 API for spawning function on a new thread (Second try)

src/d8.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_D8_H_
 #define V8_D8_H_
 
 #ifndef V8_SHARED
 #include "src/allocation.h"
 #include "src/hashmap.h"
-#include "src/list.h"
 #include "src/smart-pointers.h"
 #include "src/v8.h"
 #else
 #include "include/v8.h"
 #include "src/base/compiler-specific.h"
 #endif  // !V8_SHARED
 
 namespace v8 {
 
 
@@ skipping 139 matching lines @@
 #endif  // !V8_SHARED
 
   void ExitShell(int exit_code);
   Handle<String> ReadFile(Isolate* isolate, const char* name);
 
   const char** argv_;
   int begin_offset_;
   int end_offset_;
 };
 
-#ifndef V8_SHARED
-enum SerializationTag {
-  kSerializationTagUndefined,
-  kSerializationTagNull,
-  kSerializationTagTrue,
-  kSerializationTagFalse,
-  kSerializationTagNumber,
-  kSerializationTagString,
-  kSerializationTagArray,
-  kSerializationTagObject,
-  kSerializationTagArrayBuffer,
-  kSerializationTagTransferredArrayBuffer,
-  kSerializationTagTransferredSharedArrayBuffer,
-};
-
-
-class SerializationData {
- public:
-  SerializationData() {}
-  ~SerializationData();
-
-  void WriteTag(SerializationTag tag);
-  void WriteMemory(const void* p, int length);
-  void WriteArrayBufferContents(const ArrayBuffer::Contents& contents);
-  void WriteSharedArrayBufferContents(
-      const SharedArrayBuffer::Contents& contents);
-
-  template <typename T>
-  void Write(const T& data) {
-    WriteMemory(&data, sizeof(data));
-  }
-
-  SerializationTag ReadTag(int* offset) const;
-  void ReadMemory(void* p, int length, int* offset) const;
-  void ReadArrayBufferContents(ArrayBuffer::Contents* contents,
-                               int* offset) const;
-  void ReadSharedArrayBufferContents(SharedArrayBuffer::Contents* contents,
-                                     int* offset) const;
-
-  template <typename T>
-  T Read(int* offset) const {
-    T value;
-    ReadMemory(&value, sizeof(value), offset);
-    return value;
-  }
-
- private:
-  i::List<uint8_t> data;
-  i::List<ArrayBuffer::Contents> array_buffer_contents;
-  i::List<SharedArrayBuffer::Contents> shared_array_buffer_contents;
-};
-
-
-class SerializationDataQueue {
- public:
-  void Enqueue(SerializationData* data);
-  bool Dequeue(SerializationData** data);
-  bool IsEmpty();
-  void Clear();
-
- private:
-  base::Mutex mutex_;
-  i::List<SerializationData*> data_;
-};
-
-
-class Worker {
- public:
-  Worker();
-  ~Worker();
-
-  void StartExecuteInThread(Isolate* isolate, const char* function_string);
-  void PostMessage(SerializationData* data);
-  SerializationData* GetMessage();
-  void Terminate();
-
- private:
-  class WorkerThread : public base::Thread {
-   public:
-    explicit WorkerThread(Worker* worker)
-        : base::Thread(base::Thread::Options("WorkerThread")),
-          worker_(worker) {}
-
-    virtual void Run() { worker_->ExecuteInThread(); }
-
-   private:
-    Worker* worker_;
-  };
-
-  void ExecuteInThread();
-  void Cleanup();
-  static void PostMessageOut(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  base::Semaphore in_semaphore_;
-  base::Semaphore out_semaphore_;
-  SerializationDataQueue in_queue_;
-  SerializationDataQueue out_queue_;
-  base::Thread* thread_;
-  char* script_;
-};
-#endif  // !V8_SHARED
-
 
 class ShellOptions {
  public:
   ShellOptions()
       : script_executed(false),
         last_run(true),
         send_idle_notification(false),
         invoke_weak_callbacks(false),
         omit_quit(false),
         stress_opt(false),
@@ skipping 59 matching lines @@
   static void ReportException(Isolate* isolate, TryCatch* try_catch);
   static Handle<String> ReadFile(Isolate* isolate, const char* name);
   static Local<Context> CreateEvaluationContext(Isolate* isolate);
   static int RunMain(Isolate* isolate, int argc, char* argv[]);
   static int Main(int argc, char* argv[]);
   static void Exit(int exit_code);
   static void OnExit(Isolate* isolate);
   static void CollectGarbage(Isolate* isolate);
 
 #ifndef V8_SHARED
-  // TODO(binji): stupid implementation for now. Is there an easy way to hash an
-  // object for use in i::HashMap? By pointer?
-  typedef i::List<Handle<Object>> ObjectList;
-  static bool SerializeValue(Isolate* isolate, Handle<Value> value,
-                             const ObjectList& to_transfer,
-                             ObjectList* seen_objects,
-                             SerializationData* out_data);
-  static MaybeLocal<Value> DeserializeValue(Isolate* isolate,
-                                            const SerializationData& data,
-                                            int* offset);
-  static void CleanupWorkers();
   static Handle<Array> GetCompletions(Isolate* isolate,
                                       Handle<String> text,
                                       Handle<String> full);
   static int* LookupCounter(const char* name);
   static void* CreateHistogram(const char* name,
                                int min,
                                int max,
                                size_t buckets);
   static void AddHistogramSample(void* histogram, int sample);
   static void MapCounters(v8::Isolate* isolate, const char* name);
@@ skipping 23 matching lines @@
   static void Write(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Quit(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Version(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
   static Handle<String> ReadFromStdin(Isolate* isolate);
   static void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
     args.GetReturnValue().Set(ReadFromStdin(args.GetIsolate()));
   }
   static void Load(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void WorkerNew(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void WorkerPostMessage(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void WorkerGetMessage(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void WorkerTerminate(const v8::FunctionCallbackInfo<v8::Value>& args);
   // The OS object on the global object contains methods for performing
   // operating system calls:
   //
   // os.system("program_name", ["arg1", "arg2", ...], timeout1, timeout2) will
   // run the command, passing the arguments to the program.  The standard output
   // of the program will be picked up and returned as a multiline string.  If
   // timeout1 is present then it should be a number.  -1 indicates no timeout
   // and a positive number is used as a timeout in milliseconds that limits the
   // time spent waiting between receiving output characters from the program.
   // timeout2, if present, should be a number indicating the limit in
@@ skipping 19 matching lines @@
   static void UnsetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void SetUMask(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void MakeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
   static void RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
 
   static void AddOSMethods(v8::Isolate* isolate,
                            Handle<ObjectTemplate> os_template);
 
   static const char* kPrompt;
   static ShellOptions options;
-  static ArrayBuffer::Allocator* array_buffer_allocator;
 
  private:
   static Persistent<Context> evaluation_context_;
 #ifndef V8_SHARED
   static Persistent<Context> utility_context_;
   static CounterMap* counter_map_;
   // We statically allocate a set of local counters to be used if we
   // don't want to store the stats in a memory-mapped file
   static CounterCollection local_counters_;
   static CounterCollection* counters_;
   static base::OS::MemoryMappedFile* counters_file_;
   static base::Mutex context_mutex_;
   static const base::TimeTicks kInitialTicks;
-  static Worker worker_;
-  static i::List<SharedArrayBuffer::Contents> externalized_shared_contents_;
 
   static Counter* GetCounter(const char* name, bool is_histogram);
   static void InstallUtilityScript(Isolate* isolate);
 #endif  // !V8_SHARED
   static void Initialize(Isolate* isolate);
   static void InitializeDebugger(Isolate* isolate);
   static void RunShell(Isolate* isolate);
   static bool SetOptions(int argc, char* argv[]);
   static Handle<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate);
 };
 
 
 }  // namespace v8
 
 
 #endif  // V8_D8_H_