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 #ifndef BASE_SUPPORTS_USER_DATA_H_ 6 #define BASE_SUPPORTS_USER_DATA_H_ 7 8 #include <map> 9 10 #include "base/base_export.h" 11 #include "base/memory/linked_ptr.h" 12 #include "base/memory/ref_counted.h" 13 #include "base/threading/thread_checker.h" 14 15 namespace base { 16 17 // This is a helper for classes that want to allow users to stash random data by 18 // key. At destruction all the objects will be destructed. 19 class BASE_EXPORT SupportsUserData { 20 public: 21 SupportsUserData(); 22 23 // Derive from this class and add your own data members to associate extra 24 // information with this object. Alternatively, add this as a public base 25 // class to any class with a virtual destructor. 26 class BASE_EXPORT Data { 27 public: ~Data()28 virtual ~Data() {} 29 }; 30 31 // The user data allows the clients to associate data with this object. 32 // Multiple user data values can be stored under different keys. 33 // This object will TAKE OWNERSHIP of the given data pointer, and will 34 // delete the object if it is changed or the object is destroyed. 35 Data* GetUserData(const void* key) const; 36 void SetUserData(const void* key, Data* data); 37 void RemoveUserData(const void* key); 38 39 // SupportsUserData is not thread-safe, and on debug build will assert it is 40 // only used on one thread. Calling this method allows the caller to hand 41 // the SupportsUserData instance across threads. Use only if you are taking 42 // full control of the synchronization of that hand over. 43 void DetachUserDataThread(); 44 45 protected: 46 virtual ~SupportsUserData(); 47 48 private: 49 typedef std::map<const void*, linked_ptr<Data> > DataMap; 50 51 // Externally-defined data accessible by key. 52 DataMap user_data_; 53 // Guards usage of |user_data_| 54 ThreadChecker thread_checker_; 55 56 DISALLOW_COPY_AND_ASSIGN(SupportsUserData); 57 }; 58 59 // Adapter class that releases a refcounted object when the 60 // SupportsUserData::Data object is deleted. 61 template <typename T> 62 class UserDataAdapter : public base::SupportsUserData::Data { 63 public: Get(SupportsUserData * supports_user_data,const void * key)64 static T* Get(SupportsUserData* supports_user_data, const void* key) { 65 UserDataAdapter* data = 66 static_cast<UserDataAdapter*>(supports_user_data->GetUserData(key)); 67 return data ? static_cast<T*>(data->object_.get()) : NULL; 68 } 69 UserDataAdapter(T * object)70 UserDataAdapter(T* object) : object_(object) {} release()71 T* release() { return object_.release(); } 72 73 private: 74 scoped_refptr<T> object_; 75 76 DISALLOW_COPY_AND_ASSIGN(UserDataAdapter); 77 }; 78 79 } // namespace base 80 81 #endif // BASE_SUPPORTS_USER_DATA_H_ 82