Pepper WebSocket API: Fix memory leak issue

ppapi/cpp/var.h

 // Copyright (c) 2012 The Chromium 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 PPAPI_CPP_VAR_H_
 #define PPAPI_CPP_VAR_H_
 
 #include <string>
 #include <vector>
 
@@ skipping 39 matching lines @@
   /// A constructor used to create a UTF-8 character <code>Var</code>.
   Var(const std::string& utf8_str);  // Must be encoded in UTF-8.
 
   /// A constructor used when you have received a <code>Var</code> as a return
   /// value that has had its reference count incremented for you.
   ///
   /// You will not normally need to use this constructor because
   /// the reference count will not normally be incremented for you.
   Var(PassRef, PP_Var var) {
     var_ = var;
-    needs_release_ = true;
+    is_managed_ = true;
   }
 
   struct DontManage {};
 
   // TODO(brettw): remove DontManage when this bug is fixed
   //               http://code.google.com/p/chromium/issues/detail?id=52105
   /// This constructor is used when we've given a <code>PP_Var</code> as an
   /// input argument from somewhere and that reference is managing the
   /// reference count for us. The object will not have its reference count
   /// increased or decreased by this class instance.
   ///
   /// @param[in] var A <code>Var</code>.
   Var(DontManage, PP_Var var) {
     var_ = var;
-    needs_release_ = false;
+    is_managed_ = false;
   }
 
   /// A constructor for copying a <code>Var</code>.
   Var(const Var& other);
 
   /// Destructor.
   virtual ~Var();
 
   /// This function assigns one <code>Var</code> to another <code>Var</code>.
   ///
@@ skipping 118 matching lines @@
   /// Detach() detaches from the internal <code>PP_Var</code> of this
   /// object, keeping the reference count the same. This is used when returning
   /// a <code>PP_Var</code> from an API function where the caller expects the
   /// return value to have the reference count incremented for it.
   ///
   /// @return A detached version of this object without affecting the reference
   /// count.
   PP_Var Detach() {
     PP_Var ret = var_;
     var_ = PP_MakeUndefined();
-    needs_release_ = false;
+    is_managed_ = true;
     return ret;
   }
 
   /// DebugString() returns a short description "Var<X>" that can be used for
   /// logging, where "X" is the underlying scalar or "UNDEFINED" or "OBJ" as
   /// it does not call into the browser to get the object description.
   ///
   /// @return A string displaying the value of this <code>Var</code>. This
   /// function is used for debugging.
   std::string DebugString() const;
@@ skipping 48 matching lines @@
     }
 
    private:
     Var* output_;
     bool originally_had_exception_;
     PP_Var temp_;
   };
 
  protected:
   PP_Var var_;
-  bool needs_release_;
+
+  // |is_managed_| indicates if the instance manages |var_|.
+  // You need to check if |var_| is refcounted to call Release().
+  bool is_managed_;
 
  private:
   // Prevent an arbitrary pointer argument from being implicitly converted to
   // a bool at Var construction. If somebody makes such a mistake, (s)he will
   // get a compilation error.
   Var(void* non_scriptable_object_pointer);
 };
 
 }  // namespace pp
 
 #endif  // PPAPI_CPP_VAR_H_