Revert^2 "Add ability to declare licenses in soong." (37af0460) · Commits · e / os / android_build_soong

android/Android.bp

+6 −0

Original line number	Diff line number	Diff line
		@@ -30,6 +30,9 @@ bootstrap_go_package {
		"filegroup.go",
		"hooks.go",
		"image.go",
		"license.go",
		"license_kind.go",
		"licenses.go",
		"makefile_goal.go",
		"makevars.go",
		"metrics.go",
		@@ -77,6 +80,9 @@ bootstrap_go_package {
		"depset_test.go",
		"deptag_test.go",
		"expand_test.go",
		"license_kind_test.go",
		"license_test.go",
		"licenses_test.go",
		"module_test.go",
		"mutator_test.go",
		"namespace_test.go",

android/defaults.go

+3 −0

Original line number	Diff line number	Diff line
		@@ -204,6 +204,9 @@ func InitDefaultsModule(module DefaultsModule) {
		// its checking phase and parsing phase so add it to the list as a normal property.
		AddVisibilityProperty(module, "visibility", &commonProperties.Visibility)

		// The applicable licenses property for defaults is 'licenses'.
		setPrimaryLicensesProperty(module, "licenses", &commonProperties.Licenses)

		base.module = module
		}

android/license.go

0 → 100644

+82 −0

Original line number	Diff line number	Diff line
		// Copyright 2020 Google Inc. All rights reserved.
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.

		package android

		import (
		"github.com/google/blueprint"
		)

		type licenseKindDependencyTag struct {
		blueprint.BaseDependencyTag
		}

		var (
		licenseKindTag = licenseKindDependencyTag{}
		)

		func init() {
		RegisterLicenseBuildComponents(InitRegistrationContext)
		}

		// Register the license module type.
		func RegisterLicenseBuildComponents(ctx RegistrationContext) {
		ctx.RegisterModuleType("license", LicenseFactory)
		}

		type licenseProperties struct {
		// Specifies the kinds of license that apply.
		License_kinds []string
		// Specifies a short copyright notice to use for the license.
		Copyright_notice *string
		// Specifies the path or label for the text of the license.
		License_text []string `android:"path"`
		// Specifies the package name to which the license applies.
		Package_name *string
		// Specifies where this license can be used
		Visibility []string
		}

		type licenseModule struct {
		ModuleBase
		DefaultableModuleBase

		properties licenseProperties
		}

		func (m *licenseModule) DepsMutator(ctx BottomUpMutatorContext) {
		ctx.AddVariationDependencies(nil, licenseKindTag, m.properties.License_kinds...)
		}

		func (m *licenseModule) GenerateAndroidBuildActions(ctx ModuleContext) {
		// Nothing to do.
		}

		func LicenseFactory() Module {
		module := &licenseModule{}

		base := module.base()
		module.AddProperties(&base.nameProperties, &module.properties)

		base.generalProperties = module.GetProperties()
		base.customizableProperties = module.GetProperties()

		// The visibility property needs to be checked and parsed by the visibility module.
		setPrimaryVisibilityProperty(module, "visibility", &module.properties.Visibility)

		initAndroidModuleBase(module)
		InitDefaultableModule(module)

		return module
		}

android/license_kind.go

0 → 100644

+66 −0

Original line number	Diff line number	Diff line
		// Copyright 2020 Google Inc. All rights reserved.
		//
		// Licensed under the Apache License, Version 2.0 (the "License");
		// you may not use this file except in compliance with the License.
		// You may obtain a copy of the License at
		//
		// http://www.apache.org/licenses/LICENSE-2.0
		//
		// Unless required by applicable law or agreed to in writing, software
		// distributed under the License is distributed on an "AS IS" BASIS,
		// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		// See the License for the specific language governing permissions and
		// limitations under the License.

		package android

		func init() {
		RegisterLicenseKindBuildComponents(InitRegistrationContext)
		}

		// Register the license_kind module type.
		func RegisterLicenseKindBuildComponents(ctx RegistrationContext) {
		ctx.RegisterModuleType("license_kind", LicenseKindFactory)
		}

		type licenseKindProperties struct {
		// Specifies the conditions for all licenses of the kind.
		Conditions []string
		// Specifies the url to the canonical license definition.
		Url string
		// Specifies where this license can be used
		Visibility []string
		}

		type licenseKindModule struct {
		ModuleBase
		DefaultableModuleBase

		properties licenseKindProperties
		}

		func (m *licenseKindModule) DepsMutator(ctx BottomUpMutatorContext) {
		// Nothing to do.
		}

		func (m *licenseKindModule) GenerateAndroidBuildActions(ModuleContext) {
		// Nothing to do.
		}

		func LicenseKindFactory() Module {
		module := &licenseKindModule{}

		base := module.base()
		module.AddProperties(&base.nameProperties, &module.properties)

		base.generalProperties = module.GetProperties()
		base.customizableProperties = module.GetProperties()

		// The visibility property needs to be checked and parsed by the visibility module.
		setPrimaryVisibilityProperty(module, "visibility", &module.properties.Visibility)

		initAndroidModuleBase(module)
		InitDefaultableModule(module)

		return module
		}

android/license_kind_test.go

0 → 100644

+174 −0

Original line number	Diff line number	Diff line
		package android

		import (
		"testing"

		"github.com/google/blueprint"
		)

		var licenseKindTests = []struct {
		name string
		fs map[string][]byte
		expectedErrors []string
		}{
		{
		name: "license_kind must not accept licenses property",
		fs: map[string][]byte{
		"top/Blueprints": []byte(`
		license_kind {
		name: "top_license",
		licenses: ["other_license"],
		}`),
		},
		expectedErrors: []string{
		`top/Blueprints:4:14: unrecognized property "licenses"`,
		},
		},
		{
		name: "bad license_kind",
		fs: map[string][]byte{
		"top/Blueprints": []byte(`
		license_kind {
		name: "top_notice",
		conditions: ["notice"],
		}`),
		"other/Blueprints": []byte(`
		mock_license {
		name: "other_notice",
		license_kinds: ["notice"],
		}`),
		},
		expectedErrors: []string{
		`other/Blueprints:2:5: "other_notice" depends on undefined module "notice"`,
		},
		},
		{
		name: "good license kind",
		fs: map[string][]byte{
		"top/Blueprints": []byte(`
		license_kind {
		name: "top_by_exception_only",
		conditions: ["by_exception_only"],
		}

		mock_license {
		name: "top_proprietary",
		license_kinds: ["top_by_exception_only"],
		}`),
		"other/Blueprints": []byte(`
		mock_license {
		name: "other_proprietary",
		license_kinds: ["top_proprietary"],
		}`),
		},
		},
		{
		name: "multiple license kinds",
		fs: map[string][]byte{
		"top/Blueprints": []byte(`
		license_kind {
		name: "top_notice",
		conditions: ["notice"],
		}

		license_kind {
		name: "top_by_exception_only",
		conditions: ["by_exception_only"],
		}

		mock_license {
		name: "top_allowed_as_notice",
		license_kinds: ["top_notice"],
		}

		mock_license {
		name: "top_proprietary",
		license_kinds: ["top_by_exception_only"],
		}`),
		"other/Blueprints": []byte(`
		mock_license {
		name: "other_rule",
		license_kinds: ["top_by_exception_only"],
		}`),
		},
		},
		}

		func TestLicenseKind(t *testing.T) {
		for _, test := range licenseKindTests {
		t.Run(test.name, func(t *testing.T) {
		_, errs := testLicenseKind(test.fs)

		expectedErrors := test.expectedErrors
		if expectedErrors == nil {
		FailIfErrored(t, errs)
		} else {
		for _, expectedError := range expectedErrors {
		FailIfNoMatchingErrors(t, expectedError, errs)
		}
		if len(errs) > len(expectedErrors) {
		t.Errorf("additional errors found, expected %d, found %d", len(expectedErrors), len(errs))
		for i, expectedError := range expectedErrors {
		t.Errorf("expectedErrors[%d] = %s", i, expectedError)
		}
		for i, err := range errs {
		t.Errorf("errs[%d] = %s", i, err)
		}
		}
		}
		})
		}
		}

		func testLicenseKind(fs map[string][]byte) (*TestContext, []error) {

		// Create a new config per test as license_kind information is stored in the config.
		config := TestArchConfig(buildDir, nil, "", fs)

		ctx := NewTestArchContext(config)
		RegisterLicenseKindBuildComponents(ctx)
		ctx.RegisterModuleType("mock_license", newMockLicenseModule)
		ctx.Register()

		_, errs := ctx.ParseBlueprintsFiles(".")
		if len(errs) > 0 {
		return ctx, errs
		}

		_, errs = ctx.PrepareBuildActions(config)
		return ctx, errs
		}

		type mockLicenseProperties struct {
		License_kinds []string
		}

		type mockLicenseModule struct {
		ModuleBase
		DefaultableModuleBase

		properties mockLicenseProperties
		}

		func newMockLicenseModule() Module {
		m := &mockLicenseModule{}
		m.AddProperties(&m.properties)
		InitAndroidArchModule(m, HostAndDeviceSupported, MultilibCommon)
		InitDefaultableModule(m)
		return m
		}

		type licensekindTag struct {
		blueprint.BaseDependencyTag
		}

		func (j *mockLicenseModule) DepsMutator(ctx BottomUpMutatorContext) {
		m, ok := ctx.Module().(Module)
		if !ok {
		return
		}
		ctx.AddDependency(m, licensekindTag{}, j.properties.License_kinds...)
		}

		func (p *mockLicenseModule) GenerateAndroidBuildActions(ModuleContext) {
		}