Chromium docs

This directory contains chromium project documentation in Gitiles-flavored Markdown. It is automatically rendered by Gitiles.

If you add new documents, please also add a link to them in the Document Index below.

[TOC]

Markdown documents must follow the style guide.

You can preview your local changes using md_browser:

# in chromium checkout
./tools/md_browser/md_browser.py

To review someone else's changes, apply them locally first:

# in chromium checkout
git cl patch <CL number or URL>
./tools/md_browser/md_browser.py

• Linux Build Instructions - Linux
• Mac Build Instructions - MacOS
• Windows Build Instructions - Windows
• Android Build Instructions - Android target (on a Linux host)
• Cast Build Instructions - Cast target (on a Linux host)
• Cast for Android Build Instructions - Cast for Android (on a Linux host)
• iOS Build Instructions - iOS target (on a MacOS host)
• Linux Chromium ARM Recipes - Recipes for building Chromium for ARM on Linux.
• Common Build Tasks - Recipes for slightly more advanced build tasks
• Chrome Component Build - Faster builds using more libraries
• Using the BuildRunner - Scripts that extract build stops from builders and runs them locally on a slave
• Cr User Manual - Manual for cr, a tool that tries to hide some of the tools used for working on Chromium behind an abstraction layer

• See design/README.md

• Android Studio - Android Studio for Android builds
• Eclipse for Android - Eclipse for Android
• Eclipse for Linux - Eclipse for other platforms (This guide was written for Linux, but is probably usable on Windows/MacOS as well)
• Qt Creator - Using Qt Creator as an IDE or GUI debugger
• Setting up Visual Studio Code - Visual Studio Code
• EMACS Notes - EMACS commands/styles/tool integrations
• Atom - Atom multi-platform code editor

• Git Cookbook - A collection of git recipes for common tasks
• Git Tips - More git tips

• Clang Compiler - General information on the clang compiler, used by default on Mac and Linux
• Clang Tool Refactoring - Leveraging clang tools to perform refactorings that are AST-aware
• The Clang Static Analyzer - How to enable static analysis at build time
• Writing Clang Plugins - Don't write a clang plugin, but if you do, read this
• Updating Clang - Updating the version of Clang used to build
• Using clang-format on Chromium C++ Code - Various ways to invoke clang-format on C++ code
• Clang Tidy - Support for the clang-tidy tool in Chromium
• Updating Clang Format Binaries - How up update the clang-format binaries that come with a checkout of Chromium

• Code Reviews - Code review requirements and guidelines
• Closure Compilation - The Closure JavaScript compiler
• Callback<> and Bind() - All about Callbacks, Closures, and Bind().
• Views Platform Styling - How views are styled to fit in different native platforms
• Tab Helpers - Using WebContents/WebContentsObserver to add features to browser tabs.
• Adding third_party Libraries - How to get code into third_party/
• Graphical Debugging Aid for Chromium Views - Visualizing view trees during debugging
• Bitmap Pipeline - How bitmaps are moved from the renderer to the screen.
• base::Optional - How to use base::Optional in C++ code.
• Using the Origin Trials Framework - A framework for conditionally enabling experimental APIs for testing.
• SharedModelTypeProcessor in Unified Sync and Storage - Notes on the central data structure used in Chrome Sync.
• Chrome Sync's Model API - Data models used for syncing information across devices using Chrome Sync.
• Ozone Overview - Ozone is an abstraction layer between the window system and low level input and graphics.
• Optimizing Chrome Web UIs - Notes on making webuis more performant
• ES6 Support in Chromium - Implementation of ECMAScript6 features in Chromium

• Running and Debugging Layout Tests
• Writing Layout Tests - Layout Tests using content_shell
• Layout Test Expectations and Baselines - Setting expected results of layout tests.
• Layout Tests Tips - Best practices for Layout Tests
• Layout Tests with Manual Fallback - Writing tests that simulate manual interventions
• Extending the Layout Test Framework
• Fixing Layout Test Flakiness - Diagnosing and fixing layout test flakiness due to ordering dependencies.
• Running Layout Tests using content_shell - Running layout tests by hand.
• Testing Browser Dialogs - Using TestBrowserDialog
• Web Platform Tests - Shared tests across browser vendors
• Using Breakpad with content_shell - Capture stack traces on layout test crashes without an attached debugger
• Test Descriptions - Unit test targets that can be built, with associated desciptions.
• IPC Fuzzer - Fuzz testing of Chromium IPC interfaces.

