1// Copyright (c) 2012 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 "base/bind.h" 6#include "base/message_loop/message_loop.h" 7#include "base/test/test_timeouts.h" 8#include "base/time/time.h" 9#include "ppapi/c/dev/ppb_var_deprecated.h" 10#include "ppapi/c/dev/ppp_class_deprecated.h" 11#include "ppapi/c/pp_var.h" 12#include "ppapi/c/ppb_var.h" 13#include "ppapi/c/ppp_instance.h" 14#include "ppapi/c/private/ppp_instance_private.h" 15#include "ppapi/proxy/host_dispatcher.h" 16#include "ppapi/proxy/interface_list.h" 17#include "ppapi/proxy/ppapi_proxy_test.h" 18#include "ppapi/shared_impl/ppapi_permissions.h" 19#include "ppapi/shared_impl/ppb_var_shared.h" 20#include "ppapi/shared_impl/var.h" 21 22namespace ppapi { 23 24// A fake version of V8ObjectVar for testing. 25class V8ObjectVar : public ppapi::Var { 26 public: 27 V8ObjectVar() {} 28 virtual ~V8ObjectVar() {} 29 30 // Var overrides. 31 virtual V8ObjectVar* AsV8ObjectVar() OVERRIDE { return this; } 32 virtual PP_VarType GetType() const OVERRIDE { return PP_VARTYPE_OBJECT; } 33}; 34 35namespace proxy { 36 37namespace { 38const PP_Instance kInstance = 0xdeadbeef; 39 40PP_Var GetPPVarNoAddRef(Var* var) { 41 PP_Var var_to_return = var->GetPPVar(); 42 PpapiGlobals::Get()->GetVarTracker()->ReleaseVar(var_to_return); 43 return var_to_return; 44} 45 46PluginDispatcher* plugin_dispatcher = NULL; 47// Return the plugin-side proxy for PPB_Var_Deprecated. 48const PPB_Var_Deprecated* plugin_var_deprecated_if() { 49 // The test code must set the plugin dispatcher. 50 CHECK(plugin_dispatcher); 51 // Grab the plugin-side proxy for PPB_Var_Deprecated (for CreateObject). 52 return static_cast<const PPB_Var_Deprecated*>( 53 plugin_dispatcher->GetBrowserInterface( 54 PPB_VAR_DEPRECATED_INTERFACE)); 55} 56 57// Mock PPP_Instance_Private. 58PP_Var instance_obj; 59PP_Var GetInstanceObject(PP_Instance /*instance*/) { 60 // The 1 ref we got from CreateObject will be passed to the host. We want to 61 // have a ref of our own. 62 printf("GetInstanceObject called\n"); 63 plugin_var_deprecated_if()->AddRef(instance_obj); 64 return instance_obj; 65} 66 67PPP_Instance_Private ppp_instance_private_mock = { 68 &GetInstanceObject 69}; 70 71// We need to pass in a |PPP_Class_Deprecated| to 72// |PPB_Var_Deprecated->CreateObject| for a mock |Deallocate| method. 73void Deallocate(void* object) { 74} 75 76const PPP_Class_Deprecated ppp_class_deprecated_mock = { 77 NULL, // HasProperty 78 NULL, // HasMethod 79 NULL, // GetProperty 80 NULL, // GetAllPropertyNames 81 NULL, // SetProperty 82 NULL, // RemoveProperty 83 NULL, // Call 84 NULL, // Construct 85 &Deallocate 86}; 87 88 89// We need to mock PPP_Instance, so that we can create and destroy the pretend 90// instance that PPP_Instance_Private uses. 91PP_Bool DidCreate(PP_Instance /*instance*/, uint32_t /*argc*/, 92 const char* /*argn*/[], const char* /*argv*/[]) { 93 // Create an object var. This should exercise the typical path for creating 94 // instance objects. 95 instance_obj = 96 plugin_var_deprecated_if()->CreateObject(kInstance, 97 &ppp_class_deprecated_mock, 98 NULL); 99 return PP_TRUE; 100} 101 102void DidDestroy(PP_Instance /*instance*/) { 103 // Decrement the reference count for our instance object. It should be 104 // deleted. 105 plugin_var_deprecated_if()->Release(instance_obj); 106} 107 108PPP_Instance_1_0 ppp_instance_mock = { &DidCreate, &DidDestroy }; 109 110// Mock PPB_Var_Deprecated, so that we can emulate creating an Object Var. 111PP_Var CreateObject(PP_Instance /*instance*/, 112 const PPP_Class_Deprecated* /*ppp_class*/, 113 void* /*ppp_class_data*/) { 114 V8ObjectVar* obj_var = new V8ObjectVar; 115 return obj_var->GetPPVar(); 116} 117 118const PPB_Var_Deprecated ppb_var_deprecated_mock = { 119 PPB_Var_Shared::GetVarInterface1_0()->AddRef, 120 PPB_Var_Shared::GetVarInterface1_0()->Release, 121 PPB_Var_Shared::GetVarInterface1_0()->VarFromUtf8, 122 PPB_Var_Shared::GetVarInterface1_0()->VarToUtf8, 123 NULL, // HasProperty 124 NULL, // HasMethod 125 NULL, // GetProperty 126 NULL, // EnumerateProperties 127 NULL, // SetProperty 128 NULL, // RemoveProperty 129 NULL, // Call 130 NULL, // Construct 131 NULL, // IsInstanceOf 132 &CreateObject 133}; 134 135class PPP_Instance_Private_ProxyTest : public TwoWayTest { 136 public: 137 PPP_Instance_Private_ProxyTest() 138 : TwoWayTest(TwoWayTest::TEST_PPP_INTERFACE) { 139 plugin().RegisterTestInterface(PPP_INSTANCE_PRIVATE_INTERFACE, 140 &ppp_instance_private_mock); 141 plugin().RegisterTestInterface(PPP_INSTANCE_INTERFACE_1_0, 142 &ppp_instance_mock); 143 host().RegisterTestInterface(PPB_VAR_DEPRECATED_INTERFACE, 144 &ppb_var_deprecated_mock); 145 } 146}; 147 148} // namespace 149 150TEST_F(PPP_Instance_Private_ProxyTest, PPPInstancePrivate) { 151 // This test controls its own instance; we can't use the one that 152 // PluginProxyTestHarness provides. 153 ASSERT_NE(kInstance, pp_instance()); 154 HostDispatcher::SetForInstance(kInstance, host().host_dispatcher()); 155 156 // Requires dev interfaces. 157 InterfaceList::SetProcessGlobalPermissions( 158 PpapiPermissions::AllPermissions()); 159 160 // This file-local global is used by the PPP_Instance mock above in order to 161 // access PPB_Var_Deprecated. 162 plugin_dispatcher = plugin().plugin_dispatcher(); 163 164 // Grab the host-side proxy for PPP_Instance and PPP_Instance_Private. 165 const PPP_Instance_Private* ppp_instance_private = 166 static_cast<const PPP_Instance_Private*>( 167 host().host_dispatcher()->GetProxiedInterface( 168 PPP_INSTANCE_PRIVATE_INTERFACE)); 169 const PPP_Instance_1_1* ppp_instance = static_cast<const PPP_Instance_1_1*>( 170 host().host_dispatcher()->GetProxiedInterface( 171 PPP_INSTANCE_INTERFACE_1_1)); 172 173 // Initialize an Instance, so that the plugin-side machinery will work 174 // properly. 175 EXPECT_EQ(PP_TRUE, ppp_instance->DidCreate(kInstance, 0, NULL, NULL)); 176 177 // Check the plugin-side reference count. 178 EXPECT_EQ(1, plugin().var_tracker().GetRefCountForObject(instance_obj)); 179 // Check the host-side var exists with the expected id and has 1 refcount (the 180 // refcount on behalf of the plugin). 181 int32 expected_host_id = 182 plugin().var_tracker().GetHostObject(instance_obj).value.as_id; 183 Var* host_var = host().var_tracker().GetVar(expected_host_id); 184 ASSERT_TRUE(host_var); 185 EXPECT_EQ( 186 1, 187 host().var_tracker().GetRefCountForObject(GetPPVarNoAddRef(host_var))); 188 189 // Call from the browser side to get the instance object. 190 PP_Var host_pp_var = ppp_instance_private->GetInstanceObject(kInstance); 191 EXPECT_EQ(instance_obj.type, host_pp_var.type); 192 EXPECT_EQ(host_pp_var.value.as_id, expected_host_id); 193 EXPECT_EQ(1, plugin().var_tracker().GetRefCountForObject(instance_obj)); 194 // A reference is passed to the browser, which we consume here. 195 host().var_tracker().ReleaseVar(host_pp_var); 196 EXPECT_EQ(1, host().var_tracker().GetRefCountForObject(host_pp_var)); 197 198 // The plugin is going away; generally, so will all references to its instance 199 // object. 200 host().var_tracker().ReleaseVar(host_pp_var); 201 // Destroy the instance. DidDestroy above decrements the reference count for 202 // instance_obj, so it should also be destroyed. 203 ppp_instance->DidDestroy(kInstance); 204 EXPECT_EQ(-1, plugin().var_tracker().GetRefCountForObject(instance_obj)); 205 EXPECT_EQ(-1, host().var_tracker().GetRefCountForObject(host_pp_var)); 206} 207 208} // namespace proxy 209} // namespace ppapi 210 211