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/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 {
 
 // In CreateValueFromVar(), a stack is used to keep track of conversion progress
 // of array and dictionary vars. VarNodeBase is the base class of stack
 // elements.
 class VarNodeBase : public base::RefCounted<VarNodeBase> {
  public:
   virtual bool IsArrayVar() const { return false; }
   virtual bool IsDictionaryVar() const { return false; }
 
  protected:
   friend class base::RefCounted<VarNodeBase>;
 
   VarNodeBase() {}
   virtual ~VarNodeBase() {}
 };
 
+class ArrayVarNode : public VarNodeBase {
+ public:
+  ArrayVarNode(int64_t in_var_id, const ArrayVar* array_var)
+      : var_id(in_var_id),
+        next(array_var->elements().begin()),
+        end(array_var->elements().end()),
+        list_value(new base::ListValue()) {
+  }
+
+  virtual bool IsArrayVar() const OVERRIDE {
+    return true;
+  }
+
+  int64_t var_id;
+  ArrayVar::ElementVector::const_iterator next;
+  ArrayVar::ElementVector::const_iterator end;
+  scoped_ptr<base::ListValue> list_value;
+
+ private:
+  virtual ~ArrayVarNode() {}
+};
+
 class DictionaryVarNode : public VarNodeBase {
  public:
   DictionaryVarNode(int64_t in_var_id, const DictionaryVar* dict_var)
       : var_id(in_var_id),
         next(dict_var->key_value_map().begin()),
         end(dict_var->key_value_map().end()),
         dict_value(new base::DictionaryValue()) {
   }
 
   virtual bool IsDictionaryVar() const OVERRIDE {
@@ skipping 18 matching lines @@
   virtual bool IsListValue() const { return false; }
   virtual bool IsDictionaryValue() const { return false; }
 
  protected:
   friend class base::RefCounted<ValueNodeBase>;
 
   ValueNodeBase() {}
   virtual ~ValueNodeBase() {}
 };
 
+class ListValueNode : public ValueNodeBase {
+ public:
+  explicit ListValueNode(const base::ListValue& list_value)
+      : next(list_value.begin()),
+        end(list_value.end()),
+        array_var(new ArrayVar()) {
+    array_var->elements().reserve(list_value.GetSize());
+  }
+
+  virtual bool IsListValue() const OVERRIDE {
+    return true;
+  }
+
+  base::ListValue::const_iterator next;
+  base::ListValue::const_iterator end;
+  scoped_refptr<ArrayVar> array_var;
+
+ private:
+  virtual ~ListValueNode() {}
+};
+
 class DictionaryValueNode : public ValueNodeBase {
  public:
   explicit DictionaryValueNode(const base::DictionaryValue& dict_value)
       : iter(dict_value),
         dict_var(new DictionaryVar()) {
   }
 
   virtual bool IsDictionaryValue() const OVERRIDE {
     return true;
   }
@@ skipping 38 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 (parent_ids->find(var.value.as_id) != parent_ids->end()) {
+        // A circular reference is found.
+        return false;
+      }
+
+      ArrayVar* array_var = ArrayVar::FromPPVar(var);
+      if (!array_var)
+        return false;
+
+
+      parent_ids->insert(var.value.as_id);
+      state->push(new ArrayVarNode(var.value.as_id, array_var));
+      return true;
     }
     case PP_VARTYPE_DICTIONARY: {
       if (parent_ids->find(var.value.as_id) != parent_ids->end()) {
         // A circular reference is found.
         return false;
       }
 
       DictionaryVar* dict_var = DictionaryVar::FromPPVar(var);
       if (!dict_var)
         return false;
@@ skipping 84 matching lines @@
         return true;
       }
       return false;
     }
     case base::Value::TYPE_DICTIONARY: {
       state->push(new DictionaryValueNode(
           static_cast<const base::DictionaryValue&>(value)));
       return true;
     }
     case base::Value::TYPE_LIST: {
-      // TODO(yzshen): Add support once array var is supported.
-      return false;
+      state->push(new ListValueNode(
+          static_cast<const base::ListValue&>(value)));
+      return true;
     }
   }
   NOTREACHED();
   return false;
 }
 
 }  // namespace
 
 base::Value* CreateValueFromVar(const PP_Var& var) {
   // Used to detect circular references.
@@ skipping 24 matching lines @@
         top->current_key = top->next->first;
         current_var = top->next->second.get();
         ++top->next;
 
         // Ignore the key-value pair if the value is undefined.
         if (current_var.type == PP_VARTYPE_UNDEFINED) {
           top->current_key.clear();
           continue;
         }
       }
+    } else if (state.top()->IsArrayVar()) {
+      scoped_refptr<ArrayVarNode> top(
+          static_cast<ArrayVarNode*>(state.top().get()));
+
+      if (current_value.get())
+        top->list_value->Append(current_value.release());
+
+      if (top->next == top->end) {
+        current_value.reset(top->list_value.release());
+        parent_ids.erase(top->var_id);
+        state.pop();
+        continue;
+      } else {
+        current_var = top->next->get();
+        ++top->next;
+      }
     } else {
       NOTREACHED();
       return NULL;
     }
 
     DCHECK(!current_value.get());
     if (!CreateValueFromVarHelper(current_var, &current_value, &parent_ids,
                                   &state)) {
       return NULL;
     }
@@ skipping 26 matching lines @@
       if (top->iter.IsAtEnd()) {
         current_var = ScopedPPVar(ScopedPPVar::PassRef(),
                                   top->dict_var->GetPPVar());
         state.pop();
         continue;
       } else {
         top->current_key = top->iter.key();
         current_value = &top->iter.value();
         top->iter.Advance();
       }
+    } else if (state.top()->IsListValue()) {
+      scoped_refptr<ListValueNode> top(
+          static_cast<ListValueNode*>(state.top().get()));
+
+      if (current_var.get().type != PP_VARTYPE_UNDEFINED)
+        top->array_var->elements().push_back(current_var);
+      current_var = PP_MakeUndefined();
+      if (top->next == top->end) {
+        current_var = ScopedPPVar(ScopedPPVar::PassRef(),
+                                  top->array_var->GetPPVar());
+        state.pop();
+        continue;
+      } else {
+        current_value = *top->next;
+        ++top->next;
+      }
     } else {
       NOTREACHED();
       return PP_MakeUndefined();
     }
 
     DCHECK(current_var.get().type == PP_VARTYPE_UNDEFINED);
     if (!CreateVarFromValueHelper(*current_value, &current_var, &state))
       return PP_MakeUndefined();
   };
 
   return current_var.Release();
 }
 }  // namespace ppapi