Fixed directions for release build.

README.md

 Mojo
 ====
 
 Mojo is an effort to extract a common platform out of Chrome's renderer and plugin processes that can support multiple types of sandboxed content, such as HTML, Pepper, or NaCl.
 
 ## Set up your environment
 
 The instructions below only need to be done once. Note that a simple "git clone" command is not sufficient to build the source code because this repo uses the gclient command from depot_tools to manage most third party dependencies.
 
 1. Download depot_tools and make sure it is in your path:<br>http://www.chromium.org/developers/how-tos/install-depot-tools<br>
@@ skipping 12 matching lines @@
 
 The "fetch mojo" command does the following:
 - creates a directory called 'src' under your checkout directory
 - clones the repository using git clone
 - clones dependencies with gclient sync
 
 `install-build-deps.sh` installs any packages needed to build, then `mojo/tools/mojob.py gn` runs `gn args` and configures the build directory, out/Debug.
 
 If the fetch command fails, you will need to delete the src directory and start over.
 
-## Build Mojo
+## <a name="buildmojo"></a>Build Mojo
 
-Build Mojo by running:
+Build Mojo for Linux by running:
 
 ```
 $ ninja -C out/Debug -j 10

[jamesr, 2015/02/13 22:27:22]

can you update this too?

[jimbe, 2015/02/14 00:44:50]

I'm happy to update it, but can you clarify what you want updated? It is for use
outside of Google, so the -j parameter is okay. In the next paragraph I talk
about using mojob.py, but I note that you can't specify targets with that
strategy.

 ```
 
 (If you are a Googler, see the section at the end of this document for faster builds.)
 
 You can also use the mojob.py script for building. This script automatically calls ninja and sets -j to an appropriate value based on whether Goma is present. You cannot specify a target name with this script.
 ```
 mojo/tools/mojob.py build
 ```
 
 Run a demo:
 ```
 mojo/tools/mojo_demo.py --browser
 ```
 
 Run the tests:
 ```
 mojo/tools/mojob.py test
 ```
 
+Create a release build:
+```
+mojo/tools/mojob.py gn --release
+mojo/tools/mojob.py build --release
+mojo/tools/mojob.py test --release
+```
+
 ## Update your repo
 
 You can update your repo like this:
 ```
 $ git pull --rebase
 (fetch changes from upstream and rebase the current branch on top)
 $ gclient sync
 (update all modules as directed by the DEPS file)
 ```
 
-You do not need to rerun "gn gen out/Debug". Ninja will do so automatically as needed.
+You do not need to rerun `gn gen out/Debug` or `mojo/tools/mojob.py gn`. Ninja will do so automatically as needed.
 
 ## Contribute
 
 With git you should make all your changes in a local branch. Once your change is committed, you can delete this branch.
 
 Create a local branch named "mywork" and make changes to it.
 ```
   cd src
   git new-branch mywork
   vi ...
@@ skipping 37 matching lines @@
 
 Pull down all of the packages with this command:
 
 ```
 $ gclient sync
 ```
 
 Prepare the build directory for Android:
 
 ```
-$ src/mojo/tools/mojob.py gn --android
+$ mojo/tools/mojob.py gn --android
 ```
 
 Finally, perform the build. The result will be in out/android_Debug:
 
 ```
-$ src/mojo/tools/mojob.py build --android
+$ mojo/tools/mojob.py build --android
 ```
 
 If you see javac compile errors, make sure you have an up-to-date JDK:
 https://code.google.com/p/chromium/wiki/AndroidBuildInstructions#Install_Java_JDK
 
 ## Googlers
 
 If you're a Googler, you can use Goma, a distributed compiler service for open-source projects such as Chrome and Android. The instructions below assume that Goma is installed in the default location (~/goma).
 
 To enable Goma, update your "args.gn" file. Open the file in your editor with this command:
@@ skipping 20 matching lines @@
 0. Prerequisites:
     * Before you start, you'll need a device with an unlocked bootloader, otherwise you won't be able to run adb root (or any of the commands that require root). For Googlers, <a href="http://go/mojo-internal-build-instructions">follow this link</a> and follow the instructions before returning to this page.
     * Ensure your device is running Lollipop and has an userdebug build.
     * Set up environment for building on Android. This sets up the adb path, etc. You may need to remove /usr/bin/adb.
     ```
     source build/android/envsetup.sh
     ```
 
 1. Build changed files:
     ```
-    mojob.py build --android
+    mojo/tools/mojob.py build --android
     ```
 
 2. Push mojo_shell to to your device:
     ```
     adb install -r out/android_Debug/apks/MojoShell.apk
     ```
 
 3. Run Mojo Shell on the device:
     ```
-    ./mojo/tools/android_mojo_shell.py mojo:sample_app
+    mojo/tools/android_mojo_shell.py mojo:sample_app
     ```
 
 4. If you get a crash you won't see symbols. Use tools/android_stack_parser/stack to map back to symbols, e.g.:
     ```
     adb logcat | ./tools/android_stack_parser/stack
     ```
 
 ### On Linux
 
-1. Build the mojo target, which builds the shell and all examples:
-    ```
-    ninja -C out/Release mojo
-    ```
+1. Build the mojo target as described under [link](#buildmojo).
 
 2. Run Mojo Shell:
     ```
-    ./out/Release/mojo_shell mojo:sample_app
+    ./out/Debug/mojo_shell mojo:sample_app
     ```
 
 3. Optional: Run Mojo Shell with an HTTP server
     ```
-    cd out/Release
+    cd out/Debug
     python -m SimpleHTTPServer 4444 &
     ./mojo_shell --origin=http://127.0.0.1:4444 --disable-cache mojo:mojo_sample_app
     ```