Inhering node::objectWrap vs class wrapper

Assume I have a C++ class:

class cClass {
public:
    methodA();
    methodB();
private:
    //private stuff
}

I can bind this class to Node in two ways:

Method I - inheriting node::objectWrap directly

class cClass : public node::ObjectWrap {
public:
    static void Init(v8::Handle<v8::Object> exports);
    methodA();
    methodB();
private:
    static v8::Handle<v8::Value> New(const v8::Arguments& args);
    //private stuff
}

In this way I am editing the class structure directly. But there is a simpler way and that is:

Method II - keeping a reference to original class internally

class cClassWrapper : public node::ObjectWrap {
public:
    static void Init(v8::Handle<v8::Object> exports);
private:
    static v8::Handle<v8::Value> New(const v8::Arguments& args);
    cClass internal_;
}

Notice in method II cClassWrapper has only one internal field and that is internal_. Simply cClassWrapper is a user of cClass and the internals of cClass is untouched.

Obviously Method II is simpler to implement since class structure of cClass is untouched but I am wondering what's the downside of it (if any?). Does v8's garbage collector keeps deleting internal_ when I am passing cClassWrapper around?

I am not sure what the differences between the two implementations are.