chromium.googlesource.com

A "MOVED" tag in the repository list on chromium.googlesource.com means that the repository at that path is no longer the active home for that code. The description usually names where it went—either a different repository path on the same host or a merge back into a larger project. If you are looking for current code, follow the destination named in the description rather than cloning the old path.

How to read a MOVED entry

The list on the site shows a repository name on the left and a description on the right. For moved entries, the description carries the signal. Three patterns appear:

A concrete example from the list: aosp/platform/system/connectivity/shill (MOVED) is described as "Merged into src/platform2/shill/ again; ChromiumOS fork of https://android.googlesource.com/platform/system/connectivity/shill/". The entry tells you two things at once—the code now lives under src/platform2/shill/, and the old path was a ChromiumOS fork of an AOSP project.

Why these entries exist at all

Many entries in this list are ChromiumOS forks of AOSP projects, mirrored or forked from android.googlesource.com. Over time, some forks were merged back into their parent ChromiumOS repositories, or the project switched back to tracking the original upstream. The list keeps the old name visible with a MOVED note so that anyone arriving from an old link or bookmark can find the new location instead of hitting a dead end.

This is a redirect-by-description system, not an automatic redirect. The old repository path may still resolve, but the description is the authoritative pointer to where active development happens.

What to do if you land on a MOVED entry

1. Read the full description text next to the repository name—the destination is stated there.
2. If it says "Merged into src/platform2/X", search the list for that platform2 repository and clone from there.
3. If it says "renamed to …", use the new path directly.
4. If it says the project moved back to a chromiumos/ path, clone from that ChromiumOS repository rather than the Chromium-hosted fork.
5. If you only need to read history, the old path may still be browsable, but do not base new work on it.

Common pitfalls

• Assuming MOVED means deleted. The code almost always still exists; it just lives somewhere else.
• Cloning the old path out of habit. You may get stale code or a fork that no longer receives updates.
• Missing the "again" wording. Phrases like "Merged into … again" indicate the project returned to a previous home, so the destination is the long-term location.
• Confusing the fork note with the move note. A description can contain both a MOVED status and a note that the repo was a ChromiumOS fork of an AOSP project. The MOVED part tells you where to go; the fork part tells you the code's lineage.

If your goal is simply to browse or clone active Chromium or ChromiumOS code, start from the destination named in the description, or pick a repository without a MOVED tag.

chromium.googlesource.com is the Git repository hosting and browsing site for Chromium-related source code on Google's googlesource.com infrastructure. It is a code access and reference site, not a product or service page. Its landing page lists repositories by name and description, including ChromiumOS forks of AOSP projects, and marks some entries as MOVED when code has been relocated or merged elsewhere.

What the site is for

The site gives you a directory of Git repositories. Each entry has a name and a short description, so you can locate the source tree you need before cloning or browsing it. Typical uses are:

• Finding the canonical repository for a Chromium component or a ChromiumOS fork of an Android/AOSP project.
• Checking whether a repository still lives at its old path or has been moved.
• Getting the exact repository name to use in a clone URL or code search.

The page itself is a listing, not documentation. It does not explain how to build Chromium or how to contribute; it tells you which repositories exist and what they contain.

How to read the repository list

The list is organized by repository name, with a description column. Names follow path-like conventions, which tells you something about origin:

Descriptions frequently name the upstream source, for example a fork of https://android.googlesource.com/platform/system/core/. That upstream reference is the fastest way to confirm whether you want the ChromiumOS fork or the original AOSP tree.

Handling MOVED entries

Several entries carry a (MOVED) marker. The description then states where the code went, in one of a few forms:

• Merged into another path, e.g. merged into src/platform2/chromeos-dbus-bindings/.
• Renamed, e.g. renamed to platform/external/libbrillo/.
• Moved back to a ChromiumOS host path, e.g. back to chromiumos/platform/minijail.

If you are about to clone a repository and its entry says MOVED, use the destination named in the description instead. Cloning the old path may still work as a redirect or may be stale; the description is the authoritative pointer on this page.

Practical example

Suppose you need the ChromiumOS fork of Android's system/core. On the listing you find aosp/platform/system/core with the description "ChromiumOS fork of https://android.googlesource.com/platform/system/core/". You now know two things: the repository name to use under chromium.googlesource.com, and the upstream project it derives from. If instead you were looking for libchrome, you would see aosp/platform/external/libchrome marked MOVED to chromiumos/platform/libchrome, and you would go to the latter.

