ppapi/shared_impl/resource_tracker.h

   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 PPAPI_SHARED_IMPL_RESOURCE_TRACKER_H_
   6 #define PPAPI_SHARED_IMPL_RESOURCE_TRACKER_H_
   7
   8 #include <set>
   9
  10 #include "base/basictypes.h"
  11 #include "base/containers/hash_tables.h"
  12 #include "base/memory/linked_ptr.h"
  13 #include "base/memory/scoped_ptr.h"
  14 #include "base/memory/weak_ptr.h"
  15 #include "base/threading/thread_checker.h"
  16 #include "base/threading/thread_checker_impl.h"
  17 #include "ppapi/c/pp_instance.h"
  18 #include "ppapi/c/pp_resource.h"
  19 #include "ppapi/shared_impl/ppapi_shared_export.h"
  20
  21 namespace ppapi {
  22
  23 class Resource;
  24
  25 class PPAPI_SHARED_EXPORT ResourceTracker {
  26  public:
  27   // A SINGLE_THREADED ResourceTracker will use a thread-checker to make sure
  28   // it's always invoked on the same thread on which it was constructed. A
  29   // THREAD_SAFE ResourceTracker will check that the ProxyLock is held. See
  30   // CheckThreadingPreconditions() for more details.
  31   enum ThreadMode { SINGLE_THREADED, THREAD_SAFE };
  32   explicit ResourceTracker(ThreadMode thread_mode);
  33   virtual ~ResourceTracker();
  34
  35   // The returned pointer will be NULL if there is no resource. The reference
  36   // count of the resource is unaffected.
  37   Resource* GetResource(PP_Resource res) const;
  38
  39   void AddRefResource(PP_Resource res);
  40   void ReleaseResource(PP_Resource res);
  41
  42   // Releases a reference on the given resource once the message loop returns.
  43   void ReleaseResourceSoon(PP_Resource res);
  44
  45   // Notifies the tracker that a new instance has been created. This must be
  46   // called before creating any resources associated with the instance.
  47   void DidCreateInstance(PP_Instance instance);
  48
  49   // Called when an instance is being deleted. All plugin refs for the
  50   // associated resources will be force freed, and the resources (if they still
  51   // exist) will be disassociated from the instance.
  52   void DidDeleteInstance(PP_Instance instance);
  53
  54   // Returns the number of resources associated with the given instance.
  55   // Returns 0 if the instance isn't known.
  56   int GetLiveObjectsForInstance(PP_Instance instance) const;
  57
  58  protected:
  59   // This calls AddResource and RemoveResource.
  60   friend class Resource;
  61
  62   // On the host-side, make sure we are called on the right thread. On the
  63   // plugin side, make sure we have the proxy lock.
  64   void CheckThreadingPreconditions() const;
  65
  66   // Adds the given resource to the tracker, associating it with the instance
  67   // stored in the resource object. The new resource ID is returned, and the
  68   // resource will have 0 plugin refcount. This is called by the resource
  69   // constructor.
  70   //
  71   // Returns 0 if the resource could not be added.
  72   virtual PP_Resource AddResource(Resource* object);
  73
  74   // The opposite of AddResource, this removes the tracking information for
  75   // the given resource. It's called from the resource destructor.
  76   virtual void RemoveResource(Resource* object);
  77
  78  private:
  79   // Calls NotifyLastPluginRefWasDeleted on the given resource object and
  80   // cancels pending callbacks for the resource.
  81   void LastPluginRefWasDeleted(Resource* object);
  82
  83   typedef std::set<PP_Resource> ResourceSet;
  84
  85   struct InstanceData {
  86     // Lists all resources associated with the given instance as non-owning
  87     // pointers. This allows us to notify those resources that the instance is
  88     // going away (otherwise, they may crash if they outlive the instance).
  89     ResourceSet resources;
  90   };
  91   typedef base::hash_map<PP_Instance, linked_ptr<InstanceData> > InstanceMap;
  92
  93   InstanceMap instance_map_;
  94
  95   // For each PP_Resource, keep the object pointer and a plugin use count.
  96   // This use count is different then Resource object's RefCount, and is
  97   // manipulated using this AddRefResource/UnrefResource. When the plugin use
  98   // count is positive, we keep an extra ref on the Resource on
  99   // behalf of the plugin. When it drops to 0, we free that ref, keeping
 100   // the resource in the list.
 101   //
 102   // A resource will be in this list as long as the object is alive.
 103   typedef std::pair<Resource*, int> ResourceAndRefCount;
 104   typedef base::hash_map<PP_Resource, ResourceAndRefCount> ResourceMap;
 105   ResourceMap live_resources_;
 106
 107   int32 last_resource_value_;
 108
 109   base::WeakPtrFactory<ResourceTracker> weak_ptr_factory_;
 110
 111   // On the host side, we want to check that we are only called on the main
 112   // thread. This is to protect us from accidentally using the tracker from
 113   // other threads (especially the IO thread). On the plugin side, the tracker
 114   // is protected by the proxy lock and is thread-safe, so this will be NULL.
 115   scoped_ptr<base::ThreadChecker> thread_checker_;
 116
 117   DISALLOW_COPY_AND_ASSIGN(ResourceTracker);
 118 };
 119
 120 }  // namespace ppapi
 121
 122 #endif  // PPAPI_SHARED_IMPL_RESOURCE_TRACKER_H_