1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "extensions/renderer/bindings/api_bindings_system.h"
#include <utility>
#include "base/containers/contains.h"
#include "base/functional/bind.h"
#include "base/values.h"
#include "extensions/common/mojom/event_dispatcher.mojom.h"
#include "extensions/renderer/bindings/api_binding_hooks.h"
#include "extensions/renderer/bindings/api_binding_hooks_delegate.h"
#include "extensions/renderer/bindings/api_binding_util.h"
#include "extensions/renderer/bindings/api_response_validator.h"
#include "extensions/renderer/bindings/interaction_provider.h"
namespace extensions {
APIBindingsSystem::APIBindingsSystem(
GetAPISchemaMethod get_api_schema,
BindingAccessChecker::APIAvailabilityCallback api_available,
BindingAccessChecker::PromiseAvailabilityCallback promises_available,
APIRequestHandler::SendRequestMethod send_request,
std::unique_ptr<InteractionProvider> interaction_provider,
APIEventListeners::ListenersUpdated event_listeners_changed,
APIEventHandler::ContextOwnerIdGetter context_owner_getter,
APIBinding::OnSilentRequest on_silent_request,
binding::AddConsoleError add_console_error,
APILastError last_error)
: type_reference_map_(
base::BindRepeating(&APIBindingsSystem::InitializeType,
base::Unretained(this))),
exception_handler_(std::move(add_console_error)),
interaction_provider_(std::move(interaction_provider)),
request_handler_(std::move(send_request),
std::move(last_error),
&exception_handler_,
interaction_provider_.get()),
event_handler_(std::move(event_listeners_changed),
std::move(context_owner_getter),
&exception_handler_),
access_checker_(std::move(api_available), std::move(promises_available)),
get_api_schema_(std::move(get_api_schema)),
on_silent_request_(std::move(on_silent_request)) {
if (binding::IsResponseValidationEnabled()) {
request_handler_.SetResponseValidator(
std::make_unique<APIResponseValidator>(&type_reference_map_));
event_handler_.SetResponseValidator(
std::make_unique<APIResponseValidator>(&type_reference_map_));
}
}
APIBindingsSystem::~APIBindingsSystem() = default;
v8::Local<v8::Object> APIBindingsSystem::CreateAPIInstance(
const std::string& api_name,
v8::Local<v8::Context> context,
APIBindingHooks** hooks_out) {
std::unique_ptr<APIBinding>& binding = api_bindings_[api_name];
if (!binding)
binding = CreateNewAPIBinding(api_name);
if (hooks_out)
*hooks_out = binding->hooks();
return binding->CreateInstance(context);
}
std::unique_ptr<APIBinding> APIBindingsSystem::CreateNewAPIBinding(
const std::string& api_name) {
const base::Value::Dict& api_schema = get_api_schema_.Run(api_name);
const base::Value::List* function_definitions =
api_schema.FindList("functions");
const base::Value::List* type_definitions = api_schema.FindList("types");
const base::Value::List* event_definitions = api_schema.FindList("events");
const base::Value::Dict* property_definitions =
api_schema.FindDict("properties");
// Find the hooks for the API. If none exist, an empty set will be created so
// we can use JS custom bindings.
// TODO(devlin): Once all legacy custom bindings are converted, we don't have
// to unconditionally pass in binding hooks.
std::unique_ptr<APIBindingHooks> hooks;
auto iter = binding_hooks_.find(api_name);
if (iter != binding_hooks_.end()) {
hooks = std::move(iter->second);
binding_hooks_.erase(iter);
} else {
hooks = std::make_unique<APIBindingHooks>(api_name, &request_handler_);
}
return std::make_unique<APIBinding>(
api_name, function_definitions, type_definitions, event_definitions,
property_definitions,
base::BindRepeating(&APIBindingsSystem::CreateCustomType,
base::Unretained(this)),
on_silent_request_, std::move(hooks), &type_reference_map_,
&request_handler_, &event_handler_, &access_checker_);
}
void APIBindingsSystem::InitializeType(const std::string& type_name) {
// In order to initialize the type, we just initialize the full binding. This
// seems like a lot of work, but in practice, trying to extract out only the
// types from the schema, and then update the reference map based on that, is
// close enough to the same cost. Additionally, this happens lazily on API
// use, and relatively few APIs specify types from another API. Finally, this
// will also go away if/when we generate all these specifications.
std::string::size_type dot = type_name.rfind('.');
// The type name should be fully qualified (include the API name).
DCHECK_NE(std::string::npos, dot) << type_name;
DCHECK_LT(dot, type_name.size() - 1);
std::string api_name = type_name.substr(0, dot);
// If we've already instantiated the binding, the type should have been in
// there.
DCHECK(!base::Contains(api_bindings_, api_name)) << api_name;
api_bindings_[api_name] = CreateNewAPIBinding(api_name);
}
void APIBindingsSystem::CompleteRequest(
int request_id,
const base::Value::List& response,
const std::string& error,
mojom::ExtraResponseDataPtr extra_data) {
request_handler_.CompleteRequest(request_id, response, error,
std::move(extra_data));
}
void APIBindingsSystem::FireEventInContext(
const std::string& event_name,
v8::Local<v8::Context> context,
const base::Value::List& response,
mojom::EventFilteringInfoPtr filter) {
event_handler_.FireEventInContext(event_name, context, response,
std::move(filter));
}
void APIBindingsSystem::RegisterHooksDelegate(
const std::string& api_name,
std::unique_ptr<APIBindingHooksDelegate> delegate) {
DCHECK(api_bindings_.empty())
<< "Hook registration must happen before creating any binding instances.";
std::unique_ptr<APIBindingHooks>& hooks = binding_hooks_[api_name];
if (!hooks) {
hooks = std::make_unique<APIBindingHooks>(api_name, &request_handler_);
}
hooks->SetDelegate(std::move(delegate));
}
void APIBindingsSystem::RegisterCustomType(const std::string& type_name,
CustomTypeHandler function) {
DCHECK(!base::Contains(custom_types_, type_name))
<< "Custom type already registered: " << type_name;
custom_types_[type_name] = std::move(function);
}
void APIBindingsSystem::WillReleaseContext(v8::Local<v8::Context> context) {
binding::InvalidateContext(context);
request_handler_.InvalidateContext(context);
event_handler_.InvalidateContext(context);
}
v8::Local<v8::Object> APIBindingsSystem::CreateCustomType(
v8::Isolate* isolate,
const std::string& type_name,
const std::string& property_name,
const base::Value::List* property_values) {
auto iter = custom_types_.find(type_name);
CHECK(iter != custom_types_.end()) << "Custom type not found: " << type_name;
return iter->second.Run(isolate, property_name, property_values,
&request_handler_, &event_handler_,
&type_reference_map_, &access_checker_);
}
} // namespace extensions
|
