Disallow copy and assigning a few public objects.

include/v8.h

 // Copyright 2007-2008 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 765 matching lines @@
      * buffer.
      */
     virtual ~ExternalStringResource() {}
     /** The string data from the underlying buffer.*/
     virtual const uint16_t* data() const = 0;
     /** The length of the string. That is, the number of two-byte characters.*/
     virtual size_t length() const = 0;
    protected:
     ExternalStringResource() {}
    private:
+    // Disallow copying and assigning.
     ExternalStringResource(const ExternalStringResource&);
     void operator=(const ExternalStringResource&);
   };
 
   /**
    * An ExternalAsciiStringResource is a wrapper around an ascii
    * string buffer that resides outside V8's heap. Implement an
    * ExternalAsciiStringResource to manage the life cycle of the
    * underlying buffer.  Note that the string data must be immutable
    * and that the data must be strict 7-bit ASCII, not Latin1 or
    * UTF-8, which would require special treatment internally in the
    * engine and, in the case of UTF-8, do not allow efficient indexing.
    * Use String::New or convert to 16 bit data for non-ASCII.
    */
 
   class EXPORT ExternalAsciiStringResource {  // NOLINT
    public:
     /**
      * Override the destructor to manage the life cycle of the underlying
      * buffer.
      */
     virtual ~ExternalAsciiStringResource() {}
     /** The string data from the underlying buffer.*/
     virtual const char* data() const = 0;
     /** The number of ascii characters in the string.*/
     virtual size_t length() const = 0;
    protected:
     ExternalAsciiStringResource() {}
    private:
+    // Disallow copying and assigning.
     ExternalAsciiStringResource(const ExternalAsciiStringResource&);
     void operator=(const ExternalAsciiStringResource&);
   };
 
   /**
    * Get the ExternalStringResource for an external string.  Only
    * valid if IsExternal() returns true.
    */
   ExternalStringResource* GetExternalStringResource();
 
@@ skipping 54 matching lines @@
    */
   class EXPORT Utf8Value {
    public:
     explicit Utf8Value(Handle<v8::Value> obj);
     ~Utf8Value();
     char* operator*() { return str_; }
     int length() { return length_; }
    private:
     char* str_;
     int length_;
+
+    // Disallow copying and assigning.
+    Utf8Value(const Utf8Value&);
+    void operator=(const Utf8Value&);
   };
 
   /**
    * Converts an object to an ascii string.
    * Useful if you want to print the object.
    */
   class EXPORT AsciiValue {
    public:
     explicit AsciiValue(Handle<v8::Value> obj);
     ~AsciiValue();
     char* operator*() { return str_; }
     int length() { return length_; }
    private:
     char* str_;
     int length_;
+
+    // Disallow copying and assigning.
+    AsciiValue(const AsciiValue&);
+    void operator=(const AsciiValue&);
   };
 
   /**
    * Converts an object to a two-byte string.
    */
   class EXPORT Value {
    public:
     explicit Value(Handle<v8::Value> obj);
     ~Value();
     uint16_t* operator*() { return str_; }
     int length() { return length_; }
    private:
     uint16_t* str_;
     int length_;
+
+    // Disallow copying and assigning.
+    Value(const Value&);
+    void operator=(const Value&);
   };
 };
 
 
 /**
  * A JavaScript number value (ECMA-262, 4.3.20)
  */
 class EXPORT Number : public Primitive {
  public:
   double Value();
@@ skipping 744 matching lines @@
   const char** dependencies() { return deps_; }
   void set_auto_enable(bool value) { auto_enable_ = value; }
   bool auto_enable() { return auto_enable_; }
 
  private:
   const char* name_;
   const char* source_;
   int dep_count_;
   const char** deps_;
   bool auto_enable_;
+
+  // Disallow copying and assigning.
+  Extension(const Extension&);
+  void operator=(const Extension&);
 };
 
 
 void EXPORT RegisterExtension(Extension* extension);
 
 
 /**
  * Ignore
  */
 class EXPORT DeclareExtension {
@@ skipping 500 matching lines @@
   static void StopPreemption();
 
   /**
    * Returns whether or not the locker is locked by the current thread.
    */
   static bool IsLocked();
 
  private:
   bool has_lock_;
   bool top_level_;
+
+  // Disallow copying and assigning.
+  Locker(const Locker&);
+  void operator=(const Locker&);
 };
 
 
 
 // --- I m p l e m e n t a t i o n ---
 
 template <class T>
 Handle<T>::Handle() : val_(0) { }
 
 
@@ skipping 159 matching lines @@
 
 }  // namespace v8
 
 
 #undef EXPORT
 #undef EXPORT_INLINE
 #undef TYPE_CHECK
 
 
 #endif  // V8_H_