build: remove gyp build files (#14097)

* build: remove gyp build files

* docs: update build instructions

* build: temporary restore electron.gyp

* build: do not update Electron version in the electron.gyp

* chore: remove unused submodules

* ci: remove obsolete CI scripts and configs

* chore: remove obsolete scripts

* chore: remove obsolete functions from lib/util.py

* ci: send Slack notification for nightly build results
This commit is contained in:
Jeremy Apthorp 2018-09-08 18:15:32 -07:00 committed by Cheng Zhao
parent 98eee52fac
commit 72526927d9
56 changed files with 919 additions and 6043 deletions

View file

@ -58,40 +58,6 @@ $ sudo dnf install clang dbus-devel gtk3-devel libnotify-devel \
Other distributions may offer similar packages for installation via package
managers such as pacman. Or one can compile from source code.
## Getting the Code
```sh
$ git clone https://github.com/electron/electron
```
## Bootstrapping
The bootstrap script will download all necessary build dependencies and create
the build project files. You must have Python 2.7.x for the script to succeed.
Downloading certain files can take a long time. Notice that we are using
`ninja` to build Electron so there is no `Makefile` generated.
To bootstrap for a static, non-developer build, run:
```sh
$ cd electron
$ npm run bootstrap
```
Or to bootstrap for a development session that builds faster by not statically linking:
```sh
$ cd electron
$ npm run bootstrap:dev
```
If you are using editor supports [JSON compilation database](http://clang.llvm.org/docs/JSONCompilationDatabase.html) based
language server, you can generate it:
```sh
$ ./script/build.py --compdb
```
### Cross compilation
If you want to build for an `arm` target you should also install the following
@ -110,60 +76,15 @@ $ sudo apt-get install libc6-dev-arm64-cross linux-libc-dev-arm64-cross \
```
And to cross-compile for `arm` or `ia32` targets, you should pass the
`--target_arch` parameter to the `bootstrap.py` script:
`target_cpu` parameter to `gn gen`:
```sh
$ ./script/bootstrap.py -v --target_arch=arm
$ gn gen out/Debug --args='import(...) target_cpu="arm"'
```
## Building
If you would like to build both `Release` and `Debug` targets:
```sh
$ npm run build
```
This script will cause a very large Electron executable to be placed in
the directory `out/R`. The file size is in excess of 1.3 gigabytes. This
happens because the Release target binary contains debugging symbols.
To reduce the file size, run the `create-dist.py` script:
```sh
$ ./script/create-dist.py
```
This will put a working distribution with much smaller file sizes in
the `dist` directory. After running the `create-dist.py` script, you
may want to remove the 1.3+ gigabyte binary which is still in `out/R`.
You can also build either the `Debug` or `Release` target on its own:
```sh
$ npm run build:dev
```
```sh
$ npm run build:release
```
After building is done, you can find the `electron` debug binary under `out/D`.
## Cleaning
To clean the build files:
```sh
$ npm run clean
```
To clean only `out` and `dist` directories:
```sh
$ npm run clean-build
```
**Note:** Both clean commands require running `bootstrap` again before building.
See [Build Instructions: GN](build-instructions-gn.md)
## Troubleshooting
@ -176,87 +97,26 @@ architecture, symlink to appropriate `libncurses`:
$ sudo ln -s /usr/lib/libncurses.so.5 /usr/lib/libtinfo.so.5
```
## Tests
See [Build System Overview: Tests](build-system-overview.md#tests)
## Advanced topics
The default building configuration is targeted for major desktop Linux
distributions. To build for a specific distribution or device, the following
information may help you.
### Building `libchromiumcontent` locally
To avoid using the prebuilt binaries of `libchromiumcontent`, you can build `libchromiumcontent` locally. To do so, follow these steps:
1. Install [depot_tools](https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md#Install)
2. Install [additional build dependencies](https://chromium.googlesource.com/chromium/src/+/master/docs/linux_build_instructions.md#Install-additional-build-dependencies)
3. Fetch the git submodules:
```sh
$ git submodule update --init --recursive
```
4. Pass the `--build_release_libcc` switch to `bootstrap.py` script:
```sh
$ ./script/bootstrap.py -v --build_release_libcc
```
Note that by default the `shared_library` configuration is not built, so you can
only build `Release` version of Electron if you use this mode:
```sh
$ ./script/build.py -c R
```
### Using system `clang` instead of downloaded `clang` binaries
By default Electron is built with prebuilt
[`clang`](https://clang.llvm.org/get_started.html) binaries provided by the
Chromium project. If for some reason you want to build with the `clang`
installed in your system, you can call `bootstrap.py` with `--clang_dir=<path>`
switch. By passing it the build script will assume the `clang` binaries reside
in `<path>/bin/`.
installed in your system, you can specify the `clang_base_path` argument in the
GN args.
For example if you installed `clang` under `/user/local/bin/clang`:
For example if you installed `clang` under `/usr/local/bin/clang`:
```sh
$ ./script/bootstrap.py -v --build_release_libcc --clang_dir /usr/local
$ ./script/build.py -c R
$ gn gen out/Debug --args='import("//electron/build/args/debug.gn") clang_base_path = "/usr/local/bin"'
```
### Using compilers other than `clang`
To build Electron with compilers like `g++`, you first need to disable `clang`
with `--disable_clang` switch first, and then set `CC` and `CXX` environment
variables to the ones you want.
For example building with GCC toolchain:
```sh
$ env CC=gcc CXX=g++ ./script/bootstrap.py -v --build_release_libcc --disable_clang
$ ./script/build.py -c R
```
### Environment variables
Apart from `CC` and `CXX`, you can also set the following environment variables to
customise the build configuration:
* `CPPFLAGS`
* `CPPFLAGS_host`
* `CFLAGS`
* `CFLAGS_host`
* `CXXFLAGS`
* `CXXFLAGS_host`
* `AR`
* `AR_host`
* `CC`
* `CC_host`
* `CXX`
* `CXX_host`
* `LDFLAGS`
The environment variables have to be set when executing the `bootstrap.py`
script, it won't work in the `build.py` script.
Building Electron with compilers other than `clang` is not supported.