ppapi/shared_impl/resource_tracker.cc

   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 #include "ppapi/shared_impl/resource_tracker.h"
   6
   7 #include "base/bind.h"
   8 #include "base/compiler_specific.h"
   9 #include "base/message_loop.h"
  10 #include "ppapi/shared_impl/callback_tracker.h"
  11 #include "ppapi/shared_impl/id_assignment.h"
  12 #include "ppapi/shared_impl/ppapi_globals.h"
  13 #include "ppapi/shared_impl/proxy_lock.h"
  14 #include "ppapi/shared_impl/resource.h"
  15
  16 namespace ppapi {
  17
  18 ResourceTracker::ResourceTracker(ThreadMode thread_mode)
  19     : last_resource_value_(0),
  20       weak_ptr_factory_(this) {
  21   if (thread_mode == SINGLE_THREADED)
  22     thread_checker_.reset(new base::ThreadChecker);
  23 }
  24
  25 ResourceTracker::~ResourceTracker() {
  26 }
  27
  28 void ResourceTracker::CheckThreadingPreconditions() const {
  29   DCHECK(!thread_checker_ || thread_checker_->CalledOnValidThread());
  30 #ifndef NDEBUG
  31   ProxyLock::AssertAcquired();
  32 #endif
  33 }
  34
  35 Resource* ResourceTracker::GetResource(PP_Resource res) const {
  36   CheckThreadingPreconditions();
  37   ResourceMap::const_iterator i = live_resources_.find(res);
  38   if (i == live_resources_.end())
  39     return NULL;
  40   return i->second.first;
  41 }
  42
  43 void ResourceTracker::AddRefResource(PP_Resource res) {
  44   CheckThreadingPreconditions();
  45   DLOG_IF(ERROR, !CheckIdType(res, PP_ID_TYPE_RESOURCE))
  46       << res << " is not a PP_Resource.";
  47   ResourceMap::iterator i = live_resources_.find(res);
  48   if (i == live_resources_.end())
  49     return;
  50
  51   // Prevent overflow of refcount.
  52   if (i->second.second ==
  53       std::numeric_limits<ResourceAndRefCount::second_type>::max())
  54     return;
  55
  56   // When we go from 0 to 1 plugin ref count, keep an additional "real" ref
  57   // on its behalf.
  58   if (i->second.second == 0)
  59     i->second.first->AddRef();
  60
  61   i->second.second++;
  62   return;
  63 }
  64
  65 void ResourceTracker::ReleaseResource(PP_Resource res) {
  66   CheckThreadingPreconditions();
  67   DLOG_IF(ERROR, !CheckIdType(res, PP_ID_TYPE_RESOURCE))
  68       << res << " is not a PP_Resource.";
  69   ResourceMap::iterator i = live_resources_.find(res);
  70   if (i == live_resources_.end())
  71     return;
  72
  73   // Prevent underflow of refcount.
  74   if (i->second.second == 0)
  75     return;
  76
  77   i->second.second--;
  78   if (i->second.second == 0) {
  79     LastPluginRefWasDeleted(i->second.first);
  80
  81     // When we go from 1 to 0 plugin ref count, free the additional "real" ref
  82     // on its behalf. THIS WILL MOST LIKELY RELEASE THE OBJECT AND REMOVE IT
  83     // FROM OUR LIST.
  84     i->second.first->Release();
  85   }
  86 }
  87
  88 void ResourceTracker::ReleaseResourceSoon(PP_Resource res) {
  89   base::MessageLoop::current()->PostNonNestableTask(
  90       FROM_HERE,
  91       RunWhileLocked(base::Bind(&ResourceTracker::ReleaseResource,
  92                                 weak_ptr_factory_.GetWeakPtr(),
  93                                 res)));
  94 }
  95
  96 void ResourceTracker::DidCreateInstance(PP_Instance instance) {
  97   CheckThreadingPreconditions();
  98   // Due to the infrastructure of some tests, the instance is registered
  99   // twice in a few cases. It would be nice not to do that and assert here
 100   // instead.
 101   if (instance_map_.find(instance) != instance_map_.end())
 102     return;
 103   instance_map_[instance] = linked_ptr<InstanceData>(new InstanceData);
 104 }
 105
 106 void ResourceTracker::DidDeleteInstance(PP_Instance instance) {
 107   CheckThreadingPreconditions();
 108   InstanceMap::iterator found_instance = instance_map_.find(instance);
 109
 110   // Due to the infrastructure of some tests, the instance is unregistered
 111   // twice in a few cases. It would be nice not to do that and assert here
 112   // instead.
 113   if (found_instance == instance_map_.end())
 114     return;
 115
 116   InstanceData& data = *found_instance->second;
 117
 118   // Force release all plugin references to resources associated with the
 119   // deleted instance. Make a copy since as we iterate through them, each one
 120   // will remove itself from the tracking info individually.
 121   ResourceSet to_delete = data.resources;
 122   ResourceSet::iterator cur = to_delete.begin();
 123   while (cur != to_delete.end()) {
 124     // Note that it's remotely possible for the object to already be deleted
 125     // from the live resources. One case is if a resource object is holding
 126     // the last ref to another. When we release the first one, it will release
 127     // the second one. So the second one will be gone when we eventually get
 128     // to it.
 129     ResourceMap::iterator found_resource = live_resources_.find(*cur);
 130     if (found_resource != live_resources_.end()) {
 131       Resource* resource = found_resource->second.first;
 132       if (found_resource->second.second > 0) {
 133         LastPluginRefWasDeleted(resource);
 134         found_resource->second.second = 0;
 135
 136         // This will most likely delete the resource object and remove it
 137         // from the live_resources_ list.
 138         resource->Release();
 139       }
 140     }
 141
 142     cur++;
 143   }
 144
 145   // In general the above pass will delete all the resources and there won't
 146   // be any left in the map. However, if parts of the implementation are still
 147   // holding on to internal refs, we need to tell them that the instance is
 148   // gone.
 149   to_delete = data.resources;
 150   cur = to_delete.begin();
 151   while (cur != to_delete.end()) {
 152     ResourceMap::iterator found_resource = live_resources_.find(*cur);
 153     if (found_resource != live_resources_.end())
 154       found_resource->second.first->NotifyInstanceWasDeleted();
 155     cur++;
 156   }
 157
 158   instance_map_.erase(instance);
 159 }
 160
 161 int ResourceTracker::GetLiveObjectsForInstance(PP_Instance instance) const {
 162   CheckThreadingPreconditions();
 163   InstanceMap::const_iterator found = instance_map_.find(instance);
 164   if (found == instance_map_.end())
 165     return 0;
 166   return static_cast<int>(found->second->resources.size());
 167 }
 168
 169 PP_Resource ResourceTracker::AddResource(Resource* object) {
 170   CheckThreadingPreconditions();
 171   // If the plugin manages to create too many resources, don't do crazy stuff.
 172   if (last_resource_value_ == kMaxPPId)
 173     return 0;
 174
 175   // Allocate an ID. Note there's a rare error condition below that means we
 176   // could end up not using |new_id|, but that's harmless.
 177   PP_Resource new_id = MakeTypedId(++last_resource_value_, PP_ID_TYPE_RESOURCE);
 178
 179   // Some objects have a 0 instance, meaning they aren't associated with any
 180   // instance, so they won't be in |instance_map_|. This is (as of this writing)
 181   // only true of the PPB_MessageLoop resource for the main thread.
 182   if (object->pp_instance()) {
 183     InstanceMap::iterator found = instance_map_.find(object->pp_instance());
 184     if (found == instance_map_.end()) {
 185       // If you hit this, it's likely somebody forgot to call DidCreateInstance,
 186       // the resource was created with an invalid PP_Instance, or the renderer
 187       // side tried to create a resource for a plugin that crashed/exited. This
 188       // could happen for OOP plugins where due to reentrancies in context of
 189       // outgoing sync calls the renderer can send events after a plugin has
 190       // exited.
 191       DLOG(INFO) << "Failed to find plugin instance in instance map";
 192       return 0;
 193     }
 194     found->second->resources.insert(new_id);
 195   }
 196
 197   live_resources_[new_id] = ResourceAndRefCount(object, 0);
 198   return new_id;
 199 }
 200
 201 void ResourceTracker::RemoveResource(Resource* object) {
 202   CheckThreadingPreconditions();
 203   PP_Resource pp_resource = object->pp_resource();
 204   InstanceMap::iterator found = instance_map_.find(object->pp_instance());
 205   if (found != instance_map_.end())
 206     found->second->resources.erase(pp_resource);
 207   live_resources_.erase(pp_resource);
 208 }
 209
 210 void ResourceTracker::LastPluginRefWasDeleted(Resource* object) {
 211   // Bug http://crbug.com/134611 indicates that sometimes the resource tracker
 212   // is null here. This should never be the case since if we have a resource in
 213   // the tracker, it should always have a valid instance associated with it
 214   // (except for the resource for the main thread's message loop, which has
 215   // instance set to 0).
 216   // As a result, we do some CHECKs here to see what types of problems the
 217   // instance might have before dispatching.
 218   //
 219   // TODO(brettw) remove these checks when this bug is no longer relevant.
 220   // Note, we do an imperfect check here; this might be a loop that's not the
 221   // main one.
 222   const bool is_message_loop = (object->AsPPB_MessageLoop_API() != NULL);
 223   CHECK(object->pp_instance() || is_message_loop);
 224   CallbackTracker* callback_tracker =
 225       PpapiGlobals::Get()->GetCallbackTrackerForInstance(object->pp_instance());
 226   CHECK(callback_tracker || is_message_loop);
 227   if (callback_tracker)
 228     callback_tracker->PostAbortForResource(object->pp_resource());
 229   object->NotifyLastPluginRefWasDeleted();
 230 }
 231
 232 }  // namespace ppapi