Convert resources to take an instance key instead of an Instance*.

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>
 
 #include "ppapi/c/pp_var.h"
-
+#include "ppapi/cpp/pass_ref.h"
 
 /// @file
 /// This file defines the API for handling the passing of data types between
 /// your module and the page.
 namespace pp {
 
 /// A generic type used for passing data types between the module and the page.
 class Var {
  public:
   /// Special value passed to constructor to make <code>NULL</code>.
@@ skipping 20 matching lines @@
   ///
   /// @param[in] d A double value.
   Var(double d);
 
   /// A constructor used to create a UTF-8 character <code>Var</code>.
   Var(const char* utf8_str);  // Must be encoded in UTF-8.
 
   /// A constructor used to create a UTF-8 character <code>Var</code>.
   Var(const std::string& utf8_str);  // Must be encoded in UTF-8.
 
-  /// PassRef can be used to construct a <code>Var</code> with a
-  /// <code>PP_Var</code> when the <code>PP_Var</code>
-  /// already has had its reference count incremented.  For example:
-  /// <code>pp::Var my_var(PassRef(), my_pp_var);</code>
-  struct PassRef {};
-
   /// 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;
   }
 
@@ skipping 193 matching lines @@
         temp_ = output_->var_;
       } else {
         temp_.padding = 0;
         temp_.type = PP_VARTYPE_UNDEFINED;
       }
     }
 
     /// Destructor.
     ~OutException() {
       if (output_ && !originally_had_exception_)
-        *output_ = Var(PassRef(), temp_);
+        *output_ = Var(PASS_REF, temp_);
     }
 
     PP_Var* get() {
       if (output_)
         return &temp_;
       return NULL;
     }
 
    private:
     Var* output_;
     bool originally_had_exception_;
     PP_Var temp_;
   };
 
  protected:
   PP_Var var_;
   bool needs_release_;
 
  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_