[PPAPI] Moving pp::VarResource_Dev API into pp::Var (now stable).

ppapi/cpp/var.cc

 // 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.
 
 #include "ppapi/cpp/var.h"
 
 #include <stdio.h>
 #include <string.h>
 
 #include <algorithm>
 
 #include "ppapi/c/pp_var.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/module_impl.h"
 
 // Define equivalent to snprintf on Windows.
 #if defined(_MSC_VER)
 #  define snprintf sprintf_s
 #endif
 
 namespace pp {
 
 namespace {
 
+template <> const char* interface_name<PPB_Var_1_2>() {
+  return PPB_VAR_INTERFACE_1_2;
+}
 template <> const char* interface_name<PPB_Var_1_1>() {
   return PPB_VAR_INTERFACE_1_1;
 }
 template <> const char* interface_name<PPB_Var_1_0>() {
   return PPB_VAR_INTERFACE_1_0;
 }
 
 // Technically you can call AddRef and Release on any Var, but it may involve
 // cross-process calls depending on the plugin. This is an optimization so we
 // only do refcounting on the necessary objects.
@@ skipping 56 matching lines @@
   var_ = VarFromUtf8Helper(utf8_str, len);
   is_managed_ = true;
 }
 
 Var::Var(const std::string& utf8_str) {
   var_ = VarFromUtf8Helper(utf8_str.c_str(),
                            static_cast<uint32_t>(utf8_str.size()));
   is_managed_ = true;
 }
 
+Var::Var(const pp::Resource& resource) {
+  if (!has_interface<PPB_Var_1_2>()) {
+    PP_NOTREACHED();
+    return;
+  }
+
+  var_ = get_interface<PPB_Var_1_2>()->VarFromResource(
+      resource.pp_resource());
+  // Set |is_managed_| to true, so |var_| will be properly released upon
+  // destruction.
+  is_managed_ = true;
+}
+
 
 Var::Var(const PP_Var& var) {
   var_ = var;
   is_managed_ = true;
   if (NeedsRefcounting(var_)) {
     if (has_interface<PPB_Var_1_0>())
       get_interface<PPB_Var_1_0>()->AddRef(var_);

[dmichael (off chromium), 2014/02/06 17:25:01]

pp::Var was done before we decided to change our C++ version checking. Now, I
think the goal is that we will try the newest version first in all methods, then
fall back to the next, etc.

See file_io.cc for an example.

[Matt Giuca, 2014/02/07 03:11:22]

:O is that necessary?

It doesn't seem scalable. It means that every time you add a new version, you
have to add new else blocks to every existing method, and duplicate the calls.

Do you want me to do this or not (given that, as Yuzhu points out, we don't
currently do it here).

[dmichael (off chromium), 2014/02/07 17:45:28]

Yes, we should do it here. It's definitely kind of ugly, and it's not *strictly*
necessary, since the backing implementation happens to be the same. But... we've
discussed this before a few times before coming to this approach. See for
example this thread:
https://groups.google.com/a/chromium.org/d/msg/pepper-dev/HrcIduc88ks/1nPPPVV...
...and also some discussions I had linked to in my first response on that
thread.

pp::Var was done before that decision, and we never got around to making it
consistent. I think we need to make it consistent now. The big advantage to the
always-try-the-new-one-first approach is it gives us more hope of deprecating
old versions of the C API eventually.

     else
       var_.type = PP_VARTYPE_NULL;
   }
 }
 
 Var::Var(const Var& other) {
   var_ = other.var_;
   is_managed_ = true;
   if (NeedsRefcounting(var_)) {
     if (has_interface<PPB_Var_1_0>())

[yzshen1, 2014/02/06 18:02:58]

In all the other cpp files, we use the latest version of API and then fallback
to old ones.

But it seems this file doesn't do that...

       get_interface<PPB_Var_1_0>()->AddRef(var_);
     else
       var_.type = PP_VARTYPE_NULL;
   }
 }
 
 Var::~Var() {
   if (NeedsRefcounting(var_) &&
       is_managed_ &&
       has_interface<PPB_Var_1_0>())
@@ skipping 81 matching lines @@
     return std::string();
   }
 
   if (!has_interface<PPB_Var_1_0>())
     return std::string();
   uint32_t len;
   const char* str = get_interface<PPB_Var_1_0>()->VarToUtf8(var_, &len);
   return std::string(str, len);
 }
 
+pp::Resource Var::AsResource() const {

[yzshen1, 2014/02/06 18:02:58]

Maybe we should follow AsString to assert that it is_resource().
(And please update the comment.)

[Matt Giuca, 2014/02/07 03:11:22]

Done.

+  if (!has_interface<PPB_Var_1_2>())
+    return pp::Resource();
+
+  return pp::Resource(
+      pp::PASS_REF,
+      get_interface<PPB_Var_1_2>()->VarToResource(var_));
+}
+
 std::string Var::DebugString() const {
   char buf[256];
   if (is_undefined()) {
     snprintf(buf, sizeof(buf), "Var(UNDEFINED)");
   } else if (is_null()) {
     snprintf(buf, sizeof(buf), "Var(NULL)");
   } else if (is_bool()) {
     snprintf(buf, sizeof(buf), AsBool() ? "Var(true)" : "Var(false)");
   } else if (is_int()) {
     snprintf(buf, sizeof(buf), "Var(%d)", static_cast<int>(AsInt()));
@@ skipping 17 matching lines @@
     snprintf(buf, sizeof(buf), "Var(DICTIONARY)");
   } else if (is_array_buffer()) {
     snprintf(buf, sizeof(buf), "Var(ARRAY_BUFFER)");
   } else {
     buf[0] = '\0';
   }
   return buf;
 }
 
 }  // namespace pp