object_tracker.h

Go to the documentation of this file.

// Copyright 2016 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef SHAKA_EMBEDDED_MEMORY_OBJECT_TRACKER_H_
#define SHAKA_EMBEDDED_MEMORY_OBJECT_TRACKER_H_

#include <glog/logging.h>

#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>

#include "src/debug/mutex.h"
#include "src/util/macros.h"
#include "src/util/pseudo_singleton.h"
#include "src/util/templates.h"

namespace shaka {

class JsManagerImpl;
class RefPtrTest;

namespace eme {
class ClearKeyImplementationTest;
}  // namespace eme

namespace memory {

class HeapTracer;
class Traceable;

class ObjectTracker final : public PseudoSingleton<ObjectTracker> {
 public:
  explicit ObjectTracker(HeapTracer* tracer);
  ~ObjectTracker();

  SHAKA_NON_COPYABLE_OR_MOVABLE_TYPE(ObjectTracker);

  void RegisterObject(Traceable* object);

  void ForceAlive(const Traceable* ptr);

  void AddRef(const Traceable* object);

  void RemoveRef(const Traceable* object);

  std::unordered_set<const Traceable*> GetAliveObjects() const;

  void FreeDeadObjects(const std::unordered_set<const Traceable*>& alive);

  void Dispose();

 private:
  friend RefPtrTest;
  friend class ObjectTrackerTest;

  bool IsJsAlive(Traceable* object) const;

  uint32_t GetRefCount(Traceable* object) const;

  void DestroyObjects(const std::unordered_set<Traceable*>& to_delete,
                      std::unique_lock<Mutex>* lock);

  mutable Mutex mutex_;
  HeapTracer* tracer_;
  // A map of object pointer to ref count.
  std::unordered_map<Traceable*, uint32_t> objects_;
  std::unordered_map<Traceable*, uint64_t> last_alive_time_;
  std::unordered_set<Traceable*> to_delete_;
};

}  // namespace memory
}  // namespace shaka

#endif  // SHAKA_EMBEDDED_MEMORY_OBJECT_TRACKER_H_