Limits to keep in mind

• The listing is a directory, not a guarantee that every path is current; rely on the MOVED notes and upstream links in the descriptions.
• The page provides no pricing or access-tier information, so do not assume anonymous browsing or cloning terms from it alone.
• For build instructions, contribution rules, or code review workflow, this listing is not the source; use the project's own documentation.

chromium.googlesource.com is Google's Git hosting site for Chromium-related source code. It lists repositories alphabetically, each with a name and a short description. To get code, find the repository name in that list, turn it into a Git URL of the form https://chromium.googlesource.com/<name>, and clone it with standard Git. You need Git installed and network access to the host; the page itself does not state that cloning requires a sign-in.

Find the repository you need

The landing page ("Git repositories on chromium") is a directory. Each entry has:

• Name — the repository path, for example angle/angle or aosp/platform/system/core.
• Description — a short note on what the repo contains or where it came from.

Names are listed alphabetically, so scan or use your browser's find function on the page. Watch for entries marked (MOVED): these note that the code was merged or renamed elsewhere, for example aosp/platform/external/libchrome (MOVED) to chromiumos/platform/libchrome. For those, follow the note rather than cloning the old path.

Some descriptions also identify the repo as a ChromiumOS fork of an Android source project, such as aosp/platform/system/bt. That tells you the code's upstream origin, which matters if you need to compare against or contribute back to the original project.

Build the clone URL

Repository names map directly onto URLs under the host:

https://chromium.googlesource.com/<repository-name>

Examples using names from the listing:

Clone it

1. Confirm Git is installed: run git --version. A version number means you're ready.
2. Clone with the URL you built:

git clone https://chromium.googlesource.com/angle/angle

3. Expected result: Git creates a local directory named after the last part of the path (here angle) and checks out the default branch. A progress line ending in "done." confirms success.

To clone into a specific folder, add a target name: git clone <url> my-folder.

Check out a specific revision or branch

After cloning, list branches with git branch -r and switch with git checkout <branch>. To inspect history without a full checkout, git log --oneline in the cloned directory shows recent commits. If you only need a snapshot, git clone --depth 1 <url> fetches just the latest commit and is faster for large repositories.

Sign-in, passwords, and code review

The page header includes Sign in, Generate Password, Revoke Passwords, and Code Review links. These relate to authenticated access and the review workflow, not to browsing or cloning public code. If a clone prompts for credentials, use the password generated through that flow rather than your account password. The page does not state which repositories, if any, are restricted, so treat sign-in as something you use only when a specific operation asks for it.

Common snags

• "Repository not found" — the name is probably mistyped or the repo was moved. Recheck the exact listing entry and any (MOVED) note.
• Clone is very slow — large repos such as platform forks take time; try --depth 1 for a shallow copy.
• Authentication prompt — generate a password from the site's link and use it when Git asks.
• Looking for the browser's source — the listing covers many projects; use the description column to pick the right one rather than guessing from the name alone.

chromium.googlesource.com hosts the Chromium project's Git repositories, and its repository index includes many entries prefixed aosp/ because ChromiumOS (the OS layer built around Chromium) maintains its own forks of Android Open Source Project (AOSP) code there. The listing is a map of where ChromiumOS keeps third-party and upstream-derived components, not a claim that Chromium owns AOSP. You'll see these entries when browsing the repository list or looking for the source of a ChromiumOS component such as Bluetooth, libbrillo, or minijail.

What the aosp/ entries actually are

Most aosp/ repositories are described in the index as "ChromiumOS fork of https://android.googlesource.com/platform/…". That wording tells you three things:

• The upstream project lives in AOSP, mirrored at android.googlesource.com.
• ChromiumOS keeps a fork on the Chromium Git host so it can carry ChromiumOS-specific changes.
• The fork is the copy you should look at if you're tracing ChromiumOS behavior rather than upstream Android behavior.

Some entries are described as "Repos that are mirrored/forked directly from https://android.googlesource.com/" — a plain mirror with no ChromiumOS-specific divergence implied by the description.

Why forks live on the Chromium host

ChromiumOS builds on a mix of Chromium code and lower-level system components, several of which originate in AOSP (for example platform/system/bt for Bluetooth, platform/external/libbrillo, and platform/external/minijail). Keeping the fork on the same Git host as the rest of ChromiumOS lets the project pin, patch, and review those components alongside its own code, using the same code review and access tooling shown on the repository index page.

