New compilation API, part 2.

include/v8.h

 // Copyright 2012 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 1079 matching lines @@
 class V8_EXPORT ScriptCompiler {
  public:
   /**
    * Compilation data that the embedder can cache and pass back to speed up
    * future compilations. The data is produced if the CompilerOptions passed to
    * the compilation functions in ScriptCompiler contains produce_data_to_cache
    * = true. The data to cache can then can be retrieved from
    * UnboundScript.
    */
   struct V8_EXPORT CachedData {
-    CachedData() : data(NULL), length(0) {}
+    CachedData() : data(NULL), length(0), owns_buffer(false) {}
     // Caller keeps the ownership of data and guarantees that the data stays
     // alive long enough.
-    CachedData(const uint8_t* data, int length) : data(data), length(length) {}
+    CachedData(const uint8_t* data, int length, bool owns_buffer = false);

[dcarney, 2014/03/18 14:34:44]

make enum

[marja, 2014/03/18 16:11:05]

Done.

+    ~CachedData();
     // TODO(marja): Async compilation; add constructors which take a callback
     // which will be called when V8 no longer needs the data.
     const uint8_t* data;
     int length;
+    bool owns_buffer;
+
+  private:
+     // Prevent copying. Not implemented.
+     CachedData(const CachedData&);
   };
 
   /**
    * Source code which can be then compiled to a UnboundScript or
    * BoundScript.
    */
-  struct V8_EXPORT Source {
+  class V8_EXPORT Source {
+   public:
+    // Source takes ownership of CachedData.
     Source(Local<String> source_string, const ScriptOrigin& origin,
-           const CachedData& cached_data = CachedData());
-    Source(Local<String> source_string,
-           const CachedData& cached_data = CachedData());
+           CachedData* cached_data = NULL);
+    Source(Local<String> source_string, CachedData* cached_data = NULL);
+    ~Source();
+
+    // Ownership of the CachedData or its buffers is *not* transferred to the
+    // caller. The CachedData object is alive as long as the Source object is
+    // alive.
+    const CachedData* GetCachedData() const;
+
+   private:
+    friend class ScriptCompiler;
+     // Prevent copying. Not implemented.
+    Source(const Source&);
 
     Local<String> source_string;
 
     // Origin information
     Handle<Value> resource_name;
     Handle<Integer> resource_line_offset;
     Handle<Integer> resource_column_offset;
     Handle<Boolean> resource_is_shared_cross_origin;
 
-    // Cached data from previous compilation (if any).
-    CachedData cached_data;
+    // Cached data from previous compilation (if any), or generated during
+    // compilation (if the generate_cached_data flag is passed to
+    // ScriptCompiler).
+    CachedData* cached_data;
   };
 
   enum CompileOptions {
     kNoCompileOptions,
     kProduceDataToCache = 1 << 0
   };
 
   /**
    * Compiles the specified script (context-independent).
    *
    * \param source Script source code.
    * \return Compiled script object (context independent; for running it must be
    *   bound to a context).
    */
   static Local<UnboundScript> CompileUnbound(
-      Isolate* isolate, const Source& source,
+      Isolate* isolate, Source* source,
       CompileOptions options = kNoCompileOptions);
 
   /**
    * Compiles the specified script (bound to current context).
    *
    * \param source Script source code.
    * \param pre_data Pre-parsing data, as obtained by ScriptData::PreCompile()
    *   using pre_data speeds compilation if it's done multiple times.
    *   Owned by caller, no references are kept when this function returns.
    * \return Compiled script object, bound to the context that was active
    *   when this function was called. When run it will always use this
    *   context.
    */
   static Local<Script> Compile(
-      Isolate* isolate, const Source& source,
+      Isolate* isolate, Source* source,
       CompileOptions options = kNoCompileOptions);
 };
 
 
 /**
  * An error message.
  */
 class V8_EXPORT Message {
  public:
   Local<String> Get() const;
@@ skipping 5371 matching lines @@
  */
 
 
 }  // namespace v8
 
 
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_