diff --git a/.buckconfig b/.buckconfig
new file mode 100644
index 0000000..112615b
--- /dev/null
+++ b/.buckconfig
@@ -0,0 +1,10 @@
+[alias]
+  automerger = //:automerger
+  plugin = //:automerger
+[java]
+  src_roots = java, resources
+[project]
+  ignore = .git
+[cache]
+  mode = dir
+  dir = buck-out/cache
diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..21cb77a
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,12 @@
+/target
+/.buckversion
+/.classpath
+/.settings
+/.project
+/.buckd
+/buck-cache
+/buck-out
+/bucklets
+.buckversion
+.watchmanconfig
+/eclipse-out
diff --git a/BUCK b/BUCK
new file mode 100644
index 0000000..bde84db
--- /dev/null
+++ b/BUCK
@@ -0,0 +1,59 @@
+include_defs('//bucklets/gerrit_plugin.bucklet')
+include_defs('//bucklets/maven_jar.bucklet')
+
+gerrit_plugin(
+  name = 'automerger',
+  srcs = glob(['src/main/java/**/*.java']),
+  resources = glob(['src/main/**/*']),
+  manifest_entries = [
+    'Gerrit-PluginName: automerger',
+    'Gerrit-Module: com.googlesource.gerrit.plugins.automerger.Module',
+    'Gerrit-HttpModule: com.googlesource.gerrit.plugins.automerger.HttpModule',
+    'Implementation-Title: Automerger plugin',
+    'Implementation-URL: https://gerrit-review.googlesource.com/#/admin/projects/plugins/automerger',
+  ],
+  deps = [
+    ':re2j',
+    ':yaml',
+  ],
+)
+
+define_license(name = 're2j')
+
+maven_jar(
+  name = 'yaml',
+  id = 'org.yaml:snakeyaml:1.17',
+  sha1 = '7a27ea250c5130b2922b86dea63cbb1cc10a660c',
+  license = 'Apache2.0',
+)
+
+maven_jar(
+  name = 'mockito',
+  id = 'org.mockito:mockito-all:1.10.19',
+  sha1 = '539df70269cc254a58cccc5d8e43286b4a73bf30',
+  license = 'DO_NOT_DISTRIBUTE',
+)
+
+maven_jar(
+  name = 're2j',
+  id = 'com.google.re2j:re2j:1.0',
+  sha1 = 'd24ac5f945b832d93a55343cd1645b1ba3eca7c3',
+  license = 're2j',
+  local_license = True,
+)
+
+java_test(
+  name = 'automerger_tests',
+  srcs = glob(['src/test/java/**/*.java']),
+  resources = glob(['src/test/resources/**/*']),
+  labels = ['automerger'],
+  deps = GERRIT_PLUGIN_API + GERRIT_TESTS + [
+    ':automerger__plugin',
+    ':mockito',
+  ],
+)
+
+java_library(
+  name = 'classpath',
+  deps = [':automerger__plugin'] + GERRIT_PLUGIN_API,
+)
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..11069ed
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,201 @@
+                              Apache License
+                        Version 2.0, January 2004
+                     http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+1. Definitions.
+
+   "License" shall mean the terms and conditions for use, reproduction,
+   and distribution as defined by Sections 1 through 9 of this document.
+
+   "Licensor" shall mean the copyright owner or entity authorized by
+   the copyright owner that is granting the License.
+
+   "Legal Entity" shall mean the union of the acting entity and all
+   other entities that control, are controlled by, or are under common
+   control with that entity. For the purposes of this definition,
+   "control" means (i) the power, direct or indirect, to cause the
+   direction or management of such entity, whether by contract or
+   otherwise, or (ii) ownership of fifty percent (50%) or more of the
+   outstanding shares, or (iii) beneficial ownership of such entity.
+
+   "You" (or "Your") shall mean an individual or Legal Entity
+   exercising permissions granted by this License.
+
+   "Source" form shall mean the preferred form for making modifications,
+   including but not limited to software source code, documentation
+   source, and configuration files.
+
+   "Object" form shall mean any form resulting from mechanical
+   transformation or translation of a Source form, including but
+   not limited to compiled object code, generated documentation,
+   and conversions to other media types.
+
+   "Work" shall mean the work of authorship, whether in Source or
+   Object form, made available under the License, as indicated by a
+   copyright notice that is included in or attached to the work
+   (an example is provided in the Appendix below).
+
+   "Derivative Works" shall mean any work, whether in Source or Object
+   form, that is based on (or derived from) the Work and for which the
+   editorial revisions, annotations, elaborations, or other modifications
+   represent, as a whole, an original work of authorship. For the purposes
+   of this License, Derivative Works shall not include works that remain
+   separable from, or merely link (or bind by name) to the interfaces of,
+   the Work and Derivative Works thereof.
+
+   "Contribution" shall mean any work of authorship, including
+   the original version of the Work and any modifications or additions
+   to that Work or Derivative Works thereof, that is intentionally
+   submitted to Licensor for inclusion in the Work by the copyright owner
+   or by an individual or Legal Entity authorized to submit on behalf of
+   the copyright owner. For the purposes of this definition, "submitted"
+   means any form of electronic, verbal, or written communication sent
+   to the Licensor or its representatives, including but not limited to
+   communication on electronic mailing lists, source code control systems,
+   and issue tracking systems that are managed by, or on behalf of, the
+   Licensor for the purpose of discussing and improving the Work, but
+   excluding communication that is conspicuously marked or otherwise
+   designated in writing by the copyright owner as "Not a Contribution."
+
+   "Contributor" shall mean Licensor and any individual or Legal Entity
+   on behalf of whom a Contribution has been received by Licensor and
+   subsequently incorporated within the Work.
+
+2. Grant of Copyright License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   copyright license to reproduce, prepare Derivative Works of,
+   publicly display, publicly perform, sublicense, and distribute the
+   Work and such Derivative Works in Source or Object form.
+
+3. Grant of Patent License. Subject to the terms and conditions of
+   this License, each Contributor hereby grants to You a perpetual,
+   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+   (except as stated in this section) patent license to make, have made,
+   use, offer to sell, sell, import, and otherwise transfer the Work,
+   where such license applies only to those patent claims licensable
+   by such Contributor that are necessarily infringed by their
+   Contribution(s) alone or by combination of their Contribution(s)
+   with the Work to which such Contribution(s) was submitted. If You
+   institute patent litigation against any entity (including a
+   cross-claim or counterclaim in a lawsuit) alleging that the Work
+   or a Contribution incorporated within the Work constitutes direct
+   or contributory patent infringement, then any patent licenses
+   granted to You under this License for that Work shall terminate
+   as of the date such litigation is filed.
+
+4. Redistribution. You may reproduce and distribute copies of the
+   Work or Derivative Works thereof in any medium, with or without
+   modifications, and in Source or Object form, provided that You
+   meet the following conditions:
+
+   (a) You must give any other recipients of the Work or
+       Derivative Works a copy of this License; and
+
+   (b) You must cause any modified files to carry prominent notices
+       stating that You changed the files; and
+
+   (c) You must retain, in the Source form of any Derivative Works
+       that You distribute, all copyright, patent, trademark, and
+       attribution notices from the Source form of the Work,
+       excluding those notices that do not pertain to any part of
+       the Derivative Works; and
+
+   (d) If the Work includes a "NOTICE" text file as part of its
+       distribution, then any Derivative Works that You distribute must
+       include a readable copy of the attribution notices contained
+       within such NOTICE file, excluding those notices that do not
+       pertain to any part of the Derivative Works, in at least one
+       of the following places: within a NOTICE text file distributed
+       as part of the Derivative Works; within the Source form or
+       documentation, if provided along with the Derivative Works; or,
+       within a display generated by the Derivative Works, if and
+       wherever such third-party notices normally appear. The contents
+       of the NOTICE file are for informational purposes only and
+       do not modify the License. You may add Your own attribution
+       notices within Derivative Works that You distribute, alongside
+       or as an addendum to the NOTICE text from the Work, provided
+       that such additional attribution notices cannot be construed
+       as modifying the License.
+
+   You may add Your own copyright statement to Your modifications and
+   may provide additional or different license terms and conditions
+   for use, reproduction, or distribution of Your modifications, or
+   for any such Derivative Works as a whole, provided Your use,
+   reproduction, and distribution of the Work otherwise complies with
+   the conditions stated in this License.
+
+5. Submission of Contributions. Unless You explicitly state otherwise,
+   any Contribution intentionally submitted for inclusion in the Work
+   by You to the Licensor shall be under the terms and conditions of
+   this License, without any additional terms or conditions.
+   Notwithstanding the above, nothing herein shall supersede or modify
+   the terms of any separate license agreement you may have executed
+   with Licensor regarding such Contributions.
+
+6. Trademarks. This License does not grant permission to use the trade
+   names, trademarks, service marks, or product names of the Licensor,
+   except as required for reasonable and customary use in describing the
+   origin of the Work and reproducing the content of the NOTICE file.
+
+7. Disclaimer of Warranty. Unless required by applicable law or
+   agreed to in writing, Licensor provides the Work (and each
+   Contributor provides its Contributions) on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+   implied, including, without limitation, any warranties or conditions
+   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+   PARTICULAR PURPOSE. You are solely responsible for determining the
+   appropriateness of using or redistributing the Work and assume any
+   risks associated with Your exercise of permissions under this License.
+
+8. Limitation of Liability. In no event and under no legal theory,
+   whether in tort (including negligence), contract, or otherwise,
+   unless required by applicable law (such as deliberate and grossly
+   negligent acts) or agreed to in writing, shall any Contributor be
+   liable to You for damages, including any direct, indirect, special,
+   incidental, or consequential damages of any character arising as a
+   result of this License or out of the use or inability to use the
+   Work (including but not limited to damages for loss of goodwill,
+   work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses), even if such Contributor
+   has been advised of the possibility of such damages.
+
+9. Accepting Warranty or Additional Liability. While redistributing
+   the Work or Derivative Works thereof, You may choose to offer,
+   and charge a fee for, acceptance of support, warranty, indemnity,
+   or other liability obligations and/or rights consistent with this
+   License. However, in accepting such obligations, You may act only
+   on Your own behalf and on Your sole responsibility, not on behalf
+   of any other Contributor, and only if You agree to indemnify,
+   defend, and hold each Contributor harmless for any liability
+   incurred by, or claims asserted against, such Contributor by reason
+   of your accepting any such warranty or additional liability.
+
+END OF TERMS AND CONDITIONS
+
+APPENDIX: How to apply the Apache License to your work.
+
+   To apply the Apache License to your work, attach the following
+   boilerplate notice, with the fields enclosed by brackets "[]"
+   replaced with your own identifying information. (Don't include
+   the brackets!)  The text should be enclosed in the appropriate
+   comment syntax for the file format. We also recommend that a
+   file or class name and description of purpose be included on the
+   same "printed page" as the copyright notice for easier
+   identification within third-party archives.
+
+Copyright [yyyy] [name of copyright owner]
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
diff --git a/LICENSE-re2j b/LICENSE-re2j
new file mode 100644
index 0000000..b620ae6
--- /dev/null
+++ b/LICENSE-re2j
@@ -0,0 +1,32 @@
+This is a work derived from Russ Cox's RE2 in Go, whose license
+http://golang.org/LICENSE is as follows:
+
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+     notice, this list of conditions and the following disclaimer.
+
+   * Redistributions in binary form must reproduce the above copyright
+     notice, this list of conditions and the following disclaimer in
+     the documentation and/or other materials provided with the
+     distribution.
+
+   * Neither the name of Google Inc. nor the names of its contributors
+     may be used to endorse or promote products derived from this
+     software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/lib/gerrit/BUCK b/lib/gerrit/BUCK
new file mode 100644
index 0000000..f346f2f
--- /dev/null
+++ b/lib/gerrit/BUCK
@@ -0,0 +1,20 @@
+include_defs('//bucklets/maven_jar.bucklet')
+
+VER = '2.14-SNAPSHOT'
+REPO = MAVEN_LOCAL
+
+maven_jar(
+  name = 'plugin-api',
+  id = 'com.google.gerrit:gerrit-plugin-api:' + VER,
+  license = 'Apache2.0',
+  attach_source = False,
+  repository = REPO,
+)
+
+maven_jar(
+  name = 'acceptance-framework',
+  id = 'com.google.gerrit:gerrit-acceptance-framework:' + VER,
+  license = 'Apache2.0',
+  attach_source = False,
+  repository = REPO,
+)
\ No newline at end of file
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/AutomergeChangeAction.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/AutomergeChangeAction.java
new file mode 100644
index 0000000..08a068c
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/AutomergeChangeAction.java
@@ -0,0 +1,102 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.gerrit.extensions.restapi.Response;
+import com.google.gerrit.extensions.restapi.RestApiException;
+import com.google.gerrit.extensions.restapi.RestModifyView;
+import com.google.gerrit.extensions.webui.UiAction;
+import com.google.gerrit.reviewdb.client.Change;
+import com.google.gerrit.server.CurrentUser;
+import com.google.gerrit.server.IdentifiedUser;
+import com.google.gerrit.server.change.RevisionResource;
+import com.google.gerrit.server.events.EventFactory;
+import com.google.gson.Gson;
+import com.google.gson.reflect.TypeToken;
+import com.google.inject.Inject;
+import com.google.inject.Provider;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.lang.reflect.Type;
+import java.util.Map;
+
+class AutomergeChangeAction
+    implements UiAction<RevisionResource>,
+        RestModifyView<RevisionResource, AutomergeChangeAction.Input> {
+  private static final Logger log = LoggerFactory.getLogger(AutomergeChangeAction.class);
+
+  private Provider<CurrentUser> user;
+  private ConfigLoader config;
+  private DownstreamCreator dsCreator;
+  private EventFactory eventFactory;
+
+  @Inject
+  AutomergeChangeAction(
+      Provider<CurrentUser> user,
+      ConfigLoader config,
+      DownstreamCreator dsCreator,
+      EventFactory eventFactory) {
+    this.user = user;
+    this.config = config;
+    this.dsCreator = dsCreator;
+    this.eventFactory = eventFactory;
+  }
+
+  @Override
+  public Object apply(RevisionResource rev, Input input)
+      throws RestApiException, FailedMergeException {
+    Map<String, Boolean> branchMap = input.branchMap;
+
+    Change change = rev.getChange();
+    String revision = rev.getPatchSet().getRevision().get();
+
+    MultipleDownstreamMergeInput mdsMergeInput = new MultipleDownstreamMergeInput();
+    mdsMergeInput.dsBranchMap = branchMap;
+    mdsMergeInput.sourceId = change.getKey().get();
+    mdsMergeInput.project = change.getProject().get();
+    mdsMergeInput.topic = change.getTopic();
+    mdsMergeInput.subject = change.getSubject();
+    mdsMergeInput.obsoleteRevision = revision;
+    mdsMergeInput.currentRevision = revision;
+
+    dsCreator.createMergesAndHandleConflicts(mdsMergeInput);
+    return Response.none();
+  }
+
+  @Override
+  public Description getDescription(RevisionResource resource) {
+    String project = resource.getProject().get();
+    String branch = resource.getChange().getDest().getShortName();
+    Description desc = new Description();
+    desc = desc.setLabel("Recreate automerges").setTitle("Recreate automerges downstream");
+    try {
+      if (config.getDownstreamBranches(branch, project).isEmpty()) {
+        desc = desc.setVisible(false);
+      } else {
+        desc = desc.setVisible(user.get() instanceof IdentifiedUser);
+      }
+    } catch (RestApiException | IOException e) {
+      log.error("Failed to recreate automerges for {} on {}", project, branch);
+      desc = desc.setVisible(false);
+    }
+    return desc;
+  }
+
+  static class Input {
+    Map<String, Boolean> branchMap;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/ConfigDownstreamAction.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/ConfigDownstreamAction.java
new file mode 100644
index 0000000..d0a8022
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/ConfigDownstreamAction.java
@@ -0,0 +1,62 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.gerrit.extensions.restapi.DefaultInput;
+import com.google.gerrit.extensions.restapi.Response;
+import com.google.gerrit.extensions.restapi.RestApiException;
+import com.google.gerrit.extensions.restapi.RestModifyView;
+import com.google.gerrit.server.change.RevisionResource;
+import com.google.gson.Gson;
+import com.google.inject.Inject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Set;
+
+class ConfigDownstreamAction
+    implements RestModifyView<RevisionResource, ConfigDownstreamAction.Input> {
+  private static final Logger log = LoggerFactory.getLogger(ConfigDownstreamAction.class);
+
+  protected ConfigLoader config;
+
+  @Inject
+  public ConfigDownstreamAction(ConfigLoader config) {
+    this.config = config;
+  }
+
+  @Override
+  public Response<Map<String, Boolean>> apply(RevisionResource rev, Input input)
+      throws RestApiException, IOException {
+
+    String branchName = rev.getChange().getDest().getShortName();
+    String projectName = rev.getProject().get();
+
+    Set<String> downstreamBranches = config.getDownstreamBranches(branchName, projectName);
+    Map<String, Boolean> downstreamMap = new HashMap<>();
+    for (String downstreamBranch : downstreamBranches) {
+      boolean isSkipMerge = config.isSkipMerge(branchName, downstreamBranch, input.subject);
+      downstreamMap.put(downstreamBranch, !isSkipMerge);
+    }
+    return Response.created(downstreamMap);
+  }
+
+  static class Input {
+    @DefaultInput String subject;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/ConfigLoader.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/ConfigLoader.java
new file mode 100644
index 0000000..23c111e
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/ConfigLoader.java
@@ -0,0 +1,202 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.common.base.Charsets;
+import com.google.common.io.CharStreams;
+import com.google.gerrit.extensions.api.GerritApi;
+import com.google.gerrit.extensions.restapi.BinaryResult;
+import com.google.gerrit.extensions.restapi.ResourceNotFoundException;
+import com.google.gerrit.extensions.restapi.RestApiException;
+import com.google.inject.Inject;
+import com.google.inject.Singleton;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+@Singleton
+public class ConfigLoader {
+  private static final Logger log = LoggerFactory.getLogger(ConfigLoader.class);
+  public final String configProject;
+  public final String configProjectBranch;
+  public final String configFilename;
+  public final List<String> configOptionKeys;
+
+  protected GerritApi gApi;
+  private volatile LoadedConfig config;
+
+  @Inject
+  public ConfigLoader(GerritApi gApi) throws IOException {
+    this.gApi = gApi;
+
+    String configKeysPath = "/config/config_keys.yaml";
+    try (InputStreamReader streamReader =
+        new InputStreamReader(getClass().getResourceAsStream(configKeysPath), Charsets.UTF_8)) {
+
+      String automergerConfigYamlString = CharStreams.toString(streamReader);
+      Map automergerConfig = (Map) (new Yaml().load(automergerConfigYamlString));
+      configProject = (String) automergerConfig.get("config_project");
+      configProjectBranch = (String) automergerConfig.get("config_project_branch");
+      configFilename = (String) automergerConfig.get("config_filename");
+      configOptionKeys = (List<String>) automergerConfig.get("config_option_keys");
+
+      try {
+        loadConfig();
+      } catch (IOException | RestApiException e) {
+        log.error("Config failed to sync!", e);
+        config = new LoadedConfig();
+      }
+    }
+  }
+
+  public void loadConfig() throws IOException, RestApiException {
+    config =
+        new LoadedConfig(
+            gApi, configProject, configProjectBranch, configFilename, configOptionKeys);
+  }
+
+  // Returns true if matches DO NOT MERGE regex and merge_all is false
+  public boolean isSkipMerge(String fromBranch, String toBranch, String commitMessage) {
+    return config.isSkipMerge(fromBranch, toBranch, commitMessage);
+  }
+
+  public Map<String, Object> getConfig(String fromBranch, String toBranch) {
+    return config.getMergeConfig(fromBranch, toBranch);
+  }
+
+  public String getAutomergeLabel() {
+    return config.getAutomergeLabel();
+  }
+
+  public String getCodeReviewLabel() {
+    return config.getCodeReviewLabel();
+  }
+
+  public Set<String> getProjectsInScope(String fromBranch, String toBranch)
+      throws RestApiException, IOException {
+    try {
+      Set<String> projectSet = new HashSet<String>();
+
+      Set<String> fromProjectSet = getManifestProjects(fromBranch);
+      projectSet.addAll(fromProjectSet);
+
+      Set<String> toProjectSet = getManifestProjects(fromBranch, toBranch);
+      // Take intersection of project sets, unless one is empty.
+      if (projectSet.isEmpty()) {
+        projectSet = toProjectSet;
+      } else if (!toProjectSet.isEmpty()) {
+        projectSet.retainAll(toProjectSet);
+      }
+
+      // The lower the level a config is applied, the higher priority it has
+      // For example, a project ignored in the global config but added in the branch config will
+      // be added to the final project set, not ignored
+      applyConfig(projectSet, config.getGlobal());
+      applyConfig(projectSet, config.getMergeConfig(fromBranch));
+      applyConfig(projectSet, config.getMergeConfig(fromBranch, toBranch));
+
+      return projectSet;
+    } catch (RestApiException | IOException e) {
+      log.error("Error reading manifest for {}!", fromBranch, e);
+      throw e;
+    }
+  }
+
+  public Set<String> getDownstreamBranches(String fromBranch, String project)
+      throws RestApiException, IOException {
+    Set<String> downstreamBranches = new HashSet<String>();
+    Map<String, Map> fromBranchConfig = config.getMergeConfig(fromBranch);
+
+    if (fromBranchConfig != null) {
+      for (String key : fromBranchConfig.keySet()) {
+        if (!configOptionKeys.contains(key)) {
+          // If it's not a config option, then the key is the toBranch
+          Map<String, Object> toBranchConfig = (Map<String, Object>) fromBranchConfig.get(key);
+          Set<String> projectsInScope = getProjectsInScope(fromBranch, key);
+          if (projectsInScope.contains(project)) {
+            downstreamBranches.add(key);
+          }
+        }
+      }
+    }
+    return downstreamBranches;
+  }
+
+  // Returns overriden manifest config if specified, default if not
+  private Map<String, String> getManifestInfoFromConfig(Map<String, Object> configMap) {
+    if (configMap.containsKey("manifest")) {
+      return (Map<String, String>) configMap.get("manifest");
+    }
+    return config.getDefaultManifestInfo();
+  }
+
+  // Returns contents of manifest file for the given branch.
+  // If manifest does not exist, return empty set.
+  private Set<String> getManifestProjects(String fromBranch) throws RestApiException, IOException {
+    Map fromBranchConfig = config.getMergeConfig(fromBranch);
+    Map<String, String> manifestProjectInfo = getManifestInfoFromConfig(fromBranchConfig);
+    return getManifestProjectsForBranch(manifestProjectInfo, fromBranch);
+  }
+
+  // Returns contents of manifest file for the given branch pair
+  // If manifest does not exist, return empty set.
+  private Set<String> getManifestProjects(String fromBranch, String toBranch)
+      throws RestApiException, IOException {
+    Map<String, Object> toBranchConfig = config.getMergeConfig(fromBranch, toBranch);
+    Map<String, String> manifestProjectInfo = getManifestInfoFromConfig(toBranchConfig);
+    return getManifestProjectsForBranch(manifestProjectInfo, toBranch);
+  }
+
+  private Set<String> getManifestProjectsForBranch(
+      Map<String, String> manifestProjectInfo, String branch) throws RestApiException, IOException {
+    String manifestProject = manifestProjectInfo.get("project");
+    String manifestFile = manifestProjectInfo.get("file");
+    try {
+      BinaryResult manifestConfig =
+          gApi.projects().name(manifestProject).branch(branch).file(manifestFile);
+      ManifestReader manifestReader = new ManifestReader(branch, manifestConfig.asString());
+      return manifestReader.getProjects();
+    } catch (ResourceNotFoundException e) {
+      return new HashSet<>();
+    }
+  }
+
+  private void applyConfig(Set<String> projects, Map givenConfig) {
+    if (givenConfig.containsKey("set_projects")) {
+      List<String> setProjects = (ArrayList<String>) givenConfig.get("set_projects");
+      projects.clear();
+      projects.addAll(setProjects);
+      // if we set projects we can ignore the rest
+      return;
+    }
+    if (givenConfig.containsKey("add_projects")) {
+      List<String> addProjects = (List<String>) givenConfig.get("add_projects");
+      projects.addAll(addProjects);
+    }
+    if (givenConfig.containsKey("ignore_projects")) {
+      List<String> ignoreProjects = (List<String>) givenConfig.get("ignore_projects");
+      projects.removeAll(ignoreProjects);
+    }
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/DownstreamCreator.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/DownstreamCreator.java
new file mode 100644
index 0000000..1aeef47
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/DownstreamCreator.java
@@ -0,0 +1,445 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.common.base.Joiner;
+import com.google.gerrit.extensions.api.GerritApi;
+import com.google.gerrit.extensions.api.changes.AbandonInput;
+import com.google.gerrit.extensions.api.changes.ChangeApi;
+import com.google.gerrit.extensions.api.changes.NotifyHandling;
+import com.google.gerrit.extensions.api.changes.ReviewInput;
+import com.google.gerrit.extensions.api.changes.RestoreInput;
+import com.google.gerrit.extensions.client.ChangeStatus;
+import com.google.gerrit.extensions.client.ListChangesOption;
+import com.google.gerrit.extensions.common.ChangeInput;
+import com.google.gerrit.extensions.common.ChangeInfo;
+import com.google.gerrit.extensions.common.CommitInfo;
+import com.google.gerrit.extensions.common.MergeInput;
+import com.google.gerrit.extensions.common.MergePatchSetInput;
+import com.google.gerrit.extensions.common.RevisionInfo;
+import com.google.gerrit.extensions.events.ChangeAbandonedListener;
+import com.google.gerrit.extensions.events.ChangeMergedListener;
+import com.google.gerrit.extensions.events.ChangeRestoredListener;
+import com.google.gerrit.extensions.events.DraftPublishedListener;
+import com.google.gerrit.extensions.events.RevisionCreatedListener;
+import com.google.gerrit.extensions.events.TopicEditedListener;
+
+import com.google.gerrit.extensions.restapi.MergeConflictException;
+import com.google.gerrit.extensions.restapi.RestApiException;
+import com.google.gerrit.server.events.Event;
+import com.google.inject.Inject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.IOException;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.List;
+import java.util.ArrayList;
+import java.util.UUID;
+
+public class DownstreamCreator
+    implements ChangeAbandonedListener,
+        ChangeMergedListener,
+        ChangeRestoredListener,
+        DraftPublishedListener,
+        RevisionCreatedListener,
+        TopicEditedListener {
+  private static final Logger log = LoggerFactory.getLogger(DownstreamCreator.class);
+
+  protected GerritApi gApi;
+  protected ConfigLoader config;
+
+  @Inject
+  public DownstreamCreator(GerritApi gApi, ConfigLoader config) {
+    this.gApi = gApi;
+    this.config = config;
+  }
+
+  private void loadConfig() throws IOException, RestApiException {
+    try {
+      config.loadConfig();
+    } catch (IOException | RestApiException e) {
+      log.error("Config failed to sync!", e);
+      throw e;
+    }
+  }
+
+  @Override
+  public void onChangeMerged(ChangeMergedListener.Event event) {
+    ChangeInfo change = event.getChange();
+    try {
+      if (change.project.equals(config.configProject)
+          && change.branch.equals(config.configProjectBranch)) {
+        loadConfig();
+      }
+    } catch (RestApiException | IOException e) {
+      log.error("Failed to reload config at {}", change.id, e);
+    }
+  }
+
+  @Override
+  public void onChangeAbandoned(ChangeAbandonedListener.Event event) {
+    ChangeInfo change = event.getChange();
+    String revision = event.getRevision().commit.commit;
+    log.info("Detected revision {} abandoned on {}.", revision, change.project);
+    abandonDownstream(change, revision);
+  }
+
+  private void abandonDownstream(ChangeInfo change, String revision) {
+    try {
+      Set<String> downstreamBranches = config.getDownstreamBranches(change.branch, change.project);
+      if (downstreamBranches.isEmpty()) {
+        log.info("Downstream branches of {} on {} are empty", change.branch, change.project);
+        return;
+      }
+
+      for (String downstreamBranch : downstreamBranches) {
+        List<Integer> existingDownstream =
+            getExistingMergesOnBranch(revision, change.topic, downstreamBranch);
+        log.info("Abandoning existing downstreams: {}", existingDownstream);
+        for (Integer changeNumber : existingDownstream) {
+          abandonChange(changeNumber);
+        }
+      }
+    } catch (RestApiException | IOException e) {
+      log.error("Failed to abandon downstreams of {}", change.id, e);
+    }
+  }
+
+  @Override
+  public void onTopicEdited(TopicEditedListener.Event event) {
+    ChangeInfo change = event.getChange();
+    String oldTopic = event.getOldTopic();
+    try {
+      String revision =
+          gApi.changes()
+              .id(change.id)
+              .get(EnumSet.of(ListChangesOption.CURRENT_REVISION))
+              .currentRevision;
+      Set<String> downstreamBranches = config.getDownstreamBranches(change.branch, change.project);
+
+      if (downstreamBranches.isEmpty()) {
+        log.info("Downstream branches of {} on {} are empty", change.branch, change.project);
+        return;
+      }
+
+      for (String downstreamBranch : downstreamBranches) {
+        List<Integer> existingDownstream =
+            getExistingMergesOnBranch(revision, oldTopic, downstreamBranch);
+        for (Integer changeNumber : existingDownstream) {
+          log.info("Setting topic {} on {}", change.topic, changeNumber);
+          gApi.changes().id(changeNumber).topic(change.topic);
+        }
+      }
+    } catch (RestApiException | IOException e) {
+      log.error("Failed to edit downstream topics of {}", change.id, e);
+    }
+  }
+
+  @Override
+  public void onChangeRestored(ChangeRestoredListener.Event event) {
+    ChangeInfo change = event.getChange();
+    try {
+      automergeChanges(change, event.getRevision());
+    } catch (RestApiException | IOException e) {
+      log.error("Failed to edit downstream topics of {}", change.id, e);
+    }
+  }
+
+  @Override
+  public void onDraftPublished(DraftPublishedListener.Event event) {
+    ChangeInfo change = event.getChange();
+    try {
+      automergeChanges(change, event.getRevision());
+    } catch (RestApiException | IOException e) {
+      log.error("Failed to edit downstream topics of {}", change.id, e);
+    }
+  }
+
+  @Override
+  public void onRevisionCreated(RevisionCreatedListener.Event event) {
+    ChangeInfo change = event.getChange();
+    try {
+      automergeChanges(change, event.getRevision());
+    } catch (RestApiException | IOException e) {
+      log.error("Failed to edit downstream topics of {}", change.id, e);
+    }
+  }
+
+  private void automergeChanges(ChangeInfo change, RevisionInfo revisionInfo)
+      throws RestApiException, IOException {
+    if (revisionInfo.draft != null && revisionInfo.draft) {
+      log.info("Patchset {} is draft change, ignoring.", revisionInfo.commit.commit);
+      return;
+    }
+
+    String currentRevision = revisionInfo.commit.commit;
+    log.info(
+        "Handling patchsetevent with change id {} and revision {}", change.id, currentRevision);
+
+    Set<String> downstreamBranches = config.getDownstreamBranches(change.branch, change.project);
+
+    if (downstreamBranches.isEmpty()) {
+      log.info("Downstream branches of {} on {} are empty", change.branch, change.project);
+      return;
+    }
+
+    // Map whether or not we should merge it or skip it for each downstream
+    Map<String, Boolean> dsBranchMap = new HashMap<String, Boolean>();
+    for (String downstreamBranch : downstreamBranches) {
+      boolean isSkipMerge = config.isSkipMerge(change.branch, downstreamBranch, change.subject);
+      dsBranchMap.put(downstreamBranch, !isSkipMerge);
+    }
+    log.info("Automerging change {} from branch {}", change.id, change.branch);
+
+    ChangeApi currentChange = gApi.changes().id(change._number);
+    String previousRevision = getPreviousRevision(currentChange, revisionInfo._number);
+
+    MultipleDownstreamMergeInput mdsMergeInput = new MultipleDownstreamMergeInput();
+    mdsMergeInput.dsBranchMap = dsBranchMap;
+    mdsMergeInput.sourceId = change.id;
+    mdsMergeInput.project = change.project;
+    mdsMergeInput.topic = change.topic;
+    mdsMergeInput.subject = change.subject;
+    mdsMergeInput.obsoleteRevision = previousRevision;
+    mdsMergeInput.currentRevision = currentRevision;
+
+    createMergesAndHandleConflicts(mdsMergeInput);
+  }
+
+  public void createMergesAndHandleConflicts(MultipleDownstreamMergeInput mdsMergeInput)
+      throws RestApiException {
+    ReviewInput reviewInput = new ReviewInput();
+    Map<String, Short> labels = new HashMap<String, Short>();
+    short vote = 0;
+    try {
+      createDownstreamMerges(mdsMergeInput);
+
+      reviewInput.message =
+          "Automerging to "
+              + Joiner.on(", ").join(mdsMergeInput.dsBranchMap.keySet())
+              + " succeeded!";
+      reviewInput.notify = NotifyHandling.NONE;
+      vote = 1;
+    } catch (FailedMergeException e) {
+      reviewInput.message = e.displayConflicts();
+      reviewInput.notify = NotifyHandling.ALL;
+      vote = -1;
+    }
+    labels.put(config.getAutomergeLabel(), vote);
+    reviewInput.labels = labels;
+    gApi.changes()
+        .id(mdsMergeInput.sourceId)
+        .revision(mdsMergeInput.currentRevision)
+        .review(reviewInput);
+  }
+
+  public void createDownstreamMerges(MultipleDownstreamMergeInput mdsMergeInput)
+      throws RestApiException, FailedMergeException {
+    Map<String, String> failedMerges = new HashMap<String, String>();
+
+    List<Integer> existingDownstream;
+    for (String downstreamBranch : mdsMergeInput.dsBranchMap.keySet()) {
+      // If there are existing downstream merges, update them
+      // Otherwise, create them.
+      try {
+        boolean createDownstreams = true;
+        if (mdsMergeInput.obsoleteRevision != null) {
+          existingDownstream =
+              getExistingMergesOnBranch(
+                  mdsMergeInput.obsoleteRevision, mdsMergeInput.topic, downstreamBranch);
+          if (!existingDownstream.isEmpty()) {
+            log.info(
+                "Attempting to update downstream merge of {} on branch {}",
+                mdsMergeInput.currentRevision,
+                downstreamBranch);
+            // existingDownstream should almost always be of length one, but
+            // it's possible to construct it so that it's not
+            for (Integer dsChangeNumber : existingDownstream) {
+              updateDownstreamMerge(
+                  mdsMergeInput.currentRevision,
+                  mdsMergeInput.subject,
+                  dsChangeNumber,
+                  mdsMergeInput.dsBranchMap.get(downstreamBranch));
+              createDownstreams = false;
+            }
+          }
+        }
+        if (createDownstreams) {
+          log.info(
+              "Attempting to create downstream merge of {} on branch {}",
+              mdsMergeInput.currentRevision,
+              downstreamBranch);
+          SingleDownstreamMergeInput sdsMergeInput = new SingleDownstreamMergeInput();
+          sdsMergeInput.currentRevision = mdsMergeInput.currentRevision;
+          sdsMergeInput.sourceId = mdsMergeInput.sourceId;
+          sdsMergeInput.project = mdsMergeInput.project;
+          sdsMergeInput.topic = mdsMergeInput.topic;
+          sdsMergeInput.subject = mdsMergeInput.subject;
+          sdsMergeInput.downstreamBranch = downstreamBranch;
+          sdsMergeInput.doMerge = mdsMergeInput.dsBranchMap.get(downstreamBranch);
+          createSingleDownstreamMerge(sdsMergeInput);
+        }
+      } catch (MergeConflictException e) {
+        log.info("Merge conflict from {} to {}", mdsMergeInput.currentRevision, downstreamBranch);
+        failedMerges.put(downstreamBranch, e.getMessage());
+        log.info("Abandoning downstream of {}", mdsMergeInput.sourceId);
+        abandonDownstream(
+            gApi.changes().id(mdsMergeInput.sourceId).info(), mdsMergeInput.currentRevision);
+      }
+    }
+
+    if (!failedMerges.keySet().isEmpty()) {
+      throw new FailedMergeException(failedMerges);
+    }
+  }
+
+  // get change ids of immediate downstream changes of the revision on branch
+  public List<Integer> getExistingMergesOnBranch(
+      String upstreamRevision, String topic, String downstreamBranch) throws RestApiException {
+    List<Integer> downstreamChangeNumbers = new ArrayList<Integer>();
+    // get changes in same topic and check if their parent is upstreamRevision
+    String query = "topic:" + topic + " status:open branch:" + downstreamBranch;
+    List<ChangeInfo> changes =
+        gApi.changes()
+            .query(query)
+            .withOptions(ListChangesOption.ALL_REVISIONS, ListChangesOption.CURRENT_COMMIT)
+            .get();
+
+    for (ChangeInfo change : changes) {
+      String changeRevision = change.currentRevision;
+      RevisionInfo revision = change.revisions.get(changeRevision);
+      List<CommitInfo> parents = revision.commit.parents;
+      if (parents.size() > 1) {
+        String secondParent = parents.get(1).commit;
+        if (secondParent.equals(upstreamRevision)) {
+          downstreamChangeNumbers.add(change._number);
+        }
+      }
+    }
+    return downstreamChangeNumbers;
+  }
+
+  private void updateDownstreamMerge(
+      String newParentRevision, String upstreamSubject, Integer sourceNum, boolean doMerge)
+      throws RestApiException {
+    MergeInput mergeInput = new MergeInput();
+    mergeInput.source = newParentRevision;
+
+    MergePatchSetInput mergePatchSetInput = new MergePatchSetInput();
+    mergePatchSetInput.subject = upstreamSubject + " am: " + newParentRevision.substring(0, 10);
+    if (!doMerge) {
+      mergeInput.strategy = "ours";
+      mergePatchSetInput.subject =
+          upstreamSubject + " skipped: " + newParentRevision.substring(0, 10);
+      log.info("Skipping merge for {} on {}", newParentRevision, sourceNum);
+    }
+    mergePatchSetInput.merge = mergeInput;
+
+    ChangeApi originalChange = gApi.changes().id(sourceNum);
+
+    if (originalChange.info().status == ChangeStatus.ABANDONED) {
+      RestoreInput restoreInput = new RestoreInput();
+      restoreInput.message = "Restoring change due to upstream automerge.";
+      originalChange.restore(restoreInput);
+    }
+
+    ChangeInfo updatedChange = originalChange.createMergePatchSet(mergePatchSetInput);
+    ChangeApi updatedChangeApi = gApi.changes().id(updatedChange.id);
+    givePlusTwo(updatedChangeApi);
+  }
+
+  public void createSingleDownstreamMerge(SingleDownstreamMergeInput sdsMergeInput)
+      throws RestApiException {
+
+    String currentTopic = setTopic(sdsMergeInput.sourceId, sdsMergeInput.topic);
+
+    MergeInput mergeInput = new MergeInput();
+    mergeInput.source = sdsMergeInput.currentRevision;
+
+    log.info("Creating downstream merge for {}", sdsMergeInput.currentRevision);
+    ChangeInput downstreamChangeInput = new ChangeInput();
+    downstreamChangeInput.project = sdsMergeInput.project;
+    downstreamChangeInput.branch = sdsMergeInput.downstreamBranch;
+    downstreamChangeInput.subject =
+        sdsMergeInput.subject + " am: " + sdsMergeInput.currentRevision.substring(0, 10);
+    downstreamChangeInput.topic = currentTopic;
+    downstreamChangeInput.merge = mergeInput;
+
+    if (!sdsMergeInput.doMerge) {
+      mergeInput.strategy = "ours";
+      downstreamChangeInput.subject =
+          sdsMergeInput.subject + " skipped: " + sdsMergeInput.currentRevision.substring(0, 10);
+      log.info(
+          "Skipping merge for {} to {}",
+          sdsMergeInput.currentRevision,
+          sdsMergeInput.downstreamBranch);
+    }
+
+    ChangeApi newChangeApi = gApi.changes().create(downstreamChangeInput);
+    givePlusTwo(newChangeApi);
+  }
+
+  private void givePlusTwo(ChangeApi downstreamChange) throws RestApiException {
+    log.info("Giving +2 to {}", downstreamChange.id());
+    // Vote +2 on all downstream branches unless merge conflict.
+    ReviewInput reviewInput = new ReviewInput();
+    ChangeInfo newChange = downstreamChange.get(EnumSet.of(ListChangesOption.CURRENT_REVISION));
+    short codeReviewVote = 2;
+    Map<String, Short> labels = new HashMap<String, Short>();
+    labels.put(config.getCodeReviewLabel(), codeReviewVote);
+    reviewInput.labels = labels;
+    gApi.changes().id(newChange.id).revision(newChange.currentRevision).review(reviewInput);
+  }
+
+  private String getPreviousRevision(ChangeApi change, int currentPatchSetNumber)
+      throws RestApiException {
+    String previousRevision = null;
+    int maxPatchSetNum = 0;
+    if (currentPatchSetNumber > 1) {
+      // Get sha of patch set with highest number we can see
+      Map<String, RevisionInfo> revisionMap =
+          change.get(EnumSet.of(ListChangesOption.ALL_REVISIONS)).revisions;
+      for (Map.Entry<String, RevisionInfo> revisionEntry : revisionMap.entrySet()) {
+        int revisionPatchNumber = revisionEntry.getValue()._number;
+        if (revisionPatchNumber > maxPatchSetNum && revisionPatchNumber < currentPatchSetNumber) {
+          previousRevision = revisionEntry.getKey();
+          maxPatchSetNum = revisionPatchNumber;
+        }
+      }
+    }
+    return previousRevision;
+  }
+
+  private void abandonChange(Integer changeNumber) throws RestApiException {
+    log.info("Abandoning change: {}", changeNumber);
+    AbandonInput abandonInput = new AbandonInput();
+    abandonInput.notify = NotifyHandling.NONE;
+    abandonInput.message = "Merge parent updated; abandoning due to upstream conflict.";
+    gApi.changes().id(changeNumber).abandon(abandonInput);
+  }
+
+  private String setTopic(String sourceId, String topic) throws RestApiException {
+    if (topic == null || topic.isEmpty()) {
+      topic = "am-" + UUID.randomUUID().toString();
+      log.info("Setting original change {} topic to {}", sourceId, topic);
+      gApi.changes().id(sourceId).topic(topic);
+    }
+    return topic;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/FailedMergeException.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/FailedMergeException.java
new file mode 100644
index 0000000..78c59cc
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/FailedMergeException.java
@@ -0,0 +1,58 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.common.base.Joiner;
+
+import java.util.Map;
+
+class FailedMergeException extends Exception {
+  private static final int MAX_CONFLICT_MESSAGE_LENGTH = 10000;
+
+  public final Map<String, String> failedMerges;
+
+  FailedMergeException(Map<String, String> failedMerges) {
+    this.failedMerges = failedMerges;
+  }
+
+  public String displayConflicts() {
+    StringBuilder output = new StringBuilder();
+    output.append("Merge conflict found on ");
+    output.append(failedMergeKeys());
+    output.append(". Please follow instructions at go/resolveconflict ");
+    output.append("to resolve this merge conflict.\n\n");
+
+    for (Map.Entry<String, String> entry : failedMerges.entrySet()) {
+      String branch = entry.getKey();
+      String message = entry.getValue();
+      String conflictMessage = message;
+      boolean truncated = false;
+      if (message.length() > MAX_CONFLICT_MESSAGE_LENGTH) {
+        conflictMessage = message.substring(0, MAX_CONFLICT_MESSAGE_LENGTH);
+        truncated = true;
+      }
+      output.append(branch);
+      output.append(":\n");
+      output.append(conflictMessage);
+      if (truncated) {
+        output.append("...\n\n");
+      }
+    }
+    return output.toString();
+  }
+
+  public String failedMergeKeys() {
+    return Joiner.on(", ").join(failedMerges.keySet());
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/HttpModule.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/HttpModule.java
new file mode 100644
index 0000000..a9d82fe
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/HttpModule.java
@@ -0,0 +1,26 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.extensions.webui.JavaScriptPlugin;
+import com.google.gerrit.extensions.webui.WebUiPlugin;
+import com.google.gerrit.httpd.plugins.HttpPluginModule;
+
+public class HttpModule extends HttpPluginModule {
+  @Override
+  protected void configureServlets() {
+    DynamicSet.bind(binder(), WebUiPlugin.class).toInstance(new JavaScriptPlugin("automerger.js"));
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/LoadedConfig.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/LoadedConfig.java
new file mode 100644
index 0000000..51ea025
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/LoadedConfig.java
@@ -0,0 +1,136 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.common.base.Joiner;
+import com.google.gerrit.extensions.api.GerritApi;
+import com.google.gerrit.extensions.restapi.BinaryResult;
+import com.google.gerrit.extensions.restapi.RestApiException;
+import com.google.re2j.Pattern;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.yaml.snakeyaml.Yaml;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+
+public class LoadedConfig {
+  private static final Logger log = LoggerFactory.getLogger(LoadedConfig.class);
+
+  private final Map<String, Object> global;
+  private final Map<String, Map> config;
+  private final Map<String, String> defaultManifestInfo;
+  private final Pattern blankMergePattern;
+  private final Pattern alwaysBlankMergePattern;
+
+  public LoadedConfig() {
+    global = Collections.emptyMap();
+    config = Collections.emptyMap();
+    defaultManifestInfo = Collections.emptyMap();
+    blankMergePattern = Pattern.compile("");
+    alwaysBlankMergePattern = Pattern.compile("");
+  }
+
+  public LoadedConfig(
+      GerritApi gApi,
+      String configProject,
+      String configProjectBranch,
+      String configFilename,
+      List<String> configOptionKeys)
+      throws IOException, RestApiException {
+    log.info(
+        "Loading config file from project {} on branch {} and filename {}",
+        configProject,
+        configProjectBranch,
+        configFilename);
+    BinaryResult configFile =
+        gApi.projects().name(configProject).branch(configProjectBranch).file(configFilename);
+    String configFileString = configFile.asString();
+    config = (Map<String, Map>) (new Yaml().load(configFileString));
+    global = (Map<String, Object>) config.get("global");
+    defaultManifestInfo = (Map<String, String>) global.get("manifest");
+
+    blankMergePattern = getConfigPattern("blank_merge");
+    alwaysBlankMergePattern = getConfigPattern("always_blank_merge");
+    log.info("Finished syncing automerger config.");
+  }
+
+  private Pattern getConfigPattern(String key) {
+    Set<String> mergeStrings = new HashSet<String>((List<String>) global.get(key));
+    return Pattern.compile(Joiner.on("|").join(mergeStrings), Pattern.DOTALL);
+  }
+
+  public boolean isSkipMerge(String fromBranch, String toBranch, String commitMessage) {
+    // If regex matches always_blank_merge (DO NOT MERGE ANYWHERE), skip.
+    if (alwaysBlankMergePattern.matches(commitMessage)) {
+      return true;
+    }
+
+    // If regex matches blank_merge (DO NOT MERGE), skip iff merge_all is false
+    if (blankMergePattern.matches(commitMessage)) {
+      Map<String, Object> mergePairConfig = getMergeConfig(fromBranch, toBranch);
+      if (mergePairConfig != null) {
+        boolean isMergeAll = (boolean) mergePairConfig.getOrDefault("merge_all", false);
+        return !isMergeAll;
+      }
+    }
+    return false;
+  }
+
+  public Map<String, Map> getMergeConfig(String fromBranch) {
+    return getBranches().get(fromBranch);
+  }
+
+  public Map<String, Object> getMergeConfig(String fromBranch, String toBranch) {
+    Map<String, Map> fromBranchConfig = getBranches().get(fromBranch);
+    if (fromBranchConfig == null) {
+      return Collections.emptyMap();
+    }
+    return (Map<String, Object>) fromBranchConfig.get(toBranch);
+  }
+
+  public Map<String, Map> getBranches() {
+    return (Map<String, Map>) config.get("branches");
+  }
+
+  public Map<String, Object> getGlobal() {
+    return global;
+  }
+
+  public Map<String, String> getDefaultManifestInfo() {
+    return defaultManifestInfo;
+  }
+
+  public String getAutomergeLabel() {
+    return (String) global.getOrDefault("automerge_label", "Verified");
+  }
+
+  public String getCodeReviewLabel() {
+    return (String) global.getOrDefault("code_review_label", "Code-Review");
+  }
+
+  public Object getGlobalAttribute(String key) {
+    return global.get(key);
+  }
+
+  public Object getGlobalAttributeOrDefault(String key, Object def) {
+    return global.getOrDefault(key, def);
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/ManifestReader.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/ManifestReader.java
new file mode 100644
index 0000000..70f3fcd
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/ManifestReader.java
@@ -0,0 +1,82 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.w3c.dom.Document;
+import org.w3c.dom.Element;
+import org.w3c.dom.Node;
+import org.w3c.dom.NodeList;
+import org.xml.sax.InputSource;
+import org.xml.sax.SAXException;
+
+import javax.xml.parsers.DocumentBuilder;
+import javax.xml.parsers.DocumentBuilderFactory;
+import javax.xml.parsers.ParserConfigurationException;
+import java.io.IOException;
+import java.io.StringReader;
+import java.util.HashSet;
+import java.util.Set;
+
+public class ManifestReader {
+  private static final Logger log = LoggerFactory.getLogger(ManifestReader.class);
+
+  private final String manifestString;
+  private final String branch;
+
+  public ManifestReader(String branch, String manifestString) {
+    this.manifestString = manifestString;
+    this.branch = branch;
+  }
+
+  public Set<String> getProjects() {
+    Set<String> projectSet = new HashSet<String>();
+
+    try {
+      DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
+      DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
+      Document document = documentBuilder.parse(new InputSource(new StringReader(manifestString)));
+
+      Element defaultElement = (Element) document.getElementsByTagName("default").item(0);
+      String defaultRevision = defaultElement.getAttribute("revision");
+
+      NodeList projectNodes = document.getElementsByTagName("project");
+      for (int i = 0; i < projectNodes.getLength(); i++) {
+        Node projectNode = projectNodes.item(i);
+        if (projectNode.getNodeType() == Node.ELEMENT_NODE) {
+          Element projectElement = (Element) projectNode;
+          String path = projectElement.getAttribute("path");
+          String name = projectElement.getAttribute("name");
+
+          String revision = projectElement.getAttribute("revision");
+          if ("".equals(revision)) {
+            revision = defaultRevision;
+          }
+
+          // Only add to list of projects in scope if revision is same as
+          // manifest branch
+          if (revision.equals(branch)) {
+            projectSet.add(name);
+          }
+        }
+      }
+
+    } catch (SAXException | ParserConfigurationException | IOException e) {
+      log.error("Exception on manifest for branch {}", branch, e);
+    }
+    return projectSet;
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/Module.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/Module.java
new file mode 100644
index 0000000..951a7b4
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/Module.java
@@ -0,0 +1,43 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.gerrit.extensions.events.*;
+import com.google.gerrit.extensions.registration.DynamicSet;
+import com.google.gerrit.extensions.restapi.RestApiModule;
+import com.google.inject.AbstractModule;
+
+import static com.google.gerrit.server.change.RevisionResource.REVISION_KIND;
+
+public class Module extends AbstractModule {
+
+  @Override
+  protected void configure() {
+    DynamicSet.bind(binder(), ChangeAbandonedListener.class).to(DownstreamCreator.class);
+    DynamicSet.bind(binder(), ChangeMergedListener.class).to(DownstreamCreator.class);
+    DynamicSet.bind(binder(), ChangeRestoredListener.class).to(DownstreamCreator.class);
+    DynamicSet.bind(binder(), DraftPublishedListener.class).to(DownstreamCreator.class);
+    DynamicSet.bind(binder(), RevisionCreatedListener.class).to(DownstreamCreator.class);
+    DynamicSet.bind(binder(), TopicEditedListener.class).to(DownstreamCreator.class);
+    install(
+        new RestApiModule() {
+          @Override
+          protected void configure() {
+            post(REVISION_KIND, "automerge-change").to(AutomergeChangeAction.class);
+            post(REVISION_KIND, "config-downstream").to(ConfigDownstreamAction.class);
+          }
+        });
+  }
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/MultipleDownstreamMergeInput.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/MultipleDownstreamMergeInput.java
new file mode 100644
index 0000000..6bf7cdf
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/MultipleDownstreamMergeInput.java
@@ -0,0 +1,27 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import java.util.Map;
+
+public class MultipleDownstreamMergeInput {
+  public Map<String, Boolean> dsBranchMap;
+  public String sourceId;
+  public String project;
+  public String topic;
+  public String subject;
+  public String obsoleteRevision;
+  public String currentRevision;
+}
diff --git a/src/main/java/com/googlesource/gerrit/plugins/automerger/SingleDownstreamMergeInput.java b/src/main/java/com/googlesource/gerrit/plugins/automerger/SingleDownstreamMergeInput.java
new file mode 100644
index 0000000..f565a7c
--- /dev/null
+++ b/src/main/java/com/googlesource/gerrit/plugins/automerger/SingleDownstreamMergeInput.java
@@ -0,0 +1,25 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+public class SingleDownstreamMergeInput {
+  public String currentRevision;
+  public String sourceId;
+  public String project;
+  public String topic;
+  public String subject;
+  public String downstreamBranch;
+  public boolean doMerge;
+}
diff --git a/src/main/resources/Documentation/about.md b/src/main/resources/Documentation/about.md
new file mode 100644
index 0000000..dc9aa32
--- /dev/null
+++ b/src/main/resources/Documentation/about.md
@@ -0,0 +1,21 @@
+Plugin to allow automatically merging changes from one branch to another based
+on a config file.
+
+When the plugin detects a patchset has been created, it will
+merge downstream until it hits a merge conflict. On the
+conflicting merge, it will vote -1 on a configurable label
+and provide instructions to resolving the merge conflict.
+
+Draft changes will be ignored until published.
+
+The plugin will put all the auto-created changes in the
+same topic as the original change (or create a topic if
+none exists). If a user updates the topic, it will update
+the topic of all the downstream merges.
+
+If there are existing downstream merges from a previous
+automerged patchset, it will update them all.
+
+A UI button "Recreate automerges" has been added so that users can skip
+downstream merges. Unchecking a branch's checkbox will skip that branch and
+all automerges downstream of that branch.
\ No newline at end of file
diff --git a/src/main/resources/Documentation/build.md b/src/main/resources/Documentation/build.md
new file mode 100644
index 0000000..24145f3
--- /dev/null
+++ b/src/main/resources/Documentation/build.md
@@ -0,0 +1,74 @@
+Build
+=====
+
+This plugin can be built with Buck.
+
+Buck
+----
+
+Two build modes are supported: Standalone and in Gerrit tree.
+The standalone build mode is recommended, as this mode doesn't require
+the Gerrit tree to exist locally.
+
+
+### Build standalone
+
+Clone bucklets library:
+
+```
+  git clone https://gerrit.googlesource.com/bucklets
+
+```
+and link it to automerger plugin directory:
+
+```
+  cd automerger && ln -s ../bucklets .
+```
+
+Add link to the .buckversion file:
+
+```
+  cd automerger && ln -s bucklets/buckversion .buckversion
+```
+
+Add link to the .watchmanconfig file:
+```
+  cd automerger && ln -s bucklets/watchmanconfig .watchmanconfig
+```
+
+To build the plugin, issue the following command:
+
+
+```
+  buck build plugin
+```
+
+The output is created in
+
+```
+  buck-out/gen/automerger.jar
+```
+
+### Build in Gerrit tree
+
+Clone or link this plugin to the plugins directory of Gerrit's source
+tree, and issue the command:
+
+```
+  buck build plugins/automerger
+```
+
+The output is created in
+
+```
+  buck-out/gen/plugins/automerger/automerger.jar
+```
+
+This project can be imported into the Eclipse IDE:
+
+```
+  ./tools/eclipse/project.py
+```
+
+How to build the Gerrit Plugin API is described in the [Gerrit
+documentation](../../../Documentation/dev-buck.html#_extension_and_plugin_api_jar_files).
diff --git a/src/main/resources/Documentation/rest-api-automerge-change.md b/src/main/resources/Documentation/rest-api-automerge-change.md
new file mode 100644
index 0000000..f2fe9cc
--- /dev/null
+++ b/src/main/resources/Documentation/rest-api-automerge-change.md
@@ -0,0 +1,37 @@
+@PLUGIN@ automerge-change
+=============================
+
+NAME
+----
+automerge-change - Automerge a change downstream
+
+SYNOPSIS
+--------
+>     POST /projects/{project-name}/@PLUGIN@~automerge-change
+
+DESCRIPTION
+-----------
+Returns an HTTP 204 if successful.
+
+OPTIONS
+-------
+--branch_map
+> A map of downstream branches to their merge value (false means it is skipped)
+
+REQUEST
+-----------
+```
+  POST /projects/{project-name}/@PLUGIN@~automerge-change HTTP/1.0
+  Content-Type application/json;charset=UTF-8
+
+  {
+    "master": true,
+    "branch_two": false
+  }
+```
+
+RESPONSE
+-----------
+```
+  HTTP/1.1 204 No Content
+```
diff --git a/src/main/resources/Documentation/rest-api-config-downstream.md b/src/main/resources/Documentation/rest-api-config-downstream.md
new file mode 100644
index 0000000..45be612
--- /dev/null
+++ b/src/main/resources/Documentation/rest-api-config-downstream.md
@@ -0,0 +1,45 @@
+@PLUGIN@ config-downstream
+=============================
+
+NAME
+----
+config-downstream - Get the downstream config map
+
+SYNOPSIS
+--------
+>     POST /projects/{project-name}/@PLUGIN@~config-downstream
+
+DESCRIPTION
+-----------
+Returns a map of branches that are one hop downstream to whether or not it
+should be skipped by default.
+
+OPTIONS
+-------
+
+--subject
+> The subject of the current change
+
+REQUEST
+-----------
+```
+  POST /projects/{project-name}/@PLUGIN@~config-downstream HTTP/1.0
+  Content-Type application/json;charset=UTF-8
+
+  {
+    "subject": "DO NOT MERGE i am a test subject"
+  }
+```
+
+RESPONSE
+-----------
+```
+  HTTP/1.1 200 OK
+  Content-Disposition: attachment
+  Content-Type: application/json;charset=UTF-8
+  )]}'
+  {
+    "master": true,
+    "branch_two": false
+  }
+```
diff --git a/src/main/resources/config/config_keys.yaml b/src/main/resources/config/config_keys.yaml
new file mode 100644
index 0000000..6008124
--- /dev/null
+++ b/src/main/resources/config/config_keys.yaml
@@ -0,0 +1,14 @@
+config_project: tools/automerger
+config_project_branch: master
+config_filename: config.yaml
+global_keys:
+- always_blank_merge
+- blank_merge
+- manifest
+config_option_keys:
+- manifest
+- merge_all
+- merge_manifest
+- set_projects
+- ignore_projects
+- add_projects
\ No newline at end of file
diff --git a/src/main/resources/static/automerger.js b/src/main/resources/static/automerger.js
new file mode 100644
index 0000000..f6a3b5b
--- /dev/null
+++ b/src/main/resources/static/automerger.js
@@ -0,0 +1,93 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+var currentChange;
+var downstreamConfigMap;
+Gerrit.install(function(self) {
+
+    function onAutomergeChange(c) {
+        addCheckboxes(c, downstreamConfigMap);
+    }
+
+    function addCheckboxes(c, downstreamConfigMap) {
+        var branchToCheckbox = {};
+        var downstreamConfigBranches = Object.keys(downstreamConfigMap);
+        // Initialize checkboxes for each downstream branch
+        downstreamConfigBranches.forEach(function(branch) {
+            var checkbox = c.checkbox();
+            if (downstreamConfigMap[branch])
+                checkbox.checked = true;
+            branchToCheckbox[branch] = c.label(checkbox, branch);
+        });
+
+        //Add checkboxes to box for each downstream branch
+        var checkboxes = [];
+        Object.keys(branchToCheckbox).forEach(function(branch) {
+            checkboxes.push(branchToCheckbox[branch])
+            checkboxes.push(c.br());
+        });
+        // Create actual merge button
+        var b = createMergeButton(c, branchToCheckbox);
+        var popupElements = checkboxes.concat(b);
+        c.popup(c.div.apply(this, popupElements));
+        return branchToCheckbox;
+    }
+
+    function createMergeButton(c, branchToCheckbox) {
+        return c.button('Merge', {onclick: function(){
+            var branchMap = {};
+            Object.keys(branchToCheckbox).forEach(function(key){
+                branchMap[key] = branchToCheckbox[key].firstChild.checked;
+            });
+            // gerrit converts to camelcase on the java end
+            c.call({'branch_map': branchMap},
+                function(r){ Gerrit.refresh(); });
+        }});
+    }
+
+    function styleRelatedChanges() {
+        document.querySelectorAll('[data-branch]').forEach(function(relChange) {
+            var relatedBranch = relChange.dataset.branch;
+            if (relatedBranch == currentChange.branch) {
+                relChange.style.fontWeight = 'bold';
+            } else {
+                relChange.style.fontWeight = '';
+            }
+            if (relChange.innerText.includes('[skipped')) {
+                relChange.parentNode.style.backgroundColor = 'lightGray';
+            }
+        })
+    }
+
+    function getDownstreamConfigMap() {
+        var changeId = currentChange.id;
+        var revisionId = currentChange.current_revision;
+        var url = `/changes/${changeId}/revisions/${revisionId}` +
+                   `/automerger~config-downstream`;
+        Gerrit.post(
+            url, {'subject': currentChange.subject},
+            function(resp) {
+                downstreamConfigMap = resp;
+                styleRelatedChanges();
+            });
+    }
+
+    function onShowChange(e) {
+        currentChange = e;
+        getDownstreamConfigMap();
+    }
+
+    self.onAction('revision', 'automerge-change', onAutomergeChange);
+    Gerrit.on('showchange', onShowChange);
+});
\ No newline at end of file
diff --git a/src/test/java/com/googlesource/gerrit/plugins/automerger/ConfigLoaderTest.java b/src/test/java/com/googlesource/gerrit/plugins/automerger/ConfigLoaderTest.java
new file mode 100644
index 0000000..92c9391
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/automerger/ConfigLoaderTest.java
@@ -0,0 +1,151 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.common.base.Charsets;
+import com.google.common.io.CharStreams;
+import com.google.gerrit.extensions.api.GerritApi;
+import com.google.gerrit.extensions.restapi.RestApiException;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.Mockito;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.HashSet;
+import java.util.Set;
+
+import static com.google.common.truth.Truth.assertThat;
+
+public class ConfigLoaderTest {
+  protected GerritApi gApiMock;
+  private ConfigLoader configLoader;
+  private String configString;
+  private String manifestString;
+  private String firstDownstreamManifestString;
+  private String secondDownstreamManifestString;
+
+  @Before
+  public void setUp() throws Exception {
+    gApiMock = Mockito.mock(GerritApi.class, Mockito.RETURNS_DEEP_STUBS);
+    mockFile("config.yaml", "tools/automerger", "master", "config.yaml");
+    mockFile("default.xml", "platform/manifest", "master", "default.xml");
+    mockFile("ds_one.xml", "platform/manifest", "ds_one", "default.xml");
+    mockFile("ds_two.xml", "platform/manifest", "ds_two", "default.xml");
+  }
+
+  private void mockFile(String resourceName, String projectName, String branchName, String filename)
+      throws Exception {
+    try (InputStream in = getClass().getResourceAsStream(resourceName)) {
+      String resourceString = CharStreams.toString(new InputStreamReader(in, Charsets.UTF_8));
+      Mockito.when(
+              gApiMock.projects().name(projectName).branch(branchName).file(filename).asString())
+          .thenReturn(resourceString);
+    }
+  }
+
+  private void loadConfig() throws Exception {
+    configLoader = new ConfigLoader(gApiMock);
+  }
+
+  @Test
+  public void getProjectsInScopeTest_addProjects() throws Exception {
+    loadConfig();
+    Set<String> expectedProjects = new HashSet<String>();
+    expectedProjects.add("platform/whee");
+    expectedProjects.add("platform/added/project");
+    assertThat(configLoader.getProjectsInScope("master", "ds_one")).isEqualTo(expectedProjects);
+  }
+
+  @Test
+  public void getProjectsInScopeTest_setProjects() throws Exception {
+    loadConfig();
+    Set<String> otherExpectedProjects = new HashSet<String>();
+    otherExpectedProjects.add("platform/some/project");
+    otherExpectedProjects.add("platform/other/project");
+    assertThat(configLoader.getProjectsInScope("master", "ds_two"))
+        .isEqualTo(otherExpectedProjects);
+  }
+
+  @Test
+  public void isSkipMergeTest_noSkip() throws Exception {
+    loadConfig();
+    assertThat(configLoader.isSkipMerge("ds_two", "ds_three", "bla")).isFalse();
+  }
+
+  @Test
+  public void isSkipMergeTest_blankMerge() throws Exception {
+    loadConfig();
+    assertThat(configLoader.isSkipMerge("ds_two", "ds_three", "test test \n \n DO NOT MERGE lala"))
+        .isTrue();
+  }
+
+  @Test
+  public void isSkipMergeTest_blankMergeWithMergeAll() throws Exception {
+    loadConfig();
+    assertThat(configLoader.isSkipMerge("master", "ds_two", "test test \n \n DO NOT MERGE"))
+        .isFalse();
+  }
+
+  @Test
+  public void isSkipMergeTest_alwaysBlankMerge() throws Exception {
+    loadConfig();
+    assertThat(
+            configLoader.isSkipMerge("master", "ds_one", "test test \n \n DO NOT MERGE ANYWHERE"))
+        .isTrue();
+  }
+
+  @Test
+  public void downstreamBranchesTest() throws Exception {
+    loadConfig();
+    Set<String> expectedBranches = new HashSet<String>();
+    expectedBranches.add("ds_two");
+    assertThat(configLoader.getDownstreamBranches("master", "platform/some/project"))
+        .isEqualTo(expectedBranches);
+  }
+
+  @Test
+  public void downstreamBranchesTest_nonexistentBranch() throws Exception {
+    loadConfig();
+    Set<String> expectedBranches = new HashSet<String>();
+    assertThat(configLoader.getDownstreamBranches("idontexist", "platform/some/project"))
+        .isEqualTo(expectedBranches);
+  }
+
+  @Test(expected = IOException.class)
+  public void downstreamBranchesTest_IOException() throws Exception {
+    Mockito.when(
+            gApiMock
+                .projects()
+                .name("platform/manifest")
+                .branch("master")
+                .file("default.xml")
+                .asString())
+        .thenThrow(new IOException("!"));
+    loadConfig();
+    Set<String> expectedBranches = new HashSet<String>();
+
+    configLoader.getDownstreamBranches("master", "platform/some/project");
+  }
+
+  @Test(expected = RestApiException.class)
+  public void downstreamBranchesTest_restApiException() throws Exception {
+    Mockito.when(gApiMock.projects().name("platform/manifest").branch("master"))
+        .thenThrow(new RestApiException("!"));
+    loadConfig();
+    configLoader.getDownstreamBranches("master", "platform/some/project");
+  }
+}
diff --git a/src/test/java/com/googlesource/gerrit/plugins/automerger/DownstreamCreatorTest.java b/src/test/java/com/googlesource/gerrit/plugins/automerger/DownstreamCreatorTest.java
new file mode 100644
index 0000000..a9ee6f2
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/automerger/DownstreamCreatorTest.java
@@ -0,0 +1,251 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.gerrit.extensions.api.GerritApi;
+import com.google.gerrit.extensions.api.changes.AbandonInput;
+import com.google.gerrit.extensions.api.changes.ChangeApi;
+import com.google.gerrit.extensions.api.changes.ReviewInput;
+import com.google.gerrit.extensions.api.changes.RevisionApi;
+import com.google.gerrit.extensions.client.ListChangesOption;
+import com.google.gerrit.extensions.common.ChangeInfo;
+import com.google.gerrit.extensions.common.ChangeInput;
+import com.google.gerrit.extensions.common.CommitInfo;
+import com.google.gerrit.extensions.common.MergePatchSetInput;
+import com.google.gerrit.extensions.common.RevisionInfo;
+import com.google.common.collect.ImmutableList;
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Mockito;
+
+import java.util.ArrayList;
+import java.util.EnumSet;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import static com.google.common.truth.Truth.assertThat;
+
+public class DownstreamCreatorTest {
+  private final String changeId = "testid";
+  private final String changeProject = "testproject";
+  private final String changeBranch = "testbranch";
+  private final String changeTopic = "testtopic";
+  private final String changeSubject = "testmessage";
+  private GerritApi gApiMock;
+  private DownstreamCreator ds;
+  private ConfigLoader configMock;
+
+  @Before
+  public void setUp() throws Exception {
+    gApiMock = Mockito.mock(GerritApi.class, Mockito.RETURNS_DEEP_STUBS);
+    configMock = Mockito.mock(ConfigLoader.class);
+    Mockito.when(configMock.getCodeReviewLabel()).thenReturn("Code-Review");
+    ds = new DownstreamCreator(gApiMock, configMock);
+  }
+
+  private List<ChangeInfo> mockChangeInfoList(String upstreamBranch) {
+    return ImmutableList.of(
+        mockChangeInfo(upstreamBranch, 1),
+        mockChangeInfo("testwhee", 2),
+        mockChangeInfo(upstreamBranch, 3));
+  }
+
+  private ChangeInfo mockChangeInfo(String upstreamRevision, int number) {
+    CommitInfo parent1 = Mockito.mock(CommitInfo.class);
+    parent1.commit = "infoparent" + number;
+    CommitInfo parent2 = Mockito.mock(CommitInfo.class);
+    parent2.commit = upstreamRevision;
+
+    ChangeInfo info = Mockito.mock(ChangeInfo.class);
+    info._number = number;
+    info.currentRevision = "info" + number;
+    info.revisions = Mockito.mock(Map.class);
+
+    RevisionInfo revisionInfoMock = Mockito.mock(RevisionInfo.class);
+    CommitInfo commit = Mockito.mock(CommitInfo.class);
+    commit.parents = ImmutableList.of(parent1, parent2);
+    revisionInfoMock.commit = commit;
+
+    Mockito.when(info.revisions.get(info.currentRevision)).thenReturn(revisionInfoMock);
+
+    return info;
+  }
+
+  @Test
+  public void testCreateDownstreamMerge() throws Exception {
+    String currentRevision = "testCurrentRevision";
+
+    ChangeInfo changeInfoMock = Mockito.mock(ChangeInfo.class);
+    changeInfoMock.id = "testnewchangeid";
+    ChangeApi changeApiMock = Mockito.mock(ChangeApi.class);
+    Mockito.when(changeApiMock.get(EnumSet.of(ListChangesOption.CURRENT_REVISION)))
+        .thenReturn(changeInfoMock);
+    Mockito.when(gApiMock.changes().create(Mockito.any(ChangeInput.class)))
+        .thenReturn(changeApiMock);
+    RevisionApi revisionApiMock = Mockito.mock(RevisionApi.class);
+    Mockito.when(gApiMock.changes().id(Mockito.anyString()).revision(Mockito.anyString()))
+        .thenReturn(revisionApiMock);
+
+    SingleDownstreamMergeInput dsMergeInput = new SingleDownstreamMergeInput();
+    dsMergeInput.currentRevision = currentRevision;
+    dsMergeInput.sourceId = changeId;
+    dsMergeInput.project = changeProject;
+    dsMergeInput.topic = changeTopic;
+    dsMergeInput.subject = changeSubject;
+    dsMergeInput.downstreamBranch = "testds";
+    dsMergeInput.doMerge = true;
+
+    ds.createSingleDownstreamMerge(dsMergeInput);
+
+    // Check ReviewInput is +2
+    ArgumentCaptor<ReviewInput> reviewInputArgument = ArgumentCaptor.forClass(ReviewInput.class);
+    Mockito.verify(revisionApiMock).review(reviewInputArgument.capture());
+    ReviewInput reviewInput = reviewInputArgument.getValue();
+    assertThat(reviewInput.labels.get("Code-Review")).isEqualTo(2);
+
+    // Check ChangeInput is the right project, branch, topic, subject
+    ArgumentCaptor<ChangeInput> changeInputCaptor = ArgumentCaptor.forClass(ChangeInput.class);
+    Mockito.verify(gApiMock.changes()).create(changeInputCaptor.capture());
+    ChangeInput changeInput = changeInputCaptor.getValue();
+    assertThat(changeProject).isEqualTo(changeInput.project);
+    assertThat("testds").isEqualTo(changeInput.branch);
+    assertThat(changeTopic).isEqualTo(changeInput.topic);
+    assertThat(changeInput.merge.source).isEqualTo(currentRevision);
+
+    String expectedSubject = changeSubject + " am: " + currentRevision.substring(0, 10);
+    assertThat(expectedSubject).isEqualTo(changeInput.subject);
+  }
+
+  @Test
+  public void testCreateDownstreamMerge_skipMerge() throws Exception {
+    String currentRevision = "testCurrentRevision";
+
+    ChangeInfo changeInfoMock = Mockito.mock(ChangeInfo.class);
+    changeInfoMock.id = "testnewchangeid";
+    ChangeApi changeApiMock = Mockito.mock(ChangeApi.class);
+    Mockito.when(changeApiMock.get(EnumSet.of(ListChangesOption.CURRENT_REVISION)))
+        .thenReturn(changeInfoMock);
+    Mockito.when(gApiMock.changes().create(Mockito.any(ChangeInput.class)))
+        .thenReturn(changeApiMock);
+    RevisionApi revisionApiMock = Mockito.mock(RevisionApi.class);
+    Mockito.when(gApiMock.changes().id(Mockito.anyString()).revision(Mockito.anyString()))
+        .thenReturn(revisionApiMock);
+
+    SingleDownstreamMergeInput dsMergeInput = new SingleDownstreamMergeInput();
+    dsMergeInput.currentRevision = currentRevision;
+    dsMergeInput.sourceId = changeId;
+    dsMergeInput.project = changeProject;
+    dsMergeInput.topic = changeTopic;
+    dsMergeInput.subject = changeSubject;
+    dsMergeInput.downstreamBranch = "testds";
+    dsMergeInput.doMerge = false;
+
+    ds.createSingleDownstreamMerge(dsMergeInput);
+
+    // Check ReviewInput is +2
+    ArgumentCaptor<ReviewInput> reviewInputArgument = ArgumentCaptor.forClass(ReviewInput.class);
+    Mockito.verify(revisionApiMock).review(reviewInputArgument.capture());
+    ReviewInput reviewInput = reviewInputArgument.getValue();
+    assertThat(reviewInput.labels.get("Code-Review")).isEqualTo(2);
+
+    // Check ChangeInput is the right project, branch, topic, subject
+    ArgumentCaptor<ChangeInput> changeInputCaptor = ArgumentCaptor.forClass(ChangeInput.class);
+    Mockito.verify(gApiMock.changes()).create(changeInputCaptor.capture());
+    ChangeInput changeInput = changeInputCaptor.getValue();
+    assertThat(changeProject).isEqualTo(changeInput.project);
+    assertThat("testds").isEqualTo(changeInput.branch);
+    assertThat(changeTopic).isEqualTo(changeInput.topic);
+    assertThat(changeInput.merge.source).isEqualTo(currentRevision);
+
+    // Check that it was actually skipped
+    String expectedSubject =
+        changeSubject + " skipped: " + currentRevision.substring(0, 10);
+    assertThat(changeInput.merge.strategy).isEqualTo("ours");
+    assertThat(expectedSubject).isEqualTo(changeInput.subject);
+  }
+
+  @Test
+  public void testCreateDownstreamMerges() throws Exception {
+    Map<String, Boolean> downstreamBranchMap = new HashMap<String, Boolean>();
+    downstreamBranchMap.put("testone", true);
+    downstreamBranchMap.put("testtwo", true);
+
+    MultipleDownstreamMergeInput mdsMergeInput = new MultipleDownstreamMergeInput();
+    mdsMergeInput.dsBranchMap = downstreamBranchMap;
+    mdsMergeInput.sourceId = changeId;
+    mdsMergeInput.project = changeProject;
+    mdsMergeInput.topic = changeTopic;
+    mdsMergeInput.subject = changeSubject;
+    mdsMergeInput.obsoleteRevision = null;
+    mdsMergeInput.currentRevision = "testCurrent";
+
+    ds.createDownstreamMerges(mdsMergeInput);
+
+    ArgumentCaptor<ChangeInput> changeInputCaptor = ArgumentCaptor.forClass(ChangeInput.class);
+    Mockito.verify(gApiMock.changes(), Mockito.times(2)).create(changeInputCaptor.capture());
+    List<ChangeInput> capturedChangeInputs = changeInputCaptor.getAllValues();
+    assertThat(capturedChangeInputs.get(0).branch).isEqualTo("testone");
+    assertThat(capturedChangeInputs.get(1).branch).isEqualTo("testtwo");
+  }
+
+  @Test
+  public void testCreateDownstreamMerges_withPreviousRevisions() throws Exception {
+    Map<String, Boolean> downstreamBranchMap = new HashMap<String, Boolean>();
+    downstreamBranchMap.put("testone", true);
+    downstreamBranchMap.put("testtwo", true);
+
+    List<ChangeInfo> changeInfoList = mockChangeInfoList("testup");
+    Mockito.when(
+            gApiMock
+                .changes()
+                .query(Mockito.anyString())
+                .withOptions(ListChangesOption.ALL_REVISIONS, ListChangesOption.CURRENT_COMMIT)
+                .get())
+        .thenReturn(changeInfoList);
+
+    MultipleDownstreamMergeInput mdsMergeInput = new MultipleDownstreamMergeInput();
+    mdsMergeInput.dsBranchMap = downstreamBranchMap;
+    mdsMergeInput.sourceId = changeId;
+    mdsMergeInput.project = changeProject;
+    mdsMergeInput.topic = changeTopic;
+    mdsMergeInput.subject = changeSubject;
+    mdsMergeInput.obsoleteRevision = "testup";
+    mdsMergeInput.currentRevision = "testCurrent";
+
+    ds.createDownstreamMerges(mdsMergeInput);
+
+    // Check that previous revisions were updated
+    Mockito.verify(gApiMock.changes().id(Mockito.anyInt()), Mockito.times(2))
+        .createMergePatchSet(Mockito.any(MergePatchSetInput.class));
+  }
+
+  @Test
+  public void testGetExistingMergesOnBranch() throws Exception {
+    List<ChangeInfo> changeInfoList = mockChangeInfoList("testup");
+    Mockito.when(
+            gApiMock
+                .changes()
+                .query(Mockito.anyString())
+                .withOptions(ListChangesOption.ALL_REVISIONS, ListChangesOption.CURRENT_COMMIT)
+                .get())
+        .thenReturn(changeInfoList);
+
+    List<Integer> downstreamChangeNumbers =
+        ds.getExistingMergesOnBranch("testup", "testtopic", "testdown");
+    assertThat(downstreamChangeNumbers).containsExactly(1, 3).inOrder();
+  }
+}
diff --git a/src/test/java/com/googlesource/gerrit/plugins/automerger/ManifestReaderTest.java b/src/test/java/com/googlesource/gerrit/plugins/automerger/ManifestReaderTest.java
new file mode 100644
index 0000000..bd7b79e
--- /dev/null
+++ b/src/test/java/com/googlesource/gerrit/plugins/automerger/ManifestReaderTest.java
@@ -0,0 +1,56 @@
+// Copyright (C) 2016 The Android Open Source Project
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+// http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package com.googlesource.gerrit.plugins.automerger;
+
+import com.google.common.base.Charsets;
+import com.google.common.io.CharStreams;
+import org.junit.Before;
+import org.junit.Test;
+
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.util.HashSet;
+import java.util.Set;
+
+import static com.google.common.truth.Truth.assertThat;
+
+public class ManifestReaderTest {
+  private ManifestReader manifestReader;
+  private String manifestString;
+
+  @Before
+  public void setUp() throws Exception {
+    try (InputStream in = getClass().getResourceAsStream("default.xml")) {
+      manifestString = CharStreams.toString(new InputStreamReader(in, Charsets.UTF_8));
+    }
+    manifestReader = new ManifestReader("master", manifestString);
+  }
+
+  @Test
+  public void basicParseTest() throws Exception {
+    Set<String> expectedSet = new HashSet<String>();
+    expectedSet.add("platform/whee");
+    expectedSet.add("whoo");
+    assertThat(manifestReader.getProjects()).isEqualTo(expectedSet);
+  }
+
+  @Test
+  public void branchDifferentFromDefaultRevisionTest() throws Exception {
+    ManifestReader aospManifestReader = new ManifestReader("mirror-aosp-master", manifestString);
+    Set<String> expectedSet = new HashSet<String>();
+    expectedSet.add("platform/whaa");
+    assertThat(aospManifestReader.getProjects()).isEqualTo(expectedSet);
+  }
+}
diff --git a/src/test/resources/com/googlesource/gerrit/plugins/automerger/config.yaml b/src/test/resources/com/googlesource/gerrit/plugins/automerger/config.yaml
new file mode 100644
index 0000000..271d875
--- /dev/null
+++ b/src/test/resources/com/googlesource/gerrit/plugins/automerger/config.yaml
@@ -0,0 +1,31 @@
+branches:
+  master:
+    ds_one:
+      add_projects:
+      - platform/added/project
+      ignore_projects:
+      - whoo
+    ds_two:
+      merge_all: true
+      add_projects:
+      - platform/added/project
+      ignore_projects:
+      - whoo
+      set_projects:
+      - platform/some/project
+      - platform/other/project
+  ds_two:
+    ds_three:
+      set_projects:
+      - platform/some/project
+global:
+  always_blank_merge:
+  - .*Import translations\.\sDO NOT MERGE.*
+  - .*DO NOT MERGE ANYWHERE.*
+  blank_merge:
+  - .*DO NOT MERGE.*
+  manifest:
+    file: default.xml
+    project: platform/manifest
+  ignore_projects:
+  - platform/ignore/me
diff --git a/src/test/resources/com/googlesource/gerrit/plugins/automerger/default.xml b/src/test/resources/com/googlesource/gerrit/plugins/automerger/default.xml
new file mode 100644
index 0000000..cf69b9b
--- /dev/null
+++ b/src/test/resources/com/googlesource/gerrit/plugins/automerger/default.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest>
+  <default revision="master" />
+  <project path="whee" name="platform/whee" groups="pdk" />
+  <project path="whoo" name="whoo" groups="pdk" />
+  <project path="whaa" name="platform/whaa" groups="pdk" revision="mirror-aosp-master" />
+</manifest>
diff --git a/src/test/resources/com/googlesource/gerrit/plugins/automerger/ds_one.xml b/src/test/resources/com/googlesource/gerrit/plugins/automerger/ds_one.xml
new file mode 100644
index 0000000..5040efd
--- /dev/null
+++ b/src/test/resources/com/googlesource/gerrit/plugins/automerger/ds_one.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest>
+  <default revision="ds_one" />
+  <project path="whee" name="platform/whee" groups="pdk" />
+  <project path="whoo" name="whoo" groups="pdk" />
+  <project path="whaa" name="platform/whaa" groups="pdk" revision="mirror-aosp-master" />
+</manifest>
diff --git a/src/test/resources/com/googlesource/gerrit/plugins/automerger/ds_two.xml b/src/test/resources/com/googlesource/gerrit/plugins/automerger/ds_two.xml
new file mode 100644
index 0000000..cc48734
--- /dev/null
+++ b/src/test/resources/com/googlesource/gerrit/plugins/automerger/ds_two.xml
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest>
+  <default revision="ds_two" />
+  <project path="whee" name="platform/whee" groups="pdk" />
+  <project path="whuu" name="whuu" groups="pdk" />
+  <project path="whaa" name="platform/whaa" groups="pdk" revision="mirror-aosp-master" />
+</manifest>