module_system.cc | Explore in Territory

// Copyright 2014 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/module_system.h"

#include "base/command_line.h"
#include "base/functional/bind.h"
#include "base/logging.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/trace_event/trace_event.h"
#include "content/public/renderer/render_frame.h"
#include "extensions/common/extension.h"
#include "extensions/common/mojom/context_type.mojom.h"
#include "extensions/renderer/console.h"
#include "extensions/renderer/safe_builtins.h"
#include "extensions/renderer/script_context.h"
#include "extensions/renderer/script_context_set.h"
#include "extensions/renderer/source_map.h"
#include "extensions/renderer/v8_helpers.h"
#include "gin/converter.h"
#include "third_party/blink/public/web/web_frame.h"
#include "third_party/blink/public/web/web_v8_features.h"
#include "v8/include/v8-exception.h"
#include "v8/include/v8-external.h"
#include "v8/include/v8-function-callback.h"
#include "v8/include/v8-function.h"
#include "v8/include/v8-isolate.h"
#include "v8/include/v8-message.h"
#include "v8/include/v8-object.h"
#include "v8/include/v8-primitive.h"
#include "v8/include/v8-script.h"

namespace extensions {

GetPrivateProperty;
SetPrivateProperty;
ToV8String;
ToV8StringUnsafe;

namespace {

const char kModuleSystem[] = …;
const char kModuleName[] = …;
const char kModuleField[] = …;
const char kModulesField[] = …;

// Determines if certain fatal extensions errors should be suppressed
// (i.e., only logged) or allowed (i.e., logged before crashing).
bool ShouldSuppressFatalErrors() { … }

// Logs an error for the calling context in preparation for potentially
// crashing the renderer, with some added metadata about the context:
//  - Its type (privileged, unprivileged, etc).
//  - Whether it's valid.
//  - The extension ID, if one exists.
// Crashing won't happen in stable/beta releases, but is encouraged to happen
// in the less stable released to catch errors early.
void Fatal(ScriptContext* context, const std::string& message) { … }

void Warn(v8::Isolate* isolate, const std::string& message) { … }

// Default exception handler which logs the exception.
class DefaultExceptionHandler : public ModuleSystem::ExceptionHandler { … };

// Sets a property on the "exports" object for bindings. Called by JS with
// exports.$set(<key>, <value>).
void SetExportsProperty(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }

bool ContextNeedsMojoBindings(ScriptContext* context) { … }

}  // namespace

std::string ModuleSystem::ExceptionHandler::CreateExceptionString(
    const v8::TryCatch& try_catch) { … }

ModuleSystem::ModuleSystem(ScriptContext* context, const SourceMap* source_map)
    : … { … }

ModuleSystem::~ModuleSystem() { … }

void ModuleSystem::AddRoutes() { … }

void ModuleSystem::Invalidate() { … }

ModuleSystem::NativesEnabledScope::NativesEnabledScope(
    ModuleSystem* module_system)
    : … { … }

ModuleSystem::NativesEnabledScope::~NativesEnabledScope() { … }

void ModuleSystem::HandleException(const v8::TryCatch& try_catch) { … }

v8::MaybeLocal<v8::Object> ModuleSystem::Require(
    const std::string& module_name) { … }

void ModuleSystem::RequireForJs(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }

v8::Local<v8::Value> ModuleSystem::RequireForJsInner(
    v8::Local<v8::String> module_name,
    bool create) { … }

void ModuleSystem::CallModuleMethodSafe(const std::string& module_name,
                                        const std::string& method_name) { … }

void ModuleSystem::CallModuleMethodSafe(const std::string& module_name,
                                        const std::string& method_name,
                                        v8::LocalVector<v8::Value>* args) { … }

void ModuleSystem::CallModuleMethodSafe(const std::string& module_name,
                                        const std::string& method_name,
                                        int argc,
                                        v8::Local<v8::Value> argv[]) { … }

void ModuleSystem::CallModuleMethodSafe(
    const std::string& module_name,
    const std::string& method_name,
    int argc,
    v8::Local<v8::Value> argv[],
    blink::WebScriptExecutionCallback callback) { … }

void ModuleSystem::RegisterNativeHandler(
    const std::string& name,
    std::unique_ptr<NativeHandler> native_handler) { … }

void ModuleSystem::OverrideNativeHandlerForTest(const std::string& name) { … }

// static
void ModuleSystem::LazyFieldGetter(
    v8::Local<v8::Name> property,
    const v8::PropertyCallbackInfo<v8::Value>& info) { … }

void ModuleSystem::SetLazyField(v8::Local<v8::Object> object,
                                const std::string& field,
                                const std::string& module_name,
                                const std::string& module_field) { … }

void ModuleSystem::OnNativeBindingCreated(
    const std::string& api_name,
    v8::Local<v8::Value> api_bridge_value) { … }

void ModuleSystem::SetGetInternalAPIHook(
    v8::Local<v8::FunctionTemplate> get_internal_api) { … }

void ModuleSystem::SetJSBindingUtilGetter(const JSBindingUtilGetter& getter) { … }

v8::Local<v8::Value> ModuleSystem::RunString(v8::Local<v8::String> code,
                                             v8::Local<v8::String> name) { … }

void ModuleSystem::RequireNative(
    const v8::FunctionCallbackInfo<v8::Value>& args) { … }

v8::MaybeLocal<v8::Object> ModuleSystem::RequireNativeFromString(
    const std::string& native_name) { … }

void ModuleSystem::LoadScript(const v8::FunctionCallbackInfo<v8::Value>& args) { … }

v8::Local<v8::String> ModuleSystem::WrapSource(v8::Local<v8::String> source) { … }

void ModuleSystem::Private(const v8::FunctionCallbackInfo<v8::Value>& args) { … }

v8::Local<v8::Value> ModuleSystem::LoadModule(const std::string& module_name) { … }

v8::Local<v8::Value> ModuleSystem::LoadModuleWithNativeAPIBridge(
    const std::string& module_name,
    v8::Local<v8::Value> api_bridge) { … }

void ModuleSystem::ClobberExistingNativeHandler(const std::string& name) { … }

v8::Local<v8::Function> ModuleSystem::GetModuleFunction(
    const std::string& module_name,
    const std::string& method_name) { … }

}  // namespace extensions
chromium/extensions/renderer/module_system.cc
