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