mirror of
https://github.com/electron/electron.git
synced 2026-04-10 03:01:51 -04:00
268cd3939c
* feat: add a new contextBridge module (#20307)
* feat: add a new contextBridge module
* chore: fix docs linting
* feat: add support for function arguments being proxied
* chore: ensure that contextBridge can only be used when contextIsolation is enabled
* docs: getReverseBinding can be null
* docs: fix broken links in md file
* feat: add support for promises in function parameters
* fix: linting failure for explicit constructor
* Update atom_api_context_bridge.cc
* chore: update docs and API design as per feedback
* refactor: remove reverse bindings and handle GC'able functions across the bridge
* chore: only expose debugGC in testing builds
* fix: do not proxy promises as objects
* spec: add complete spec coverage for contextBridge
* spec: add tests for null/undefined and the anti-overwrite logic
* chore: fix linting
* spec: add complex nested back-and-forth function calling
* fix: expose contextBridge in sandboxed renderers
* refactor: improve security of default_app using the new contextBridge module
* s/bindAPIInMainWorld/exposeInMainWorld
* chore: sorry for this commit, its a big one, I fixed like everything and refactored a lot
* chore: remove PassedValueCache as it is unused now
Values transferred from context A to context B are now cachde in the RenderFramePersistenceStore
* chore: move to anonymous namespace
* refactor: remove PassValueToOtherContextWithCache
* chore: remove commented unused code blocks
* chore: remove .only
* chore: remote commented code
* refactor: extract RenderFramePersistenceStore
* spec: ensure it works with numbered keys
* fix: handle number keys correctly
* fix: sort out the linter
* spec: update default_app asar spec for removed file
* refactor: change signatures to return v8 objects directly rather than the mate dictionary handle
* refactor: use the v8 serializer to support cloneable buffers and other object types
* chore: fix linting
* fix: handle hash collisions with a linked list in the map
* fix: enforce a recursion limit on the context bridge
* chore: fix linting
* chore: remove TODO
* chore: adapt for PR feedback
* chore: remove .only
* chore: clean up docs and clean up the proxy map when objects are released
* chore: ensure we cache object values that are cloned through the V8 serializer
* docs: mark contextBridge as experimental (#20638)
* docs: mark contextBridge as experimental
This commit didn't make it to the original PR, quick addition here
* Update context-bridge.md
* chore: touch up the differences between master and 6-0-x
* chore: add v8 serializer converter, cherry picked from 2fad53e66b
* chore: support converting OnceCallback to V8 (#17941)
* chore: fixup tests
* chore: fix linting
* chore: add patch for mojo message constructor
88 lines
2.7 KiB
C++
88 lines
2.7 KiB
C++
// Copyright (c) 2019 GitHub, Inc. All rights reserved.
|
|
// Use of this source code is governed by the MIT license that can be
|
|
// found in the LICENSE file.
|
|
|
|
#ifndef ATOM_COMMON_NATIVE_MATE_CONVERTERS_ONCE_CALLBACK_H_
|
|
#define ATOM_COMMON_NATIVE_MATE_CONVERTERS_ONCE_CALLBACK_H_
|
|
|
|
#include <utility>
|
|
|
|
#include "atom/common/native_mate_converters/callback.h"
|
|
|
|
namespace mate {
|
|
|
|
namespace internal {
|
|
|
|
// Manages the OnceCallback with ref-couting.
|
|
template <typename Sig>
|
|
class RefCountedOnceCallback
|
|
: public base::RefCounted<RefCountedOnceCallback<Sig>> {
|
|
public:
|
|
explicit RefCountedOnceCallback(base::OnceCallback<Sig> callback)
|
|
: callback_(std::move(callback)) {}
|
|
|
|
base::OnceCallback<Sig> GetCallback() { return std::move(callback_); }
|
|
|
|
private:
|
|
friend class base::RefCounted<RefCountedOnceCallback<Sig>>;
|
|
~RefCountedOnceCallback() = default;
|
|
|
|
base::OnceCallback<Sig> callback_;
|
|
};
|
|
|
|
// Invokes the OnceCallback.
|
|
template <typename Sig>
|
|
struct InvokeOnceCallback {};
|
|
|
|
template <typename... ArgTypes>
|
|
struct InvokeOnceCallback<void(ArgTypes...)> {
|
|
static void Go(
|
|
scoped_refptr<RefCountedOnceCallback<void(ArgTypes...)>> holder,
|
|
ArgTypes... args) {
|
|
base::OnceCallback<void(ArgTypes...)> callback = holder->GetCallback();
|
|
DCHECK(!callback.is_null());
|
|
std::move(callback).Run(std::move(args)...);
|
|
}
|
|
};
|
|
|
|
template <typename ReturnType, typename... ArgTypes>
|
|
struct InvokeOnceCallback<ReturnType(ArgTypes...)> {
|
|
static ReturnType Go(
|
|
scoped_refptr<RefCountedOnceCallback<ReturnType(ArgTypes...)>> holder,
|
|
ArgTypes... args) {
|
|
base::OnceCallback<void(ArgTypes...)> callback = holder->GetCallback();
|
|
DCHECK(!callback.is_null());
|
|
return std::move(callback).Run(std::move(args)...);
|
|
}
|
|
};
|
|
|
|
} // namespace internal
|
|
|
|
template <typename Sig>
|
|
struct Converter<base::OnceCallback<Sig>> {
|
|
static v8::Local<v8::Value> ToV8(v8::Isolate* isolate,
|
|
base::OnceCallback<Sig> val) {
|
|
// Reuse the converter of base::RepeatingCallback by storing the callback
|
|
// with a RefCounted.
|
|
auto holder = base::MakeRefCounted<internal::RefCountedOnceCallback<Sig>>(
|
|
std::move(val));
|
|
return Converter<base::RepeatingCallback<Sig>>::ToV8(
|
|
isolate,
|
|
base::BindRepeating(&internal::InvokeOnceCallback<Sig>::Go, holder));
|
|
}
|
|
|
|
static bool FromV8(v8::Isolate* isolate,
|
|
v8::Local<v8::Value> val,
|
|
base::OnceCallback<Sig>* out) {
|
|
if (!val->IsFunction())
|
|
return false;
|
|
*out = base::BindOnce(&internal::V8FunctionInvoker<Sig>::Go, isolate,
|
|
internal::SafeV8Function(isolate, val));
|
|
return true;
|
|
}
|
|
};
|
|
|
|
} // namespace mate
|
|
|
|
#endif // ATOM_COMMON_NATIVE_MATE_CONVERTERS_ONCE_CALLBACK_H_
|