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 <algorithm>
 #include <limits>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.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 24 matching lines @@
     case PP_VARTYPE_OBJECT: {
       return NULL;
     }
     case PP_VARTYPE_ARRAY: {
       if (std::find(parent_ids->begin(), parent_ids->end(), var.value.as_id) !=
               parent_ids->end()) {
         // A circular reference is found.
         return NULL;
       }
 
+      ArrayVar* array_var = ArrayVar::FromPPVar(var);
+      if (!array_var)
+        return NULL;
+
       scoped_ptr<base::ListValue> list_value(new base::ListValue());
       parent_ids->push_back(var.value.as_id);
 
-      // TODO(yzshen): Implement it once array var is supported.
+      for (ArrayVar::ElementVector::const_iterator iter =
+               array_var->elements().begin();
+           iter != array_var->elements().end(); ++iter) {
+        base::Value* value = CreateValueFromVarImpl(iter->get(), parent_ids);
+        if (!value) {
+          parent_ids->pop_back();
+          return NULL;
+        }
+
+        list_value->Append(value);
+      }
 
       parent_ids->pop_back();
       return list_value.release();
     }
     case PP_VARTYPE_DICTIONARY: {
       if (std::find(parent_ids->begin(), parent_ids->end(), var.value.as_id) !=
               parent_ids->end()) {
         // A circular reference is found.
         return NULL;
       }
@@ skipping 103 matching lines @@
                               CreateVarFromValue(iter.value()));
         if (child_var.get().type == PP_VARTYPE_UNDEFINED ||
             !dict_var->SetWithStringKey(iter.key(), child_var.get())) {
           return PP_MakeUndefined();
         }
       }
 
       return dict_var->GetPPVar();
     }
     case base::Value::TYPE_LIST: {
-      // TODO(yzshen): Add support once array var is supported.
-      return PP_MakeUndefined();
+      const base::ListValue& list_value =
+          static_cast<const base::ListValue&>(value);
+
+      scoped_refptr<ArrayVar> array_var(new ArrayVar());
+      array_var->elements().reserve(list_value.GetSize());
+      for (base::ListValue::const_iterator iter = list_value.begin();
+           iter != list_value.end(); ++iter) {
+        ScopedPPVar child_var(ScopedPPVar::PassRef(),
+                              CreateVarFromValue(**iter));
+        if (child_var.get().type == PP_VARTYPE_UNDEFINED)
+          return PP_MakeUndefined();
+
+        array_var->elements().push_back(child_var);
+      }
+
+      return array_var->GetPPVar();
     }
   }
   NOTREACHED();
   return PP_MakeUndefined();
 }
 
 }  // namespace ppapi