A practical consequence: when you search for a component's source, the Chromium-hosted fork is often the authoritative copy for ChromiumOS, while the AOSP URL in the description is the upstream reference point.

What "MOVED" means in the list

Several entries carry a (MOVED) marker, and the description explains where the code went. The pattern is consistent: a fork that was once separate has been merged back into a ChromiumOS platform repository. Examples from the index:

So a MOVED entry is a signpost, not a live location. If you need current code for shill, for instance, the description points you to src/platform2/shill/ rather than the old aosp/ path.

How to use the list to find code

1. Open the repository index at chromium.googlesource.com and locate the component by name (the list is alphabetical, grouped by prefix such as aosp/, chromiumos/, src/).
2. Read the description column before cloning. If it says (MOVED), follow the destination it names instead of the repository you clicked.
3. If the description says "ChromiumOS fork of …", treat the Chromium-hosted repo as the ChromiumOS copy and the android.googlesource.com URL as upstream.
4. Clone from the repository page's own clone instructions; the index page itself only lists names and descriptions.

The main pitfall is cloning a MOVED repository and working against stale code — always check the description first. The second is assuming an aosp/ fork is identical to upstream AOSP; the fork exists precisely because ChromiumOS changes it.

The page at chromium.googlesource.com is a plain alphabetical index of Git repositories hosted on the chromium host. Each entry is a repository name followed by a short description, and that description is what tells you whether the repo is the one you want. Repositories that have been relocated or renamed are still listed, with a "MOVED" note in the description pointing to the current location. The top of the page also carries links for Code Review, Generate Password, Revoke Passwords, and Sign in.

What the page contains

The heading is "Git repositories on chromium," and below it the repositories appear as a two-column list: Name and Description. There is no search box or category grouping described on the page, so navigation means scanning names and reading descriptions.

The top-of-page links serve account and review tasks rather than browsing:

• Code Review — entry point to the review tool used with these repositories
• Generate Password / Revoke Passwords — credential management for Git access
• Sign in — authentication

Reading the descriptions

Descriptions are short and often state the repo's origin or purpose. Two patterns are worth knowing:

Forks of AOSP. Many entries begin with aosp/ and describe themselves as a "ChromiumOS fork of" an android.googlesource.com path. For example, aosp/platform/system/core is described as the ChromiumOS fork of the Android platform system/core repo. These exist on the chromium host because ChromiumOS builds on Android-derived components.

Moved entries. A description containing "(MOVED)" means the repo no longer lives at that name. The note usually says where it went — merged into another path, renamed, or moved back to a different host. Examples from the page:

If you land on a MOVED entry, follow the path named in its description instead of cloning the old name.

Finding and cloning a repository

1. Identify the component. Decide which part of the codebase you need (for example, a Bluetooth module or a hardware interface). The name usually reflects the component path.
2. Scan the Name column for a match, then confirm against the Description. Prefer entries without "(MOVED)".
3. Check for a MOVED note before cloning. If present, switch to the location the description names.
4. Clone from the repository page. Selecting a repository name opens its page on the host, which provides the clone URL for that repo. Use the standard git clone <url> form with the URL shown there.
5. Verify by listing the cloned directory contents or checking git remote -v to confirm the origin matches the repo you intended.

A concrete case: if you need the ChromiumOS fork of Android's system/core, the entry aosp/platform/system/core is the right target, and its description confirms the fork relationship. If you instead pick aosp/platform/external/libchrome, the "(MOVED) to chromiumos/platform/libchrome" note tells you the clone would not give you the maintained code.

Common snags

• Cloning a stale name. The most likely mistake is picking a MOVED entry. The description is the only warning on the index page, so read it before copying a name.
• Confusing forks with upstream. An aosp/... entry on this host is a ChromiumOS fork, not the original Android repository. If you need upstream Android code, the description points to the android.googlesource.com path it was forked from.
• Assuming the list is complete or categorized. The page presents a flat name/description list; there is no indication of grouping by project, so long scans are expected.
• Credential steps. The Generate Password and Revoke Passwords links exist for managing Git access credentials, but the page itself does not describe the login requirements or terms of use for those tools — check the linked pages directly rather than assuming open access.