Add PPB_VarArray_Dev support - part 1.

ppapi/shared_impl/var_value_conversions.cc

 // Copyright (c) 2013 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/shared_impl/var_value_conversions.h"
 
 #include <limits>
 #include <set>
 #include <stack>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stl_util.h"
 #include "base/values.h"
 #include "ppapi/c/pp_bool.h"
 #include "ppapi/c/pp_stdint.h"
+#include "ppapi/shared_impl/array_var.h"
 #include "ppapi/shared_impl/dictionary_var.h"
 #include "ppapi/shared_impl/ppapi_globals.h"
 #include "ppapi/shared_impl/scoped_pp_var.h"
 #include "ppapi/shared_impl/var.h"
 #include "ppapi/shared_impl/var_tracker.h"
 
 namespace ppapi {
 
 namespace {
 
@@ skipping 63 matching lines @@
       if (!string_var)
         return false;
 
       value->reset(new base::StringValue(string_var->value()));
       return true;
     }
     case PP_VARTYPE_OBJECT: {
       return false;
     }
     case PP_VARTYPE_ARRAY: {
-      // TODO(yzshen): Implement it once array var is supported.
-      return false;
+      if (ContainsKey(parent_ids, var.value.as_id)) {
+        // A circular reference is found.
+        return false;
+      }
+
+      value->reset(new base::ListValue());
+      state->push(VarNode(var, value->get()));
+      return true;
     }
     case PP_VARTYPE_DICTIONARY: {
       if (ContainsKey(parent_ids, var.value.as_id)) {
         // A circular reference is found.
         return false;
       }
 
       value->reset(new base::DictionaryValue());
       state->push(VarNode(var, value->get()));
       return true;
@@ skipping 80 matching lines @@
       }
       return false;
     }
     case base::Value::TYPE_DICTIONARY: {
       scoped_refptr<DictionaryVar> dict_var(new DictionaryVar());
       *var = ScopedPPVar(ScopedPPVar::PassRef(), dict_var->GetPPVar());
       state->push(ValueNode(var->get(), &value));
       return true;
     }
     case base::Value::TYPE_LIST: {
-      // TODO(yzshen): Add support once array var is supported.
-      return false;
+      scoped_refptr<ArrayVar> array_var(new ArrayVar());
+      *var = ScopedPPVar(ScopedPPVar::PassRef(), array_var->GetPPVar());
+      state->push(ValueNode(var->get(), &value));
+      return true;
     }
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace
 
 base::Value* CreateValueFromVar(const PP_Var& var) {
   // Used to detect circular references.
@@ skipping 30 matching lines @@
           continue;
 
         scoped_ptr<base::Value> child_value;
         if (!CreateValueFromVarHelper(parent_ids, iter->second.get(),
                                       &child_value, &state)) {
           return NULL;
         }
 
         dict_value->SetWithoutPathExpansion(iter->first, child_value.release());
       }
+    } else if (top.var.type == PP_VARTYPE_ARRAY) {
+      parent_ids.insert(top.var.value.as_id);
+      top.sentinel = true;
+
+      ArrayVar* array_var = ArrayVar::FromPPVar(top.var);
+      if (!array_var)
+        return NULL;
+
+      DCHECK(top.value->GetType() == base::Value::TYPE_LIST);
+      base::ListValue* list_value = static_cast<base::ListValue*>(top.value);
+
+      for (ArrayVar::ElementVector::const_iterator iter =
+               array_var->elements().begin();
+           iter != array_var->elements().end();
+           ++iter) {
+        scoped_ptr<base::Value> child_value;
+        if (!CreateValueFromVarHelper(parent_ids, iter->get(), &child_value,
+                                      &state)) {
+          return NULL;
+        }
+
+        list_value->Append(child_value.release());
+      }
     } else {
       NOTREACHED();
       return NULL;
     }
   }
   DCHECK(parent_ids.empty());
   return root_value.release();
 }
 
 PP_Var CreateVarFromValue(const base::Value& value) {
@@ skipping 14 matching lines @@
       DCHECK(dict_var);
       for (base::DictionaryValue::Iterator iter(*dict_value);
            !iter.IsAtEnd();
            iter.Advance()) {
         ScopedPPVar child_var;
         if (!CreateVarFromValueHelper(iter.value(), &child_var, &state) ||
             !dict_var->SetWithStringKey(iter.key(), child_var.get())) {
           return PP_MakeUndefined();
         }
       }
+    } else if (top.value->GetType() == base::Value::TYPE_LIST) {
+      const base::ListValue* list_value =
+          static_cast<const base::ListValue*>(top.value);
+      ArrayVar* array_var = ArrayVar::FromPPVar(top.var);
+      DCHECK(array_var);
+      for (base::ListValue::const_iterator iter = list_value->begin();
+           iter != list_value->end();
+           ++iter) {
+        ScopedPPVar child_var;
+        if (!CreateVarFromValueHelper(**iter, &child_var, &state))
+          return PP_MakeUndefined();
+
+        array_var->elements().push_back(child_var);
+      }
     } else {
       NOTREACHED();
       return PP_MakeUndefined();
     }
   }
 
   return root_var.Release();
 }
 }  // namespace ppapi