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) {}
+    enum BufferPolicy {
+      BufferNotOwned,
+      BufferOwned
+    };
+
+    CachedData() : data(NULL), length(0), buffer_policy(BufferNotOwned) {}
     // Caller keeps the ownership of data and guarantees that the data stays
     // alive long enough.

[Sven Panne, 2014/03/19 12:04:52]

I think the comment is out of date. Furthermore, we should note that if the data
is owned by CachedData, it will be deleted via 'delete[]'.

[marja, 2014/03/19 12:23:48]

Updated the comment to be:

If buffer_policy is BufferNotOwned, the caller keeps the ownership of data and
guarantees that it stays alive until the CachedData object is destroyed. If the
policy is BufferOwned, the given data will be deleted (with delete[]) when the
CachedData object is destroyed.

-    CachedData(const uint8_t* data, int length) : data(data), length(length) {}
+    CachedData(const uint8_t* data, int length,
+               BufferPolicy buffer_policy = BufferNotOwned);
+    ~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;
+    BufferPolicy buffer_policy;
+
+  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_