1// Copyright 2014 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "fake_ppapi/fake_var_dictionary_interface.h"
6
7#include "fake_ppapi/fake_var_manager.h"
8#include "gtest/gtest.h"
9
10FakeVarDictionaryInterface::FakeVarDictionaryInterface(FakeVarManager* manager,
11    nacl_io::VarInterface* var_interface,
12    nacl_io::VarArrayInterface* array_interface) :
13  manager_(manager),
14  var_interface_(var_interface),
15  array_interface_(array_interface) {}
16
17
18PP_Var FakeVarDictionaryInterface::Create() {
19  FakeVarData* var_data = manager_->CreateVarData();
20  var_data->type = PP_VARTYPE_DICTIONARY;
21
22  struct PP_Var result = {PP_VARTYPE_DICTIONARY, 0, {PP_FALSE}};
23  result.value.as_id = var_data->id;
24  return result;
25}
26
27PP_Bool FakeVarDictionaryInterface::Set(PP_Var var, PP_Var key, PP_Var value) {
28  EXPECT_EQ(PP_VARTYPE_DICTIONARY, var.type);
29  EXPECT_EQ(PP_VARTYPE_STRING, key.type);
30  FakeVarData* data = manager_->GetVarData(var);
31  FakeVarData* key_data = manager_->GetVarData(key);
32  EXPECT_NE(static_cast<FakeVarData*>(NULL), data);
33  EXPECT_NE(static_cast<FakeVarData*>(NULL), key_data);
34  const std::string& key_string = key_data->string_value;
35  FakeDictType& dict = data->dict_value;
36  manager_->AddRef(value);
37  // Release any existing value
38  if (dict.count(key_string) > 0) {
39    manager_->Release(dict[key_string]);
40  }
41  dict[key_string] = value;
42  return PP_TRUE;
43}
44
45PP_Var FakeVarDictionaryInterface::Get(PP_Var var, PP_Var key) {
46  EXPECT_EQ(PP_VARTYPE_DICTIONARY, var.type);
47  EXPECT_EQ(PP_VARTYPE_STRING, key.type);
48  FakeVarData* data = manager_->GetVarData(var);
49  FakeVarData* key_data = manager_->GetVarData(key);
50  EXPECT_NE(static_cast<FakeVarData*>(NULL), data);
51  EXPECT_NE(static_cast<FakeVarData*>(NULL), key_data);
52  FakeDictType& dict = data->dict_value;
53  const std::string& key_string = key_data->string_value;
54  PP_Var rtn = dict[key_string];
55  manager_->AddRef(rtn);
56  return rtn;
57}
58
59void FakeVarDictionaryInterface::Delete(PP_Var var, PP_Var key) {
60  EXPECT_EQ(PP_VARTYPE_DICTIONARY, var.type);
61  EXPECT_EQ(PP_VARTYPE_STRING, key.type);
62  FakeVarData* data = manager_->GetVarData(var);
63  FakeVarData* key_data = manager_->GetVarData(key);
64  EXPECT_NE(static_cast<FakeVarData*>(NULL), data);
65  EXPECT_NE(static_cast<FakeVarData*>(NULL), key_data);
66  FakeDictType& dict = data->dict_value;
67  const std::string& key_string = key_data->string_value;
68  if (dict.count(key_string) > 0) {
69    manager_->Release(dict[key_string]);
70  }
71  dict.erase(key_string);
72}
73
74PP_Bool FakeVarDictionaryInterface::HasKey(PP_Var var, PP_Var key) {
75  EXPECT_EQ(PP_VARTYPE_DICTIONARY, var.type);
76  EXPECT_EQ(PP_VARTYPE_STRING, key.type);
77  FakeVarData* data = manager_->GetVarData(var);
78  FakeVarData* key_data = manager_->GetVarData(key);
79  EXPECT_NE(static_cast<FakeVarData*>(NULL), data);
80  EXPECT_NE(static_cast<FakeVarData*>(NULL), key_data);
81  FakeDictType& dict = data->dict_value;
82  const std::string& key_string = key_data->string_value;
83  if (dict.count(key_string) > 0)
84    return PP_FALSE;
85  return PP_TRUE;
86}
87
88PP_Var FakeVarDictionaryInterface::GetKeys(PP_Var var) {
89  EXPECT_EQ(PP_VARTYPE_DICTIONARY, var.type);
90  FakeVarData* data = manager_->GetVarData(var);
91  EXPECT_NE(static_cast<FakeVarData*>(NULL), data);
92  FakeDictType& dict = data->dict_value;
93  PP_Var rtn = array_interface_->Create();
94  array_interface_->SetLength(rtn, dict.size());
95  int index = 0;
96  for (FakeDictType::iterator it = dict.begin(); it != dict.end(); it++) {
97    PP_Var key = var_interface_->VarFromUtf8(it->first.c_str(),
98                                             it->first.size());
99    array_interface_->Set(rtn, index, key);
100    manager_->Release(key);
101    index++;
102  }
103  return rtn;
104}
105