ppapi/shared_impl/var_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/var_tracker.h"
   6
   7 #include <string.h>
   8
   9 #include <limits>
  10
  11 #include "base/logging.h"
  12 #include "base/memory/shared_memory.h"
  13 #include "ppapi/shared_impl/host_resource.h"
  14 #include "ppapi/shared_impl/id_assignment.h"
  15 #include "ppapi/shared_impl/proxy_lock.h"
  16 #include "ppapi/shared_impl/resource_var.h"
  17 #include "ppapi/shared_impl/var.h"
  18
  19 namespace ppapi {
  20
  21 VarTracker::VarInfo::VarInfo()
  22     : var(), ref_count(0), track_with_no_reference_count(0) {}
  23
  24 VarTracker::VarInfo::VarInfo(Var* v, int input_ref_count)
  25     : var(v), ref_count(input_ref_count), track_with_no_reference_count(0) {}
  26
  27 VarTracker::VarTracker(ThreadMode thread_mode) : last_var_id_(0) {
  28   if (thread_mode == SINGLE_THREADED)
  29     thread_checker_.reset(new base::ThreadChecker);
  30 }
  31
  32 VarTracker::~VarTracker() {}
  33
  34 void VarTracker::CheckThreadingPreconditions() const {
  35   DCHECK(!thread_checker_ || thread_checker_->CalledOnValidThread());
  36 #ifndef NDEBUG
  37   ProxyLock::AssertAcquired();
  38 #endif
  39 }
  40
  41 int32 VarTracker::AddVar(Var* var) {
  42   CheckThreadingPreconditions();
  43
  44   return AddVarInternal(var, ADD_VAR_TAKE_ONE_REFERENCE);
  45 }
  46
  47 Var* VarTracker::GetVar(int32 var_id) const {
  48   CheckThreadingPreconditions();
  49
  50   VarMap::const_iterator result = live_vars_.find(var_id);
  51   if (result == live_vars_.end())
  52     return NULL;
  53   return result->second.var.get();
  54 }
  55
  56 Var* VarTracker::GetVar(const PP_Var& var) const {
  57   CheckThreadingPreconditions();
  58
  59   if (!IsVarTypeRefcounted(var.type))
  60     return NULL;
  61   return GetVar(static_cast<int32>(var.value.as_id));
  62 }
  63
  64 bool VarTracker::AddRefVar(int32 var_id) {
  65   CheckThreadingPreconditions();
  66
  67   DLOG_IF(ERROR, !CheckIdType(var_id, PP_ID_TYPE_VAR))
  68       << var_id << " is not a PP_Var ID.";
  69   VarMap::iterator found = live_vars_.find(var_id);
  70   if (found == live_vars_.end()) {
  71     NOTREACHED();  // Invalid var.
  72     return false;
  73   }
  74
  75   VarInfo& info = found->second;
  76   if (info.ref_count == 0) {
  77     // All live vars with no refcount should be tracked objects.
  78     DCHECK(info.track_with_no_reference_count > 0);
  79     DCHECK(info.var->GetType() == PP_VARTYPE_OBJECT);
  80
  81     TrackedObjectGettingOneRef(found);
  82   }
  83
  84   // Basic refcount increment.
  85   info.ref_count++;
  86   return true;
  87 }
  88
  89 bool VarTracker::AddRefVar(const PP_Var& var) {
  90   CheckThreadingPreconditions();
  91
  92   if (!IsVarTypeRefcounted(var.type))
  93     return true;
  94   return AddRefVar(static_cast<int32>(var.value.as_id));
  95 }
  96
  97 bool VarTracker::ReleaseVar(int32 var_id) {
  98   CheckThreadingPreconditions();
  99
 100   DLOG_IF(ERROR, !CheckIdType(var_id, PP_ID_TYPE_VAR))
 101       << var_id << " is not a PP_Var ID.";
 102   VarMap::iterator found = live_vars_.find(var_id);
 103   if (found == live_vars_.end())
 104     return false;
 105
 106   VarInfo& info = found->second;
 107   if (info.ref_count == 0) {
 108     NOTREACHED() << "Releasing an object with zero ref";
 109     return false;
 110   }
 111   info.ref_count--;
 112
 113   if (info.ref_count == 0) {
 114     // Hold a reference to the Var until it is erased so that we don't re-enter
 115     // live_vars_.erase() during deletion.
 116     // TODO(raymes): Make deletion of Vars iterative instead of recursive.
 117     scoped_refptr<Var> var(info.var);
 118     if (var->GetType() == PP_VARTYPE_OBJECT) {
 119       // Objects have special requirements and may not necessarily be released
 120       // when the refcount goes to 0.
 121       ObjectGettingZeroRef(found);
 122     } else {
 123       // All other var types can just be released.
 124       DCHECK(info.track_with_no_reference_count == 0);
 125       var->ResetVarID();
 126       live_vars_.erase(found);
 127     }
 128   }
 129   return true;
 130 }
 131
 132 bool VarTracker::ReleaseVar(const PP_Var& var) {
 133   CheckThreadingPreconditions();
 134
 135   if (!IsVarTypeRefcounted(var.type))
 136     return false;
 137   return ReleaseVar(static_cast<int32>(var.value.as_id));
 138 }
 139
 140 int32 VarTracker::AddVarInternal(Var* var, AddVarRefMode mode) {
 141   // If the plugin manages to create millions of strings.
 142   if (last_var_id_ == std::numeric_limits<int32>::max() >> kPPIdTypeBits)
 143     return 0;
 144
 145   int32 new_id = MakeTypedId(++last_var_id_, PP_ID_TYPE_VAR);
 146   std::pair<VarMap::iterator, bool> was_inserted =
 147       live_vars_.insert(std::make_pair(
 148           new_id, VarInfo(var, mode == ADD_VAR_TAKE_ONE_REFERENCE ? 1 : 0)));
 149   // We should never insert an ID that already exists.
 150   DCHECK(was_inserted.second);
 151
 152   return new_id;
 153 }
 154
 155 VarTracker::VarMap::iterator VarTracker::GetLiveVar(int32 id) {
 156   return live_vars_.find(id);
 157 }
 158
 159 int VarTracker::GetRefCountForObject(const PP_Var& plugin_object) {
 160   CheckThreadingPreconditions();
 161
 162   VarMap::iterator found = GetLiveVar(plugin_object);
 163   if (found == live_vars_.end())
 164     return -1;
 165   return found->second.ref_count;
 166 }
 167
 168 int VarTracker::GetTrackedWithNoReferenceCountForObject(
 169     const PP_Var& plugin_object) {
 170   CheckThreadingPreconditions();
 171
 172   VarMap::iterator found = GetLiveVar(plugin_object);
 173   if (found == live_vars_.end())
 174     return -1;
 175   return found->second.track_with_no_reference_count;
 176 }
 177
 178 // static
 179 bool VarTracker::IsVarTypeRefcounted(PP_VarType type) {
 180   return type >= PP_VARTYPE_STRING;
 181 }
 182
 183 VarTracker::VarMap::iterator VarTracker::GetLiveVar(const PP_Var& var) {
 184   return live_vars_.find(static_cast<int32>(var.value.as_id));
 185 }
 186
 187 VarTracker::VarMap::const_iterator VarTracker::GetLiveVar(const PP_Var& var)
 188     const {
 189   return live_vars_.find(static_cast<int32>(var.value.as_id));
 190 }
 191
 192 PP_Var VarTracker::MakeArrayBufferPPVar(uint32 size_in_bytes) {
 193   CheckThreadingPreconditions();
 194
 195   scoped_refptr<ArrayBufferVar> array_buffer(CreateArrayBuffer(size_in_bytes));
 196   if (!array_buffer.get())
 197     return PP_MakeNull();
 198   return array_buffer->GetPPVar();
 199 }
 200
 201 PP_Var VarTracker::MakeArrayBufferPPVar(uint32 size_in_bytes,
 202                                         const void* data) {
 203   CheckThreadingPreconditions();
 204
 205   ArrayBufferVar* array_buffer = MakeArrayBufferVar(size_in_bytes, data);
 206   return array_buffer ? array_buffer->GetPPVar() : PP_MakeNull();
 207 }
 208
 209 ArrayBufferVar* VarTracker::MakeArrayBufferVar(uint32 size_in_bytes,
 210                                                const void* data) {
 211   CheckThreadingPreconditions();
 212
 213   ArrayBufferVar* array_buffer(CreateArrayBuffer(size_in_bytes));
 214   if (!array_buffer)
 215     return NULL;
 216   memcpy(array_buffer->Map(), data, size_in_bytes);
 217   return array_buffer;
 218 }
 219
 220 PP_Var VarTracker::MakeArrayBufferPPVar(uint32 size_in_bytes,
 221                                         base::SharedMemoryHandle handle) {
 222   CheckThreadingPreconditions();
 223
 224   scoped_refptr<ArrayBufferVar> array_buffer(
 225       CreateShmArrayBuffer(size_in_bytes, handle));
 226   if (!array_buffer.get())
 227     return PP_MakeNull();
 228   return array_buffer->GetPPVar();
 229 }
 230
 231 PP_Var VarTracker::MakeResourcePPVar(PP_Resource pp_resource) {
 232   CheckThreadingPreconditions();
 233
 234   ResourceVar* resource_var = MakeResourceVar(pp_resource);
 235   return resource_var ? resource_var->GetPPVar() : PP_MakeNull();
 236 }
 237
 238 std::vector<PP_Var> VarTracker::GetLiveVars() {
 239   CheckThreadingPreconditions();
 240
 241   std::vector<PP_Var> var_vector;
 242   var_vector.reserve(live_vars_.size());
 243   for (VarMap::const_iterator iter = live_vars_.begin();
 244        iter != live_vars_.end();
 245        ++iter) {
 246     var_vector.push_back(iter->second.var->GetPPVar());
 247   }
 248   return var_vector;
 249 }
 250
 251 void VarTracker::TrackedObjectGettingOneRef(VarMap::const_iterator obj) {
 252   // Anybody using tracked objects should override this.
 253   NOTREACHED();
 254 }
 255
 256 void VarTracker::ObjectGettingZeroRef(VarMap::iterator iter) {
 257   DeleteObjectInfoIfNecessary(iter);
 258 }
 259
 260 bool VarTracker::DeleteObjectInfoIfNecessary(VarMap::iterator iter) {
 261   if (iter->second.ref_count != 0 ||
 262       iter->second.track_with_no_reference_count != 0)
 263     return false;  // Object still alive.
 264   iter->second.var->ResetVarID();
 265   live_vars_.erase(iter);
 266   return true;
 267 }
 268
 269 }  // namespace ppapi