Update Chromium docs on using clang

docs/clang.md

 # Clang
 
 [Clang](http://clang.llvm.org/) is a compiler with many desirable features
 (outlined on their website).
 
 Chrome can be built with Clang. It is now the default compiler on Mac and Linux
 for building Chrome, and it is currently useful for its warning and error
 messages on Android and Windows.
 
 See
 [the open bugs](http://code.google.com/p/chromium/issues/list?q=label:clang).
 
 [TOC]
 
 ## Build instructions
 
-Get clang (happens automatically during `gclient runhooks` on Mac and Linux):
+### Ninja

[Nico, 2016/04/13 00:50:14]

(we can probably drop this heading too; all platforms are on ninja by now)

 
-    tools/clang/scripts/update.py
+Regenerate the ninja build files with Clang enabled. On Linux or Mac, Clang is
+enabled by default.
 
-(Only needs to be run once per checkout, and clang will be automatically updated
-by `gclient runhooks`.)
+If you use gyp: `GYP_DEFINES=clang=1 build/gyp_chromium`
+
+If you use gn, run `gn args` and add `is_clang = true` to your args.gn file.
+
+Build: `ninja -C out/Debug chrome`
 
 ### Reverting to gcc on linux
 
 We don't have bots that test this, but building with gcc4.8+ should still work
 on Linux. If your system gcc is new enough, use this to build with gcc if you
 don't want to build with clang:
 
     GYP_DEFINES=clang=0 build/gyp_chromium
 
-### Ninja
-
-Regenerate the build files (`clang=1` is on by default on Mac and Linux):
-
-If you use gyp: `GYP_DEFINES=clang=1 build/gyp_chromium`
-
-If you use gn, run `gn args` and add `is_clang = true` to your args.gn file.
-
-Build: `ninja -C out/Debug chrome`
-
 ## Mailing List
 
 http://groups.google.com/a/chromium.org/group/clang/topics
 
 ## Using plugins
 
 The
 [chromium style plugin](http://dev.chromium.org/developers/coding-style/chromium-style-checker-errors)
 is used by default when clang is used.
 
@@ skipping 20 matching lines @@
 
 *   `GYP_DEFINES='clang=1 clang_load=/path/to/libFindBadConstructs.so
     clang_add_plugin=find-bad-constructs' gclient runhooks`
 
 ## Using the clang static analyzer
 
 See [clang_static_analyzer.md](clang_static_analyzer.md).
 
 ## Windows
 
-**Experimental!**
-
 clang can be used as compiler on Windows. Clang uses Visual Studio's linker and
 SDK, so you still need to have Visual Studio installed.
 
 Things should compile, and all tests should pass. You can check these bots for
 how things are currently looking:
 http://build.chromium.org/p/chromium.fyi/console?category=win%20clang
 
 ``` shell
 python tools\clang\scripts\update.py
 set GYP_DEFINES=clang=1
 python build\gyp_chromium
 
 # or, if you use gn, run `gn args` and add `is_clang = true` to your args.gn
 ninja -C out\Debug chrome
 ```
 

[Nico, 2016/04/13 00:50:14]

mention somewhere here that update.py only needs to be run once and autoupdates
after that. maybe just paste the "(Only needs to be run once per checkout, and
clang will be …" bit here

[Reid Kleckner, 2016/04/13 18:11:47]

What about simplifying this to `gclient runhooks` here and above? Is that too
slow?

[Nico, 2016/04/13 18:13:58]

It's not enough in a gn build, since runhooks calls update.py with --if-needed,
and that exits on Windows unless clang=1 is in GYP_DEFINES (which it isn't in gn
builds) 

 Current brokenness:
 
-*   Goma doesn't work.
 *   Debug info is very limited.
 *   To get colored diagnostics, you need to be running
     [ansicon](https://github.com/adoxa/ansicon/releases).
 
 ## Using a custom clang binary
 
 If you want to try building Chromium with your own clang binary that you've
 already built, set `make_clang_dir` to the directory containing `bin/clang`
 (i.e. the directory you ran cmake in, or your `Release+Asserts` folder if you
 use the configure/make build). You also need to disable chromium's clang plugin
@@ skipping 11 matching lines @@
 
 You can then run `head out/Release/build.ninja` and check that the first to
 lines set `cc` and `cxx` to your clang binary. If things look good, run `ninja
 -C out/Release` to build.
 
 If your clang revision is very different from the one currently used in chromium
 
 *   Check `tools/clang/scripts/update.py` to find chromium's clang revision
 *   You might have to tweak warning flags. Or you could set `werror=` in the
     line above to disable warnings as errors (but this only works on Linux).
+
+## Using LLD
+
+**Experimental!**
+
+LLD is a relatively new linker from LLVM. The current focus is on Windows and
+Linux support, where it can link Chrome approximately twice as fast as gold and
+MSVC's link.exe as of this writing. LLD does not yet support generating PDB
+files, which makes it hard to debug Chrome while using LLD.
+
+If you use gyp, you can enable it with `GYP_DEFINES=lld=1`. If you use gn, set
+`use_lld = true` in args.gn. Currently this configuration is only supported on
+Windows.