1// Copyright (c) 2011 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/callback.h" 6#include "base/bind.h" 7#include "base/memory/ref_counted.h" 8 9namespace base { 10 11// Do not put everything inside an anonymous namespace. If you do, many of the 12// helper function declarations will generate unused definition warnings. 13 14static const int kParentValue = 1; 15static const int kChildValue = 2; 16 17class NoRef { 18 public: 19 void VoidMethod0() {} 20 void VoidConstMethod0() const {} 21 int IntMethod0() { return 1; } 22}; 23 24class HasRef : public NoRef, public base::RefCounted<HasRef> { 25}; 26 27class Parent { 28 public: 29 void AddRef(void) const {} 30 void Release(void) const {} 31 virtual void VirtualSet() { value = kParentValue; } 32 void NonVirtualSet() { value = kParentValue; } 33 int value; 34}; 35 36class Child : public Parent { 37 public: 38 virtual void VirtualSet() { value = kChildValue; } 39 void NonVirtualSet() { value = kChildValue; } 40}; 41 42class NoRefParent { 43 public: 44 virtual void VirtualSet() { value = kParentValue; } 45 void NonVirtualSet() { value = kParentValue; } 46 int value; 47}; 48 49class NoRefChild : public NoRefParent { 50 virtual void VirtualSet() { value = kChildValue; } 51 void NonVirtualSet() { value = kChildValue; } 52}; 53 54template <typename T> 55T PolymorphicIdentity(T t) { 56 return t; 57} 58 59int UnwrapParentRef(Parent& p) { 60 return p.value; 61} 62 63template <typename T> 64void VoidPolymorphic1(T t) { 65} 66 67#if defined(NCTEST_METHOD_ON_CONST_OBJECT) // [r"invalid conversion from 'const base::NoRef\*' to 'base::NoRef\*'"] 68 69// Method bound to const-object. 70// 71// Only const methods should be allowed to work with const objects. 72void WontCompile() { 73 HasRef has_ref; 74 const HasRef* const_has_ref_ptr_ = &has_ref; 75 Callback<void(void)> method_to_const_cb = 76 Bind(&HasRef::VoidMethod0, const_has_ref_ptr_); 77 method_to_const_cb.Run(); 78} 79 80#elif defined(NCTEST_METHOD_BIND_NEEDS_REFCOUNTED_OBJECT) // [r"has no member named 'AddRef'"] 81 82// Method bound to non-refcounted object. 83// 84// We require refcounts unless you have Unretained(). 85void WontCompile() { 86 NoRef no_ref; 87 Callback<void(void)> no_ref_cb = 88 Bind(&NoRef::VoidMethod0, &no_ref); 89 no_ref_cb.Run(); 90} 91 92#elif defined(NCTEST_CONST_METHOD_NEEDS_REFCOUNTED_OBJECT) // [r"has no member named 'AddRef'"] 93 94// Const Method bound to non-refcounted object. 95// 96// We require refcounts unless you have Unretained(). 97void WontCompile() { 98 NoRef no_ref; 99 Callback<void(void)> no_ref_const_cb = 100 Bind(&NoRef::VoidConstMethod0, &no_ref); 101 no_ref_const_cb.Run(); 102} 103 104#elif defined(NCTEST_CONST_POINTER) // [r"invalid conversion from 'const base::NoRef\*' to 'base::NoRef\*'"] 105 106// Const argument used with non-const pointer parameter of same type. 107// 108// This is just a const-correctness check. 109void WontCompile() { 110 const NoRef* const_no_ref_ptr; 111 Callback<NoRef*(void)> pointer_same_cb = 112 Bind(&PolymorphicIdentity<NoRef*>, const_no_ref_ptr); 113 pointer_same_cb.Run(); 114} 115 116#elif defined(NCTEST_CONST_POINTER_SUBTYPE) // [r"'const base::NoRefParent\*' to 'base::NoRefParent\*'"] 117 118// Const argument used with non-const pointer parameter of super type. 119// 120// This is just a const-correctness check. 121void WontCompile() { 122 const NoRefChild* const_child_ptr; 123 Callback<NoRefParent*(void)> pointer_super_cb = 124 Bind(&PolymorphicIdentity<NoRefParent*>, const_child_ptr); 125 pointer_super_cb.Run(); 126} 127 128#elif defined(DISABLED_NCTEST_DISALLOW_NON_CONST_REF_PARAM) // [r"badstring"] 129// I think there's a type safety promotion issue here where we can pass a const 130// ref to a non const-ref function, or vice versa accidentally. Or we make a 131// copy accidentally. Check. 132 133// Functions with reference parameters, unsupported. 134// 135// First, non-const reference parameters are disallowed by the Google 136// style guide. Second, since we are doing argument forwarding it becomes 137// very tricky to avoid copies, maintain const correctness, and not 138// accidentally have the function be modifying a temporary, or a copy. 139void WontCompile() { 140 Parent p; 141 Callback<int(Parent&)> ref_arg_cb = Bind(&UnwrapParentRef); 142 ref_arg_cb.Run(p); 143} 144 145#elif defined(NCTEST_DISALLOW_BIND_TO_NON_CONST_REF_PARAM) // [r"size of array is negative"] 146 147// Binding functions with reference parameters, unsupported. 148// 149// See comment in NCTEST_DISALLOW_NON_CONST_REF_PARAM 150void WontCompile() { 151 Parent p; 152 Callback<int(void)> ref_cb = Bind(&UnwrapParentRef, p); 153 ref_cb.Run(); 154} 155 156#elif defined(NCTEST_NO_IMPLICIT_ARRAY_PTR_CONVERSION) // [r"size of array is negative"] 157 158// A method should not be bindable with an array of objects. 159// 160// This is likely not wanted behavior. We specifically check for it though 161// because it is possible, depending on how you implement prebinding, to 162// implicitly convert an array type to a pointer type. 163void WontCompile() { 164 HasRef p[10]; 165 Callback<void(void)> method_bound_to_array_cb = 166 Bind(&HasRef::VoidMethod0, p); 167 method_bound_to_array_cb.Run(); 168} 169 170#elif defined(NCTEST_NO_RAW_PTR_FOR_REFCOUNTED_TYPES) // [r"size of array is negative"] 171 172// Refcounted types should not be bound as a raw pointer. 173void WontCompile() { 174 HasRef for_raw_ptr; 175 int a; 176 Callback<void(void)> ref_count_as_raw_ptr_a = 177 Bind(&VoidPolymorphic1<int*>, &a); 178 Callback<void(void)> ref_count_as_raw_ptr = 179 Bind(&VoidPolymorphic1<HasRef*>, &for_raw_ptr); 180} 181 182#elif defined(NCTEST_WEAKPTR_BIND_MUST_RETURN_VOID) // [r"size of array is negative"] 183 184// WeakPtrs cannot be bound to methods with return types. 185void WontCompile() { 186 NoRef no_ref; 187 WeakPtrFactory<NoRef> weak_factory(&no_ref); 188 Callback<int(void)> weak_ptr_with_non_void_return_type = 189 Bind(&NoRef::IntMethod0, weak_factory.GetWeakPtr()); 190 weak_ptr_with_non_void_return_type.Run(); 191} 192 193#elif defined(NCTEST_DISALLOW_ASSIGN_DIFFERENT_TYPES) // [r"conversion from 'base::Callback<void\(int\)>' to non-scalar type"] 194 195// Bind result cannot be assigned to Callbacks with a mismatching type. 196void WontCompile() { 197 Closure callback_mismatches_bind_type = Bind(&VoidPolymorphic1<int>); 198} 199 200#endif 201 202} // namespace base 203