Fix some typos

Author: zbynek

src/main/markdown/articles/mvp-architecture-2.md

@@ -330,7 +330,7 @@ public class ContactsViewColumnDefinitions<ContactDetails> {
       });
     }
 
-    public List<ColumnDefinition<ContactDetails>> getColumnDefnitions() {
+    public List<ColumnDefinition<ContactDetails>> getColumnDefinitions() {
       return columnDefinitions;
     }
   }

src/main/markdown/doc/latest/DevGuideAutoBeans.md

@@ -228,7 +228,7 @@ Maps are serialized in two forms based on whether or not the key type is a value
 ```json
 { "1" : { "property" : "value"}, "55" : { "property" : "value" } }
 ```
-A map that uses a reference object as a key will instead be encoded as a list of two lists. This allows object-identity maps that contain keys with identical serialized froms to be deserialized correctly. For example, a `Map<Person, Address>` would be encoded as: 
+A map that uses a reference object as a key will instead be encoded as a list of two lists. This allows object-identity maps that contain keys with identical serialized forms to be deserialized correctly. For example, a `Map<Person, Address>` would be encoded as: 
 
 ```json
 [ 

src/main/markdown/doc/latest/DevGuideCodingBasicsJsInterop.md

@@ -149,7 +149,7 @@ fn(40); // will return 42!
 ## Adding additional utility methods to a native type
 
 The JsInterop contract specifies that a native type may contain only native methods except the ones annotated with `@JsOverlay`. 
-`@JsOverlay` allows adding a method to a native type (annotated with `@JsType(isNative=true)`) or on a default method of a `@JsFunction` annotated interface . The `@JsOverlay` contract specifies that the methods annotated should be final and should not override any existing native method. The annotated methods will not be accessble from JavaScript and can be used from Java only. `@JsOverlay` can be useful for adding utilities methods that may not be offered by the native type. For example:
+`@JsOverlay` allows adding a method to a native type (annotated with `@JsType(isNative=true)`) or on a default method of a `@JsFunction` annotated interface . The `@JsOverlay` contract specifies that the methods annotated should be final and should not override any existing native method. The annotated methods will not be accessible from JavaScript and can be used from Java only. `@JsOverlay` can be useful for adding utilities methods that may not be offered by the native type. For example:
 
 ```java
 @JsType(isNative = true)

src/main/markdown/doc/latest/DevGuideCodingBasicsOverlay.md

