Home | History | Annotate | Download | only in shared_impl 
      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_
    123