mirror of
https://bitbucket.org/chromiumembedded/cef
synced 2024-12-08 07:41:04 +01:00
443 lines
13 KiB
C++
443 lines
13 KiB
C++
// Copyright (c) 2012 The Chromium Embedded Framework Authors. All rights
|
|
// reserved. Use of this source code is governed by a BSD-style license that
|
|
// can be found in the LICENSE file.
|
|
|
|
#ifndef CEF_LIBCEF_COMMON_VALUE_BASE_H_
|
|
#define CEF_LIBCEF_COMMON_VALUE_BASE_H_
|
|
#pragma once
|
|
|
|
#include <map>
|
|
#include <set>
|
|
#include "include/cef_base.h"
|
|
|
|
#include "base/logging.h"
|
|
#include "base/memory/ref_counted.h"
|
|
#include "base/notreached.h"
|
|
#include "base/synchronization/lock.h"
|
|
#include "base/thread_annotations.h"
|
|
#include "base/threading/platform_thread.h"
|
|
|
|
// Controller implementation base class.
|
|
class CefValueController
|
|
: public base::RefCountedThreadSafe<CefValueController> {
|
|
public:
|
|
// Implemented by a class controlled using the access controller.
|
|
class Object {
|
|
public:
|
|
virtual ~Object() {}
|
|
|
|
// Called when the value has been removed.
|
|
virtual void OnControlRemoved() = 0;
|
|
};
|
|
|
|
// Encapsulates context locking and verification logic.
|
|
class AutoLock {
|
|
public:
|
|
explicit AutoLock(CefValueController* impl)
|
|
: impl_(impl), verified_(impl && impl->VerifyThread()) {
|
|
DCHECK(impl);
|
|
if (verified_) {
|
|
impl_->lock();
|
|
}
|
|
}
|
|
|
|
AutoLock(const AutoLock&) = delete;
|
|
AutoLock& operator=(const AutoLock&) = delete;
|
|
|
|
~AutoLock() {
|
|
if (verified_) {
|
|
impl_->unlock();
|
|
}
|
|
}
|
|
|
|
inline bool verified() { return verified_; }
|
|
|
|
private:
|
|
scoped_refptr<CefValueController> impl_;
|
|
bool verified_;
|
|
};
|
|
|
|
CefValueController();
|
|
|
|
CefValueController(const CefValueController&) = delete;
|
|
CefValueController& operator=(const CefValueController&) = delete;
|
|
|
|
// Returns true if this controller is thread safe.
|
|
virtual bool thread_safe() = 0;
|
|
|
|
// Returns true if the current thread is allowed to access this controller.
|
|
virtual bool on_correct_thread() = 0;
|
|
|
|
// Lock the controller.
|
|
virtual void lock() = 0;
|
|
|
|
// Unlock the controller.
|
|
virtual void unlock() = 0;
|
|
|
|
// Returns true if the controller is locked on the current thread.
|
|
virtual bool locked() = 0;
|
|
|
|
// Assert that the lock has been acquired.
|
|
virtual void AssertLockAcquired() = 0;
|
|
|
|
// Verify that the current thread is correct for accessing the controller.
|
|
inline bool VerifyThread() {
|
|
if (!thread_safe() && !on_correct_thread()) {
|
|
// This object should only be accessed from the thread that created it.
|
|
NOTREACHED() << "object accessed from incorrect thread.";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
// The controller must already be locked before calling the below methods.
|
|
|
|
// Set the owner for this controller.
|
|
void SetOwner(void* value, Object* object);
|
|
|
|
// Add a reference value and associated object.
|
|
void AddReference(void* value, Object* object);
|
|
|
|
// Remove the value. If |notify_object| is true the removed object will be
|
|
// notified. If |value| is the owner all reference objects will be removed.
|
|
// If |value| has dependencies those objects will also be removed.
|
|
void Remove(void* value, bool notify_object);
|
|
|
|
// Returns the object for the specified value.
|
|
Object* Get(void* value);
|
|
|
|
// Add a dependency between |parent| and |child|.
|
|
void AddDependency(void* parent, void* child);
|
|
|
|
// Recursively removes any dependent values.
|
|
void RemoveDependencies(void* value);
|
|
|
|
// Takes ownership of all references and dependencies currently controlled by
|
|
// |other|. The |other| controller must already be locked.
|
|
void TakeFrom(CefValueController* other);
|
|
|
|
// Replace all instances of |old_value| with |new_value|. Used in cases where
|
|
// move semantics may move the contents of an object without retaining the
|
|
// object pointer itself.
|
|
void Swap(void* old_value, void* new_value);
|
|
|
|
protected:
|
|
friend class base::RefCountedThreadSafe<CefValueController>;
|
|
|
|
virtual ~CefValueController();
|
|
|
|
private:
|
|
// Owner object.
|
|
void* owner_value_;
|
|
Object* owner_object_;
|
|
|
|
// Map of reference objects.
|
|
using ReferenceMap = std::map<void*, Object*>;
|
|
ReferenceMap reference_map_;
|
|
|
|
// Map of dependency objects.
|
|
using DependencySet = std::set<void*>;
|
|
using DependencyMap = std::map<void*, DependencySet>;
|
|
DependencyMap dependency_map_;
|
|
};
|
|
|
|
// Thread-safe access control implementation.
|
|
class CefValueControllerThreadSafe : public CefValueController {
|
|
public:
|
|
explicit CefValueControllerThreadSafe() : locked_thread_id_(0) {}
|
|
|
|
CefValueControllerThreadSafe(const CefValueControllerThreadSafe&) = delete;
|
|
CefValueControllerThreadSafe& operator=(const CefValueControllerThreadSafe&) =
|
|
delete;
|
|
|
|
// CefValueController methods.
|
|
bool thread_safe() override { return true; }
|
|
bool on_correct_thread() override { return true; }
|
|
void lock() override NO_THREAD_SAFETY_ANALYSIS {
|
|
lock_.Acquire();
|
|
locked_thread_id_ = base::PlatformThread::CurrentId();
|
|
}
|
|
void unlock() override NO_THREAD_SAFETY_ANALYSIS {
|
|
locked_thread_id_ = 0;
|
|
lock_.Release();
|
|
}
|
|
bool locked() override {
|
|
return (locked_thread_id_ == base::PlatformThread::CurrentId());
|
|
}
|
|
void AssertLockAcquired() override { lock_.AssertAcquired(); }
|
|
|
|
private:
|
|
base::Lock lock_;
|
|
base::PlatformThreadId locked_thread_id_;
|
|
};
|
|
|
|
// Non-thread-safe access control implementation.
|
|
class CefValueControllerNonThreadSafe : public CefValueController {
|
|
public:
|
|
explicit CefValueControllerNonThreadSafe()
|
|
: thread_id_(base::PlatformThread::CurrentId()) {}
|
|
|
|
CefValueControllerNonThreadSafe(const CefValueControllerNonThreadSafe&) =
|
|
delete;
|
|
CefValueControllerNonThreadSafe& operator=(
|
|
const CefValueControllerNonThreadSafe&) = delete;
|
|
|
|
// CefValueController methods.
|
|
bool thread_safe() override { return false; }
|
|
bool on_correct_thread() override {
|
|
return (thread_id_ == base::PlatformThread::CurrentId());
|
|
}
|
|
void lock() override {}
|
|
void unlock() override {}
|
|
bool locked() override { return on_correct_thread(); }
|
|
void AssertLockAcquired() override { DCHECK(locked()); }
|
|
|
|
private:
|
|
base::PlatformThreadId thread_id_;
|
|
};
|
|
|
|
// Helper macros for verifying context.
|
|
|
|
#define CEF_VALUE_VERIFY_RETURN_VOID_EX(object, modify) \
|
|
if (!VerifyAttached()) \
|
|
return; \
|
|
AutoLock auto_lock(object, modify); \
|
|
if (!auto_lock.verified()) \
|
|
return;
|
|
|
|
#define CEF_VALUE_VERIFY_RETURN_VOID(modify) \
|
|
CEF_VALUE_VERIFY_RETURN_VOID_EX(this, modify)
|
|
|
|
#define CEF_VALUE_VERIFY_RETURN_EX(object, modify, error_val) \
|
|
if (!VerifyAttached()) \
|
|
return error_val; \
|
|
AutoLock auto_lock(object, modify); \
|
|
if (!auto_lock.verified()) \
|
|
return error_val;
|
|
|
|
#define CEF_VALUE_VERIFY_RETURN(modify, error_val) \
|
|
CEF_VALUE_VERIFY_RETURN_EX(this, modify, error_val)
|
|
|
|
// Template class for implementing CEF wrappers of other types.
|
|
template <class CefType, class ValueType>
|
|
class CefValueBase : public CefType, public CefValueController::Object {
|
|
public:
|
|
// Specifies how the value will be used.
|
|
enum ValueMode {
|
|
// A reference to a value managed by an existing controller. These values
|
|
// can be safely detached but ownership should not be transferred (make a
|
|
// copy of the value instead).
|
|
kReference,
|
|
|
|
// The value has its own controller and will be deleted on destruction.
|
|
// These values can only be detached to another controller otherwise any
|
|
// references will not be properly managed.
|
|
kOwnerWillDelete,
|
|
|
|
// The value has its own controller and will not be deleted on destruction.
|
|
// This should only be used for global values or scope-limited values that
|
|
// will be explicitly detached.
|
|
kOwnerNoDelete,
|
|
};
|
|
|
|
// Create a new object.
|
|
// If |read_only| is true mutable access will not be allowed.
|
|
// If |parent_value| is non-NULL and the value mode is kReference a dependency
|
|
// will be added.
|
|
CefValueBase(ValueType* value,
|
|
void* parent_value,
|
|
ValueMode value_mode,
|
|
bool read_only,
|
|
CefValueController* controller)
|
|
: value_(value),
|
|
value_mode_(value_mode),
|
|
read_only_(read_only),
|
|
controller_(controller) {
|
|
DCHECK(value_);
|
|
|
|
// Specifying a parent value for a non-reference doesn't make sense.
|
|
DCHECK(!(!reference() && parent_value));
|
|
|
|
if (!reference() && !controller_.get()) {
|
|
// For owned values default to using a new multi-threaded controller.
|
|
controller_ = new CefValueControllerThreadSafe();
|
|
SetOwnsController();
|
|
}
|
|
|
|
// A controller is required.
|
|
DCHECK(controller_.get());
|
|
|
|
if (reference()) {
|
|
// Register the reference with the controller.
|
|
controller_->AddReference(value_, this);
|
|
|
|
// Add a dependency on the parent value.
|
|
if (parent_value) {
|
|
controller_->AddDependency(parent_value, value_);
|
|
}
|
|
}
|
|
}
|
|
|
|
CefValueBase(const CefValueBase&) = delete;
|
|
CefValueBase& operator=(const CefValueBase&) = delete;
|
|
|
|
~CefValueBase() override {
|
|
if (controller_.get() && value_) {
|
|
Delete();
|
|
}
|
|
}
|
|
|
|
// True if the underlying value is referenced instead of owned.
|
|
inline bool reference() const { return (value_mode_ == kReference); }
|
|
|
|
// True if the underlying value will be deleted.
|
|
inline bool will_delete() const { return (value_mode_ == kOwnerWillDelete); }
|
|
|
|
// True if access to the underlying value is read-only.
|
|
inline bool read_only() const { return read_only_; }
|
|
|
|
// True if the underlying value has been detached.
|
|
inline bool detached() const { return !controller_.get(); }
|
|
|
|
// Returns the controller.
|
|
inline CefValueController* controller() const { return controller_.get(); }
|
|
|
|
// Deletes the underlying value.
|
|
void Delete() {
|
|
CEF_VALUE_VERIFY_RETURN_VOID(false);
|
|
|
|
// Remove the object from the controller. If this is the owner object any
|
|
// references will be detached.
|
|
controller()->Remove(value_, false);
|
|
|
|
if (will_delete()) {
|
|
// Remove any dependencies.
|
|
controller()->RemoveDependencies(value_);
|
|
|
|
// Delete the value.
|
|
DeleteValue(value_);
|
|
}
|
|
|
|
controller_ = nullptr;
|
|
value_ = nullptr;
|
|
}
|
|
|
|
// Detaches the underlying value and returns a pointer to it. If this is an
|
|
// owner and a |new_controller| value is specified any existing references
|
|
// will be passed to the new controller.
|
|
[[nodiscard]] ValueType* Detach(CefValueController* new_controller) {
|
|
CEF_VALUE_VERIFY_RETURN(false, nullptr);
|
|
|
|
if (new_controller && !reference()) {
|
|
// Pass any existing references and dependencies to the new controller.
|
|
// They will be removed from this controller.
|
|
new_controller->TakeFrom(controller());
|
|
}
|
|
|
|
// Remove the object from the controller. If this is the owner object any
|
|
// references will be detached.
|
|
controller()->Remove(value_, false);
|
|
controller_ = nullptr;
|
|
|
|
// Return the old value.
|
|
ValueType* old_val = value_;
|
|
value_ = nullptr;
|
|
return old_val;
|
|
}
|
|
|
|
// Verify that the value is attached.
|
|
inline bool VerifyAttached() const {
|
|
if (detached()) {
|
|
// This object should not be accessed after being detached.
|
|
NOTREACHED() << "object accessed after being detached.";
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
protected:
|
|
// CefValueController::Object methods.
|
|
void OnControlRemoved() override {
|
|
DCHECK(controller()->locked());
|
|
|
|
// Only references should be removed in this manner.
|
|
DCHECK(reference());
|
|
|
|
controller_ = nullptr;
|
|
value_ = nullptr;
|
|
}
|
|
|
|
// Override to customize value deletion.
|
|
virtual void DeleteValue(ValueType* value) { delete value; }
|
|
|
|
// Returns a mutable reference to the value.
|
|
inline ValueType* mutable_value() const {
|
|
DCHECK(value_);
|
|
DCHECK(!read_only_);
|
|
DCHECK(controller()->locked());
|
|
return value_;
|
|
}
|
|
|
|
// Returns a const reference to the value.
|
|
inline const ValueType& const_value() const {
|
|
DCHECK(value_);
|
|
DCHECK(controller()->locked());
|
|
return *value_;
|
|
}
|
|
|
|
// Returns an mutable reference to the value without checking read-only state.
|
|
inline ValueType* mutable_value_unchecked() const {
|
|
return const_cast<ValueType*>(&const_value());
|
|
}
|
|
|
|
// Verify that the value can be accessed.
|
|
inline bool VerifyAccess(bool modify) const {
|
|
// The controller must already be locked.
|
|
DCHECK(controller()->locked());
|
|
|
|
if (read_only() && modify) {
|
|
// This object cannot be modified.
|
|
NOTREACHED() << "mutation attempted on read-only object.";
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Used to indicate that this object owns the controller.
|
|
inline void SetOwnsController() {
|
|
CefValueController::AutoLock lock_scope(controller_.get());
|
|
if (lock_scope.verified()) {
|
|
controller_->SetOwner(value_, this);
|
|
}
|
|
}
|
|
|
|
// Encapsulates value locking and verification logic.
|
|
class AutoLock {
|
|
public:
|
|
explicit AutoLock(CefValueBase* impl, bool modify)
|
|
: auto_lock_(impl->controller()) {
|
|
verified_ = (auto_lock_.verified() && impl->VerifyAccess(modify));
|
|
}
|
|
|
|
AutoLock(const AutoLock&) = delete;
|
|
AutoLock& operator=(const AutoLock&) = delete;
|
|
|
|
inline bool verified() { return verified_; }
|
|
|
|
private:
|
|
CefValueController::AutoLock auto_lock_;
|
|
bool verified_;
|
|
};
|
|
|
|
private:
|
|
ValueType* value_;
|
|
ValueMode value_mode_;
|
|
bool read_only_;
|
|
scoped_refptr<CefValueController> controller_;
|
|
|
|
IMPLEMENT_REFCOUNTING(CefValueBase);
|
|
};
|
|
|
|
#endif // CEF_LIBCEF_COMMON_VALUE_BASE_H_
|