@@ -183,7 +183,7 @@ function $onModuleLoad(){
 
 This is pretty darn optimized. Even the overhead of the `getFullName()` method went away. In fact, _all_ of the Java method calls went away. When we say that "GWT
 gives you affordable abstractions," this is the kind of thing we're talking about. Not only does inlined code run significantly faster, we no longer had to include the function
-definitions themselves, thus shrinking the script a litte, too. (To be fair, though, inlining can also easily increase script size, so we're careful to strike a balance between
+definitions themselves, thus shrinking the script a little, too. (To be fair, though, inlining can also easily increase script size, so we're careful to strike a balance between
 size and speed.) It's pretty fun to look back at the original Java source above and try to reason about the sequence of optimizations the compiler had to perform to end up
 here.
 

src/main/markdown/doc/latest/DevGuideI18nPluralForms.md

@@ -159,7 +159,7 @@ the count is 0, `"Nobody is here"` is chosen; if the count is 3,
 `"{1}, {2}, and one other are here"` is chosen because 2 is subtracted
 from the count before looking up the plural form to use.
 
-BTW, we know it is somewhat klunky to have to pass in the names this way.
+BTW, we know it is somewhat clunky to have to pass in the names this way.
 In the future, we will add a way of referencing elements in the list/array
 from the placeholders, where you could simply call `peopleHere(names)`.
 

src/main/markdown/doc/latest/DevGuideLightweightMetrics.md

@@ -21,7 +21,7 @@ The [Debug Panel for GWT](http://code.google.com/p/gwt-debug-panel/), developed
 
 The Lightweight Metrics system is composed of sets of events that you're interested in tracking and a global collector method that is responsible for evaluating these events and reporting metrics.
 
-For example, when loading a GWT application, the steps involved in the process consist of bootstrapping the application, loading external references, and starting up the GWT module. Each of these steps further break down into dowloading the bootstrap script, selecting the right permutation of your application to load, fetching the permutation, and so on. This is illustrated in the [Lightweight Metrics design doc](http://code.google.com/p/google-web-toolkit/wiki/LightweightMetricsDesign) (see GWT Startup Process diagram). Each of the smaller steps, like selecting the correct permutation of the application to load, can be represented as events you would like to measure in the overall application load time. The events themselves are standard JSON objects that contain the following information:
+For example, when loading a GWT application, the steps involved in the process consist of bootstrapping the application, loading external references, and starting up the GWT module. Each of these steps further break down into downloading the bootstrap script, selecting the right permutation of your application to load, fetching the permutation, and so on. This is illustrated in the [Lightweight Metrics design doc](http://code.google.com/p/google-web-toolkit/wiki/LightweightMetricsDesign) (see GWT Startup Process diagram). Each of the smaller steps, like selecting the correct permutation of the application to load, can be represented as events you would like to measure in the overall application load time. The events themselves are standard JSON objects that contain the following information:
 
 ```javascript
 { 

src/main/markdown/doc/latest/DevGuideOrganizingProjects.md

@@ -314,7 +314,7 @@ the path prefix up to and including `jre`. As a result, `com/google/myproject/gw
 The GWT project uses this technique internally for the JRE emulation
 classes provided with GWT. One caveat specific to overriding JRE classes in
 this way is that they will never actually be used in development mode. In
-development mode, the native JRE classes always supercede classes compiled
+development mode, the native JRE classes always supersede classes compiled
 from source.
 
 The `<super-source>` element supports [pattern-based

src/main/markdown/doc/latest/DevGuideRequestFactory.md

@@ -364,7 +364,7 @@ as _transportable types_.  Each client-side transportable type is mapped to a se
 
 In determining whether or not a client-side method defined in a proxy or
 context type is a valid mapping for a domain method, the client types are
-converted to ther domain equivalent and regular Java type assignability rules
+converted to their domain equivalent and regular Java type assignability rules
 are considered.
 
 A proxy type will be available on the client if it is:
@@ -399,7 +399,7 @@ formally implement the RequestContext interface. The name and argument list for
 each method is the same on client and server, with the following mapping
 rules:
 
-*   Client side methods that return `Reques<T>`return only T on the server. For example, a method
+*   Client side methods that return `Request<T>`return only T on the server. For example, a method
 that returns `Request<String>` in the client interface simply returns String on the server.
 *   EntityProxy types become the domain entity type on the server, so a method that returns
 `Request<List<EmployeeProxy>>` will just return `List<Employee>` on the server.

src/main/markdown/doc/latest/DevGuideSecurityRpcXsrf.md

@@ -124,7 +124,7 @@ package com.example.foo.client;
   }
 ```
 
-Method level annotations override RPC interface level annoatations. If no
+Method level annotations override RPC interface level annotations. If no
   annotations are present and the RPC interface contains a method that returns
   [`RpcToken`](/javadoc/latest/com/google/gwt/user/client/rpc/RpcToken.html) or its implementation, then XSRF token validation is
   performed on all methods of that interface except for the method returning

src/main/markdown/doc/latest/DevGuideUiBinder.md

@@ -84,7 +84,7 @@ aren't forced to pay the widget tax just to have templates.
 </ui:UiBinder>
 ```
 
-Now suppose you need to programatically read and write the text in the
+Now suppose you need to programmatically read and write the text in the
 span (the one with the `ui:field='nameSpan'` attribute) above. You'd
 probably like to write actual Java code to do things like that, so
 UiBinder templates have an associated owner class that allows