• Linux Proxy Config - Network proxy sources on Linux
• Debugging SSL on Linux - Tips on debugging SSL code in Linux
• Linux Cert Managment - Managing X.509 Certificates in Linux
• Tips for Debugging on Linux
• Linux GTK Theme Integration - Having Chrome match the GTK+ theme.
• Gtk vs ViewsGtk - Notes on when to use Gtk vs ViewsGtk
• Browser Plugins on Linux - A collection of links to information on how browser plugins work on Linux
• Linux Crash Dumping - How Breakpad uploads crash reports to Google crash servers.
• Linux Minidump to Core - How to convert a Breakpad-generated minidump files to a core file readable by most debuggersx
• Linux Sandbox IPC - The lower level UPC system used to route requests from the bottom of the call stack up into the browser.
• Linux Dev Build as Default Browser - How to configure a Dev build of Chrome as the default browser in Linux.
• Linux Chromium Packages - Packages of Chromium browser (not Chrome) provided by some Linux distributions.
• seccomp Sandbox Crash Dumping - Notes on crash dumping a process running in a seccomp sandbox.
• Linux Password Storage - Keychain integrations between Chromium and Linux.
• Linux Sublime Development - Using Sublime as an IDE for Chromium development on Linux.
• Building and Debugging GTK - Building Chromium against GTK using lower optimization levels and/or more debugging symbols.
• Debugging GTK - Using the GTK Debug packages and related tools.
• Chroot Notes - Setting up a chroot to work around libfreetype differences in some versions of Linux.
• Linux Sandboxing - The Linux multi-process model to isolate browser components with different privileges.
• Zygote Process - How the Linux Zygote process, used to spawn new processes, works.
• Running Layout Tests on Linux - Linux-specific instructions for running layout tests.
• Linux Sysroot Images - How builds use libraries on Linux
• msttcorefonts on Mandriva - Getting fonts needed to build Chrome that are not available for Mandriva
• Linux Hardware Video Decoding - Enabling hardware video decode codepaths on Linux

• Using CCache on Mac - Speed up builds on Mac using ccache with clang/ninja
• Cocoa tips and tricks - A collection of idioms used when writing Cocoa views and controllers
• MacViews Release Plan

• Handling cygwin rebaseall failures
• Hacking on ANGLE in Chromium - OpenGL ES 2.0 built on top of DirectX
• Retrieveing Code Analysis Warnings - How to retrieve and summarize the warnings generated by Microsoft VC++'s /analyze compile option.
• Windows Split DLLs - Splitting chrome.dll into multiple dlls to work around toolchain limitations on Windows.

• Google Play Services in Chrome for Android
• Accessing C++ Enums in Java - How to use C++-defined enums in Java code
• Profiling Content Shell on Android - Setting up profiling for content_shell on Android
• Working Remotely with Android - Building on a remote machine for an Android device connected to your local machine
• Using FindBugs for Android - Using the open source static analysis tool findbugs on the Java code.
• Android Test Instructions - Running a build on an Android device or emulator.
• Android Debugging - Tools and tips for how to debug Java and/or C/C++ code running on Android.
• Android Logging - How Chrome's logging API works with android.util.Log on Android, and usage guidelines.
• Chromoting Android Hacking - Viewing the logs and debugging the Chrome Remote Desktop Android client.

• Continuous Build and Test Infrastructure for Chromium for iOS
• Opening links in Chrome for iOS - How to have your iOS app open links in Chrome.
• User Agent in Chrome for iOS - Notes on User Agent strings using Chrome for iOS.

• Audio Focus Handling - How multiple MediaSession audio streams interact
• Autoplay of HTMLMediaElements - How HTMLMediaElements are autoplayed.
• Piranha Plant - Future architecture of MediaStreams

• Accessibility Overview - Overview of accessibility concerns and approaches in Chromium.
• Accessibility Tests - Where to find accessibility-related tests in the codebase.
• ChromeVox on Chrome OS - Enabling spoken feedback (ChromeVox) on Chrome OS.
• ChromeVox on Desktop Linux - Enabling spoken feedback (ChromeVox) on desktop Linux.
• BRLTTY in Chrome OS - Chrome OS integration with BRLTTY to support refreshable braille displays
• PATTS on Chrome OS - Notes on the PATTS speech sythesis engine used on Chrome OS
• VoiceOver - Using Apple's VoiceOver feature with Chromium on iOS.

• Overview
• GPU Profiling
• Adding Tracing to a Component
• Enabling Startup Tracing
• Memory Usage in CC
• Memory Benchmarks
• Heap Profiling
• Heap Profiling Internals

• Useful URLs - A collection of links to various tools and dashboards
• ERC IRC - Using ERC in EMACS to access IRC
• Kiosk Mode - Simulating kiosk mode.
• User Handle Mapping - Names of developers across Chromium/IRC/Google
• Documentation Best Practices
• Documentation Guidelines
• Shift-Based Development - An experiment in handing off development of coordinated work between developers in different time zones.
• Chromium Browser vs Google Chrome - What's the difference between Chromium Browser and Google Chrome?
• Proxy Auto Config using WPAD - How WPAD servers are used to automatically set proxy settings.
• Installing Chromium OS on VMWare - How to install Chromium OS on VMWare.

• Old ChromeOS build instructions
• TPM Quick Reference - Trusted Platform Module notes.
• System Hardening Features - A list of current and planned Chrome OS security features.
• Browser View Resizer - Design doc for making browser window resizing easier on Windows.
• WebView Policies
• Linux Profiling - How to profile Chromium on Linux
• Linux Graphics Pipeline
• Linux SUID Sandbox - Sandboxing renderers using a SUID binary on Linux
• Linux SUID Sandbox Development - Development on the above system.
• Linux PID Namespace Support
• Vanilla msysgit workflow - A workflow for using mostly vanilla git on Windows.
• Old Chromoting Build Instructions
• Old Options - Pre-Material Design chrome://settings notes.