`auto_generate_cdp` comes under `GPL-3.0` whereas `rust-headless-chrome` that uses this crate is licensed under `MIT`

[Subhra264]

I have a deny.toml with copyleft = "deny" that simply means I can't use any dependency that is licensed under a copyleft license. So, even if I want to use headless_chrome since it is MIT licensed, the cargo-deny license checks fail, as it uses GPL licensed auto_generate_cdp for build.

As far as I know (not an expert on this, so correct me if I am wrong), GPL requires the dependent crate to also be licensed under GPL (same license condition of GPL). How is it then possible for headless_chrome to have a different license other than GPL? Is there a possibility of changing the license of this crate from GPL to something like MIT or any other non-copyleft license?

[yuhr]

@Subhra264 I noticed that rust-headless-chrome is using auto_generate_cdp as a build dependency and not embedding auto_generate_cdp itself into their code, thus the license is irrelevant (see the FAQ of GPL). Maybe cargo-deny is overdefensive here and you have to wait for EmbarkStudios/cargo-deny#563 to be implemented (or use exceptions?).

[yuhr]

Hmm, looking into the code, it seems many portions of GPL-licensed code are outputted into the generated code e.g.:

auto_generate_cdp/src/lib.rs

Lines 41 to 111 in 889a2f1

	let modv = quote! {
	#[allow(unused)]
	#[allow(non_camel_case_types)]
	#[allow(non_snake_case)]
	pub mod cdp {
	pub mod types {
	use serde::{Deserialize, Serialize};
	use std::fmt::Debug;
	pub type JsFloat = f64;
	pub type JsUInt = u32;
	pub type WindowId = JsUInt;
	pub type CallId = JsUInt;
	#[derive(Serialize, Debug)]
	pub struct MethodCall<T>
	where
	T: Debug,
	{
	#[serde(rename = "method")]
	method_name: &'static str,
	pub id: CallId,
	params: T,
	}
	impl<T> MethodCall<T>
	where
	T: Debug,
	{
	pub fn get_params(&self) -> &T {
	&self.params
	}
	}
	pub trait Method: Debug {
	const NAME: &'static str;
	type ReturnObject: serde::de::DeserializeOwned + std::fmt::Debug;
	fn to_method_call(self, call_id: CallId) -> MethodCall<Self>
	where
	Self: std::marker::Sized,
	{
	MethodCall {
	id: call_id,
	params: self,
	method_name: Self::NAME,
	}
	}
	}
	#[derive(Deserialize, Debug, Clone, PartialEq)]
	#[serde(tag = "method")]
	#[allow(clippy::large_enum_variant)]
	pub enum Event {
	#(#browser_events)*
	#(#js_events)*
	}
	}
	#(#js_mods)*
	#(#browser_mods)*
	}
	};

This way the generated code should be considered as a derived work unfortunately.

[yuhr]

@mdrokz Would there be any chance to switch the license to more permissive one? Licensing is the only blocker from adoption of not only this useful generator but also crates depending on this. Preferable alternative would be MPL-2.0 which enforces file-by-file copyleft but doesn't pollute the entire descendant project.