Home | History | Annotate | Download | only in base 
      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:
     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:
     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 
     70   UserDataAdapter(T* object) : object_(object) {}
     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