diff --git a/aidl/Android.mk b/aidl/Android.mk
new file mode 100644
index 0000000..3c1463a
--- /dev/null
+++ b/aidl/Android.mk
@@ -0,0 +1,204 @@
+#
+# Copyright (C) 2015 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.
+#
+
+LOCAL_PATH := $(call my-dir)
+
+aidl_cflags := -Wall -Wextra -Werror
+aidl_static_libraries := libbase libcutils
+
+aidl_module_host_os := darwin linux windows
+ifdef BRILLO
+  aidl_module_host_os := darwin linux
+endif
+
+# Logic shared between aidl and its unittests
+include $(CLEAR_VARS)
+LOCAL_MODULE := libaidl-common
+LOCAL_MODULE_HOST_OS := $(aidl_module_host_os)
+
+LOCAL_WHOLE_STATIC_LIBRARIES := libgtest_prod
+LOCAL_CLANG_CFLAGS := $(aidl_cflags)
+# Tragically, the code is riddled with unused parameters.
+LOCAL_CLANG_CFLAGS += -Wno-unused-parameter
+# yacc dumps a lot of code *just in case*.
+LOCAL_CLANG_CFLAGS += -Wno-unused-function
+LOCAL_CLANG_CFLAGS += -Wno-unneeded-internal-declaration
+# yacc is a tool from a more civilized age.
+LOCAL_CLANG_CFLAGS += -Wno-deprecated-register
+# yacc also has a habit of using char* over const char*.
+LOCAL_CLANG_CFLAGS += -Wno-writable-strings
+LOCAL_STATIC_LIBRARIES := $(aidl_static_libraries)
+
+LOCAL_SRC_FILES := \
+    aidl.cpp \
+    aidl_language.cpp \
+    aidl_language_l.ll \
+    aidl_language_y.yy \
+    ast_cpp.cpp \
+    ast_java.cpp \
+    code_writer.cpp \
+    generate_cpp.cpp \
+    generate_java.cpp \
+    generate_java_binder.cpp \
+    import_resolver.cpp \
+    line_reader.cpp \
+    io_delegate.cpp \
+    options.cpp \
+    type_cpp.cpp \
+    type_java.cpp \
+    type_namespace.cpp \
+
+include $(BUILD_HOST_STATIC_LIBRARY)
+
+
+# aidl executable
+include $(CLEAR_VARS)
+LOCAL_MODULE := aidl
+
+LOCAL_MODULE_HOST_OS := $(aidl_module_host_os)
+LOCAL_CFLAGS := $(aidl_cflags)
+LOCAL_WHOLE_STATIC_LIBRARIES := libgtest_prod
+LOCAL_SRC_FILES := main_java.cpp
+LOCAL_STATIC_LIBRARIES := libaidl-common $(aidl_static_libraries)
+include $(BUILD_HOST_EXECUTABLE)
+
+# aidl-cpp executable
+include $(CLEAR_VARS)
+LOCAL_MODULE := aidl-cpp
+
+LOCAL_MODULE_HOST_OS := $(aidl_module_host_os)
+LOCAL_CFLAGS := $(aidl_cflags)
+LOCAL_WHOLE_STATIC_LIBRARIES := libgtest_prod
+LOCAL_SRC_FILES := main_cpp.cpp
+LOCAL_STATIC_LIBRARIES := libaidl-common $(aidl_static_libraries)
+include $(BUILD_HOST_EXECUTABLE)
+
+# Unit tests
+include $(CLEAR_VARS)
+LOCAL_MODULE := aidl_unittests
+LOCAL_MODULE_HOST_OS := darwin linux
+
+LOCAL_CFLAGS := $(aidl_cflags) -g -DUNIT_TEST
+# Tragically, the code is riddled with unused parameters.
+LOCAL_CLANG_CFLAGS := -Wno-unused-parameter
+LOCAL_SRC_FILES := \
+    aidl_unittest.cpp \
+    ast_cpp_unittest.cpp \
+    ast_java_unittest.cpp \
+    generate_cpp_unittest.cpp \
+    io_delegate_unittest.cpp \
+    options_unittest.cpp \
+    tests/end_to_end_tests.cpp \
+    tests/fake_io_delegate.cpp \
+    tests/main.cpp \
+    tests/test_data_example_interface.cpp \
+    tests/test_data_ping_responder.cpp \
+    tests/test_data_string_constants.cpp \
+    tests/test_util.cpp \
+    type_cpp_unittest.cpp \
+    type_java_unittest.cpp \
+
+LOCAL_STATIC_LIBRARIES := \
+    libaidl-common \
+    $(aidl_static_libraries) \
+    libgmock_host \
+
+LOCAL_LDLIBS_linux := -lrt
+include $(BUILD_HOST_NATIVE_TEST)
+
+#
+# Everything below here is used for integration testing of generated AIDL code.
+#
+aidl_integration_test_cflags := $(aidl_cflags) -Wunused-parameter
+aidl_integration_test_shared_libs := \
+    libbase \
+    libbinder \
+    liblog \
+    libutils
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := libaidl-integration-test
+LOCAL_MODULE_CLASS := SHARED_LIBRARIES
+LOCAL_CFLAGS := $(aidl_integration_test_cflags)
+LOCAL_SHARED_LIBRARIES := $(aidl_integration_test_shared_libs)
+LOCAL_AIDL_INCLUDES := \
+    system/tools/aidl/tests/ \
+    frameworks/native/aidl/binder
+LOCAL_SRC_FILES := \
+    tests/android/aidl/tests/ITestService.aidl \
+    tests/android/aidl/tests/INamedCallback.aidl \
+    tests/simple_parcelable.cpp
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := aidl_test_service
+LOCAL_CFLAGS := $(aidl_integration_test_cflags)
+LOCAL_SHARED_LIBRARIES := \
+    libaidl-integration-test \
+    $(aidl_integration_test_shared_libs)
+LOCAL_SRC_FILES := \
+    tests/aidl_test_service.cpp
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := aidl_test_client
+LOCAL_CFLAGS := $(aidl_integration_test_cflags)
+LOCAL_SHARED_LIBRARIES := \
+    libaidl-integration-test \
+    $(aidl_integration_test_shared_libs)
+LOCAL_SRC_FILES := \
+    tests/aidl_test_client.cpp \
+    tests/aidl_test_client_file_descriptors.cpp \
+    tests/aidl_test_client_parcelables.cpp \
+    tests/aidl_test_client_nullables.cpp \
+    tests/aidl_test_client_primitives.cpp \
+    tests/aidl_test_client_utf8_strings.cpp \
+    tests/aidl_test_client_service_exceptions.cpp
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+LOCAL_MODULE := aidl_test_sentinel_searcher
+LOCAL_SRC_FILES := tests/aidl_test_sentinel_searcher.cpp
+LOCAL_CFLAGS := $(aidl_integration_test_cflags)
+include $(BUILD_EXECUTABLE)
+
+
+# aidl on its own doesn't need the framework, but testing native/java
+# compatibility introduces java dependencies.
+ifndef BRILLO
+
+include $(CLEAR_VARS)
+LOCAL_PACKAGE_NAME := aidl_test_services
+# Turn off Java optimization tools to speed up our test iterations.
+LOCAL_PROGUARD_ENABLED := disabled
+LOCAL_DEX_PREOPT := false
+LOCAL_CERTIFICATE := platform
+LOCAL_MANIFEST_FILE := tests/java_app/AndroidManifest.xml
+LOCAL_RESOURCE_DIR := $(LOCAL_PATH)/tests/java_app/resources
+LOCAL_SRC_FILES := \
+    tests/android/aidl/tests/INamedCallback.aidl \
+    tests/android/aidl/tests/ITestService.aidl \
+    tests/java_app/src/android/aidl/tests/NullableTests.java \
+    tests/java_app/src/android/aidl/tests/SimpleParcelable.java \
+    tests/java_app/src/android/aidl/tests/TestFailException.java \
+    tests/java_app/src/android/aidl/tests/TestLogger.java \
+    tests/java_app/src/android/aidl/tests/TestServiceClient.java
+LOCAL_AIDL_INCLUDES := \
+    system/tools/aidl/tests/ \
+    frameworks/native/aidl/binder
+include $(BUILD_PACKAGE)
+
+endif  # not defined BRILLO
diff --git a/aidl/MODULE_LICENSE_APACHE2 b/aidl/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/aidl/MODULE_LICENSE_APACHE2
diff --git a/aidl/NOTICE b/aidl/NOTICE
new file mode 100644
index 0000000..c5b1efa
--- /dev/null
+++ b/aidl/NOTICE
@@ -0,0 +1,190 @@
+
+   Copyright (c) 2005-2008, 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.
+
+   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.
+
+
+                                 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
+
diff --git a/aidl/aidl.cpp b/aidl/aidl.cpp
new file mode 100644
index 0000000..cd778fa
--- /dev/null
+++ b/aidl/aidl.cpp
@@ -0,0 +1,771 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "aidl.h"
+
+#include <fcntl.h>
+#include <iostream>
+#include <map>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <unistd.h>
+
+#ifdef _WIN32
+#include <io.h>
+#include <direct.h>
+#include <sys/stat.h>
+#endif
+
+#include <android-base/strings.h>
+
+#include "aidl_language.h"
+#include "generate_cpp.h"
+#include "generate_java.h"
+#include "import_resolver.h"
+#include "logging.h"
+#include "options.h"
+#include "os.h"
+#include "type_cpp.h"
+#include "type_java.h"
+#include "type_namespace.h"
+
+#ifndef O_BINARY
+#  define O_BINARY  0
+#endif
+
+using android::base::Join;
+using android::base::Split;
+using std::cerr;
+using std::endl;
+using std::map;
+using std::set;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace {
+
+// The following are gotten as the offset from the allowable id's between
+// android.os.IBinder.FIRST_CALL_TRANSACTION=1 and
+// android.os.IBinder.LAST_CALL_TRANSACTION=16777215
+const int kMinUserSetMethodId = 0;
+const int kMaxUserSetMethodId = 16777214;
+
+bool check_filename(const std::string& filename,
+                    const std::string& package,
+                    const std::string& name,
+                    unsigned line) {
+    const char* p;
+    string expected;
+    string fn;
+    size_t len;
+    bool valid = false;
+
+    if (!IoDelegate::GetAbsolutePath(filename, &fn)) {
+      return false;
+    }
+
+    if (!package.empty()) {
+        expected = package;
+        expected += '.';
+    }
+
+    len = expected.length();
+    for (size_t i=0; i<len; i++) {
+        if (expected[i] == '.') {
+            expected[i] = OS_PATH_SEPARATOR;
+        }
+    }
+
+    expected.append(name, 0, name.find('.'));
+
+    expected += ".aidl";
+
+    len = fn.length();
+    valid = (len >= expected.length());
+
+    if (valid) {
+        p = fn.c_str() + (len - expected.length());
+
+#ifdef _WIN32
+        if (OS_PATH_SEPARATOR != '/') {
+            // Input filename under cygwin most likely has / separators
+            // whereas the expected string uses \\ separators. Adjust
+            // them accordingly.
+          for (char *c = const_cast<char *>(p); *c; ++c) {
+                if (*c == '/') *c = OS_PATH_SEPARATOR;
+            }
+        }
+#endif
+
+        // aidl assumes case-insensitivity on Mac Os and Windows.
+#if defined(__linux__)
+        valid = (expected == p);
+#else
+        valid = !strcasecmp(expected.c_str(), p);
+#endif
+    }
+
+    if (!valid) {
+        fprintf(stderr, "%s:%d interface %s should be declared in a file"
+                " called %s.\n",
+                filename.c_str(), line, name.c_str(), expected.c_str());
+    }
+
+    return valid;
+}
+
+bool check_filenames(const std::string& filename, const AidlDocument* doc) {
+  if (!doc)
+    return true;
+
+  const AidlInterface* interface = doc->GetInterface();
+
+  if (interface) {
+    return check_filename(filename, interface->GetPackage(),
+                          interface->GetName(), interface->GetLine());
+  }
+
+  bool success = true;
+
+  for (const auto& item : doc->GetParcelables()) {
+    success &= check_filename(filename, item->GetPackage(), item->GetName(),
+                              item->GetLine());
+  }
+
+  return success;
+}
+
+bool gather_types(const std::string& filename,
+                  const AidlDocument* doc,
+                  TypeNamespace* types) {
+  bool success = true;
+
+  const AidlInterface* interface = doc->GetInterface();
+
+  if (interface)
+    return types->AddBinderType(*interface, filename);
+
+  for (const auto& item : doc->GetParcelables()) {
+    success &= types->AddParcelableType(*item, filename);
+  }
+
+  return success;
+}
+
+int check_types(const string& filename,
+                const AidlInterface* c,
+                TypeNamespace* types) {
+  int err = 0;
+
+  if (c->IsUtf8() && c->IsUtf8InCpp()) {
+    cerr << filename << ":" << c->GetLine()
+         << "Interface cannot be marked as both @utf8 and @utf8InCpp";
+    err = 1;
+  }
+
+  // Has to be a pointer due to deleting copy constructor. No idea why.
+  map<string, const AidlMethod*> method_names;
+  for (const auto& m : c->GetMethods()) {
+    bool oneway = m->IsOneway() || c->IsOneway();
+
+    if (!types->MaybeAddContainerType(m->GetType())) {
+      err = 1;  // return type is invalid
+    }
+
+    const ValidatableType* return_type =
+        types->GetReturnType(m->GetType(), filename, *c);
+
+    if (!return_type) {
+      err = 1;
+    }
+
+    m->GetMutableType()->SetLanguageType(return_type);
+
+    if (oneway && m->GetType().GetName() != "void") {
+        cerr << filename << ":" << m->GetLine()
+            << " oneway method '" << m->GetName() << "' cannot return a value"
+            << endl;
+        err = 1;
+    }
+
+    int index = 1;
+    for (const auto& arg : m->GetArguments()) {
+      if (!types->MaybeAddContainerType(arg->GetType())) {
+        err = 1;
+      }
+
+      const ValidatableType* arg_type =
+          types->GetArgType(*arg, index, filename, *c);
+
+      if (!arg_type) {
+        err = 1;
+      }
+
+      arg->GetMutableType()->SetLanguageType(arg_type);
+
+      if (oneway && arg->IsOut()) {
+        cerr << filename << ":" << m->GetLine()
+            << " oneway method '" << m->GetName()
+            << "' cannot have out parameters" << endl;
+        err = 1;
+      }
+    }
+
+    auto it = method_names.find(m->GetName());
+    // prevent duplicate methods
+    if (it == method_names.end()) {
+      method_names[m->GetName()] = m.get();
+    } else {
+      cerr << filename << ":" << m->GetLine()
+           << " attempt to redefine method " << m->GetName() << "," << endl
+           << filename << ":" << it->second->GetLine()
+           << "    previously defined here." << endl;
+      err = 1;
+    }
+  }
+  return err;
+}
+
+void write_common_dep_file(const string& output_file,
+                           const vector<string>& aidl_sources,
+                           CodeWriter* writer) {
+  // Encode that the output file depends on aidl input files.
+  writer->Write("%s : \\\n", output_file.c_str());
+  writer->Write("  %s", Join(aidl_sources, " \\\n  ").c_str());
+  writer->Write("\n\n");
+
+  // Output "<input_aidl_file>: " so make won't fail if the input .aidl file
+  // has been deleted, moved or renamed in incremental build.
+  for (const auto& src : aidl_sources) {
+    writer->Write("%s :\n", src.c_str());
+  }
+}
+
+bool write_java_dep_file(const JavaOptions& options,
+                         const vector<unique_ptr<AidlImport>>& imports,
+                         const IoDelegate& io_delegate,
+                         const string& output_file_name) {
+  string dep_file_name = options.DependencyFilePath();
+  if (dep_file_name.empty()) {
+    return true;  // nothing to do
+  }
+  CodeWriterPtr writer = io_delegate.GetCodeWriter(dep_file_name);
+  if (!writer) {
+    LOG(ERROR) << "Could not open dependency file: " << dep_file_name;
+    return false;
+  }
+
+  vector<string> source_aidl = {options.input_file_name_};
+  for (const auto& import : imports) {
+    if (!import->GetFilename().empty()) {
+      source_aidl.push_back(import->GetFilename());
+    }
+  }
+
+  write_common_dep_file(output_file_name, source_aidl, writer.get());
+
+  return true;
+}
+
+bool write_cpp_dep_file(const CppOptions& options,
+                        const AidlInterface& interface,
+                        const vector<unique_ptr<AidlImport>>& imports,
+                        const IoDelegate& io_delegate) {
+  using ::android::aidl::cpp::HeaderFile;
+  using ::android::aidl::cpp::ClassNames;
+
+  string dep_file_name = options.DependencyFilePath();
+  if (dep_file_name.empty()) {
+    return true;  // nothing to do
+  }
+  CodeWriterPtr writer = io_delegate.GetCodeWriter(dep_file_name);
+  if (!writer) {
+    LOG(ERROR) << "Could not open dependency file: " << dep_file_name;
+    return false;
+  }
+
+  vector<string> source_aidl = {options.InputFileName()};
+  for (const auto& import : imports) {
+    if (!import->GetFilename().empty()) {
+      source_aidl.push_back(import->GetFilename());
+    }
+  }
+
+  vector<string> headers;
+  for (ClassNames c : {ClassNames::CLIENT,
+                       ClassNames::SERVER,
+                       ClassNames::INTERFACE}) {
+    headers.push_back(options.OutputHeaderDir() + '/' +
+                      HeaderFile(interface, c, false /* use_os_sep */));
+  }
+
+  write_common_dep_file(options.OutputCppFilePath(), source_aidl, writer.get());
+  writer->Write("\n");
+
+  // Generated headers also depend on the source aidl files.
+  writer->Write("%s : \\\n    %s\n", Join(headers, " \\\n    ").c_str(),
+                Join(source_aidl, " \\\n    ").c_str());
+
+  return true;
+}
+
+string generate_outputFileName(const JavaOptions& options,
+                               const AidlInterface& interface) {
+    const string& name = interface.GetName();
+    string package = interface.GetPackage();
+    string result;
+
+    // create the path to the destination folder based on the
+    // interface package name
+    result = options.output_base_folder_;
+    result += OS_PATH_SEPARATOR;
+
+    string packageStr = package;
+    size_t len = packageStr.length();
+    for (size_t i=0; i<len; i++) {
+        if (packageStr[i] == '.') {
+            packageStr[i] = OS_PATH_SEPARATOR;
+        }
+    }
+
+    result += packageStr;
+
+    // add the filename by replacing the .aidl extension to .java
+    result += OS_PATH_SEPARATOR;
+    result.append(name, 0, name.find('.'));
+    result += ".java";
+
+    return result;
+}
+
+int check_and_assign_method_ids(const char * filename,
+                                const std::vector<std::unique_ptr<AidlMethod>>& items) {
+    // Check whether there are any methods with manually assigned id's and any that are not.
+    // Either all method id's must be manually assigned or all of them must not.
+    // Also, check for duplicates of user set id's and that the id's are within the proper bounds.
+    set<int> usedIds;
+    bool hasUnassignedIds = false;
+    bool hasAssignedIds = false;
+    for (const auto& item : items) {
+        if (item->HasId()) {
+            hasAssignedIds = true;
+            // Ensure that the user set id is not duplicated.
+            if (usedIds.find(item->GetId()) != usedIds.end()) {
+                // We found a duplicate id, so throw an error.
+                fprintf(stderr,
+                        "%s:%d Found duplicate method id (%d) for method: %s\n",
+                        filename, item->GetLine(),
+                        item->GetId(), item->GetName().c_str());
+                return 1;
+            }
+            // Ensure that the user set id is within the appropriate limits
+            if (item->GetId() < kMinUserSetMethodId ||
+                    item->GetId() > kMaxUserSetMethodId) {
+                fprintf(stderr, "%s:%d Found out of bounds id (%d) for method: %s\n",
+                        filename, item->GetLine(),
+                        item->GetId(), item->GetName().c_str());
+                fprintf(stderr, "    Value for id must be between %d and %d inclusive.\n",
+                        kMinUserSetMethodId, kMaxUserSetMethodId);
+                return 1;
+            }
+            usedIds.insert(item->GetId());
+        } else {
+            hasUnassignedIds = true;
+        }
+        if (hasAssignedIds && hasUnassignedIds) {
+            fprintf(stderr,
+                    "%s: You must either assign id's to all methods or to none of them.\n",
+                    filename);
+            return 1;
+        }
+    }
+
+    // In the case that all methods have unassigned id's, set a unique id for them.
+    if (hasUnassignedIds) {
+        int newId = 0;
+        for (const auto& item : items) {
+            item->SetId(newId++);
+        }
+    }
+
+    // success
+    return 0;
+}
+
+bool validate_constants(const AidlInterface& interface) {
+  bool success = true;
+  set<string> names;
+  for (const std::unique_ptr<AidlIntConstant>& int_constant :
+       interface.GetIntConstants()) {
+    if (names.count(int_constant->GetName()) > 0) {
+      LOG(ERROR) << "Found duplicate constant name '" << int_constant->GetName()
+                 << "'";
+      success = false;
+    }
+    names.insert(int_constant->GetName());
+    // We've logged an error message for this on object construction.
+    success = success && int_constant->IsValid();
+  }
+  for (const std::unique_ptr<AidlStringConstant>& string_constant :
+       interface.GetStringConstants()) {
+    if (names.count(string_constant->GetName()) > 0) {
+      LOG(ERROR) << "Found duplicate constant name '" << string_constant->GetName()
+                 << "'";
+      success = false;
+    }
+    names.insert(string_constant->GetName());
+    // We've logged an error message for this on object construction.
+    success = success && string_constant->IsValid();
+  }
+  return success;
+}
+
+// TODO: Remove this in favor of using the YACC parser b/25479378
+bool ParsePreprocessedLine(const string& line, string* decl,
+                           vector<string>* package, string* class_name) {
+  // erase all trailing whitespace and semicolons
+  const size_t end = line.find_last_not_of(" ;\t");
+  if (end == string::npos) {
+    return false;
+  }
+  if (line.rfind(';', end) != string::npos) {
+    return false;
+  }
+
+  decl->clear();
+  string type;
+  vector<string> pieces = Split(line.substr(0, end + 1), " \t");
+  for (const string& piece : pieces) {
+    if (piece.empty()) {
+      continue;
+    }
+    if (decl->empty()) {
+      *decl = std::move(piece);
+    } else if (type.empty()) {
+      type = std::move(piece);
+    } else {
+      return false;
+    }
+  }
+
+  // Note that this logic is absolutely wrong.  Given a parcelable
+  // org.some.Foo.Bar, the class name is Foo.Bar, but this code will claim that
+  // the class is just Bar.  However, this was the way it was done in the past.
+  //
+  // See b/17415692
+  size_t dot_pos = type.rfind('.');
+  if (dot_pos != string::npos) {
+    *class_name = type.substr(dot_pos + 1);
+    *package = Split(type.substr(0, dot_pos), ".");
+  } else {
+    *class_name = type;
+    package->clear();
+  }
+
+  return true;
+}
+
+}  // namespace
+
+namespace internals {
+
+bool parse_preprocessed_file(const IoDelegate& io_delegate,
+                             const string& filename, TypeNamespace* types) {
+  bool success = true;
+  unique_ptr<LineReader> line_reader = io_delegate.GetLineReader(filename);
+  if (!line_reader) {
+    LOG(ERROR) << "cannot open preprocessed file: " << filename;
+    success = false;
+    return success;
+  }
+
+  string line;
+  unsigned lineno = 1;
+  for ( ; line_reader->ReadLine(&line); ++lineno) {
+    if (line.empty() || line.compare(0, 2, "//") == 0) {
+      // skip comments and empty lines
+      continue;
+    }
+
+    string decl;
+    vector<string> package;
+    string class_name;
+    if (!ParsePreprocessedLine(line, &decl, &package, &class_name)) {
+      success = false;
+      break;
+    }
+
+    if (decl == "parcelable") {
+      AidlParcelable doc(new AidlQualifiedName(class_name, ""),
+                         lineno, package);
+      types->AddParcelableType(doc, filename);
+    } else if (decl == "interface") {
+      auto temp = new std::vector<std::unique_ptr<AidlMember>>();
+      AidlInterface doc(class_name, lineno, "", false, temp, package);
+      types->AddBinderType(doc, filename);
+    } else {
+      success = false;
+      break;
+    }
+  }
+  if (!success) {
+    LOG(ERROR) << filename << ':' << lineno
+               << " malformed preprocessed file line: '" << line << "'";
+  }
+
+  return success;
+}
+
+AidlError load_and_validate_aidl(
+    const std::vector<std::string>& preprocessed_files,
+    const std::vector<std::string>& import_paths,
+    const std::string& input_file_name,
+    const IoDelegate& io_delegate,
+    TypeNamespace* types,
+    std::unique_ptr<AidlInterface>* returned_interface,
+    std::vector<std::unique_ptr<AidlImport>>* returned_imports) {
+  AidlError err = AidlError::OK;
+
+  std::map<AidlImport*,std::unique_ptr<AidlDocument>> docs;
+
+  // import the preprocessed file
+  for (const string& s : preprocessed_files) {
+    if (!parse_preprocessed_file(io_delegate, s, types)) {
+      err = AidlError::BAD_PRE_PROCESSED_FILE;
+    }
+  }
+  if (err != AidlError::OK) {
+    return err;
+  }
+
+  // parse the input file
+  Parser p{io_delegate};
+  if (!p.ParseFile(input_file_name)) {
+    return AidlError::PARSE_ERROR;
+  }
+
+  AidlDocument* parsed_doc = p.GetDocument();
+
+  unique_ptr<AidlInterface> interface(parsed_doc->ReleaseInterface());
+
+  if (!interface) {
+    LOG(ERROR) << "refusing to generate code from aidl file defining "
+                  "parcelable";
+    return AidlError::FOUND_PARCELABLE;
+  }
+
+  if (!check_filename(input_file_name.c_str(), interface->GetPackage(),
+                      interface->GetName(), interface->GetLine()) ||
+      !types->IsValidPackage(interface->GetPackage())) {
+    LOG(ERROR) << "Invalid package declaration '" << interface->GetPackage()
+               << "'";
+    return AidlError::BAD_PACKAGE;
+  }
+
+  // parse the imports of the input file
+  ImportResolver import_resolver{io_delegate, import_paths};
+  for (auto& import : p.GetImports()) {
+    if (types->HasImportType(*import)) {
+      // There are places in the Android tree where an import doesn't resolve,
+      // but we'll pick the type up through the preprocessed types.
+      // This seems like an error, but legacy support demands we support it...
+      continue;
+    }
+    string import_path = import_resolver.FindImportFile(import->GetNeededClass());
+    if (import_path.empty()) {
+      cerr << import->GetFileFrom() << ":" << import->GetLine()
+           << ": couldn't find import for class "
+           << import->GetNeededClass() << endl;
+      err = AidlError::BAD_IMPORT;
+      continue;
+    }
+    import->SetFilename(import_path);
+
+    Parser p{io_delegate};
+    if (!p.ParseFile(import->GetFilename())) {
+      cerr << "error while parsing import for class "
+           << import->GetNeededClass() << endl;
+      err = AidlError::BAD_IMPORT;
+      continue;
+    }
+
+    std::unique_ptr<AidlDocument> document(p.ReleaseDocument());
+    if (!check_filenames(import->GetFilename(), document.get()))
+      err = AidlError::BAD_IMPORT;
+    docs[import.get()] = std::move(document);
+  }
+  if (err != AidlError::OK) {
+    return err;
+  }
+
+  // gather the types that have been declared
+  if (!types->AddBinderType(*interface.get(), input_file_name)) {
+    err = AidlError::BAD_TYPE;
+  }
+
+  interface->SetLanguageType(types->GetInterfaceType(*interface));
+
+  for (const auto& import : p.GetImports()) {
+    // If we skipped an unresolved import above (see comment there) we'll have
+    // an empty bucket here.
+    const auto import_itr = docs.find(import.get());
+    if (import_itr == docs.cend()) {
+      continue;
+    }
+
+    if (!gather_types(import->GetFilename(), import_itr->second.get(), types)) {
+      err = AidlError::BAD_TYPE;
+    }
+  }
+
+  // check the referenced types in parsed_doc to make sure we've imported them
+  if (check_types(input_file_name, interface.get(), types) != 0) {
+    err = AidlError::BAD_TYPE;
+  }
+  if (err != AidlError::OK) {
+    return err;
+  }
+
+
+  // assign method ids and validate.
+  if (check_and_assign_method_ids(input_file_name.c_str(),
+                                  interface->GetMethods()) != 0) {
+    return AidlError::BAD_METHOD_ID;
+  }
+  if (!validate_constants(*interface)) {
+    return AidlError::BAD_CONSTANTS;
+  }
+
+  if (returned_interface)
+    *returned_interface = std::move(interface);
+
+  if (returned_imports)
+    p.ReleaseImports(returned_imports);
+
+  return AidlError::OK;
+}
+
+} // namespace internals
+
+int compile_aidl_to_cpp(const CppOptions& options,
+                        const IoDelegate& io_delegate) {
+  unique_ptr<AidlInterface> interface;
+  std::vector<std::unique_ptr<AidlImport>> imports;
+  unique_ptr<cpp::TypeNamespace> types(new cpp::TypeNamespace());
+  types->Init();
+  AidlError err = internals::load_and_validate_aidl(
+      std::vector<std::string>{},  // no preprocessed files
+      options.ImportPaths(),
+      options.InputFileName(),
+      io_delegate,
+      types.get(),
+      &interface,
+      &imports);
+  if (err != AidlError::OK) {
+    return 1;
+  }
+
+  if (!write_cpp_dep_file(options, *interface, imports, io_delegate)) {
+    return 1;
+  }
+
+  return (cpp::GenerateCpp(options, *types, *interface, io_delegate)) ? 0 : 1;
+}
+
+int compile_aidl_to_java(const JavaOptions& options,
+                         const IoDelegate& io_delegate) {
+  unique_ptr<AidlInterface> interface;
+  std::vector<std::unique_ptr<AidlImport>> imports;
+  unique_ptr<java::JavaTypeNamespace> types(new java::JavaTypeNamespace());
+  types->Init();
+  AidlError aidl_err = internals::load_and_validate_aidl(
+      options.preprocessed_files_,
+      options.import_paths_,
+      options.input_file_name_,
+      io_delegate,
+      types.get(),
+      &interface,
+      &imports);
+  if (aidl_err == AidlError::FOUND_PARCELABLE && !options.fail_on_parcelable_) {
+    // We aborted code generation because this file contains parcelables.
+    // However, we were not told to complain if we find parcelables.
+    // Just generate a dep file and exit quietly.  The dep file is for a legacy
+    // use case by the SDK.
+    write_java_dep_file(options, imports, io_delegate, "");
+    return 0;
+  }
+  if (aidl_err != AidlError::OK) {
+    return 1;
+  }
+
+  string output_file_name = options.output_file_name_;
+  // if needed, generate the output file name from the base folder
+  if (output_file_name.empty() && !options.output_base_folder_.empty()) {
+    output_file_name = generate_outputFileName(options, *interface);
+  }
+
+  // make sure the folders of the output file all exists
+  if (!io_delegate.CreatePathForFile(output_file_name)) {
+    return 1;
+  }
+
+  if (!write_java_dep_file(options, imports, io_delegate, output_file_name)) {
+    return 1;
+  }
+
+  return generate_java(output_file_name, options.input_file_name_.c_str(),
+                       interface.get(), types.get(), io_delegate);
+}
+
+bool preprocess_aidl(const JavaOptions& options,
+                     const IoDelegate& io_delegate) {
+  unique_ptr<CodeWriter> writer =
+      io_delegate.GetCodeWriter(options.output_file_name_);
+
+  for (const auto& file : options.files_to_preprocess_) {
+    Parser p{io_delegate};
+    if (!p.ParseFile(file))
+      return false;
+    AidlDocument* doc = p.GetDocument();
+    string line;
+
+    const AidlInterface* interface = doc->GetInterface();
+
+    if (interface != nullptr &&
+        !writer->Write("interface %s;\n",
+                       interface->GetCanonicalName().c_str())) {
+      return false;
+    }
+
+    for (const auto& parcelable : doc->GetParcelables()) {
+      if (!writer->Write("parcelable %s;\n",
+                         parcelable->GetCanonicalName().c_str())) {
+        return false;
+      }
+    }
+  }
+
+  return writer->Close();
+}
+
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/aidl.h b/aidl/aidl.h
new file mode 100644
index 0000000..2e5b0ee
--- /dev/null
+++ b/aidl/aidl.h
@@ -0,0 +1,74 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_AIDL_H_
+#define AIDL_AIDL_H_
+
+#include <limits>
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "aidl_language.h"
+#include "io_delegate.h"
+#include "options.h"
+#include "type_namespace.h"
+
+namespace android {
+namespace aidl {
+
+enum class AidlError {
+  UNKOWN = std::numeric_limits<int32_t>::min(),
+  BAD_PRE_PROCESSED_FILE,
+  PARSE_ERROR,
+  FOUND_PARCELABLE,
+  BAD_PACKAGE,
+  BAD_IMPORT,
+  BAD_TYPE,
+  BAD_METHOD_ID,
+  GENERATION_ERROR,
+  BAD_CONSTANTS,
+
+  OK = 0,
+};
+
+int compile_aidl_to_cpp(const CppOptions& options,
+                        const IoDelegate& io_delegate);
+int compile_aidl_to_java(const JavaOptions& options,
+                         const IoDelegate& io_delegate);
+bool preprocess_aidl(const JavaOptions& options,
+                     const IoDelegate& io_delegate);
+
+namespace internals {
+
+AidlError load_and_validate_aidl(
+    const std::vector<std::string>& preprocessed_files,
+    const std::vector<std::string>& import_paths,
+    const std::string& input_file_name,
+    const IoDelegate& io_delegate,
+    TypeNamespace* types,
+    std::unique_ptr<AidlInterface>* returned_interface,
+    std::vector<std::unique_ptr<AidlImport>>* returned_imports);
+
+bool parse_preprocessed_file(const IoDelegate& io_delegate,
+                             const std::string& filename, TypeNamespace* types);
+
+} // namespace internals
+
+}  // namespace android
+}  // namespace aidl
+
+#endif  // AIDL_AIDL_H_
diff --git a/aidl/aidl_language.cpp b/aidl/aidl_language.cpp
new file mode 100644
index 0000000..bbe305b
--- /dev/null
+++ b/aidl/aidl_language.cpp
@@ -0,0 +1,312 @@
+#include "aidl_language.h"
+
+#include <iostream>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string>
+
+#include <android-base/parseint.h>
+#include <android-base/strings.h>
+
+#include "aidl_language_y.h"
+#include "logging.h"
+
+#ifdef _WIN32
+int isatty(int  fd)
+{
+    return (fd == 0);
+}
+#endif
+
+using android::aidl::IoDelegate;
+using android::base::Join;
+using android::base::Split;
+using std::cerr;
+using std::endl;
+using std::string;
+using std::unique_ptr;
+
+void yylex_init(void **);
+void yylex_destroy(void *);
+void yyset_in(FILE *f, void *);
+int yyparse(Parser*);
+YY_BUFFER_STATE yy_scan_buffer(char *, size_t, void *);
+void yy_delete_buffer(YY_BUFFER_STATE, void *);
+
+AidlToken::AidlToken(const std::string& text, const std::string& comments)
+    : text_(text),
+      comments_(comments) {}
+
+AidlType::AidlType(const std::string& name, unsigned line,
+                   const std::string& comments, bool is_array)
+    : name_(name),
+      line_(line),
+      is_array_(is_array),
+      comments_(comments) {}
+
+string AidlType::ToString() const {
+  return name_ + (is_array_ ? "[]" : "");
+}
+
+AidlArgument::AidlArgument(AidlArgument::Direction direction, AidlType* type,
+                           std::string name, unsigned line)
+    : type_(type),
+      direction_(direction),
+      direction_specified_(true),
+      name_(name),
+      line_(line) {}
+
+AidlArgument::AidlArgument(AidlType* type, std::string name, unsigned line)
+    : type_(type),
+      direction_(AidlArgument::IN_DIR),
+      direction_specified_(false),
+      name_(name),
+      line_(line) {}
+
+string AidlArgument::ToString() const {
+  string ret;
+
+  if (direction_specified_) {
+    switch(direction_) {
+    case AidlArgument::IN_DIR:
+      ret += "in ";
+      break;
+    case AidlArgument::OUT_DIR:
+      ret += "out ";
+      break;
+    case AidlArgument::INOUT_DIR:
+      ret += "inout ";
+      break;
+    }
+  }
+
+  ret += type_->ToString();
+  ret += " ";
+  ret += name_;
+
+  return ret;
+}
+
+AidlIntConstant::AidlIntConstant(std::string name, int32_t value)
+    : name_(name),
+      value_(value),
+      is_valid_(true) {}
+
+AidlIntConstant::AidlIntConstant(std::string name,
+                                 std::string value,
+                                 unsigned line_number)
+    : name_(name) {
+  uint32_t unsigned_val;
+  if (!android::base::ParseUint(value.c_str(), &unsigned_val)) {
+    is_valid_ = false;
+    LOG(ERROR) << "Found invalid int value '" << value
+               << "' on line " << line_number;
+  } else {
+    // Converting from unsigned to signed integer.
+    value_ = unsigned_val;
+    is_valid_ = true;
+  }
+}
+
+AidlStringConstant::AidlStringConstant(std::string name,
+                                       std::string value,
+                                       unsigned line_number)
+    : name_(name),
+      value_(value) {
+  is_valid_ = true;
+  for (size_t i = 0; i < value_.length(); ++i) {
+    const char& c = value_[i];
+    if (c <= 0x1f || // control characters are < 0x20
+        c >= 0x7f || // DEL is 0x7f
+        c == '\\') { // Disallow backslashes for future proofing.
+      LOG(ERROR) << "Found invalid character at index " << i
+                 << " in string constant '" << value_
+                 << "' beginning on line " << line_number;
+      is_valid_ = false;
+      break;
+    }
+  }
+}
+
+AidlMethod::AidlMethod(bool oneway, AidlType* type, std::string name,
+                       std::vector<std::unique_ptr<AidlArgument>>* args,
+                       unsigned line, const std::string& comments, int id)
+    : oneway_(oneway),
+      comments_(comments),
+      type_(type),
+      name_(name),
+      line_(line),
+      arguments_(std::move(*args)),
+      id_(id) {
+  has_id_ = true;
+  delete args;
+  for (const unique_ptr<AidlArgument>& a : arguments_) {
+    if (a->IsIn()) { in_arguments_.push_back(a.get()); }
+    if (a->IsOut()) { out_arguments_.push_back(a.get()); }
+  }
+}
+
+AidlMethod::AidlMethod(bool oneway, AidlType* type, std::string name,
+                       std::vector<std::unique_ptr<AidlArgument>>* args,
+                       unsigned line, const std::string& comments)
+    : AidlMethod(oneway, type, name, args, line, comments, 0) {
+  has_id_ = false;
+}
+
+Parser::Parser(const IoDelegate& io_delegate)
+    : io_delegate_(io_delegate) {
+  yylex_init(&scanner_);
+}
+
+AidlParcelable::AidlParcelable(AidlQualifiedName* name, unsigned line,
+                               const std::vector<std::string>& package,
+                               const std::string& cpp_header)
+    : name_(name),
+      line_(line),
+      package_(package),
+      cpp_header_(cpp_header) {
+  // Strip off quotation marks if we actually have a cpp header.
+  if (cpp_header_.length() >= 2) {
+    cpp_header_ = cpp_header_.substr(1, cpp_header_.length() - 2);
+  }
+}
+
+std::string AidlParcelable::GetPackage() const {
+  return Join(package_, '.');
+}
+
+std::string AidlParcelable::GetCanonicalName() const {
+  if (package_.empty()) {
+    return GetName();
+  }
+  return GetPackage() + "." + GetName();
+}
+
+AidlInterface::AidlInterface(const std::string& name, unsigned line,
+                             const std::string& comments, bool oneway,
+                             std::vector<std::unique_ptr<AidlMember>>* members,
+                             const std::vector<std::string>& package)
+    : name_(name),
+      comments_(comments),
+      line_(line),
+      oneway_(oneway),
+      package_(package) {
+  for (auto& member : *members) {
+    AidlMember* local = member.release();
+    AidlMethod* method = local->AsMethod();
+    AidlIntConstant* int_constant = local->AsIntConstant();
+    AidlStringConstant* string_constant = local->AsStringConstant();
+
+    if (method) {
+      methods_.emplace_back(method);
+    } else if (int_constant) {
+      int_constants_.emplace_back(int_constant);
+    } else if (string_constant) {
+      string_constants_.emplace_back(string_constant);
+    } else {
+      LOG(FATAL) << "Member is neither method nor constant!";
+    }
+  }
+
+  delete members;
+}
+
+std::string AidlInterface::GetPackage() const {
+  return Join(package_, '.');
+}
+
+std::string AidlInterface::GetCanonicalName() const {
+  if (package_.empty()) {
+    return GetName();
+  }
+  return GetPackage() + "." + GetName();
+}
+
+AidlDocument::AidlDocument(AidlInterface* interface)
+    : interface_(interface) {}
+
+AidlQualifiedName::AidlQualifiedName(std::string term,
+                                     std::string comments)
+    : terms_({term}),
+      comments_(comments) {
+  if (term.find('.') != string::npos) {
+    terms_ = Split(term, ".");
+    for (const auto& term: terms_) {
+      if (term.empty()) {
+        LOG(FATAL) << "Malformed qualified identifier: '" << term << "'";
+      }
+    }
+  }
+}
+
+void AidlQualifiedName::AddTerm(const std::string& term) {
+  terms_.push_back(term);
+}
+
+AidlImport::AidlImport(const std::string& from,
+                       const std::string& needed_class, unsigned line)
+    : from_(from),
+      needed_class_(needed_class),
+      line_(line) {}
+
+Parser::~Parser() {
+  if (raw_buffer_) {
+    yy_delete_buffer(buffer_, scanner_);
+    raw_buffer_.reset();
+  }
+  yylex_destroy(scanner_);
+}
+
+bool Parser::ParseFile(const string& filename) {
+  // Make sure we can read the file first, before trashing previous state.
+  unique_ptr<string> new_buffer = io_delegate_.GetFileContents(filename);
+  if (!new_buffer) {
+    LOG(ERROR) << "Error while opening file for parsing: '" << filename << "'";
+    return false;
+  }
+
+  // Throw away old parsing state if we have any.
+  if (raw_buffer_) {
+    yy_delete_buffer(buffer_, scanner_);
+    raw_buffer_.reset();
+  }
+
+  raw_buffer_ = std::move(new_buffer);
+  // We're going to scan this buffer in place, and yacc demands we put two
+  // nulls at the end.
+  raw_buffer_->append(2u, '\0');
+  filename_ = filename;
+  package_.reset();
+  error_ = 0;
+  document_.reset();
+
+  buffer_ = yy_scan_buffer(&(*raw_buffer_)[0], raw_buffer_->length(), scanner_);
+
+  if (yy::parser(this).parse() != 0 || error_ != 0) {
+    return false;}
+
+  if (document_.get() != nullptr)
+    return true;
+
+  LOG(ERROR) << "Parser succeeded but yielded no document!";
+  return false;
+}
+
+void Parser::ReportError(const string& err, unsigned line) {
+  cerr << filename_ << ":" << line << ": " << err << endl;
+  error_ = 1;
+}
+
+std::vector<std::string> Parser::Package() const {
+  if (!package_) {
+    return {};
+  }
+  return package_->GetTerms();
+}
+
+void Parser::AddImport(AidlQualifiedName* name, unsigned line) {
+  imports_.emplace_back(new AidlImport(this->FileName(),
+                                       name->GetDotName(), line));
+  delete name;
+}
diff --git a/aidl/aidl_language.h b/aidl/aidl_language.h
new file mode 100644
index 0000000..e27cd10
--- /dev/null
+++ b/aidl/aidl_language.h
@@ -0,0 +1,428 @@
+#ifndef AIDL_AIDL_LANGUAGE_H_
+#define AIDL_AIDL_LANGUAGE_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <android-base/macros.h>
+#include <android-base/strings.h>
+
+#include <io_delegate.h>
+
+struct yy_buffer_state;
+typedef yy_buffer_state* YY_BUFFER_STATE;
+
+class AidlToken {
+ public:
+  AidlToken(const std::string& text, const std::string& comments);
+
+  const std::string& GetText() const { return text_; }
+  const std::string& GetComments() const { return comments_; }
+
+ private:
+  std::string text_;
+  std::string comments_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlToken);
+};
+
+class AidlNode {
+ public:
+  AidlNode() = default;
+  virtual ~AidlNode() = default;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AidlNode);
+};
+
+namespace android {
+namespace aidl {
+
+class ValidatableType;
+
+}  // namespace aidl
+}  // namespace android
+
+class AidlAnnotatable : public AidlNode {
+ public:
+  enum Annotation : uint32_t {
+    AnnotationNone = 0,
+    AnnotationNullable = 1 << 0,
+    AnnotationUtf8 = 1 << 1,
+    AnnotationUtf8InCpp = 1 << 2,
+  };
+
+  AidlAnnotatable() = default;
+  virtual ~AidlAnnotatable() = default;
+
+  void Annotate(AidlAnnotatable::Annotation annotation) {
+    annotations_ =
+        static_cast<AidlAnnotatable::Annotation>(annotations_ | annotation);
+  }
+  bool IsNullable() const {
+    return annotations_ & AnnotationNullable;
+  }
+  bool IsUtf8() const {
+    return annotations_ & AnnotationUtf8;
+  }
+  bool IsUtf8InCpp() const {
+    return annotations_ & AnnotationUtf8InCpp;
+  }
+
+ private:
+  Annotation annotations_ = AnnotationNone;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlAnnotatable);
+};
+
+class AidlType : public AidlAnnotatable {
+ public:
+  AidlType(const std::string& name, unsigned line,
+           const std::string& comments, bool is_array);
+  virtual ~AidlType() = default;
+
+  const std::string& GetName() const { return name_; }
+  unsigned GetLine() const { return line_; }
+  bool IsArray() const { return is_array_; }
+  const std::string& GetComments() const { return comments_; }
+
+  std::string ToString() const;
+
+  void SetLanguageType(const android::aidl::ValidatableType* language_type) {
+    language_type_ = language_type;
+  }
+
+  template<typename T>
+  const T* GetLanguageType() const {
+    return reinterpret_cast<const T*>(language_type_);
+  }
+
+ private:
+  std::string name_;
+  unsigned line_;
+  bool is_array_;
+  std::string comments_;
+  const android::aidl::ValidatableType* language_type_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlType);
+};
+
+class AidlArgument : public AidlNode {
+ public:
+  enum Direction { IN_DIR = 1, OUT_DIR = 2, INOUT_DIR = 3 };
+
+  AidlArgument(AidlArgument::Direction direction, AidlType* type,
+               std::string name, unsigned line);
+  AidlArgument(AidlType* type, std::string name, unsigned line);
+  virtual ~AidlArgument() = default;
+
+  Direction GetDirection() const { return direction_; }
+  bool IsOut() const { return direction_ & OUT_DIR; }
+  bool IsIn() const { return direction_ & IN_DIR; }
+  bool DirectionWasSpecified() const { return direction_specified_; }
+
+  std::string GetName() const { return name_; }
+  int GetLine() const { return line_; }
+  const AidlType& GetType() const { return *type_; }
+  AidlType* GetMutableType() { return type_.get(); }
+
+  std::string ToString() const;
+
+ private:
+  std::unique_ptr<AidlType> type_;
+  Direction direction_;
+  bool direction_specified_;
+  std::string name_;
+  unsigned line_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlArgument);
+};
+
+class AidlMethod;
+class AidlIntConstant;
+class AidlStringConstant;
+class AidlMember : public AidlNode {
+ public:
+  AidlMember() = default;
+  virtual ~AidlMember() = default;
+
+  virtual AidlMethod* AsMethod() { return nullptr; }
+  virtual AidlIntConstant* AsIntConstant() { return nullptr; }
+  virtual AidlStringConstant* AsStringConstant() { return nullptr; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(AidlMember);
+};
+
+class AidlIntConstant : public AidlMember {
+ public:
+  AidlIntConstant(std::string name, int32_t value);
+  AidlIntConstant(std::string name, std::string value, unsigned line_number);
+  virtual ~AidlIntConstant() = default;
+
+  const std::string& GetName() const { return name_; }
+  int GetValue() const { return value_; }
+  bool IsValid() const { return is_valid_; }
+
+  AidlIntConstant* AsIntConstant() override { return this; }
+
+ private:
+  std::string name_;
+  int32_t value_;
+  bool is_valid_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlIntConstant);
+};
+
+class AidlStringConstant : public AidlMember {
+ public:
+  AidlStringConstant(std::string name, std::string value, unsigned line_number);
+  virtual ~AidlStringConstant() = default;
+
+  const std::string& GetName() const { return name_; }
+  const std::string& GetValue() const { return value_; }
+  bool IsValid() const { return is_valid_; }
+
+  AidlStringConstant* AsStringConstant() override { return this; }
+
+ private:
+  std::string name_;
+  std::string value_;
+  bool is_valid_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlStringConstant);
+};
+
+class AidlMethod : public AidlMember {
+ public:
+  AidlMethod(bool oneway, AidlType* type, std::string name,
+             std::vector<std::unique_ptr<AidlArgument>>* args,
+             unsigned line, const std::string& comments);
+  AidlMethod(bool oneway, AidlType* type, std::string name,
+             std::vector<std::unique_ptr<AidlArgument>>* args,
+             unsigned line, const std::string& comments, int id);
+  virtual ~AidlMethod() = default;
+
+  AidlMethod* AsMethod() override { return this; }
+
+  const std::string& GetComments() const { return comments_; }
+  const AidlType& GetType() const { return *type_; }
+  AidlType* GetMutableType() { return type_.get(); }
+  bool IsOneway() const { return oneway_; }
+  const std::string& GetName() const { return name_; }
+  unsigned GetLine() const { return line_; }
+  bool HasId() const { return has_id_; }
+  int GetId() { return id_; }
+  void SetId(unsigned id) { id_ = id; }
+
+  const std::vector<std::unique_ptr<AidlArgument>>& GetArguments() const {
+    return arguments_;
+  }
+  // An inout parameter will appear in both GetInArguments()
+  // and GetOutArguments().  AidlMethod retains ownership of the argument
+  // pointers returned in this way.
+  const std::vector<const AidlArgument*>& GetInArguments() const {
+    return in_arguments_;
+  }
+  const std::vector<const AidlArgument*>& GetOutArguments() const {
+    return out_arguments_;
+  }
+
+ private:
+  bool oneway_;
+  std::string comments_;
+  std::unique_ptr<AidlType> type_;
+  std::string name_;
+  unsigned line_;
+  const std::vector<std::unique_ptr<AidlArgument>> arguments_;
+  std::vector<const AidlArgument*> in_arguments_;
+  std::vector<const AidlArgument*> out_arguments_;
+  bool has_id_;
+  int id_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlMethod);
+};
+
+class AidlParcelable;
+class AidlInterface;
+class AidlDocument : public AidlNode {
+ public:
+  AidlDocument() = default;
+  explicit AidlDocument(AidlInterface* interface);
+  virtual ~AidlDocument() = default;
+
+  const AidlInterface* GetInterface() const { return interface_.get(); }
+  AidlInterface* ReleaseInterface() { return interface_.release(); }
+
+  const std::vector<std::unique_ptr<AidlParcelable>>& GetParcelables() const {
+    return parcelables_;
+  }
+
+  void AddParcelable(AidlParcelable* parcelable) {
+    parcelables_.push_back(std::unique_ptr<AidlParcelable>(parcelable));
+  }
+
+ private:
+  std::vector<std::unique_ptr<AidlParcelable>> parcelables_;
+  std::unique_ptr<AidlInterface> interface_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlDocument);
+};
+
+class AidlQualifiedName : public AidlNode {
+ public:
+  AidlQualifiedName(std::string term, std::string comments);
+  virtual ~AidlQualifiedName() = default;
+
+  const std::vector<std::string>& GetTerms() const { return terms_; }
+  const std::string& GetComments() const { return comments_; }
+  std::string GetDotName() const { return android::base::Join(terms_, '.'); }
+
+  void AddTerm(const std::string& term);
+
+ private:
+  std::vector<std::string> terms_;
+  std::string comments_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlQualifiedName);
+};
+
+class AidlParcelable : public AidlNode {
+ public:
+  AidlParcelable(AidlQualifiedName* name, unsigned line,
+                 const std::vector<std::string>& package,
+                 const std::string& cpp_header = "");
+  virtual ~AidlParcelable() = default;
+
+  std::string GetName() const { return name_->GetDotName(); }
+  unsigned GetLine() const { return line_; }
+  std::string GetPackage() const;
+  const std::vector<std::string>& GetSplitPackage() const { return package_; }
+  std::string GetCppHeader() const { return cpp_header_; }
+  std::string GetCanonicalName() const;
+
+ private:
+  std::unique_ptr<AidlQualifiedName> name_;
+  unsigned line_;
+  const std::vector<std::string> package_;
+  std::string cpp_header_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlParcelable);
+};
+
+class AidlInterface : public AidlAnnotatable {
+ public:
+  AidlInterface(const std::string& name, unsigned line,
+                const std::string& comments, bool oneway_,
+                std::vector<std::unique_ptr<AidlMember>>* members,
+                const std::vector<std::string>& package);
+  virtual ~AidlInterface() = default;
+
+  const std::string& GetName() const { return name_; }
+  unsigned GetLine() const { return line_; }
+  const std::string& GetComments() const { return comments_; }
+  bool IsOneway() const { return oneway_; }
+  const std::vector<std::unique_ptr<AidlMethod>>& GetMethods() const
+      { return methods_; }
+  const std::vector<std::unique_ptr<AidlIntConstant>>& GetIntConstants() const
+      { return int_constants_; }
+  const std::vector<std::unique_ptr<AidlStringConstant>>&
+      GetStringConstants() const { return string_constants_; }
+  std::string GetPackage() const;
+  std::string GetCanonicalName() const;
+  const std::vector<std::string>& GetSplitPackage() const { return package_; }
+
+  void SetLanguageType(const android::aidl::ValidatableType* language_type) {
+    language_type_ = language_type;
+  }
+
+  template<typename T>
+  const T* GetLanguageType() const {
+    return reinterpret_cast<const T*>(language_type_);
+  }
+
+ private:
+  std::string name_;
+  std::string comments_;
+  unsigned line_;
+  bool oneway_;
+  std::vector<std::unique_ptr<AidlMethod>> methods_;
+  std::vector<std::unique_ptr<AidlIntConstant>> int_constants_;
+  std::vector<std::unique_ptr<AidlStringConstant>> string_constants_;
+  std::vector<std::string> package_;
+
+  const android::aidl::ValidatableType* language_type_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlInterface);
+};
+
+class AidlImport : public AidlNode {
+ public:
+  AidlImport(const std::string& from, const std::string& needed_class,
+             unsigned line);
+  virtual ~AidlImport() = default;
+
+  const std::string& GetFileFrom() const { return from_; }
+  const std::string& GetFilename() const { return filename_; }
+  const std::string& GetNeededClass() const { return needed_class_; }
+  unsigned GetLine() const { return line_; }
+
+  void SetFilename(const std::string& filename) { filename_ = filename; }
+
+ private:
+  std::string from_;
+  std::string filename_;
+  std::string needed_class_;
+  unsigned line_;
+
+  DISALLOW_COPY_AND_ASSIGN(AidlImport);
+};
+
+class Parser {
+ public:
+  explicit Parser(const android::aidl::IoDelegate& io_delegate);
+  ~Parser();
+
+  // Parse contents of file |filename|.
+  bool ParseFile(const std::string& filename);
+
+  void ReportError(const std::string& err, unsigned line);
+
+  bool FoundNoErrors() const { return error_ == 0; }
+  const std::string& FileName() const { return filename_; }
+  void* Scanner() const { return scanner_; }
+
+  void SetDocument(AidlDocument* doc) { document_.reset(doc); };
+
+  void AddImport(AidlQualifiedName* name, unsigned line);
+
+  std::vector<std::string> Package() const;
+  void SetPackage(AidlQualifiedName* name) { package_.reset(name); }
+
+  AidlDocument* GetDocument() const { return document_.get(); }
+  AidlDocument* ReleaseDocument() { return document_.release(); }
+  const std::vector<std::unique_ptr<AidlImport>>& GetImports() {
+    return imports_;
+  }
+
+  void ReleaseImports(std::vector<std::unique_ptr<AidlImport>>* ret) {
+      *ret = std::move(imports_);
+      imports_.clear();
+  }
+
+ private:
+  const android::aidl::IoDelegate& io_delegate_;
+  int error_ = 0;
+  std::string filename_;
+  std::unique_ptr<AidlQualifiedName> package_;
+  void* scanner_ = nullptr;
+  std::unique_ptr<AidlDocument> document_;
+  std::vector<std::unique_ptr<AidlImport>> imports_;
+  std::unique_ptr<std::string> raw_buffer_;
+  YY_BUFFER_STATE buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(Parser);
+};
+
+#endif // AIDL_AIDL_LANGUAGE_H_
diff --git a/aidl/aidl_language_l.ll b/aidl/aidl_language_l.ll
new file mode 100644
index 0000000..a56758b
--- /dev/null
+++ b/aidl/aidl_language_l.ll
@@ -0,0 +1,106 @@
+%{
+#include <string.h>
+#include <stdlib.h>
+
+#include "aidl_language.h"
+#include "aidl_language_y.h"
+
+#define YY_USER_ACTION yylloc->columns(yyleng);
+%}
+
+%option yylineno
+%option noyywrap
+%option reentrant
+%option bison-bridge
+%option bison-locations
+
+%x COPYING LONG_COMMENT
+
+identifier  [_a-zA-Z][_a-zA-Z0-9]*
+whitespace  ([ \t\r]+)
+intvalue    [-+]?(0|[1-9][0-9]*)
+hexvalue    0[x|X][0-9a-fA-F]+
+
+%%
+%{
+  /* This happens at every call to yylex (every time we receive one token) */
+  std::string extra_text;
+  yylloc->step();
+%}
+
+
+\%\%\{                { extra_text += "/**"; BEGIN(COPYING); }
+<COPYING>\}\%\%       { extra_text += "**/"; yylloc->step(); BEGIN(INITIAL); }
+<COPYING>.*           { extra_text += yytext; }
+<COPYING>\n+          { extra_text += yytext; yylloc->lines(yyleng); }
+
+\/\*                  { extra_text += yytext; BEGIN(LONG_COMMENT); }
+<LONG_COMMENT>\*+\/   { extra_text += yytext; yylloc->step(); BEGIN(INITIAL);  }
+<LONG_COMMENT>\*+     { extra_text += yytext; }
+<LONG_COMMENT>\n+     { extra_text += yytext; yylloc->lines(yyleng); }
+<LONG_COMMENT>[^*\n]+ { extra_text += yytext; }
+
+\"[^\"]*\"            { yylval->token = new AidlToken(yytext, extra_text);
+                        return yy::parser::token::C_STR; }
+
+\/\/.*\n              { extra_text += yytext; yylloc->lines(1); yylloc->step(); }
+
+\n+                   { yylloc->lines(yyleng); yylloc->step(); }
+{whitespace}          {}
+<<EOF>>               { yyterminate(); }
+
+    /* symbols */
+;                     { return ';'; }
+\{                    { return '{'; }
+\}                    { return '}'; }
+=                     { return '='; }
+,                     { return ','; }
+\.                    { return '.'; }
+\(                    { return '('; }
+\)                    { return ')'; }
+\[                    { return '['; }
+\]                    { return ']'; }
+\<                    { return '<'; }
+\>                    { return '>'; }
+
+    /* keywords */
+parcelable            { return yy::parser::token::PARCELABLE; }
+import                { return yy::parser::token::IMPORT; }
+package               { return yy::parser::token::PACKAGE; }
+int                   { return yy::parser::token::INT; }
+String                { return yy::parser::token::STRING; }
+in                    { return yy::parser::token::IN; }
+out                   { return yy::parser::token::OUT; }
+inout                 { return yy::parser::token::INOUT; }
+cpp_header            { return yy::parser::token::CPP_HEADER; }
+const                 { return yy::parser::token::CONST; }
+@nullable             { return yy::parser::token::ANNOTATION_NULLABLE; }
+@utf8                 { return yy::parser::token::ANNOTATION_UTF8; }
+@utf8InCpp            { return yy::parser::token::ANNOTATION_UTF8_CPP; }
+
+interface             { yylval->token = new AidlToken("interface", extra_text);
+                        return yy::parser::token::INTERFACE;
+                      }
+oneway                { yylval->token = new AidlToken("oneway", extra_text);
+                        return yy::parser::token::ONEWAY;
+                      }
+
+    /* scalars */
+{identifier}          { yylval->token = new AidlToken(yytext, extra_text);
+                        return yy::parser::token::IDENTIFIER;
+                      }
+{intvalue}            { yylval->integer = std::stoi(yytext);
+                        return yy::parser::token::INTVALUE; }
+{hexvalue}            { yylval->token = new AidlToken(yytext, extra_text);
+                        return yy::parser::token::HEXVALUE; }
+
+    /* syntax error! */
+.                     { printf("UNKNOWN(%s)", yytext);
+                        yylval->token = new AidlToken(yytext, extra_text);
+                        return yy::parser::token::IDENTIFIER;
+                      }
+
+%%
+
+// comment and whitespace handling
+// ================================================
diff --git a/aidl/aidl_language_y.yy b/aidl/aidl_language_y.yy
new file mode 100644
index 0000000..4ad6754
--- /dev/null
+++ b/aidl/aidl_language_y.yy
@@ -0,0 +1,321 @@
+%{
+#include "aidl_language.h"
+#include "aidl_language_y.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int yylex(yy::parser::semantic_type *, yy::parser::location_type *, void *);
+
+#define lex_scanner ps->Scanner()
+
+%}
+
+%parse-param { Parser* ps }
+%lex-param { void *lex_scanner }
+
+%pure-parser
+%skeleton "glr.cc"
+
+%union {
+    AidlToken* token;
+    int integer;
+    std::string *str;
+    AidlType::Annotation annotation;
+    AidlType::Annotation annotation_list;
+    AidlType* type;
+    AidlType* unannotated_type;
+    AidlArgument* arg;
+    AidlArgument::Direction direction;
+    std::vector<std::unique_ptr<AidlArgument>>* arg_list;
+    AidlMethod* method;
+    AidlMember* constant;
+    std::vector<std::unique_ptr<AidlMember>>* members;
+    AidlQualifiedName* qname;
+    AidlInterface* interface_obj;
+    AidlParcelable* parcelable;
+    AidlDocument* parcelable_list;
+}
+
+%token<token> IDENTIFIER INTERFACE ONEWAY C_STR HEXVALUE
+%token<integer> INTVALUE
+
+%token '(' ')' ',' '=' '[' ']' '<' '>' '.' '{' '}' ';'
+%token IN OUT INOUT PACKAGE IMPORT PARCELABLE CPP_HEADER CONST INT STRING
+%token ANNOTATION_NULLABLE ANNOTATION_UTF8 ANNOTATION_UTF8_CPP
+
+%type<parcelable_list> parcelable_decls
+%type<parcelable> parcelable_decl
+%type<members> members
+%type<interface_obj> interface_decl
+%type<method> method_decl
+%type<constant> constant_decl
+%type<annotation> annotation
+%type<annotation_list>annotation_list
+%type<type> type
+%type<unannotated_type> unannotated_type
+%type<arg_list> arg_list
+%type<arg> arg
+%type<direction> direction
+%type<str> generic_list
+%type<qname> qualified_name
+
+%type<token> identifier error
+%%
+document
+ : package imports parcelable_decls
+  { ps->SetDocument($3); }
+ | package imports interface_decl
+  { ps->SetDocument(new AidlDocument($3)); };
+
+/* A couple of tokens that are keywords elsewhere are identifiers when
+ * occurring in the identifier position. Therefore identifier is a
+ * non-terminal, which is either an IDENTIFIER token, or one of the
+ * aforementioned keyword tokens.
+ */
+identifier
+ : IDENTIFIER
+  { $$ = $1; }
+ | CPP_HEADER
+  { $$ = new AidlToken("cpp_header", ""); }
+ | INT
+  { $$ = new AidlToken("int", ""); }
+ | STRING
+  { $$ = new AidlToken("String", ""); }
+ ;
+
+package
+ : {}
+ | PACKAGE qualified_name ';'
+  { ps->SetPackage($2); };
+
+imports
+ : {}
+ | import imports {};
+
+import
+ : IMPORT qualified_name ';'
+  { ps->AddImport($2, @1.begin.line); };
+
+qualified_name
+ : identifier {
+    $$ = new AidlQualifiedName($1->GetText(), $1->GetComments());
+    delete $1;
+  }
+ | qualified_name '.' identifier
+  { $$ = $1;
+    $$->AddTerm($3->GetText());
+  };
+
+parcelable_decls
+ :
+  { $$ = new AidlDocument(); }
+ | parcelable_decls parcelable_decl {
+   $$ = $1;
+   $$->AddParcelable($2);
+  }
+ | parcelable_decls error {
+    fprintf(stderr, "%s:%d: syntax error don't know what to do with \"%s\"\n",
+            ps->FileName().c_str(),
+            @2.begin.line, $2->GetText().c_str());
+    $$ = $1;
+  };
+
+parcelable_decl
+ : PARCELABLE qualified_name ';' {
+    $$ = new AidlParcelable($2, @2.begin.line, ps->Package());
+  }
+ | PARCELABLE qualified_name CPP_HEADER C_STR ';' {
+    $$ = new AidlParcelable($2, @2.begin.line, ps->Package(), $4->GetText());
+  }
+ | PARCELABLE ';' {
+    fprintf(stderr, "%s:%d syntax error in parcelable declaration. Expected type name.\n",
+            ps->FileName().c_str(), @1.begin.line);
+    $$ = NULL;
+  }
+ | PARCELABLE error ';' {
+    fprintf(stderr, "%s:%d syntax error in parcelable declaration. Expected type name, saw \"%s\".\n",
+            ps->FileName().c_str(), @2.begin.line, $2->GetText().c_str());
+    $$ = NULL;
+  };
+
+interface_decl
+ : annotation_list INTERFACE identifier '{' members '}' {
+    $$ = new AidlInterface($3->GetText(), @2.begin.line, $2->GetComments(),
+                           false, $5, ps->Package());
+    $$->Annotate($1);
+    delete $2;
+    delete $3;
+  }
+ | annotation_list ONEWAY INTERFACE identifier '{' members '}' {
+    $$ = new AidlInterface($4->GetText(), @4.begin.line, $2->GetComments(),
+                           true, $6, ps->Package());
+    $$->Annotate($1);
+    delete $2;
+    delete $3;
+    delete $4;
+  }
+ | annotation_list INTERFACE error '{' members '}' {
+    fprintf(stderr, "%s:%d: syntax error in interface declaration.  Expected "
+                    "type name, saw \"%s\"\n",
+            ps->FileName().c_str(), @3.begin.line, $3->GetText().c_str());
+    $$ = NULL;
+    delete $2;
+    delete $3;
+    delete $5;
+  }
+ | annotation_list INTERFACE error '}' {
+    fprintf(stderr, "%s:%d: syntax error in interface declaration.  Expected "
+                    "type name, saw \"%s\"\n",
+            ps->FileName().c_str(), @3.begin.line, $3->GetText().c_str());
+    $$ = NULL;
+    delete $2;
+    delete $3;
+  };
+
+members
+ :
+  { $$ = new std::vector<std::unique_ptr<AidlMember>>(); }
+ | members method_decl
+  { $1->push_back(std::unique_ptr<AidlMember>($2)); }
+ | members constant_decl
+  { $1->push_back(std::unique_ptr<AidlMember>($2)); }
+ | members error ';' {
+    fprintf(stderr, "%s:%d: syntax error before ';' "
+                    "(expected method or constant declaration)\n",
+            ps->FileName().c_str(), @3.begin.line);
+    $$ = $1;
+  };
+
+constant_decl
+ : CONST INT identifier '=' INTVALUE ';' {
+    $$ = new AidlIntConstant($3->GetText(), $5);
+    delete $3;
+   }
+ | CONST INT identifier '=' HEXVALUE ';' {
+    $$ = new AidlIntConstant($3->GetText(), $5->GetText(), @5.begin.line);
+    delete $3;
+   }
+ | CONST STRING identifier '=' C_STR ';' {
+    $$ = new AidlStringConstant($3->GetText(), $5->GetText(), @5.begin.line);
+    delete $3;
+    delete $5;
+   }
+ ;
+
+method_decl
+ : type identifier '(' arg_list ')' ';' {
+    $$ = new AidlMethod(false, $1, $2->GetText(), $4, @2.begin.line,
+                        $1->GetComments());
+    delete $2;
+  }
+ | ONEWAY type identifier '(' arg_list ')' ';' {
+    $$ = new AidlMethod(true, $2, $3->GetText(), $5, @3.begin.line,
+                        $1->GetComments());
+    delete $1;
+    delete $3;
+  }
+ | type identifier '(' arg_list ')' '=' INTVALUE ';' {
+    $$ = new AidlMethod(false, $1, $2->GetText(), $4, @2.begin.line,
+                        $1->GetComments(), $7);
+    delete $2;
+  }
+ | ONEWAY type identifier '(' arg_list ')' '=' INTVALUE ';' {
+    $$ = new AidlMethod(true, $2, $3->GetText(), $5, @3.begin.line,
+                        $1->GetComments(), $8);
+    delete $1;
+    delete $3;
+  };
+
+arg_list
+ :
+  { $$ = new std::vector<std::unique_ptr<AidlArgument>>(); }
+ | arg {
+    $$ = new std::vector<std::unique_ptr<AidlArgument>>();
+    $$->push_back(std::unique_ptr<AidlArgument>($1));
+  }
+ | arg_list ',' arg {
+    $$ = $1;
+    $$->push_back(std::unique_ptr<AidlArgument>($3));
+  }
+ | error {
+    fprintf(stderr, "%s:%d: syntax error in parameter list\n",
+            ps->FileName().c_str(), @1.begin.line);
+    $$ = new std::vector<std::unique_ptr<AidlArgument>>();
+  };
+
+arg
+ : direction type identifier {
+    $$ = new AidlArgument($1, $2, $3->GetText(), @3.begin.line);
+    delete $3;
+  };
+ | type identifier {
+    $$ = new AidlArgument($1, $2->GetText(), @2.begin.line);
+    delete $2;
+  };
+
+unannotated_type
+ : qualified_name {
+    $$ = new AidlType($1->GetDotName(), @1.begin.line, $1->GetComments(), false);
+    delete $1;
+  }
+ | qualified_name '[' ']' {
+    $$ = new AidlType($1->GetDotName(), @1.begin.line, $1->GetComments(),
+                      true);
+    delete $1;
+  }
+ | qualified_name '<' generic_list '>' {
+    $$ = new AidlType($1->GetDotName() + "<" + *$3 + ">", @1.begin.line,
+                      $1->GetComments(), false);
+    delete $1;
+    delete $3;
+  };
+
+type
+ : annotation_list unannotated_type {
+    $$ = $2;
+    $2->Annotate($1);
+  };
+
+generic_list
+ : qualified_name {
+    $$ = new std::string($1->GetDotName());
+    delete $1;
+  }
+ | generic_list ',' qualified_name {
+    $$ = new std::string(*$1 + "," + $3->GetDotName());
+    delete $1;
+    delete $3;
+  };
+
+annotation_list
+ :
+  { $$ = AidlType::AnnotationNone; }
+ | annotation_list annotation
+  { $$ = static_cast<AidlType::Annotation>($1 | $2); };
+
+annotation
+ : ANNOTATION_NULLABLE
+  { $$ = AidlType::AnnotationNullable; }
+ | ANNOTATION_UTF8
+  { $$ = AidlType::AnnotationUtf8; }
+ | ANNOTATION_UTF8_CPP
+  { $$ = AidlType::AnnotationUtf8InCpp; };
+
+direction
+ : IN
+  { $$ = AidlArgument::IN_DIR; }
+ | OUT
+  { $$ = AidlArgument::OUT_DIR; }
+ | INOUT
+  { $$ = AidlArgument::INOUT_DIR; };
+
+%%
+
+#include <ctype.h>
+#include <stdio.h>
+
+void yy::parser::error(const yy::parser::location_type& l,
+                       const std::string& errstr) {
+  ps->ReportError(errstr, l.begin.line);
+}
diff --git a/aidl/aidl_unittest.cpp b/aidl/aidl_unittest.cpp
new file mode 100644
index 0000000..0d2ba53
--- /dev/null
+++ b/aidl/aidl_unittest.cpp
@@ -0,0 +1,399 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include <android-base/stringprintf.h>
+#include <gtest/gtest.h>
+
+#include "aidl.h"
+#include "aidl_language.h"
+#include "tests/fake_io_delegate.h"
+#include "type_cpp.h"
+#include "type_java.h"
+#include "type_namespace.h"
+
+using android::aidl::test::FakeIoDelegate;
+using android::base::StringPrintf;
+using std::set;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+using android::aidl::internals::parse_preprocessed_file;
+
+namespace android {
+namespace aidl {
+namespace {
+
+const char kExpectedDepFileContents[] =
+R"(place/for/output/p/IFoo.java : \
+  p/IFoo.aidl
+
+p/IFoo.aidl :
+)";
+
+const char kExpectedParcelableDepFileContents[] =
+R"( : \
+  p/Foo.aidl
+
+p/Foo.aidl :
+)";
+
+}  // namespace
+
+class AidlTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    java_types_.Init();
+    cpp_types_.Init();
+  }
+
+  unique_ptr<AidlInterface> Parse(const string& path,
+                                  const string& contents,
+                                  TypeNamespace* types,
+                                  AidlError* error = nullptr) {
+    io_delegate_.SetFileContents(path, contents);
+    unique_ptr<AidlInterface> ret;
+    std::vector<std::unique_ptr<AidlImport>> imports;
+    AidlError actual_error = ::android::aidl::internals::load_and_validate_aidl(
+        preprocessed_files_,
+        import_paths_,
+        path,
+        io_delegate_,
+        types,
+        &ret,
+        &imports);
+    if (error != nullptr) {
+      *error = actual_error;
+    }
+    return ret;
+  }
+
+  FakeIoDelegate io_delegate_;
+  vector<string> preprocessed_files_;
+  vector<string> import_paths_;
+  java::JavaTypeNamespace java_types_;
+  cpp::TypeNamespace cpp_types_;
+};
+
+TEST_F(AidlTest, JavaAcceptsMissingPackage) {
+  EXPECT_NE(nullptr, Parse("IFoo.aidl", "interface IFoo { }", &java_types_));
+}
+
+TEST_F(AidlTest, RejectsArraysOfBinders) {
+  import_paths_.push_back("");
+  io_delegate_.SetFileContents("bar/IBar.aidl",
+                               "package bar; interface IBar {}");
+  string path = "foo/IFoo.aidl";
+  string contents = "package foo;\n"
+                    "import bar.IBar;\n"
+                    "interface IFoo { void f(in IBar[] input); }";
+  EXPECT_EQ(nullptr, Parse(path, contents, &java_types_));
+  EXPECT_EQ(nullptr, Parse(path, contents, &cpp_types_));
+}
+
+TEST_F(AidlTest, CppRejectsMissingPackage) {
+  EXPECT_EQ(nullptr, Parse("IFoo.aidl", "interface IFoo { }", &cpp_types_));
+  EXPECT_NE(nullptr,
+            Parse("a/IFoo.aidl", "package a; interface IFoo { }", &cpp_types_));
+}
+
+TEST_F(AidlTest, RejectsOnewayOutParameters) {
+  string oneway_interface =
+      "package a; oneway interface IFoo { void f(out int bar); }";
+  string oneway_method =
+      "package a; interface IBar { oneway void f(out int bar); }";
+  EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_interface, &cpp_types_));
+  EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_interface, &java_types_));
+  EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, &cpp_types_));
+  EXPECT_EQ(nullptr, Parse("a/IBar.aidl", oneway_method, &java_types_));
+}
+
+TEST_F(AidlTest, RejectsOnewayNonVoidReturn) {
+  string oneway_method = "package a; interface IFoo { oneway int f(); }";
+  EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, &cpp_types_));
+  EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, &java_types_));
+}
+
+TEST_F(AidlTest, RejectsNullablePrimitive) {
+  string oneway_method = "package a; interface IFoo { @nullable int f(); }";
+  EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, &cpp_types_));
+  EXPECT_EQ(nullptr, Parse("a/IFoo.aidl", oneway_method, &java_types_));
+}
+
+TEST_F(AidlTest, ParsesNullableAnnotation) {
+  for (auto is_nullable: {true, false}) {
+    auto parse_result = Parse(
+        "a/IFoo.aidl",
+        StringPrintf( "package a; interface IFoo {%s String f(); }",
+                     (is_nullable) ? "@nullable" : ""),
+        &cpp_types_);
+    ASSERT_NE(nullptr, parse_result);
+    ASSERT_FALSE(parse_result->GetMethods().empty());
+    EXPECT_EQ(parse_result->GetMethods()[0]->GetType().IsNullable(),
+              is_nullable);
+  }
+}
+
+TEST_F(AidlTest, ParsesUtf8Annotations) {
+  for (auto is_utf8: {true, false}) {
+    auto parse_result = Parse(
+        "a/IFoo.aidl",
+        StringPrintf( "package a; interface IFoo {%s String f(); }",
+                     (is_utf8) ? "@utf8InCpp" : ""),
+        &cpp_types_);
+    ASSERT_NE(nullptr, parse_result);
+    ASSERT_FALSE(parse_result->GetMethods().empty());
+    EXPECT_EQ(parse_result->GetMethods()[0]->GetType().IsUtf8InCpp(),
+              is_utf8);
+  }
+}
+
+TEST_F(AidlTest, AcceptsOneway) {
+  string oneway_method = "package a; interface IFoo { oneway void f(int a); }";
+  string oneway_interface =
+      "package a; oneway interface IBar { void f(int a); }";
+  EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, &cpp_types_));
+  EXPECT_NE(nullptr, Parse("a/IFoo.aidl", oneway_method, &java_types_));
+  EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, &cpp_types_));
+  EXPECT_NE(nullptr, Parse("a/IBar.aidl", oneway_interface, &java_types_));
+}
+
+TEST_F(AidlTest, ParsesPreprocessedFile) {
+  string simple_content = "parcelable a.Foo;\ninterface b.IBar;";
+  io_delegate_.SetFileContents("path", simple_content);
+  EXPECT_FALSE(java_types_.HasTypeByCanonicalName("a.Foo"));
+  EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &java_types_));
+  EXPECT_TRUE(java_types_.HasTypeByCanonicalName("a.Foo"));
+  EXPECT_TRUE(java_types_.HasTypeByCanonicalName("b.IBar"));
+}
+
+TEST_F(AidlTest, ParsesPreprocessedFileWithWhitespace) {
+  string simple_content = "parcelable    a.Foo;\n  interface b.IBar  ;\t";
+  io_delegate_.SetFileContents("path", simple_content);
+  EXPECT_FALSE(java_types_.HasTypeByCanonicalName("a.Foo"));
+  EXPECT_TRUE(parse_preprocessed_file(io_delegate_, "path", &java_types_));
+  EXPECT_TRUE(java_types_.HasTypeByCanonicalName("a.Foo"));
+  EXPECT_TRUE(java_types_.HasTypeByCanonicalName("b.IBar"));
+}
+
+TEST_F(AidlTest, PreferImportToPreprocessed) {
+  io_delegate_.SetFileContents("preprocessed", "interface another.IBar;");
+  io_delegate_.SetFileContents("one/IBar.aidl", "package one; "
+                                                "interface IBar {}");
+  preprocessed_files_.push_back("preprocessed");
+  import_paths_.push_back("");
+  auto parse_result = Parse(
+      "p/IFoo.aidl", "package p; import one.IBar; interface IFoo {}",
+      &java_types_);
+  EXPECT_NE(nullptr, parse_result);
+  // We expect to know about both kinds of IBar
+  EXPECT_TRUE(java_types_.HasTypeByCanonicalName("one.IBar"));
+  EXPECT_TRUE(java_types_.HasTypeByCanonicalName("another.IBar"));
+  // But if we request just "IBar" we should get our imported one.
+  AidlType ambiguous_type("IBar", 0, "", false /* not an array */);
+  const java::Type* type = java_types_.Find(ambiguous_type);
+  ASSERT_TRUE(type);
+  EXPECT_EQ("one.IBar", type->CanonicalName());
+}
+
+TEST_F(AidlTest, WritePreprocessedFile) {
+  io_delegate_.SetFileContents("p/Outer.aidl",
+                               "package p; parcelable Outer.Inner;");
+  io_delegate_.SetFileContents("one/IBar.aidl", "package one; import p.Outer;"
+                                                "interface IBar {}");
+
+  JavaOptions options;
+  options.output_file_name_ = "preprocessed";
+  options.files_to_preprocess_.resize(2);
+  options.files_to_preprocess_[0] = "p/Outer.aidl";
+  options.files_to_preprocess_[1] = "one/IBar.aidl";
+  EXPECT_TRUE(::android::aidl::preprocess_aidl(options, io_delegate_));
+
+  string output;
+  EXPECT_TRUE(io_delegate_.GetWrittenContents("preprocessed", &output));
+  EXPECT_EQ("parcelable p.Outer.Inner;\ninterface one.IBar;\n", output);
+}
+
+TEST_F(AidlTest, RequireOuterClass) {
+  io_delegate_.SetFileContents("p/Outer.aidl",
+                               "package p; parcelable Outer.Inner;");
+  import_paths_.push_back("");
+  auto parse_result = Parse(
+      "p/IFoo.aidl",
+      "package p; import p.Outer; interface IFoo { void f(in Inner c); }",
+      &java_types_);
+  EXPECT_EQ(nullptr, parse_result);
+}
+
+TEST_F(AidlTest, ParseCompoundParcelableFromPreprocess) {
+  io_delegate_.SetFileContents("preprocessed",
+                               "parcelable p.Outer.Inner;");
+  preprocessed_files_.push_back("preprocessed");
+  auto parse_result = Parse(
+      "p/IFoo.aidl",
+      "package p; interface IFoo { void f(in Inner c); }",
+      &java_types_);
+  // TODO(wiley): This should actually return nullptr because we require
+  //              the outer class name.  However, for legacy reasons,
+  //              this behavior must be maintained.  b/17415692
+  EXPECT_NE(nullptr, parse_result);
+}
+
+TEST_F(AidlTest, FailOnParcelable) {
+  JavaOptions options;
+  options.input_file_name_ = "p/IFoo.aidl";
+  io_delegate_.SetFileContents(options.input_file_name_,
+                               "package p; parcelable IFoo;");
+  // By default, we shouldn't fail on parcelable.
+  EXPECT_EQ(0, ::android::aidl::compile_aidl_to_java(options, io_delegate_));
+  options.fail_on_parcelable_ = true;
+  EXPECT_NE(0, ::android::aidl::compile_aidl_to_java(options, io_delegate_));
+}
+
+TEST_F(AidlTest, FailOnDuplicateConstantNames) {
+  AidlError reported_error;
+  EXPECT_EQ(nullptr,
+            Parse("p/IFoo.aidl",
+                   R"(package p;
+                      interface IFoo {
+                        const String DUPLICATED = "d";
+                        const int DUPLICATED = 1;
+                      }
+                   )",
+                   &cpp_types_,
+                   &reported_error));
+  EXPECT_EQ(AidlError::BAD_CONSTANTS, reported_error);
+}
+
+TEST_F(AidlTest, FailOnMalformedConstHexValue) {
+  AidlError reported_error;
+  EXPECT_EQ(nullptr,
+            Parse("p/IFoo.aidl",
+                   R"(package p;
+                      interface IFoo {
+                        const int BAD_HEX_VALUE = 0xffffffffffffffffff;
+                      }
+                   )",
+                   &cpp_types_,
+                   &reported_error));
+  EXPECT_EQ(AidlError::BAD_CONSTANTS, reported_error);
+}
+
+TEST_F(AidlTest, ParsePositiveConstHexValue) {
+  AidlError reported_error;
+  auto cpp_parse_result =
+    Parse("p/IFoo.aidl",
+           R"(package p;
+              interface IFoo {
+                const int POSITIVE_HEX_VALUE = 0xf5;
+              }
+           )",
+           &cpp_types_,
+           &reported_error);
+  EXPECT_NE(nullptr, cpp_parse_result);
+  const auto& cpp_int_constants = cpp_parse_result->GetIntConstants();
+  EXPECT_EQ((size_t)1, cpp_int_constants.size());
+  EXPECT_EQ("POSITIVE_HEX_VALUE", cpp_int_constants[0]->GetName());
+  EXPECT_EQ(245, cpp_int_constants[0]->GetValue());
+}
+
+TEST_F(AidlTest, ParseNegativeConstHexValue) {
+  AidlError reported_error;
+  auto cpp_parse_result =
+    Parse("p/IFoo.aidl",
+           R"(package p;
+              interface IFoo {
+                const int NEGATIVE_HEX_VALUE = 0xffffffff;
+              }
+           )",
+           &cpp_types_,
+           &reported_error);
+  EXPECT_NE(nullptr, cpp_parse_result);
+  const auto& cpp_int_constants = cpp_parse_result->GetIntConstants();
+  EXPECT_EQ((size_t)1, cpp_int_constants.size());
+  EXPECT_EQ("NEGATIVE_HEX_VALUE", cpp_int_constants[0]->GetName());
+  EXPECT_EQ(-1, cpp_int_constants[0]->GetValue());
+}
+
+TEST_F(AidlTest, UnderstandsNativeParcelables) {
+  io_delegate_.SetFileContents(
+      "p/Bar.aidl",
+      "package p; parcelable Bar cpp_header \"baz/header\";");
+  import_paths_.push_back("");
+  const string input_path = "p/IFoo.aidl";
+  const string input = "package p; import p.Bar; interface IFoo { }";
+
+  // C++ understands C++ specific stuff
+  auto cpp_parse_result = Parse(input_path, input, &cpp_types_);
+  EXPECT_NE(nullptr, cpp_parse_result);
+  auto cpp_type = cpp_types_.FindTypeByCanonicalName("p.Bar");
+  ASSERT_NE(nullptr, cpp_type);
+  EXPECT_EQ("::p::Bar", cpp_type->CppType());
+  set<string> headers;
+  cpp_type->GetHeaders(&headers);
+  EXPECT_EQ(1u, headers.size());
+  EXPECT_EQ(1u, headers.count("baz/header"));
+
+  // Java ignores C++ specific stuff
+  auto java_parse_result = Parse(input_path, input, &java_types_);
+  EXPECT_NE(nullptr, java_parse_result);
+  auto java_type = java_types_.FindTypeByCanonicalName("p.Bar");
+  ASSERT_NE(nullptr, java_type);
+  EXPECT_EQ("p.Bar", java_type->InstantiableName());
+}
+
+TEST_F(AidlTest, WritesCorrectDependencyFile) {
+  // While the in tree build system always gives us an output file name,
+  // other android tools take advantage of our ability to infer the intended
+  // file name.  This test makes sure we handle this correctly.
+  JavaOptions options;
+  options.input_file_name_ = "p/IFoo.aidl";
+  options.output_base_folder_ = "place/for/output";
+  options.dep_file_name_ = "dep/file/path";
+  io_delegate_.SetFileContents(options.input_file_name_,
+                               "package p; interface IFoo {}");
+  EXPECT_EQ(0, ::android::aidl::compile_aidl_to_java(options, io_delegate_));
+  string actual_dep_file_contents;
+  EXPECT_TRUE(io_delegate_.GetWrittenContents(options.dep_file_name_,
+                                              &actual_dep_file_contents));
+  EXPECT_EQ(actual_dep_file_contents, kExpectedDepFileContents);
+}
+
+TEST_F(AidlTest, WritesTrivialDependencyFileForParcelable) {
+  // The SDK uses aidl to decide whether a .aidl file is a parcelable.  It does
+  // this by calling aidl with every .aidl file it finds, then parsing the
+  // generated dependency files.  Those that reference .java output files are
+  // for interfaces and those that do not are parcelables.  However, for both
+  // parcelables and interfaces, we *must* generate a non-empty dependency file.
+  JavaOptions options;
+  options.input_file_name_ = "p/Foo.aidl";
+  options.output_base_folder_ = "place/for/output";
+  options.dep_file_name_ = "dep/file/path";
+  io_delegate_.SetFileContents(options.input_file_name_,
+                               "package p; parcelable Foo;");
+  EXPECT_EQ(0, ::android::aidl::compile_aidl_to_java(options, io_delegate_));
+  string actual_dep_file_contents;
+  EXPECT_TRUE(io_delegate_.GetWrittenContents(options.dep_file_name_,
+                                              &actual_dep_file_contents));
+  EXPECT_EQ(actual_dep_file_contents, kExpectedParcelableDepFileContents);
+}
+
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/ast_cpp.cpp b/aidl/ast_cpp.cpp
new file mode 100644
index 0000000..783b0f3
--- /dev/null
+++ b/aidl/ast_cpp.cpp
@@ -0,0 +1,455 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "ast_cpp.h"
+
+#include <algorithm>
+
+#include "code_writer.h"
+#include "logging.h"
+
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace cpp {
+
+ClassDecl::ClassDecl(const std::string& name, const std::string& parent)
+    : name_(name),
+      parent_(parent) {}
+
+ClassDecl::ClassDecl(const std::string& name, const std::string& parent,
+                     std::vector<unique_ptr<Declaration>> public_members,
+                     std::vector<unique_ptr<Declaration>> private_members)
+    : name_(name),
+      parent_(parent),
+      public_members_(std::move(public_members)),
+      private_members_(std::move(private_members)) {}
+
+void ClassDecl::Write(CodeWriter* to) const {
+  to->Write("class %s ", name_.c_str());
+
+  if (parent_.length() > 0)
+      to->Write(": public %s ", parent_.c_str());
+
+  to->Write("{\n");
+
+  if (!public_members_.empty())
+      to->Write("public:\n");
+
+  for (const auto& dec : public_members_)
+    dec->Write(to);
+
+  if (!private_members_.empty())
+      to->Write("private:\n");
+
+  for (const auto& dec : private_members_)
+    dec->Write(to);
+
+  to->Write("};  // class %s\n", name_.c_str());
+}
+
+void ClassDecl::AddPublic(std::unique_ptr<Declaration> member) {
+  public_members_.push_back(std::move(member));
+}
+
+void ClassDecl::AddPrivate(std::unique_ptr<Declaration> member) {
+  private_members_.push_back(std::move(member));
+}
+
+Enum::EnumField::EnumField(const string& k, const string& v)
+    : key(k),
+      value(v) {}
+
+Enum::Enum(const string& name, const string& base_type)
+    : enum_name_(name), underlying_type_(base_type) {}
+
+Enum::Enum(const string& name) : Enum(name, "") {}
+
+void Enum::Write(CodeWriter* to) const {
+  if (underlying_type_.empty()) {
+    to->Write("enum %s {\n", enum_name_.c_str());
+  } else {
+    to->Write("enum %s : %s {\n", enum_name_.c_str(), underlying_type_.c_str());
+  }
+  for (const auto& field : fields_) {
+    if (field.value.empty()) {
+      to->Write("  %s,\n", field.key.c_str());
+    } else {
+      to->Write("  %s = %s,\n", field.key.c_str(), field.value.c_str());
+    }
+  }
+  to->Write("};\n");
+}
+
+void Enum::AddValue(const string& key, const string& value) {
+  fields_.emplace_back(key, value);
+}
+
+ArgList::ArgList(const std::string& single_argument)
+    : ArgList(vector<string>{single_argument}) {}
+
+ArgList::ArgList(const std::vector<std::string>& arg_list) {
+  for (const auto& s : arg_list) {
+    arguments_.emplace_back(new LiteralExpression(s));
+  }
+}
+
+ArgList::ArgList(std::vector<std::unique_ptr<AstNode>> arg_list)
+    : arguments_(std::move(arg_list)) {}
+
+ArgList::ArgList(ArgList&& arg_list)
+    : arguments_(std::move(arg_list.arguments_)) {}
+
+void ArgList::Write(CodeWriter* to) const {
+  to->Write("(");
+  bool is_first = true;
+  for (const auto& s : arguments_) {
+    if (!is_first) { to->Write(", "); }
+    is_first = false;
+    s->Write(to);
+  }
+  to->Write(")");
+}
+
+ConstructorDecl::ConstructorDecl(
+    const std::string& name,
+    ArgList&& arg_list)
+    : ConstructorDecl(name, std::move(arg_list), 0u) {}
+
+ConstructorDecl::ConstructorDecl(
+    const std::string& name,
+    ArgList&& arg_list,
+    uint32_t modifiers)
+    : name_(name),
+      arguments_(std::move(arg_list)),
+      modifiers_(modifiers) {}
+
+void ConstructorDecl::Write(CodeWriter* to) const {
+  if (modifiers_ & Modifiers::IS_VIRTUAL)
+    to->Write("virtual ");
+
+  if (modifiers_ & Modifiers::IS_EXPLICIT)
+    to->Write("explicit ");
+
+  to->Write("%s", name_.c_str());
+
+  arguments_.Write(to);
+
+  if (modifiers_ & Modifiers::IS_DEFAULT)
+    to->Write(" = default");
+
+  to->Write(";\n");
+}
+
+MacroDecl::MacroDecl(const std::string& name, ArgList&& arg_list)
+    : name_(name),
+      arguments_(std::move(arg_list)) {}
+
+void MacroDecl::Write(CodeWriter* to) const {
+  to->Write("%s", name_.c_str());
+  arguments_.Write(to);
+  to->Write("\n");
+}
+
+MethodDecl::MethodDecl(const std::string& return_type,
+                       const std::string& name,
+                       ArgList&& arg_list)
+    : MethodDecl(return_type, name, std::move(arg_list), 0u) {}
+
+MethodDecl::MethodDecl(const std::string& return_type,
+                       const std::string& name,
+                       ArgList&& arg_list,
+                       uint32_t modifiers)
+    : return_type_(return_type),
+      name_(name),
+      arguments_(std::move(arg_list)),
+      is_const_(modifiers & IS_CONST),
+      is_virtual_(modifiers & IS_VIRTUAL),
+      is_override_(modifiers & IS_OVERRIDE),
+      is_pure_virtual_(modifiers & IS_PURE_VIRTUAL),
+      is_static_(modifiers & IS_STATIC) {}
+
+void MethodDecl::Write(CodeWriter* to) const {
+  if (is_virtual_)
+    to->Write("virtual ");
+
+  if (is_static_)
+    to->Write("static ");
+
+  to->Write("%s %s", return_type_.c_str(), name_.c_str());
+
+  arguments_.Write(to);
+
+  if (is_const_)
+    to->Write(" const");
+
+  if (is_override_)
+    to->Write(" override");
+
+  if (is_pure_virtual_)
+    to->Write(" = 0");
+
+  to->Write(";\n");
+}
+
+void StatementBlock::AddStatement(unique_ptr<AstNode> statement) {
+  statements_.push_back(std::move(statement));
+}
+
+void StatementBlock::AddStatement(AstNode* statement) {
+  statements_.emplace_back(statement);
+}
+
+void StatementBlock::AddLiteral(const std::string& expression_str,
+                                bool add_semicolon) {
+  if (add_semicolon) {
+    statements_.push_back(unique_ptr<AstNode>(new Statement(expression_str)));
+  } else {
+    statements_.push_back(unique_ptr<AstNode>(
+        new LiteralExpression(expression_str)));
+  }
+}
+
+void StatementBlock::Write(CodeWriter* to) const {
+  to->Write("{\n");
+  for (const auto& statement : statements_) {
+    statement->Write(to);
+  }
+  to->Write("}\n");
+}
+
+ConstructorImpl::ConstructorImpl(const string& class_name,
+                                 ArgList&& arg_list,
+                                 const vector<string>& initializer_list)
+      : class_name_(class_name),
+        arguments_(std::move(arg_list)),
+        initializer_list_(initializer_list) {}
+
+void ConstructorImpl::Write(CodeWriter* to) const {
+  to->Write("%s::%s", class_name_.c_str(), class_name_.c_str());
+  arguments_.Write(to);
+  to->Write("\n");
+
+  bool is_first = true;
+  for (const string& i : initializer_list_) {
+    if (is_first) {
+      to->Write("    : %s", i.c_str());
+    } else {
+      to->Write(",\n      %s", i.c_str());
+    }
+    is_first = false;
+  }
+
+  body_.Write(to);
+}
+
+MethodImpl::MethodImpl(const string& return_type,
+                       const string& class_name,
+                       const string& method_name,
+                       ArgList&& arg_list,
+                       bool is_const_method)
+    : return_type_(return_type),
+      method_name_(method_name),
+      arguments_(std::move(arg_list)),
+      is_const_method_(is_const_method) {
+  if (!class_name.empty()) {
+    method_name_ = class_name + "::" + method_name;
+  }
+}
+
+StatementBlock* MethodImpl::GetStatementBlock() {
+  return &statements_;
+}
+
+void MethodImpl::Write(CodeWriter* to) const {
+  to->Write("%s %s", return_type_.c_str(), method_name_.c_str());
+  arguments_.Write(to);
+  to->Write("%s ", (is_const_method_) ? " const" : "");
+  statements_.Write(to);
+}
+
+SwitchStatement::SwitchStatement(const std::string& expression)
+    : switch_expression_(expression) {}
+
+StatementBlock* SwitchStatement::AddCase(const string& value_expression) {
+  auto it = std::find(case_values_.begin(), case_values_.end(), value_expression);
+  if (it != case_values_.end()) {
+    LOG(ERROR) << "internal error: duplicate switch case labels";
+    return nullptr;
+  }
+  StatementBlock* ret = new StatementBlock();
+  case_values_.push_back(value_expression);
+  case_logic_.push_back(unique_ptr<StatementBlock>{ret});
+  return ret;
+}
+
+void SwitchStatement::Write(CodeWriter* to) const {
+  to->Write("switch (%s) {\n", switch_expression_.c_str());
+  for (size_t i = 0; i < case_values_.size(); ++i) {
+    const string& case_value = case_values_[i];
+    const unique_ptr<StatementBlock>& statements = case_logic_[i];
+    if (case_value.empty()) {
+      to->Write("default:\n");
+    } else {
+      to->Write("case %s:\n", case_value.c_str());
+    }
+    statements->Write(to);
+    to->Write("break;\n");
+  }
+  to->Write("}\n");
+}
+
+
+Assignment::Assignment(const std::string& left, const std::string& right)
+    : Assignment(left, new LiteralExpression{right}) {}
+
+Assignment::Assignment(const std::string& left, AstNode* right)
+    : lhs_(left),
+      rhs_(right) {}
+
+void Assignment::Write(CodeWriter* to) const {
+  to->Write("%s = ", lhs_.c_str());
+  rhs_->Write(to);
+  to->Write(";\n");
+}
+
+MethodCall::MethodCall(const std::string& method_name,
+                       const std::string& single_argument)
+    : MethodCall(method_name, ArgList{single_argument}) {}
+
+MethodCall::MethodCall(const std::string& method_name,
+                       ArgList&& arg_list)
+    : method_name_(method_name),
+      arguments_{std::move(arg_list)} {}
+
+void MethodCall::Write(CodeWriter* to) const {
+  to->Write("%s", method_name_.c_str());
+  arguments_.Write(to);
+}
+
+IfStatement::IfStatement(AstNode* expression, bool invert_expression)
+    : expression_(expression),
+      invert_expression_(invert_expression) {}
+
+void IfStatement::Write(CodeWriter* to) const {
+  to->Write("if (%s", (invert_expression_) ? "!(" : "");
+  expression_->Write(to);
+  to->Write(")%s ", (invert_expression_) ? ")" : "");
+  on_true_.Write(to);
+
+  if (!on_false_.Empty()) {
+    to->Write("else ");
+    on_false_.Write(to);
+  }
+}
+
+Statement::Statement(unique_ptr<AstNode> expression)
+    : expression_(std::move(expression)) {}
+
+Statement::Statement(AstNode* expression) : expression_(expression) {}
+
+Statement::Statement(const string& expression)
+    : expression_(new LiteralExpression(expression)) {}
+
+void Statement::Write(CodeWriter* to) const {
+  expression_->Write(to);
+  to->Write(";\n");
+}
+
+Comparison::Comparison(AstNode* lhs, const string& comparison, AstNode* rhs)
+    : left_(lhs),
+      right_(rhs),
+      operator_(comparison) {}
+
+void Comparison::Write(CodeWriter* to) const {
+  to->Write("((");
+  left_->Write(to);
+  to->Write(") %s (", operator_.c_str());
+  right_->Write(to);
+  to->Write("))");
+}
+
+LiteralExpression::LiteralExpression(const std::string& expression)
+    : expression_(expression) {}
+
+void LiteralExpression::Write(CodeWriter* to) const {
+  to->Write("%s", expression_.c_str());
+}
+
+CppNamespace::CppNamespace(const std::string& name,
+                           std::vector<unique_ptr<Declaration>> declarations)
+    : declarations_(std::move(declarations)),
+      name_(name) {}
+
+CppNamespace::CppNamespace(const std::string& name,
+                           unique_ptr<Declaration> declaration)
+    : name_(name) {
+  declarations_.push_back(std::move(declaration));
+}
+CppNamespace::CppNamespace(const std::string& name)
+    : name_(name) {}
+
+void CppNamespace::Write(CodeWriter* to) const {
+  to->Write("namespace %s {\n\n", name_.c_str());
+
+  for (const auto& dec : declarations_) {
+    dec->Write(to);
+    to->Write("\n");
+  }
+
+  to->Write("}  // namespace %s\n", name_.c_str());
+}
+
+Document::Document(const std::vector<std::string>& include_list,
+                   unique_ptr<CppNamespace> a_namespace)
+    : include_list_(include_list),
+      namespace_(std::move(a_namespace)) {}
+
+void Document::Write(CodeWriter* to) const {
+  for (const auto& include : include_list_) {
+    to->Write("#include <%s>\n", include.c_str());
+  }
+  to->Write("\n");
+
+  namespace_->Write(to);
+}
+
+CppHeader::CppHeader(const std::string& include_guard,
+                     const std::vector<std::string>& include_list,
+                     unique_ptr<CppNamespace> a_namespace)
+    : Document(include_list, std::move(a_namespace)),
+      include_guard_(include_guard) {}
+
+void CppHeader::Write(CodeWriter* to) const {
+  to->Write("#ifndef %s\n", include_guard_.c_str());
+  to->Write("#define %s\n\n", include_guard_.c_str());
+
+  Document::Write(to);
+  to->Write("\n");
+
+  to->Write("#endif  // %s\n", include_guard_.c_str());
+}
+
+CppSource::CppSource(const std::vector<std::string>& include_list,
+                     unique_ptr<CppNamespace> a_namespace)
+    : Document(include_list, std::move(a_namespace)) {}
+
+}  // namespace cpp
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/ast_cpp.h b/aidl/ast_cpp.h
new file mode 100644
index 0000000..bb251ec
--- /dev/null
+++ b/aidl/ast_cpp.h
@@ -0,0 +1,420 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_AST_CPP_H_
+#define AIDL_AST_CPP_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <android-base/macros.h>
+
+namespace android {
+namespace aidl {
+class CodeWriter;
+}  // namespace aidl
+}  // namespace android
+
+namespace android {
+namespace aidl {
+namespace cpp {
+
+class AstNode {
+ public:
+  AstNode() = default;
+  virtual ~AstNode() = default;
+  virtual void Write(CodeWriter* to) const = 0;
+};  // class AstNode
+
+class Declaration : public AstNode {
+ public:
+  Declaration() = default;
+  virtual ~Declaration() = default;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Declaration);
+};  // class Declaration
+
+class ClassDecl : public Declaration {
+ public:
+  ClassDecl(const std::string& name,
+            const std::string& parent);
+  ClassDecl(const std::string& name,
+            const std::string& parent,
+            std::vector<std::unique_ptr<Declaration>> public_members,
+            std::vector<std::unique_ptr<Declaration>> private_members);
+  virtual ~ClassDecl() = default;
+
+  void Write(CodeWriter* to) const override;
+
+  void AddPublic(std::unique_ptr<Declaration> member);
+  void AddPrivate(std::unique_ptr<Declaration> member);
+
+ private:
+  std::string name_;
+  std::string parent_;
+  std::vector<std::unique_ptr<Declaration>> public_members_;
+  std::vector<std::unique_ptr<Declaration>> private_members_;
+
+  DISALLOW_COPY_AND_ASSIGN(ClassDecl);
+};  // class ClassDecl
+
+class Enum : public Declaration {
+ public:
+  Enum(const std::string& name, const std::string& base_type);
+  explicit Enum(const std::string& name);
+  virtual ~Enum() = default;
+
+  bool HasValues() const { return !fields_.empty(); }
+  void Write(CodeWriter* to) const override;
+
+  void AddValue(const std::string& key, const std::string& value);
+
+ private:
+  struct EnumField {
+    EnumField(const std::string& k, const std::string& v);
+    const std::string key;
+    const std::string value;
+  };
+
+  std::string enum_name_;
+  std::string underlying_type_;
+  std::vector<EnumField> fields_;
+
+  DISALLOW_COPY_AND_ASSIGN(Enum);
+};  // class Enum
+
+class ArgList : public AstNode {
+ public:
+  ArgList() = default;
+  explicit ArgList(const std::string& single_argument);
+  explicit ArgList(const std::vector<std::string>& arg_list);
+  explicit ArgList(std::vector<std::unique_ptr<AstNode>> arg_list);
+  ArgList(ArgList&& arg_list);
+  virtual ~ArgList() = default;
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::vector<std::unique_ptr<AstNode>> arguments_;
+
+  DISALLOW_COPY_AND_ASSIGN(ArgList);
+};  // class ArgList
+
+class ConstructorDecl : public Declaration {
+ public:
+  enum Modifiers {
+    IS_VIRTUAL = 1 << 0,
+    IS_DEFAULT = 1 << 1,
+    IS_EXPLICIT = 1 << 2,
+  };
+
+  ConstructorDecl(const std::string& name,
+                  ArgList&& arg_list);
+  ConstructorDecl(const std::string& name,
+                  ArgList&& arg_list,
+                  uint32_t modifiers);
+
+  virtual ~ConstructorDecl() = default;
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  const std::string name_;
+  const ArgList arguments_;
+  const uint32_t modifiers_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConstructorDecl);
+};  // class ConstructorDecl
+
+class MacroDecl : public Declaration {
+ public:
+  MacroDecl(const std::string& name, ArgList&& arg_list);
+  virtual ~MacroDecl() = default;
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  const std::string name_;
+  const ArgList arguments_;
+
+  DISALLOW_COPY_AND_ASSIGN(MacroDecl);
+};  // class MacroDecl
+
+class MethodDecl : public Declaration {
+ public:
+  enum Modifiers {
+    IS_CONST = 1 << 0,
+    IS_VIRTUAL = 1 << 1,
+    IS_OVERRIDE = 1 << 2,
+    IS_PURE_VIRTUAL = 1 << 3,
+    IS_STATIC = 1 << 4,
+  };
+
+  MethodDecl(const std::string& return_type,
+             const std::string& name,
+             ArgList&& arg_list);
+  MethodDecl(const std::string& return_type,
+             const std::string& name,
+             ArgList&& arg_list,
+             uint32_t modifiers);
+  virtual ~MethodDecl() = default;
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  const std::string return_type_;
+  const std::string name_;
+  const ArgList arguments_;
+  bool is_const_ = false;
+  bool is_virtual_ = false;
+  bool is_override_ = false;
+  bool is_pure_virtual_ = false;
+  bool is_static_ = true;
+
+  DISALLOW_COPY_AND_ASSIGN(MethodDecl);
+};  // class MethodDecl
+
+class StatementBlock : public Declaration {
+ public:
+  StatementBlock() = default;
+  virtual ~StatementBlock() = default;
+
+  void AddStatement(std::unique_ptr<AstNode> statement);
+  void AddStatement(AstNode* statement);  // Takes ownership
+  void AddLiteral(const std::string& expression, bool add_semicolon = true);
+  bool Empty() const { return statements_.empty(); }
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::vector<std::unique_ptr<AstNode>> statements_;
+
+  DISALLOW_COPY_AND_ASSIGN(StatementBlock);
+};  // class StatementBlock
+
+class ConstructorImpl : public Declaration {
+ public:
+  ConstructorImpl(const std::string& class_name,
+                  ArgList&& arg_list,
+                  const std::vector<std::string>& initializer_list);
+  virtual ~ConstructorImpl() = default;
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::string class_name_;
+  ArgList arguments_;
+  std::vector<std::string> initializer_list_;
+  StatementBlock body_;
+
+  DISALLOW_COPY_AND_ASSIGN(ConstructorImpl);
+};  // class ConstructorImpl
+
+class MethodImpl : public Declaration {
+ public:
+  // Passing an empty class name causes the method to be declared as a normal
+  // function (ie. no ClassName:: qualifier).
+  MethodImpl(const std::string& return_type,
+             const std::string& class_name,
+             const std::string& method_name,
+             ArgList&& arg_list,
+             bool is_const_method = false);
+  virtual ~MethodImpl() = default;
+
+  // MethodImpl retains ownership of the statement block.
+  StatementBlock* GetStatementBlock();
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::string return_type_;
+  std::string method_name_;
+  const ArgList arguments_;
+  StatementBlock statements_;
+  bool is_const_method_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(MethodImpl);
+};  // class MethodImpl
+
+class SwitchStatement : public AstNode {
+ public:
+  explicit SwitchStatement(const std::string& expression);
+  virtual ~SwitchStatement() = default;
+
+  // Add a case statement and return a pointer code block corresponding
+  // to the case.  The switch statement will add a break statement
+  // after the code block by default to prevent accidental fall-through.
+  // Returns nullptr on duplicate value expressions (by strcmp, not value
+  // equivalence).
+  StatementBlock* AddCase(const std::string& value_expression);
+  void Write(CodeWriter* to) const override;
+
+ private:
+  const std::string switch_expression_;
+  std::vector<std::string> case_values_;
+  std::vector<std::unique_ptr<StatementBlock>> case_logic_;
+
+  DISALLOW_COPY_AND_ASSIGN(SwitchStatement);
+};  // class SwitchStatement
+
+class Assignment : public AstNode {
+ public:
+  Assignment(const std::string& left, const std::string& right);
+  Assignment(const std::string& left, AstNode* right);
+  ~Assignment() = default;
+  void Write(CodeWriter* to) const override;
+
+ private:
+  const std::string lhs_;
+  std::unique_ptr<AstNode> rhs_;
+
+  DISALLOW_COPY_AND_ASSIGN(Assignment);
+};  // class Assignment
+
+class MethodCall : public AstNode {
+ public:
+  MethodCall(const std::string& method_name,
+             const std::string& single_argument);
+  MethodCall(const std::string& method_name, ArgList&& arg_list);
+  ~MethodCall() = default;
+  void Write(CodeWriter* to) const override;
+
+ private:
+  const std::string method_name_;
+  const ArgList arguments_;
+
+  DISALLOW_COPY_AND_ASSIGN(MethodCall);
+};  // class MethodCall
+
+class IfStatement : public AstNode {
+ public:
+  explicit IfStatement(AstNode* expression,
+              bool invert_expression = false);
+  virtual ~IfStatement() = default;
+  StatementBlock* OnTrue() { return &on_true_; }
+  StatementBlock* OnFalse() { return &on_false_; }
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::unique_ptr<AstNode> expression_;
+  bool invert_expression_ = false;
+  StatementBlock on_true_;
+  StatementBlock on_false_;
+
+  DISALLOW_COPY_AND_ASSIGN(IfStatement);
+};  // class IfStatement
+
+class Statement : public AstNode {
+ public:
+  explicit Statement(std::unique_ptr<AstNode> expression);
+  explicit Statement(AstNode* expression);  // Takes possession.
+  explicit Statement(const std::string& expression);
+  ~Statement() = default;
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::unique_ptr<AstNode> expression_;
+
+  DISALLOW_COPY_AND_ASSIGN(Statement);
+};  // class Statement
+
+class Comparison : public AstNode {
+ public:
+  Comparison(AstNode* lhs, const std::string& comparison, AstNode* rhs);
+  ~Comparison() = default;
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::unique_ptr<AstNode> left_;
+  std::unique_ptr<AstNode> right_;
+  const std::string operator_;
+
+  DISALLOW_COPY_AND_ASSIGN(Comparison);
+};  // class Comparison
+
+class LiteralExpression : public AstNode {
+ public:
+  explicit LiteralExpression(const std::string& expression);
+  ~LiteralExpression() = default;
+  void Write(CodeWriter* to) const override;
+
+ private:
+  const std::string expression_;
+
+  DISALLOW_COPY_AND_ASSIGN(LiteralExpression);
+};  // class LiteralExpression
+
+class CppNamespace : public Declaration {
+ public:
+  CppNamespace(const std::string& name,
+               std::vector<std::unique_ptr<Declaration>> declarations);
+  CppNamespace(const std::string& name,
+               std::unique_ptr<Declaration> declaration);
+  explicit CppNamespace(const std::string& name);
+  virtual ~CppNamespace() = default;
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::vector<std::unique_ptr<Declaration>> declarations_;
+  std::string name_;
+
+  DISALLOW_COPY_AND_ASSIGN(CppNamespace);
+};  // class CppNamespace
+
+class Document : public AstNode {
+ public:
+  Document(const std::vector<std::string>& include_list,
+           std::unique_ptr<CppNamespace> a_namespace);
+
+  void Write(CodeWriter* to) const override;
+
+ private:
+  std::vector<std::string> include_list_;
+  std::unique_ptr<CppNamespace> namespace_;
+
+  DISALLOW_COPY_AND_ASSIGN(Document);
+};  // class Document
+
+class CppHeader final : public Document {
+ public:
+  CppHeader(const std::string& include_guard,
+            const std::vector<std::string>& include_list,
+            std::unique_ptr<CppNamespace> a_namespace);
+  void Write(CodeWriter* to) const override;
+
+ private:
+  const std::string include_guard_;
+
+  DISALLOW_COPY_AND_ASSIGN(CppHeader);
+};  // class CppHeader
+
+class CppSource final : public Document {
+ public:
+  CppSource(const std::vector<std::string>& include_list,
+            std::unique_ptr<CppNamespace> a_namespace);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(CppSource);
+};  // class CppSource
+
+}  // namespace cpp
+}  // namespace aidl
+}  // namespace android
+
+#endif // AIDL_AST_CPP_H_
diff --git a/aidl/ast_cpp_unittest.cpp b/aidl/ast_cpp_unittest.cpp
new file mode 100644
index 0000000..aee23b7
--- /dev/null
+++ b/aidl/ast_cpp_unittest.cpp
@@ -0,0 +1,246 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <string>
+
+#include <gtest/gtest.h>
+
+#include "ast_cpp.h"
+#include "code_writer.h"
+
+using std::string;
+using std::vector;
+using std::unique_ptr;
+
+namespace android {
+namespace aidl {
+namespace cpp {
+namespace {
+
+const char kExpectedHeaderOutput[] =
+R"(#ifndef HEADER_INCLUDE_GUARD_H_
+#define HEADER_INCLUDE_GUARD_H_
+
+#include <string>
+#include <memory>
+
+namespace android {
+
+namespace test {
+
+class TestClass {
+public:
+void NormalMethod(int normalarg, float normal2);
+virtual void SubMethod(int subarg) const;
+};  // class TestClass
+
+class TestSubClass : public TestClass {
+public:
+virtual void SubMethod(int subarg) const;
+};  // class TestSubClass
+
+}  // namespace test
+
+}  // namespace android
+
+#endif  // HEADER_INCLUDE_GUARD_H_
+)";
+
+const char kExpectedEnumOutput[] =
+R"(enum Foo {
+  BAR = 42,
+  BAZ,
+};
+)";
+
+const char kExpectedSwitchOutput[] =
+R"(switch (var) {
+case 2:
+{
+baz;
+}
+break;
+case 1:
+{
+foo;
+bar;
+}
+break;
+}
+)";
+
+const char kExpectedMethodImplOutput[] =
+R"(return_type ClassName::MethodName(arg 1, arg 2, arg 3) const {
+foo;
+bar;
+}
+)";
+}  // namespace
+
+class AstCppTests : public ::testing::Test {
+ protected:
+  void CompareGeneratedCode(const AstNode& node,
+                            const string& expected_output) {
+    string actual_output;
+    CodeWriterPtr writer = GetStringWriter(&actual_output);
+    node.Write(writer.get());
+    EXPECT_EQ(expected_output, actual_output);
+  }
+};  // class AstCppTests
+
+
+TEST_F(AstCppTests, GeneratesHeader) {
+  unique_ptr<MethodDecl> norm{new MethodDecl(
+      "void", "NormalMethod",
+      ArgList{vector<string>{"int normalarg", "float normal2"}})};
+  unique_ptr<MethodDecl> sub{
+      new MethodDecl("void", "SubMethod",
+                     ArgList{ "int subarg" },
+                     MethodDecl::IS_CONST | MethodDecl::IS_VIRTUAL)};
+  unique_ptr<MethodDecl> sub2{
+      new MethodDecl("void", "SubMethod",
+                     ArgList{ "int subarg" },
+                     MethodDecl::IS_CONST | MethodDecl::IS_VIRTUAL)};
+  vector<unique_ptr<Declaration>> test_methods;
+  test_methods.push_back(std::move(norm));
+  test_methods.push_back(std::move(sub));
+
+  vector<unique_ptr<Declaration>> test_sub_methods;
+  test_sub_methods.push_back(std::move(sub2));
+
+  unique_ptr<Declaration> test{new ClassDecl { "TestClass", "",
+      std::move(test_methods), {} }};
+
+  unique_ptr<Declaration> test_sub{new ClassDecl { "TestSubClass",
+      "TestClass", std::move(test_sub_methods), {} }};
+
+  vector<unique_ptr<Declaration>> classes;
+  classes.push_back(std::move(test));
+  classes.push_back(std::move(test_sub));
+
+  unique_ptr<CppNamespace> test_ns{new CppNamespace {"test",
+      std::move(classes)}};
+
+  vector<unique_ptr<Declaration>> test_ns_vec;
+  test_ns_vec.push_back(std::move(test_ns));
+
+  unique_ptr<CppNamespace> android_ns{new CppNamespace {"android",
+      std::move(test_ns_vec) }};
+
+  CppHeader cpp_header{"HEADER_INCLUDE_GUARD_H_", {"string", "memory"},
+      std::move(android_ns) };
+  CompareGeneratedCode(cpp_header, kExpectedHeaderOutput);
+}
+
+TEST_F(AstCppTests, GeneratesEnum) {
+  Enum e("Foo");
+  e.AddValue("BAR", "42");
+  e.AddValue("BAZ", "");
+  CompareGeneratedCode(e, kExpectedEnumOutput);
+}
+
+TEST_F(AstCppTests, GeneratesArgList) {
+  ArgList simple("foo");
+  CompareGeneratedCode(simple, "(foo)");
+  ArgList compound({"foo", "bar", "baz"});
+  CompareGeneratedCode(compound, "(foo, bar, baz)");
+  std::vector<unique_ptr<AstNode>> args;
+  args.emplace_back(new LiteralExpression("foo()"));
+  ArgList nested(std::move(args));
+  CompareGeneratedCode(nested, "(foo())");
+}
+
+TEST_F(AstCppTests, GeneratesStatement) {
+  Statement s(new LiteralExpression("foo"));
+  CompareGeneratedCode(s, "foo;\n");
+}
+
+TEST_F(AstCppTests, GeneratesComparison) {
+  Comparison c(
+      new LiteralExpression("lhs"), "&&", new LiteralExpression("rhs"));
+  CompareGeneratedCode(c, "((lhs) && (rhs))");
+}
+
+TEST_F(AstCppTests, GeneratesStatementBlock) {
+  StatementBlock block;
+  block.AddStatement(unique_ptr<AstNode>(new Statement("foo")));
+  block.AddStatement(unique_ptr<AstNode>(new Statement("bar")));
+  CompareGeneratedCode(block, "{\nfoo;\nbar;\n}\n");
+}
+
+TEST_F(AstCppTests, GeneratesConstructorImpl) {
+  ConstructorImpl c("ClassName", ArgList({"a", "b", "c"}),
+                    {"baz_(foo)", "bar_(blah)"});
+  string expected = R"(ClassName::ClassName(a, b, c)
+    : baz_(foo),
+      bar_(blah){
+}
+)";
+  CompareGeneratedCode(c, expected);
+}
+
+TEST_F(AstCppTests, GeneratesAssignment) {
+  Assignment simple("foo", "8");
+  CompareGeneratedCode(simple, "foo = 8;\n");
+  Assignment less_simple("foo", new MethodCall("f", "8"));
+  CompareGeneratedCode(less_simple, "foo = f(8);\n");
+}
+
+TEST_F(AstCppTests, GeneratesMethodCall) {
+  MethodCall single("single", "arg");
+  CompareGeneratedCode(single, "single(arg)");
+  MethodCall multi(
+      "multi",
+      ArgList({"has", "some", "args"}));
+  CompareGeneratedCode(multi, "multi(has, some, args)");
+}
+
+TEST_F(AstCppTests, GeneratesIfStatement) {
+  IfStatement s(new LiteralExpression("foo"));
+  s.OnTrue()->AddLiteral("on true1");
+  s.OnFalse()->AddLiteral("on false");
+  CompareGeneratedCode(s, "if (foo) {\non true1;\n}\nelse {\non false;\n}\n");
+
+  IfStatement s2(new LiteralExpression("bar"));
+  s2.OnTrue()->AddLiteral("on true1");
+  CompareGeneratedCode(s2, "if (bar) {\non true1;\n}\n");
+}
+
+TEST_F(AstCppTests, GeneratesSwitchStatement) {
+  SwitchStatement s("var");
+  // These are intentionally out of alphanumeric order.  We're testing
+  // that switch respects case addition order.
+  auto case2 = s.AddCase("2");
+  case2->AddStatement(unique_ptr<AstNode>{new Statement{"baz"}});
+  auto case1 = s.AddCase("1");
+  case1->AddStatement(unique_ptr<AstNode>{new Statement{"foo"}});
+  case1->AddStatement(unique_ptr<AstNode>{new Statement{"bar"}});
+  CompareGeneratedCode(s, kExpectedSwitchOutput);
+}
+
+TEST_F(AstCppTests, GeneratesMethodImpl) {
+  MethodImpl m{"return_type", "ClassName", "MethodName",
+               ArgList{{"arg 1", "arg 2", "arg 3"}},
+               true};
+  auto b = m.GetStatementBlock();
+  b->AddLiteral("foo");
+  b->AddLiteral("bar");
+  CompareGeneratedCode(m, kExpectedMethodImplOutput);
+}
+
+}  // namespace cpp
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/ast_java.cpp b/aidl/ast_java.cpp
new file mode 100644
index 0000000..1ba723c
--- /dev/null
+++ b/aidl/ast_java.cpp
@@ -0,0 +1,525 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "ast_java.h"
+
+#include "code_writer.h"
+#include "type_java.h"
+
+using std::vector;
+using std::string;
+
+namespace android {
+namespace aidl {
+namespace java {
+
+void WriteModifiers(CodeWriter* to, int mod, int mask) {
+  int m = mod & mask;
+
+  if (m & OVERRIDE) {
+    to->Write("@Override ");
+  }
+
+  if ((m & SCOPE_MASK) == PUBLIC) {
+    to->Write("public ");
+  } else if ((m & SCOPE_MASK) == PRIVATE) {
+    to->Write("private ");
+  } else if ((m & SCOPE_MASK) == PROTECTED) {
+    to->Write("protected ");
+  }
+
+  if (m & STATIC) {
+    to->Write("static ");
+  }
+
+  if (m & FINAL) {
+    to->Write("final ");
+  }
+
+  if (m & ABSTRACT) {
+    to->Write("abstract ");
+  }
+}
+
+void WriteArgumentList(CodeWriter* to, const vector<Expression*>& arguments) {
+  size_t N = arguments.size();
+  for (size_t i = 0; i < N; i++) {
+    arguments[i]->Write(to);
+    if (i != N - 1) {
+      to->Write(", ");
+    }
+  }
+}
+
+Field::Field(int m, Variable* v) : ClassElement(), modifiers(m), variable(v) {}
+
+void Field::Write(CodeWriter* to) const {
+  if (this->comment.length() != 0) {
+    to->Write("%s\n", this->comment.c_str());
+  }
+  WriteModifiers(to, this->modifiers, SCOPE_MASK | STATIC | FINAL | OVERRIDE);
+  to->Write("%s %s", this->variable->type->JavaType().c_str(),
+            this->variable->name.c_str());
+  if (this->value.length() != 0) {
+    to->Write(" = %s", this->value.c_str());
+  }
+  to->Write(";\n");
+}
+
+LiteralExpression::LiteralExpression(const string& v) : value(v) {}
+
+void LiteralExpression::Write(CodeWriter* to) const {
+  to->Write("%s", this->value.c_str());
+}
+
+StringLiteralExpression::StringLiteralExpression(const string& v) : value(v) {}
+
+void StringLiteralExpression::Write(CodeWriter* to) const {
+  to->Write("\"%s\"", this->value.c_str());
+}
+
+Variable::Variable(const Type* t, const string& n)
+    : type(t), name(n), dimension(0) {}
+
+Variable::Variable(const Type* t, const string& n, int d)
+    : type(t), name(n), dimension(d) {}
+
+void Variable::WriteDeclaration(CodeWriter* to) const {
+  string dim;
+  for (int i = 0; i < this->dimension; i++) {
+    dim += "[]";
+  }
+  to->Write("%s%s %s", this->type->JavaType().c_str(), dim.c_str(),
+            this->name.c_str());
+}
+
+void Variable::Write(CodeWriter* to) const { to->Write("%s", name.c_str()); }
+
+FieldVariable::FieldVariable(Expression* o, const string& n)
+    : object(o), clazz(NULL), name(n) {}
+
+FieldVariable::FieldVariable(const Type* c, const string& n)
+    : object(NULL), clazz(c), name(n) {}
+
+void FieldVariable::Write(CodeWriter* to) const {
+  if (this->object != NULL) {
+    this->object->Write(to);
+  } else if (this->clazz != NULL) {
+    to->Write("%s", this->clazz->JavaType().c_str());
+  }
+  to->Write(".%s", name.c_str());
+}
+
+void StatementBlock::Write(CodeWriter* to) const {
+  to->Write("{\n");
+  int N = this->statements.size();
+  for (int i = 0; i < N; i++) {
+    this->statements[i]->Write(to);
+  }
+  to->Write("}\n");
+}
+
+void StatementBlock::Add(Statement* statement) {
+  this->statements.push_back(statement);
+}
+
+void StatementBlock::Add(Expression* expression) {
+  this->statements.push_back(new ExpressionStatement(expression));
+}
+
+ExpressionStatement::ExpressionStatement(Expression* e) : expression(e) {}
+
+void ExpressionStatement::Write(CodeWriter* to) const {
+  this->expression->Write(to);
+  to->Write(";\n");
+}
+
+Assignment::Assignment(Variable* l, Expression* r)
+    : lvalue(l), rvalue(r), cast(NULL) {}
+
+Assignment::Assignment(Variable* l, Expression* r, const Type* c)
+    : lvalue(l), rvalue(r), cast(c) {}
+
+void Assignment::Write(CodeWriter* to) const {
+  this->lvalue->Write(to);
+  to->Write(" = ");
+  if (this->cast != NULL) {
+    to->Write("(%s)", this->cast->JavaType().c_str());
+  }
+  this->rvalue->Write(to);
+}
+
+MethodCall::MethodCall(const string& n) : name(n) {}
+
+MethodCall::MethodCall(const string& n, int argc = 0, ...) : name(n) {
+  va_list args;
+  va_start(args, argc);
+  init(argc, args);
+  va_end(args);
+}
+
+MethodCall::MethodCall(Expression* o, const string& n) : obj(o), name(n) {}
+
+MethodCall::MethodCall(const Type* t, const string& n) : clazz(t), name(n) {}
+
+MethodCall::MethodCall(Expression* o, const string& n, int argc = 0, ...)
+    : obj(o), name(n) {
+  va_list args;
+  va_start(args, argc);
+  init(argc, args);
+  va_end(args);
+}
+
+MethodCall::MethodCall(const Type* t, const string& n, int argc = 0, ...)
+    : clazz(t), name(n) {
+  va_list args;
+  va_start(args, argc);
+  init(argc, args);
+  va_end(args);
+}
+
+void MethodCall::init(int n, va_list args) {
+  for (int i = 0; i < n; i++) {
+    Expression* expression = (Expression*)va_arg(args, void*);
+    this->arguments.push_back(expression);
+  }
+}
+
+void MethodCall::Write(CodeWriter* to) const {
+  if (this->obj != NULL) {
+    this->obj->Write(to);
+    to->Write(".");
+  } else if (this->clazz != NULL) {
+    to->Write("%s.", this->clazz->JavaType().c_str());
+  }
+  to->Write("%s(", this->name.c_str());
+  WriteArgumentList(to, this->arguments);
+  to->Write(")");
+}
+
+Comparison::Comparison(Expression* l, const string& o, Expression* r)
+    : lvalue(l), op(o), rvalue(r) {}
+
+void Comparison::Write(CodeWriter* to) const {
+  to->Write("(");
+  this->lvalue->Write(to);
+  to->Write("%s", this->op.c_str());
+  this->rvalue->Write(to);
+  to->Write(")");
+}
+
+NewExpression::NewExpression(const Type* t) : type(t) {}
+
+NewExpression::NewExpression(const Type* t, int argc = 0, ...) : type(t) {
+  va_list args;
+  va_start(args, argc);
+  init(argc, args);
+  va_end(args);
+}
+
+void NewExpression::init(int n, va_list args) {
+  for (int i = 0; i < n; i++) {
+    Expression* expression = (Expression*)va_arg(args, void*);
+    this->arguments.push_back(expression);
+  }
+}
+
+void NewExpression::Write(CodeWriter* to) const {
+  to->Write("new %s(", this->type->InstantiableName().c_str());
+  WriteArgumentList(to, this->arguments);
+  to->Write(")");
+}
+
+NewArrayExpression::NewArrayExpression(const Type* t, Expression* s)
+    : type(t), size(s) {}
+
+void NewArrayExpression::Write(CodeWriter* to) const {
+  to->Write("new %s[", this->type->JavaType().c_str());
+  size->Write(to);
+  to->Write("]");
+}
+
+Ternary::Ternary(Expression* a, Expression* b, Expression* c)
+    : condition(a), ifpart(b), elsepart(c) {}
+
+void Ternary::Write(CodeWriter* to) const {
+  to->Write("((");
+  this->condition->Write(to);
+  to->Write(")?(");
+  this->ifpart->Write(to);
+  to->Write("):(");
+  this->elsepart->Write(to);
+  to->Write("))");
+}
+
+Cast::Cast(const Type* t, Expression* e) : type(t), expression(e) {}
+
+void Cast::Write(CodeWriter* to) const {
+  to->Write("((%s)", this->type->JavaType().c_str());
+  expression->Write(to);
+  to->Write(")");
+}
+
+VariableDeclaration::VariableDeclaration(Variable* l, Expression* r,
+                                         const Type* c)
+    : lvalue(l), cast(c), rvalue(r) {}
+
+VariableDeclaration::VariableDeclaration(Variable* l) : lvalue(l) {}
+
+void VariableDeclaration::Write(CodeWriter* to) const {
+  this->lvalue->WriteDeclaration(to);
+  if (this->rvalue != NULL) {
+    to->Write(" = ");
+    if (this->cast != NULL) {
+      to->Write("(%s)", this->cast->JavaType().c_str());
+    }
+    this->rvalue->Write(to);
+  }
+  to->Write(";\n");
+}
+
+void IfStatement::Write(CodeWriter* to) const {
+  if (this->expression != NULL) {
+    to->Write("if (");
+    this->expression->Write(to);
+    to->Write(") ");
+  }
+  this->statements->Write(to);
+  if (this->elseif != NULL) {
+    to->Write("else ");
+    this->elseif->Write(to);
+  }
+}
+
+ReturnStatement::ReturnStatement(Expression* e) : expression(e) {}
+
+void ReturnStatement::Write(CodeWriter* to) const {
+  to->Write("return ");
+  this->expression->Write(to);
+  to->Write(";\n");
+}
+
+void TryStatement::Write(CodeWriter* to) const {
+  to->Write("try ");
+  this->statements->Write(to);
+}
+
+CatchStatement::CatchStatement(Variable* e)
+    : statements(new StatementBlock), exception(e) {}
+
+void CatchStatement::Write(CodeWriter* to) const {
+  to->Write("catch ");
+  if (this->exception != NULL) {
+    to->Write("(");
+    this->exception->WriteDeclaration(to);
+    to->Write(") ");
+  }
+  this->statements->Write(to);
+}
+
+void FinallyStatement::Write(CodeWriter* to) const {
+  to->Write("finally ");
+  this->statements->Write(to);
+}
+
+Case::Case(const string& c) { cases.push_back(c); }
+
+void Case::Write(CodeWriter* to) const {
+  int N = this->cases.size();
+  if (N > 0) {
+    for (int i = 0; i < N; i++) {
+      string s = this->cases[i];
+      if (s.length() != 0) {
+        to->Write("case %s:\n", s.c_str());
+      } else {
+        to->Write("default:\n");
+      }
+    }
+  } else {
+    to->Write("default:\n");
+  }
+  statements->Write(to);
+}
+
+SwitchStatement::SwitchStatement(Expression* e) : expression(e) {}
+
+void SwitchStatement::Write(CodeWriter* to) const {
+  to->Write("switch (");
+  this->expression->Write(to);
+  to->Write(")\n{\n");
+  int N = this->cases.size();
+  for (int i = 0; i < N; i++) {
+    this->cases[i]->Write(to);
+  }
+  to->Write("}\n");
+}
+
+void Break::Write(CodeWriter* to) const { to->Write("break;\n"); }
+
+void Method::Write(CodeWriter* to) const {
+  size_t N, i;
+
+  if (this->comment.length() != 0) {
+    to->Write("%s\n", this->comment.c_str());
+  }
+
+  WriteModifiers(to, this->modifiers,
+                 SCOPE_MASK | STATIC | ABSTRACT | FINAL | OVERRIDE);
+
+  if (this->returnType != NULL) {
+    string dim;
+    for (i = 0; i < this->returnTypeDimension; i++) {
+      dim += "[]";
+    }
+    to->Write("%s%s ", this->returnType->JavaType().c_str(), dim.c_str());
+  }
+
+  to->Write("%s(", this->name.c_str());
+
+  N = this->parameters.size();
+  for (i = 0; i < N; i++) {
+    this->parameters[i]->WriteDeclaration(to);
+    if (i != N - 1) {
+      to->Write(", ");
+    }
+  }
+
+  to->Write(")");
+
+  N = this->exceptions.size();
+  for (i = 0; i < N; i++) {
+    if (i == 0) {
+      to->Write(" throws ");
+    } else {
+      to->Write(", ");
+    }
+    to->Write("%s", this->exceptions[i]->JavaType().c_str());
+  }
+
+  if (this->statements == NULL) {
+    to->Write(";\n");
+  } else {
+    to->Write("\n");
+    this->statements->Write(to);
+  }
+}
+
+void IntConstant::Write(CodeWriter* to) const {
+  WriteModifiers(to, STATIC | FINAL | PUBLIC, ALL_MODIFIERS);
+  to->Write("int %s = %d;\n", name.c_str(), value);
+}
+
+void StringConstant::Write(CodeWriter* to) const {
+  WriteModifiers(to, STATIC | FINAL | PUBLIC, ALL_MODIFIERS);
+  to->Write("String %s = %s;\n", name.c_str(), value.c_str());
+}
+
+void Class::Write(CodeWriter* to) const {
+  size_t N, i;
+
+  if (this->comment.length() != 0) {
+    to->Write("%s\n", this->comment.c_str());
+  }
+
+  WriteModifiers(to, this->modifiers, ALL_MODIFIERS);
+
+  if (this->what == Class::CLASS) {
+    to->Write("class ");
+  } else {
+    to->Write("interface ");
+  }
+
+  string name = this->type->JavaType();
+  size_t pos = name.rfind('.');
+  if (pos != string::npos) {
+    name = name.c_str() + pos + 1;
+  }
+
+  to->Write("%s", name.c_str());
+
+  if (this->extends != NULL) {
+    to->Write(" extends %s", this->extends->JavaType().c_str());
+  }
+
+  N = this->interfaces.size();
+  if (N != 0) {
+    if (this->what == Class::CLASS) {
+      to->Write(" implements");
+    } else {
+      to->Write(" extends");
+    }
+    for (i = 0; i < N; i++) {
+      to->Write(" %s", this->interfaces[i]->JavaType().c_str());
+    }
+  }
+
+  to->Write("\n");
+  to->Write("{\n");
+
+  N = this->elements.size();
+  for (i = 0; i < N; i++) {
+    this->elements[i]->Write(to);
+  }
+
+  to->Write("}\n");
+}
+
+static string escape_backslashes(const string& str) {
+  string result;
+  const size_t I = str.length();
+  for (size_t i = 0; i < I; i++) {
+    char c = str[i];
+    if (c == '\\') {
+      result += "\\\\";
+    } else {
+      result += c;
+    }
+  }
+  return result;
+}
+
+Document::Document(const std::string& comment,
+                   const std::string& package,
+                   const std::string& original_src,
+                   std::unique_ptr<Class> clazz)
+    : comment_(comment),
+      package_(package),
+      original_src_(original_src),
+      clazz_(std::move(clazz)) {
+}
+
+void Document::Write(CodeWriter* to) const {
+  if (!comment_.empty()) {
+    to->Write("%s\n", comment_.c_str());
+  }
+  to->Write(
+      "/*\n"
+      " * This file is auto-generated.  DO NOT MODIFY.\n"
+      " * Original file: %s\n"
+      " */\n",
+      escape_backslashes(original_src_).c_str());
+  if (!package_.empty()) {
+    to->Write("package %s;\n", package_.c_str());
+  }
+
+  if (clazz_) {
+    clazz_->Write(to);
+  }
+}
+
+}  // namespace java
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/ast_java.h b/aidl/ast_java.h
new file mode 100644
index 0000000..c5ded58
--- /dev/null
+++ b/aidl/ast_java.h
@@ -0,0 +1,388 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_AST_JAVA_H_
+#define AIDL_AST_JAVA_H_
+
+#include <memory>
+#include <stdarg.h>
+#include <stdio.h>
+#include <string>
+#include <vector>
+
+enum {
+  PACKAGE_PRIVATE = 0x00000000,
+  PUBLIC = 0x00000001,
+  PRIVATE = 0x00000002,
+  PROTECTED = 0x00000003,
+  SCOPE_MASK = 0x00000003,
+
+  STATIC = 0x00000010,
+  FINAL = 0x00000020,
+  ABSTRACT = 0x00000040,
+
+  OVERRIDE = 0x00000100,
+
+  ALL_MODIFIERS = 0xffffffff
+};
+
+namespace android {
+namespace aidl {
+class CodeWriter;
+}  // namespace aidl
+}  // namespace android
+
+namespace android {
+namespace aidl {
+namespace java {
+
+class Type;
+
+// Write the modifiers that are set in both mod and mask
+void WriteModifiers(CodeWriter* to, int mod, int mask);
+
+struct ClassElement {
+  ClassElement() = default;
+  virtual ~ClassElement() = default;
+
+  virtual void Write(CodeWriter* to) const = 0;
+};
+
+struct Expression {
+  virtual ~Expression() = default;
+  virtual void Write(CodeWriter* to) const = 0;
+};
+
+struct LiteralExpression : public Expression {
+  std::string value;
+
+  explicit LiteralExpression(const std::string& value);
+  virtual ~LiteralExpression() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+// TODO: also escape the contents.  not needed for now
+struct StringLiteralExpression : public Expression {
+  std::string value;
+
+  explicit StringLiteralExpression(const std::string& value);
+  virtual ~StringLiteralExpression() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct Variable : public Expression {
+  const Type* type = nullptr;
+  std::string name;
+  int dimension = 0;
+
+  Variable() = default;
+  Variable(const Type* type, const std::string& name);
+  Variable(const Type* type, const std::string& name, int dimension);
+  virtual ~Variable() = default;
+
+  void WriteDeclaration(CodeWriter* to) const;
+  void Write(CodeWriter* to) const;
+};
+
+struct FieldVariable : public Expression {
+  Expression* object;
+  const Type* clazz;
+  std::string name;
+
+  FieldVariable(Expression* object, const std::string& name);
+  FieldVariable(const Type* clazz, const std::string& name);
+  virtual ~FieldVariable() = default;
+
+  void Write(CodeWriter* to) const;
+};
+
+struct Field : public ClassElement {
+  std::string comment;
+  int modifiers = 0;
+  Variable* variable = nullptr;
+  std::string value;
+
+  Field() = default;
+  Field(int modifiers, Variable* variable);
+  virtual ~Field() = default;
+
+  void Write(CodeWriter* to) const override;
+};
+
+struct Statement {
+  virtual ~Statement() = default;
+  virtual void Write(CodeWriter* to) const = 0;
+};
+
+struct StatementBlock : public Statement {
+  std::vector<Statement*> statements;
+
+  StatementBlock() = default;
+  virtual ~StatementBlock() = default;
+  void Write(CodeWriter* to) const override;
+
+  void Add(Statement* statement);
+  void Add(Expression* expression);
+};
+
+struct ExpressionStatement : public Statement {
+  Expression* expression;
+
+  explicit ExpressionStatement(Expression* expression);
+  virtual ~ExpressionStatement() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct Assignment : public Expression {
+  Variable* lvalue;
+  Expression* rvalue;
+  const Type* cast;
+
+  Assignment(Variable* lvalue, Expression* rvalue);
+  Assignment(Variable* lvalue, Expression* rvalue, const Type* cast);
+  virtual ~Assignment() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct MethodCall : public Expression {
+  Expression* obj = nullptr;
+  const Type* clazz = nullptr;
+  std::string name;
+  std::vector<Expression*> arguments;
+  std::vector<std::string> exceptions;
+
+  explicit MethodCall(const std::string& name);
+  MethodCall(const std::string& name, int argc, ...);
+  MethodCall(Expression* obj, const std::string& name);
+  MethodCall(const Type* clazz, const std::string& name);
+  MethodCall(Expression* obj, const std::string& name, int argc, ...);
+  MethodCall(const Type* clazz, const std::string& name, int argc, ...);
+  virtual ~MethodCall() = default;
+  void Write(CodeWriter* to) const override;
+
+ private:
+  void init(int n, va_list args);
+};
+
+struct Comparison : public Expression {
+  Expression* lvalue;
+  std::string op;
+  Expression* rvalue;
+
+  Comparison(Expression* lvalue, const std::string& op, Expression* rvalue);
+  virtual ~Comparison() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct NewExpression : public Expression {
+  const Type* type;
+  std::vector<Expression*> arguments;
+
+  explicit NewExpression(const Type* type);
+  NewExpression(const Type* type, int argc, ...);
+  virtual ~NewExpression() = default;
+  void Write(CodeWriter* to) const override;
+
+ private:
+  void init(int n, va_list args);
+};
+
+struct NewArrayExpression : public Expression {
+  const Type* type;
+  Expression* size;
+
+  NewArrayExpression(const Type* type, Expression* size);
+  virtual ~NewArrayExpression() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct Ternary : public Expression {
+  Expression* condition = nullptr;
+  Expression* ifpart = nullptr;
+  Expression* elsepart = nullptr;
+
+  Ternary() = default;
+  Ternary(Expression* condition, Expression* ifpart, Expression* elsepart);
+  virtual ~Ternary() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct Cast : public Expression {
+  const Type* type = nullptr;
+  Expression* expression = nullptr;
+
+  Cast() = default;
+  Cast(const Type* type, Expression* expression);
+  virtual ~Cast() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct VariableDeclaration : public Statement {
+  Variable* lvalue = nullptr;
+  const Type* cast = nullptr;
+  Expression* rvalue = nullptr;
+
+  explicit VariableDeclaration(Variable* lvalue);
+  VariableDeclaration(Variable* lvalue, Expression* rvalue,
+                      const Type* cast = NULL);
+  virtual ~VariableDeclaration() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct IfStatement : public Statement {
+  Expression* expression = nullptr;
+  StatementBlock* statements = new StatementBlock;
+  IfStatement* elseif = nullptr;
+
+  IfStatement() = default;
+  virtual ~IfStatement() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct ReturnStatement : public Statement {
+  Expression* expression;
+
+  explicit ReturnStatement(Expression* expression);
+  virtual ~ReturnStatement() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct TryStatement : public Statement {
+  StatementBlock* statements = new StatementBlock;
+
+  TryStatement() = default;
+  virtual ~TryStatement() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct CatchStatement : public Statement {
+  StatementBlock* statements;
+  Variable* exception;
+
+  explicit CatchStatement(Variable* exception);
+  virtual ~CatchStatement() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct FinallyStatement : public Statement {
+  StatementBlock* statements = new StatementBlock;
+
+  FinallyStatement() = default;
+  virtual ~FinallyStatement() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct Case {
+  std::vector<std::string> cases;
+  StatementBlock* statements = new StatementBlock;
+
+  Case() = default;
+  explicit Case(const std::string& c);
+  virtual ~Case() = default;
+  virtual void Write(CodeWriter* to) const;
+};
+
+struct SwitchStatement : public Statement {
+  Expression* expression;
+  std::vector<Case*> cases;
+
+  explicit SwitchStatement(Expression* expression);
+  virtual ~SwitchStatement() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct Break : public Statement {
+  Break() = default;
+  virtual ~Break() = default;
+  void Write(CodeWriter* to) const override;
+};
+
+struct Method : public ClassElement {
+  std::string comment;
+  int modifiers = 0;
+  const Type* returnType = nullptr;  // nullptr means constructor
+  size_t returnTypeDimension = 0;
+  std::string name;
+  std::vector<Variable*> parameters;
+  std::vector<const Type*> exceptions;
+  StatementBlock* statements = nullptr;
+
+  Method() = default;
+  virtual ~Method() = default;
+
+  void Write(CodeWriter* to) const override;
+};
+
+struct IntConstant : public ClassElement {
+  const std::string name;
+  const int value;
+
+  IntConstant(std::string name, int value)
+      : name(name), value(value) {}
+  virtual ~IntConstant() = default;
+
+  void Write(CodeWriter* to) const override;
+};
+
+struct StringConstant : public ClassElement {
+  const std::string name;
+  const std::string value;
+
+  StringConstant(std::string name, std::string value)
+      : name(name), value(value) {}
+  ~StringConstant() override = default;
+
+  void Write(CodeWriter* to) const override;
+};
+
+struct Class : public ClassElement {
+  enum { CLASS, INTERFACE };
+
+  std::string comment;
+  int modifiers = 0;
+  int what = CLASS;  // CLASS or INTERFACE
+  const Type* type = nullptr;
+  const Type* extends = nullptr;
+  std::vector<const Type*> interfaces;
+  std::vector<ClassElement*> elements;
+
+  Class() = default;
+  virtual ~Class() = default;
+
+  void Write(CodeWriter* to) const override;
+};
+
+class Document {
+ public:
+  Document(const std::string& comment,
+           const std::string& package,
+           const std::string& original_src,
+           std::unique_ptr<Class> clazz);
+  virtual ~Document() = default;
+  virtual void Write(CodeWriter* to) const;
+
+ private:
+  std::string comment_;
+  std::string package_;
+  std::string original_src_;
+  std::unique_ptr<Class> clazz_;
+};
+
+}  // namespace java
+}  // namespace aidl
+}  // namespace android
+
+#endif  // AIDL_AST_JAVA_H_
diff --git a/aidl/ast_java_unittest.cpp b/aidl/ast_java_unittest.cpp
new file mode 100644
index 0000000..b2aad23
--- /dev/null
+++ b/aidl/ast_java_unittest.cpp
@@ -0,0 +1,63 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <string>
+
+#include <gtest/gtest.h>
+
+#include "ast_java.h"
+#include "code_writer.h"
+#include "type_java.h"
+
+using std::string;
+
+namespace android {
+namespace aidl {
+namespace java {
+namespace {
+
+const char kExpectedClassOutput[] =
+R"(// class comment
+final class TestClass extends SuperClass
+{
+}
+)";
+
+}  // namespace
+
+TEST(AstJavaTests, GeneratesClass) {
+  JavaTypeNamespace types;
+  types.Init();
+  Type class_type(&types, "TestClass", ValidatableType::KIND_GENERATED,
+                  false, false);
+  Type extend_type(&types, "SuperClass", ValidatableType::KIND_BUILT_IN,
+                   false, false);
+  Class a_class;
+  a_class.comment = "// class comment";
+  a_class.modifiers = FINAL;
+  a_class.what = Class::CLASS;
+  a_class.type = &class_type;
+  a_class.extends = &extend_type;
+
+  string actual_output;
+  CodeWriterPtr writer = GetStringWriter(&actual_output);
+  a_class.Write(writer.get());
+  EXPECT_EQ(string(kExpectedClassOutput), actual_output);
+}
+
+}  // namespace java
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/code_writer.cpp b/aidl/code_writer.cpp
new file mode 100644
index 0000000..58b1dc1
--- /dev/null
+++ b/aidl/code_writer.cpp
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "code_writer.h"
+
+#include <iostream>
+#include <stdarg.h>
+
+#include <android-base/stringprintf.h>
+
+using std::cerr;
+using std::endl;
+
+namespace android {
+namespace aidl {
+
+namespace {
+
+class StringCodeWriter : public CodeWriter {
+ public:
+  explicit StringCodeWriter(std::string* output_buffer) : output_(output_buffer) {}
+  virtual ~StringCodeWriter() = default;
+
+  bool Write(const char* format, ...) override {
+    va_list ap;
+    va_start(ap, format);
+    android::base::StringAppendV(output_, format, ap);
+    va_end(ap);
+    return true;
+  }
+
+  bool Close() override { return true; }
+
+ private:
+  std::string* output_;
+};  // class StringCodeWriter
+
+class FileCodeWriter : public CodeWriter {
+ public:
+  FileCodeWriter(FILE* output_file, bool close_on_destruction)
+      : output_(output_file),
+        close_on_destruction_(close_on_destruction) {}
+  virtual ~FileCodeWriter() {
+    if (close_on_destruction_ && output_ != nullptr) {
+      fclose(output_);
+    }
+  }
+
+  bool Write(const char* format, ...) override {
+    bool success;
+    va_list ap;
+    va_start(ap, format);
+    success = vfprintf(output_, format, ap) >= 0;
+    va_end(ap);
+    no_error_ = no_error_ && success;
+    return success;
+  }
+
+  bool Close() override {
+    if (output_ != nullptr) {
+      no_error_ = fclose(output_) == 0 && no_error_;
+      output_ = nullptr;
+    }
+    return no_error_;
+  }
+
+ private:
+  bool no_error_ = true;
+  FILE* output_;
+  bool close_on_destruction_;
+};  // class StringCodeWriter
+
+}  // namespace
+
+CodeWriterPtr GetFileWriter(const std::string& output_file) {
+  CodeWriterPtr result;
+  FILE* to = nullptr;
+  bool close_on_destruction = true;
+  if (output_file == "-") {
+    to = stdout;
+    close_on_destruction = false;
+  } else {
+    // open file in binary mode to ensure that the tool produces the
+    // same output on all platforms !!
+    to = fopen(output_file.c_str(), "wb");
+  }
+
+  if (to != nullptr) {
+    result.reset(new FileCodeWriter(to, close_on_destruction));
+  } else {
+    cerr << "unable to open " << output_file << " for write" << endl;
+  }
+
+  return result;
+}
+
+CodeWriterPtr GetStringWriter(std::string* output_buffer) {
+  return CodeWriterPtr(new StringCodeWriter(output_buffer));
+}
+
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/code_writer.h b/aidl/code_writer.h
new file mode 100644
index 0000000..4b2fe16
--- /dev/null
+++ b/aidl/code_writer.h
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_CODE_WRITER_H_
+#define AIDL_CODE_WRITER_H_
+
+#include <memory>
+#include <string>
+
+#include <stdio.h>
+
+#include <android-base/macros.h>
+
+namespace android {
+namespace aidl {
+
+class CodeWriter {
+ public:
+  // Write a formatted string to this writer in the usual printf sense.
+  // Returns false on error.
+  virtual bool Write(const char* format, ...) = 0;
+  virtual bool Close() = 0;
+  virtual ~CodeWriter() = default;
+};  // class CodeWriter
+
+using CodeWriterPtr = std::unique_ptr<CodeWriter>;
+
+// Get a CodeWriter that writes to |output_file|.
+CodeWriterPtr GetFileWriter(const std::string& output_file);
+
+// Get a CodeWriter that writes to a string buffer.
+// Caller retains ownership of the buffer.
+// The buffer must outlive the CodeWriter.
+CodeWriterPtr GetStringWriter(std::string* output_buffer);
+
+}  // namespace aidl
+}  // namespace android
+
+#endif // AIDL_CODE_WRITER_H_
diff --git a/aidl/docs/aidl-cpp.md b/aidl/docs/aidl-cpp.md
new file mode 100644
index 0000000..65cc8e4
--- /dev/null
+++ b/aidl/docs/aidl-cpp.md
@@ -0,0 +1,276 @@
+# Generating C++ Binder Interfaces with `aidl-cpp`
+
+## Background
+
+“aidl” refers to several related but distinct concepts:
+
+ - the AIDL interface [definition language](http://developer.android.com/guide/components/aidl.html)
+ - .aidl files (which contain AIDL)
+ - the aidl generator which transforms AIDL into client/server IPC interfaces
+
+The _aidl generator_ is a command line tool that generates client and server
+stubs for Binder interfaces from a specification in a file with the .aidl
+extension.  For Java interfaces, the executable is called `aidl` while for C++
+the binary is called `aidl-cpp`.  In this document, we’ll use AIDL to describe
+the language of .aidl files and _aidl generator_ to refer to the code generation
+tool that takes an .aidl file, parses the AIDL, and outputs code.
+
+Previously, the _aidl generator_ only generated Java interface/stub/proxy
+objects.  C++ Binder interfaces were handcrafted with various degrees of
+compatibility with the Java equivalents.  The Brillo project added support for
+generating C++ with the _aidl generator_.  This generated C++ is cross-language
+compatible (e.g. Java clients are tested to interoperate with native services).
+
+## Overview
+
+This document describes how C++ generation works with attention to:
+
+ - build interface
+ - cross-language type mapping
+ - implementing a generated interface
+ - C++ parcelables
+ - cross-language error reporting
+ - cross-language null reference handling
+
+## Detailed Design
+
+### Build Interface
+
+Write AIDL in .aidl files and add them to `LOCAL_SRC_FILES` in your Android.mk.
+If your build target is a binary (e.g. you include `$(BUILD_SHARED_LIBRARY)`),
+then the generated code will be C++, not Java.
+
+AIDL definitions should be hosted from the same repository as the
+implementation.  Any system that needs the definition will also need the
+implementation (for both parcelables and interface).  If there are multiple
+implementations (i.e. one in Java and one in C++), keep the definition with the
+native implementation.  Android
+[now has systems](https://developers.google.com/brillo/?hl=en) that run the
+native components of the system without the Java.
+
+If you use an import statement in your AIDL, even from the same package, you
+need to add a path to `LOCAL_AIDL_INCLUDES`.  This path should be relative to
+the root of the Android tree.  For instance, a file IFoo.aidl defining
+com.example.IFoo might sit in a folder hierarchy
+something/something-else/com/example/IFoo.aidl.  Then we would write:
+
+```
+LOCAL_AIDL_INCLUDES := something/something-else
+```
+
+Generated C++ ends up in nested namespaces corresponding to the interface’s
+package.  The generated header also corresponds to the interface package.  So
+com.example.IFoo becomes ::com::example::IFoo in header “com/example/IFoo.h”.
+
+Similar to how Java works, the suffix of the path to a .aidl file must match
+the package.  So if IFoo.aidl declares itself to be in package com.example, the
+folder structure (as given to `LOCAL_SRC_FILES`) must look like:
+`some/prefix/com/example/IFoo.aidl`.
+
+To generate code from .aidl files from another build target (e.g. another
+binary or java), just add a relative path to the .aidl files to
+`LOCAL_SRC_FILES`.  Remember that importing AIDL works the same, even for code
+in other directory hierarchies: add the include root path relative to the
+checkout root to `LOCAL_AIDL_INCLUDES`.
+
+### Type Mapping
+
+The following table summarizes the equivalent C++ types for common Java types
+and whether those types may be used as in/out/inout parameters in AIDL
+interfaces.
+
+| Java Type             | C++ Type            | inout | Notes                                                 |
+|-----------------------|---------------------|-------|-------------------------------------------------------|
+| boolean               | bool                | in    | "These 8 types are all considered primitives.         |
+| byte                  | int8\_t             | in    |                                                       |
+| char                  | char16\_t           | in    |                                                       |
+| int                   | int32\_t            | in    |                                                       |
+| long                  | int64\_t            | in    |                                                       |
+| float                 | float               | in    |                                                       |
+| double                | double              | in    |                                                       |
+| String                | String16            | in    | Supports null references.                             |
+| @utf8InCpp String     | std::string         | in    | @utf8InCpp causes UTF16 to UTF8 conversion in C++.    |
+| android.os.Parcelable | android::Parcelable | inout |                                                       |
+| T extends IBinder     | sp<T>               | in    |                                                       |
+| Arrays (T[])          | vector<T>           | inout | May contain only primitives, Strings and parcelables. |
+| List<String>          | vector<String16>    | inout |                                                       |
+| PersistableBundle     | PersistableBundle   | inout | binder/PersistableBundle.h                            |
+| List<IBinder>         | vector<sp<IBinder>> | inout |                                                       |
+| FileDescriptor        | unique_fd           | inout | android-base/unique_fd.h from libbase                 |
+
+Note that java.util.Map and java.utils.List are not good candidates for cross
+language communication because they may contain arbitrary types on the Java
+side.  For instance, Map is cast to Map<String,Object> and then the object
+values dynamically inspected and serialized as type/value pairs.  Support
+exists for sending arbitrary Java serializables, Android Bundles, etc.
+
+Note that annotations may be placed at the interface level, as well as on a
+type by type basis.  Interface level annotations will be applied
+opportunistically and be overridden by per type annotations.  For instance, an
+interface marked @nullable will still not allow null int parameters.
+
+### Implementing a generated interface
+
+Given an interface declaration like:
+
+```
+package foo;
+
+import bar.IAnotherInterface;
+
+interface IFoo {
+  IAnotherInterface DoSomething(int count, out List<String> output);
+}
+```
+
+`aidl-cpp` will generate a C++ interface:
+
+```
+namespace foo {
+
+// Some headers have been omitted for clarity.
+#include <android/String16.h>
+#include <cstdint>
+#include <vector>
+#include <bar/IAnotherInterface.h>
+
+// Some class members have been omitted for clarity.
+class IFoo : public android::IInterface {
+ public:
+  virtual android::binder::Status DoSomething(
+      int32_t count,
+      std::vector<android::String16>* output,
+      android::sp<bar::IAnotherInterface>* returned_value) = 0;
+};
+```
+
+Note that `aidl-cpp` will import headers for types used in the interface.  For
+imported types (e.g. parcelables and interfaces), it will import a header
+corresponding to the package/class name of the import.  For instance,
+`import bar.IAnotherInterface` causes aidl-cpp to generate
+`#include <bar/IAnotherInterface.h>`.
+
+When writing a service that implements this interface, write:
+
+```
+#include "foo/BnFoo.h"
+
+namespace unrelated_namespace {
+
+class MyFoo : public foo::BnFoo {
+ public:
+  android::binder::Status DoSomething(
+      int32_t count,
+      std::vector<android::String16>* output,
+      android::sp<bar::IAnotherInterface>* returned_value) override {
+    for (int32_t i = 0; i < count; ++i) {
+      output->push_back(String16("..."));
+    }
+    *returned_value = new InstanceOfAnotherInterface;
+    return Status::ok();
+  }
+};  // class MyFoo
+
+}  // namespace unrelated_namespace
+```
+
+Note that the output values, `output` and `returned_value` are passed by
+pointer, and that this pointer is always valid.
+
+#### Dependencies
+
+The generated C++ code will use symbols from libbinder as well as libutils.
+AIDL files using the FileDescriptor type will also explicitly require
+libnativehelper, although this is likely a transitive dependency of the other
+two, and should be included automatically within the Android build tree
+regardless.
+
+### C++ Parcelables
+
+In Java, a parcelable should extend android.os.Parcelable and provide a static
+final CREATOR field that acts as a factory for new instances/arrays of
+instances of the parcelable.  In addition, in order to be used as an out
+parameter, a parcelable class must define a readFromParcel method.
+
+In C++, parcelables must implement android::Parcelable from binder/Parcelable.h
+in libbinder.  Parcelables must define a constructor that takes no arguments.
+In order to be used in arrays, a parcelable must implement a copy or move
+constructor (called implicitly in vector).
+
+The C++ generator needs to know what header defines the C++ parcelable.  It
+learns this from the `cpp_header` directive shown below.  The generator takes
+this string and uses it as the literal include statement in generated code.
+The idea here is that you generate your code once, link it into a library along
+with parcelable implementations, and export appropriate header paths.  This
+header include must make sense in the context of the Android.mk that compiles
+this generated code.
+
+```
+// ExampleParcelable.aidl
+package com.example.android;
+
+// Native types must be aliased at their declaration in the appropriate .aidl
+// file.  This allows multiple interfaces to use a parcelable and its C++
+// equivalent without duplicating the mapping between the C++ and Java types.
+// Generator will assume bar/foo.h declares class
+// com::example::android::ExampleParcelable
+parcelable ExampleParcelable cpp_header "bar/foo.h";
+```
+
+### Null Reference Handling
+
+The aidl generator for both C++ and Java languages has been expanded to
+understand nullable annotations.
+
+Given an interface definition like:
+
+```
+interface IExample {
+  void ReadStrings(String neverNull, in @nullable String maybeNull);
+};
+```
+
+the generated C++ header code looks like:
+
+```
+class IExample {
+  android::binder::Status ReadStrings(
+      const android::String16& in_neverNull,
+      const std::unique_ptr<android::String16>& in_maybeNull);
+};
+```
+
+Note that by default, the generated C++ passes a const reference to the value
+of a parameter and rejects null references with a NullPointerException sent
+back the caller.  Parameters marked with @nullable are passed by pointer,
+allowing native services to explicitly control whether they allow method
+overloading via null parameters.  Java stubs and proxies currently do nothing
+with the @nullable annotation.
+
+Consider an AIDL type `in @nullable List<String> bar`.  This type
+indicates that the remote caller may pass in a list of strings, and that both
+the list and any string in the list may be null.  This type will map to a C++
+type `unique_ptr<vector<unique_ptr<String16>>>* bar`.  In this case:
+
+  - `bar` is never null
+  - `*bar` might be null
+  - `(*bar)->empty()` could be true
+  - `(**bar)[0]` could be null (and so on)
+
+### Exception Reporting
+
+C++ methods generated by the aidl generator return `android::binder::Status`
+objects, rather than `android::status_t`.  This Status object allows generated
+C++ code to send and receive exceptions (an exception type and a String16 error
+message) since we do not use real exceptions in C++.  More background on Status
+objects can be found here.
+
+For legacy support and migration ease, the Status object includes a mechanism
+to report a `android::status_t`.  However, that return code is interpreted by a
+different code path and does not include a helpful String message.
+
+For situations where your native service needs to throw an error code specific
+to the service, use `Status::fromServiceSpecificError()`.  This kind of
+exception comes with a helpful message and an integer error code.  Make your
+error codes consistent across services by using interface constants (see
+below).
diff --git a/aidl/docs/constants.md b/aidl/docs/constants.md
new file mode 100644
index 0000000..55fbd97
--- /dev/null
+++ b/aidl/docs/constants.md
@@ -0,0 +1,35 @@
+# Defining constants as part of an interface
+
+AIDL has been enhanced to support defining integer and string constants
+as part of an interface.
+
+## Integer constants
+
+```
+interface IMyInterface {
+    const int CONST_A = 1;
+    const int CONST_B = 2;
+    const int CONST_C = 3;
+    ...
+}
+```
+
+These map to appropriate 32 bit integer class constants in Java and C++ (e.g.
+`IMyInterface.CONST_A` and `IMyInterface::CONST_A` respectively).
+
+## String constants
+
+```
+interface IMyInterface {
+    const String CONST_A = "foo";
+    const String CONST_B = "bar";
+    ...
+}
+```
+
+These map to class level String constants in Java, and static getter
+functions that return a const android::String16& in C++.
+
+The constants are limited to contain printable ASCII characters < 0x10
+and without backspaces (i.e. no '\' character).
+
diff --git a/aidl/docs/making-changes.md b/aidl/docs/making-changes.md
new file mode 100644
index 0000000..ac84b86
--- /dev/null
+++ b/aidl/docs/making-changes.md
@@ -0,0 +1,21 @@
+# Making changes
+
+## Coding style
+
+This project was originally written in C, in the Android platform style.
+It has been substantially re-written in C++, in the Google C++ style.
+
+This style
+[is summarized here](https://google.github.io/styleguide/cppguide.html).
+
+When in doubt, clang-format -style=google is a good reference.
+
+## Testing
+
+This codebase has both integration and unittests, all of which are expected to
+consistently pass against a device/emulator:
+
+```
+$ ./runtests.sh && echo "All tests pass"
+
+```
diff --git a/aidl/generate_cpp.cpp b/aidl/generate_cpp.cpp
new file mode 100644
index 0000000..41e9fb4
--- /dev/null
+++ b/aidl/generate_cpp.cpp
@@ -0,0 +1,858 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "generate_cpp.h"
+
+#include <cctype>
+#include <cstring>
+#include <memory>
+#include <random>
+#include <set>
+#include <string>
+
+#include <android-base/stringprintf.h>
+
+#include "aidl_language.h"
+#include "ast_cpp.h"
+#include "code_writer.h"
+#include "logging.h"
+#include "os.h"
+
+using android::base::StringPrintf;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+using std::set;
+
+namespace android {
+namespace aidl {
+namespace cpp {
+namespace internals {
+namespace {
+
+const char kAndroidStatusVarName[] = "_aidl_ret_status";
+const char kCodeVarName[] = "_aidl_code";
+const char kFlagsVarName[] = "_aidl_flags";
+const char kDataVarName[] = "_aidl_data";
+const char kErrorLabel[] = "_aidl_error";
+const char kImplVarName[] = "_aidl_impl";
+const char kReplyVarName[] = "_aidl_reply";
+const char kReturnVarName[] = "_aidl_return";
+const char kStatusVarName[] = "_aidl_status";
+const char kAndroidParcelLiteral[] = "::android::Parcel";
+const char kAndroidStatusLiteral[] = "::android::status_t";
+const char kAndroidStatusOk[] = "::android::OK";
+const char kBinderStatusLiteral[] = "::android::binder::Status";
+const char kIBinderHeader[] = "binder/IBinder.h";
+const char kIInterfaceHeader[] = "binder/IInterface.h";
+const char kParcelHeader[] = "binder/Parcel.h";
+const char kStatusHeader[] = "binder/Status.h";
+const char kString16Header[] = "utils/String16.h";
+const char kStrongPointerHeader[] = "utils/StrongPointer.h";
+
+unique_ptr<AstNode> BreakOnStatusNotOk() {
+  IfStatement* ret = new IfStatement(new Comparison(
+      new LiteralExpression(kAndroidStatusVarName), "!=",
+      new LiteralExpression(kAndroidStatusOk)));
+  ret->OnTrue()->AddLiteral("break");
+  return unique_ptr<AstNode>(ret);
+}
+
+unique_ptr<AstNode> GotoErrorOnBadStatus() {
+  IfStatement* ret = new IfStatement(new Comparison(
+      new LiteralExpression(kAndroidStatusVarName), "!=",
+      new LiteralExpression(kAndroidStatusOk)));
+  ret->OnTrue()->AddLiteral(StringPrintf("goto %s", kErrorLabel));
+  return unique_ptr<AstNode>(ret);
+}
+
+
+unique_ptr<AstNode> ReturnOnStatusNotOk() {
+  IfStatement* ret = new IfStatement(new Comparison(
+      new LiteralExpression(kAndroidStatusVarName), "!=",
+      new LiteralExpression(kAndroidStatusOk)));
+  ret->OnTrue()->AddLiteral(StringPrintf("return %s", kAndroidStatusVarName));
+  return unique_ptr<AstNode>(ret);
+}
+
+string UpperCase(const std::string& s) {
+  string result = s;
+  for (char& c : result)
+    c = toupper(c);
+  return result;
+}
+
+string BuildVarName(const AidlArgument& a) {
+  string prefix = "out_";
+  if (a.GetDirection() & AidlArgument::IN_DIR) {
+    prefix = "in_";
+  }
+  return prefix + a.GetName();
+}
+
+ArgList BuildArgList(const TypeNamespace& types,
+                     const AidlMethod& method,
+                     bool for_declaration) {
+  // Build up the argument list for the server method call.
+  vector<string> method_arguments;
+  for (const unique_ptr<AidlArgument>& a : method.GetArguments()) {
+    string literal;
+    if (for_declaration) {
+      // Method declarations need types, pointers to out params, and variable
+      // names that match the .aidl specification.
+      const Type* type = a->GetType().GetLanguageType<Type>();
+
+      literal = type->CppType();
+
+      if (a->IsOut()) {
+        literal = literal + "*";
+      } else {
+        // We pass in parameters that are not primitives by const reference.
+        // Arrays of primitives are not primitives.
+        if (!type->IsCppPrimitive() || a->GetType().IsArray()) {
+          literal = "const " + literal + "&";
+        }
+      }
+
+      literal += " " + a->GetName();
+    } else {
+      if (a->IsOut()) { literal = "&"; }
+      literal += BuildVarName(*a);
+    }
+    method_arguments.push_back(literal);
+  }
+
+  const Type* return_type = method.GetType().GetLanguageType<Type>();
+
+  if (return_type != types.VoidType()) {
+    string literal;
+    if (for_declaration) {
+      literal = StringPrintf(
+          "%s* %s", return_type->CppType().c_str(),
+          kReturnVarName);
+    } else {
+      literal = string{"&"} + kReturnVarName;
+    }
+    method_arguments.push_back(literal);
+  }
+
+  return ArgList(method_arguments);
+}
+
+unique_ptr<Declaration> BuildMethodDecl(const AidlMethod& method,
+                                        const TypeNamespace& types,
+                                        bool for_interface) {
+  uint32_t modifiers = 0;
+  if (for_interface) {
+    modifiers |= MethodDecl::IS_VIRTUAL;
+    modifiers |= MethodDecl::IS_PURE_VIRTUAL;
+  } else {
+    modifiers |= MethodDecl::IS_OVERRIDE;
+  }
+
+  return unique_ptr<Declaration>{
+      new MethodDecl{kBinderStatusLiteral,
+                     method.GetName(),
+                     BuildArgList(types, method, true /* for method decl */),
+                     modifiers}};
+}
+
+unique_ptr<CppNamespace> NestInNamespaces(
+    vector<unique_ptr<Declaration>> decls,
+    const vector<string>& package) {
+  if (package.empty()) {
+    // We should also be checking this before we get this far, but do it again
+    // for the sake of unit tests and meaningful errors.
+    LOG(FATAL) << "C++ generation requires a package declaration "
+                  "for namespacing";
+  }
+  auto it = package.crbegin();  // Iterate over the namespaces inner to outer
+  unique_ptr<CppNamespace> inner{new CppNamespace{*it, std::move(decls)}};
+  ++it;
+  for (; it != package.crend(); ++it) {
+    inner.reset(new CppNamespace{*it, std::move(inner)});
+  }
+  return inner;
+}
+
+unique_ptr<CppNamespace> NestInNamespaces(unique_ptr<Declaration> decl,
+                                          const vector<string>& package) {
+  vector<unique_ptr<Declaration>> decls;
+  decls.push_back(std::move(decl));
+  return NestInNamespaces(std::move(decls), package);
+}
+
+bool DeclareLocalVariable(const TypeNamespace& types, const AidlArgument& a,
+                          StatementBlock* b) {
+  const Type* cpp_type = a.GetType().GetLanguageType<Type>();
+  if (!cpp_type) { return false; }
+
+  string type = cpp_type->CppType();
+
+  b->AddLiteral(type + " " + BuildVarName(a));
+  return true;
+}
+
+string ClassName(const AidlInterface& interface, ClassNames type) {
+  string c_name = interface.GetName();
+
+  if (c_name.length() >= 2 && c_name[0] == 'I' && isupper(c_name[1]))
+    c_name = c_name.substr(1);
+
+  switch (type) {
+    case ClassNames::CLIENT:
+      c_name = "Bp" + c_name;
+      break;
+    case ClassNames::SERVER:
+      c_name = "Bn" + c_name;
+      break;
+    case ClassNames::INTERFACE:
+      c_name = "I" + c_name;
+      break;
+    case ClassNames::BASE:
+      break;
+  }
+  return c_name;
+}
+
+string BuildHeaderGuard(const AidlInterface& interface,
+                        ClassNames header_type) {
+  string class_name = ClassName(interface, header_type);
+  for (size_t i = 1; i < class_name.size(); ++i) {
+    if (isupper(class_name[i])) {
+      class_name.insert(i, "_");
+      ++i;
+    }
+  }
+  string ret = StringPrintf("AIDL_GENERATED_%s_%s_H_",
+                            interface.GetPackage().c_str(),
+                            class_name.c_str());
+  for (char& c : ret) {
+    if (c == '.') {
+      c = '_';
+    }
+    c = toupper(c);
+  }
+  return ret;
+}
+
+unique_ptr<Declaration> DefineClientTransaction(const TypeNamespace& types,
+                                                const AidlInterface& interface,
+                                                const AidlMethod& method) {
+  const string i_name = ClassName(interface, ClassNames::INTERFACE);
+  const string bp_name = ClassName(interface, ClassNames::CLIENT);
+  unique_ptr<MethodImpl> ret{new MethodImpl{
+      kBinderStatusLiteral, bp_name, method.GetName(),
+      ArgList{BuildArgList(types, method, true /* for method decl */)}}};
+  StatementBlock* b = ret->GetStatementBlock();
+
+  // Declare parcels to hold our query and the response.
+  b->AddLiteral(StringPrintf("%s %s", kAndroidParcelLiteral, kDataVarName));
+  // Even if we're oneway, the transact method still takes a parcel.
+  b->AddLiteral(StringPrintf("%s %s", kAndroidParcelLiteral, kReplyVarName));
+
+  // Declare the status_t variable we need for error handling.
+  b->AddLiteral(StringPrintf("%s %s = %s", kAndroidStatusLiteral,
+                             kAndroidStatusVarName,
+                             kAndroidStatusOk));
+  // We unconditionally return a Status object.
+  b->AddLiteral(StringPrintf("%s %s", kBinderStatusLiteral, kStatusVarName));
+
+  // Add the name of the interface we're hoping to call.
+  b->AddStatement(new Assignment(
+      kAndroidStatusVarName,
+      new MethodCall(StringPrintf("%s.writeInterfaceToken",
+                                  kDataVarName),
+                     "getInterfaceDescriptor()")));
+  b->AddStatement(GotoErrorOnBadStatus());
+
+  for (const auto& a: method.GetArguments()) {
+    const Type* type = a->GetType().GetLanguageType<Type>();
+    string var_name = ((a->IsOut()) ? "*" : "") + a->GetName();
+    var_name = type->WriteCast(var_name);
+
+    if (a->IsIn()) {
+      // Serialization looks roughly like:
+      //     _aidl_ret_status = _aidl_data.WriteInt32(in_param_name);
+      //     if (_aidl_ret_status != ::android::OK) { goto error; }
+      const string& method = type->WriteToParcelMethod();
+      b->AddStatement(new Assignment(
+          kAndroidStatusVarName,
+          new MethodCall(StringPrintf("%s.%s", kDataVarName, method.c_str()),
+                         ArgList(var_name))));
+      b->AddStatement(GotoErrorOnBadStatus());
+    } else if (a->IsOut() && a->GetType().IsArray()) {
+      // Special case, the length of the out array is written into the parcel.
+      //     _aidl_ret_status = _aidl_data.writeVectorSize(&out_param_name);
+      //     if (_aidl_ret_status != ::android::OK) { goto error; }
+      b->AddStatement(new Assignment(
+          kAndroidStatusVarName,
+          new MethodCall(StringPrintf("%s.writeVectorSize", kDataVarName),
+                         ArgList(var_name))));
+      b->AddStatement(GotoErrorOnBadStatus());
+    }
+  }
+
+  // Invoke the transaction on the remote binder and confirm status.
+  string transaction_code = StringPrintf(
+      "%s::%s", i_name.c_str(), UpperCase(method.GetName()).c_str());
+
+  vector<string> args = {transaction_code, kDataVarName,
+                         StringPrintf("&%s", kReplyVarName)};
+
+  if (interface.IsOneway() || method.IsOneway()) {
+    args.push_back("::android::IBinder::FLAG_ONEWAY");
+  }
+
+  b->AddStatement(new Assignment(
+      kAndroidStatusVarName,
+      new MethodCall("remote()->transact",
+                     ArgList(args))));
+  b->AddStatement(GotoErrorOnBadStatus());
+
+  if (!interface.IsOneway() && !method.IsOneway()) {
+    // Strip off the exception header and fail if we see a remote exception.
+    // _aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+    // if (_aidl_ret_status != ::android::OK) { goto error; }
+    // if (!_aidl_status.isOk()) { return _aidl_ret_status; }
+    b->AddStatement(new Assignment(
+        kAndroidStatusVarName,
+        StringPrintf("%s.readFromParcel(%s)", kStatusVarName, kReplyVarName)));
+    b->AddStatement(GotoErrorOnBadStatus());
+    IfStatement* exception_check = new IfStatement(
+        new LiteralExpression(StringPrintf("!%s.isOk()", kStatusVarName)));
+    b->AddStatement(exception_check);
+    exception_check->OnTrue()->AddLiteral(
+        StringPrintf("return %s", kStatusVarName));
+  }
+
+  // Type checking should guarantee that nothing below emits code until "return
+  // status" if we are a oneway method, so no more fear of accessing reply.
+
+  // If the method is expected to return something, read it first by convention.
+  const Type* return_type = method.GetType().GetLanguageType<Type>();
+  if (return_type != types.VoidType()) {
+    const string& method_call = return_type->ReadFromParcelMethod();
+    b->AddStatement(new Assignment(
+        kAndroidStatusVarName,
+        new MethodCall(StringPrintf("%s.%s", kReplyVarName,
+                                    method_call.c_str()),
+                       ArgList(kReturnVarName))));
+    b->AddStatement(GotoErrorOnBadStatus());
+  }
+
+  for (const AidlArgument* a : method.GetOutArguments()) {
+    // Deserialization looks roughly like:
+    //     _aidl_ret_status = _aidl_reply.ReadInt32(out_param_name);
+    //     if (_aidl_status != ::android::OK) { goto _aidl_error; }
+    string method =
+      a->GetType().GetLanguageType<Type>()->ReadFromParcelMethod();
+
+    b->AddStatement(new Assignment(
+        kAndroidStatusVarName,
+        new MethodCall(StringPrintf("%s.%s", kReplyVarName,
+                                    method.c_str()),
+                       ArgList(a->GetName()))));
+    b->AddStatement(GotoErrorOnBadStatus());
+  }
+
+  // If we've gotten to here, one of two things is true:
+  //   1) We've read some bad status_t
+  //   2) We've only read status_t == OK and there was no exception in the
+  //      response.
+  // In both cases, we're free to set Status from the status_t and return.
+  b->AddLiteral(StringPrintf("%s:\n", kErrorLabel), false /* no semicolon */);
+  b->AddLiteral(
+      StringPrintf("%s.setFromStatusT(%s)", kStatusVarName,
+                   kAndroidStatusVarName));
+  b->AddLiteral(StringPrintf("return %s", kStatusVarName));
+
+  return unique_ptr<Declaration>(ret.release());
+}
+
+}  // namespace
+
+unique_ptr<Document> BuildClientSource(const TypeNamespace& types,
+                                       const AidlInterface& interface) {
+  vector<string> include_list = {
+      HeaderFile(interface, ClassNames::CLIENT, false),
+      kParcelHeader
+  };
+  vector<unique_ptr<Declaration>> file_decls;
+
+  // The constructor just passes the IBinder instance up to the super
+  // class.
+  const string i_name = ClassName(interface, ClassNames::INTERFACE);
+  file_decls.push_back(unique_ptr<Declaration>{new ConstructorImpl{
+      ClassName(interface, ClassNames::CLIENT),
+      ArgList{StringPrintf("const ::android::sp<::android::IBinder>& %s",
+                           kImplVarName)},
+      { "BpInterface<" + i_name + ">(" + kImplVarName + ")" }}});
+
+  // Clients define a method per transaction.
+  for (const auto& method : interface.GetMethods()) {
+    unique_ptr<Declaration> m = DefineClientTransaction(
+        types, interface, *method);
+    if (!m) { return nullptr; }
+    file_decls.push_back(std::move(m));
+  }
+  return unique_ptr<Document>{new CppSource{
+      include_list,
+      NestInNamespaces(std::move(file_decls), interface.GetSplitPackage())}};
+}
+
+namespace {
+
+bool HandleServerTransaction(const TypeNamespace& types,
+                             const AidlMethod& method,
+                             StatementBlock* b) {
+  // Declare all the parameters now.  In the common case, we expect no errors
+  // in serialization.
+  for (const unique_ptr<AidlArgument>& a : method.GetArguments()) {
+    if (!DeclareLocalVariable(types, *a, b)) { return false; }
+  }
+
+  // Declare a variable to hold the return value.
+  const Type* return_type = method.GetType().GetLanguageType<Type>();
+  if (return_type != types.VoidType()) {
+    b->AddLiteral(StringPrintf(
+        "%s %s", return_type->CppType().c_str(),
+        kReturnVarName));
+  }
+
+  // Check that the client is calling the correct interface.
+  IfStatement* interface_check = new IfStatement(
+      new MethodCall(StringPrintf("%s.checkInterface",
+                                  kDataVarName), "this"),
+      true /* invert the check */);
+  b->AddStatement(interface_check);
+  interface_check->OnTrue()->AddStatement(
+      new Assignment(kAndroidStatusVarName, "::android::BAD_TYPE"));
+  interface_check->OnTrue()->AddLiteral("break");
+
+  // Deserialize each "in" parameter to the transaction.
+  for (const auto& a: method.GetArguments()) {
+    // Deserialization looks roughly like:
+    //     _aidl_ret_status = _aidl_data.ReadInt32(&in_param_name);
+    //     if (_aidl_ret_status != ::android::OK) { break; }
+    const Type* type = a->GetType().GetLanguageType<Type>();
+    const string& readMethod = type->ReadFromParcelMethod();
+
+    if (a->IsIn()) {
+      b->AddStatement(new Assignment{
+          kAndroidStatusVarName,
+          new MethodCall{string(kDataVarName) + "." + readMethod,
+                         "&" + BuildVarName(*a)}});
+      b->AddStatement(BreakOnStatusNotOk());
+    } else if (a->IsOut() && a->GetType().IsArray()) {
+      // Special case, the length of the out array is written into the parcel.
+      //     _aidl_ret_status = _aidl_data.resizeOutVector(&out_param_name);
+      //     if (_aidl_ret_status != ::android::OK) { break; }
+      b->AddStatement(new Assignment{
+          kAndroidStatusVarName,
+          new MethodCall{string(kDataVarName) + ".resizeOutVector",
+                         "&" + BuildVarName(*a)}});
+      b->AddStatement(BreakOnStatusNotOk());
+    }
+  }
+
+  // Call the actual method.  This is implemented by the subclass.
+  vector<unique_ptr<AstNode>> status_args;
+  status_args.emplace_back(new MethodCall(
+          method.GetName(),
+          BuildArgList(types, method, false /* not for method decl */)));
+  b->AddStatement(new Statement(new MethodCall(
+      StringPrintf("%s %s", kBinderStatusLiteral, kStatusVarName),
+      ArgList(std::move(status_args)))));
+
+  // Write exceptions during transaction handling to parcel.
+  if (!method.IsOneway()) {
+    b->AddStatement(new Assignment(
+        kAndroidStatusVarName,
+        StringPrintf("%s.writeToParcel(%s)", kStatusVarName, kReplyVarName)));
+    b->AddStatement(BreakOnStatusNotOk());
+    IfStatement* exception_check = new IfStatement(
+        new LiteralExpression(StringPrintf("!%s.isOk()", kStatusVarName)));
+    b->AddStatement(exception_check);
+    exception_check->OnTrue()->AddLiteral("break");
+  }
+
+  // If we have a return value, write it first.
+  if (return_type != types.VoidType()) {
+    string writeMethod =
+        string(kReplyVarName) + "->" +
+        return_type->WriteToParcelMethod();
+    b->AddStatement(new Assignment{
+        kAndroidStatusVarName, new MethodCall{writeMethod,
+        ArgList{return_type->WriteCast(kReturnVarName)}}});
+    b->AddStatement(BreakOnStatusNotOk());
+  }
+
+  // Write each out parameter to the reply parcel.
+  for (const AidlArgument* a : method.GetOutArguments()) {
+    // Serialization looks roughly like:
+    //     _aidl_ret_status = data.WriteInt32(out_param_name);
+    //     if (_aidl_ret_status != ::android::OK) { break; }
+    const Type* type = a->GetType().GetLanguageType<Type>();
+    const string& writeMethod = type->WriteToParcelMethod();
+
+    b->AddStatement(new Assignment{
+        kAndroidStatusVarName,
+        new MethodCall{string(kReplyVarName) + "->" + writeMethod,
+                       type->WriteCast(BuildVarName(*a))}});
+    b->AddStatement(BreakOnStatusNotOk());
+  }
+
+  return true;
+}
+
+}  // namespace
+
+unique_ptr<Document> BuildServerSource(const TypeNamespace& types,
+                                       const AidlInterface& interface) {
+  const string bn_name = ClassName(interface, ClassNames::SERVER);
+  vector<string> include_list{
+      HeaderFile(interface, ClassNames::SERVER, false),
+      kParcelHeader
+  };
+  unique_ptr<MethodImpl> on_transact{new MethodImpl{
+      kAndroidStatusLiteral, bn_name, "onTransact",
+      ArgList{{StringPrintf("uint32_t %s", kCodeVarName),
+               StringPrintf("const %s& %s", kAndroidParcelLiteral,
+                            kDataVarName),
+               StringPrintf("%s* %s", kAndroidParcelLiteral, kReplyVarName),
+               StringPrintf("uint32_t %s", kFlagsVarName)}}
+      }};
+
+  // Declare the status_t variable
+  on_transact->GetStatementBlock()->AddLiteral(
+      StringPrintf("%s %s = %s", kAndroidStatusLiteral, kAndroidStatusVarName,
+                   kAndroidStatusOk));
+
+  // Add the all important switch statement, but retain a pointer to it.
+  SwitchStatement* s = new SwitchStatement{kCodeVarName};
+  on_transact->GetStatementBlock()->AddStatement(s);
+
+  // The switch statement has a case statement for each transaction code.
+  for (const auto& method : interface.GetMethods()) {
+    StatementBlock* b = s->AddCase("Call::" + UpperCase(method->GetName()));
+    if (!b) { return nullptr; }
+
+    if (!HandleServerTransaction(types, *method, b)) { return nullptr; }
+  }
+
+  // The switch statement has a default case which defers to the super class.
+  // The superclass handles a few pre-defined transactions.
+  StatementBlock* b = s->AddCase("");
+  b->AddLiteral(StringPrintf(
+                "%s = ::android::BBinder::onTransact(%s, %s, "
+                "%s, %s)", kAndroidStatusVarName, kCodeVarName,
+                kDataVarName, kReplyVarName, kFlagsVarName));
+
+  // If we saw a null reference, we can map that to an appropriate exception.
+  IfStatement* null_check = new IfStatement(
+      new LiteralExpression(string(kAndroidStatusVarName) +
+                            " == ::android::UNEXPECTED_NULL"));
+  on_transact->GetStatementBlock()->AddStatement(null_check);
+  null_check->OnTrue()->AddStatement(new Assignment(
+      kAndroidStatusVarName,
+      StringPrintf("%s::fromExceptionCode(%s::EX_NULL_POINTER)"
+                   ".writeToParcel(%s)",
+                   kBinderStatusLiteral, kBinderStatusLiteral,
+                   kReplyVarName)));
+
+  // Finally, the server's onTransact method just returns a status code.
+  on_transact->GetStatementBlock()->AddLiteral(
+      StringPrintf("return %s", kAndroidStatusVarName));
+
+  return unique_ptr<Document>{new CppSource{
+      include_list,
+      NestInNamespaces(std::move(on_transact), interface.GetSplitPackage())}};
+}
+
+unique_ptr<Document> BuildInterfaceSource(const TypeNamespace& /* types */,
+                                          const AidlInterface& interface) {
+  vector<string> include_list{
+      HeaderFile(interface, ClassNames::INTERFACE, false),
+      HeaderFile(interface, ClassNames::CLIENT, false),
+  };
+
+  string fq_name = ClassName(interface, ClassNames::INTERFACE);
+  if (!interface.GetPackage().empty()) {
+    fq_name = interface.GetPackage() + "." + fq_name;
+  }
+
+  vector<unique_ptr<Declaration>> decls;
+
+  unique_ptr<MacroDecl> meta_if{new MacroDecl{
+      "IMPLEMENT_META_INTERFACE",
+      ArgList{vector<string>{ClassName(interface, ClassNames::BASE),
+                             '"' + fq_name + '"'}}}};
+  decls.push_back(std::move(meta_if));
+
+  for (const auto& constant: interface.GetStringConstants()) {
+    unique_ptr<MethodImpl> getter(new MethodImpl(
+        "const ::android::String16&",
+        ClassName(interface, ClassNames::INTERFACE),
+        constant->GetName(),
+        {}));
+    getter->GetStatementBlock()->AddLiteral(
+        StringPrintf("static const ::android::String16 value(%s)",
+                     constant->GetValue().c_str()));
+    getter->GetStatementBlock()->AddLiteral("return value");
+    decls.push_back(std::move(getter));
+  }
+
+  return unique_ptr<Document>{new CppSource{
+      include_list,
+      NestInNamespaces(std::move(decls), interface.GetSplitPackage())}};
+}
+
+unique_ptr<Document> BuildClientHeader(const TypeNamespace& types,
+                                       const AidlInterface& interface) {
+  const string i_name = ClassName(interface, ClassNames::INTERFACE);
+  const string bp_name = ClassName(interface, ClassNames::CLIENT);
+
+  unique_ptr<ConstructorDecl> constructor{new ConstructorDecl{
+      bp_name,
+      ArgList{StringPrintf("const ::android::sp<::android::IBinder>& %s",
+                           kImplVarName)},
+      ConstructorDecl::IS_EXPLICIT
+  }};
+  unique_ptr<ConstructorDecl> destructor{new ConstructorDecl{
+      "~" + bp_name,
+      ArgList{},
+      ConstructorDecl::IS_VIRTUAL | ConstructorDecl::IS_DEFAULT}};
+
+  vector<unique_ptr<Declaration>> publics;
+  publics.push_back(std::move(constructor));
+  publics.push_back(std::move(destructor));
+
+  for (const auto& method: interface.GetMethods()) {
+    publics.push_back(BuildMethodDecl(*method, types, false));
+  }
+
+  unique_ptr<ClassDecl> bp_class{
+      new ClassDecl{bp_name,
+                    "::android::BpInterface<" + i_name + ">",
+                    std::move(publics),
+                    {}
+      }};
+
+  return unique_ptr<Document>{new CppHeader{
+      BuildHeaderGuard(interface, ClassNames::CLIENT),
+      {kIBinderHeader,
+       kIInterfaceHeader,
+       "utils/Errors.h",
+       HeaderFile(interface, ClassNames::INTERFACE, false)},
+      NestInNamespaces(std::move(bp_class), interface.GetSplitPackage())}};
+}
+
+unique_ptr<Document> BuildServerHeader(const TypeNamespace& /* types */,
+                                       const AidlInterface& interface) {
+  const string i_name = ClassName(interface, ClassNames::INTERFACE);
+  const string bn_name = ClassName(interface, ClassNames::SERVER);
+
+  unique_ptr<Declaration> on_transact{new MethodDecl{
+      kAndroidStatusLiteral, "onTransact",
+      ArgList{{StringPrintf("uint32_t %s", kCodeVarName),
+               StringPrintf("const %s& %s", kAndroidParcelLiteral,
+                            kDataVarName),
+               StringPrintf("%s* %s", kAndroidParcelLiteral, kReplyVarName),
+               StringPrintf("uint32_t %s = 0", kFlagsVarName)}},
+      MethodDecl::IS_OVERRIDE
+  }};
+
+  std::vector<unique_ptr<Declaration>> publics;
+  publics.push_back(std::move(on_transact));
+
+  unique_ptr<ClassDecl> bn_class{
+      new ClassDecl{bn_name,
+                    "::android::BnInterface<" + i_name + ">",
+                    std::move(publics),
+                    {}
+      }};
+
+  return unique_ptr<Document>{new CppHeader{
+      BuildHeaderGuard(interface, ClassNames::SERVER),
+      {"binder/IInterface.h",
+       HeaderFile(interface, ClassNames::INTERFACE, false)},
+      NestInNamespaces(std::move(bn_class), interface.GetSplitPackage())}};
+}
+
+unique_ptr<Document> BuildInterfaceHeader(const TypeNamespace& types,
+                                          const AidlInterface& interface) {
+  set<string> includes = { kIBinderHeader, kIInterfaceHeader,
+                           kStatusHeader, kStrongPointerHeader };
+
+  for (const auto& method : interface.GetMethods()) {
+    for (const auto& argument : method->GetArguments()) {
+      const Type* type = argument->GetType().GetLanguageType<Type>();
+      type->GetHeaders(&includes);
+    }
+
+    const Type* return_type = method->GetType().GetLanguageType<Type>();
+    return_type->GetHeaders(&includes);
+  }
+
+  unique_ptr<ClassDecl> if_class{
+      new ClassDecl{ClassName(interface, ClassNames::INTERFACE),
+                    "::android::IInterface"}};
+  if_class->AddPublic(unique_ptr<Declaration>{new MacroDecl{
+      "DECLARE_META_INTERFACE",
+      ArgList{vector<string>{ClassName(interface, ClassNames::BASE)}}}});
+
+  unique_ptr<Enum> constant_enum{new Enum{"", "int32_t"}};
+  for (const auto& constant : interface.GetIntConstants()) {
+    constant_enum->AddValue(
+        constant->GetName(), std::to_string(constant->GetValue()));
+  }
+  if (constant_enum->HasValues()) {
+    if_class->AddPublic(std::move(constant_enum));
+  }
+
+  if (!interface.GetStringConstants().empty()) {
+    includes.insert(kString16Header);
+  }
+  for (const auto& constant : interface.GetStringConstants()) {
+    unique_ptr<MethodDecl> getter(new MethodDecl(
+          "const ::android::String16&", constant->GetName(),
+          {}, MethodDecl::IS_STATIC));
+    if_class->AddPublic(std::move(getter));
+  }
+
+  if (!interface.GetMethods().empty()) {
+    unique_ptr<Enum> call_enum{new Enum{"Call"}};
+    for (const auto& method : interface.GetMethods()) {
+      // Each method gets an enum entry and pure virtual declaration.
+      if_class->AddPublic(BuildMethodDecl(*method, types, true));
+      call_enum->AddValue(
+          UpperCase(method->GetName()),
+          StringPrintf("::android::IBinder::FIRST_CALL_TRANSACTION + %d",
+                       method->GetId()));
+    }
+    if_class->AddPublic(std::move(call_enum));
+  }
+
+  return unique_ptr<Document>{new CppHeader{
+      BuildHeaderGuard(interface, ClassNames::INTERFACE),
+      vector<string>(includes.begin(), includes.end()),
+      NestInNamespaces(std::move(if_class), interface.GetSplitPackage())}};
+}
+
+bool WriteHeader(const CppOptions& options,
+                 const TypeNamespace& types,
+                 const AidlInterface& interface,
+                 const IoDelegate& io_delegate,
+                 ClassNames header_type) {
+  unique_ptr<Document> header;
+  switch (header_type) {
+    case ClassNames::INTERFACE:
+      header = BuildInterfaceHeader(types, interface);
+      break;
+    case ClassNames::CLIENT:
+      header = BuildClientHeader(types, interface);
+      break;
+    case ClassNames::SERVER:
+      header = BuildServerHeader(types, interface);
+      break;
+    default:
+      LOG(FATAL) << "aidl internal error";
+  }
+  if (!header) {
+    LOG(ERROR) << "aidl internal error: Failed to generate header.";
+    return false;
+  }
+
+  const string header_path = options.OutputHeaderDir() + OS_PATH_SEPARATOR +
+                             HeaderFile(interface, header_type);
+  unique_ptr<CodeWriter> code_writer(io_delegate.GetCodeWriter(header_path));
+  header->Write(code_writer.get());
+
+  const bool success = code_writer->Close();
+  if (!success) {
+    io_delegate.RemovePath(header_path);
+  }
+
+  return success;
+}
+
+}  // namespace internals
+
+using namespace internals;
+
+string HeaderFile(const AidlInterface& interface,
+                  ClassNames class_type,
+                  bool use_os_sep) {
+  string file_path = interface.GetPackage();
+  for (char& c: file_path) {
+    if (c == '.') {
+      c = (use_os_sep) ? OS_PATH_SEPARATOR : '/';
+    }
+  }
+  if (!file_path.empty()) {
+    file_path += (use_os_sep) ? OS_PATH_SEPARATOR : '/';
+  }
+  file_path += ClassName(interface, class_type);
+  file_path += ".h";
+
+  return file_path;
+}
+
+bool GenerateCpp(const CppOptions& options,
+                 const TypeNamespace& types,
+                 const AidlInterface& interface,
+                 const IoDelegate& io_delegate) {
+  auto interface_src = BuildInterfaceSource(types, interface);
+  auto client_src = BuildClientSource(types, interface);
+  auto server_src = BuildServerSource(types, interface);
+
+  if (!interface_src || !client_src || !server_src) {
+    return false;
+  }
+
+  if (!io_delegate.CreatedNestedDirs(options.OutputHeaderDir(),
+                                     interface.GetSplitPackage())) {
+    LOG(ERROR) << "Failed to create directory structure for headers.";
+    return false;
+  }
+
+  if (!WriteHeader(options, types, interface, io_delegate,
+                   ClassNames::INTERFACE) ||
+      !WriteHeader(options, types, interface, io_delegate,
+                   ClassNames::CLIENT) ||
+      !WriteHeader(options, types, interface, io_delegate,
+                   ClassNames::SERVER)) {
+    return false;
+  }
+
+  unique_ptr<CodeWriter> writer = io_delegate.GetCodeWriter(
+      options.OutputCppFilePath());
+  interface_src->Write(writer.get());
+  client_src->Write(writer.get());
+  server_src->Write(writer.get());
+
+  const bool success = writer->Close();
+  if (!success) {
+    io_delegate.RemovePath(options.OutputCppFilePath());
+  }
+
+  return success;
+}
+
+}  // namespace cpp
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/generate_cpp.h b/aidl/generate_cpp.h
new file mode 100644
index 0000000..1ffc681
--- /dev/null
+++ b/aidl/generate_cpp.h
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_GENERATE_CPP_H_
+#define AIDL_GENERATE_CPP_H_
+
+#include <memory>
+#include <string>
+
+#include "aidl_language.h"
+#include "ast_cpp.h"
+#include "options.h"
+#include "type_cpp.h"
+
+namespace android {
+namespace aidl {
+namespace cpp {
+
+bool GenerateCpp(const CppOptions& options,
+                 const cpp::TypeNamespace& types,
+                 const AidlInterface& parsed_doc,
+                 const IoDelegate& io_delegate);
+
+// These roughly correspond to the various class names in the C++ hierarchy:
+enum class ClassNames {
+  BASE,       // Foo (not a real class, but useful in some circumstances).
+  CLIENT,     // BpFoo
+  SERVER,     // BnFoo
+  INTERFACE,  // IFoo
+};
+
+// Generate the relative path to a header file.  If |use_os_sep| we'll use the
+// operating system specific path separator rather than C++'s expected '/' when
+// including headers.
+std::string HeaderFile(const AidlInterface& interface, ClassNames class_type,
+                       bool use_os_sep = true);
+
+namespace internals {
+std::unique_ptr<Document> BuildClientSource(const TypeNamespace& types,
+                                            const AidlInterface& parsed_doc);
+std::unique_ptr<Document> BuildServerSource(const TypeNamespace& types,
+                                            const AidlInterface& parsed_doc);
+std::unique_ptr<Document> BuildInterfaceSource(const TypeNamespace& types,
+                                               const AidlInterface& parsed_doc);
+std::unique_ptr<Document> BuildClientHeader(const TypeNamespace& types,
+                                            const AidlInterface& parsed_doc);
+std::unique_ptr<Document> BuildServerHeader(const TypeNamespace& types,
+                                            const AidlInterface& parsed_doc);
+std::unique_ptr<Document> BuildInterfaceHeader(const TypeNamespace& types,
+                                               const AidlInterface& parsed_doc);
+}
+}  // namespace cpp
+}  // namespace aidl
+}  // namespace android
+
+#endif // AIDL_GENERATE_CPP_H_
diff --git a/aidl/generate_cpp_unittest.cpp b/aidl/generate_cpp_unittest.cpp
new file mode 100644
index 0000000..50bfd9c
--- /dev/null
+++ b/aidl/generate_cpp_unittest.cpp
@@ -0,0 +1,888 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <string>
+
+#include <android-base/stringprintf.h>
+#include <gtest/gtest.h>
+
+#include "aidl.h"
+#include "aidl_language.h"
+#include "ast_cpp.h"
+#include "code_writer.h"
+#include "generate_cpp.h"
+#include "os.h"
+#include "tests/fake_io_delegate.h"
+#include "tests/test_util.h"
+#include "type_cpp.h"
+
+using ::android::aidl::test::FakeIoDelegate;
+using ::android::base::StringPrintf;
+using std::string;
+using std::unique_ptr;
+
+namespace android {
+namespace aidl {
+namespace cpp {
+namespace {
+
+const string kComplexTypeInterfaceAIDL =
+R"(package android.os;
+import foo.IFooType;
+interface IComplexTypeInterface {
+  const int MY_CONSTANT = 3;
+  int[] Send(in @nullable int[] goes_in, inout double[] goes_in_and_out, out boolean[] goes_out);
+  oneway void Piff(int times);
+  IFooType TakesABinder(IFooType f);
+  @nullable IFooType NullableBinder();
+  List<String> StringListMethod(in java.util.List<String> input, out List<String> output);
+  List<IBinder> BinderListMethod(in java.util.List<IBinder> input, out List<IBinder> output);
+  FileDescriptor TakesAFileDescriptor(in FileDescriptor f);
+  FileDescriptor[] TakesAFileDescriptorArray(in FileDescriptor[] f);
+})";
+
+const char kExpectedComplexTypeClientHeaderOutput[] =
+R"(#ifndef AIDL_GENERATED_ANDROID_OS_BP_COMPLEX_TYPE_INTERFACE_H_
+#define AIDL_GENERATED_ANDROID_OS_BP_COMPLEX_TYPE_INTERFACE_H_
+
+#include <binder/IBinder.h>
+#include <binder/IInterface.h>
+#include <utils/Errors.h>
+#include <android/os/IComplexTypeInterface.h>
+
+namespace android {
+
+namespace os {
+
+class BpComplexTypeInterface : public ::android::BpInterface<IComplexTypeInterface> {
+public:
+explicit BpComplexTypeInterface(const ::android::sp<::android::IBinder>& _aidl_impl);
+virtual ~BpComplexTypeInterface() = default;
+::android::binder::Status Send(const ::std::unique_ptr<::std::vector<int32_t>>& goes_in, ::std::vector<double>* goes_in_and_out, ::std::vector<bool>* goes_out, ::std::vector<int32_t>* _aidl_return) override;
+::android::binder::Status Piff(int32_t times) override;
+::android::binder::Status TakesABinder(const ::android::sp<::foo::IFooType>& f, ::android::sp<::foo::IFooType>* _aidl_return) override;
+::android::binder::Status NullableBinder(::android::sp<::foo::IFooType>* _aidl_return) override;
+::android::binder::Status StringListMethod(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* output, ::std::vector<::android::String16>* _aidl_return) override;
+::android::binder::Status BinderListMethod(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* output, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) override;
+::android::binder::Status TakesAFileDescriptor(const ::android::base::unique_fd& f, ::android::base::unique_fd* _aidl_return) override;
+::android::binder::Status TakesAFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& f, ::std::vector<::android::base::unique_fd>* _aidl_return) override;
+};  // class BpComplexTypeInterface
+
+}  // namespace os
+
+}  // namespace android
+
+#endif  // AIDL_GENERATED_ANDROID_OS_BP_COMPLEX_TYPE_INTERFACE_H_
+)";
+
+const char kExpectedComplexTypeClientSourceOutput[] =
+R"(#include <android/os/BpComplexTypeInterface.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+namespace os {
+
+BpComplexTypeInterface::BpComplexTypeInterface(const ::android::sp<::android::IBinder>& _aidl_impl)
+    : BpInterface<IComplexTypeInterface>(_aidl_impl){
+}
+
+::android::binder::Status BpComplexTypeInterface::Send(const ::std::unique_ptr<::std::vector<int32_t>>& goes_in, ::std::vector<double>* goes_in_and_out, ::std::vector<bool>* goes_out, ::std::vector<int32_t>* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeInt32Vector(goes_in);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeDoubleVector(*goes_in_and_out);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeVectorSize(*goes_out);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IComplexTypeInterface::SEND, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readInt32Vector(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_reply.readDoubleVector(goes_in_and_out);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_reply.readBoolVector(goes_out);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpComplexTypeInterface::Piff(int32_t times) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeInt32(times);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IComplexTypeInterface::PIFF, _aidl_data, &_aidl_reply, ::android::IBinder::FLAG_ONEWAY);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpComplexTypeInterface::TakesABinder(const ::android::sp<::foo::IFooType>& f, ::android::sp<::foo::IFooType>* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeStrongBinder(::foo::IFooType::asBinder(f));
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IComplexTypeInterface::TAKESABINDER, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readStrongBinder(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpComplexTypeInterface::NullableBinder(::android::sp<::foo::IFooType>* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IComplexTypeInterface::NULLABLEBINDER, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readNullableStrongBinder(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpComplexTypeInterface::StringListMethod(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* output, ::std::vector<::android::String16>* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeString16Vector(input);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IComplexTypeInterface::STRINGLISTMETHOD, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readString16Vector(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_reply.readString16Vector(output);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpComplexTypeInterface::BinderListMethod(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* output, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeStrongBinderVector(input);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IComplexTypeInterface::BINDERLISTMETHOD, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readStrongBinderVector(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_reply.readStrongBinderVector(output);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpComplexTypeInterface::TakesAFileDescriptor(const ::android::base::unique_fd& f, ::android::base::unique_fd* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeUniqueFileDescriptor(f);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IComplexTypeInterface::TAKESAFILEDESCRIPTOR, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readUniqueFileDescriptor(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpComplexTypeInterface::TakesAFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& f, ::std::vector<::android::base::unique_fd>* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeUniqueFileDescriptorVector(f);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IComplexTypeInterface::TAKESAFILEDESCRIPTORARRAY, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readUniqueFileDescriptorVector(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+}  // namespace os
+
+}  // namespace android
+)";
+
+const char kExpectedComplexTypeServerHeaderOutput[] =
+R"(#ifndef AIDL_GENERATED_ANDROID_OS_BN_COMPLEX_TYPE_INTERFACE_H_
+#define AIDL_GENERATED_ANDROID_OS_BN_COMPLEX_TYPE_INTERFACE_H_
+
+#include <binder/IInterface.h>
+#include <android/os/IComplexTypeInterface.h>
+
+namespace android {
+
+namespace os {
+
+class BnComplexTypeInterface : public ::android::BnInterface<IComplexTypeInterface> {
+public:
+::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags = 0) override;
+};  // class BnComplexTypeInterface
+
+}  // namespace os
+
+}  // namespace android
+
+#endif  // AIDL_GENERATED_ANDROID_OS_BN_COMPLEX_TYPE_INTERFACE_H_
+)";
+
+const char kExpectedComplexTypeServerSourceOutput[] =
+R"(#include <android/os/BnComplexTypeInterface.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+namespace os {
+
+::android::status_t BnComplexTypeInterface::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) {
+::android::status_t _aidl_ret_status = ::android::OK;
+switch (_aidl_code) {
+case Call::SEND:
+{
+::std::unique_ptr<::std::vector<int32_t>> in_goes_in;
+::std::vector<double> in_goes_in_and_out;
+::std::vector<bool> out_goes_out;
+::std::vector<int32_t> _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readInt32Vector(&in_goes_in);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+_aidl_ret_status = _aidl_data.readDoubleVector(&in_goes_in_and_out);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+_aidl_ret_status = _aidl_data.resizeOutVector(&out_goes_out);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(Send(in_goes_in, &in_goes_in_and_out, &out_goes_out, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeInt32Vector(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeDoubleVector(in_goes_in_and_out);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeBoolVector(out_goes_out);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::PIFF:
+{
+int32_t in_times;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readInt32(&in_times);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(Piff(in_times));
+}
+break;
+case Call::TAKESABINDER:
+{
+::android::sp<::foo::IFooType> in_f;
+::android::sp<::foo::IFooType> _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readStrongBinder(&in_f);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(TakesABinder(in_f, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeStrongBinder(::foo::IFooType::asBinder(_aidl_return));
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::NULLABLEBINDER:
+{
+::android::sp<::foo::IFooType> _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+::android::binder::Status _aidl_status(NullableBinder(&_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeStrongBinder(::foo::IFooType::asBinder(_aidl_return));
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::STRINGLISTMETHOD:
+{
+::std::vector<::android::String16> in_input;
+::std::vector<::android::String16> out_output;
+::std::vector<::android::String16> _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readString16Vector(&in_input);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(StringListMethod(in_input, &out_output, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeString16Vector(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeString16Vector(out_output);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::BINDERLISTMETHOD:
+{
+::std::vector<::android::sp<::android::IBinder>> in_input;
+::std::vector<::android::sp<::android::IBinder>> out_output;
+::std::vector<::android::sp<::android::IBinder>> _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readStrongBinderVector(&in_input);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(BinderListMethod(in_input, &out_output, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeStrongBinderVector(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeStrongBinderVector(out_output);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::TAKESAFILEDESCRIPTOR:
+{
+::android::base::unique_fd in_f;
+::android::base::unique_fd _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readUniqueFileDescriptor(&in_f);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(TakesAFileDescriptor(in_f, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeUniqueFileDescriptor(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::TAKESAFILEDESCRIPTORARRAY:
+{
+::std::vector<::android::base::unique_fd> in_f;
+::std::vector<::android::base::unique_fd> _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readUniqueFileDescriptorVector(&in_f);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(TakesAFileDescriptorArray(in_f, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeUniqueFileDescriptorVector(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+default:
+{
+_aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags);
+}
+break;
+}
+if (_aidl_ret_status == ::android::UNEXPECTED_NULL) {
+_aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeToParcel(_aidl_reply);
+}
+return _aidl_ret_status;
+}
+
+}  // namespace os
+
+}  // namespace android
+)";
+
+const char kExpectedComplexTypeInterfaceHeaderOutput[] =
+R"(#ifndef AIDL_GENERATED_ANDROID_OS_I_COMPLEX_TYPE_INTERFACE_H_
+#define AIDL_GENERATED_ANDROID_OS_I_COMPLEX_TYPE_INTERFACE_H_
+
+#include <android-base/unique_fd.h>
+#include <binder/IBinder.h>
+#include <binder/IInterface.h>
+#include <binder/Status.h>
+#include <cstdint>
+#include <foo/IFooType.h>
+#include <memory>
+#include <utils/String16.h>
+#include <utils/StrongPointer.h>
+#include <vector>
+
+namespace android {
+
+namespace os {
+
+class IComplexTypeInterface : public ::android::IInterface {
+public:
+DECLARE_META_INTERFACE(ComplexTypeInterface)
+enum  : int32_t {
+  MY_CONSTANT = 3,
+};
+virtual ::android::binder::Status Send(const ::std::unique_ptr<::std::vector<int32_t>>& goes_in, ::std::vector<double>* goes_in_and_out, ::std::vector<bool>* goes_out, ::std::vector<int32_t>* _aidl_return) = 0;
+virtual ::android::binder::Status Piff(int32_t times) = 0;
+virtual ::android::binder::Status TakesABinder(const ::android::sp<::foo::IFooType>& f, ::android::sp<::foo::IFooType>* _aidl_return) = 0;
+virtual ::android::binder::Status NullableBinder(::android::sp<::foo::IFooType>* _aidl_return) = 0;
+virtual ::android::binder::Status StringListMethod(const ::std::vector<::android::String16>& input, ::std::vector<::android::String16>* output, ::std::vector<::android::String16>* _aidl_return) = 0;
+virtual ::android::binder::Status BinderListMethod(const ::std::vector<::android::sp<::android::IBinder>>& input, ::std::vector<::android::sp<::android::IBinder>>* output, ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) = 0;
+virtual ::android::binder::Status TakesAFileDescriptor(const ::android::base::unique_fd& f, ::android::base::unique_fd* _aidl_return) = 0;
+virtual ::android::binder::Status TakesAFileDescriptorArray(const ::std::vector<::android::base::unique_fd>& f, ::std::vector<::android::base::unique_fd>* _aidl_return) = 0;
+enum Call {
+  SEND = ::android::IBinder::FIRST_CALL_TRANSACTION + 0,
+  PIFF = ::android::IBinder::FIRST_CALL_TRANSACTION + 1,
+  TAKESABINDER = ::android::IBinder::FIRST_CALL_TRANSACTION + 2,
+  NULLABLEBINDER = ::android::IBinder::FIRST_CALL_TRANSACTION + 3,
+  STRINGLISTMETHOD = ::android::IBinder::FIRST_CALL_TRANSACTION + 4,
+  BINDERLISTMETHOD = ::android::IBinder::FIRST_CALL_TRANSACTION + 5,
+  TAKESAFILEDESCRIPTOR = ::android::IBinder::FIRST_CALL_TRANSACTION + 6,
+  TAKESAFILEDESCRIPTORARRAY = ::android::IBinder::FIRST_CALL_TRANSACTION + 7,
+};
+};  // class IComplexTypeInterface
+
+}  // namespace os
+
+}  // namespace android
+
+#endif  // AIDL_GENERATED_ANDROID_OS_I_COMPLEX_TYPE_INTERFACE_H_
+)";
+
+const char kExpectedComplexTypeInterfaceSourceOutput[] =
+R"(#include <android/os/IComplexTypeInterface.h>
+#include <android/os/BpComplexTypeInterface.h>
+
+namespace android {
+
+namespace os {
+
+IMPLEMENT_META_INTERFACE(ComplexTypeInterface, "android.os.IComplexTypeInterface")
+
+}  // namespace os
+
+}  // namespace android
+)";
+
+}  // namespace
+
+class ASTTest : public ::testing::Test {
+ protected:
+  ASTTest(string file_path, string file_contents)
+      : file_path_(file_path),
+        file_contents_(file_contents) {
+    types_.Init();
+  }
+
+  unique_ptr<AidlInterface> Parse() {
+    io_delegate_.SetFileContents(file_path_, file_contents_);
+
+    unique_ptr<AidlInterface> ret;
+    std::vector<std::unique_ptr<AidlImport>> imports;
+    AidlError err = ::android::aidl::internals::load_and_validate_aidl(
+        {},  // no preprocessed files
+        {"."},
+        file_path_,
+        io_delegate_,
+        &types_,
+        &ret,
+        &imports);
+
+    if (err != AidlError::OK)
+      return nullptr;
+
+    return ret;
+  }
+
+  void Compare(Document* doc, const char* expected) {
+    string output;
+    unique_ptr<CodeWriter> cw = GetStringWriter(&output);
+
+    doc->Write(cw.get());
+
+    if (expected == output) {
+      return; // Success
+    }
+
+    test::PrintDiff(expected, output);
+    FAIL() << "Document contents did not match expected contents";
+  }
+
+  const string file_path_;
+  const string file_contents_;
+  FakeIoDelegate io_delegate_;
+  TypeNamespace types_;
+};
+
+class ComplexTypeInterfaceASTTest : public ASTTest {
+ public:
+  ComplexTypeInterfaceASTTest()
+      : ASTTest("android/os/IComplexTypeInterface.aidl",
+                kComplexTypeInterfaceAIDL) {
+    io_delegate_.SetFileContents("foo/IFooType.aidl",
+                                 "package foo; interface IFooType {}");
+  }
+};
+
+TEST_F(ComplexTypeInterfaceASTTest, GeneratesClientHeader) {
+  unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+  unique_ptr<Document> doc = internals::BuildClientHeader(types_, *interface);
+  Compare(doc.get(), kExpectedComplexTypeClientHeaderOutput);
+}
+
+TEST_F(ComplexTypeInterfaceASTTest, GeneratesClientSource) {
+  unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+  unique_ptr<Document> doc = internals::BuildClientSource(types_, *interface);
+  Compare(doc.get(), kExpectedComplexTypeClientSourceOutput);
+}
+
+TEST_F(ComplexTypeInterfaceASTTest, GeneratesServerHeader) {
+  unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+  unique_ptr<Document> doc = internals::BuildServerHeader(types_, *interface);
+  Compare(doc.get(), kExpectedComplexTypeServerHeaderOutput);
+}
+
+TEST_F(ComplexTypeInterfaceASTTest, GeneratesServerSource) {
+  unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+  unique_ptr<Document> doc = internals::BuildServerSource(types_, *interface);
+  Compare(doc.get(), kExpectedComplexTypeServerSourceOutput);
+}
+
+TEST_F(ComplexTypeInterfaceASTTest, GeneratesInterfaceHeader) {
+  unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+  unique_ptr<Document> doc = internals::BuildInterfaceHeader(types_, *interface);
+  Compare(doc.get(), kExpectedComplexTypeInterfaceHeaderOutput);
+}
+
+TEST_F(ComplexTypeInterfaceASTTest, GeneratesInterfaceSource) {
+  unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+  unique_ptr<Document> doc = internals::BuildInterfaceSource(types_, *interface);
+  Compare(doc.get(), kExpectedComplexTypeInterfaceSourceOutput);
+}
+
+namespace test_io_handling {
+
+const char kInputPath[] = "a/IFoo.aidl";
+const char kOutputPath[] = "output.cpp";
+const char kHeaderDir[] = "headers";
+const char kInterfaceHeaderRelPath[] = "a/IFoo.h";
+
+}  // namespace test_io_handling
+
+class IoErrorHandlingTest : public ASTTest {
+ public:
+  IoErrorHandlingTest ()
+      : ASTTest(test_io_handling::kInputPath,
+                "package a; interface IFoo {}"),
+        options_(GetOptions()) {}
+
+  const unique_ptr<CppOptions> options_;
+
+ private:
+  static unique_ptr<CppOptions> GetOptions() {
+    using namespace test_io_handling;
+
+    const int argc = 4;
+    const char* cmdline[argc] = {
+      "aidl-cpp", kInputPath, kHeaderDir, kOutputPath
+    };
+    return CppOptions::Parse(argc, cmdline);
+  }
+};
+
+TEST_F(IoErrorHandlingTest, GenerateCorrectlyAbsentErrors) {
+  // Confirm that this is working correctly without I/O problems.
+  const unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+  ASSERT_TRUE(GenerateCpp(*options_, types_, *interface, io_delegate_));
+}
+
+TEST_F(IoErrorHandlingTest, HandlesBadHeaderWrite) {
+  using namespace test_io_handling;
+  const unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+
+  // Simulate issues closing the interface header.
+  const string header_path =
+      StringPrintf("%s%c%s", kHeaderDir, OS_PATH_SEPARATOR,
+                   kInterfaceHeaderRelPath);
+  io_delegate_.AddBrokenFilePath(header_path);
+  ASSERT_FALSE(GenerateCpp(*options_, types_, *interface, io_delegate_));
+  // We should never attempt to write the C++ file if we fail writing headers.
+  ASSERT_FALSE(io_delegate_.GetWrittenContents(kOutputPath, nullptr));
+  // We should remove partial results.
+  ASSERT_TRUE(io_delegate_.PathWasRemoved(header_path));
+}
+
+TEST_F(IoErrorHandlingTest, HandlesBadCppWrite) {
+  using test_io_handling::kOutputPath;
+  const unique_ptr<AidlInterface> interface = Parse();
+  ASSERT_NE(interface, nullptr);
+
+  // Simulate issues closing the cpp file.
+  io_delegate_.AddBrokenFilePath(kOutputPath);
+  ASSERT_FALSE(GenerateCpp(*options_, types_, *interface, io_delegate_));
+  // We should remove partial results.
+  ASSERT_TRUE(io_delegate_.PathWasRemoved(kOutputPath));
+}
+
+}  // namespace cpp
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/generate_java.cpp b/aidl/generate_java.cpp
new file mode 100644
index 0000000..14df353
--- /dev/null
+++ b/aidl/generate_java.cpp
@@ -0,0 +1,76 @@
+/*
+ * 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.
+ */
+
+#include "generate_java.h"
+
+#include <memory>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <android-base/stringprintf.h>
+
+#include "code_writer.h"
+#include "type_java.h"
+
+using std::unique_ptr;
+using ::android::aidl::java::Variable;
+using std::string;
+using android::base::StringPrintf;
+
+namespace android {
+namespace aidl {
+
+// =================================================
+VariableFactory::VariableFactory(const string& base)
+    : base_(base),
+      index_(0) {
+}
+
+Variable* VariableFactory::Get(const Type* type) {
+  Variable* v = new Variable(
+      type, StringPrintf("%s%d", base_.c_str(), index_));
+  vars_.push_back(v);
+  index_++;
+  return v;
+}
+
+Variable* VariableFactory::Get(int index) {
+  return vars_[index];
+}
+
+namespace java {
+
+int generate_java(const string& filename, const string& originalSrc,
+                  AidlInterface* iface, JavaTypeNamespace* types,
+                  const IoDelegate& io_delegate) {
+  Class* cl = generate_binder_interface_class(iface, types);
+
+  Document* document = new Document(
+      "" /* no comment */,
+      (!iface->GetPackage().empty()) ? iface->GetPackage() : "",
+      originalSrc,
+      unique_ptr<Class>(cl));
+
+  CodeWriterPtr code_writer = io_delegate.GetCodeWriter(filename);
+  document->Write(code_writer.get());
+
+  return 0;
+}
+
+}  // namespace java
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/generate_java.h b/aidl/generate_java.h
new file mode 100644
index 0000000..ed04ba1
--- /dev/null
+++ b/aidl/generate_java.h
@@ -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.
+ */
+
+#ifndef AIDL_GENERATE_JAVA_H_
+#define AIDL_GENERATE_JAVA_H_
+
+#include <string>
+
+#include "aidl_language.h"
+#include "ast_java.h"
+#include "io_delegate.h"
+
+namespace android {
+namespace aidl {
+
+namespace java {
+
+class JavaTypeNamespace;
+
+int generate_java(const std::string& filename, const std::string& originalSrc,
+                  AidlInterface* iface, java::JavaTypeNamespace* types,
+                  const IoDelegate& io_delegate);
+
+android::aidl::java::Class* generate_binder_interface_class(
+    const AidlInterface* iface, java::JavaTypeNamespace* types);
+
+}  // namespace java
+
+class VariableFactory {
+ public:
+  using Variable = ::android::aidl::java::Variable;
+  using Type = ::android::aidl::java::Type;
+
+  explicit VariableFactory(const std::string& base); // base must be short
+  Variable* Get(const Type* type);
+  Variable* Get(int index);
+
+ private:
+  std::vector<Variable*> vars_;
+  std::string base_;
+  int index_;
+
+  DISALLOW_COPY_AND_ASSIGN(VariableFactory);
+};
+
+}  // namespace android
+}  // namespace aidl
+
+#endif // AIDL_GENERATE_JAVA_H_
diff --git a/aidl/generate_java_binder.cpp b/aidl/generate_java_binder.cpp
new file mode 100644
index 0000000..02a6922
--- /dev/null
+++ b/aidl/generate_java_binder.cpp
@@ -0,0 +1,552 @@
+/*
+ * 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.
+ */
+
+#include "generate_java.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <string.h>
+
+#include <android-base/macros.h>
+
+#include "type_java.h"
+
+using std::string;
+
+namespace android {
+namespace aidl {
+namespace java {
+
+// =================================================
+class StubClass : public Class {
+ public:
+  StubClass(const Type* type, const InterfaceType* interfaceType,
+            JavaTypeNamespace* types);
+  virtual ~StubClass() = default;
+
+  Variable* transact_code;
+  Variable* transact_data;
+  Variable* transact_reply;
+  Variable* transact_flags;
+  SwitchStatement* transact_switch;
+
+ private:
+  void make_as_interface(const InterfaceType* interfaceType,
+                         JavaTypeNamespace* types);
+
+  DISALLOW_COPY_AND_ASSIGN(StubClass);
+};
+
+StubClass::StubClass(const Type* type, const InterfaceType* interfaceType,
+                     JavaTypeNamespace* types)
+    : Class() {
+  this->comment = "/** Local-side IPC implementation stub class. */";
+  this->modifiers = PUBLIC | ABSTRACT | STATIC;
+  this->what = Class::CLASS;
+  this->type = type;
+  this->extends = types->BinderNativeType();
+  this->interfaces.push_back(interfaceType);
+
+  // descriptor
+  Field* descriptor =
+      new Field(STATIC | FINAL | PRIVATE,
+                new Variable(types->StringType(), "DESCRIPTOR"));
+  descriptor->value = "\"" + interfaceType->JavaType() + "\"";
+  this->elements.push_back(descriptor);
+
+  // ctor
+  Method* ctor = new Method;
+  ctor->modifiers = PUBLIC;
+  ctor->comment =
+      "/** Construct the stub at attach it to the "
+      "interface. */";
+  ctor->name = "Stub";
+  ctor->statements = new StatementBlock;
+  MethodCall* attach =
+      new MethodCall(THIS_VALUE, "attachInterface", 2, THIS_VALUE,
+                     new LiteralExpression("DESCRIPTOR"));
+  ctor->statements->Add(attach);
+  this->elements.push_back(ctor);
+
+  // asInterface
+  make_as_interface(interfaceType, types);
+
+  // asBinder
+  Method* asBinder = new Method;
+  asBinder->modifiers = PUBLIC | OVERRIDE;
+  asBinder->returnType = types->IBinderType();
+  asBinder->name = "asBinder";
+  asBinder->statements = new StatementBlock;
+  asBinder->statements->Add(new ReturnStatement(THIS_VALUE));
+  this->elements.push_back(asBinder);
+
+  // onTransact
+  this->transact_code = new Variable(types->IntType(), "code");
+  this->transact_data = new Variable(types->ParcelType(), "data");
+  this->transact_reply = new Variable(types->ParcelType(), "reply");
+  this->transact_flags = new Variable(types->IntType(), "flags");
+  Method* onTransact = new Method;
+  onTransact->modifiers = PUBLIC | OVERRIDE;
+  onTransact->returnType = types->BoolType();
+  onTransact->name = "onTransact";
+  onTransact->parameters.push_back(this->transact_code);
+  onTransact->parameters.push_back(this->transact_data);
+  onTransact->parameters.push_back(this->transact_reply);
+  onTransact->parameters.push_back(this->transact_flags);
+  onTransact->statements = new StatementBlock;
+  onTransact->exceptions.push_back(types->RemoteExceptionType());
+  this->elements.push_back(onTransact);
+  this->transact_switch = new SwitchStatement(this->transact_code);
+
+  onTransact->statements->Add(this->transact_switch);
+  MethodCall* superCall = new MethodCall(
+      SUPER_VALUE, "onTransact", 4, this->transact_code, this->transact_data,
+      this->transact_reply, this->transact_flags);
+  onTransact->statements->Add(new ReturnStatement(superCall));
+}
+
+void StubClass::make_as_interface(const InterfaceType* interfaceType,
+                                  JavaTypeNamespace* types) {
+  Variable* obj = new Variable(types->IBinderType(), "obj");
+
+  Method* m = new Method;
+  m->comment = "/**\n * Cast an IBinder object into an ";
+  m->comment += interfaceType->JavaType();
+  m->comment += " interface,\n";
+  m->comment += " * generating a proxy if needed.\n */";
+  m->modifiers = PUBLIC | STATIC;
+  m->returnType = interfaceType;
+  m->name = "asInterface";
+  m->parameters.push_back(obj);
+  m->statements = new StatementBlock;
+
+  IfStatement* ifstatement = new IfStatement();
+  ifstatement->expression = new Comparison(obj, "==", NULL_VALUE);
+  ifstatement->statements = new StatementBlock;
+  ifstatement->statements->Add(new ReturnStatement(NULL_VALUE));
+  m->statements->Add(ifstatement);
+
+  // IInterface iin = obj.queryLocalInterface(DESCRIPTOR)
+  MethodCall* queryLocalInterface = new MethodCall(obj, "queryLocalInterface");
+  queryLocalInterface->arguments.push_back(new LiteralExpression("DESCRIPTOR"));
+  IInterfaceType* iinType = new IInterfaceType(types);
+  Variable* iin = new Variable(iinType, "iin");
+  VariableDeclaration* iinVd =
+      new VariableDeclaration(iin, queryLocalInterface, NULL);
+  m->statements->Add(iinVd);
+
+  // Ensure the instance type of the local object is as expected.
+  // One scenario where this is needed is if another package (with a
+  // different class loader) runs in the same process as the service.
+
+  // if (iin != null && iin instanceof <interfaceType>) return (<interfaceType>)
+  // iin;
+  Comparison* iinNotNull = new Comparison(iin, "!=", NULL_VALUE);
+  Comparison* instOfCheck =
+      new Comparison(iin, " instanceof ",
+                     new LiteralExpression(interfaceType->JavaType()));
+  IfStatement* instOfStatement = new IfStatement();
+  instOfStatement->expression = new Comparison(iinNotNull, "&&", instOfCheck);
+  instOfStatement->statements = new StatementBlock;
+  instOfStatement->statements->Add(
+      new ReturnStatement(new Cast(interfaceType, iin)));
+  m->statements->Add(instOfStatement);
+
+  NewExpression* ne = new NewExpression(interfaceType->GetProxy());
+  ne->arguments.push_back(obj);
+  m->statements->Add(new ReturnStatement(ne));
+
+  this->elements.push_back(m);
+}
+
+// =================================================
+class ProxyClass : public Class {
+ public:
+  ProxyClass(const JavaTypeNamespace* types, const Type* type,
+             const InterfaceType* interfaceType);
+  virtual ~ProxyClass();
+
+  Variable* mRemote;
+  bool mOneWay;
+};
+
+ProxyClass::ProxyClass(const JavaTypeNamespace* types, const Type* type,
+                       const InterfaceType* interfaceType)
+    : Class() {
+  this->modifiers = PRIVATE | STATIC;
+  this->what = Class::CLASS;
+  this->type = type;
+  this->interfaces.push_back(interfaceType);
+
+  mOneWay = interfaceType->OneWay();
+
+  // IBinder mRemote
+  mRemote = new Variable(types->IBinderType(), "mRemote");
+  this->elements.push_back(new Field(PRIVATE, mRemote));
+
+  // Proxy()
+  Variable* remote = new Variable(types->IBinderType(), "remote");
+  Method* ctor = new Method;
+  ctor->name = "Proxy";
+  ctor->statements = new StatementBlock;
+  ctor->parameters.push_back(remote);
+  ctor->statements->Add(new Assignment(mRemote, remote));
+  this->elements.push_back(ctor);
+
+  // IBinder asBinder()
+  Method* asBinder = new Method;
+  asBinder->modifiers = PUBLIC | OVERRIDE;
+  asBinder->returnType = types->IBinderType();
+  asBinder->name = "asBinder";
+  asBinder->statements = new StatementBlock;
+  asBinder->statements->Add(new ReturnStatement(mRemote));
+  this->elements.push_back(asBinder);
+}
+
+ProxyClass::~ProxyClass() {}
+
+// =================================================
+static void generate_new_array(const Type* t, StatementBlock* addTo,
+                               Variable* v, Variable* parcel,
+                               JavaTypeNamespace* types) {
+  Variable* len = new Variable(types->IntType(), v->name + "_length");
+  addTo->Add(new VariableDeclaration(len, new MethodCall(parcel, "readInt")));
+  IfStatement* lencheck = new IfStatement();
+  lencheck->expression = new Comparison(len, "<", new LiteralExpression("0"));
+  lencheck->statements->Add(new Assignment(v, NULL_VALUE));
+  lencheck->elseif = new IfStatement();
+  lencheck->elseif->statements->Add(
+      new Assignment(v, new NewArrayExpression(t, len)));
+  addTo->Add(lencheck);
+}
+
+static void generate_write_to_parcel(const Type* t, StatementBlock* addTo,
+                                     Variable* v, Variable* parcel, int flags) {
+  t->WriteToParcel(addTo, v, parcel, flags);
+}
+
+static void generate_create_from_parcel(const Type* t, StatementBlock* addTo,
+                                        Variable* v, Variable* parcel,
+                                        Variable** cl) {
+  t->CreateFromParcel(addTo, v, parcel, cl);
+}
+
+static void generate_int_constant(const AidlIntConstant& constant,
+                                  Class* interface) {
+  IntConstant* decl = new IntConstant(constant.GetName(), constant.GetValue());
+  interface->elements.push_back(decl);
+}
+
+static void generate_string_constant(const AidlStringConstant& constant,
+                                     Class* interface) {
+  StringConstant* decl = new StringConstant(constant.GetName(),
+                                            constant.GetValue());
+  interface->elements.push_back(decl);
+}
+
+static void generate_method(const AidlMethod& method, Class* interface,
+                            StubClass* stubClass, ProxyClass* proxyClass,
+                            int index, JavaTypeNamespace* types) {
+  int i;
+
+  const bool oneway = proxyClass->mOneWay || method.IsOneway();
+
+  // == the TRANSACT_ constant =============================================
+  string transactCodeName = "TRANSACTION_";
+  transactCodeName += method.GetName();
+
+  char transactCodeValue[60];
+  sprintf(transactCodeValue, "(android.os.IBinder.FIRST_CALL_TRANSACTION + %d)",
+          index);
+
+  Field* transactCode = new Field(
+      STATIC | FINAL, new Variable(types->IntType(), transactCodeName));
+  transactCode->value = transactCodeValue;
+  stubClass->elements.push_back(transactCode);
+
+  // == the declaration in the interface ===================================
+  Method* decl = new Method;
+  decl->comment = method.GetComments();
+  decl->modifiers = PUBLIC;
+  decl->returnType = method.GetType().GetLanguageType<Type>();
+  decl->returnTypeDimension = method.GetType().IsArray() ? 1 : 0;
+  decl->name = method.GetName();
+
+  for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
+    decl->parameters.push_back(
+        new Variable(arg->GetType().GetLanguageType<Type>(), arg->GetName(),
+                     arg->GetType().IsArray() ? 1 : 0));
+  }
+
+  decl->exceptions.push_back(types->RemoteExceptionType());
+
+  interface->elements.push_back(decl);
+
+  // == the stub method ====================================================
+
+  Case* c = new Case(transactCodeName);
+
+  MethodCall* realCall = new MethodCall(THIS_VALUE, method.GetName());
+
+  // interface token validation is the very first thing we do
+  c->statements->Add(new MethodCall(stubClass->transact_data,
+                                    "enforceInterface", 1,
+                                    new LiteralExpression("DESCRIPTOR")));
+
+  // args
+  Variable* cl = NULL;
+  VariableFactory stubArgs("_arg");
+  for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
+    const Type* t = arg->GetType().GetLanguageType<Type>();
+    Variable* v = stubArgs.Get(t);
+    v->dimension = arg->GetType().IsArray() ? 1 : 0;
+
+    c->statements->Add(new VariableDeclaration(v));
+
+    if (arg->GetDirection() & AidlArgument::IN_DIR) {
+      generate_create_from_parcel(t, c->statements, v, stubClass->transact_data,
+                                  &cl);
+    } else {
+      if (!arg->GetType().IsArray()) {
+        c->statements->Add(new Assignment(v, new NewExpression(v->type)));
+      } else {
+        generate_new_array(v->type, c->statements, v, stubClass->transact_data,
+                           types);
+      }
+    }
+
+    realCall->arguments.push_back(v);
+  }
+
+  // the real call
+  Variable* _result = NULL;
+  if (method.GetType().GetName() == "void") {
+    c->statements->Add(realCall);
+
+    if (!oneway) {
+      // report that there were no exceptions
+      MethodCall* ex =
+          new MethodCall(stubClass->transact_reply, "writeNoException", 0);
+      c->statements->Add(ex);
+    }
+  } else {
+    _result =
+        new Variable(decl->returnType, "_result", decl->returnTypeDimension);
+    c->statements->Add(new VariableDeclaration(_result, realCall));
+
+    if (!oneway) {
+      // report that there were no exceptions
+      MethodCall* ex =
+          new MethodCall(stubClass->transact_reply, "writeNoException", 0);
+      c->statements->Add(ex);
+    }
+
+    // marshall the return value
+    generate_write_to_parcel(decl->returnType, c->statements, _result,
+                             stubClass->transact_reply,
+                             Type::PARCELABLE_WRITE_RETURN_VALUE);
+  }
+
+  // out parameters
+  i = 0;
+  for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
+    const Type* t = arg->GetType().GetLanguageType<Type>();
+    Variable* v = stubArgs.Get(i++);
+
+    if (arg->GetDirection() & AidlArgument::OUT_DIR) {
+      generate_write_to_parcel(t, c->statements, v, stubClass->transact_reply,
+                               Type::PARCELABLE_WRITE_RETURN_VALUE);
+    }
+  }
+
+  // return true
+  c->statements->Add(new ReturnStatement(TRUE_VALUE));
+  stubClass->transact_switch->cases.push_back(c);
+
+  // == the proxy method ===================================================
+  Method* proxy = new Method;
+  proxy->comment = method.GetComments();
+  proxy->modifiers = PUBLIC | OVERRIDE;
+  proxy->returnType = method.GetType().GetLanguageType<Type>();
+  proxy->returnTypeDimension = method.GetType().IsArray() ? 1 : 0;
+  proxy->name = method.GetName();
+  proxy->statements = new StatementBlock;
+  for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
+    proxy->parameters.push_back(
+        new Variable(arg->GetType().GetLanguageType<Type>(), arg->GetName(),
+                     arg->GetType().IsArray() ? 1 : 0));
+  }
+  proxy->exceptions.push_back(types->RemoteExceptionType());
+  proxyClass->elements.push_back(proxy);
+
+  // the parcels
+  Variable* _data = new Variable(types->ParcelType(), "_data");
+  proxy->statements->Add(new VariableDeclaration(
+      _data, new MethodCall(types->ParcelType(), "obtain")));
+  Variable* _reply = NULL;
+  if (!oneway) {
+    _reply = new Variable(types->ParcelType(), "_reply");
+    proxy->statements->Add(new VariableDeclaration(
+        _reply, new MethodCall(types->ParcelType(), "obtain")));
+  }
+
+  // the return value
+  _result = NULL;
+  if (method.GetType().GetName() != "void") {
+    _result = new Variable(proxy->returnType, "_result",
+                           method.GetType().IsArray() ? 1 : 0);
+    proxy->statements->Add(new VariableDeclaration(_result));
+  }
+
+  // try and finally
+  TryStatement* tryStatement = new TryStatement();
+  proxy->statements->Add(tryStatement);
+  FinallyStatement* finallyStatement = new FinallyStatement();
+  proxy->statements->Add(finallyStatement);
+
+  // the interface identifier token: the DESCRIPTOR constant, marshalled as a
+  // string
+  tryStatement->statements->Add(new MethodCall(
+      _data, "writeInterfaceToken", 1, new LiteralExpression("DESCRIPTOR")));
+
+  // the parameters
+  for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
+    const Type* t = arg->GetType().GetLanguageType<Type>();
+    Variable* v =
+        new Variable(t, arg->GetName(), arg->GetType().IsArray() ? 1 : 0);
+    AidlArgument::Direction dir = arg->GetDirection();
+    if (dir == AidlArgument::OUT_DIR && arg->GetType().IsArray()) {
+      IfStatement* checklen = new IfStatement();
+      checklen->expression = new Comparison(v, "==", NULL_VALUE);
+      checklen->statements->Add(
+          new MethodCall(_data, "writeInt", 1, new LiteralExpression("-1")));
+      checklen->elseif = new IfStatement();
+      checklen->elseif->statements->Add(
+          new MethodCall(_data, "writeInt", 1, new FieldVariable(v, "length")));
+      tryStatement->statements->Add(checklen);
+    } else if (dir & AidlArgument::IN_DIR) {
+      generate_write_to_parcel(t, tryStatement->statements, v, _data, 0);
+    } else {
+      delete v;
+    }
+  }
+
+  // the transact call
+  MethodCall* call = new MethodCall(
+      proxyClass->mRemote, "transact", 4,
+      new LiteralExpression("Stub." + transactCodeName), _data,
+      _reply ? _reply : NULL_VALUE,
+      new LiteralExpression(oneway ? "android.os.IBinder.FLAG_ONEWAY" : "0"));
+  tryStatement->statements->Add(call);
+
+  // throw back exceptions.
+  if (_reply) {
+    MethodCall* ex = new MethodCall(_reply, "readException", 0);
+    tryStatement->statements->Add(ex);
+  }
+
+  // returning and cleanup
+  if (_reply != NULL) {
+    if (_result != NULL) {
+      generate_create_from_parcel(proxy->returnType, tryStatement->statements,
+                                  _result, _reply, &cl);
+    }
+
+    // the out/inout parameters
+    for (const std::unique_ptr<AidlArgument>& arg : method.GetArguments()) {
+      const Type* t = arg->GetType().GetLanguageType<Type>();
+      if (arg->GetDirection() & AidlArgument::OUT_DIR) {
+        Variable* v =
+            new Variable(t, arg->GetName(), arg->GetType().IsArray() ? 1 : 0);
+        t->ReadFromParcel(tryStatement->statements, v, _reply, &cl);
+      }
+    }
+
+    finallyStatement->statements->Add(new MethodCall(_reply, "recycle"));
+  }
+  finallyStatement->statements->Add(new MethodCall(_data, "recycle"));
+
+  if (_result != NULL) {
+    proxy->statements->Add(new ReturnStatement(_result));
+  }
+}
+
+static void generate_interface_descriptors(StubClass* stub, ProxyClass* proxy,
+                                           const JavaTypeNamespace* types) {
+  // the interface descriptor transaction handler
+  Case* c = new Case("INTERFACE_TRANSACTION");
+  c->statements->Add(new MethodCall(stub->transact_reply, "writeString", 1,
+                                    new LiteralExpression("DESCRIPTOR")));
+  c->statements->Add(new ReturnStatement(TRUE_VALUE));
+  stub->transact_switch->cases.push_back(c);
+
+  // and the proxy-side method returning the descriptor directly
+  Method* getDesc = new Method;
+  getDesc->modifiers = PUBLIC;
+  getDesc->returnType = types->StringType();
+  getDesc->returnTypeDimension = 0;
+  getDesc->name = "getInterfaceDescriptor";
+  getDesc->statements = new StatementBlock;
+  getDesc->statements->Add(
+      new ReturnStatement(new LiteralExpression("DESCRIPTOR")));
+  proxy->elements.push_back(getDesc);
+}
+
+Class* generate_binder_interface_class(const AidlInterface* iface,
+                                       JavaTypeNamespace* types) {
+  const InterfaceType* interfaceType = iface->GetLanguageType<InterfaceType>();
+
+  // the interface class
+  Class* interface = new Class;
+  interface->comment = iface->GetComments();
+  interface->modifiers = PUBLIC;
+  interface->what = Class::INTERFACE;
+  interface->type = interfaceType;
+  interface->interfaces.push_back(types->IInterfaceType());
+
+  // the stub inner class
+  StubClass* stub =
+      new StubClass(interfaceType->GetStub(), interfaceType, types);
+  interface->elements.push_back(stub);
+
+  // the proxy inner class
+  ProxyClass* proxy =
+      new ProxyClass(types, interfaceType->GetProxy(), interfaceType);
+  stub->elements.push_back(proxy);
+
+  // stub and proxy support for getInterfaceDescriptor()
+  generate_interface_descriptors(stub, proxy, types);
+
+  // all the declared constants of the interface
+  for (const auto& item : iface->GetIntConstants()) {
+    generate_int_constant(*item, interface);
+  }
+  for (const auto& item : iface->GetStringConstants()) {
+    generate_string_constant(*item, interface);
+  }
+
+  // all the declared methods of the interface
+  for (const auto& item : iface->GetMethods()) {
+    generate_method(*item, interface, stub, proxy, item->GetId(), types);
+  }
+
+  return interface;
+}
+
+}  // namespace java
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/import_resolver.cpp b/aidl/import_resolver.cpp
new file mode 100644
index 0000000..4957c76
--- /dev/null
+++ b/aidl/import_resolver.cpp
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "import_resolver.h"
+
+#include <unistd.h>
+
+#ifdef _WIN32
+#include <io.h>
+#endif
+
+#include "os.h"
+
+using std::string;
+using std::vector;
+
+namespace android {
+namespace aidl {
+
+ImportResolver::ImportResolver(const IoDelegate& io_delegate,
+                               const vector<string>& import_paths)
+    : io_delegate_(io_delegate) {
+  for (string path : import_paths) {
+    if (path.empty()) {
+      path = ".";
+    }
+    if (path[path.size() - 1] != OS_PATH_SEPARATOR) {
+      path += OS_PATH_SEPARATOR;
+    }
+    import_paths_.push_back(std::move(path));
+  }
+}
+
+
+string ImportResolver::FindImportFile(const string& canonical_name) const {
+  // Convert the canonical name to a relative file path.
+  string relative_path = canonical_name;
+  for (char& c : relative_path) {
+    if (c == '.') {
+      c = OS_PATH_SEPARATOR;
+    }
+  }
+  relative_path += ".aidl";
+
+  // Look for that relative path at each of our import roots.
+  for (string path : import_paths_) {
+    path = path + relative_path;
+    if (io_delegate_.FileIsReadable(path)) {
+      return path;
+    }
+  }
+
+  return "";
+}
+
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/import_resolver.h b/aidl/import_resolver.h
new file mode 100644
index 0000000..e7562fb
--- /dev/null
+++ b/aidl/import_resolver.h
@@ -0,0 +1,50 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_IMPORT_RESOLVER_H_
+#define AIDL_IMPORT_RESOLVER_H_
+
+#include <string>
+#include <vector>
+
+#include <android-base/macros.h>
+
+#include "io_delegate.h"
+
+namespace android {
+namespace aidl {
+
+class ImportResolver {
+ public:
+  ImportResolver(const IoDelegate& io_delegate,
+                 const std::vector<std::string>& import_paths);
+  virtual ~ImportResolver() = default;
+
+  // Resolve the canonical name for a class to a file that exists
+  // in one of the import paths given to the ImportResolver.
+  std::string FindImportFile(const std::string& canonical_name) const;
+
+ private:
+  const IoDelegate& io_delegate_;
+  std::vector<std::string> import_paths_;
+
+  DISALLOW_COPY_AND_ASSIGN(ImportResolver);
+};
+
+}  // namespace android
+}  // namespace aidl
+
+#endif // AIDL_IMPORT_RESOLVER_H_
diff --git a/aidl/io_delegate.cpp b/aidl/io_delegate.cpp
new file mode 100644
index 0000000..62be3f5
--- /dev/null
+++ b/aidl/io_delegate.cpp
@@ -0,0 +1,190 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "io_delegate.h"
+
+#include <cstring>
+#include <fstream>
+#include <vector>
+
+#ifdef _WIN32
+#include <direct.h>
+#else
+#include <sys/stat.h>
+#include <unistd.h>
+#endif
+
+#include <android-base/strings.h>
+
+#include "logging.h"
+#include "os.h"
+
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+using android::base::Split;
+
+namespace android {
+namespace aidl {
+
+bool IoDelegate::GetAbsolutePath(const string& path, string* absolute_path) {
+#ifdef _WIN32
+
+  char buf[4096];
+  DWORD path_len = GetFullPathName(path.c_str(), sizeof(buf), buf, nullptr);
+  if (path_len <= 0 || path_len >= sizeof(buf)) {
+    LOG(ERROR) << "Failed to GetFullPathName(" << path << ")";
+    return false;
+  }
+  *absolute_path = buf;
+
+  return true;
+
+#else
+
+  if (path.empty()) {
+    LOG(ERROR) << "Giving up on finding an absolute path to represent the "
+                  "empty string.";
+    return false;
+  }
+  if (path[0] == OS_PATH_SEPARATOR) {
+    *absolute_path = path;
+    return true;
+  }
+
+  char buf[4096];
+  if (getcwd(buf, sizeof(buf)) == nullptr) {
+    LOG(ERROR) << "Path of current working directory does not fit in "
+               << sizeof(buf) << " bytes";
+    return false;
+  }
+
+  *absolute_path = buf;
+  *absolute_path += OS_PATH_SEPARATOR;
+  *absolute_path += path;
+  return true;
+#endif
+}
+
+unique_ptr<string> IoDelegate::GetFileContents(
+    const string& filename,
+    const string& content_suffix) const {
+  unique_ptr<string> contents;
+  std::ifstream in(filename, std::ios::in | std::ios::binary);
+  if (!in) {
+    return contents;
+  }
+  contents.reset(new string);
+  in.seekg(0, std::ios::end);
+  ssize_t file_size = in.tellg();
+  contents->resize(file_size + content_suffix.length());
+  in.seekg(0, std::ios::beg);
+  // Read the file contents into the beginning of the string
+  in.read(&(*contents)[0], file_size);
+  // Drop the suffix in at the end.
+  contents->replace(file_size, content_suffix.length(), content_suffix);
+  in.close();
+
+  return contents;
+}
+
+unique_ptr<LineReader> IoDelegate::GetLineReader(
+    const string& file_path) const {
+  return LineReader::ReadFromFile(file_path);
+}
+
+bool IoDelegate::FileIsReadable(const string& path) const {
+#ifdef _WIN32
+  // check that the file exists and is not write-only
+  return (0 == _access(path.c_str(), 0)) &&  // mode 0=exist
+         (0 == _access(path.c_str(), 4));    // mode 4=readable
+#else
+  return (0 == access(path.c_str(), R_OK));
+#endif
+}
+
+bool IoDelegate::CreatedNestedDirs(
+    const string& caller_base_dir,
+    const vector<string>& nested_subdirs) const {
+  string base_dir = caller_base_dir;
+  if (base_dir.empty()) {
+    base_dir = ".";
+  }
+  for (const string& subdir : nested_subdirs) {
+    if (base_dir[base_dir.size() - 1] != OS_PATH_SEPARATOR) {
+      base_dir += OS_PATH_SEPARATOR;
+    }
+    base_dir += subdir;
+    bool success;
+#ifdef _WIN32
+    success = _mkdir(base_dir.c_str()) == 0;
+#else
+    success = mkdir(base_dir.c_str(),
+                    S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH) == 0;
+#endif
+    // On darwin when you try to mkdir("/", ...) we get EISDIR.
+    if (!success && (errno != EEXIST && errno != EISDIR)) {
+      LOG(ERROR) << "Error while creating " << base_dir << ": "
+                 << strerror(errno);
+      return false;
+    }
+  }
+  return true;
+}
+
+bool IoDelegate::CreatePathForFile(const string& path) const {
+  if (path.empty()) {
+    return true;
+  }
+
+  string absolute_path;
+  if (!GetAbsolutePath(path, &absolute_path)) {
+    return false;
+  }
+
+  auto directories = Split(absolute_path, string{1u, OS_PATH_SEPARATOR});
+
+  // The "base" directory is just the root of the file system.  On Windows,
+  // this will look like "C:\" but on Unix style file systems we get an empty
+  // string after splitting "/foo" with "/"
+  string base = directories[0];
+  if (base.empty()) {
+    base = "/";
+  }
+  directories.erase(directories.begin());
+
+  // Remove the actual file in question, we're just creating the directory path.
+  directories.pop_back();
+
+  return CreatedNestedDirs(base, directories);
+}
+
+unique_ptr<CodeWriter> IoDelegate::GetCodeWriter(
+    const string& file_path) const {
+  return GetFileWriter(file_path);
+}
+
+void IoDelegate::RemovePath(const std::string& file_path) const {
+#ifdef _WIN32
+  _unlink(file_path.c_str());
+#else
+  unlink(file_path.c_str());
+#endif
+}
+
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/io_delegate.h b/aidl/io_delegate.h
new file mode 100644
index 0000000..dc9a3e3
--- /dev/null
+++ b/aidl/io_delegate.h
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_IO_DELEGATE_H_
+#define AIDL_IO_DELEGATE_H_
+
+#include <android-base/macros.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "code_writer.h"
+#include "line_reader.h"
+
+namespace android {
+namespace aidl {
+
+class IoDelegate {
+ public:
+  IoDelegate() = default;
+  virtual ~IoDelegate() = default;
+
+  // Stores an absolute version of |path| to |*absolute_path|,
+  // possibly prefixing it with the current working directory.
+  // Returns false and does not set |*absolute_path| on error.
+  static bool GetAbsolutePath(const std::string& path,
+                              std::string* absolute_path);
+
+  // Returns a unique_ptr to the contents of |filename|.
+  // Will append the optional |content_suffix| to the returned contents.
+  virtual std::unique_ptr<std::string> GetFileContents(
+      const std::string& filename,
+      const std::string& content_suffix = "") const;
+
+  virtual std::unique_ptr<LineReader> GetLineReader(
+      const std::string& file_path) const;
+
+  virtual bool FileIsReadable(const std::string& path) const;
+
+  virtual bool CreatedNestedDirs(
+      const std::string& base_dir,
+      const std::vector<std::string>& nested_subdirs) const;
+
+  bool CreatePathForFile(const std::string& path) const;
+
+  virtual std::unique_ptr<CodeWriter> GetCodeWriter(
+      const std::string& file_path) const;
+
+  virtual void RemovePath(const std::string& file_path) const;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(IoDelegate);
+};  // class IoDelegate
+
+}  // namespace android
+}  // namespace aidl
+
+#endif // AIDL_IO_DELEGATE_H_
diff --git a/aidl/io_delegate_unittest.cpp b/aidl/io_delegate_unittest.cpp
new file mode 100644
index 0000000..5227d0b
--- /dev/null
+++ b/aidl/io_delegate_unittest.cpp
@@ -0,0 +1,46 @@
+/*
+ * 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.
+ */
+
+#include <string>
+
+#include <gtest/gtest.h>
+
+#include "io_delegate.h"
+
+using std::string;
+
+namespace android {
+namespace aidl {
+
+TEST(IoDelegateTest, CannotGetAbsolutePathFromEmptyString) {
+  string absolute_path;
+  EXPECT_FALSE(IoDelegate::GetAbsolutePath("", &absolute_path));
+  EXPECT_TRUE(absolute_path.empty());
+}
+
+TEST(IoDelegateTest, CurrentlyInfersLinuxAbsolutePath) {
+  string absolute_path;
+  EXPECT_TRUE(IoDelegate::GetAbsolutePath("foo", &absolute_path));
+  ASSERT_FALSE(absolute_path.empty());
+  // Should find our desired file at the end of |absolute_path|
+  // But we don't know the prefix, since it's the current working directory
+  EXPECT_TRUE(absolute_path.rfind("/foo") == absolute_path.length() - 4);
+  // Whatever our current working directory, the path is absolute.
+  EXPECT_EQ(absolute_path[0], '/');
+}
+
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/line_reader.cpp b/aidl/line_reader.cpp
new file mode 100644
index 0000000..0bcaa1d
--- /dev/null
+++ b/aidl/line_reader.cpp
@@ -0,0 +1,91 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "line_reader.h"
+
+#include <fstream>
+#include <sstream>
+
+using std::istringstream;
+using std::ifstream;
+using std::string;
+using std::unique_ptr;
+
+namespace android {
+namespace aidl {
+
+class FileLineReader : public LineReader {
+ public:
+  FileLineReader() = default;
+  virtual ~FileLineReader() {
+    input_stream_.close();
+  }
+
+  bool Init(const std::string& file_path) {
+    input_stream_.open(file_path, ifstream::in | ifstream::binary);
+    return input_stream_.is_open() && input_stream_.good();
+  }
+
+  bool ReadLine(string* line) override {
+    if (!input_stream_.good()) {
+      return false;
+    }
+    line->clear();
+    std::getline(input_stream_, *line);
+    return true;
+  }
+
+ private:
+  ifstream input_stream_;
+
+  DISALLOW_COPY_AND_ASSIGN(FileLineReader);
+};  // class FileLineReader
+
+class MemoryLineReader : public LineReader {
+ public:
+  explicit MemoryLineReader(const string& contents) : input_stream_(contents) {}
+  virtual ~MemoryLineReader() = default;
+
+  bool ReadLine(string* line) override {
+    if (!input_stream_.good()) {
+      return false;
+    }
+    line->clear();
+    std::getline(input_stream_, *line);
+    return true;
+  }
+
+ private:
+  istringstream input_stream_;
+
+  DISALLOW_COPY_AND_ASSIGN(MemoryLineReader);
+};  // class MemoryLineReader
+
+unique_ptr<LineReader> LineReader::ReadFromFile(const string& file_path) {
+  unique_ptr<FileLineReader> file_reader(new FileLineReader());
+  unique_ptr<LineReader> ret;
+  if (file_reader->Init(file_path)) {
+    ret.reset(file_reader.release());
+  }
+  return ret;
+}
+
+unique_ptr<LineReader> LineReader::ReadFromMemory(const string& contents) {
+  return unique_ptr<LineReader>(new MemoryLineReader(contents));
+}
+
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/line_reader.h b/aidl/line_reader.h
new file mode 100644
index 0000000..885327e
--- /dev/null
+++ b/aidl/line_reader.h
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_LINE_READER_H_
+#define AIDL_LINE_READER_H_
+
+#include <memory>
+#include <string>
+
+#include <android-base/macros.h>
+
+namespace android {
+namespace aidl {
+
+class LineReader {
+ public:
+  LineReader() = default;
+  virtual ~LineReader() = default;
+  virtual bool ReadLine(std::string* line) = 0;
+
+  static std::unique_ptr<LineReader> ReadFromFile(
+      const std::string& file_path);
+  static std::unique_ptr<LineReader> ReadFromMemory(
+      const std::string& contents);
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(LineReader);
+};  // class LineReader
+
+}  // namespace android
+}  // namespace aidl
+
+#endif // AIDL_LINE_READER_H_
diff --git a/aidl/logging.h b/aidl/logging.h
new file mode 100644
index 0000000..f76c4e0
--- /dev/null
+++ b/aidl/logging.h
@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_LOGGING_H_
+#define AIDL_LOGGING_H_
+
+// We must include windows.h before android-base/logging.h on Windows.
+#ifdef _WIN32
+#include <windows.h>
+#endif
+
+#include <android-base/logging.h>
+
+#endif // AIDL_LOGGING_H_
diff --git a/aidl/main_cpp.cpp b/aidl/main_cpp.cpp
new file mode 100644
index 0000000..790efdc
--- /dev/null
+++ b/aidl/main_cpp.cpp
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <memory>
+
+#include "aidl.h"
+#include "io_delegate.h"
+#include "logging.h"
+#include "options.h"
+
+using android::aidl::CppOptions;
+
+int main(int argc, char** argv) {
+  android::base::InitLogging(argv);
+  LOG(DEBUG) << "aidl starting";
+
+  std::unique_ptr<CppOptions> options = CppOptions::Parse(argc, argv);
+  if (!options) {
+    return 1;
+  }
+
+  android::aidl::IoDelegate io_delegate;
+  return android::aidl::compile_aidl_to_cpp(*options, io_delegate);
+}
diff --git a/aidl/main_java.cpp b/aidl/main_java.cpp
new file mode 100644
index 0000000..7d32b24
--- /dev/null
+++ b/aidl/main_java.cpp
@@ -0,0 +1,46 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <iostream>
+#include <memory>
+
+#include "aidl.h"
+#include "io_delegate.h"
+#include "logging.h"
+#include "options.h"
+
+using android::aidl::JavaOptions;
+
+int main(int argc, char** argv) {
+  android::base::InitLogging(argv);
+  LOG(DEBUG) << "aidl starting";
+  std::unique_ptr<JavaOptions> options = JavaOptions::Parse(argc, argv);
+  if (!options) {
+    return 1;
+  }
+
+  android::aidl::IoDelegate io_delegate;
+  switch (options->task) {
+    case JavaOptions::COMPILE_AIDL_TO_JAVA:
+      return android::aidl::compile_aidl_to_java(*options, io_delegate);
+    case JavaOptions::PREPROCESS_AIDL:
+      if (android::aidl::preprocess_aidl(*options, io_delegate))
+        return 0;
+      return 1;
+  }
+  std::cerr << "aidl: internal error" << std::endl;
+  return 1;
+}
diff --git a/aidl/options.cpp b/aidl/options.cpp
new file mode 100644
index 0000000..c7cef5c
--- /dev/null
+++ b/aidl/options.cpp
@@ -0,0 +1,267 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "options.h"
+
+#include <cstring>
+#include <iostream>
+#include <stdio.h>
+
+#include "logging.h"
+#include "os.h"
+
+using std::cerr;
+using std::endl;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace {
+
+unique_ptr<JavaOptions> java_usage() {
+  fprintf(stderr,
+          "usage: aidl OPTIONS INPUT [OUTPUT]\n"
+          "       aidl --preprocess OUTPUT INPUT...\n"
+          "\n"
+          "OPTIONS:\n"
+          "   -I<DIR>    search path for import statements.\n"
+          "   -d<FILE>   generate dependency file.\n"
+          "   -a         generate dependency file next to the output file with "
+          "the name based on the input file.\n"
+          "   -p<FILE>   file created by --preprocess to import.\n"
+          "   -o<FOLDER> base output folder for generated files.\n"
+          "   -b         fail when trying to compile a parcelable.\n"
+          "\n"
+          "INPUT:\n"
+          "   An aidl interface file.\n"
+          "\n"
+          "OUTPUT:\n"
+          "   The generated interface files.\n"
+          "   If omitted and the -o option is not used, the input filename is "
+          "used, with the .aidl extension changed to a .java extension.\n"
+          "   If the -o option is used, the generated files will be placed in "
+          "the base output folder, under their package folder\n");
+  return unique_ptr<JavaOptions>(nullptr);
+}
+
+}  // namespace
+
+unique_ptr<JavaOptions> JavaOptions::Parse(int argc, const char* const* argv) {
+  unique_ptr<JavaOptions> options(new JavaOptions());
+  int i = 1;
+
+  if (argc >= 2 && 0 == strcmp(argv[1], "--preprocess")) {
+    if (argc < 4) {
+      return java_usage();
+    }
+    options->output_file_name_ = argv[2];
+    for (int i = 3; i < argc; i++) {
+      options->files_to_preprocess_.push_back(argv[i]);
+    }
+    options->task = PREPROCESS_AIDL;
+    return options;
+  }
+
+  options->task = COMPILE_AIDL_TO_JAVA;
+  // OPTIONS
+  while (i < argc) {
+    const char* s = argv[i];
+    const size_t len = strlen(s);
+    if (s[0] != '-') {
+      break;
+    }
+    if (len <= 1) {
+      fprintf(stderr, "unknown option (%d): %s\n", i, s);
+      return java_usage();
+    }
+    // -I<system-import-path>
+    if (s[1] == 'I') {
+      if (len > 2) {
+        options->import_paths_.push_back(s + 2);
+      } else {
+        fprintf(stderr, "-I option (%d) requires a path.\n", i);
+        return java_usage();
+      }
+    } else if (s[1] == 'd') {
+      if (len > 2) {
+        options->dep_file_name_ = s + 2;
+      } else {
+        fprintf(stderr, "-d option (%d) requires a file.\n", i);
+        return java_usage();
+      }
+    } else if (strcmp(s, "-a") == 0) {
+      options->auto_dep_file_ = true;
+    } else if (s[1] == 'p') {
+      if (len > 2) {
+        options->preprocessed_files_.push_back(s + 2);
+      } else {
+        fprintf(stderr, "-p option (%d) requires a file.\n", i);
+        return java_usage();
+      }
+    } else if (s[1] == 'o') {
+      if (len > 2) {
+        options->output_base_folder_= s + 2;
+      } else {
+        fprintf(stderr, "-o option (%d) requires a path.\n", i);
+        return java_usage();
+      }
+    } else if (strcmp(s, "-b") == 0) {
+      options->fail_on_parcelable_ = true;
+    } else {
+      // s[1] is not known
+      fprintf(stderr, "unknown option (%d): %s\n", i, s);
+      return java_usage();
+    }
+    i++;
+  }
+  // INPUT
+  if (i < argc) {
+    options->input_file_name_ = argv[i];
+    i++;
+  } else {
+    fprintf(stderr, "INPUT required\n");
+    return java_usage();
+  }
+  if (!EndsWith(options->input_file_name_, ".aidl")) {
+    cerr << "Expected .aidl file for input but got "
+         << options->input_file_name_ << endl;
+    return java_usage();
+  }
+
+  // OUTPUT
+  if (i < argc) {
+    options->output_file_name_ = argv[i];
+    i++;
+  } else if (options->output_base_folder_.empty()) {
+    // copy input into output and change the extension from .aidl to .java
+    options->output_file_name_= options->input_file_name_;
+    if (!ReplaceSuffix(".aidl", ".java", &options->output_file_name_)) {
+      // we should never get here since we validated the suffix.
+      LOG(FATAL) << "Internal aidl error.";
+      return java_usage();
+    }
+  }
+
+  // anything remaining?
+  if (i != argc) {
+    fprintf(stderr, "unknown option%s:",
+            (i == argc - 1 ? (const char*)"" : (const char*)"s"));
+    for (; i < argc - 1; i++) {
+      fprintf(stderr, " %s", argv[i]);
+    }
+    fprintf(stderr, "\n");
+    return java_usage();
+  }
+
+  return options;
+}
+
+string JavaOptions::DependencyFilePath() const {
+  if (auto_dep_file_) {
+    return output_file_name_ + ".d";
+  }
+  return dep_file_name_;
+}
+
+namespace {
+
+unique_ptr<CppOptions> cpp_usage() {
+  cerr << "usage: aidl-cpp INPUT_FILE HEADER_DIR OUTPUT_FILE" << endl
+       << endl
+       << "OPTIONS:" << endl
+       << "   -I<DIR>   search path for import statements" << endl
+       << "   -d<FILE>  generate dependency file" << endl
+       << endl
+       << "INPUT_FILE:" << endl
+       << "   an aidl interface file" << endl
+       << "HEADER_DIR:" << endl
+       << "   empty directory to put generated headers" << endl
+       << "OUTPUT_FILE:" << endl
+       << "   path to write generated .cpp code" << endl;
+  return unique_ptr<CppOptions>(nullptr);
+}
+
+}  // namespace
+
+unique_ptr<CppOptions> CppOptions::Parse(int argc, const char* const* argv) {
+  unique_ptr<CppOptions> options(new CppOptions());
+  int i = 1;
+
+  // Parse flags, all of which start with '-'
+  for ( ; i < argc; ++i) {
+    const size_t len = strlen(argv[i]);
+    const char *s = argv[i];
+    if (s[0] != '-') {
+      break;  // On to the positional arguments.
+    }
+    if (len < 2) {
+      cerr << "Invalid argument '" << s << "'." << endl;
+      return cpp_usage();
+    }
+    const string the_rest = s + 2;
+    if (s[1] == 'I') {
+      options->import_paths_.push_back(the_rest);
+    } else if (s[1] == 'd') {
+      options->dep_file_name_ = the_rest;
+    } else {
+      cerr << "Invalid argument '" << s << "'." << endl;
+      return cpp_usage();
+    }
+  }
+
+  // There are exactly three positional arguments.
+  const int remaining_args = argc - i;
+  if (remaining_args != 3) {
+    cerr << "Expected 3 positional arguments but got " << remaining_args << "." << endl;
+    return cpp_usage();
+  }
+
+  options->input_file_name_ = argv[i];
+  options->output_header_dir_ = argv[i + 1];
+  options->output_file_name_ = argv[i + 2];
+
+  if (!EndsWith(options->input_file_name_, ".aidl")) {
+    cerr << "Expected .aidl file for input but got " << options->input_file_name_ << endl;
+    return cpp_usage();
+  }
+
+  return options;
+}
+
+bool EndsWith(const string& str, const string& suffix) {
+  if (str.length() < suffix.length()) {
+    return false;
+  }
+  return std::equal(str.crbegin(), str.crbegin() + suffix.length(),
+                    suffix.crbegin());
+}
+
+bool ReplaceSuffix(const string& old_suffix,
+                   const string& new_suffix,
+                   string* str) {
+  if (!EndsWith(*str, old_suffix)) return false;
+  str->replace(str->length() - old_suffix.length(),
+               old_suffix.length(),
+               new_suffix);
+  return true;
+}
+
+
+
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/options.h b/aidl/options.h
new file mode 100644
index 0000000..6f32c62
--- /dev/null
+++ b/aidl/options.h
@@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_OPTIONS_H_
+#define AIDL_OPTIONS_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <android-base/macros.h>
+#include <gtest/gtest_prod.h>
+
+namespace android {
+namespace aidl {
+
+// This object represents the parsed options to the Java generating aidl.
+class JavaOptions final {
+ public:
+  enum {
+      COMPILE_AIDL_TO_JAVA,
+      PREPROCESS_AIDL,
+  };
+
+  ~JavaOptions() = default;
+
+  // Parses the command line and returns a non-null pointer to an JavaOptions
+  // object on success.
+  // Prints the usage statement on failure.
+  static std::unique_ptr<JavaOptions> Parse(int argc, const char* const* argv);
+
+  std::string DependencyFilePath() const;
+
+  int task{COMPILE_AIDL_TO_JAVA};
+  bool fail_on_parcelable_{false};
+  std::vector<std::string> import_paths_;
+  std::vector<std::string> preprocessed_files_;
+  std::string input_file_name_;
+  std::string output_file_name_;
+  std::string output_base_folder_;
+  std::string dep_file_name_;
+  bool auto_dep_file_{false};
+  std::vector<std::string> files_to_preprocess_;
+
+ private:
+  JavaOptions() = default;
+
+  FRIEND_TEST(EndToEndTest, IExampleInterface);
+  FRIEND_TEST(AidlTest, FailOnParcelable);
+  FRIEND_TEST(AidlTest, WritePreprocessedFile);
+  FRIEND_TEST(AidlTest, WritesCorrectDependencyFile);
+  FRIEND_TEST(AidlTest, WritesTrivialDependencyFileForParcelable);
+
+  DISALLOW_COPY_AND_ASSIGN(JavaOptions);
+};
+
+class CppOptions final {
+ public:
+
+  ~CppOptions() = default;
+
+  // Parses the command line and returns a non-null pointer to an CppOptions
+  // object on success.
+  // Prints the usage statement on failure.
+  static std::unique_ptr<CppOptions> Parse(int argc, const char* const* argv);
+
+  std::string InputFileName() const { return input_file_name_; }
+  std::string OutputHeaderDir() const { return output_header_dir_; }
+  std::string OutputCppFilePath() const { return output_file_name_; }
+
+  std::vector<std::string> ImportPaths() const { return import_paths_; }
+  std::string DependencyFilePath() const { return dep_file_name_; }
+
+ private:
+  CppOptions() = default;
+
+  std::string input_file_name_;
+  std::vector<std::string> import_paths_;
+  std::string output_header_dir_;
+  std::string output_file_name_;
+  std::string dep_file_name_;
+
+  FRIEND_TEST(CppOptionsTests, ParsesCompileCpp);
+  DISALLOW_COPY_AND_ASSIGN(CppOptions);
+};
+
+bool EndsWith(const std::string& str, const std::string& suffix);
+bool ReplaceSuffix(const std::string& old_suffix,
+                   const std::string& new_suffix,
+                   std::string* str);
+
+}  // namespace android
+}  // namespace aidl
+
+#endif // AIDL_OPTIONS_H_
diff --git a/aidl/options_unittest.cpp b/aidl/options_unittest.cpp
new file mode 100644
index 0000000..568765b
--- /dev/null
+++ b/aidl/options_unittest.cpp
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+#include "options.h"
+
+using std::cerr;
+using std::endl;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace {
+
+const char kPreprocessCommandOutputFile[] = "output_file_name";
+const char kPreprocessCommandInput1[] = "input1";
+const char kPreprocessCommandInput2[] = "input2";
+const char kPreprocessCommandInput3[] = "input3";
+const char* kPreprocessCommand[] = {
+    "aidl", "--preprocess",
+    kPreprocessCommandOutputFile,
+    kPreprocessCommandInput1,
+    kPreprocessCommandInput2,
+    kPreprocessCommandInput3,
+    nullptr,
+};
+
+const char kCompileCommandInput[] = "directory/ITool.aidl";
+const char kCompileCommandIncludePath[] = "-Iinclude_path";
+const char* kCompileJavaCommand[] = {
+    "aidl",
+    "-b",
+    kCompileCommandIncludePath,
+    kCompileCommandInput,
+    nullptr,
+};
+const char kCompileCommandJavaOutput[] = "directory/ITool.java";
+
+const char kCompileDepFile[] = "-doutput.deps";
+const char kCompileCommandHeaderDir[] = "output/dir";
+const char kCompileCommandCppOutput[] = "some/file.cpp";
+const char* kCompileCppCommand[] = {
+    "aidl-cpp",
+    kCompileCommandIncludePath,
+    kCompileDepFile,
+    kCompileCommandInput,
+    kCompileCommandHeaderDir,
+    kCompileCommandCppOutput,
+    nullptr,
+};
+
+template <typename T>
+unique_ptr<T> GetOptions(const char* command[]) {
+  int argc = 0;
+  const char** command_part = command;
+  for (; *command_part; ++argc, ++command_part) {}
+  unique_ptr<T> options(T::Parse(argc, command));
+  if (!options) {
+    cerr << "Failed to parse command line:";
+    for (int i = 0; i < argc; ++i) {
+      cerr << " " << command[i];
+      cerr << endl;
+    }
+  }
+  EXPECT_NE(options, nullptr) << "Failed to parse options!";
+  return options;
+}
+
+}  // namespace
+
+TEST(JavaOptionsTests, ParsesPreprocess) {
+  unique_ptr<JavaOptions> options = GetOptions<JavaOptions>(kPreprocessCommand);
+  EXPECT_EQ(JavaOptions::PREPROCESS_AIDL, options->task);
+  EXPECT_EQ(false, options->fail_on_parcelable_);
+  EXPECT_EQ(0u, options->import_paths_.size());
+  EXPECT_EQ(0u, options->preprocessed_files_.size());
+  EXPECT_EQ(string{}, options->input_file_name_);
+  EXPECT_EQ(string{kPreprocessCommandOutputFile}, options->output_file_name_);
+  EXPECT_EQ(false, options->auto_dep_file_);
+  const vector<string> expected_input{kPreprocessCommandInput1,
+                                      kPreprocessCommandInput2,
+                                      kPreprocessCommandInput3};
+  EXPECT_EQ(expected_input, options->files_to_preprocess_);
+}
+
+TEST(JavaOptionsTests, ParsesCompileJava) {
+  unique_ptr<JavaOptions> options =
+      GetOptions<JavaOptions>(kCompileJavaCommand);
+  EXPECT_EQ(JavaOptions::COMPILE_AIDL_TO_JAVA, options->task);
+  EXPECT_EQ(true, options->fail_on_parcelable_);
+  EXPECT_EQ(1u, options->import_paths_.size());
+  EXPECT_EQ(0u, options->preprocessed_files_.size());
+  EXPECT_EQ(string{kCompileCommandInput}, options->input_file_name_);
+  EXPECT_EQ(string{kCompileCommandJavaOutput}, options->output_file_name_);
+  EXPECT_EQ(false, options->auto_dep_file_);
+}
+
+TEST(CppOptionsTests, ParsesCompileCpp) {
+  unique_ptr<CppOptions> options = GetOptions<CppOptions>(kCompileCppCommand);
+  ASSERT_EQ(1u, options->import_paths_.size());
+  EXPECT_EQ(string{kCompileCommandIncludePath}.substr(2),
+            options->import_paths_[0]);
+  EXPECT_EQ(string{kCompileDepFile}.substr(2), options->dep_file_name_);
+  EXPECT_EQ(kCompileCommandInput, options->InputFileName());
+  EXPECT_EQ(kCompileCommandHeaderDir, options->OutputHeaderDir());
+  EXPECT_EQ(kCompileCommandCppOutput, options->OutputCppFilePath());
+}
+
+TEST(OptionsTests, EndsWith) {
+  EXPECT_TRUE(EndsWith("foo", ""));
+  EXPECT_TRUE(EndsWith("foo", "o"));
+  EXPECT_TRUE(EndsWith("foo", "foo"));
+  EXPECT_FALSE(EndsWith("foo", "fooo"));
+  EXPECT_FALSE(EndsWith("", "o"));
+  EXPECT_TRUE(EndsWith("", ""));
+}
+
+TEST(OptionsTests, ReplaceSuffix) {
+  struct test_case_t {
+    const char* input;
+    const char* old_suffix;
+    const char* new_suffix;
+    const char* result;
+  };
+  const size_t kNumCases = 3;
+  test_case_t kTestInput[kNumCases] = {
+    {"foo.bar", "bar", "foo", "foo.foo"},
+    {"whole", "whole", "new", "new"},
+    {"", "", "", ""},
+  };
+  for (const auto& test_case : kTestInput) {
+    string mutated = test_case.input;
+    EXPECT_TRUE(ReplaceSuffix(test_case.old_suffix,
+                              test_case.new_suffix,
+                              &mutated));
+    EXPECT_EQ(mutated, test_case.result);
+  }
+}
+
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/os.h b/aidl/os.h
new file mode 100644
index 0000000..752ed47
--- /dev/null
+++ b/aidl/os.h
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2015, 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.
+ */
+
+#ifndef AIDL_OS_H_
+#define AIDL_OS_H_
+
+#if defined(_WIN32)
+#define OS_PATH_SEPARATOR '\\'
+#else
+#define OS_PATH_SEPARATOR '/'
+#endif
+
+#endif  // AIDL_OS_H_
diff --git a/aidl/runtests.sh b/aidl/runtests.sh
new file mode 100755
index 0000000..05809f9
--- /dev/null
+++ b/aidl/runtests.sh
@@ -0,0 +1,41 @@
+#!/usr/bin/env bash
+
+# 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.
+
+if [ -z $ANDROID_BUILD_TOP ]; then
+  echo "You need to source and lunch before you can use this script"
+  exit 1
+fi
+
+echo "Running tests"
+set -e # fail early
+
+# NOTE We can't actually run these commands, since they rely on functions added
+#      by build/envsetup.sh to the bash shell environment.
+echo "+ mmma -j32 $ANDROID_BUILD_TOP/system/tools/aidl"
+make -j32 -C $ANDROID_BUILD_TOP -f build/core/main.mk \
+    MODULES-IN-system-tools-aidl
+
+set -x # print commands
+
+${ANDROID_HOST_OUT}/nativetest64/aidl_unittests/aidl_unittests
+
+adb root
+adb wait-for-device
+adb remount
+adb sync
+adb install -r \
+    ${ANDROID_PRODUCT_OUT}/system/app/aidl_test_services/aidl_test_services.apk
+${ANDROID_BUILD_TOP}/system/tools/aidl/tests/integration-test.py
diff --git a/aidl/tests/aidl_test_client.cpp b/aidl/tests/aidl_test_client.cpp
new file mode 100644
index 0000000..84c8183
--- /dev/null
+++ b/aidl/tests/aidl_test_client.cpp
@@ -0,0 +1,108 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include <iostream>
+
+#include <android-base/logging.h>
+#include <binder/IServiceManager.h>
+#include <utils/String16.h>
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/ITestService.h"
+
+#include "aidl_test_client_file_descriptors.h"
+#include "aidl_test_client_nullables.h"
+#include "aidl_test_client_parcelables.h"
+#include "aidl_test_client_primitives.h"
+#include "aidl_test_client_service_exceptions.h"
+#include "aidl_test_client_utf8_strings.h"
+
+// libutils:
+using android::OK;
+using android::sp;
+using android::status_t;
+using android::String16;
+
+// libbinder:
+using android::getService;
+
+// generated
+using android::aidl::tests::ITestService;
+
+using std::cerr;
+using std::cout;
+using std::endl;
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+const char kServiceName[] = "android.aidl.tests.ITestService";
+
+bool GetService(sp<ITestService>* service) {
+  cout << "Retrieving test service binder" << endl;
+  status_t status = getService(String16(kServiceName), service);
+  if (status != OK) {
+    cerr << "Failed to get service binder: '" << kServiceName
+         << "' status=" << status << endl;
+    return false;
+  }
+  return true;
+}
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
+
+/* Runs all the test cases in aidl_test_client_*.cpp files. */
+int main(int /* argc */, char * argv []) {
+  android::base::InitLogging(argv, android::base::StderrLogger);
+  sp<ITestService> service;
+  namespace client_tests = android::aidl::tests::client;
+
+
+  if (!client_tests::GetService(&service)) return 1;
+
+  if (!client_tests::ConfirmPrimitiveRepeat(service)) return 1;
+
+  if (!client_tests::ConfirmReverseArrays(service)) return 1;
+
+  if (!client_tests::ConfirmReverseLists(service)) return 1;
+
+  if (!client_tests::ConfirmReverseBinderLists(service)) return 1;
+
+  if (!client_tests::ConfirmSimpleParcelables(service)) return 1;
+
+  if (!client_tests::ConfirmPersistableBundles(service)) return 1;
+
+  if (!client_tests::ConfirmFileDescriptors(service)) return 1;
+
+  if (!client_tests::ConfirmFileDescriptorArrays(service)) return 1;
+
+  if (!client_tests::ConfirmServiceSpecificExceptions(service)) return 1;
+
+  if (!client_tests::ConfirmNullables(service)) return 1;
+
+  if (!client_tests::ConfirmUtf8InCppStringRepeat(service)) return 1;
+
+  if (!client_tests::ConfirmUtf8InCppStringArrayReverse(service)) return 1;
+
+  if (!client_tests::ConfirmUtf8InCppStringListReverse(service)) return 1;
+
+  return 0;
+}
diff --git a/aidl/tests/aidl_test_client_file_descriptors.cpp b/aidl/tests/aidl_test_client_file_descriptors.cpp
new file mode 100644
index 0000000..b5913a3
--- /dev/null
+++ b/aidl/tests/aidl_test_client_file_descriptors.cpp
@@ -0,0 +1,171 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include "aidl_test_client_file_descriptors.h"
+
+#include <iostream>
+#include <vector>
+
+ #include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+#include <android-base/unique_fd.h>
+
+// libbase
+using android::base::unique_fd;
+
+// libutils:
+using android::sp;
+
+// libbinder:
+using android::binder::Status;
+
+// generated
+using android::aidl::tests::ITestService;
+
+using std::cerr;
+using std::cout;
+using std::endl;
+using std::string;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+#define FdByName(_fd) #_fd, _fd
+
+bool DoWrite(const string& name, const unique_fd& fd, const string& buf) {
+  int wrote;
+
+  while ((wrote = write(fd.get(), buf.data(), buf.size())) < 0 && errno == EINTR);
+
+  if (wrote == (signed)buf.size()) {
+    return true;
+  }
+
+  if (wrote < 0) {
+    cerr << "Error writing to file descriptor '" << name << "': "
+        << strerror(errno) << endl;
+  } else {
+    cerr << "File descriptor '" << name << "'accepted short data." << endl;
+  }
+
+  return false;
+}
+
+bool DoRead(const string& name, const unique_fd& fd, const string& expected) {
+  size_t length = expected.size();
+  int got;
+  string buf;
+  buf.resize(length);
+
+  while ((got = read(fd.get(), &buf[0], length)) < 0 && errno == EINTR);
+
+  if (got < 0) {
+    cerr << "Error reading from '" << name << "': " << strerror(errno) << endl;
+    return false;
+  }
+
+  if (buf != expected) {
+    cerr << "Expected '" << expected << "' got '" << buf << "'" << endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool DoPipe(unique_fd* read_side, unique_fd* write_side) {
+  int fds[2];
+  unique_fd return_fd;
+
+  if (pipe(fds)) {
+    cout << "Error creating pipes: " << strerror(errno) << endl;
+    return false;
+  }
+
+  read_side->reset(fds[0]);
+  write_side->reset(fds[1]);
+  return true;
+}
+
+bool ConfirmFileDescriptors(const sp<ITestService>& s) {
+  Status status;
+  cout << "Confirming passing and returning file descriptors works." << endl;
+
+  unique_fd return_fd;
+  unique_fd read_fd;
+  unique_fd write_fd;
+
+  if (!DoPipe(&read_fd, &write_fd)) {
+    return false;
+  }
+
+  status = s->RepeatFileDescriptor(write_fd, &return_fd);
+
+  if (!status.isOk()) {
+    cerr << "Could not repeat file descriptors." << endl;
+    return false;
+  }
+
+  /* A note on some of the spookier stuff going on here: IIUC writes to pipes
+   * should be atomic and non-blocking so long as the total size doesn't exceed
+   * PIPE_BUF. We thus play a bit fast and loose with failure modes here.
+   */
+
+  bool ret =
+      DoWrite(FdByName(return_fd), "ReturnString") &&
+      DoRead(FdByName(read_fd), "ReturnString");
+
+  return ret;
+}
+
+bool ConfirmFileDescriptorArrays(const sp<ITestService>& s) {
+  Status status;
+  cout << "Confirming passing and returning file descriptor arrays works." << endl;
+
+  vector<unique_fd> array;
+  array.resize(2);
+
+  if (!DoPipe(&array[0], &array[1])) {
+    return false;
+  }
+
+  vector<unique_fd> repeated;
+  vector<unique_fd> reversed;
+
+  status = s->ReverseFileDescriptorArray(array, &repeated, &reversed);
+
+  if (!status.isOk()) {
+    cerr << "Could not reverse file descriptor array." << endl;
+    return false;
+  }
+
+  bool ret =
+      DoWrite(FdByName(array[1]), "First") &&
+      DoWrite(FdByName(repeated[1]), "Second") &&
+      DoWrite(FdByName(reversed[0]), "Third") &&
+      DoRead(FdByName(reversed[1]), "FirstSecondThird");
+
+  return ret;
+}
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/aidl_test_client_file_descriptors.h b/aidl/tests/aidl_test_client_file_descriptors.h
new file mode 100644
index 0000000..306e551
--- /dev/null
+++ b/aidl/tests/aidl_test_client_file_descriptors.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef ANDROID_AIDL_TESTS_CLIENT_FILE_DESCRIPTORS_H
+#define ANDROID_AIDL_TESTS_CLIENT_FILE_DESCRIPTORS_H
+
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/ITestService.h"
+
+// Tests for passing and returning file descriptors.
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmFileDescriptors(const sp<ITestService>& s);
+bool ConfirmFileDescriptorArrays(const sp<ITestService>& s);
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
+
+#endif  // ANDROID_AIDL_TESTS_CLIENT_FILE_DESCRIPTORS_H
diff --git a/aidl/tests/aidl_test_client_nullables.cpp b/aidl/tests/aidl_test_client_nullables.cpp
new file mode 100644
index 0000000..805827c
--- /dev/null
+++ b/aidl/tests/aidl_test_client_nullables.cpp
@@ -0,0 +1,280 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include "aidl_test_client_nullables.h"
+
+#include <utils/String16.h>
+
+#include <iostream>
+#include <memory>
+#include <string>
+#include <vector>
+
+// libutils:
+using android::sp;
+using android::String16;
+
+// libbinder:
+using android::binder::Status;
+
+// generated
+using android::aidl::tests::ITestService;
+using android::aidl::tests::SimpleParcelable;
+
+using std::string;
+using std::unique_ptr;
+using std::vector;
+using std::cout;
+using std::cerr;
+using std::endl;
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+namespace {
+template<typename T>
+bool ValuesEqual(const unique_ptr<T>& in, const unique_ptr<T>& out) {
+  return *in == *out;
+}
+
+template<>
+bool ValuesEqual<vector<unique_ptr<String16>>>(
+    const unique_ptr<vector<unique_ptr<String16>>>& in,
+    const unique_ptr<vector<unique_ptr<String16>>>& out) {
+  if (!in) {
+    return !out;
+  }
+
+  if (!out) {
+    return false;
+  }
+
+  if (in->size() != out->size()) {
+    return false;
+  }
+
+  for (size_t i = 0; i < in->size(); i++) {
+    const unique_ptr<String16>& a = (*in)[i];
+    const unique_ptr<String16>& b = (*out)[i];
+
+    if (!(a || b)) {
+      continue;
+    }
+
+    if (!(a && b)) {
+      return false;
+    }
+
+    if (*a != *b) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+template<typename T>
+bool ConfirmNullableType(const sp<ITestService>& s, const string& type_name,
+                         unique_ptr<T> in,
+                         Status(ITestService::*func)(const unique_ptr<T>&,
+                                                     unique_ptr<T>*)) {
+  cout << "... Confirming nullables for " << type_name << " ..." << endl;
+  Status status;
+  unique_ptr<T> out;
+
+  status = (*s.*func)(in, &out);
+
+  if (!status.isOk()) {
+    cerr << "Could not repeat nullable " << type_name << "." << endl;
+    return false;
+  }
+
+  if (!out) {
+    cerr << "Got back null when repeating " << type_name << "." << endl;
+    return false;
+  }
+
+  if (!ValuesEqual(in, out)) {
+    cerr << "Got back a non-matching value when repeating " << type_name
+         << "." << endl;
+    return false;
+  }
+
+  in.reset();
+  status = (*s.*func)(in, &out);
+
+  if (!status.isOk()) {
+    cerr << "Could not repeat null as " << type_name << "." << endl;
+    return false;
+  }
+
+  if (out) {
+    cerr << "Got back a value when sent null for " << type_name << "."
+         << endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool CheckAppropriateIBinderHandling(const sp<ITestService>& s) {
+
+  Status status;
+  sp<IBinder> binder = new BBinder();
+  sp<IBinder> null_binder = nullptr;
+  unique_ptr<vector<sp<IBinder>>> list_with_nulls(
+      new vector<sp<IBinder>>{binder, null_binder});
+  unique_ptr<vector<sp<IBinder>>> list_without_nulls(
+      new vector<sp<IBinder>>{binder, binder});
+
+  // Methods without @nullable throw up when given null binders
+  if (s->TakesAnIBinder(null_binder).exceptionCode() !=
+      binder::Status::EX_NULL_POINTER) {
+    cerr << "Did not receive expected null exception on line: "
+         << __LINE__ << endl;
+    return false;
+  }
+  if (s->TakesAnIBinderList(*list_with_nulls).exceptionCode() !=
+      binder::Status::EX_NULL_POINTER) {
+    cerr << "Did not receive expected null exception on line: "
+         << __LINE__ << endl;
+    return false;
+  }
+
+  // But those same methods are fine with valid binders
+  if (!s->TakesAnIBinder(binder).isOk()) {
+    cerr << "Received unexpected exception on line "
+         << __LINE__ << endl;
+    return false;
+  }
+  if (!s->TakesAnIBinderList(*list_without_nulls).isOk()) {
+    cerr << "Received unexpected exception on line "
+         << __LINE__ << endl;
+    return false;
+  }
+
+  // And methods with @nullable don't care.
+  if (!s->TakesANullableIBinder(null_binder).isOk()) {
+    cerr << "Received unexpected exception on line "
+         << __LINE__ << endl;
+    return false;
+  }
+  if (!s->TakesANullableIBinder(binder).isOk()) {
+    cerr << "Received unexpected exception on line "
+         << __LINE__ << endl;
+    return false;
+  }
+  if (!s->TakesANullableIBinderList(list_with_nulls).isOk()) {
+    cerr << "Received unexpected exception on line "
+         << __LINE__ << endl;
+    return false;
+  }
+  if (!s->TakesANullableIBinderList(list_without_nulls).isOk()) {
+    cerr << "Received unexpected exception on line "
+         << __LINE__ << endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool CheckAppropriateIInterfaceHandling(const sp<ITestService>& s) {
+
+  sp<INamedCallback> callback;
+  if (!s->GetCallback(false, &callback).isOk()) {
+    cerr << "Received unexpected exception on line "
+         << __LINE__ << endl;
+    return false;
+  }
+  if (callback.get() == nullptr) {
+    cerr << "Expected to receive a non-null binder on line: "
+         << __LINE__ << endl;
+    return false;
+  }
+  if (!s->GetCallback(true, &callback).isOk()) {
+    cerr << "Received unexpected exception on line "
+         << __LINE__ << endl;
+    return false;
+  }
+  if (callback.get() != nullptr) {
+    cerr << "Expected to receive a null binder on line: "
+         << __LINE__ << endl;
+    return false;
+  }
+  return true;
+}
+
+}  // namespace
+
+bool ConfirmNullables(const sp<ITestService>& s) {
+  Status status;
+  cout << "Confirming passing and returning nullable values works." << endl;
+
+  if (!ConfirmNullableType(s, "integer array",
+                           unique_ptr<vector<int32_t>>(
+                               new vector<int32_t>({1,2,3})),
+                           &ITestService::RepeatNullableIntArray)) {
+    return false;
+  }
+
+  if (!ConfirmNullableType(s, "string",
+                           unique_ptr<String16>(new String16("Blooob")),
+                           &ITestService::RepeatNullableString)) {
+    return false;
+  }
+
+  unique_ptr<vector<unique_ptr<String16>>> test_string_array(
+      new vector<unique_ptr<String16>>());
+  test_string_array->push_back(unique_ptr<String16>(new String16("Wat")));
+  test_string_array->push_back(unique_ptr<String16>(
+      new String16("Blooob")));
+  test_string_array->push_back(unique_ptr<String16>(new String16("Wat")));
+  test_string_array->push_back(unique_ptr<String16>(nullptr));
+  test_string_array->push_back(unique_ptr<String16>(new String16("YEAH")));
+  test_string_array->push_back(unique_ptr<String16>(
+      new String16("OKAAAAY")));
+
+  if (!ConfirmNullableType(s, "string array", std::move(test_string_array),
+                           &ITestService::RepeatNullableStringList)) {
+    return false;
+  }
+
+  if (!ConfirmNullableType(s, "parcelable",
+                           unique_ptr<SimpleParcelable>(
+                               new SimpleParcelable("Booya", 42)),
+                           &ITestService::RepeatNullableParcelable)) {
+    return false;
+  }
+
+  if (!CheckAppropriateIBinderHandling(s)) {
+    cerr << "Handled null IBinders poorly." << endl;
+    return false;
+  }
+
+  if (!CheckAppropriateIInterfaceHandling(s)) {
+    cerr << "Handled nullable IInterface instances poorly." << endl;
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/aidl_test_client_nullables.h b/aidl/tests/aidl_test_client_nullables.h
new file mode 100644
index 0000000..807aa4e
--- /dev/null
+++ b/aidl/tests/aidl_test_client_nullables.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef ANDROID_AIDL_TESTS_CLIENT_NULLABLES_H
+#define ANDROID_AIDL_TESTS_CLIENT_NULLABLES_H
+
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/ITestService.h"
+
+// Tests for passing and returning file descriptors.
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmNullables(const sp<ITestService>& s);
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
+
+#endif  // ANDROID_AIDL_TESTS_CLIENT_NULLABLES_H
diff --git a/aidl/tests/aidl_test_client_parcelables.cpp b/aidl/tests/aidl_test_client_parcelables.cpp
new file mode 100644
index 0000000..09e7f0a
--- /dev/null
+++ b/aidl/tests/aidl_test_client_parcelables.cpp
@@ -0,0 +1,151 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include "aidl_test_client_parcelables.h"
+
+#include <iostream>
+#include <vector>
+
+// libutils:
+using android::sp;
+
+// libbinder:
+using android::binder::Status;
+
+// generated
+using android::aidl::tests::ITestService;
+using android::aidl::tests::SimpleParcelable;
+using android::os::PersistableBundle;
+
+using std::cout;
+using std::endl;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmSimpleParcelables(const sp<ITestService>& s) {
+  cout << "Confirming passing and returning SimpleParcelable objects works."
+       << endl;
+
+  SimpleParcelable input("Booya", 42);
+  SimpleParcelable out_param, returned;
+  Status status = s->RepeatSimpleParcelable(input, &out_param, &returned);
+  if (!status.isOk()) {
+    cout << "Binder call failed." << endl;
+    return false;
+  }
+  if (input != out_param || input != returned) {
+    cout << "Failed to repeat SimpleParcelable objects." << endl;
+    return false;
+  }
+
+  cout << "Attempting to reverse an array of SimpleParcelable objects." << endl;
+  const vector<SimpleParcelable> original{SimpleParcelable("first", 0),
+                                          SimpleParcelable("second", 1),
+                                          SimpleParcelable("third", 2)};
+  vector<SimpleParcelable> repeated;
+  vector<SimpleParcelable> reversed;
+  status = s->ReverseSimpleParcelables(original, &repeated, &reversed);
+  if (!status.isOk()) {
+    cout << "Binder call failed." << endl;
+    return false;
+  }
+  std::reverse(reversed.begin(), reversed.end());
+  if (repeated != original || reversed != original) {
+    cout << "Failed to reverse an array of SimpleParcelable objects." << endl;
+    return false;
+  }
+
+  return true;
+}
+
+bool ConfirmPersistableBundles(const sp<ITestService>& s) {
+  cout << "Confirming passing and returning PersistableBundle objects works."
+       << endl;
+
+  PersistableBundle empty_bundle, returned;
+  Status status = s->RepeatPersistableBundle(empty_bundle, &returned);
+  if (!status.isOk()) {
+    cout << "Binder call failed for empty PersistableBundle." << endl;
+    return false;
+  }
+  if (empty_bundle != returned) {
+    cout << "Failed to repeat empty PersistableBundle." << endl;
+    return false;
+  }
+
+  PersistableBundle non_empty_bundle;
+  non_empty_bundle.putBoolean(String16("test_bool"), false);
+  non_empty_bundle.putInt(String16("test_int"), 33);
+  non_empty_bundle.putLong(String16("test_long"), 34359738368l);
+  non_empty_bundle.putDouble(String16("test_double"), 1.1);
+  non_empty_bundle.putString(String16("test_string"), String16("Woot!"));
+  non_empty_bundle.putBooleanVector(String16("test_bool_vector"),
+                                    {true, false, true});
+  non_empty_bundle.putIntVector(String16("test_int_vector"), {33, 44, 55, 142});
+  non_empty_bundle.putLongVector(String16("test_long_vector"),
+                                 {34l, 8371l, 34359738375l});
+  non_empty_bundle.putDoubleVector(String16("test_double_vector"), {2.2, 5.4});
+  non_empty_bundle.putStringVector(String16("test_string_vector"),
+                                   {String16("hello"), String16("world!")});
+  PersistableBundle nested_bundle;
+  nested_bundle.putInt(String16("test_nested_int"), 345);
+  non_empty_bundle.putPersistableBundle(String16("test_persistable_bundle"),
+                                        nested_bundle);
+
+  status = s->RepeatPersistableBundle(non_empty_bundle, &returned);
+  if (!status.isOk()) {
+    cout << "Binder call failed. " << endl;
+    return false;
+  }
+  if (non_empty_bundle != returned) {
+    cout << "Failed to repeat PersistableBundle object." << endl;
+    return false;
+  }
+
+  cout << "Attempting to reverse an array of PersistableBundle objects."
+       << endl;
+  PersistableBundle first;
+  PersistableBundle second;
+  PersistableBundle third;
+  first.putInt(String16("test_int"), 1231);
+  second.putLong(String16("test_long"), 222222l);
+  third.putDouble(String16("test_double"), 10.8);
+  const vector<PersistableBundle> original{first, second, third};
+
+  vector<PersistableBundle> repeated;
+  vector<PersistableBundle> reversed;
+  status = s->ReversePersistableBundles(original, &repeated, &reversed);
+  if (!status.isOk()) {
+    cout << "Binder call failed." << endl;
+    return false;
+  }
+  std::reverse(reversed.begin(), reversed.end());
+  if (repeated != original || reversed != original) {
+    cout << "Failed to reverse an array of PersistableBundle objects." << endl;
+    return false;
+  }
+
+  return true;
+}
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/aidl_test_client_parcelables.h b/aidl/tests/aidl_test_client_parcelables.h
new file mode 100644
index 0000000..9616e02
--- /dev/null
+++ b/aidl/tests/aidl_test_client_parcelables.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef ANDROID_AIDL_TESTS_CLIENT_PARCELABLES_H
+#define ANDROID_AIDL_TESTS_CLIENT_PARCELABLES_H
+
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/ITestService.h"
+
+// Tests for passing and returning parcelable types.
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmSimpleParcelables(const sp<ITestService>& s);
+bool ConfirmPersistableBundles(const sp<ITestService>& s);
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
+
+#endif  // ANDROID_AIDL_TESTS_CLIENT_PARCELABLES_H
diff --git a/aidl/tests/aidl_test_client_primitives.cpp b/aidl/tests/aidl_test_client_primitives.cpp
new file mode 100644
index 0000000..6f70f43
--- /dev/null
+++ b/aidl/tests/aidl_test_client_primitives.cpp
@@ -0,0 +1,231 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include "aidl_test_client_primitives.h"
+
+#include <iostream>
+#include <vector>
+
+#include <utils/String16.h>
+#include <utils/String8.h>
+
+#include "android/aidl/tests/INamedCallback.h"
+
+#include "test_helpers.h"
+
+// libutils:
+using android::sp;
+using android::String16;
+using android::String8;
+
+// libbinder:
+using android::binder::Status;
+
+// generated
+using android::aidl::tests::ITestService;
+using android::aidl::tests::INamedCallback;
+
+using std::cerr;
+using std::cout;
+using std::endl;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmPrimitiveRepeat(const sp<ITestService>& s) {
+  cout << "Confirming passing and returning primitives works." << endl;
+
+  if (!RepeatPrimitive(s, &ITestService::RepeatBoolean, true) ||
+      !RepeatPrimitive(s, &ITestService::RepeatByte, int8_t{-128}) ||
+      !RepeatPrimitive(s, &ITestService::RepeatChar, char16_t{'A'}) ||
+      !RepeatPrimitive(s, &ITestService::RepeatInt, int32_t{1 << 30}) ||
+      !RepeatPrimitive(s, &ITestService::RepeatLong, int64_t{1ll << 60}) ||
+      !RepeatPrimitive(s, &ITestService::RepeatFloat, float{1.0f/3.0f}) ||
+      !RepeatPrimitive(s, &ITestService::RepeatDouble, double{1.0/3.0}) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT)  ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT2) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT3) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT4) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT5) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT6) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT7) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT8) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT9) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT10) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT11) ||
+      !RepeatPrimitive(
+          s, &ITestService::RepeatInt, ITestService::TEST_CONSTANT12)
+      ) {
+    return false;
+  }
+
+  vector<String16> inputs = {
+      String16("Deliver us from evil."),
+      String16(),
+      String16("\0\0", 2),
+      // This is actually two unicode code points:
+      //   U+10437: The 'small letter yee' character in the deseret alphabet
+      //   U+20AC: A euro sign
+      String16("\xD8\x01\xDC\x37\x20\xAC"),
+      ITestService::STRING_TEST_CONSTANT(),
+      ITestService::STRING_TEST_CONSTANT2(),
+  };
+  for (const auto& input : inputs) {
+    String16 reply;
+    Status status = s->RepeatString(input, &reply);
+    if (!status.isOk() || input != reply) {
+      cerr << "Failed while requesting service to repeat String16=\""
+           << String8(input).string()
+           << "\". Got status=" << status.toString8() << endl;
+      return false;
+    }
+  }
+  return true;
+}
+
+bool ConfirmReverseArrays(const sp<ITestService>& s) {
+  cout << "Confirming passing and returning arrays works." << endl;
+
+  if (!ReverseArray(s, &ITestService::ReverseBoolean,
+                    {true, false, false}) ||
+      !ReverseArray(s, &ITestService::ReverseByte,
+                    {uint8_t{255}, uint8_t{0}, uint8_t{127}}) ||
+      !ReverseArray(s, &ITestService::ReverseChar,
+                    {char16_t{'A'}, char16_t{'B'}, char16_t{'C'}}) ||
+      !ReverseArray(s, &ITestService::ReverseInt,
+                    {1, 2, 3}) ||
+      !ReverseArray(s, &ITestService::ReverseLong,
+                    {-1ll, 0ll, int64_t{1ll << 60}}) ||
+      !ReverseArray(s, &ITestService::ReverseFloat,
+                    {-0.3f, -0.7f, 8.0f}) ||
+      !ReverseArray(s, &ITestService::ReverseDouble,
+                    {1.0/3.0, 1.0/7.0, 42.0}) ||
+      !ReverseArray(s, &ITestService::ReverseString,
+                    {String16{"f"}, String16{"a"}, String16{"b"}})) {
+    return false;
+  }
+
+  return true;
+}
+
+bool ConfirmReverseLists(const sp<ITestService>& s) {
+  cout << "Confirming passing and returning List<T> works." << endl;
+
+  if (!ReverseArray(s, &ITestService::ReverseStringList,
+                    {String16{"f"}, String16{"a"}, String16{"b"}})) {
+    return false;
+  }
+
+  return true;
+}
+
+bool ConfirmReverseBinderLists(const sp<ITestService>& s) {
+  Status status;
+  cout << "Confirming passing and returning List<T> works with binders." << endl;
+
+  vector<String16> names = {
+    String16{"Larry"},
+    String16{"Curly"},
+    String16{"Moe"}
+  };
+
+  vector<sp<IBinder>> input;
+
+  for (int i = 0; i < 3; i++) {
+    sp<INamedCallback> got;
+
+    status = s->GetOtherTestService(names[i], &got);
+    if (!status.isOk()) {
+      cerr << "Could not retrieve service for test." << endl;
+      return false;
+    }
+
+    input.push_back(INamedCallback::asBinder(got));
+  }
+
+  vector<sp<IBinder>> output;
+  vector<sp<IBinder>> reversed;
+
+  status = s->ReverseNamedCallbackList(input, &output, &reversed);
+  if (!status.isOk()) {
+    cerr << "Failed to reverse named callback list." << endl;
+  }
+
+  if (output.size() != 3) {
+    cerr << "ReverseNamedCallbackList gave repetition with wrong length." << endl;
+    return false;
+  }
+
+  if (reversed.size() != 3) {
+    cerr << "ReverseNamedCallbackList gave reversal with wrong length." << endl;
+    return false;
+  }
+
+  for (int i = 0; i < 3; i++) {
+    String16 ret;
+    sp<INamedCallback> named_callback =
+        android::interface_cast<INamedCallback>(output[i]);
+    status = named_callback->GetName(&ret);
+
+    if (!status.isOk()) {
+      cerr << "Could not query INamedCallback from output" << endl;
+      return false;
+    }
+
+    if (ret != names[i]) {
+      cerr << "Output had wrong INamedCallback" << endl;
+      return false;
+    }
+  }
+
+  for (int i = 0; i < 3; i++) {
+    String16 ret;
+    sp<INamedCallback> named_callback =
+        android::interface_cast<INamedCallback>(reversed[i]);
+    status = named_callback->GetName(&ret);
+
+    if (!status.isOk()) {
+      cerr << "Could not query INamedCallback from reversed output" << endl;
+      return false;
+    }
+
+    if (ret != names[2 - i]) {
+      cerr << "Reversed output had wrong INamedCallback" << endl;
+      return false;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/aidl_test_client_primitives.h b/aidl/tests/aidl_test_client_primitives.h
new file mode 100644
index 0000000..f9b39da
--- /dev/null
+++ b/aidl/tests/aidl_test_client_primitives.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef ANDROID_AIDL_TESTS_CLIENT_PRIMITIVES_H
+#define ANDROID_AIDL_TESTS_CLIENT_PRIMITIVES_H
+
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/ITestService.h"
+
+// Tests for passing and returning primitive types defined in the AIDL docs.
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmPrimitiveRepeat(const sp<ITestService>& s);
+bool ConfirmReverseArrays(const android::sp<ITestService>& s);
+bool ConfirmReverseLists(const android::sp<ITestService>& s);
+bool ConfirmReverseBinderLists(const android::sp<ITestService>& s);
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
+
+#endif  // ANDROID_AIDL_TESTS_CLIENT_PRIMITIVES_H
diff --git a/aidl/tests/aidl_test_client_service_exceptions.cpp b/aidl/tests/aidl_test_client_service_exceptions.cpp
new file mode 100644
index 0000000..3f1f374
--- /dev/null
+++ b/aidl/tests/aidl_test_client_service_exceptions.cpp
@@ -0,0 +1,49 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include "aidl_test_client_service_exceptions.h"
+
+#include <iostream>
+
+#include "binder/Status.h"
+
+using android::binder::Status;
+using std::cout;
+using std::endl;
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmServiceSpecificExceptions(const sp<ITestService>& s) {
+  cout << "Confirming application exceptions work" << endl;
+
+  for (int32_t i = -1; i < 2; ++i) {
+    Status status = s->ThrowServiceException(i);
+    if (status.exceptionCode() != Status::EX_SERVICE_SPECIFIC ||
+        status.serviceSpecificErrorCode() != i) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/aidl_test_client_service_exceptions.h b/aidl/tests/aidl_test_client_service_exceptions.h
new file mode 100644
index 0000000..e4a1dd3
--- /dev/null
+++ b/aidl/tests/aidl_test_client_service_exceptions.h
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef ANDROID_AIDL_TESTS_CLIENT_SERVICE_EXCEPTIONS_H
+#define ANDROID_AIDL_TESTS_CLIENT_SERVICE_EXCEPTIONS_H
+
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/ITestService.h"
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+// Tests for service specific exception support.
+bool ConfirmServiceSpecificExceptions(const sp<ITestService>& s);
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
+
+#endif  // ANDROID_AIDL_TESTS_CLIENT_SERVICE_EXCEPTIONS_H
diff --git a/aidl/tests/aidl_test_client_utf8_strings.cpp b/aidl/tests/aidl_test_client_utf8_strings.cpp
new file mode 100644
index 0000000..216aef7
--- /dev/null
+++ b/aidl/tests/aidl_test_client_utf8_strings.cpp
@@ -0,0 +1,167 @@
+/*
+ * 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.
+ */
+
+#include "aidl_test_client_utf8_strings.h"
+
+#include <android-base/logging.h>
+#include <binder/Status.h>
+#include <utils/StrongPointer.h>
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "android/aidl/tests/ITestService.h"
+#include "test_helpers.h"
+
+// libutils:
+using android::sp;
+
+// libbinder:
+using android::binder::Status;
+
+// generated
+using android::aidl::tests::ITestService;
+
+using std::unique_ptr;
+using std::string;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmUtf8InCppStringRepeat(const sp<ITestService>& s) {
+  const vector<string> utf8_inputs = {
+    string("Deliver us from evil."),
+    string(),
+    string("\0\0", 2),
+    // Similarly, the utf8 encodings of the small letter yee and euro sign.
+    string("\xF0\x90\x90\xB7\xE2\x82\xAC"),
+  };
+  LOG(INFO) << "Confirming repeating utf8 strings works.";
+
+  for (const auto& input : utf8_inputs) {
+    string reply;
+    Status status = s->RepeatUtf8CppString(input, &reply);
+    if (!status.isOk() || input != reply) {
+      LOG(ERROR) << "Failed while requesting service to repeat utf8 string=\""
+                 << input
+                 << "\". Got status=" << status.toString8()
+                 << " and output=" << reply;
+      return false;
+    }
+  }
+
+  unique_ptr<string> ret;
+  Status repeat_null_status = s->RepeatNullableUtf8CppString(nullptr, &ret);
+  if (!repeat_null_status.isOk() || ret) {
+    LOG(ERROR) << "RepeatNullableUtf8CppString(null) did not return null";
+    return false;
+  }
+
+  for (const auto& input : utf8_inputs) {
+    unique_ptr<string> reply;
+    Status status = s->RepeatNullableUtf8CppString(
+        unique_ptr<string>(new string(input)), &reply);
+    if (!status.isOk()) {
+      LOG(ERROR) << "Got status=" << status.toString8() << " while repeating "
+                    "nullable utf8 string " << input;
+      return false;
+    }
+    if (!reply) {
+      LOG(ERROR) << "Got null reply while repeating nullable utf8 string "
+                 << input;
+      return false;
+    }
+    if (input != *reply) {
+      LOG(ERROR) << "Failed while requesting service to repeat utf8 string=\""
+                 << input
+                 << "\". Got status=" << status.toString8()
+                 << " and output=" << *reply;
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool ConfirmUtf8InCppStringArrayReverse(const sp<ITestService>& s) {
+  LOG(INFO) << "Confirming passing and returning utf8 string arrays works.";
+  if (!ReverseArray(s, &ITestService::ReverseUtf8CppString,
+                    {string{"a"}, string{}, string{"\xc3\xb8"}})) {
+    return false;
+  }
+
+  return true;
+}
+
+bool ConfirmUtf8InCppStringListReverse(const sp<ITestService>& s) {
+  LOG(INFO) << "Confirming reversing a list of utf8 strings works";
+  unique_ptr<vector<unique_ptr<string>>> input, reversed, repeated;
+  Status status = s->ReverseUtf8CppStringList(input, &reversed, &repeated);
+  if (!status.isOk() || reversed || repeated) {
+    LOG(ERROR) << "Reversing null list of utf8 strings failed.";
+    return false;
+  }
+
+  input.reset(new vector<unique_ptr<string>>);
+  input->emplace_back(new string("Deliver us from evil."));
+  input->emplace_back(nullptr);
+  input->emplace_back(new string("\xF0\x90\x90\xB7\xE2\x82\xAC"));
+
+  status = s->ReverseUtf8CppStringList(input, &repeated, &reversed);
+  if (!status.isOk() || !reversed || !repeated) {
+    LOG(ERROR) << "Reversing list of utf8 strings failed.";
+    return false;
+  }
+  if (reversed->size() != input->size() || repeated->size() != input->size()) {
+    LOG(ERROR) << "Bad output sizes.";
+    return false;
+  }
+
+  for (size_t i = 0; i < input->size(); ++i) {
+    const string* input_str = (*input)[i].get();
+    const string* repeated_str = (*repeated)[i].get();
+    const string* reversed_str = (*reversed)[(reversed->size() - 1) - i].get();
+    if (!input_str) {
+      if(repeated_str || reversed_str) {
+        LOG(ERROR) << "Expected null values, but got non-null.";
+        return false;
+      }
+      // 3 nullptrs to strings.  No need to compare values.
+      continue;
+    }
+    if (!repeated_str || !reversed_str) {
+      LOG(ERROR) << "Expected non-null values, but got null.";
+      return false;
+    }
+    if (*input_str != *repeated_str || *input_str != *reversed_str) {
+      LOG(ERROR) << "Expected '" << *input_str << "' but got "
+                 << "repeated='" << *repeated_str << "' and "
+                 << "reversed='" << *reversed_str;
+      return false;
+    }
+  }
+  return true;
+}
+
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/aidl_test_client_utf8_strings.h b/aidl/tests/aidl_test_client_utf8_strings.h
new file mode 100644
index 0000000..a362fd5
--- /dev/null
+++ b/aidl/tests/aidl_test_client_utf8_strings.h
@@ -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.
+ */
+
+#ifndef ANDROID_AIDL_TESTS_CLIENT_UTF8_STRINGS_H
+#define ANDROID_AIDL_TESTS_CLIENT_UTF8_STRINGS_H
+
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/ITestService.h"
+
+// Tests for passing and returning utf8 strings.
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+bool ConfirmUtf8InCppStringRepeat(
+    const android::sp<android::aidl::tests::ITestService>& s);
+bool ConfirmUtf8InCppStringArrayReverse(
+    const android::sp<android::aidl::tests::ITestService>& s);
+bool ConfirmUtf8InCppStringListReverse(
+    const android::sp<android::aidl::tests::ITestService>& s);
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
+
+#endif  // ANDROID_AIDL_TESTS_CLIENT_UTF8_STRINGS_H
+
diff --git a/aidl/tests/aidl_test_sentinel_searcher.cpp b/aidl/tests/aidl_test_sentinel_searcher.cpp
new file mode 100644
index 0000000..e260366
--- /dev/null
+++ b/aidl/tests/aidl_test_sentinel_searcher.cpp
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include <fstream>
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <errno.h>
+#include <time.h>
+#include <unistd.h>
+
+using std::cerr;
+using std::cout;
+using std::endl;
+using std::getline;
+using std::ifstream;
+using std::string;
+using std::vector;
+
+namespace {
+
+bool ReadLines(const string& input_file_path, vector<string>* lines) {
+  ifstream watched_file(input_file_path);
+  if (!watched_file.is_open()) {
+    cerr << "Unable to open input file: " << input_file_path << endl;
+    return false;
+  }
+
+  string line;
+  while (getline(watched_file, line)) {
+    lines->push_back(line);
+  }
+  watched_file.close();
+  return true;
+}
+
+bool HasSentinel(const vector<string>& lines, const string& sentinel) {
+  for (const auto& line : lines) {
+    if (line.find(sentinel) != string::npos) {
+      return true;
+    }
+  }
+  return false;
+}
+
+}  // namespace
+
+int main(int argc, const char* argv[]) {
+  if (argc != 5) {
+    cerr << "Invalid usage." << endl;
+    cerr << argv[0]
+         << " <timeout in seconds>"
+         << " <input file path>"
+         << " <success sentinel>"
+         << " <failure sentinel>" << endl;
+    return -EINVAL;
+  }
+  const string timeout_as_str = argv[1];
+  const string input_file_path = argv[2];
+  const string success_sentinel = argv[3];
+  const string failure_sentinel = argv[4];
+
+  const int timeout_seconds = atoi(timeout_as_str.c_str());
+  if (timeout_seconds <= 0) {
+    cerr << "Invalid timeout value (in seconds): " << timeout_as_str << endl;
+    return -EINVAL;
+  }
+
+  int exit_code = 1;
+  const time_t start_time = time(nullptr);
+  vector<string> lines;
+  while (true) {
+    sleep(1);
+    if (time(nullptr) - start_time > timeout_seconds) {
+      cerr << "Timed out waiting for success/failure sentinel." << endl;
+      break;
+    }
+    // Ignore errors when reading lines.  The file may not immediately exist
+    // because it takes the Java process some time to create it.
+    lines.clear();
+    ReadLines(input_file_path, &lines);
+
+    if (HasSentinel(lines, success_sentinel)) {
+      exit_code = 0;
+      break;
+    }
+    if (HasSentinel(lines, failure_sentinel)) {
+      break;
+    }
+  }
+
+  cout << "Found output:" << endl;
+  for (const auto& line : lines) {
+    cout << "  " << line << endl;
+  }
+  return exit_code;
+}
diff --git a/aidl/tests/aidl_test_service.cpp b/aidl/tests/aidl_test_service.cpp
new file mode 100644
index 0000000..9e2304e
--- /dev/null
+++ b/aidl/tests/aidl_test_service.cpp
@@ -0,0 +1,459 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include <unistd.h>
+
+#include <android-base/unique_fd.h>
+#include <binder/IInterface.h>
+#include <binder/IPCThreadState.h>
+#include <binder/IServiceManager.h>
+#include <binder/ProcessState.h>
+#include <binder/Status.h>
+#include <utils/Errors.h>
+#include <utils/Log.h>
+#include <utils/Looper.h>
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/BnTestService.h"
+#include "android/aidl/tests/ITestService.h"
+
+#include "android/aidl/tests/BnNamedCallback.h"
+#include "android/aidl/tests/INamedCallback.h"
+
+// Used implicitly.
+#undef LOG_TAG
+#define LOG_TAG "aidl_native_service"
+
+// libbase
+using android::base::unique_fd;
+
+// libutils:
+using android::Looper;
+using android::LooperCallback;
+using android::OK;
+using android::sp;
+using android::String16;
+
+// libbinder:
+using android::BnInterface;
+using android::defaultServiceManager;
+using android::IInterface;
+using android::IPCThreadState;
+using android::Parcel;
+using android::ProcessState;
+using android::binder::Status;
+
+// Generated code:
+using android::aidl::tests::BnNamedCallback;
+using android::aidl::tests::BnTestService;
+using android::aidl::tests::INamedCallback;
+using android::aidl::tests::SimpleParcelable;
+using android::os::PersistableBundle;
+
+// Standard library
+using std::map;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace {
+
+class BinderCallback : public LooperCallback {
+ public:
+  BinderCallback() {}
+  ~BinderCallback() override {}
+
+  int handleEvent(int /* fd */, int /* events */, void* /* data */) override {
+    IPCThreadState::self()->handlePolledCommands();
+    return 1;  // Continue receiving callbacks.
+  }
+};
+
+class NamedCallback : public BnNamedCallback {
+ public:
+  explicit NamedCallback(String16 name) : name_(name) {}
+
+  Status GetName(String16* ret) {
+    *ret = name_;
+    return Status::ok();
+  }
+
+ private:
+  String16 name_;
+};
+
+class NativeService : public BnTestService {
+ public:
+  NativeService() {}
+  virtual ~NativeService() = default;
+
+  void LogRepeatedStringToken(const String16& token) {
+    ALOGI("Repeating '%s' of length=%zu", android::String8(token).string(),
+          token.size());
+  }
+
+  template <typename T>
+  void LogRepeatedToken(const T& token) {
+    std::ostringstream token_str;
+    token_str << token;
+    ALOGI("Repeating token %s", token_str.str().c_str());
+  }
+
+  Status RepeatBoolean(bool token, bool* _aidl_return) override {
+    LogRepeatedToken(token ? 1 : 0);
+    *_aidl_return = token;
+    return Status::ok();
+  }
+  Status RepeatByte(int8_t token, int8_t* _aidl_return) override {
+    LogRepeatedToken(token);
+    *_aidl_return = token;
+    return Status::ok();
+  }
+  Status RepeatChar(char16_t token, char16_t* _aidl_return) override {
+    LogRepeatedStringToken(String16(&token, 1));
+    *_aidl_return = token;
+    return Status::ok();
+  }
+  Status RepeatInt(int32_t token, int32_t* _aidl_return) override {
+    LogRepeatedToken(token);
+    *_aidl_return = token;
+    return Status::ok();
+  }
+  Status RepeatLong(int64_t token, int64_t* _aidl_return) override {
+    LogRepeatedToken(token);
+    *_aidl_return = token;
+    return Status::ok();
+  }
+  Status RepeatFloat(float token, float* _aidl_return) override {
+    LogRepeatedToken(token);
+    *_aidl_return = token;
+    return Status::ok();
+  }
+  Status RepeatDouble(double token, double* _aidl_return) override {
+    LogRepeatedToken(token);
+    *_aidl_return = token;
+    return Status::ok();
+  }
+  Status RepeatString(const String16& token, String16* _aidl_return) override {
+    LogRepeatedStringToken(token);
+    *_aidl_return = token;
+    return Status::ok();
+  }
+
+  Status RepeatSimpleParcelable(const SimpleParcelable& input,
+                                SimpleParcelable* repeat,
+                                SimpleParcelable* _aidl_return) override {
+    ALOGI("Repeated a SimpleParcelable %s", input.toString().c_str());
+    *repeat = input;
+    *_aidl_return = input;
+    return Status::ok();
+  }
+
+  Status RepeatPersistableBundle(const PersistableBundle& input,
+                                 PersistableBundle* _aidl_return) override {
+    ALOGI("Repeated a PersistableBundle");
+    *_aidl_return = input;
+    return Status::ok();
+  }
+
+  template <typename T>
+  Status ReverseArray(const vector<T>& input, vector<T>* repeated,
+                      vector<T>* _aidl_return) {
+    ALOGI("Reversing array of length %zu", input.size());
+    *repeated = input;
+    *_aidl_return = input;
+    std::reverse(_aidl_return->begin(), _aidl_return->end());
+    return Status::ok();
+  }
+
+  template<typename T>
+  Status RepeatNullable(const unique_ptr<T>& input,
+                        unique_ptr<T>* _aidl_return) {
+    ALOGI("Repeating nullable value");
+
+    _aidl_return->reset();
+    if (input) {
+      _aidl_return->reset(new T(*input));
+    }
+
+    return Status::ok();
+  }
+
+  Status ReverseBoolean(const vector<bool>& input,
+                        vector<bool>* repeated,
+                        vector<bool>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReverseByte(const vector<uint8_t>& input,
+                     vector<uint8_t>* repeated,
+                     vector<uint8_t>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReverseChar(const vector<char16_t>& input,
+                     vector<char16_t>* repeated,
+                     vector<char16_t>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReverseInt(const vector<int32_t>& input,
+                    vector<int32_t>* repeated,
+                    vector<int32_t>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReverseLong(const vector<int64_t>& input,
+                     vector<int64_t>* repeated,
+                     vector<int64_t>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReverseFloat(const vector<float>& input,
+                      vector<float>* repeated,
+                      vector<float>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReverseDouble(const vector<double>& input,
+                       vector<double>* repeated,
+                       vector<double>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReverseString(const vector<String16>& input,
+                       vector<String16>* repeated,
+                       vector<String16>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReverseSimpleParcelables(
+      const vector<SimpleParcelable>& input,
+      vector<SimpleParcelable>* repeated,
+      vector<SimpleParcelable>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+  Status ReversePersistableBundles(
+      const vector<PersistableBundle>& input,
+      vector<PersistableBundle>* repeated,
+      vector<PersistableBundle>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+
+  Status GetOtherTestService(const String16& name,
+                             sp<INamedCallback>* returned_service) override {
+    if (service_map_.find(name) == service_map_.end()) {
+      sp<INamedCallback> new_item(new NamedCallback(name));
+      service_map_[name] = new_item;
+    }
+
+    *returned_service = service_map_[name];
+    return Status::ok();
+  }
+
+  Status VerifyName(const sp<INamedCallback>& service, const String16& name,
+                    bool* returned_value) override {
+    String16 foundName;
+    Status status = service->GetName(&foundName);
+
+    if (status.isOk()) {
+      *returned_value = foundName == name;
+    }
+
+    return status;
+  }
+
+  Status ReverseStringList(const vector<String16>& input,
+                           vector<String16>* repeated,
+                           vector<String16>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+
+  Status ReverseNamedCallbackList(const vector<sp<IBinder>>& input,
+                                  vector<sp<IBinder>>* repeated,
+                                  vector<sp<IBinder>>* _aidl_return) override {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+
+  Status RepeatFileDescriptor(const unique_fd& read,
+                              unique_fd* _aidl_return) override {
+    ALOGE("Repeating file descriptor");
+    *_aidl_return = unique_fd(dup(read.get()));
+    return Status::ok();
+  }
+
+  Status ReverseFileDescriptorArray(const vector<unique_fd>& input,
+                                    vector<unique_fd>* repeated,
+                                    vector<unique_fd>* _aidl_return) override {
+    ALOGI("Reversing descriptor array of length %zu", input.size());
+    for (const auto& item : input) {
+      repeated->push_back(unique_fd(dup(item.get())));
+      _aidl_return->push_back(unique_fd(dup(item.get())));
+    }
+    std::reverse(_aidl_return->begin(), _aidl_return->end());
+    return Status::ok();
+  }
+
+  Status ThrowServiceException(int code) override {
+    return Status::fromServiceSpecificError(code);
+  }
+
+  Status RepeatNullableIntArray(const unique_ptr<vector<int32_t>>& input,
+                                unique_ptr<vector<int32_t>>* _aidl_return) {
+    return RepeatNullable(input, _aidl_return);
+  }
+
+  Status RepeatNullableStringList(
+             const unique_ptr<vector<unique_ptr<String16>>>& input,
+             unique_ptr<vector<unique_ptr<String16>>>* _aidl_return) {
+    ALOGI("Repeating nullable string list");
+    if (!input) {
+      _aidl_return->reset();
+      return Status::ok();
+    }
+
+    _aidl_return->reset(new vector<unique_ptr<String16>>);
+
+    for (const auto& item : *input) {
+      if (!item) {
+        (*_aidl_return)->emplace_back(nullptr);
+      } else {
+        (*_aidl_return)->emplace_back(new String16(*item));
+      }
+    }
+
+    return Status::ok();
+  }
+
+  Status RepeatNullableString(const unique_ptr<String16>& input,
+                              unique_ptr<String16>* _aidl_return) {
+    return RepeatNullable(input, _aidl_return);
+  }
+
+  Status RepeatNullableParcelable(const unique_ptr<SimpleParcelable>& input,
+                              unique_ptr<SimpleParcelable>* _aidl_return) {
+    return RepeatNullable(input, _aidl_return);
+  }
+
+  Status TakesAnIBinder(const sp<IBinder>& input) override {
+    (void)input;
+    return Status::ok();
+  }
+  Status TakesAnIBinderList(const vector<sp<IBinder>>& input) override {
+    (void)input;
+    return Status::ok();
+  }
+  Status TakesANullableIBinder(const sp<IBinder>& input) {
+    (void)input;
+    return Status::ok();
+  }
+  Status TakesANullableIBinderList(const unique_ptr<vector<sp<IBinder>>>& input) {
+    (void)input;
+    return Status::ok();
+  }
+
+  Status RepeatUtf8CppString(const string& token,
+                             string* _aidl_return) override {
+    ALOGI("Repeating utf8 string '%s' of length=%zu", token.c_str(), token.size());
+    *_aidl_return = token;
+    return Status::ok();
+  }
+
+  Status RepeatNullableUtf8CppString(
+      const unique_ptr<string>& token,
+      unique_ptr<string>* _aidl_return) override {
+    if (!token) {
+      ALOGI("Received null @utf8InCpp string");
+      return Status::ok();
+    }
+    ALOGI("Repeating utf8 string '%s' of length=%zu",
+          token->c_str(), token->size());
+    _aidl_return->reset(new string(*token));
+    return Status::ok();
+  }
+
+  Status ReverseUtf8CppString(const vector<string>& input,
+                              vector<string>* repeated,
+                              vector<string>* _aidl_return) {
+    return ReverseArray(input, repeated, _aidl_return);
+  }
+
+  Status ReverseUtf8CppStringList(
+      const unique_ptr<vector<unique_ptr<::string>>>& input,
+      unique_ptr<vector<unique_ptr<string>>>* repeated,
+      unique_ptr<vector<unique_ptr<string>>>* _aidl_return) {
+    if (!input) {
+      ALOGI("Received null list of utf8 strings");
+      return Status::ok();
+    }
+    _aidl_return->reset(new vector<unique_ptr<string>>);
+    repeated->reset(new vector<unique_ptr<string>>);
+
+    for (const auto& item : *input) {
+      (*repeated)->emplace_back(nullptr);
+      (*_aidl_return)->emplace_back(nullptr);
+      if (item) {
+        (*repeated)->back().reset(new string(*item));
+        (*_aidl_return)->back().reset(new string(*item));
+      }
+    }
+    std::reverse((*_aidl_return)->begin(), (*_aidl_return)->end());
+
+    return Status::ok();
+  }
+
+  Status GetCallback(bool return_null, sp<INamedCallback>* ret) {
+    if (!return_null) {
+      return GetOtherTestService(String16("ABT: always be testing"), ret);
+    }
+    return Status::ok();
+  }
+
+ private:
+  map<String16, sp<INamedCallback>> service_map_;
+};
+
+int Run() {
+  android::sp<NativeService> service = new NativeService;
+  sp<Looper> looper(Looper::prepare(0 /* opts */));
+
+  int binder_fd = -1;
+  ProcessState::self()->setThreadPoolMaxThreadCount(0);
+  IPCThreadState::self()->disableBackgroundScheduling(true);
+  IPCThreadState::self()->setupPolling(&binder_fd);
+  ALOGI("Got binder FD %d", binder_fd);
+  if (binder_fd < 0) return -1;
+
+  sp<BinderCallback> cb(new BinderCallback);
+  if (looper->addFd(binder_fd, Looper::POLL_CALLBACK, Looper::EVENT_INPUT, cb,
+                    nullptr) != 1) {
+    ALOGE("Failed to add binder FD to Looper");
+    return -1;
+  }
+
+  defaultServiceManager()->addService(service->getInterfaceDescriptor(),
+                                      service);
+
+  ALOGI("Entering loop");
+  while (true) {
+    const int result = looper->pollAll(-1 /* timeoutMillis */);
+    ALOGI("Looper returned %d", result);
+  }
+  return 0;
+}
+
+}  // namespace
+
+int main(int /* argc */, char* /* argv */ []) {
+  return Run();
+}
diff --git a/aidl/tests/android/aidl/tests/INamedCallback.aidl b/aidl/tests/android/aidl/tests/INamedCallback.aidl
new file mode 100644
index 0000000..c295fef
--- /dev/null
+++ b/aidl/tests/android/aidl/tests/INamedCallback.aidl
@@ -0,0 +1,21 @@
+/*
+ * Copyright (C) 2015 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 android.aidl.tests;
+
+interface INamedCallback {
+  String GetName();
+}
diff --git a/aidl/tests/android/aidl/tests/ITestService.aidl b/aidl/tests/android/aidl/tests/ITestService.aidl
new file mode 100644
index 0000000..4de6925
--- /dev/null
+++ b/aidl/tests/android/aidl/tests/ITestService.aidl
@@ -0,0 +1,111 @@
+/*
+ * Copyright (C) 2015 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 android.aidl.tests;
+
+import android.aidl.tests.INamedCallback;
+import android.aidl.tests.SimpleParcelable;
+import android.os.PersistableBundle;
+
+interface ITestService {
+  // Test that constants are accessible
+  const int TEST_CONSTANT = 42;
+  const int TEST_CONSTANT2 = -42;
+  const int TEST_CONSTANT3 = +42;
+  const int TEST_CONSTANT4 = +4;
+  const int TEST_CONSTANT5 = -4;
+  const int TEST_CONSTANT6 = -0;
+  const int TEST_CONSTANT7 = +0;
+  const int TEST_CONSTANT8 = 0;
+  const int TEST_CONSTANT9 = 0x56;
+  const int TEST_CONSTANT10 = 0xa5;
+  const int TEST_CONSTANT11 = 0xFA;
+  const int TEST_CONSTANT12 = 0xffffffff;
+
+  const String STRING_TEST_CONSTANT = "foo";
+  const String STRING_TEST_CONSTANT2 = "bar";
+
+  // Test that primitives work as parameters and return types.
+  boolean RepeatBoolean(boolean token);
+  byte RepeatByte(byte token);
+  char RepeatChar(char token);
+  int RepeatInt(int token);
+  long RepeatLong(long token);
+  float RepeatFloat(float token);
+  double RepeatDouble(double token);
+  String RepeatString(String token);
+
+  SimpleParcelable RepeatSimpleParcelable(in SimpleParcelable input,
+                                          out SimpleParcelable repeat);
+  PersistableBundle RepeatPersistableBundle(in PersistableBundle input);
+
+  // Test that arrays work as parameters and return types.
+  boolean[] ReverseBoolean(in boolean[] input, out boolean[] repeated);
+  byte[]    ReverseByte   (in byte[]    input, out byte[]    repeated);
+  char[]    ReverseChar   (in char[]    input, out char[]    repeated);
+  int[]     ReverseInt    (in int[]     input, out int[]     repeated);
+  long[]    ReverseLong   (in long[]    input, out long[]    repeated);
+  float[]   ReverseFloat  (in float[]   input, out float[]   repeated);
+  double[]  ReverseDouble (in double[]  input, out double[]  repeated);
+  String[]  ReverseString (in String[]  input, out String[]  repeated);
+
+  SimpleParcelable[]  ReverseSimpleParcelables(in SimpleParcelable[] input,
+                                               out SimpleParcelable[] repeated);
+  PersistableBundle[] ReversePersistableBundles(
+      in PersistableBundle[] input, out PersistableBundle[] repeated);
+
+  // Test that clients can send and receive Binders.
+  INamedCallback GetOtherTestService(String name);
+  boolean VerifyName(INamedCallback service, String name);
+
+  // Test that List<T> types work correctly.
+  List<String> ReverseStringList(in List<String> input,
+                                 out List<String> repeated);
+  List<IBinder> ReverseNamedCallbackList(in List<IBinder> input,
+                                         out List<IBinder> repeated);
+
+  FileDescriptor RepeatFileDescriptor(in FileDescriptor read);
+  FileDescriptor[] ReverseFileDescriptorArray(in FileDescriptor[] input,
+                                              out FileDescriptor[] repeated);
+
+  // Test that service specific exceptions work correctly.
+  void ThrowServiceException(int code);
+
+  // Test nullability
+  @nullable int[] RepeatNullableIntArray(in @nullable int[] input);
+  @nullable String RepeatNullableString(in @nullable String input);
+  @nullable List<String> RepeatNullableStringList(in @nullable List<String> input);
+  @nullable SimpleParcelable RepeatNullableParcelable(in @nullable SimpleParcelable input);
+
+  void TakesAnIBinder(in IBinder input);
+  void TakesAnIBinderList(in List<IBinder> input);
+  void TakesANullableIBinder(in @nullable IBinder input);
+  void TakesANullableIBinderList(in @nullable List<IBinder> input);
+
+  // Test utf8 decoding from utf16 wire format
+  @utf8InCpp String RepeatUtf8CppString(@utf8InCpp String token);
+  @nullable @utf8InCpp String RepeatNullableUtf8CppString(
+      @nullable @utf8InCpp String token);
+
+  @utf8InCpp String[]  ReverseUtf8CppString (in @utf8InCpp String[] input,
+                                             out @utf8InCpp String[] repeated);
+
+  @nullable @utf8InCpp List<String> ReverseUtf8CppStringList(
+      in @nullable @utf8InCpp List<String> input,
+      out @nullable @utf8InCpp List<String> repeated);
+
+  @nullable INamedCallback GetCallback(boolean return_null);
+}
diff --git a/aidl/tests/android/aidl/tests/SimpleParcelable.aidl b/aidl/tests/android/aidl/tests/SimpleParcelable.aidl
new file mode 100644
index 0000000..8573999
--- /dev/null
+++ b/aidl/tests/android/aidl/tests/SimpleParcelable.aidl
@@ -0,0 +1,19 @@
+/*
+ * Copyright (C) 2015 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 android.aidl.tests;
+
+parcelable SimpleParcelable cpp_header "tests/simple_parcelable.h";
diff --git a/aidl/tests/end_to_end_tests.cpp b/aidl/tests/end_to_end_tests.cpp
new file mode 100644
index 0000000..480bfd9
--- /dev/null
+++ b/aidl/tests/end_to_end_tests.cpp
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include <android-base/logging.h>
+#include <gtest/gtest.h>
+
+#include "aidl.h"
+#include "options.h"
+#include "tests/fake_io_delegate.h"
+#include "tests/test_data.h"
+#include "tests/test_util.h"
+
+using android::aidl::test::CanonicalNameToPath;
+using android::aidl::test::FakeIoDelegate;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace android {
+namespace aidl {
+
+class EndToEndTest : public ::testing::Test {
+ protected:
+  virtual void SetUp() {
+  }
+
+  void AddStubAidls(const char** parcelables, const char** interfaces,
+                    const char* cpp_header=nullptr) {
+    for ( ; *parcelables; ++parcelables) {
+      io_delegate_.AddStubParcelable(
+          *parcelables, (cpp_header) ? cpp_header : "");
+    }
+    for ( ; *interfaces; ++interfaces) {
+      io_delegate_.AddStubInterface(*interfaces);
+    }
+  }
+
+  void CheckFileContents(const string& rel_path,
+                         const string& expected_content) {
+    string actual_content;
+    ASSERT_TRUE(io_delegate_.GetWrittenContents(rel_path, &actual_content))
+        << "Expected aidl to write to " << rel_path << " but it did not.";
+
+    if (actual_content == expected_content) {
+      return;  // success!
+    }
+
+    test::PrintDiff(expected_content, actual_content);
+    FAIL() << "Actual contents of " << rel_path
+           << " did not match expected content";
+  }
+
+  FakeIoDelegate io_delegate_;
+};
+
+TEST_F(EndToEndTest, IExampleInterface) {
+  using namespace ::android::aidl::test_data::example_interface;
+
+  JavaOptions options;
+  options.fail_on_parcelable_ = true;
+  options.import_paths_.push_back("");
+  options.input_file_name_ = CanonicalNameToPath(kCanonicalName, ".aidl");
+  options.output_file_name_ = kJavaOutputPath;
+  options.dep_file_name_ = "an/arbitrary/path/to/deps.P";
+
+  // Load up our fake file system with data.
+  io_delegate_.SetFileContents(options.input_file_name_, kInterfaceDefinition);
+  io_delegate_.AddCompoundParcelable("android.test.CompoundParcelable",
+                                     {"Subclass1", "Subclass2"});
+  AddStubAidls(kImportedParcelables, kImportedInterfaces);
+
+  // Check that we parse correctly.
+  EXPECT_EQ(android::aidl::compile_aidl_to_java(options, io_delegate_), 0);
+  CheckFileContents(kJavaOutputPath, kExpectedJavaOutput);
+  CheckFileContents(options.DependencyFilePath(), kExpectedJavaDepsOutput);
+}
+
+TEST_F(EndToEndTest, IPingResponderCpp) {
+  using namespace ::android::aidl::test_data::ping_responder;
+
+  const string input_path = CanonicalNameToPath(kCanonicalName, ".aidl");
+  const string output_file = kCppOutputPath;
+  const size_t argc = 6;
+  const char* cmdline[argc + 1] = {
+      "aidl-cpp", "-ddeps.P", "-I.", input_path.c_str(), kGenHeaderDir,
+      output_file.c_str(), nullptr
+  };
+  auto options = CppOptions::Parse(argc, cmdline);
+
+  // Set up input paths.
+  io_delegate_.SetFileContents(input_path, kInterfaceDefinition);
+  AddStubAidls(kImportedParcelables, kImportedInterfaces, kCppParcelableHeader);
+
+  // Check that we parse and generate code correctly.
+  EXPECT_EQ(android::aidl::compile_aidl_to_cpp(*options, io_delegate_), 0);
+  CheckFileContents(output_file, kExpectedCppOutput);
+  CheckFileContents(kGenInterfaceHeaderPath, kExpectedIHeaderOutput);
+  CheckFileContents(kGenClientHeaderPath, kExpectedBpHeaderOutput);
+  CheckFileContents(kGenServerHeaderPath, kExpectedBnHeaderOutput);
+  CheckFileContents(options->DependencyFilePath(), kExpectedCppDepsOutput);
+}
+
+TEST_F(EndToEndTest, StringConstantsInCpp) {
+  using namespace ::android::aidl::test_data::string_constants;
+
+  const string input_path = CanonicalNameToPath(kCanonicalName, ".aidl");
+  const string output_file = kCppOutputPath;
+  const size_t argc = 4;
+  const char* cmdline[argc + 1] = {
+      "aidl-cpp", input_path.c_str(), kGenHeaderDir,
+      output_file.c_str(), nullptr
+  };
+  auto options = CppOptions::Parse(argc, cmdline);
+
+  // Set up input paths.
+  io_delegate_.SetFileContents(input_path, kInterfaceDefinition);
+
+  // Check that we parse and generate code correctly.
+  EXPECT_EQ(android::aidl::compile_aidl_to_cpp(*options, io_delegate_), 0);
+  CheckFileContents(output_file, kExpectedCppOutput);
+  CheckFileContents(kGenInterfaceHeaderPath, kExpectedIHeaderOutput);
+}
+
+TEST_F(EndToEndTest, StringConstantsInJava) {
+  using namespace ::android::aidl::test_data::string_constants;
+
+  const string input_path = CanonicalNameToPath(kCanonicalName, ".aidl");
+  const string output_file = kJavaOutputPath;
+  const size_t argc = 4;
+  const char* cmdline[argc + 1] = {
+    "aidl",
+    "-b",
+    input_path.c_str(),
+    output_file.c_str(),
+    nullptr,
+};
+  auto options = JavaOptions::Parse(argc, cmdline);
+
+  // Load up our fake file system with data.
+  io_delegate_.SetFileContents(input_path, kInterfaceDefinition);
+
+  // Check that we parse correctly.
+  EXPECT_EQ(android::aidl::compile_aidl_to_java(*options, io_delegate_), 0);
+  CheckFileContents(kJavaOutputPath, kExpectedJavaOutput);
+}
+
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/tests/fake_io_delegate.cpp b/aidl/tests/fake_io_delegate.cpp
new file mode 100644
index 0000000..c5575f6
--- /dev/null
+++ b/aidl/tests/fake_io_delegate.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "fake_io_delegate.h"
+
+#include <android-base/stringprintf.h>
+
+#include "logging.h"
+#include "os.h"
+#include "tests/test_util.h"
+
+using android::base::StringAppendF;
+using android::base::StringPrintf;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+namespace android {
+namespace aidl {
+namespace test {
+
+// Claims to always write successfully, but can't close the file.
+class BrokenCodeWriter : public CodeWriter {
+  bool Write(const char* /* format */, ...) override {  return true; }
+  bool Close() override { return false; }
+  virtual ~BrokenCodeWriter() = default;
+};  // class BrokenCodeWriter
+
+unique_ptr<string> FakeIoDelegate::GetFileContents(
+    const string& relative_filename,
+    const string& content_suffix) const {
+  string filename = CleanPath(relative_filename);
+  unique_ptr<string> contents;
+  auto it = file_contents_.find(filename);
+  if (it == file_contents_.end()) {
+    return contents;
+  }
+  contents.reset(new string);
+  *contents = it->second;
+  contents->append(content_suffix);
+
+  return contents;
+}
+
+unique_ptr<LineReader> FakeIoDelegate::GetLineReader(
+    const string& file_path) const {
+  unique_ptr<LineReader> ret;
+  const auto& it = file_contents_.find(CleanPath(file_path));
+  if (it != file_contents_.cend()) {
+    ret = LineReader::ReadFromMemory(it->second);
+  }
+  return ret;
+}
+
+bool FakeIoDelegate::FileIsReadable(const string& path) const {
+  return file_contents_.find(CleanPath(path)) != file_contents_.end();
+}
+
+bool FakeIoDelegate::CreatedNestedDirs(
+    const std::string& /* base_dir */,
+    const std::vector<std::string>& /* nested_subdirs */) const {
+  // We don't test directory creation explicitly.
+  return true;
+}
+
+std::unique_ptr<CodeWriter> FakeIoDelegate::GetCodeWriter(
+    const std::string& file_path) const {
+  if (broken_files_.count(file_path) > 0) {
+    return unique_ptr<CodeWriter>(new BrokenCodeWriter);
+  }
+  removed_files_.erase(file_path);
+  written_file_contents_[file_path] = "";
+  return GetStringWriter(&written_file_contents_[file_path]);
+}
+
+void FakeIoDelegate::RemovePath(const std::string& file_path) const {
+  removed_files_.insert(file_path);
+}
+
+void FakeIoDelegate::SetFileContents(const string& filename,
+                                     const string& contents) {
+  file_contents_[filename] = contents;
+}
+
+void FakeIoDelegate::AddStubParcelable(const string& canonical_name,
+                                       const string& cpp_header) {
+  string package, class_name, rel_path;
+  SplitPackageClass(canonical_name, &rel_path, &package, &class_name);
+  string contents;
+  if (cpp_header.empty()) {
+    contents = StringPrintf("package %s;\nparcelable %s;",
+                            package.c_str(), class_name.c_str());
+  } else {
+    contents = StringPrintf("package %s;\nparcelable %s cpp_header \"%s\";",
+                            package.c_str(), class_name.c_str(),
+                            cpp_header.c_str());
+  }
+  SetFileContents(rel_path, contents);
+}
+
+void FakeIoDelegate::AddStubInterface(const string& canonical_name) {
+  string package, class_name, rel_path;
+  SplitPackageClass(canonical_name, &rel_path, &package, &class_name);
+  string contents = StringPrintf("package %s;\ninterface %s { }",
+                                 package.c_str(), class_name.c_str());
+  SetFileContents(rel_path, contents);
+}
+
+void FakeIoDelegate::AddCompoundParcelable(const string& canonical_name,
+                                           const vector<string>& subclasses) {
+  string package, class_name, rel_path;
+  SplitPackageClass(canonical_name, &rel_path, &package, &class_name);
+  string contents = StringPrintf("package %s;\n", package.c_str());
+  for (const string& subclass : subclasses) {
+    StringAppendF(&contents, "parcelable %s.%s;\n",
+                  class_name.c_str(), subclass.c_str());
+  }
+  SetFileContents(rel_path, contents);
+}
+
+void FakeIoDelegate::AddBrokenFilePath(const std::string& path) {
+  broken_files_.insert(path);
+}
+
+bool FakeIoDelegate::GetWrittenContents(const string& path, string* content) {
+  const auto it = written_file_contents_.find(path);
+  if (it == written_file_contents_.end()) {
+    return false;
+  }
+  if (content) {
+    *content = it->second;
+  }
+  return true;
+}
+
+bool FakeIoDelegate::PathWasRemoved(const std::string& path) {
+  if (removed_files_.count(path) > 0) {
+    return true;
+  }
+  return false;
+}
+
+string FakeIoDelegate::CleanPath(const string& path) const {
+  string clean_path = path;
+  while (clean_path.length() >= 2 &&
+         clean_path[0] == '.' &&
+         clean_path[1] == OS_PATH_SEPARATOR) {
+    clean_path = clean_path.substr(2);
+  }
+  return clean_path;
+}
+
+}  // namespace test
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/tests/fake_io_delegate.h b/aidl/tests/fake_io_delegate.h
new file mode 100644
index 0000000..aae2091
--- /dev/null
+++ b/aidl/tests/fake_io_delegate.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_TESTS_FAKE_IO_DELEGATE_H_
+#define AIDL_TESTS_FAKE_IO_DELEGATE_H_
+
+#include <android-base/macros.h>
+
+#include <map>
+#include <memory>
+#include <set>
+#include <string>
+#include <vector>
+
+#include "io_delegate.h"
+
+namespace android {
+namespace aidl {
+namespace test {
+
+class FakeIoDelegate : public IoDelegate {
+ public:
+  FakeIoDelegate() = default;
+  virtual ~FakeIoDelegate() = default;
+
+  // Overrides from the real IoDelegate
+  std::unique_ptr<std::string> GetFileContents(
+      const std::string& filename,
+      const std::string& append_content_suffix = "") const override;
+  std::unique_ptr<LineReader> GetLineReader(
+      const std::string& file_path) const override;
+  bool FileIsReadable(const std::string& path) const override;
+  bool CreatedNestedDirs(
+      const std::string& base_dir,
+      const std::vector<std::string>& nested_subdirs) const override;
+  std::unique_ptr<CodeWriter> GetCodeWriter(
+      const std::string& file_path) const override;
+  void RemovePath(const std::string& file_path) const override;
+
+  // Methods added to facilitate testing.
+  void SetFileContents(const std::string& filename,
+                       const std::string& contents);
+  void AddStubParcelable(const std::string& canonical_name,
+                         const std::string& cpp_header);
+  void AddStubInterface(const std::string& canonical_name);
+  void AddCompoundParcelable(const std::string& canonical_name,
+                             const std::vector<std::string>& subclasses);
+  void AddBrokenFilePath(const std::string& path);
+  // Returns true iff we've previously written to |path|.
+  // When we return true, we'll set *contents to the written string.
+  bool GetWrittenContents(const std::string& path, std::string* content);
+
+  bool PathWasRemoved(const std::string& path);
+
+ private:
+  // Remove leading "./" from |path|.
+  std::string CleanPath(const std::string& path) const;
+
+  std::map<std::string, std::string> file_contents_;
+  // Normally, writing to files leaves the IoDelegate unchanged, so
+  // GetCodeWriter is a const method.  However, for tests, we break this
+  // intentionally by storing the written strings.
+  mutable std::map<std::string, std::string> written_file_contents_;
+
+  // We normally just write to strings in |written_file_contents_| but for
+  // files in this list, we simulate I/O errors.
+  std::set<std::string> broken_files_;
+  mutable std::set<std::string> removed_files_;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeIoDelegate);
+};  // class FakeIoDelegate
+
+}  // namespace test
+}  // namespace android
+}  // namespace aidl
+
+#endif // AIDL_TESTS_FAKE_IO_DELEGATE_H_
diff --git a/aidl/tests/integration-test.py b/aidl/tests/integration-test.py
new file mode 100755
index 0000000..0079ba9
--- /dev/null
+++ b/aidl/tests/integration-test.py
@@ -0,0 +1,192 @@
+#!/usr/bin/env python
+
+"""
+Test that aidl generates functional code by running it on an Android device.
+"""
+
+import argparse
+import pipes
+import subprocess
+import shlex
+
+JAVA_OUTPUT_READER = 'aidl_test_sentinel_searcher'
+NATIVE_TEST_CLIENT = 'aidl_test_client'
+NATIVE_TEST_SERVICE = 'aidl_test_service'
+
+TEST_FILTER_ALL = 'all'
+TEST_FILTER_JAVA = 'java'
+TEST_FILTER_NATIVE = 'native'
+
+JAVA_CLIENT_TIMEOUT_SECONDS = 30
+JAVA_LOG_FILE = '/data/data/android.aidl.tests/files/test-client.log'
+JAVA_SUCCESS_SENTINEL = '>>> Java Client Success <<<'
+JAVA_FAILURE_SENTINEL = '>>> Java Client Failure <<<'
+
+class TestFail(Exception):
+    """Raised on test failures."""
+    pass
+
+
+class ShellResult(object):
+    """Represents the result of running a shell command."""
+
+    def __init__(self, exit_status, stdout, stderr):
+        """Construct an instance.
+
+        Args:
+            exit_status: integer exit code of shell command
+            stdout: string stdout of shell command
+            stderr: string stderr of shell command
+        """
+        self.stdout = stdout
+        self.stderr = stderr
+        self.exit_status = exit_status
+
+    def printable_string(self):
+        """Get a string we could print to the logs and understand."""
+        output = []
+        output.append('stdout:')
+        for line in self.stdout.splitlines():
+            output.append('  > %s' % line)
+        output.append('stderr:')
+        for line in self.stderr.splitlines():
+            output.append('  > %s' % line)
+        return '\n'.join(output)
+
+
+class AdbHost(object):
+    """Represents a device connected via ADB."""
+
+    def __init__(self, device_serial=None, verbose=None):
+        """Construct an instance.
+
+        Args:
+            device_serial: options string serial number of attached device.
+            verbose: True iff we should print out ADB commands we run.
+        """
+        self._device_serial = device_serial
+        self._verbose = verbose
+
+    def run(self, command, background=False, ignore_status=False):
+        """Run a command on the device via adb shell.
+
+        Args:
+            command: string containing a shell command to run.
+            background: True iff we should run this command in the background.
+            ignore_status: True iff we should ignore the command's exit code.
+
+        Returns:
+            instance of ShellResult.
+
+        Raises:
+            subprocess.CalledProcessError on command exit != 0.
+        """
+        if background:
+            command = '( %s ) </dev/null >/dev/null 2>&1 &' % command
+        return self.adb('shell %s' % pipes.quote(command),
+                        ignore_status=ignore_status)
+
+    def mktemp(self):
+        """Make a temp file on the device.
+
+        Returns:
+            path to created file as a string
+
+        Raises:
+            subprocess.CalledProcessError on failure.
+        """
+        # Work around b/19635681
+        result = self.run('source /system/etc/mkshrc && mktemp')
+        return result.stdout.strip()
+
+    def adb(self, command, ignore_status=False):
+        """Run an ADB command (e.g. `adb sync`).
+
+        Args:
+            command: string containing command to run
+            ignore_status: True iff we should ignore the command's exit code.
+
+        Returns:
+            instance of ShellResult.
+
+        Raises:
+            subprocess.CalledProcessError on command exit != 0.
+        """
+        command = 'adb %s' % command
+        if self._verbose:
+            print(command)
+        p = subprocess.Popen(command, shell=True, close_fds=True,
+                             stdout=subprocess.PIPE, stderr=subprocess.PIPE,
+                             universal_newlines=True)
+        stdout, stderr = p.communicate()
+        if not ignore_status and p.returncode:
+            raise subprocess.CalledProcessError(p.returncode, command)
+        return ShellResult(p.returncode, stdout, stderr)
+
+
+def run_test(host, test_native, test_java):
+    """Body of the test.
+
+    Args:
+        host: AdbHost object to run tests on
+        test_native: True iff we should test native Binder clients.
+        test_java: True iff we shoudl test Java Binder clients.
+    """
+
+    print('Starting aidl integration testing...')
+
+    # Kill any previous test context
+    host.run('rm -f %s' % JAVA_LOG_FILE, ignore_status=True)
+    host.run('pkill %s' % NATIVE_TEST_SERVICE, ignore_status=True)
+
+    # Start up a native server
+    host.run(NATIVE_TEST_SERVICE, background=True)
+
+    # Start up clients
+    if test_native:
+        host.run('pkill %s' % NATIVE_TEST_CLIENT, ignore_status=True)
+        result = host.run(NATIVE_TEST_CLIENT, ignore_status=True)
+        if result.exit_status:
+            print(result.printable_string())
+            raise TestFail('%s returned status code %d' %
+                           (NATIVE_TEST_CLIENT, result.exit_status))
+
+    if test_java:
+        host.run('am start -S -a android.intent.action.MAIN '
+                 '-n android.aidl.tests/.TestServiceClient '
+                 '--es sentinel.success "%s" '
+                 '--es sentinel.failure "%s"' %
+                 (JAVA_SUCCESS_SENTINEL, JAVA_FAILURE_SENTINEL))
+        result = host.run('%s %d %s "%s" "%s"' %
+                          (JAVA_OUTPUT_READER, JAVA_CLIENT_TIMEOUT_SECONDS,
+                           JAVA_LOG_FILE, JAVA_SUCCESS_SENTINEL,
+                           JAVA_FAILURE_SENTINEL),
+                          ignore_status=True)
+        if result.exit_status:
+            print(result.printable_string())
+            raise TestFail('Java client did not complete successfully.')
+
+    print('Success!')
+
+
+def main():
+    """Main entry point."""
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+            '--test-filter', default=TEST_FILTER_ALL,
+            choices=[TEST_FILTER_ALL, TEST_FILTER_JAVA, TEST_FILTER_NATIVE])
+    parser.add_argument('--verbose', '-v', action='store_true', default=False)
+    args = parser.parse_args()
+    host = AdbHost(verbose=args.verbose)
+    try:
+        # Tragically, SELinux interferes with our testing
+        host.run('setenforce 0')
+        run_test(host,
+                 args.test_filter in (TEST_FILTER_ALL, TEST_FILTER_NATIVE),
+                 args.test_filter in (TEST_FILTER_ALL, TEST_FILTER_JAVA))
+    finally:
+        host.run('setenforce 1')
+
+
+if __name__ == '__main__':
+    main()
diff --git a/aidl/tests/java_app/AndroidManifest.xml b/aidl/tests/java_app/AndroidManifest.xml
new file mode 100644
index 0000000..9093892
--- /dev/null
+++ b/aidl/tests/java_app/AndroidManifest.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    package="android.aidl.tests">
+
+  <application android:label="@string/application_title">
+
+    <activity android:name="android.aidl.tests.TestServiceClient">
+      <intent-filter>
+        <action android:name="android.intent.action.MAIN" />
+        <category android:name="android.intent.category.LAUNCHER" />
+      </intent-filter>
+    </activity>
+  </application>
+</manifest>
diff --git a/aidl/tests/java_app/README b/aidl/tests/java_app/README
new file mode 100644
index 0000000..a3dfceb
--- /dev/null
+++ b/aidl/tests/java_app/README
@@ -0,0 +1,17 @@
+To use this APK do something like:
+
+1) Build your favorite AOSP flavor.
+2) Start an emulator:
+    $ emulator
+3) Push over hellod binary:
+    $ adb remount && adb sync
+4) Install the Java client:
+    $ adb install -r <path-to-APK-in-out-directory>
+5) Put selinux in permissive mode.
+6) Start hellod:
+    $ adb shell "(hellod ) </dev/null >/dev/null 2>&1 &"
+7) Start Java client:
+    $ adb shell am start -S -a android.intent.action.MAIN \
+                           -n "android.aidl.tests/.TestServiceClient"
+8) Watch output on logcat:
+    $ adb logcat -s TestServiceClient hellod
diff --git a/aidl/tests/java_app/resources/values/strings.xml b/aidl/tests/java_app/resources/values/strings.xml
new file mode 100644
index 0000000..d5ee63e
--- /dev/null
+++ b/aidl/tests/java_app/resources/values/strings.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Strictly speaking, we don't need this. However, without something in
+     resources/ the build rebuilds the APK despite having no changes to the
+     source code.  This seems to be because it fails to generate some
+     resources metafile (R.stamp?) -->
+<resources>
+  <string
+    name="application_title"
+    >AIDL Test Services</string>
+</resources>
diff --git a/aidl/tests/java_app/src/android/aidl/tests/NullableTests.java b/aidl/tests/java_app/src/android/aidl/tests/NullableTests.java
new file mode 100644
index 0000000..83a9877
--- /dev/null
+++ b/aidl/tests/java_app/src/android/aidl/tests/NullableTests.java
@@ -0,0 +1,108 @@
+/*
+ * 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 android.aidl.tests;
+
+import android.aidl.tests.TestFailException;
+import android.os.IBinder;
+import java.util.ArrayList;
+import java.util.List;
+
+class NullableTests {
+    private static final String TAG = "TestServiceClient";
+    private ITestService mService;
+    private TestLogger mLog;
+
+    public NullableTests(ITestService service, TestLogger logger) {
+        mService = service;
+        mLog = logger;
+    }
+
+    public void checkNullHandling() throws TestFailException {
+        mLog.log("Checking that sending null strings reports an error...");
+        try {
+            String response = mService.RepeatString(null);
+            mLog.logAndThrow("Expected to fail on null string input!");
+        } catch (NullPointerException ex) {
+            mLog.log("Caught an exception on null string parameter (expected)");
+            mLog.log("null strings behave as expected");
+            return;
+        } catch (Exception ex) {
+            mLog.logAndThrow("Expected to receive NullPointerException on " +
+                             "null parameter, but got " + ex.toString());
+        }
+        mLog.logAndThrow("Expected to receive NullPointerException on " +
+                         "null parameter, but nothing was thrown??");
+    }
+
+    public void checkNullBinderDetection() throws TestFailException {
+        mLog.log("Checking that service handles @nullable IBinder...");
+        try {
+            mService.TakesAnIBinder(null);
+            mLog.logAndThrow("Expected to fail on null Binder!");
+        } catch (NullPointerException ex) {
+            mLog.log("Caught an exception on null Binder parameter (expected)");
+            return;
+        } catch (Exception ex) {
+            mLog.logAndThrow("Expected to receive NullPointerException," +
+                             "but got " + ex.toString());
+        }
+        mLog.logAndThrow("Expected to receive NullPointerException on " +
+                         "null parameter, but nothing was thrown??");
+    }
+
+    public void checkNullBinderInListDetection() throws TestFailException {
+        List<IBinder> listWithNulls = new ArrayList<IBinder>();
+        listWithNulls.add(null);
+        try {
+            mService.TakesAnIBinderList(listWithNulls);
+            mLog.logAndThrow("Expected to fail on list with null Binder!");
+        } catch (NullPointerException ex) {
+            mLog.log("Caught an exception on list with null Binder (expected)");
+            return;
+        } catch (Exception ex) {
+            mLog.logAndThrow("Expected to receive NullPointerException," +
+                             "but got " + ex.toString());
+        }
+        mLog.logAndThrow("Expected to receive NullPointerException on " +
+                         "null parameter, but nothing was thrown??");
+    }
+
+    public void checkNullInterfaceHandling() throws TestFailException {
+        mLog.log("Checking @nullable IInterface handling...");
+        try {
+            INamedCallback callback  = mService.GetCallback(false);
+            if (callback == null) {
+                mLog.logAndThrow("Expected to get non-null INamedCallback.");
+            }
+            callback  = mService.GetCallback(true);
+            if (callback != null) {
+                mLog.logAndThrow("Expected to get null INamedCallback.");
+            }
+        } catch (Exception ex) {
+            mLog.logAndThrow("Unexpected exception during @nullable IInterface test: " +
+                             ex.toString());
+        }
+        mLog.log("@nullable IInterface handling works as expected.");
+    }
+
+    public void runTests() throws TestFailException {
+        checkNullHandling();
+        checkNullBinderDetection();
+        checkNullBinderInListDetection();
+        checkNullInterfaceHandling();
+    }
+}
diff --git a/aidl/tests/java_app/src/android/aidl/tests/SimpleParcelable.java b/aidl/tests/java_app/src/android/aidl/tests/SimpleParcelable.java
new file mode 100644
index 0000000..1def98c
--- /dev/null
+++ b/aidl/tests/java_app/src/android/aidl/tests/SimpleParcelable.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2015, 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 android.aidl.tests;
+
+import android.os.Parcel;
+import android.os.Parcelable;
+
+public class SimpleParcelable implements Parcelable {
+    private String mName;
+    private int mNumber;
+
+    SimpleParcelable() {}
+    SimpleParcelable(String name, int number) {
+        mName = name;
+        mNumber = number;
+    }
+
+    public int describeContents() { return 0; }
+
+    public void writeToParcel(Parcel dest, int flags) {
+        dest.writeString(mName);
+        dest.writeInt(mNumber);
+    }
+
+    public void readFromParcel(Parcel source) {
+        mName = source.readString();
+        mNumber = source.readInt();
+    }
+
+    public boolean equals(Object o) {
+        if (o == null) {
+            return false;
+        }
+        if (!(o instanceof SimpleParcelable)) {
+            return false;
+        }
+        SimpleParcelable p = (SimpleParcelable)o;
+        if ((mName == null && p.mName != null) ||
+            (mName != null && !mName.equals(p.mName))) {
+            return false;
+        }
+        return mNumber == p.mNumber;
+    }
+
+    public String toString() {
+        return "SimpleParcelable(" + mName + ", " + mNumber + ")";
+    }
+
+    public static final Parcelable.Creator<SimpleParcelable> CREATOR =
+            new Parcelable.Creator<SimpleParcelable>() {
+        public SimpleParcelable createFromParcel(Parcel source) {
+            String name = source.readString();
+            int number = source.readInt();
+            return new SimpleParcelable(name, number);
+        }
+
+        public SimpleParcelable[] newArray(int size) {
+            return new SimpleParcelable[size];
+        }
+    };
+}
diff --git a/aidl/tests/java_app/src/android/aidl/tests/TestFailException.java b/aidl/tests/java_app/src/android/aidl/tests/TestFailException.java
new file mode 100644
index 0000000..de000fa
--- /dev/null
+++ b/aidl/tests/java_app/src/android/aidl/tests/TestFailException.java
@@ -0,0 +1,24 @@
+/*
+ * 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 android.aidl.tests;
+
+public class TestFailException extends Exception {
+    public TestFailException(String message) {
+        super(message);
+    }
+}
+
diff --git a/aidl/tests/java_app/src/android/aidl/tests/TestLogger.java b/aidl/tests/java_app/src/android/aidl/tests/TestLogger.java
new file mode 100644
index 0000000..b2e400b
--- /dev/null
+++ b/aidl/tests/java_app/src/android/aidl/tests/TestLogger.java
@@ -0,0 +1,53 @@
+/*
+ * 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 android.aidl.tests;
+
+import android.util.Log;
+import java.io.PrintWriter;
+import java.io.IOException;
+import android.content.Context;
+
+public class TestLogger {
+    private static final String TAG = "TestServiceClient";
+    private PrintWriter mLogFile;
+
+    public TestLogger(Context context) {
+        try {
+            mLogFile = new PrintWriter(context.openFileOutput(
+                    "test-client.log", Context.MODE_PRIVATE));
+        } catch (IOException ex) {
+            throw new RuntimeException("Failed to open log file for writing.");
+        }
+    }
+
+    public void log(String line) {
+        Log.i(TAG, line);
+        mLogFile.println(line);
+    }
+
+    public void logAndThrow(String line) throws TestFailException {
+        Log.e(TAG, line);
+        mLogFile.println(line);
+        throw new TestFailException(line);
+    }
+
+    public void close() {
+        if (mLogFile != null) {
+            mLogFile.close();
+        }
+    }
+}
diff --git a/aidl/tests/java_app/src/android/aidl/tests/TestServiceClient.java b/aidl/tests/java_app/src/android/aidl/tests/TestServiceClient.java
new file mode 100644
index 0000000..4af4aa0
--- /dev/null
+++ b/aidl/tests/java_app/src/android/aidl/tests/TestServiceClient.java
@@ -0,0 +1,685 @@
+/*
+ * Copyright (C) 2015, 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 android.aidl.tests;
+
+import android.aidl.tests.SimpleParcelable;
+import android.aidl.tests.TestFailException;
+import android.aidl.tests.TestLogger;
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.os.ServiceSpecificException;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.PersistableBundle;
+import android.os.RemoteException;
+import android.os.ServiceManager;
+import android.util.Log;
+import java.io.File;
+import java.io.FileDescriptor;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+// Generated
+import android.aidl.tests.INamedCallback;
+import android.aidl.tests.ITestService;
+
+public class TestServiceClient extends Activity {
+    private static final String TAG = "TestServiceClient";
+
+    private TestLogger mLog;
+    private String mSuccessSentinel;
+    private String mFailureSentinel;
+
+    private void init() {
+        Intent intent = getIntent();
+        mLog = new TestLogger(this);
+        mLog.log("Reading sentinels from intent...");
+        mSuccessSentinel = intent.getStringExtra("sentinel.success");
+        mFailureSentinel = intent.getStringExtra("sentinel.failure");
+        if (mSuccessSentinel == null || mFailureSentinel == null) {
+            String message = "Failed to read intent extra input.";
+            Log.e(TAG, message);
+            mLog.close();
+            throw new RuntimeException(message);
+        }
+    }
+
+    private ITestService getService() throws TestFailException {
+        IBinder service = new ServiceManager().getService(
+                ITestService.class.getName());
+        if (service == null) {
+            mLog.logAndThrow("Failed to obtain binder...");
+        }
+        ITestService ret = ITestService.Stub.asInterface(service);
+        if (ret == null) {
+            mLog.logAndThrow("Failed to cast IBinder instance.");
+        }
+        return ret;
+    }
+
+    private void checkPrimitiveRepeat(ITestService service)
+            throws TestFailException {
+        mLog.log("Checking that service can repeat primitives back...");
+        try {
+            {
+                boolean query = true;
+                boolean response = service.RepeatBoolean(query);
+                if (query != response) {
+                    mLog.logAndThrow("Repeat with " + query +
+                                     " responded " + response);
+                }
+            }
+            {
+                char query = 'A';
+                char response = service.RepeatChar(query);
+                if (query != response) {
+                    mLog.logAndThrow("Repeat with " + query +
+                                     " responded " + response);
+                }
+            }
+            {
+                byte query = -128;
+                byte response = service.RepeatByte(query);
+                if (query != response) {
+                    mLog.logAndThrow("Repeat with " + query +
+                                     " responded " + response);
+                }
+            }
+            {
+                int query = 1 << 30;
+                int response = service.RepeatInt(query);
+                if (query != response) {
+                    mLog.logAndThrow("Repeat with " + query +
+                                     " responded " + response);
+                }
+            }
+            {
+                int query[] = {ITestService.TEST_CONSTANT,
+                               ITestService.TEST_CONSTANT2,
+                               ITestService.TEST_CONSTANT3,
+                               ITestService.TEST_CONSTANT4,
+                               ITestService.TEST_CONSTANT5,
+                               ITestService.TEST_CONSTANT6,
+                               ITestService.TEST_CONSTANT7,
+                               ITestService.TEST_CONSTANT8};
+                for (int i = 0; i < query.length; i++) {
+                    int response = service.RepeatInt(query[i]);
+                    if (query[i] != response) {
+                        mLog.logAndThrow("Repeat with " + query[i] +
+                                " responded " + response);
+                    }
+                }
+            }
+            {
+                long query = 1L << 60;
+                long response = service.RepeatLong(query);
+                if (query != response) {
+                    mLog.logAndThrow("Repeat with " + query +
+                                     " responded " + response);
+                }
+            }
+            {
+                float query = 1.0f/3.0f;
+                float response = service.RepeatFloat(query);
+                if (query != response) {
+                    mLog.logAndThrow("Repeat with " + query +
+                                     " responded " + response);
+                }
+            }
+            {
+                double query = 1.0/3.0;
+                double response = service.RepeatDouble(query);
+                if (query != response) {
+                    mLog.logAndThrow("Repeat with " + query +
+                                     " responded " + response);
+                }
+            }
+
+            List<String> queries = Arrays.asList(
+                "not empty", "", "\0",
+                ITestService.STRING_TEST_CONSTANT,
+                ITestService.STRING_TEST_CONSTANT2);
+            for (String query : queries) {
+                String response = service.RepeatString(query);
+                if (!query.equals(response)) {
+                    mLog.logAndThrow("Repeat request with '" + query + "'" +
+                                     " of length " + query.length() +
+                                     " responded with '" + response + "'" +
+                                     " of length " + response.length());
+                }
+            }
+        } catch (RemoteException ex) {
+            mLog.log(ex.toString());
+            mLog.logAndThrow("Service failed to repeat a primitive back.");
+        }
+        mLog.log("...Basic primitive repeating works.");
+    }
+
+    private void checkArrayReversal(ITestService service)
+            throws TestFailException {
+        mLog.log("Checking that service can reverse and return arrays...");
+        try {
+            {
+                boolean[] input = {true, false, false, false};
+                boolean echoed[] = new boolean[input.length];
+                boolean[] reversed = service.ReverseBoolean(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (input[i] != reversed[j]) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+            {
+                byte[] input = {0, 1, 2};
+                byte echoed[] = new byte[input.length];
+                byte[] reversed = service.ReverseByte(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (input[i] != reversed[j]) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+            {
+                char[] input = {'A', 'B', 'C', 'D', 'E'};
+                char echoed[] = new char[input.length];
+                char[] reversed = service.ReverseChar(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (input[i] != reversed[j]) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+            {
+                int[] input = {-1, 0, 1, 2, 3, 4, 5, 6};
+                int echoed[] = new int[input.length];
+                int[] reversed = service.ReverseInt(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (input[i] != reversed[j]) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+            {
+                long[] input = {-2, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8};
+                long echoed[] = new long[input.length];
+                long[] reversed = service.ReverseLong(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (input[i] != reversed[j]) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+            {
+                float[] input = {0.0f, 1.0f, -0.3f};
+                float echoed[] = new float[input.length];
+                float[] reversed = service.ReverseFloat(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (input[i] != reversed[j]) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+            {
+                double[] input = {-1.0, -4.0, -2.0};
+                double echoed[] = new double[input.length];
+                double[] reversed = service.ReverseDouble(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (input[i] != reversed[j]) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+            {
+                String[] input = {"For", "relaxing", "times"};
+                String echoed[] = new String[input.length];
+                String[] reversed = service.ReverseString(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (!input[i].equals(reversed[j])) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+        } catch (RemoteException ex) {
+            mLog.log(ex.toString());
+            mLog.logAndThrow("Service failed to reverse an array.");
+        }
+        mLog.log("...service can reverse and return arrays.");
+    }
+
+    private void checkBinderExchange(
+                ITestService service) throws TestFailException {
+      mLog.log("Checking exchange of binders...");
+      try {
+          INamedCallback got = service.GetOtherTestService("Smythe");
+          mLog.log("Received test service");
+          String name = got.GetName();
+
+          if (!name.equals("Smythe")) {
+              mLog.logAndThrow("Tried to get service with name 'Smythe'" +
+                               " and found service with name '" + name + "'");
+          }
+
+          if (!service.VerifyName(got, "Smythe")) {
+              mLog.logAndThrow("Test service could not verify name of 'Smythe'");
+          }
+      } catch (RemoteException ex) {
+          mLog.log(ex.toString());
+          mLog.logAndThrow("Service failed to exchange binders.");
+      }
+      mLog.log("...Exchange of binders works");
+    }
+
+    private void checkListReversal(ITestService service)
+            throws TestFailException {
+        mLog.log("Checking that service can reverse and return lists...");
+        try {
+            {
+                List<String> input = Arrays.asList("Walk", "into", "Córdoba");
+                List<String> echoed = new ArrayList<String>();
+                List<String> reversed = service.ReverseStringList(input, echoed);
+                if (!input.equals(echoed)) {
+                    mLog.logAndThrow("Failed to echo input List<String> back.");
+                }
+                Collections.reverse(input);
+                if (!input.equals(reversed)) {
+                    mLog.logAndThrow("Reversed list is not correct.");
+                }
+            }
+        } catch (RemoteException ex) {
+            mLog.log(ex.toString());
+            mLog.logAndThrow("Service failed to reverse an List<String>.");
+        }
+        mLog.log("...service can reverse and return lists.");
+    }
+
+    private void checkSimpleParcelables(ITestService service)
+            throws TestFailException {
+        mLog.log("Checking that service can repeat and reverse SimpleParcelable objects...");
+        try {
+            {
+                SimpleParcelable input = new SimpleParcelable("foo", 42);
+                SimpleParcelable out_param = new SimpleParcelable();
+                SimpleParcelable returned =
+                        service.RepeatSimpleParcelable(input, out_param);
+                if (!input.equals(out_param)) {
+                    mLog.log(input.toString() + " != " + out_param.toString());
+                    mLog.logAndThrow("out param SimpleParcelable was not equivalent");
+                }
+                if (!input.equals(returned)) {
+                    mLog.log(input.toString() + " != " + returned.toString());
+                    mLog.logAndThrow("returned SimpleParcelable was not equivalent");
+                }
+            }
+            {
+                SimpleParcelable[] input = new SimpleParcelable[3];
+                input[0] = new SimpleParcelable("a", 1);
+                input[1] = new SimpleParcelable("b", 2);
+                input[2] = new SimpleParcelable("c", 3);
+                SimpleParcelable[] repeated = new SimpleParcelable[3];
+                SimpleParcelable[] reversed = service.ReverseSimpleParcelables(
+                        input, repeated);
+                if (!Arrays.equals(input, repeated)) {
+                    mLog.logAndThrow(
+                            "Repeated list of SimpleParcelable objects did not match.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow(
+                            "Reversed list of SimpleParcelable objects had wrong length.");
+                }
+                for (int i = 0, k = input.length - 1;
+                     i < input.length;
+                     ++i, --k) {
+                    if (!input[i].equals(reversed[k])) {
+                        mLog.log(input[i].toString() + " != " +
+                                 reversed[k].toString());
+                        mLog.logAndThrow("reversed SimpleParcelable was not equivalent");
+                    }
+                }
+            }
+        } catch (Exception ex) {
+            mLog.log(ex.toString());
+            mLog.logAndThrow("Service failed to handle SimpleParcelable objects.");
+        }
+        mLog.log("...service can manipulate SimpleParcelable objects.");
+    }
+
+    private void checkPersistableBundles(ITestService service)
+            throws TestFailException {
+        mLog.log("Checking that service can repeat and reverse PersistableBundle objects...");
+        try {
+            {
+                PersistableBundle emptyBundle = new PersistableBundle();
+                PersistableBundle returned = service.RepeatPersistableBundle(emptyBundle);
+                if (emptyBundle.size() != 0 || returned.size() != 0) {
+                    mLog.log(emptyBundle.toString() + " != " + returned.toString());
+                    mLog.logAndThrow("returned empty PersistableBundle object was not equivalent");
+                }
+                mLog.log("...service can repeat and reverse empty PersistableBundle objects...");
+            }
+            {
+                final String testBoolKey = new String("testBool");
+                final String testIntKey = new String("testInt");
+                final String testNestedIntKey = new String("testNestedInt");
+                final String testLongKey = new String("testLong");
+                final String testDoubleKey = new String("testDouble");
+                final String testStringKey = new String("testString");
+                final String testBoolArrayKey = new String("testBoolArray");
+                final String testIntArrayKey = new String("testIntArray");
+                final String testLongArrayKey = new String("testLongArray");
+                final String testDoubleArrayKey = new String("testDoubleArray");
+                final String testStringArrayKey = new String("testStringArray");
+                final String testPersistableBundleKey = new String("testPersistableBundle");
+                PersistableBundle nonEmptyBundle = new PersistableBundle();
+                nonEmptyBundle.putBoolean(testBoolKey, false);
+                nonEmptyBundle.putInt(testIntKey, 33);
+                nonEmptyBundle.putLong(testLongKey, 34359738368L);
+                nonEmptyBundle.putDouble(testDoubleKey, 1.1);
+                nonEmptyBundle.putString(testStringKey, new String("Woot!"));
+                nonEmptyBundle.putBooleanArray(testBoolArrayKey, new boolean[] {true, false, true});
+                nonEmptyBundle.putIntArray(testIntArrayKey, new int[] {33, 44, 55, 142});
+                nonEmptyBundle.putLongArray(
+                    testLongArrayKey, new long[] {34L, 8371L, 34359738375L});
+                nonEmptyBundle.putDoubleArray(testDoubleArrayKey, new double[] {2.2, 5.4});
+                nonEmptyBundle.putStringArray(testStringArrayKey, new String[] {"hello", "world!"});
+                PersistableBundle testNestedPersistableBundle = new PersistableBundle();
+                testNestedPersistableBundle.putInt(testNestedIntKey, 345);
+                nonEmptyBundle.putPersistableBundle(
+                    testPersistableBundleKey, testNestedPersistableBundle);
+                PersistableBundle returned = service.RepeatPersistableBundle(nonEmptyBundle);
+                if (returned.size() != nonEmptyBundle.size()
+                    || returned.getBoolean(testBoolKey) != nonEmptyBundle.getBoolean(testBoolKey)
+                    || returned.getInt(testIntKey) != nonEmptyBundle.getInt(testIntKey)
+                    || returned.getLong(testLongKey) != nonEmptyBundle.getLong(testLongKey)
+                    || returned.getDouble(testDoubleKey) != nonEmptyBundle.getDouble(testDoubleKey)
+                    || !returned.getString(testStringKey)
+                                .equals(nonEmptyBundle.getString(testStringKey))
+                    || !Arrays.equals(nonEmptyBundle.getBooleanArray(testBoolArrayKey),
+                                      returned.getBooleanArray(testBoolArrayKey))
+                    || !Arrays.equals(nonEmptyBundle.getIntArray(testIntArrayKey),
+                                      returned.getIntArray(testIntArrayKey))
+                    || !Arrays.equals(nonEmptyBundle.getLongArray(testLongArrayKey),
+                                      returned.getLongArray(testLongArrayKey))
+                    || !Arrays.equals(nonEmptyBundle.getDoubleArray(testDoubleArrayKey),
+                                      returned.getDoubleArray(testDoubleArrayKey))
+                    || !Arrays.equals(nonEmptyBundle.getStringArray(testStringArrayKey),
+                                      returned.getStringArray(testStringArrayKey))) {
+                    PersistableBundle temp =
+                        returned.getPersistableBundle(testPersistableBundleKey);
+                    if (temp == null
+                        || temp.getInt(testNestedIntKey)
+                            != testNestedPersistableBundle.getInt(testNestedIntKey)) {
+                        mLog.log(nonEmptyBundle.toString() + " != " + returned.toString());
+                        mLog.logAndThrow("returned non-empty PersistableBundle " +
+                                         "object was not equivalent");
+                    }
+                }
+                mLog.log("...service can repeat and reverse non-empty " +
+                         "PersistableBundle objects...");
+            }
+            {
+                PersistableBundle[] input = new PersistableBundle[3];
+                PersistableBundle first = new PersistableBundle();
+                PersistableBundle second = new PersistableBundle();
+                PersistableBundle third = new PersistableBundle();
+                final String testIntKey = new String("testInt");
+                final String testLongKey = new String("testLong");
+                final String testDoubleKey = new String("testDouble");
+                first.putInt(testIntKey, 1231);
+                second.putLong(testLongKey, 222222L);
+                third.putDouble(testDoubleKey, 10.8);
+                input[0] = first;
+                input[1] = second;
+                input[2] = third;
+                final int original_input_size = input.length;
+                PersistableBundle[] repeated = new PersistableBundle[input.length];
+                PersistableBundle[] reversed = service.ReversePersistableBundles(input, repeated);
+                if (input.length != repeated.length || input.length != original_input_size) {
+                    mLog.logAndThrow("Repeated list of PersistableBundle objects had " +
+                                     "wrong length.");
+                }
+                if (input[0].getInt(testIntKey) != repeated[0].getInt(testIntKey)
+                    || input[1].getLong(testLongKey) != repeated[1].getLong(testLongKey)
+                    || input[2].getDouble(testDoubleKey) != repeated[2].getDouble(testDoubleKey)) {
+                    mLog.logAndThrow("Repeated list of PersistableBundle objects did not match.");
+                }
+                if (input.length != reversed.length || input.length != original_input_size) {
+                    mLog.logAndThrow("Reversed list of PersistableBundle objects had " +
+                                     "wrong length.");
+                }
+                if (input[0].getInt(testIntKey) != reversed[2].getInt(testIntKey)
+                    || input[1].getLong(testLongKey) != reversed[1].getLong(testLongKey)
+                    || input[2].getDouble(testDoubleKey) != reversed[0].getDouble(testDoubleKey)) {
+                    mLog.logAndThrow("reversed PersistableBundle objects were not equivalent");
+                }
+                mLog.log("...service can repeat and reverse arrays of " +
+                         "non-empty PersistableBundle objects...");
+            }
+        } catch (Exception ex) {
+            mLog.log(ex.toString());
+            mLog.logAndThrow("Service failed to handle PersistableBundle objects.");
+        }
+        mLog.log("...service can manipulate PersistableBundle objects.");
+    }
+
+    private void checkFileDescriptorPassing(ITestService service)
+            throws TestFailException {
+        mLog.log("Checking that service can receive and return file descriptors...");
+        try {
+            FileOutputStream fileOutputStream =
+                    openFileOutput("test-dummy", Context.MODE_PRIVATE);
+
+            FileDescriptor descriptor = fileOutputStream.getFD();
+            FileDescriptor journeyed = service.RepeatFileDescriptor(descriptor);
+            fileOutputStream.close();
+
+            FileOutputStream journeyedStream = new FileOutputStream(journeyed);
+
+            String testData = "FrazzleSnazzleFlimFlamFlibbityGumboChops";
+            byte[] output = testData.getBytes();
+            journeyedStream.write(output);
+            journeyedStream.close();
+
+            FileInputStream fileInputStream = openFileInput("test-dummy");
+            byte[] input = new byte[output.length];
+            if (fileInputStream.read(input) != input.length) {
+                mLog.logAndThrow("Read short count from file");
+            }
+
+            if (!Arrays.equals(input, output)) {
+                mLog.logAndThrow("Read incorrect data");
+            }
+        } catch (RemoteException ex) {
+            mLog.log(ex.toString());
+            mLog.logAndThrow("Service failed to repeat a file descriptor.");
+        } catch (IOException ex) {
+            mLog.log(ex.toString());
+            mLog.logAndThrow("Exception while operating on temporary file");
+        }
+        mLog.log("...service can receive and return file descriptors.");
+    }
+
+    private void checkServiceSpecificExceptions(
+                ITestService service) throws TestFailException {
+        mLog.log("Checking application exceptions...");
+        for (int i = -1; i < 2; ++i) {
+            try {
+                service.ThrowServiceException(i);
+            } catch (RemoteException ex) {
+                mLog.logAndThrow("Service threw RemoteException: " +
+                                 ex.toString());
+            } catch (ServiceSpecificException ex) {
+                if (ex.errorCode != i) {
+                    mLog.logAndThrow("Service threw wrong error code: " + i);
+                }
+            }
+        }
+        mLog.log("...application exceptions work");
+    }
+
+    private void checkUtf8Strings(ITestService service)
+            throws TestFailException {
+        mLog.log("Checking that service can work with UTF8 strings...");
+        // Note that Java's underlying encoding is UTF16.
+        final List<String> utf8_queries = Arrays.asList(
+              "typical string",
+              "",
+              "\0\0\0",
+              // Java doesn't handle unicode code points above U+FFFF well.
+              new String(Character.toChars(0x1F701)) + "\u03A9");
+        try {
+            for (String query : utf8_queries) {
+                String response = service.RepeatUtf8CppString(query);
+                if (!query.equals(response)) {
+                    mLog.logAndThrow("Repeat request with '" + query + "'" +
+                                     " of length " + query.length() +
+                                     " responded with '" + response + "'" +
+                                     " of length " + response.length());
+                }
+            }
+            {
+                String[] input = (String[])utf8_queries.toArray();
+                String echoed[] = new String[input.length];
+                String[] reversed = service.ReverseUtf8CppString(input, echoed);
+                if (!Arrays.equals(input, echoed)) {
+                    mLog.logAndThrow("Failed to echo utf8 input array back.");
+                }
+                if (input.length != reversed.length) {
+                    mLog.logAndThrow("Reversed utf8 array is the wrong size.");
+                }
+                for (int i = 0; i < input.length; ++i) {
+                    int j = reversed.length - (1 + i);
+                    if (!input[i].equals(reversed[j])) {
+                        mLog.logAndThrow(
+                                "input[" + i + "] = " + input[i] +
+                                " but reversed value = " + reversed[j]);
+                    }
+                }
+            }
+        } catch (RemoteException ex) {
+            mLog.log(ex.toString());
+            mLog.logAndThrow("Service failed to handle utf8 strings.");
+        }
+        mLog.log("...UTF8 annotations work.");
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        Log.i(TAG, "Starting!");
+        try {
+          init();
+          ITestService service = getService();
+          checkPrimitiveRepeat(service);
+          checkArrayReversal(service);
+          checkBinderExchange(service);
+          checkListReversal(service);
+          checkSimpleParcelables(service);
+          checkPersistableBundles(service);
+          checkFileDescriptorPassing(service);
+          checkServiceSpecificExceptions(service);
+          checkUtf8Strings(service);
+          new NullableTests(service, mLog).runTests();
+
+          mLog.log(mSuccessSentinel);
+        } catch (TestFailException e) {
+            mLog.log(mFailureSentinel);
+            throw new RuntimeException(e);
+        } finally {
+            if (mLog != null) {
+                mLog.close();
+            }
+        }
+    }
+}
diff --git a/aidl/tests/main.cpp b/aidl/tests/main.cpp
new file mode 100644
index 0000000..4d820af
--- /dev/null
+++ b/aidl/tests/main.cpp
@@ -0,0 +1,6 @@
+#include <gtest/gtest.h>
+
+int main(int argc, char **argv) {
+  ::testing::InitGoogleTest(&argc, argv);
+  return RUN_ALL_TESTS();
+}
diff --git a/aidl/tests/simple_parcelable.cpp b/aidl/tests/simple_parcelable.cpp
new file mode 100644
index 0000000..e092d25
--- /dev/null
+++ b/aidl/tests/simple_parcelable.cpp
@@ -0,0 +1,56 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#include "tests/simple_parcelable.h"
+
+#include <android-base/stringprintf.h>
+#include <binder/Parcel.h>
+#include <utils/String8.h>
+
+using android::base::StringPrintf;
+
+namespace android {
+namespace aidl {
+namespace tests {
+
+SimpleParcelable::SimpleParcelable(const std::string& name, int32_t number)
+    : name_(name.c_str(), name.length()),
+      number_(number) {}
+
+status_t SimpleParcelable::writeToParcel(Parcel* parcel) const {
+  status_t status = parcel->writeString16(name_);
+  if (status != OK) {
+    return status;
+  }
+  status = parcel->writeInt32(number_);
+  return status;
+}
+
+status_t SimpleParcelable::readFromParcel(const Parcel* parcel) {
+  status_t status = parcel->readString16(&name_);
+  if (status != OK) {
+    return status;
+  }
+  return parcel->readInt32(&number_);
+}
+
+std::string SimpleParcelable::toString() const {
+    return StringPrintf("%s(%d)", String8(name_).string(), number_);
+}
+
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/simple_parcelable.h b/aidl/tests/simple_parcelable.h
new file mode 100644
index 0000000..52a20de
--- /dev/null
+++ b/aidl/tests/simple_parcelable.h
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+
+#ifndef AIDL_TESTS_SIMPLE_PARCELABLE_H_
+#define AIDL_TESTS_SIMPLE_PARCELABLE_H_
+
+#include <cstdint>
+#include <string>
+
+#include <binder/Parcelable.h>
+#include <utils/Errors.h>
+#include <utils/String16.h>
+
+namespace android {
+namespace aidl {
+namespace tests {
+
+class SimpleParcelable : public Parcelable {
+ public:
+  SimpleParcelable() = default;
+  SimpleParcelable(const std::string& name, int32_t number);
+  virtual ~SimpleParcelable() = default;
+
+  // Write |this| parcelable to the given |parcel|.  Keep in mind that
+  // implementations of writeToParcel must be manually kept in sync
+  // with readFromParcel and the Java equivalent versions of these methods.
+  //
+  // Returns android::OK on success and an appropriate error otherwise.
+  status_t writeToParcel(Parcel* parcel) const override;
+
+  // Read data from the given |parcel| into |this|.  After readFromParcel
+  // completes, |this| should have equivalent state to the object that
+  // wrote itself to the parcel.
+  //
+  // Returns android::OK on success and an appropriate error otherwise.
+  status_t readFromParcel(const Parcel* parcel) override;
+
+  std::string toString() const;
+
+  friend bool operator==(const SimpleParcelable& lhs,
+                         const SimpleParcelable& rhs) {
+    return (lhs.name_ == rhs.name_) && (lhs.number_ == rhs.number_);
+  }
+  friend bool operator!=(const SimpleParcelable& lhs,
+                         const SimpleParcelable& rhs) {
+    return !(lhs == rhs);
+  }
+
+ private:
+  String16 name_;
+  int32_t number_ = 0;
+};  // class SimpleParcelable
+
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
+
+#endif  // AIDL_TESTS_SIMPLE_PARCELABLE_H_
diff --git a/aidl/tests/test_data.h b/aidl/tests/test_data.h
new file mode 100644
index 0000000..d3a5f6c
--- /dev/null
+++ b/aidl/tests/test_data.h
@@ -0,0 +1,81 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_TESTS_TEST_DATA_H_
+#define AIDL_TESTS_TEST_DATA_H_
+
+namespace android {
+namespace aidl {
+namespace test_data {
+
+namespace example_interface {
+
+extern const char kCanonicalName[];
+extern const char kJavaOutputPath[];
+extern const char kInterfaceDefinition[];
+extern const char* kImportedParcelables[];
+extern const char* kImportedInterfaces[];
+
+extern const char kExpectedJavaDepsOutput[];
+extern const char kExpectedJavaOutput[];
+
+}  // namespace example_interface
+
+namespace ping_responder {
+
+extern const char kCanonicalName[];
+extern const char kInterfaceDefinition[];
+
+extern const char kCppOutputPath[];
+extern const char kCppParcelableHeader[];
+extern const char* kImportedParcelables[];
+extern const char* kImportedInterfaces[];
+
+extern const char kGenHeaderDir[];
+extern const char kGenInterfaceHeaderPath[];
+extern const char kGenClientHeaderPath[];
+extern const char kGenServerHeaderPath[];
+
+extern const char kExpectedCppDepsOutput[];
+
+extern const char kExpectedCppOutput[];
+extern const char kExpectedIHeaderOutput[];
+extern const char kExpectedBpHeaderOutput[];
+extern const char kExpectedBnHeaderOutput[];
+
+}  // namespace ping_responder
+
+namespace string_constants {
+
+extern const char kCanonicalName[];
+extern const char kInterfaceDefinition[];
+
+extern const char kJavaOutputPath[];
+extern const char kExpectedJavaOutput[];
+
+extern const char kCppOutputPath[];
+extern const char kGenHeaderDir[];
+extern const char kGenInterfaceHeaderPath[];
+extern const char kExpectedIHeaderOutput[];
+extern const char kExpectedCppOutput[];
+
+}  // namespace string_constants
+
+}  // namespace test_data
+}  // namespace aidl
+}  // namespace android
+
+#endif // AIDL_TESTS_TEST_DATA_H_
diff --git a/aidl/tests/test_data_example_interface.cpp b/aidl/tests/test_data_example_interface.cpp
new file mode 100644
index 0000000..81b919f
--- /dev/null
+++ b/aidl/tests/test_data_example_interface.cpp
@@ -0,0 +1,456 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "tests/test_data.h"
+
+namespace android {
+namespace aidl {
+namespace test_data {
+namespace example_interface {
+
+const char kCanonicalName[] = "android.test.IExampleInterface";
+
+const char kJavaOutputPath[] = "some/path/to/output.java";
+
+const char* kImportedParcelables[] = {
+  "android.foo.ExampleParcelable",
+  nullptr,
+};
+
+const char* kImportedInterfaces[] = {
+  "android.bar.IAuxInterface",
+  "android.test.IAuxInterface2",
+  nullptr,
+};
+
+const char kInterfaceDefinition[] = R"(
+package android.test;
+
+import android.foo.ExampleParcelable;
+import android.test.CompoundParcelable;
+import android.bar.IAuxInterface;
+import android.test.IAuxInterface2;
+
+interface IExampleInterface {
+    const int EXAMPLE_CONSTANT = 3;
+    boolean isEnabled();
+    int getState();
+    String getAddress();
+
+    /* Test long comment */
+    ExampleParcelable[] getParcelables();
+
+    // Test short comment
+    boolean setScanMode(int mode, int duration);
+
+    /* Test long comment */
+    // And short comment
+    void registerBinder(IAuxInterface foo);
+    IExampleInterface getRecursiveBinder();
+
+    int takesAnInterface(in IAuxInterface2 arg);
+    int takesAParcelable(in CompoundParcelable.Subclass1 arg,
+                         inout CompoundParcelable.Subclass2 arg2);
+}
+)";
+
+const char kExpectedJavaDepsOutput[] =
+R"(some/path/to/output.java : \
+  android/test/IExampleInterface.aidl \
+  ./android/foo/ExampleParcelable.aidl \
+  ./android/test/CompoundParcelable.aidl \
+  ./android/bar/IAuxInterface.aidl \
+  ./android/test/IAuxInterface2.aidl
+
+android/test/IExampleInterface.aidl :
+./android/foo/ExampleParcelable.aidl :
+./android/test/CompoundParcelable.aidl :
+./android/bar/IAuxInterface.aidl :
+./android/test/IAuxInterface2.aidl :
+)";
+
+const char kExpectedJavaOutput[] =
+R"(/*
+ * This file is auto-generated.  DO NOT MODIFY.
+ * Original file: android/test/IExampleInterface.aidl
+ */
+package android.test;
+public interface IExampleInterface extends android.os.IInterface
+{
+/** Local-side IPC implementation stub class. */
+public static abstract class Stub extends android.os.Binder implements android.test.IExampleInterface
+{
+private static final java.lang.String DESCRIPTOR = "android.test.IExampleInterface";
+/** Construct the stub at attach it to the interface. */
+public Stub()
+{
+this.attachInterface(this, DESCRIPTOR);
+}
+/**
+ * Cast an IBinder object into an android.test.IExampleInterface interface,
+ * generating a proxy if needed.
+ */
+public static android.test.IExampleInterface asInterface(android.os.IBinder obj)
+{
+if ((obj==null)) {
+return null;
+}
+android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
+if (((iin!=null)&&(iin instanceof android.test.IExampleInterface))) {
+return ((android.test.IExampleInterface)iin);
+}
+return new android.test.IExampleInterface.Stub.Proxy(obj);
+}
+@Override public android.os.IBinder asBinder()
+{
+return this;
+}
+@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
+{
+switch (code)
+{
+case INTERFACE_TRANSACTION:
+{
+reply.writeString(DESCRIPTOR);
+return true;
+}
+case TRANSACTION_isEnabled:
+{
+data.enforceInterface(DESCRIPTOR);
+boolean _result = this.isEnabled();
+reply.writeNoException();
+reply.writeInt(((_result)?(1):(0)));
+return true;
+}
+case TRANSACTION_getState:
+{
+data.enforceInterface(DESCRIPTOR);
+int _result = this.getState();
+reply.writeNoException();
+reply.writeInt(_result);
+return true;
+}
+case TRANSACTION_getAddress:
+{
+data.enforceInterface(DESCRIPTOR);
+java.lang.String _result = this.getAddress();
+reply.writeNoException();
+reply.writeString(_result);
+return true;
+}
+case TRANSACTION_getParcelables:
+{
+data.enforceInterface(DESCRIPTOR);
+android.foo.ExampleParcelable[] _result = this.getParcelables();
+reply.writeNoException();
+reply.writeTypedArray(_result, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
+return true;
+}
+case TRANSACTION_setScanMode:
+{
+data.enforceInterface(DESCRIPTOR);
+int _arg0;
+_arg0 = data.readInt();
+int _arg1;
+_arg1 = data.readInt();
+boolean _result = this.setScanMode(_arg0, _arg1);
+reply.writeNoException();
+reply.writeInt(((_result)?(1):(0)));
+return true;
+}
+case TRANSACTION_registerBinder:
+{
+data.enforceInterface(DESCRIPTOR);
+android.bar.IAuxInterface _arg0;
+_arg0 = android.bar.IAuxInterface.Stub.asInterface(data.readStrongBinder());
+this.registerBinder(_arg0);
+reply.writeNoException();
+return true;
+}
+case TRANSACTION_getRecursiveBinder:
+{
+data.enforceInterface(DESCRIPTOR);
+android.test.IExampleInterface _result = this.getRecursiveBinder();
+reply.writeNoException();
+reply.writeStrongBinder((((_result!=null))?(_result.asBinder()):(null)));
+return true;
+}
+case TRANSACTION_takesAnInterface:
+{
+data.enforceInterface(DESCRIPTOR);
+android.test.IAuxInterface2 _arg0;
+_arg0 = android.test.IAuxInterface2.Stub.asInterface(data.readStrongBinder());
+int _result = this.takesAnInterface(_arg0);
+reply.writeNoException();
+reply.writeInt(_result);
+return true;
+}
+case TRANSACTION_takesAParcelable:
+{
+data.enforceInterface(DESCRIPTOR);
+android.test.CompoundParcelable.Subclass1 _arg0;
+if ((0!=data.readInt())) {
+_arg0 = android.test.CompoundParcelable.Subclass1.CREATOR.createFromParcel(data);
+}
+else {
+_arg0 = null;
+}
+android.test.CompoundParcelable.Subclass2 _arg1;
+if ((0!=data.readInt())) {
+_arg1 = android.test.CompoundParcelable.Subclass2.CREATOR.createFromParcel(data);
+}
+else {
+_arg1 = null;
+}
+int _result = this.takesAParcelable(_arg0, _arg1);
+reply.writeNoException();
+reply.writeInt(_result);
+if ((_arg1!=null)) {
+reply.writeInt(1);
+_arg1.writeToParcel(reply, android.os.Parcelable.PARCELABLE_WRITE_RETURN_VALUE);
+}
+else {
+reply.writeInt(0);
+}
+return true;
+}
+}
+return super.onTransact(code, data, reply, flags);
+}
+private static class Proxy implements android.test.IExampleInterface
+{
+private android.os.IBinder mRemote;
+Proxy(android.os.IBinder remote)
+{
+mRemote = remote;
+}
+@Override public android.os.IBinder asBinder()
+{
+return mRemote;
+}
+public java.lang.String getInterfaceDescriptor()
+{
+return DESCRIPTOR;
+}
+@Override public boolean isEnabled() throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+boolean _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+mRemote.transact(Stub.TRANSACTION_isEnabled, _data, _reply, 0);
+_reply.readException();
+_result = (0!=_reply.readInt());
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+@Override public int getState() throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+int _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+mRemote.transact(Stub.TRANSACTION_getState, _data, _reply, 0);
+_reply.readException();
+_result = _reply.readInt();
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+@Override public java.lang.String getAddress() throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+java.lang.String _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+mRemote.transact(Stub.TRANSACTION_getAddress, _data, _reply, 0);
+_reply.readException();
+_result = _reply.readString();
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+/* Test long comment */
+@Override public android.foo.ExampleParcelable[] getParcelables() throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+android.foo.ExampleParcelable[] _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+mRemote.transact(Stub.TRANSACTION_getParcelables, _data, _reply, 0);
+_reply.readException();
+_result = _reply.createTypedArray(android.foo.ExampleParcelable.CREATOR);
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+// Test short comment
+
+@Override public boolean setScanMode(int mode, int duration) throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+boolean _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+_data.writeInt(mode);
+_data.writeInt(duration);
+mRemote.transact(Stub.TRANSACTION_setScanMode, _data, _reply, 0);
+_reply.readException();
+_result = (0!=_reply.readInt());
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+/* Test long comment */// And short comment
+
+@Override public void registerBinder(android.bar.IAuxInterface foo) throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+_data.writeStrongBinder((((foo!=null))?(foo.asBinder()):(null)));
+mRemote.transact(Stub.TRANSACTION_registerBinder, _data, _reply, 0);
+_reply.readException();
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+}
+@Override public android.test.IExampleInterface getRecursiveBinder() throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+android.test.IExampleInterface _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+mRemote.transact(Stub.TRANSACTION_getRecursiveBinder, _data, _reply, 0);
+_reply.readException();
+_result = android.test.IExampleInterface.Stub.asInterface(_reply.readStrongBinder());
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+@Override public int takesAnInterface(android.test.IAuxInterface2 arg) throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+int _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+_data.writeStrongBinder((((arg!=null))?(arg.asBinder()):(null)));
+mRemote.transact(Stub.TRANSACTION_takesAnInterface, _data, _reply, 0);
+_reply.readException();
+_result = _reply.readInt();
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+@Override public int takesAParcelable(android.test.CompoundParcelable.Subclass1 arg, android.test.CompoundParcelable.Subclass2 arg2) throws android.os.RemoteException
+{
+android.os.Parcel _data = android.os.Parcel.obtain();
+android.os.Parcel _reply = android.os.Parcel.obtain();
+int _result;
+try {
+_data.writeInterfaceToken(DESCRIPTOR);
+if ((arg!=null)) {
+_data.writeInt(1);
+arg.writeToParcel(_data, 0);
+}
+else {
+_data.writeInt(0);
+}
+if ((arg2!=null)) {
+_data.writeInt(1);
+arg2.writeToParcel(_data, 0);
+}
+else {
+_data.writeInt(0);
+}
+mRemote.transact(Stub.TRANSACTION_takesAParcelable, _data, _reply, 0);
+_reply.readException();
+_result = _reply.readInt();
+if ((0!=_reply.readInt())) {
+arg2.readFromParcel(_reply);
+}
+}
+finally {
+_reply.recycle();
+_data.recycle();
+}
+return _result;
+}
+}
+static final int TRANSACTION_isEnabled = (android.os.IBinder.FIRST_CALL_TRANSACTION + 0);
+static final int TRANSACTION_getState = (android.os.IBinder.FIRST_CALL_TRANSACTION + 1);
+static final int TRANSACTION_getAddress = (android.os.IBinder.FIRST_CALL_TRANSACTION + 2);
+static final int TRANSACTION_getParcelables = (android.os.IBinder.FIRST_CALL_TRANSACTION + 3);
+static final int TRANSACTION_setScanMode = (android.os.IBinder.FIRST_CALL_TRANSACTION + 4);
+static final int TRANSACTION_registerBinder = (android.os.IBinder.FIRST_CALL_TRANSACTION + 5);
+static final int TRANSACTION_getRecursiveBinder = (android.os.IBinder.FIRST_CALL_TRANSACTION + 6);
+static final int TRANSACTION_takesAnInterface = (android.os.IBinder.FIRST_CALL_TRANSACTION + 7);
+static final int TRANSACTION_takesAParcelable = (android.os.IBinder.FIRST_CALL_TRANSACTION + 8);
+}
+public static final int EXAMPLE_CONSTANT = 3;
+public boolean isEnabled() throws android.os.RemoteException;
+public int getState() throws android.os.RemoteException;
+public java.lang.String getAddress() throws android.os.RemoteException;
+/* Test long comment */
+public android.foo.ExampleParcelable[] getParcelables() throws android.os.RemoteException;
+// Test short comment
+
+public boolean setScanMode(int mode, int duration) throws android.os.RemoteException;
+/* Test long comment */// And short comment
+
+public void registerBinder(android.bar.IAuxInterface foo) throws android.os.RemoteException;
+public android.test.IExampleInterface getRecursiveBinder() throws android.os.RemoteException;
+public int takesAnInterface(android.test.IAuxInterface2 arg) throws android.os.RemoteException;
+public int takesAParcelable(android.test.CompoundParcelable.Subclass1 arg, android.test.CompoundParcelable.Subclass2 arg2) throws android.os.RemoteException;
+}
+)";
+
+}  // namespace example_interface
+}  // namespace test_data
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/test_data_ping_responder.cpp b/aidl/tests/test_data_ping_responder.cpp
new file mode 100644
index 0000000..40cb602
--- /dev/null
+++ b/aidl/tests/test_data_ping_responder.cpp
@@ -0,0 +1,461 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "tests/test_data.h"
+
+namespace android {
+namespace aidl {
+namespace test_data {
+namespace ping_responder {
+
+const char kCanonicalName[] = "android.os.IPingResponder";
+const char kInterfaceDefinition[] = R"(
+package android.os;
+
+import bar.Unused;
+
+interface IPingResponder {
+  String Ping(String input);
+
+  @nullable
+  String NullablePing(@nullable String input);
+
+  @utf8InCpp
+  String Utf8Ping(@utf8InCpp String input);
+
+  @utf8InCpp @nullable
+  String NullableUtf8Ping(@utf8InCpp @nullable String input);
+}
+)";
+
+const char kCppOutputPath[] = "some/path/to/output.cpp";
+
+const char kCppParcelableHeader[] = "cpp-header-str";
+
+const char* kImportedParcelables[] = {
+  "bar.Unused",
+  nullptr,
+};
+
+const char* kImportedInterfaces[] = {
+  nullptr,
+};
+
+const char kGenHeaderDir[] = "some/path";
+const char kGenInterfaceHeaderPath[] = "some/path/android/os/IPingResponder.h";
+const char kGenClientHeaderPath[] = "some/path/android/os/BpPingResponder.h";
+const char kGenServerHeaderPath[] = "some/path/android/os/BnPingResponder.h";
+
+const char kExpectedCppDepsOutput[] =
+R"(some/path/to/output.cpp : \
+  android/os/IPingResponder.aidl \
+  ./bar/Unused.aidl
+
+android/os/IPingResponder.aidl :
+./bar/Unused.aidl :
+
+some/path/android/os/BpPingResponder.h \
+    some/path/android/os/BnPingResponder.h \
+    some/path/android/os/IPingResponder.h : \
+    android/os/IPingResponder.aidl \
+    ./bar/Unused.aidl
+)";
+
+const char kExpectedCppOutput[] =
+R"(#include <android/os/IPingResponder.h>
+#include <android/os/BpPingResponder.h>
+
+namespace android {
+
+namespace os {
+
+IMPLEMENT_META_INTERFACE(PingResponder, "android.os.IPingResponder")
+
+}  // namespace os
+
+}  // namespace android
+#include <android/os/BpPingResponder.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+namespace os {
+
+BpPingResponder::BpPingResponder(const ::android::sp<::android::IBinder>& _aidl_impl)
+    : BpInterface<IPingResponder>(_aidl_impl){
+}
+
+::android::binder::Status BpPingResponder::Ping(const ::android::String16& input, ::android::String16* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeString16(input);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IPingResponder::PING, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readString16(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpPingResponder::NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeString16(input);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IPingResponder::NULLABLEPING, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readString16(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpPingResponder::Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeUtf8AsUtf16(input);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IPingResponder::UTF8PING, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+::android::binder::Status BpPingResponder::NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) {
+::android::Parcel _aidl_data;
+::android::Parcel _aidl_reply;
+::android::status_t _aidl_ret_status = ::android::OK;
+::android::binder::Status _aidl_status;
+_aidl_ret_status = _aidl_data.writeInterfaceToken(getInterfaceDescriptor());
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_data.writeUtf8AsUtf16(input);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = remote()->transact(IPingResponder::NULLABLEUTF8PING, _aidl_data, &_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_ret_status = _aidl_status.readFromParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+if (!_aidl_status.isOk()) {
+return _aidl_status;
+}
+_aidl_ret_status = _aidl_reply.readUtf8FromUtf16(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+goto _aidl_error;
+}
+_aidl_error:
+_aidl_status.setFromStatusT(_aidl_ret_status);
+return _aidl_status;
+}
+
+}  // namespace os
+
+}  // namespace android
+#include <android/os/BnPingResponder.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+namespace os {
+
+::android::status_t BnPingResponder::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) {
+::android::status_t _aidl_ret_status = ::android::OK;
+switch (_aidl_code) {
+case Call::PING:
+{
+::android::String16 in_input;
+::android::String16 _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readString16(&in_input);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(Ping(in_input, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeString16(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::NULLABLEPING:
+{
+::std::unique_ptr<::android::String16> in_input;
+::std::unique_ptr<::android::String16> _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readString16(&in_input);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(NullablePing(in_input, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeString16(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::UTF8PING:
+{
+::std::string in_input;
+::std::string _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_input);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(Utf8Ping(in_input, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+case Call::NULLABLEUTF8PING:
+{
+::std::unique_ptr<::std::string> in_input;
+::std::unique_ptr<::std::string> _aidl_return;
+if (!(_aidl_data.checkInterface(this))) {
+_aidl_ret_status = ::android::BAD_TYPE;
+break;
+}
+_aidl_ret_status = _aidl_data.readUtf8FromUtf16(&in_input);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+::android::binder::Status _aidl_status(NullableUtf8Ping(in_input, &_aidl_return));
+_aidl_ret_status = _aidl_status.writeToParcel(_aidl_reply);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+if (!_aidl_status.isOk()) {
+break;
+}
+_aidl_ret_status = _aidl_reply->writeUtf8AsUtf16(_aidl_return);
+if (((_aidl_ret_status) != (::android::OK))) {
+break;
+}
+}
+break;
+default:
+{
+_aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags);
+}
+break;
+}
+if (_aidl_ret_status == ::android::UNEXPECTED_NULL) {
+_aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeToParcel(_aidl_reply);
+}
+return _aidl_ret_status;
+}
+
+}  // namespace os
+
+}  // namespace android
+)";
+
+const char kExpectedIHeaderOutput[] =
+R"(#ifndef AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_
+#define AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_
+
+#include <binder/IBinder.h>
+#include <binder/IInterface.h>
+#include <binder/Status.h>
+#include <memory>
+#include <string>
+#include <utils/String16.h>
+#include <utils/StrongPointer.h>
+
+namespace android {
+
+namespace os {
+
+class IPingResponder : public ::android::IInterface {
+public:
+DECLARE_META_INTERFACE(PingResponder)
+virtual ::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) = 0;
+virtual ::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) = 0;
+virtual ::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) = 0;
+virtual ::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) = 0;
+enum Call {
+  PING = ::android::IBinder::FIRST_CALL_TRANSACTION + 0,
+  NULLABLEPING = ::android::IBinder::FIRST_CALL_TRANSACTION + 1,
+  UTF8PING = ::android::IBinder::FIRST_CALL_TRANSACTION + 2,
+  NULLABLEUTF8PING = ::android::IBinder::FIRST_CALL_TRANSACTION + 3,
+};
+};  // class IPingResponder
+
+}  // namespace os
+
+}  // namespace android
+
+#endif  // AIDL_GENERATED_ANDROID_OS_I_PING_RESPONDER_H_
+)";
+
+const char kExpectedBpHeaderOutput[] =
+R"(#ifndef AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_
+#define AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_
+
+#include <binder/IBinder.h>
+#include <binder/IInterface.h>
+#include <utils/Errors.h>
+#include <android/os/IPingResponder.h>
+
+namespace android {
+
+namespace os {
+
+class BpPingResponder : public ::android::BpInterface<IPingResponder> {
+public:
+explicit BpPingResponder(const ::android::sp<::android::IBinder>& _aidl_impl);
+virtual ~BpPingResponder() = default;
+::android::binder::Status Ping(const ::android::String16& input, ::android::String16* _aidl_return) override;
+::android::binder::Status NullablePing(const ::std::unique_ptr<::android::String16>& input, ::std::unique_ptr<::android::String16>* _aidl_return) override;
+::android::binder::Status Utf8Ping(const ::std::string& input, ::std::string* _aidl_return) override;
+::android::binder::Status NullableUtf8Ping(const ::std::unique_ptr<::std::string>& input, ::std::unique_ptr<::std::string>* _aidl_return) override;
+};  // class BpPingResponder
+
+}  // namespace os
+
+}  // namespace android
+
+#endif  // AIDL_GENERATED_ANDROID_OS_BP_PING_RESPONDER_H_
+)";
+
+const char kExpectedBnHeaderOutput[] =
+R"(#ifndef AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_
+#define AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_
+
+#include <binder/IInterface.h>
+#include <android/os/IPingResponder.h>
+
+namespace android {
+
+namespace os {
+
+class BnPingResponder : public ::android::BnInterface<IPingResponder> {
+public:
+::android::status_t onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags = 0) override;
+};  // class BnPingResponder
+
+}  // namespace os
+
+}  // namespace android
+
+#endif  // AIDL_GENERATED_ANDROID_OS_BN_PING_RESPONDER_H_
+)";
+
+}  // namespace ping_responder
+}  // namespace test_data
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/test_data_string_constants.cpp b/aidl/tests/test_data_string_constants.cpp
new file mode 100644
index 0000000..4674843
--- /dev/null
+++ b/aidl/tests/test_data_string_constants.cpp
@@ -0,0 +1,195 @@
+/*
+ * 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.
+ */
+
+#include "tests/test_data.h"
+
+namespace android {
+namespace aidl {
+namespace test_data {
+namespace string_constants {
+
+const char kCanonicalName[] = "android.os.IStringConstants";
+const char kInterfaceDefinition[] = R"(
+package android.os;
+
+interface IStringConstants {
+  const String EXAMPLE_CONSTANT = "foo";
+}
+)";
+
+const char kJavaOutputPath[] = "some/path/to/output.java";
+const char kExpectedJavaOutput[] =
+R"(/*
+ * This file is auto-generated.  DO NOT MODIFY.
+ * Original file: android/os/IStringConstants.aidl
+ */
+package android.os;
+public interface IStringConstants extends android.os.IInterface
+{
+/** Local-side IPC implementation stub class. */
+public static abstract class Stub extends android.os.Binder implements android.os.IStringConstants
+{
+private static final java.lang.String DESCRIPTOR = "android.os.IStringConstants";
+/** Construct the stub at attach it to the interface. */
+public Stub()
+{
+this.attachInterface(this, DESCRIPTOR);
+}
+/**
+ * Cast an IBinder object into an android.os.IStringConstants interface,
+ * generating a proxy if needed.
+ */
+public static android.os.IStringConstants asInterface(android.os.IBinder obj)
+{
+if ((obj==null)) {
+return null;
+}
+android.os.IInterface iin = obj.queryLocalInterface(DESCRIPTOR);
+if (((iin!=null)&&(iin instanceof android.os.IStringConstants))) {
+return ((android.os.IStringConstants)iin);
+}
+return new android.os.IStringConstants.Stub.Proxy(obj);
+}
+@Override public android.os.IBinder asBinder()
+{
+return this;
+}
+@Override public boolean onTransact(int code, android.os.Parcel data, android.os.Parcel reply, int flags) throws android.os.RemoteException
+{
+switch (code)
+{
+case INTERFACE_TRANSACTION:
+{
+reply.writeString(DESCRIPTOR);
+return true;
+}
+}
+return super.onTransact(code, data, reply, flags);
+}
+private static class Proxy implements android.os.IStringConstants
+{
+private android.os.IBinder mRemote;
+Proxy(android.os.IBinder remote)
+{
+mRemote = remote;
+}
+@Override public android.os.IBinder asBinder()
+{
+return mRemote;
+}
+public java.lang.String getInterfaceDescriptor()
+{
+return DESCRIPTOR;
+}
+}
+}
+public static final String EXAMPLE_CONSTANT = "foo";
+}
+)";
+
+const char kCppOutputPath[] = "some/path/to/output.cpp";
+const char kGenHeaderDir[] = "output";
+const char kGenInterfaceHeaderPath[] = "output/android/os/IStringConstants.h";
+const char kExpectedIHeaderOutput[] =
+R"(#ifndef AIDL_GENERATED_ANDROID_OS_I_STRING_CONSTANTS_H_
+#define AIDL_GENERATED_ANDROID_OS_I_STRING_CONSTANTS_H_
+
+#include <binder/IBinder.h>
+#include <binder/IInterface.h>
+#include <binder/Status.h>
+#include <utils/String16.h>
+#include <utils/StrongPointer.h>
+
+namespace android {
+
+namespace os {
+
+class IStringConstants : public ::android::IInterface {
+public:
+DECLARE_META_INTERFACE(StringConstants)
+static const ::android::String16& EXAMPLE_CONSTANT();
+};  // class IStringConstants
+
+}  // namespace os
+
+}  // namespace android
+
+#endif  // AIDL_GENERATED_ANDROID_OS_I_STRING_CONSTANTS_H_
+)";
+
+const char kExpectedCppOutput[] =
+R"(#include <android/os/IStringConstants.h>
+#include <android/os/BpStringConstants.h>
+
+namespace android {
+
+namespace os {
+
+IMPLEMENT_META_INTERFACE(StringConstants, "android.os.IStringConstants")
+
+const ::android::String16& IStringConstants::EXAMPLE_CONSTANT() {
+static const ::android::String16 value("foo");
+return value;
+}
+
+}  // namespace os
+
+}  // namespace android
+#include <android/os/BpStringConstants.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+namespace os {
+
+BpStringConstants::BpStringConstants(const ::android::sp<::android::IBinder>& _aidl_impl)
+    : BpInterface<IStringConstants>(_aidl_impl){
+}
+
+}  // namespace os
+
+}  // namespace android
+#include <android/os/BnStringConstants.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+namespace os {
+
+::android::status_t BnStringConstants::onTransact(uint32_t _aidl_code, const ::android::Parcel& _aidl_data, ::android::Parcel* _aidl_reply, uint32_t _aidl_flags) {
+::android::status_t _aidl_ret_status = ::android::OK;
+switch (_aidl_code) {
+default:
+{
+_aidl_ret_status = ::android::BBinder::onTransact(_aidl_code, _aidl_data, _aidl_reply, _aidl_flags);
+}
+break;
+}
+if (_aidl_ret_status == ::android::UNEXPECTED_NULL) {
+_aidl_ret_status = ::android::binder::Status::fromExceptionCode(::android::binder::Status::EX_NULL_POINTER).writeToParcel(_aidl_reply);
+}
+return _aidl_ret_status;
+}
+
+}  // namespace os
+
+}  // namespace android
+)";
+
+}  // namespace string_constants
+}  // namespace test_data
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/test_helpers.h b/aidl/tests/test_helpers.h
new file mode 100644
index 0000000..7d5145b
--- /dev/null
+++ b/aidl/tests/test_helpers.h
@@ -0,0 +1,78 @@
+/*
+ * 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.
+ */
+
+#include <algorithm>
+#include <vector>
+
+#include <android-base/logging.h>
+#include <binder/Status.h>
+#include <utils/StrongPointer.h>
+
+#include "android/aidl/tests/ITestService.h"
+
+namespace android {
+namespace aidl {
+namespace tests {
+namespace client {
+
+template <typename T, typename U>
+bool RepeatPrimitive(
+    const android::sp<android::aidl::tests::ITestService>& service,
+    android::binder::Status(android::aidl::tests::ITestService::*func)(T, T*),
+    U input) {
+  T reply;
+  android::binder::Status status = (*service.*func)(input, &reply);
+  if (!status.isOk() || input != reply) {
+    LOG(ERROR) << "Failed to repeat primitive. status=" << status.toString8()
+               << ".";
+    return false;
+  }
+  return true;
+}
+
+template <typename T>
+bool ReverseArray(
+    const android::sp<android::aidl::tests::ITestService>& service,
+    android::binder::Status(android::aidl::tests::ITestService::*func)(
+        const std::vector<T>&, std::vector<T>*, std::vector<T>*),
+        std::vector<T> input) {
+  std::vector<T> actual_reversed;
+  std::vector<T> actual_repeated;
+  android::binder::Status status = (*service.*func)(
+      input, &actual_repeated, &actual_reversed);
+  if (!status.isOk()) {
+    LOG(ERROR) << "Failed to repeat array. status=" << status.toString8()
+               << ".";
+    return false;
+  }
+  if (input != actual_repeated) {
+    LOG(ERROR) << "Repeated version of array did not match";
+    LOG(ERROR) << "input.size()=" << input.size()
+               << " repeated.size()=" << actual_repeated.size();
+    return false;
+  }
+  std::reverse(input.begin(), input.end());
+  if (input != actual_reversed) {
+    LOG(ERROR) << "Reversed version of array did not match";
+    return false;
+  }
+  return true;
+}
+
+}  // namespace client
+}  // namespace tests
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/tests/test_util.cpp b/aidl/tests/test_util.cpp
new file mode 100644
index 0000000..9cb52f3
--- /dev/null
+++ b/aidl/tests/test_util.cpp
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+
+#include <android-base/strings.h>
+
+#include "os.h"
+#include "tests/test_util.h"
+
+using android::base::Split;
+using android::base::Join;
+using std::string;
+using std::vector;
+using std::cout;
+using std::endl;
+using std::distance;
+
+namespace android {
+namespace aidl {
+namespace test {
+
+string CanonicalNameToPath(const char* package_class, const char* extension) {
+  string rel_path{package_class};
+  for (char& c : rel_path) {
+    if (c == '.') {
+      c = OS_PATH_SEPARATOR;
+    }
+  }
+  rel_path += extension;
+  return rel_path;
+}
+
+void SplitPackageClass(const string& package_class,
+                       string* rel_path,
+                       string* package,
+                       string* class_name) {
+  *package = string{package_class, 0, package_class.rfind('.')};
+  *class_name = string{package_class, package_class.rfind('.') + 1};
+  *rel_path = CanonicalNameToPath(package_class.c_str(), ".aidl");
+}
+
+void PrintDiff(const string& a, const string& b) {
+  const int LEFT = 1;
+  const int UP = 2;
+  const int UP_LEFT = 4;
+
+  auto a_lines = Split(a, "\n");
+  auto b_lines = Split(b, "\n");
+
+  struct diff_table_entry {
+    size_t longest_common_subsequence_length;
+    int propagation_directions;
+  };
+
+  diff_table_entry table[a_lines.size() + 1][b_lines.size() + 1];
+
+  for (size_t i = 0; i < a_lines.size() + 1; ++i) {
+    for (size_t j = 0; j < b_lines.size() + 1; ++j) {
+      if (i == 0 || j == 0) {
+        int directions = 0;
+
+        if (i) {
+          directions |= UP;
+        }
+
+        if (j) {
+          directions |= LEFT;
+        }
+
+        table[i][j].longest_common_subsequence_length = 0;
+        table[i][j].propagation_directions = directions;
+      } else if (a_lines[i-1] == b_lines[j-1]) {
+        table[i][j].longest_common_subsequence_length =
+            table[i-1][j-1].longest_common_subsequence_length + 1;
+        table[i][j].propagation_directions = UP_LEFT;
+      } else {
+        size_t length_up = table[i-1][j].longest_common_subsequence_length;
+        size_t length_left = table[i][j-1].longest_common_subsequence_length;
+        int directions = 0;
+        size_t length;
+
+        if (length_up >= length_left) {
+          directions |= UP;
+          length = length_up;
+        }
+
+        if (length_left >= length_up) {
+          directions |= LEFT;
+          length = length_left;
+        }
+
+        table[i][j].longest_common_subsequence_length = length;
+        table[i][j].propagation_directions = directions;
+      }
+    }
+  }
+
+  size_t i = a_lines.size();
+  size_t j = b_lines.size();
+  vector<string> output;
+
+  while (table[i][j].propagation_directions) {
+    if (table[i][j].propagation_directions & UP_LEFT) {
+      output.push_back(" " + a_lines[i-1]);
+      i--;
+      j--;
+    } else if (table[i][j].propagation_directions & UP) {
+      output.push_back("-" + a_lines[i-1]);
+      i--;
+    } else {
+      output.push_back("+" + b_lines[j-1]);
+      j--;
+    }
+  }
+
+  int print_mask = 0;
+  bool printed_last = false;
+  size_t line_number = 0;
+
+  for (auto it = output.crbegin(), frontier = output.crbegin();
+       it != output.crend(); ++it) {
+    while (frontier != output.crend() && distance(it, frontier) <= 3) {
+      print_mask <<= 1;
+      print_mask &= 0x7f;
+
+      if ((*frontier)[0] != ' ') {
+        print_mask |= 1;
+      }
+
+      frontier++;
+    }
+
+    if ((*it)[0] != '-') {
+      line_number++;
+    }
+
+    if (print_mask) {
+      if (!printed_last) {
+        cout << "Line: " << line_number << endl;
+      }
+
+      cout << *it << endl;
+      printed_last = true;
+    } else {
+      printed_last = false;
+    }
+  }
+}
+
+}  // namespace test
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/tests/test_util.h b/aidl/tests/test_util.h
new file mode 100644
index 0000000..34b9e5d
--- /dev/null
+++ b/aidl/tests/test_util.h
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_TESTS_TEST_UTIL_H_
+#define AIDL_TESTS_TEST_UTIL_H_
+
+#include <string>
+
+namespace android {
+namespace aidl {
+namespace test {
+
+std::string CanonicalNameToPath(const char* package_class,
+                                const char* extension);
+
+void SplitPackageClass(const std::string& package_class,
+                       std::string* rel_path,
+                       std::string* package,
+                       std::string* class_name);
+
+void PrintDiff(const std::string& a, const std::string& b);
+
+}  // namespace test
+}  // namespace android
+}  // namespace aidl
+
+#endif // AIDL_TESTS_TEST_UTIL_H_
diff --git a/aidl/type_cpp.cpp b/aidl/type_cpp.cpp
new file mode 100644
index 0000000..2c0552d
--- /dev/null
+++ b/aidl/type_cpp.cpp
@@ -0,0 +1,567 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "type_cpp.h"
+
+#include <algorithm>
+#include <iostream>
+#include <vector>
+
+#include <android-base/stringprintf.h>
+#include <android-base/strings.h>
+
+#include "logging.h"
+
+using std::cerr;
+using std::endl;
+using std::set;
+using std::string;
+using std::unique_ptr;
+using std::vector;
+
+using android::base::Split;
+using android::base::Join;
+using android::base::StringPrintf;
+
+namespace android {
+namespace aidl {
+namespace cpp {
+namespace {
+
+const char kNoPackage[] = "";
+const char kNoHeader[] = "";
+const char kNoValidMethod[] = "";
+Type* const kNoArrayType = nullptr;
+Type* const kNoNullableType = nullptr;
+
+bool is_cpp_keyword(const std::string& str) {
+  static const std::vector<std::string> kCppKeywords{
+    "alignas", "alignof", "and", "and_eq", "asm", "auto", "bitand", "bitor",
+    "bool", "break", "case", "catch", "char", "char16_t", "char32_t", "class",
+    "compl", "concept", "const", "constexpr", "const_cast", "continue",
+    "decltype", "default", "delete", "do", "double", "dynamic_cast", "else",
+    "enum", "explicit", "export", "extern", "false", "float", "for", "friend",
+    "goto", "if", "inline", "int", "long", "mutable", "namespace", "new",
+    "noexcept", "not", "not_eq", "nullptr", "operator", "or", "or_eq",
+    "private", "protected", "public", "register", "reinterpret_cast",
+    "requires", "return", "short", "signed", "sizeof", "static",
+    "static_assert", "static_cast", "struct", "switch", "template", "this",
+    "thread_local", "throw", "true", "try", "typedef", "typeid", "typename",
+    "union", "unsigned", "using", "virtual", "void", "volatile", "wchar_t",
+    "while", "xor", "xor_eq",
+  };
+  return std::find(kCppKeywords.begin(), kCppKeywords.end(), str) !=
+      kCppKeywords.end();
+}
+
+class VoidType : public Type {
+ public:
+  VoidType() : Type(ValidatableType::KIND_BUILT_IN, kNoPackage, "void",
+                    {}, "void", kNoValidMethod, kNoValidMethod) {}
+  virtual ~VoidType() = default;
+  bool CanBeOutParameter() const override { return false; }
+  bool CanWriteToParcel() const override { return false; }
+};  // class VoidType
+
+class CppArrayType : public Type {
+ public:
+  CppArrayType(int kind,  // from ValidatableType
+            const std::string& package,
+            const string& underlying_aidl_type,
+            const string& cpp_header,
+            const string& underlying_cpp_type,
+            const string& read_method,
+            const string& write_method,
+            bool is_nullable,
+            const string& src_file_name = "")
+      : Type(kind, package,
+             underlying_aidl_type + "[]",
+             GetHeaders(is_nullable, cpp_header),
+             GetCppType(is_nullable, underlying_cpp_type),
+             read_method, write_method, kNoArrayType,
+             (is_nullable)
+                 ? kNoNullableType
+                 // All arrays are nullable.
+                 : new CppArrayType(kind, package, underlying_aidl_type,
+                                    cpp_header, underlying_cpp_type,
+                                    read_method, write_method, true),
+             src_file_name) {}
+
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  static vector<string> GetHeaders(bool is_nullable, const string& cpp_header) {
+    vector<string> result = {"vector"};
+    if (is_nullable) {
+      result.push_back("memory");
+    }
+    if (!cpp_header.empty()) {
+      result.push_back(cpp_header);
+    }
+    return result;
+  }
+
+  static string GetCppType(bool is_nullable,
+                           const string& underlying_cpp_type) {
+    if (is_nullable)
+      return StringPrintf("::std::unique_ptr<::std::vector<%s>>",
+                          underlying_cpp_type.c_str());
+    return StringPrintf("::std::vector<%s>",
+                        underlying_cpp_type.c_str());
+  }
+
+  DISALLOW_COPY_AND_ASSIGN(CppArrayType);
+};  // class CppArrayType
+
+class PrimitiveType : public Type {
+ public:
+  PrimitiveType(const std::string& aidl_type,
+                const std::string& header,
+                const std::string& cpp_type,
+                const std::string& read_method,
+                const std::string& write_method,
+                const std::string& read_array_method,
+                const std::string& write_array_method)
+      : Type(ValidatableType::KIND_BUILT_IN, kNoPackage, aidl_type, {header},
+             cpp_type, read_method, write_method,
+             new CppArrayType(ValidatableType::KIND_BUILT_IN, kNoPackage,
+                              aidl_type, header, cpp_type,
+                              read_array_method, write_array_method,
+                              false)) {}
+
+  virtual ~PrimitiveType() = default;
+  bool IsCppPrimitive() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(PrimitiveType);
+};  // class PrimitiveType
+
+// Unfortunately, bytes in Java are signed.  However, most C authors would
+// say that a byte is not in fact signed.  Compromise: customize this otherwise
+// normal primitive to use signed single bytes, but unsigned byte arrays.
+class ByteType : public Type {
+ public:
+  ByteType()
+      : Type(ValidatableType::KIND_BUILT_IN, kNoPackage, "byte",
+             {"cstdint"}, "int8_t", "readByte", "writeByte",
+             new CppArrayType(ValidatableType::KIND_BUILT_IN, kNoPackage,
+                              "byte", "cstdint", "uint8_t",
+                              "readByteVector", "writeByteVector",
+                              false)) {}
+
+  virtual ~ByteType() = default;
+  bool IsCppPrimitive() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(ByteType);
+};  // class PrimitiveType
+
+class BinderType : public Type {
+ public:
+  BinderType(const AidlInterface& interface, const std::string& src_file_name)
+      : BinderType(interface, src_file_name,
+                   new BinderType(interface, src_file_name, kNoNullableType,
+                                  "readNullableStrongBinder"),
+                   "readStrongBinder") {}
+  virtual ~BinderType() = default;
+
+  string WriteCast(const string& val) const override {
+    return write_cast_ + "(" + val + ")";
+  }
+
+ private:
+  BinderType(const AidlInterface& interface,
+             const std::string& src_file_name,
+             Type* nullable_type, const std::string& read)
+      : Type(ValidatableType::KIND_GENERATED,
+             interface.GetPackage(), interface.GetName(),
+             {GetCppHeader(interface)}, GetCppName(interface),
+             read, "writeStrongBinder", kNoArrayType, nullable_type,
+             src_file_name, interface.GetLine()),
+        write_cast_(GetRawCppName(interface) + "::asBinder") {}
+
+  static string GetCppName(const AidlInterface& interface) {
+    return "::android::sp<" + GetRawCppName(interface) + ">";
+  }
+
+  static string GetRawCppName(const AidlInterface& interface) {
+    vector<string> name = interface.GetSplitPackage();
+    string ret;
+
+    name.push_back(interface.GetName());
+
+    for (const auto& term : name) {
+      ret += "::" + term;
+    }
+
+    return ret;
+  }
+
+  static string GetCppHeader(const AidlInterface& interface) {
+    vector<string> name = interface.GetSplitPackage();
+    name.push_back(interface.GetName());
+    return Join(name, '/') + ".h";
+  }
+
+  std::string write_cast_;
+};
+
+class NullableParcelableType : public Type {
+ public:
+  NullableParcelableType(const AidlParcelable& parcelable,
+                         const std::string& src_file_name)
+      : Type(ValidatableType::KIND_PARCELABLE,
+             parcelable.GetPackage(), parcelable.GetName(),
+             {parcelable.GetCppHeader()}, GetCppName(parcelable),
+             "readParcelable", "writeNullableParcelable",
+             kNoArrayType, kNoNullableType,
+             src_file_name, parcelable.GetLine()) {}
+  virtual ~NullableParcelableType() = default;
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  static string GetCppName(const AidlParcelable& parcelable) {
+    return "::std::unique_ptr<::" + Join(parcelable.GetSplitPackage(), "::") +
+        "::" + parcelable.GetName() + ">";
+  }
+};
+
+class ParcelableType : public Type {
+ public:
+  ParcelableType(const AidlParcelable& parcelable,
+                 const std::string& src_file_name)
+      : Type(ValidatableType::KIND_PARCELABLE,
+             parcelable.GetPackage(), parcelable.GetName(),
+             {parcelable.GetCppHeader()}, GetCppName(parcelable),
+             "readParcelable", "writeParcelable",
+             new CppArrayType(
+                 ValidatableType::KIND_PARCELABLE, parcelable.GetPackage(),
+                 parcelable.GetName(), parcelable.GetCppHeader(),
+                 GetCppName(parcelable),
+                 "readParcelableVector", "writeParcelableVector", false,
+                 src_file_name),
+             new NullableParcelableType(parcelable, src_file_name),
+             src_file_name, parcelable.GetLine()) {}
+  virtual ~ParcelableType() = default;
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  static string GetCppName(const AidlParcelable& parcelable) {
+    return "::" + Join(parcelable.GetSplitPackage(), "::") +
+        "::" + parcelable.GetName();
+  }
+};
+
+class NullableStringListType : public Type {
+ public:
+  NullableStringListType()
+      : Type(ValidatableType::KIND_BUILT_IN,
+             "java.util", "List<" + string(kStringCanonicalName) + ">",
+             {"utils/String16.h", "memory", "vector"},
+             "::std::unique_ptr<::std::vector<std::unique_ptr<::android::String16>>>",
+             "readString16Vector", "writeString16Vector") {}
+  virtual ~NullableStringListType() = default;
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NullableStringListType);
+};  // class NullableStringListType
+
+class StringListType : public Type {
+ public:
+  StringListType()
+      : Type(ValidatableType::KIND_BUILT_IN,
+             "java.util", "List<" + string(kStringCanonicalName) + ">",
+             {"utils/String16.h", "vector"},
+             "::std::vector<::android::String16>",
+             "readString16Vector", "writeString16Vector",
+             kNoArrayType, new NullableStringListType()) {}
+  virtual ~StringListType() = default;
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(StringListType);
+};  // class StringListType
+
+class NullableUtf8InCppStringListType : public Type {
+ public:
+  NullableUtf8InCppStringListType()
+      : Type(ValidatableType::KIND_BUILT_IN,
+             "java.util", "List<" + string(kUtf8InCppStringCanonicalName) + ">",
+             {"memory", "string", "vector"},
+             "::std::unique_ptr<::std::vector<std::unique_ptr<::std::string>>>",
+             "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector") {}
+  virtual ~NullableUtf8InCppStringListType() = default;
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NullableUtf8InCppStringListType);
+};  // class NullableUtf8InCppStringListType
+
+class Utf8InCppStringListType : public Type {
+ public:
+  Utf8InCppStringListType()
+      : Type(ValidatableType::KIND_BUILT_IN,
+             "java.util", "List<" + string(kUtf8InCppStringCanonicalName) + ">",
+             {"string", "vector"},
+             "::std::vector<::std::string>",
+             "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector",
+             kNoArrayType, new NullableUtf8InCppStringListType()) {}
+  virtual ~Utf8InCppStringListType() = default;
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(Utf8InCppStringListType);
+};  // class Utf8InCppStringListType
+
+class NullableBinderListType : public Type {
+ public:
+  NullableBinderListType()
+      : Type(ValidatableType::KIND_BUILT_IN, "java.util",
+             "List<android.os.IBinder>", {"binder/IBinder.h", "vector"},
+             "::std::unique_ptr<::std::vector<::android::sp<::android::IBinder>>>",
+             "readStrongBinderVector", "writeStrongBinderVector") {}
+  virtual ~NullableBinderListType() = default;
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(NullableBinderListType);
+};  // class NullableBinderListType
+
+class BinderListType : public Type {
+ public:
+  BinderListType()
+      : Type(ValidatableType::KIND_BUILT_IN, "java.util",
+             "List<android.os.IBinder>", {"binder/IBinder.h", "vector"},
+             "::std::vector<::android::sp<::android::IBinder>>",
+             "readStrongBinderVector", "writeStrongBinderVector",
+             kNoArrayType, new NullableBinderListType()) {}
+  virtual ~BinderListType() = default;
+  bool CanBeOutParameter() const override { return true; }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(BinderListType);
+};  // class BinderListType
+
+}  // namespace
+
+Type::Type(int kind,
+           const std::string& package,
+           const std::string& aidl_type,
+           const vector<string>& headers,
+           const string& cpp_type,
+           const string& read_method,
+           const string& write_method,
+           Type* array_type,
+           Type* nullable_type,
+           const string& src_file_name,
+           int line)
+    : ValidatableType(kind, package, aidl_type, src_file_name, line),
+      headers_(headers),
+      aidl_type_(aidl_type),
+      cpp_type_(cpp_type),
+      parcel_read_method_(read_method),
+      parcel_write_method_(write_method),
+      array_type_(array_type),
+      nullable_type_(nullable_type) {}
+
+bool Type::CanWriteToParcel() const { return true; }
+
+void TypeNamespace::Init() {
+  Add(new ByteType());
+  Add(new PrimitiveType(
+      "int",
+      "cstdint", "int32_t", "readInt32", "writeInt32",
+      "readInt32Vector", "writeInt32Vector"));
+  Add(new PrimitiveType(
+      "long",
+      "cstdint", "int64_t", "readInt64", "writeInt64",
+      "readInt64Vector", "writeInt64Vector"));
+  Add(new PrimitiveType(
+      "float",
+      kNoHeader, "float", "readFloat", "writeFloat",
+      "readFloatVector", "writeFloatVector"));
+  Add(new PrimitiveType(
+      "double",
+      kNoHeader, "double", "readDouble", "writeDouble",
+      "readDoubleVector", "writeDoubleVector"));
+  Add(new PrimitiveType(
+      "boolean",
+      kNoHeader, "bool", "readBool", "writeBool",
+      "readBoolVector", "writeBoolVector"));
+  // C++11 defines the char16_t type as a built in for Unicode characters.
+  Add(new PrimitiveType(
+      "char",
+      kNoHeader, "char16_t", "readChar", "writeChar",
+      "readCharVector", "writeCharVector"));
+
+  Type* string_array_type = new CppArrayType(
+      ValidatableType::KIND_BUILT_IN, "java.lang", "String",
+      "utils/String16.h", "::android::String16",
+      "readString16Vector", "writeString16Vector", false);
+
+  Type* nullable_string_type =
+      new Type(ValidatableType::KIND_BUILT_IN, "java.lang", "String",
+               {"memory", "utils/String16.h"}, "::std::unique_ptr<::android::String16>",
+               "readString16", "writeString16");
+
+  string_type_ = new Type(ValidatableType::KIND_BUILT_IN, "java.lang", "String",
+                          {"utils/String16.h"}, "::android::String16",
+                          "readString16", "writeString16",
+                          string_array_type, nullable_string_type);
+  Add(string_type_);
+
+  using ::android::aidl::kAidlReservedTypePackage;
+  using ::android::aidl::kUtf8InCppStringClass;
+
+  // This type is a Utf16 string in the parcel, but deserializes to
+  // a std::string in Utf8 format when we use it in C++.
+  Type* cpp_utf8_string_array = new CppArrayType(
+      ValidatableType::KIND_BUILT_IN,
+      kAidlReservedTypePackage, kUtf8InCppStringClass,
+      "string", "::std::string",
+      "readUtf8VectorFromUtf16Vector", "writeUtf8VectorAsUtf16Vector",
+      false);
+  Type* nullable_cpp_utf8_string_type = new Type(
+      ValidatableType::KIND_BUILT_IN,
+      kAidlReservedTypePackage, kUtf8InCppStringClass,
+      {"string", "memory"}, "::std::unique_ptr<::std::string>",
+      "readUtf8FromUtf16", "writeUtf8AsUtf16");
+  Add(new Type(
+      ValidatableType::KIND_BUILT_IN,
+      kAidlReservedTypePackage, kUtf8InCppStringClass,
+      {"string"}, "::std::string", "readUtf8FromUtf16", "writeUtf8AsUtf16",
+      cpp_utf8_string_array, nullable_cpp_utf8_string_type));
+
+  Type* nullable_ibinder = new Type(
+      ValidatableType::KIND_BUILT_IN, "android.os", "IBinder",
+      {"binder/IBinder.h"}, "::android::sp<::android::IBinder>",
+      "readNullableStrongBinder", "writeStrongBinder");
+  ibinder_type_ = new Type(
+      ValidatableType::KIND_BUILT_IN, "android.os", "IBinder",
+      {"binder/IBinder.h"}, "::android::sp<::android::IBinder>",
+      "readStrongBinder", "writeStrongBinder",
+      kNoArrayType, nullable_ibinder);
+  Add(ibinder_type_);
+
+  Add(new BinderListType());
+  Add(new StringListType());
+  Add(new Utf8InCppStringListType());
+
+  Type* fd_vector_type = new CppArrayType(
+      ValidatableType::KIND_BUILT_IN, kNoPackage, "FileDescriptor",
+      "android-base/unique_fd.h",
+      "::android::base::unique_fd",
+      "readUniqueFileDescriptorVector", "writeUniqueFileDescriptorVector",
+      false);
+
+  Add(new Type(
+      ValidatableType::KIND_BUILT_IN, kNoPackage, "FileDescriptor",
+      {"android-base/unique_fd.h"}, "::android::base::unique_fd",
+      "readUniqueFileDescriptor", "writeUniqueFileDescriptor",
+      fd_vector_type));
+
+  void_type_ = new class VoidType();
+  Add(void_type_);
+}
+
+bool TypeNamespace::AddParcelableType(const AidlParcelable& p,
+                                      const string& filename) {
+  if (p.GetCppHeader().empty()) {
+    LOG(ERROR) << "Parcelable " << p.GetCanonicalName()
+               << " has no C++ header defined.";
+    return false;
+  }
+  Add(new ParcelableType(p, filename));
+  return true;
+}
+
+bool TypeNamespace::AddBinderType(const AidlInterface& b,
+                                  const string& file_name) {
+  Add(new BinderType(b, file_name));
+  return true;
+}
+
+bool TypeNamespace::AddListType(const std::string& type_name) {
+  const Type* contained_type = FindTypeByCanonicalName(type_name);
+  if (!contained_type) {
+    LOG(ERROR) << "Cannot create List<" << type_name << "> because contained "
+                  "type cannot be found or is invalid.";
+    return false;
+  }
+  if (contained_type->IsCppPrimitive()) {
+    LOG(ERROR) << "Cannot create List<" << type_name << "> because contained "
+                  "type is a primitive in Java and Java List cannot hold "
+                  "primitives.";
+    return false;
+  }
+
+  if (contained_type->CanonicalName() == kStringCanonicalName ||
+      contained_type->CanonicalName() == kUtf8InCppStringCanonicalName ||
+      contained_type == IBinderType()) {
+    return true;
+  }
+
+  // TODO Support lists of parcelables b/23600712
+
+  LOG(ERROR) << "aidl-cpp does not yet support List<" << type_name << ">";
+  return false;
+}
+
+bool TypeNamespace::AddMapType(const std::string& /* key_type_name */,
+                               const std::string& /* value_type_name */) {
+  // TODO Support list types b/25242025
+  LOG(ERROR) << "aidl does not implement support for typed maps!";
+  return false;
+}
+
+bool TypeNamespace::IsValidPackage(const string& package) const {
+  if (package.empty()) {
+    return false;
+  }
+
+  auto pieces = Split(package, ".");
+  for (const string& piece : pieces) {
+    if (is_cpp_keyword(piece)) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+const ValidatableType* TypeNamespace::GetArgType(const AidlArgument& a,
+    int arg_index,
+    const std::string& filename,
+    const AidlInterface& interface) const {
+  const string error_prefix = StringPrintf(
+      "In file %s line %d parameter %s (%d):\n    ",
+      filename.c_str(), a.GetLine(), a.GetName().c_str(), arg_index);
+
+  // check that the name doesn't match a keyword
+  if (is_cpp_keyword(a.GetName().c_str())) {
+    cerr << error_prefix << "Argument name is a C++ keyword"
+         << endl;
+    return nullptr;
+  }
+
+  return ::android::aidl::TypeNamespace::GetArgType(a, arg_index, filename,
+                                                    interface);
+}
+
+}  // namespace cpp
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/type_cpp.h b/aidl/type_cpp.h
new file mode 100644
index 0000000..0a6a4a9
--- /dev/null
+++ b/aidl/type_cpp.h
@@ -0,0 +1,125 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_TYPE_CPP_H_
+#define AIDL_TYPE_CPP_H_
+
+#include <memory>
+#include <string>
+#include <set>
+#include <vector>
+
+#include <android-base/macros.h>
+
+#include "type_namespace.h"
+
+namespace android {
+namespace aidl {
+namespace cpp {
+
+class Type : public ValidatableType {
+ public:
+  Type(int kind,  // from ValidatableType
+       const std::string& package,
+       const std::string& aidl_type,
+       const std::vector<std::string>& header,
+       const std::string& cpp_type,
+       const std::string& read_method,
+       const std::string& write_method,
+       Type* array_type = nullptr,
+       Type* nullable_type = nullptr,
+       const std::string& src_file_name = "",
+       int line = -1);
+  virtual ~Type() = default;
+
+  // overrides of ValidatableType
+  bool CanBeOutParameter() const override { return false; }
+  bool CanWriteToParcel() const override;
+
+  const Type* ArrayType() const override { return array_type_.get(); }
+  const Type* NullableType() const override { return nullable_type_.get(); }
+  std::string CppType() const { return cpp_type_; }
+  const std::string& ReadFromParcelMethod() const {
+    return parcel_read_method_;
+  }
+  const std::string& WriteToParcelMethod() const {
+    return parcel_write_method_;
+  }
+
+  void GetHeaders(std::set<std::string>* headers) const {
+    for (const std::string& header : headers_) {
+      if (!header.empty()) {
+        headers->insert(header);
+      }
+    }
+  }
+  virtual bool IsCppPrimitive() const { return false; }
+  virtual std::string WriteCast(const std::string& value) const {
+    return value;
+  }
+
+ private:
+  // |headers| are the headers we must include to use this type
+  const std::vector<std::string> headers_;
+  // |aidl_type| is what we find in the yacc generated AST (e.g. "int").
+  const std::string aidl_type_;
+  // |cpp_type| is what we use in the generated C++ code (e.g. "int32_t").
+  const std::string cpp_type_;
+  const std::string parcel_read_method_;
+  const std::string parcel_write_method_;
+
+  const std::unique_ptr<Type> array_type_;
+  const std::unique_ptr<Type> nullable_type_;
+
+  DISALLOW_COPY_AND_ASSIGN(Type);
+};  // class Type
+
+class TypeNamespace : public ::android::aidl::LanguageTypeNamespace<Type> {
+ public:
+  TypeNamespace() = default;
+  virtual ~TypeNamespace() = default;
+
+  void Init() override;
+  bool AddParcelableType(const AidlParcelable& p,
+                         const std::string& filename) override;
+  bool AddBinderType(const AidlInterface& b,
+                     const std::string& filename) override;
+  bool AddListType(const std::string& type_name) override;
+  bool AddMapType(const std::string& key_type_name,
+                  const std::string& value_type_name) override;
+
+  bool IsValidPackage(const std::string& package) const override;
+  const ValidatableType* GetArgType(const AidlArgument& a,
+                             int arg_index,
+                             const std::string& filename,
+                             const AidlInterface& interface) const override;
+
+  const Type* VoidType() const { return void_type_; }
+  const Type* IBinderType() const { return ibinder_type_; }
+
+ private:
+  Type* void_type_ = nullptr;
+  Type* string_type_ = nullptr;
+  Type* ibinder_type_ = nullptr;
+
+  DISALLOW_COPY_AND_ASSIGN(TypeNamespace);
+};  // class TypeNamespace
+
+}  // namespace cpp
+}  // namespace aidl
+}  // namespace android
+
+#endif  // AIDL_TYPE_NAMESPACE_CPP_H_
diff --git a/aidl/type_cpp_unittest.cpp b/aidl/type_cpp_unittest.cpp
new file mode 100644
index 0000000..35fc3d5
--- /dev/null
+++ b/aidl/type_cpp_unittest.cpp
@@ -0,0 +1,53 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <memory>
+
+#include <gtest/gtest.h>
+
+#include "type_cpp.h"
+
+namespace android {
+namespace aidl {
+namespace cpp {
+
+class CppTypeNamespaceTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    types_.Init();
+  }
+  TypeNamespace types_;
+};
+
+TEST_F(CppTypeNamespaceTest, HasSomeBasicTypes) {
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("byte"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("int"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("long"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("float"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("double"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("boolean"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("char"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("String"));
+}
+
+TEST_F(CppTypeNamespaceTest, SupportsListString) {
+  EXPECT_TRUE(
+      types_.HasTypeByCanonicalName("java.util.List<java.lang.String>"));
+}
+
+}  // namespace cpp
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/type_java.cpp b/aidl/type_java.cpp
new file mode 100644
index 0000000..18d27a2
--- /dev/null
+++ b/aidl/type_java.cpp
@@ -0,0 +1,908 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "type_java.h"
+
+#include <sys/types.h>
+
+#include <android-base/strings.h>
+
+#include "aidl_language.h"
+#include "logging.h"
+
+using std::string;
+using android::base::Split;
+using android::base::Join;
+using android::base::Trim;
+
+namespace android {
+namespace aidl {
+namespace java {
+
+Expression* NULL_VALUE;
+Expression* THIS_VALUE;
+Expression* SUPER_VALUE;
+Expression* TRUE_VALUE;
+Expression* FALSE_VALUE;
+
+// ================================================================
+
+Type::Type(const JavaTypeNamespace* types, const string& name, int kind,
+           bool canWriteToParcel, bool canBeOut)
+    : Type(types, "", name, kind, canWriteToParcel, canBeOut, "", -1) {}
+
+Type::Type(const JavaTypeNamespace* types, const string& package,
+           const string& name, int kind, bool canWriteToParcel,
+           bool canBeOut, const string& declFile, int declLine)
+    : ValidatableType(kind, package, name, declFile, declLine),
+      m_types(types),
+      m_javaType((package.empty()) ? name : package + "." + name),
+      m_canWriteToParcel(canWriteToParcel),
+      m_canBeOut(canBeOut) {
+}
+
+string Type::CreatorName() const { return ""; }
+
+string Type::InstantiableName() const { return JavaType(); }
+
+void Type::WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                         int flags) const {
+  fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%sn", __FILE__,
+          __LINE__, m_javaType.c_str());
+  addTo->Add(new LiteralExpression("/* WriteToParcel error " + m_javaType +
+                                   " */"));
+}
+
+void Type::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                            Variable* parcel, Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n", __FILE__,
+          __LINE__, m_javaType.c_str());
+  addTo->Add(new LiteralExpression("/* CreateFromParcel error " +
+                                   m_javaType + " */"));
+}
+
+void Type::ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                          Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d qualifiedName=%s\n", __FILE__,
+          __LINE__, m_javaType.c_str());
+  addTo->Add(new LiteralExpression("/* ReadFromParcel error " +
+                                   m_javaType + " */"));
+}
+
+Expression* Type::BuildWriteToParcelFlags(int flags) const {
+  if (flags == 0) {
+    return new LiteralExpression("0");
+  }
+  if ((flags & PARCELABLE_WRITE_RETURN_VALUE) != 0) {
+    return new FieldVariable(m_types->ParcelableInterfaceType(),
+                             "PARCELABLE_WRITE_RETURN_VALUE");
+  }
+  return new LiteralExpression("0");
+}
+
+// ================================================================
+
+BasicType::BasicType(const JavaTypeNamespace* types, const string& name,
+                     const string& marshallParcel,
+                     const string& unmarshallParcel,
+                     const string& writeArrayParcel,
+                     const string& createArrayParcel,
+                     const string& readArrayParcel)
+    : Type(types, name, ValidatableType::KIND_BUILT_IN, true, false),
+      m_marshallParcel(marshallParcel),
+      m_unmarshallParcel(unmarshallParcel) {
+  m_array_type.reset(new BasicArrayType(types, name, writeArrayParcel,
+                                        createArrayParcel, readArrayParcel));
+}
+
+void BasicType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                              Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, m_marshallParcel, 1, v));
+}
+
+void BasicType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                 Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, m_unmarshallParcel)));
+}
+
+BasicArrayType::BasicArrayType(const JavaTypeNamespace* types,
+                               const string& name,
+                               const string& writeArrayParcel,
+                               const string& createArrayParcel,
+                               const string& readArrayParcel)
+    : Type(types, name, ValidatableType::KIND_BUILT_IN, true, true),
+      m_writeArrayParcel(writeArrayParcel),
+      m_createArrayParcel(createArrayParcel),
+      m_readArrayParcel(readArrayParcel) {}
+
+
+void BasicArrayType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                   Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, m_writeArrayParcel, 1, v));
+}
+
+void BasicArrayType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                      Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, m_createArrayParcel)));
+}
+
+void BasicArrayType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                    Variable* parcel, Variable**) const {
+  addTo->Add(new MethodCall(parcel, m_readArrayParcel, 1, v));
+}
+
+// ================================================================
+
+FileDescriptorType::FileDescriptorType(const JavaTypeNamespace* types)
+    : Type(types, "java.io", "FileDescriptor", ValidatableType::KIND_BUILT_IN,
+           true, false) {
+    m_array_type.reset(new FileDescriptorArrayType(types));
+}
+
+void FileDescriptorType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                       Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeRawFileDescriptor", 1, v));
+}
+
+void FileDescriptorType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                          Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "readRawFileDescriptor")));
+}
+
+FileDescriptorArrayType::FileDescriptorArrayType(const JavaTypeNamespace* types)
+    : Type(types, "java.io", "FileDescriptor", ValidatableType::KIND_BUILT_IN,
+           true, true) {}
+
+void FileDescriptorArrayType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                            Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeRawFileDescriptorArray", 1, v));
+}
+
+void FileDescriptorArrayType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                               Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "createRawFileDescriptorArray")));
+}
+
+void FileDescriptorArrayType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                             Variable* parcel, Variable**) const {
+  addTo->Add(new MethodCall(parcel, "readRawFileDescriptorArray", 1, v));
+}
+
+// ================================================================
+
+BooleanType::BooleanType(const JavaTypeNamespace* types)
+    : Type(types, "boolean", ValidatableType::KIND_BUILT_IN, true, false) {
+    m_array_type.reset(new BooleanArrayType(types));
+}
+
+void BooleanType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(
+      parcel, "writeInt", 1,
+      new Ternary(v, new LiteralExpression("1"), new LiteralExpression("0"))));
+}
+
+void BooleanType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                   Variable* parcel, Variable**) const {
+  addTo->Add(
+      new Assignment(v, new Comparison(new LiteralExpression("0"), "!=",
+                                       new MethodCall(parcel, "readInt"))));
+}
+
+BooleanArrayType::BooleanArrayType(const JavaTypeNamespace* types)
+    : Type(types, "boolean", ValidatableType::KIND_BUILT_IN, true, true) {}
+
+void BooleanArrayType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                     Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeBooleanArray", 1, v));
+}
+
+void BooleanArrayType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                        Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "createBooleanArray")));
+}
+
+void BooleanArrayType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                      Variable* parcel, Variable**) const {
+  addTo->Add(new MethodCall(parcel, "readBooleanArray", 1, v));
+}
+
+// ================================================================
+
+CharType::CharType(const JavaTypeNamespace* types)
+    : Type(types, "char", ValidatableType::KIND_BUILT_IN, true, false) {
+    m_array_type.reset(new CharArrayType(types));
+}
+
+void CharType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                             Variable* parcel, int flags) const {
+  addTo->Add(
+      new MethodCall(parcel, "writeInt", 1, new Cast(m_types->IntType(), v)));
+}
+
+void CharType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "readInt"), this));
+}
+
+CharArrayType::CharArrayType(const JavaTypeNamespace* types)
+    : Type(types, "char", ValidatableType::KIND_BUILT_IN, true, true) {}
+
+void CharArrayType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                  Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeCharArray", 1, v));
+}
+
+void CharArrayType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                     Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "createCharArray")));
+}
+
+void CharArrayType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                   Variable* parcel, Variable**) const {
+  addTo->Add(new MethodCall(parcel, "readCharArray", 1, v));
+}
+
+// ================================================================
+
+StringType::StringType(const JavaTypeNamespace* types,
+                       const std::string& package,
+                       const std::string& class_name)
+    : Type(types, package, class_name,
+           ValidatableType::KIND_BUILT_IN, true, false) {
+  m_array_type.reset(new StringArrayType(types));
+}
+
+string StringType::CreatorName() const {
+  return "android.os.Parcel.STRING_CREATOR";
+}
+
+void StringType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                               Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeString", 1, v));
+}
+
+void StringType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                  Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "readString")));
+}
+
+StringArrayType::StringArrayType(const JavaTypeNamespace* types)
+    : Type(types, "java.lang", "String", ValidatableType::KIND_BUILT_IN,
+           true, true) {}
+
+string StringArrayType::CreatorName() const {
+  return "android.os.Parcel.STRING_CREATOR";
+}
+
+void StringArrayType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                    Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeStringArray", 1, v));
+}
+
+void StringArrayType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                       Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "createStringArray")));
+}
+
+void StringArrayType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                     Variable* parcel, Variable**) const {
+  addTo->Add(new MethodCall(parcel, "readStringArray", 1, v));
+}
+
+// ================================================================
+
+CharSequenceType::CharSequenceType(const JavaTypeNamespace* types)
+    : Type(types, "java.lang", "CharSequence", ValidatableType::KIND_BUILT_IN,
+           true, false) {}
+
+string CharSequenceType::CreatorName() const {
+  return "android.os.Parcel.STRING_CREATOR";
+}
+
+void CharSequenceType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                     Variable* parcel, int flags) const {
+  // if (v != null) {
+  //     parcel.writeInt(1);
+  //     v.writeToParcel(parcel);
+  // } else {
+  //     parcel.writeInt(0);
+  // }
+  IfStatement* elsepart = new IfStatement();
+  elsepart->statements->Add(
+      new MethodCall(parcel, "writeInt", 1, new LiteralExpression("0")));
+  IfStatement* ifpart = new IfStatement;
+  ifpart->expression = new Comparison(v, "!=", NULL_VALUE);
+  ifpart->elseif = elsepart;
+  ifpart->statements->Add(
+      new MethodCall(parcel, "writeInt", 1, new LiteralExpression("1")));
+  ifpart->statements->Add(new MethodCall(m_types->TextUtilsType(),
+                                         "writeToParcel", 3, v, parcel,
+                                         BuildWriteToParcelFlags(flags)));
+
+  addTo->Add(ifpart);
+}
+
+void CharSequenceType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                        Variable* parcel, Variable**) const {
+  // if (0 != parcel.readInt()) {
+  //     v = TextUtils.createFromParcel(parcel)
+  // } else {
+  //     v = null;
+  // }
+  IfStatement* elsepart = new IfStatement();
+  elsepart->statements->Add(new Assignment(v, NULL_VALUE));
+
+  IfStatement* ifpart = new IfStatement();
+  ifpart->expression = new Comparison(new LiteralExpression("0"), "!=",
+                                      new MethodCall(parcel, "readInt"));
+  ifpart->elseif = elsepart;
+  ifpart->statements->Add(new Assignment(
+      v, new MethodCall(m_types->TextUtilsType(),
+                        "CHAR_SEQUENCE_CREATOR.createFromParcel", 1, parcel)));
+
+  addTo->Add(ifpart);
+}
+
+// ================================================================
+
+RemoteExceptionType::RemoteExceptionType(const JavaTypeNamespace* types)
+    : Type(types, "android.os", "RemoteException",
+           ValidatableType::KIND_BUILT_IN, false, false) {}
+
+void RemoteExceptionType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                        Variable* parcel, int flags) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+void RemoteExceptionType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                           Variable* parcel, Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+// ================================================================
+
+RuntimeExceptionType::RuntimeExceptionType(const JavaTypeNamespace* types)
+    : Type(types, "java.lang", "RuntimeException",
+           ValidatableType::KIND_BUILT_IN, false, false) {}
+
+void RuntimeExceptionType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                         Variable* parcel, int flags) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+void RuntimeExceptionType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                            Variable* parcel,
+                                            Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+// ================================================================
+
+IBinderType::IBinderType(const JavaTypeNamespace* types)
+    : Type(types, "android.os", "IBinder", ValidatableType::KIND_BUILT_IN,
+           true, false) {
+  m_array_type.reset(new IBinderArrayType(types));
+}
+
+void IBinderType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeStrongBinder", 1, v));
+}
+
+void IBinderType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                   Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "readStrongBinder")));
+}
+
+IBinderArrayType::IBinderArrayType(const JavaTypeNamespace* types)
+    : Type(types, "android.os", "IBinder", ValidatableType::KIND_BUILT_IN,
+           true, true) {}
+
+void IBinderArrayType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                     Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeBinderArray", 1, v));
+}
+
+void IBinderArrayType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                        Variable* parcel, Variable**) const {
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "createBinderArray")));
+}
+
+void IBinderArrayType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                      Variable* parcel, Variable**) const {
+  addTo->Add(new MethodCall(parcel, "readBinderArray", 1, v));
+}
+
+// ================================================================
+
+IInterfaceType::IInterfaceType(const JavaTypeNamespace* types)
+    : Type(types, "android.os", "IInterface", ValidatableType::KIND_BUILT_IN,
+           false, false) {}
+
+void IInterfaceType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                   Variable* parcel, int flags) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+void IInterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                      Variable* parcel, Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+// ================================================================
+
+BinderType::BinderType(const JavaTypeNamespace* types)
+    : Type(types, "android.os", "Binder", ValidatableType::KIND_BUILT_IN,
+           false, false) {}
+
+void BinderType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                               Variable* parcel, int flags) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+void BinderType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                  Variable* parcel, Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+// ================================================================
+
+BinderProxyType::BinderProxyType(const JavaTypeNamespace* types)
+    : Type(types, "android.os", "BinderProxy", ValidatableType::KIND_BUILT_IN,
+           false, false) {}
+
+void BinderProxyType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                    Variable* parcel, int flags) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+void BinderProxyType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                       Variable* parcel, Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+// ================================================================
+
+ParcelType::ParcelType(const JavaTypeNamespace* types)
+    : Type(types, "android.os", "Parcel", ValidatableType::KIND_BUILT_IN,
+           false, false) {}
+
+void ParcelType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                               Variable* parcel, int flags) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+void ParcelType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                  Variable* parcel, Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+// ================================================================
+
+ParcelableInterfaceType::ParcelableInterfaceType(const JavaTypeNamespace* types)
+    : Type(types, "android.os", "Parcelable", ValidatableType::KIND_BUILT_IN,
+           false, false) {}
+
+void ParcelableInterfaceType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                            Variable* parcel, int flags) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+void ParcelableInterfaceType::CreateFromParcel(StatementBlock* addTo,
+                                               Variable* v, Variable* parcel,
+                                               Variable**) const {
+  fprintf(stderr, "aidl:internal error %s:%d\n", __FILE__, __LINE__);
+}
+
+// ================================================================
+
+MapType::MapType(const JavaTypeNamespace* types)
+    : Type(types, "java.util", "Map", ValidatableType::KIND_BUILT_IN,
+           true, true) {}
+
+void MapType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                            Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeMap", 1, v));
+}
+
+static void EnsureClassLoader(StatementBlock* addTo, Variable** cl,
+                              const JavaTypeNamespace* types) {
+  // We don't want to look up the class loader once for every
+  // collection argument, so ensure we do it at most once per method.
+  if (*cl == NULL) {
+    *cl = new Variable(types->ClassLoaderType(), "cl");
+    addTo->Add(new VariableDeclaration(
+        *cl, new LiteralExpression("this.getClass().getClassLoader()"),
+        types->ClassLoaderType()));
+  }
+}
+
+void MapType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                               Variable* parcel, Variable** cl) const {
+  EnsureClassLoader(addTo, cl, m_types);
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "readHashMap", 1, *cl)));
+}
+
+void MapType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                             Variable* parcel, Variable** cl) const {
+  EnsureClassLoader(addTo, cl, m_types);
+  addTo->Add(new MethodCall(parcel, "readMap", 2, v, *cl));
+}
+
+// ================================================================
+
+ListType::ListType(const JavaTypeNamespace* types)
+    : Type(types, "java.util", "List", ValidatableType::KIND_BUILT_IN,
+           true, true) {}
+
+string ListType::InstantiableName() const { return "java.util.ArrayList"; }
+
+void ListType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                             Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeList", 1, v));
+}
+
+void ListType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                Variable* parcel, Variable** cl) const {
+  EnsureClassLoader(addTo, cl, m_types);
+  addTo->Add(
+      new Assignment(v, new MethodCall(parcel, "readArrayList", 1, *cl)));
+}
+
+void ListType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                              Variable* parcel, Variable** cl) const {
+  EnsureClassLoader(addTo, cl, m_types);
+  addTo->Add(new MethodCall(parcel, "readList", 2, v, *cl));
+}
+
+// ================================================================
+
+UserDataType::UserDataType(const JavaTypeNamespace* types,
+                           const string& package, const string& name,
+                           bool builtIn, bool canWriteToParcel,
+                           const string& declFile, int declLine)
+    : Type(types, package, name,
+           builtIn ? ValidatableType::KIND_BUILT_IN
+                   : ValidatableType::KIND_PARCELABLE,
+           canWriteToParcel, true, declFile, declLine) {
+  m_array_type.reset(new UserDataArrayType(types, package, name, builtIn,
+                                           canWriteToParcel, declFile,
+                                           declLine));
+}
+
+string UserDataType::CreatorName() const {
+  return JavaType() + ".CREATOR";
+}
+
+void UserDataType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                 Variable* parcel, int flags) const {
+  // if (v != null) {
+  //     parcel.writeInt(1);
+  //     v.writeToParcel(parcel);
+  // } else {
+  //     parcel.writeInt(0);
+  // }
+  IfStatement* elsepart = new IfStatement();
+  elsepart->statements->Add(
+      new MethodCall(parcel, "writeInt", 1, new LiteralExpression("0")));
+  IfStatement* ifpart = new IfStatement;
+  ifpart->expression = new Comparison(v, "!=", NULL_VALUE);
+  ifpart->elseif = elsepart;
+  ifpart->statements->Add(
+      new MethodCall(parcel, "writeInt", 1, new LiteralExpression("1")));
+  ifpart->statements->Add(new MethodCall(v, "writeToParcel", 2, parcel,
+                                         BuildWriteToParcelFlags(flags)));
+
+  addTo->Add(ifpart);
+}
+
+void UserDataType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                    Variable* parcel, Variable**) const {
+  // if (0 != parcel.readInt()) {
+  //     v = CLASS.CREATOR.createFromParcel(parcel)
+  // } else {
+  //     v = null;
+  // }
+  IfStatement* elsepart = new IfStatement();
+  elsepart->statements->Add(new Assignment(v, NULL_VALUE));
+
+  IfStatement* ifpart = new IfStatement();
+  ifpart->expression = new Comparison(new LiteralExpression("0"), "!=",
+                                      new MethodCall(parcel, "readInt"));
+  ifpart->elseif = elsepart;
+  ifpart->statements->Add(new Assignment(
+      v, new MethodCall(v->type, "CREATOR.createFromParcel", 1, parcel)));
+
+  addTo->Add(ifpart);
+}
+
+void UserDataType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                  Variable* parcel, Variable**) const {
+  // TODO: really, we don't need to have this extra check, but we
+  // don't have two separate marshalling code paths
+  // if (0 != parcel.readInt()) {
+  //     v.readFromParcel(parcel)
+  // }
+  IfStatement* ifpart = new IfStatement();
+  ifpart->expression = new Comparison(new LiteralExpression("0"), "!=",
+                                      new MethodCall(parcel, "readInt"));
+  ifpart->statements->Add(new MethodCall(v, "readFromParcel", 1, parcel));
+  addTo->Add(ifpart);
+}
+
+UserDataArrayType::UserDataArrayType(const JavaTypeNamespace* types,
+                           const string& package, const string& name,
+                           bool builtIn, bool canWriteToParcel,
+                           const string& declFile, int declLine)
+    : Type(types, package, name,
+           builtIn ? ValidatableType::KIND_BUILT_IN
+                   : ValidatableType::KIND_PARCELABLE,
+           canWriteToParcel, true, declFile, declLine) {}
+
+string UserDataArrayType::CreatorName() const {
+  return JavaType() + ".CREATOR";
+}
+
+void UserDataArrayType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                      Variable* parcel, int flags) const {
+  addTo->Add(new MethodCall(parcel, "writeTypedArray", 2, v,
+                            BuildWriteToParcelFlags(flags)));
+}
+
+void UserDataArrayType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                         Variable* parcel, Variable**) const {
+  string creator = v->type->JavaType() + ".CREATOR";
+  addTo->Add(new Assignment(v, new MethodCall(parcel, "createTypedArray", 1,
+                                              new LiteralExpression(creator))));
+}
+
+void UserDataArrayType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                       Variable* parcel, Variable**) const {
+  string creator = v->type->JavaType() + ".CREATOR";
+  addTo->Add(new MethodCall(parcel, "readTypedArray", 2, v,
+                            new LiteralExpression(creator)));
+}
+
+// ================================================================
+
+InterfaceType::InterfaceType(const JavaTypeNamespace* types,
+                             const string& package, const string& name,
+                             bool builtIn, bool oneway, const string& declFile,
+                             int declLine, const Type* stub, const Type* proxy)
+    : Type(types, package, name, builtIn ? ValidatableType::KIND_BUILT_IN
+                                         : ValidatableType::KIND_INTERFACE,
+           true, false, declFile, declLine),
+      m_oneway(oneway),
+      stub_(stub),
+      proxy_(proxy) {}
+
+bool InterfaceType::OneWay() const { return m_oneway; }
+
+void InterfaceType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                  Variable* parcel, int flags) const {
+  // parcel.writeStrongBinder(v != null ? v.asBinder() : null);
+  addTo->Add(
+      new MethodCall(parcel, "writeStrongBinder", 1,
+                     new Ternary(new Comparison(v, "!=", NULL_VALUE),
+                                 new MethodCall(v, "asBinder"), NULL_VALUE)));
+}
+
+void InterfaceType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                     Variable* parcel, Variable**) const {
+  // v = Interface.asInterface(parcel.readStrongBinder());
+  addTo->Add(new Assignment(
+      v, new MethodCall(stub_, "asInterface", 1,
+                        new MethodCall(parcel, "readStrongBinder"))));
+}
+
+// ================================================================
+
+GenericListType::GenericListType(const JavaTypeNamespace* types,
+                                 const Type* contained_type)
+    : Type(types, "java.util", "List<" + contained_type->CanonicalName() + ">",
+           ValidatableType::KIND_BUILT_IN, true, true),
+      m_contained_type(contained_type),
+      m_creator(contained_type->CreatorName()) {}
+
+string GenericListType::CreatorName() const {
+  return "android.os.Parcel.arrayListCreator";
+}
+
+string GenericListType::InstantiableName() const {
+  return "java.util.ArrayList<" + m_contained_type->JavaType() + ">";
+}
+
+void GenericListType::WriteToParcel(StatementBlock* addTo, Variable* v,
+                                    Variable* parcel, int flags) const {
+  if (m_creator == m_types->StringType()->CreatorName()) {
+    addTo->Add(new MethodCall(parcel, "writeStringList", 1, v));
+  } else if (m_creator == m_types->IBinderType()->CreatorName()) {
+    addTo->Add(new MethodCall(parcel, "writeBinderList", 1, v));
+  } else {
+    // parcel.writeTypedListXX(arg);
+    addTo->Add(new MethodCall(parcel, "writeTypedList", 1, v));
+  }
+}
+
+void GenericListType::CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                       Variable* parcel, Variable**) const {
+  if (m_creator == m_types->StringType()->CreatorName()) {
+    addTo->Add(
+        new Assignment(v, new MethodCall(parcel, "createStringArrayList", 0)));
+  } else if (m_creator == m_types->IBinderType()->CreatorName()) {
+    addTo->Add(
+        new Assignment(v, new MethodCall(parcel, "createBinderArrayList", 0)));
+  } else {
+    // v = _data.readTypedArrayList(XXX.creator);
+    addTo->Add(
+        new Assignment(v, new MethodCall(parcel, "createTypedArrayList", 1,
+                                         new LiteralExpression(m_creator))));
+  }
+}
+
+void GenericListType::ReadFromParcel(StatementBlock* addTo, Variable* v,
+                                     Variable* parcel, Variable**) const {
+  if (m_creator == m_types->StringType()->CreatorName()) {
+    addTo->Add(new MethodCall(parcel, "readStringList", 1, v));
+  } else if (m_creator == m_types->IBinderType()->CreatorName()) {
+    addTo->Add(new MethodCall(parcel, "readBinderList", 1, v));
+  } else {
+    // v = _data.readTypedList(v, XXX.creator);
+    addTo->Add(new MethodCall(parcel, "readTypedList", 2, v,
+                              new LiteralExpression(m_creator)));
+  }
+}
+
+// ================================================================
+
+ClassLoaderType::ClassLoaderType(const JavaTypeNamespace* types)
+    : Type(types, "java.lang", "ClassLoader", ValidatableType::KIND_BUILT_IN,
+           false, false) {}
+
+// ================================================================
+
+void JavaTypeNamespace::Init() {
+  Add(new BasicType(this, "void", "XXX", "XXX", "XXX", "XXX", "XXX"));
+
+  m_bool_type = new BooleanType(this);
+  Add(m_bool_type);
+
+  Add(new BasicType(this, "byte", "writeByte", "readByte", "writeByteArray",
+                    "createByteArray", "readByteArray"));
+
+  Add(new CharType(this));
+
+  m_int_type = new BasicType(this, "int", "writeInt", "readInt",
+                             "writeIntArray", "createIntArray", "readIntArray");
+  Add(m_int_type);
+
+  Add(new BasicType(this, "long", "writeLong", "readLong", "writeLongArray",
+                    "createLongArray", "readLongArray"));
+
+  Add(new BasicType(this, "float", "writeFloat", "readFloat", "writeFloatArray",
+                    "createFloatArray", "readFloatArray"));
+
+  Add(new BasicType(this, "double", "writeDouble", "readDouble",
+                    "writeDoubleArray", "createDoubleArray",
+                    "readDoubleArray"));
+
+  m_string_type = new class StringType(this, "java.lang", "String");
+  Add(m_string_type);
+  Add(new class StringType(this, ::android::aidl::kAidlReservedTypePackage,
+                           ::android::aidl::kUtf8InCppStringClass));
+
+  Add(new Type(this, "java.lang", "Object", ValidatableType::KIND_BUILT_IN,
+               false, false));
+
+  Add(new FileDescriptorType(this));
+
+  Add(new CharSequenceType(this));
+
+  Add(new MapType(this));
+
+  Add(new ListType(this));
+
+  m_text_utils_type =
+      new Type(this, "android.text", "TextUtils",
+               ValidatableType::KIND_BUILT_IN, false, false);
+  Add(m_text_utils_type);
+
+  m_remote_exception_type = new class RemoteExceptionType(this);
+  Add(m_remote_exception_type);
+
+  m_runtime_exception_type = new class RuntimeExceptionType(this);
+  Add(m_runtime_exception_type);
+
+  m_ibinder_type = new class IBinderType(this);
+  Add(m_ibinder_type);
+
+  m_iinterface_type = new class IInterfaceType(this);
+  Add(m_iinterface_type);
+
+  m_binder_native_type = new class BinderType(this);
+  Add(m_binder_native_type);
+
+  m_binder_proxy_type = new class BinderProxyType(this);
+  Add(m_binder_proxy_type);
+
+  m_parcel_type = new class ParcelType(this);
+  Add(m_parcel_type);
+
+  m_parcelable_interface_type = new class ParcelableInterfaceType(this);
+  Add(m_parcelable_interface_type);
+
+  m_context_type = new class Type(this, "android.content", "Context",
+                                  ValidatableType::KIND_BUILT_IN, false, false);
+  Add(m_context_type);
+
+  m_classloader_type = new class ClassLoaderType(this);
+  Add(m_classloader_type);
+
+  NULL_VALUE = new LiteralExpression("null");
+  THIS_VALUE = new LiteralExpression("this");
+  SUPER_VALUE = new LiteralExpression("super");
+  TRUE_VALUE = new LiteralExpression("true");
+  FALSE_VALUE = new LiteralExpression("false");
+}
+
+bool JavaTypeNamespace::AddParcelableType(const AidlParcelable& p,
+                                          const std::string& filename) {
+  Type* type =
+      new UserDataType(this, p.GetPackage(), p.GetName(), false,
+                       true, filename, p.GetLine());
+  return Add(type);
+}
+
+bool JavaTypeNamespace::AddBinderType(const AidlInterface& b,
+                                      const std::string& filename) {
+  // for interfaces, add the stub, proxy, and interface types.
+  Type* stub = new Type(this, b.GetPackage(),
+                        b.GetName() + ".Stub", ValidatableType::KIND_GENERATED,
+                        false, false, filename, b.GetLine());
+  Type* proxy = new Type(this, b.GetPackage(),
+                         b.GetName() + ".Stub.Proxy",
+                         ValidatableType::KIND_GENERATED,
+                         false, false, filename, b.GetLine());
+  Type* type =
+      new InterfaceType(this, b.GetPackage(), b.GetName(), false,
+                        b.IsOneway(), filename, b.GetLine(), stub, proxy);
+
+  bool success = true;
+  success &= Add(type);
+  success &= Add(stub);
+  success &= Add(proxy);
+  return success;
+}
+
+bool JavaTypeNamespace::AddListType(const std::string& contained_type_name) {
+  const Type* contained_type = FindTypeByCanonicalName(contained_type_name);
+  if (!contained_type) {
+    return false;
+  }
+  Add(new GenericListType(this, contained_type));
+  return true;
+}
+
+bool JavaTypeNamespace::AddMapType(const string& key_type_name,
+                                   const string& value_type_name) {
+  LOG(ERROR) << "Don't know how to create a Map<K,V> container.";
+  return false;
+}
+
+}  // namespace java
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/type_java.h b/aidl/type_java.h
new file mode 100644
index 0000000..6d35f2a
--- /dev/null
+++ b/aidl/type_java.h
@@ -0,0 +1,498 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_TYPE_JAVA_H_
+#define AIDL_TYPE_JAVA_H_
+
+#include <string>
+#include <vector>
+
+#include "ast_java.h"
+#include "type_namespace.h"
+
+namespace android {
+namespace aidl {
+namespace java {
+
+class JavaTypeNamespace;
+
+class Type : public ValidatableType {
+ public:
+  // WriteToParcel flags
+  enum { PARCELABLE_WRITE_RETURN_VALUE = 0x0001 };
+
+  Type(const JavaTypeNamespace* types, const std::string& name, int kind,
+       bool canWriteToParcel, bool canBeOut);
+  Type(const JavaTypeNamespace* types, const std::string& package,
+       const std::string& name, int kind, bool canWriteToParcel, bool canBeOut,
+       const std::string& declFile = "", int declLine = -1);
+  virtual ~Type() = default;
+
+  bool CanBeOutParameter() const override { return m_canBeOut; }
+  bool CanWriteToParcel() const override { return m_canWriteToParcel; }
+
+  const ValidatableType* ArrayType() const override { return m_array_type.get(); }
+  const ValidatableType* NullableType() const override { return nullptr; }
+
+  virtual std::string JavaType() const { return m_javaType; }
+  virtual std::string CreatorName() const;
+  virtual std::string InstantiableName() const;
+
+  virtual void WriteToParcel(StatementBlock* addTo, Variable* v,
+                             Variable* parcel, int flags) const;
+  virtual void CreateFromParcel(StatementBlock* addTo, Variable* v,
+                                Variable* parcel, Variable** cl) const;
+  virtual void ReadFromParcel(StatementBlock* addTo, Variable* v,
+                              Variable* parcel, Variable** cl) const;
+
+ protected:
+  Expression* BuildWriteToParcelFlags(int flags) const;
+
+  const JavaTypeNamespace* m_types;
+
+  std::unique_ptr<Type> m_array_type;
+
+ private:
+  Type();
+  Type(const Type&);
+
+  std::string m_javaType;
+  std::string m_declFile;
+  bool m_canWriteToParcel;
+  bool m_canBeOut;
+};
+
+class BasicArrayType : public Type {
+ public:
+  BasicArrayType(const JavaTypeNamespace* types, const std::string& name,
+                 const std::string& writeArrayParcel,
+                 const std::string& createArrayParcel,
+                 const std::string& readArrayParcel);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+
+ private:
+  std::string m_writeArrayParcel;
+  std::string m_createArrayParcel;
+  std::string m_readArrayParcel;
+};
+
+class BasicType : public Type {
+ public:
+  BasicType(const JavaTypeNamespace* types, const std::string& name,
+            const std::string& marshallParcel,
+            const std::string& unmarshallParcel,
+            const std::string& writeArrayParcel,
+            const std::string& createArrayParcel,
+            const std::string& readArrayParcel);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+
+ private:
+  std::string m_marshallParcel;
+  std::string m_unmarshallParcel;
+};
+
+class FileDescriptorArrayType : public Type {
+ public:
+  explicit FileDescriptorArrayType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v,
+                        Variable* parcel, Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class FileDescriptorType : public Type {
+ public:
+  explicit FileDescriptorType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class BooleanArrayType : public Type {
+ public:
+  explicit BooleanArrayType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v,
+                        Variable* parcel, Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class BooleanType : public Type {
+ public:
+  explicit BooleanType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class CharArrayType : public Type {
+ public:
+  explicit CharArrayType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v,
+                        Variable* parcel, Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class CharType : public Type {
+ public:
+  explicit CharType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class StringArrayType : public Type {
+ public:
+  explicit StringArrayType(const JavaTypeNamespace* types);
+
+  std::string CreatorName() const override;
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v,
+                        Variable* parcel, Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class StringType : public Type {
+ public:
+  StringType(const JavaTypeNamespace* types, const std::string& package,
+             const std::string& class_name);
+
+  std::string JavaType() const override { return "java.lang.String"; }
+  std::string CreatorName() const override;
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class CharSequenceType : public Type {
+ public:
+  explicit CharSequenceType(const JavaTypeNamespace* types);
+
+  std::string CreatorName() const override;
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class RemoteExceptionType : public Type {
+ public:
+  explicit RemoteExceptionType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class RuntimeExceptionType : public Type {
+ public:
+  explicit RuntimeExceptionType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class IBinderArrayType : public Type {
+ public:
+  explicit IBinderArrayType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v,
+                        Variable* parcel, Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class IBinderType : public Type {
+ public:
+  explicit IBinderType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class IInterfaceType : public Type {
+ public:
+  explicit IInterfaceType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class BinderType : public Type {
+ public:
+  explicit BinderType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class BinderProxyType : public Type {
+ public:
+  explicit BinderProxyType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class ParcelType : public Type {
+ public:
+  explicit ParcelType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class ParcelableInterfaceType : public Type {
+ public:
+  explicit ParcelableInterfaceType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+};
+
+class MapType : public Type {
+ public:
+  explicit MapType(const JavaTypeNamespace* types);
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class ListType : public Type {
+ public:
+  explicit ListType(const JavaTypeNamespace* types);
+
+  std::string InstantiableName() const override;
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class UserDataArrayType : public Type {
+ public:
+  UserDataArrayType(const JavaTypeNamespace* types, const std::string& package,
+                    const std::string& name, bool builtIn,
+                    bool canWriteToParcel, const std::string& declFile = "",
+                    int declLine = -1);
+
+  std::string CreatorName() const override;
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v,
+                        Variable* parcel, Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class UserDataType : public Type {
+ public:
+  UserDataType(const JavaTypeNamespace* types, const std::string& package,
+               const std::string& name, bool builtIn, bool canWriteToParcel,
+               const std::string& declFile = "", int declLine = -1);
+
+  std::string CreatorName() const override;
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+};
+
+class InterfaceType : public Type {
+ public:
+  InterfaceType(const JavaTypeNamespace* types, const std::string& package,
+                const std::string& name, bool builtIn, bool oneway,
+                const std::string& declFile, int declLine, const Type* stub,
+                const Type* proxy);
+
+  bool OneWay() const;
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+  const Type* GetStub() const { return stub_; }
+  const Type* GetProxy() const { return proxy_; }
+
+ private:
+  bool m_oneway;
+  const Type* stub_;
+  const Type* proxy_;
+};
+
+class ClassLoaderType : public Type {
+ public:
+  explicit ClassLoaderType(const JavaTypeNamespace* types);
+};
+
+class GenericListType : public Type {
+ public:
+  GenericListType(const JavaTypeNamespace* types, const Type* arg);
+
+  std::string CreatorName() const override;
+  std::string InstantiableName() const override;
+  std::string JavaType() const override {
+    return "java.util.List<" + m_contained_type->JavaType() + ">";
+  }
+
+  void WriteToParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                     int flags) const override;
+  void CreateFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                        Variable** cl) const override;
+  void ReadFromParcel(StatementBlock* addTo, Variable* v, Variable* parcel,
+                      Variable** cl) const override;
+  const ValidatableType* NullableType() const override { return this; }
+
+ private:
+  const Type* m_contained_type;
+  const std::string m_creator;
+};
+
+class JavaTypeNamespace : public LanguageTypeNamespace<Type> {
+ public:
+  JavaTypeNamespace() = default;
+  virtual ~JavaTypeNamespace() = default;
+
+  void Init() override;
+  bool AddParcelableType(const AidlParcelable& p,
+                         const std::string& filename) override;
+  bool AddBinderType(const AidlInterface& b,
+                     const std::string& filename) override;
+  bool AddListType(const std::string& contained_type_name) override;
+  bool AddMapType(const std::string& key_type_name,
+                  const std::string& value_type_name) override;
+
+  const Type* BoolType() const { return m_bool_type; }
+  const Type* IntType() const { return m_int_type; }
+  const Type* StringType() const { return m_string_type; }
+  const Type* TextUtilsType() const { return m_text_utils_type; }
+  const Type* RemoteExceptionType() const { return m_remote_exception_type; }
+  const Type* RuntimeExceptionType() const { return m_runtime_exception_type; }
+  const Type* IBinderType() const { return m_ibinder_type; }
+  const Type* IInterfaceType() const { return m_iinterface_type; }
+  const Type* BinderNativeType() const { return m_binder_native_type; }
+  const Type* BinderProxyType() const { return m_binder_proxy_type; }
+  const Type* ParcelType() const { return m_parcel_type; }
+  const Type* ParcelableInterfaceType() const {
+    return m_parcelable_interface_type;
+  }
+  const Type* ContextType() const { return m_context_type; }
+  const Type* ClassLoaderType() const { return m_classloader_type; }
+
+ private:
+  const Type* m_bool_type{nullptr};
+  const Type* m_int_type{nullptr};
+  const Type* m_string_type{nullptr};
+  const Type* m_text_utils_type{nullptr};
+  const Type* m_remote_exception_type{nullptr};
+  const Type* m_runtime_exception_type{nullptr};
+  const Type* m_ibinder_type{nullptr};
+  const Type* m_iinterface_type{nullptr};
+  const Type* m_binder_native_type{nullptr};
+  const Type* m_binder_proxy_type{nullptr};
+  const Type* m_parcel_type{nullptr};
+  const Type* m_parcelable_interface_type{nullptr};
+  const Type* m_context_type{nullptr};
+  const Type* m_classloader_type{nullptr};
+
+  DISALLOW_COPY_AND_ASSIGN(JavaTypeNamespace);
+};
+
+extern Expression* NULL_VALUE;
+extern Expression* THIS_VALUE;
+extern Expression* SUPER_VALUE;
+extern Expression* TRUE_VALUE;
+extern Expression* FALSE_VALUE;
+
+}  // namespace java
+}  // namespace aidl
+}  // namespace android
+
+#endif  // AIDL_TYPE_JAVA_H_
diff --git a/aidl/type_java_unittest.cpp b/aidl/type_java_unittest.cpp
new file mode 100644
index 0000000..a9df134
--- /dev/null
+++ b/aidl/type_java_unittest.cpp
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include <memory>
+
+#include <gtest/gtest.h>
+
+#include "aidl_language.h"
+#include "type_java.h"
+
+using std::unique_ptr;
+
+namespace android {
+namespace aidl {
+namespace java {
+
+class JavaTypeNamespaceTest : public ::testing::Test {
+ protected:
+  void SetUp() override {
+    types_.Init();
+  }
+  JavaTypeNamespace types_;
+};
+
+TEST_F(JavaTypeNamespaceTest, HasSomeBasicTypes) {
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("void"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("int"));
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("java.lang.String"));
+}
+
+TEST_F(JavaTypeNamespaceTest, ContainerTypeCreation) {
+  // We start with no knowledge of parcelables or lists of them.
+  EXPECT_FALSE(types_.HasTypeByCanonicalName("Foo"));
+  EXPECT_FALSE(types_.HasTypeByCanonicalName("java.util.List<a.goog.Foo>"));
+  unique_ptr<AidlParcelable> parcelable(
+      new AidlParcelable(new AidlQualifiedName("Foo", ""), 0, {"a", "goog"}));
+  // Add the parcelable type we care about.
+  EXPECT_TRUE(types_.AddParcelableType(*parcelable.get(), __FILE__));
+  // Now we can find the parcelable type, but not the List of them.
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("a.goog.Foo"));
+  EXPECT_FALSE(types_.HasTypeByCanonicalName("java.util.List<a.goog.Foo>"));
+  // But after we add the list explicitly...
+  AidlType container_type("List<Foo>", 0, "", false /* not array */);
+  EXPECT_TRUE(types_.MaybeAddContainerType(container_type));
+  // This should work.
+  EXPECT_TRUE(types_.HasTypeByCanonicalName("java.util.List<a.goog.Foo>"));
+}
+
+}  // namespace java
+}  // namespace android
+}  // namespace aidl
diff --git a/aidl/type_namespace.cpp b/aidl/type_namespace.cpp
new file mode 100644
index 0000000..d3f4aaf
--- /dev/null
+++ b/aidl/type_namespace.cpp
@@ -0,0 +1,165 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#include "type_namespace.h"
+
+#include <algorithm>
+#include <string>
+#include <vector>
+
+#include "aidl_language.h"
+#include "logging.h"
+
+using android::base::StringPrintf;
+using android::base::Split;
+using android::base::Trim;
+using std::string;
+using std::vector;
+
+namespace android {
+namespace aidl {
+
+// Since packages cannot contain '-' normally, we cannot be asked
+// to create a type that conflicts with these strings.
+const char kAidlReservedTypePackage[] = "aidl-internal";
+const char kUtf8StringClass[] = "Utf8String";
+const char kUtf8InCppStringClass[] = "Utf8InCppString";
+
+// These *must* match the package and class names above.
+const char kUtf8StringCanonicalName[] = "aidl-internal.Utf8String";
+const char kUtf8InCppStringCanonicalName[] = "aidl-internal.Utf8InCppString";
+
+const char kStringCanonicalName[] = "java.lang.String";
+
+const char kUtf8Annotation[] = "@utf8";
+const char kUtf8InCppAnnotation[] = "@utfInCpp";
+
+namespace {
+
+bool is_java_keyword(const char* str) {
+  static const std::vector<std::string> kJavaKeywords{
+      "abstract",   "assert",       "boolean",   "break",      "byte",
+      "case",       "catch",        "char",      "class",      "const",
+      "continue",   "default",      "do",        "double",     "else",
+      "enum",       "extends",      "final",     "finally",    "float",
+      "for",        "goto",         "if",        "implements", "import",
+      "instanceof", "int",          "interface", "long",       "native",
+      "new",        "package",      "private",   "protected",  "public",
+      "return",     "short",        "static",    "strictfp",   "super",
+      "switch",     "synchronized", "this",      "throw",      "throws",
+      "transient",  "try",          "void",      "volatile",   "while",
+      "true",       "false",        "null",
+  };
+  return std::find(kJavaKeywords.begin(), kJavaKeywords.end(), str) !=
+      kJavaKeywords.end();
+}
+
+} // namespace
+
+ValidatableType::ValidatableType(
+    int kind, const string& package, const string& type_name,
+    const string& decl_file, int decl_line)
+    : kind_(kind),
+      type_name_(type_name),
+      canonical_name_((package.empty()) ? type_name
+                                        : package + "." + type_name),
+      origin_file_(decl_file),
+      origin_line_(decl_line) {}
+
+string ValidatableType::HumanReadableKind() const {
+  switch (Kind()) {
+    case ValidatableType::KIND_BUILT_IN:
+      return "a built in";
+    case ValidatableType::KIND_PARCELABLE:
+      return "a parcelable";
+    case ValidatableType::KIND_INTERFACE:
+      return "an interface";
+    case ValidatableType::KIND_GENERATED:
+      return "a generated";
+  }
+  return "unknown";
+}
+
+bool TypeNamespace::IsValidPackage(const string& /* package */) const {
+  return true;
+}
+
+const ValidatableType* TypeNamespace::GetReturnType(
+    const AidlType& raw_type, const string& filename,
+    const AidlInterface& interface) const {
+  string error_msg;
+  const ValidatableType* return_type = GetValidatableType(raw_type, &error_msg,
+                                                          interface);
+  if (return_type == nullptr) {
+    LOG(ERROR) << StringPrintf("In file %s line %d return type %s:\n    ",
+                               filename.c_str(), raw_type.GetLine(),
+                               raw_type.ToString().c_str())
+               << error_msg;
+    return nullptr;
+  }
+
+  return return_type;
+}
+
+const ValidatableType* TypeNamespace::GetArgType(
+    const AidlArgument& a, int arg_index, const string& filename,
+    const AidlInterface& interface) const {
+  string error_prefix = StringPrintf(
+      "In file %s line %d parameter %s (argument %d):\n    ",
+      filename.c_str(), a.GetLine(), a.GetName().c_str(), arg_index);
+
+  // check the arg type
+  string error_msg;
+  const ValidatableType* t = GetValidatableType(a.GetType(), &error_msg,
+                                                interface);
+  if (t == nullptr) {
+    LOG(ERROR) << error_prefix << error_msg;
+    return nullptr;
+  }
+
+  if (!a.DirectionWasSpecified() && t->CanBeOutParameter()) {
+    LOG(ERROR) << error_prefix << StringPrintf(
+        "'%s' can be an out type, so you must declare it as in,"
+        " out or inout.",
+        a.GetType().ToString().c_str());
+    return nullptr;
+  }
+
+  if (a.GetDirection() != AidlArgument::IN_DIR &&
+      !t->CanBeOutParameter()) {
+    LOG(ERROR) << error_prefix << StringPrintf(
+        "'%s' can only be an in parameter.",
+        a.ToString().c_str());
+    return nullptr;
+  }
+
+  // check that the name doesn't match a keyword
+  if (is_java_keyword(a.GetName().c_str())) {
+    LOG(ERROR) << error_prefix << "Argument name is a Java or aidl keyword";
+    return nullptr;
+  }
+
+  // Reserve a namespace for internal use
+  if (a.GetName().substr(0, 5)  == "_aidl") {
+    LOG(ERROR) << error_prefix << "Argument name cannot begin with '_aidl'";
+    return nullptr;
+  }
+
+  return t;
+}
+
+}  // namespace aidl
+}  // namespace android
diff --git a/aidl/type_namespace.h b/aidl/type_namespace.h
new file mode 100644
index 0000000..7defd24
--- /dev/null
+++ b/aidl/type_namespace.h
@@ -0,0 +1,496 @@
+/*
+ * Copyright (C) 2015, 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.
+ */
+
+#ifndef AIDL_TYPE_NAMESPACE_H_
+#define AIDL_TYPE_NAMESPACE_H_
+
+#include <memory>
+#include <string>
+
+#include <android-base/macros.h>
+#include <android-base/stringprintf.h>
+#include <android-base/strings.h>
+
+#include "aidl_language.h"
+#include "logging.h"
+
+namespace android {
+namespace aidl {
+
+// Special reserved type names.
+extern const char kAidlReservedTypePackage[];
+extern const char kUtf8StringClass[];  // UTF8 wire format string
+extern const char kUtf8InCppStringClass[];  // UTF16 wire format, UTF8 in C++
+
+// Helpful aliases defined to be <kAidlReservedTypePackage>.<class name>
+extern const char kUtf8StringCanonicalName[];
+extern const char kUtf8InCppStringCanonicalName[];
+
+// We sometimes special case this class.
+extern const char kStringCanonicalName[];
+
+// Note that these aren't the strings recognized by the parser, we just keep
+// here for the sake of logging a common string constant.
+extern const char kUtf8Annotation[];
+extern const char kUtf8InCppAnnotation[];
+
+class ValidatableType {
+ public:
+  enum {
+    KIND_BUILT_IN,
+    KIND_PARCELABLE,
+    KIND_INTERFACE,
+    KIND_GENERATED,
+  };
+
+  ValidatableType(int kind,
+                  const std::string& package, const std::string& type_name,
+                  const std::string& decl_file, int decl_line);
+  virtual ~ValidatableType() = default;
+
+  virtual bool CanBeArray() const { return ArrayType() != nullptr; }
+  virtual bool CanBeOutParameter() const = 0;
+  virtual bool CanWriteToParcel() const = 0;
+
+  virtual const ValidatableType* ArrayType() const = 0;
+  virtual const ValidatableType* NullableType() const = 0;
+
+  // ShortName() is the class name without a package.
+  std::string ShortName() const { return type_name_; }
+  // CanonicalName() returns the canonical AIDL type, with packages.
+  std::string CanonicalName() const { return canonical_name_; }
+
+  int Kind() const { return kind_; }
+  std::string HumanReadableKind() const;
+  std::string DeclFile() const { return origin_file_; }
+  int DeclLine() const { return origin_line_; }
+
+ private:
+  const int kind_;
+  const std::string type_name_;
+  const std::string canonical_name_;
+  const std::string origin_file_;
+  const int origin_line_;
+
+  DISALLOW_COPY_AND_ASSIGN(ValidatableType);
+};
+
+class TypeNamespace {
+ public:
+  // Load the TypeNamespace with built in types.  Don't do work in the
+  // constructor because many of the useful methods are virtual.
+  virtual void Init() = 0;
+
+  // Load this TypeNamespace with user defined types.
+  virtual bool AddParcelableType(const AidlParcelable& p,
+                                 const std::string& filename) = 0;
+  virtual bool AddBinderType(const AidlInterface& b,
+                             const std::string& filename) = 0;
+  // Add a container type to this namespace.  Returns false only
+  // on error. Silently discards requests to add non-container types.
+  virtual bool MaybeAddContainerType(const AidlType& aidl_type) = 0;
+
+  // Returns true iff this has a type for |import|.
+  virtual bool HasImportType(const AidlImport& import) const = 0;
+
+  // Returns true iff |package| is a valid package name.
+  virtual bool IsValidPackage(const std::string& package) const;
+
+  // Returns a pointer to a type corresponding to |raw_type| or nullptr
+  // if this is an invalid return type.
+  virtual const ValidatableType* GetReturnType(
+      const AidlType& raw_type,
+      const std::string& filename,
+      const AidlInterface& interface) const;
+
+  // Returns a pointer to a type corresponding to |a| or nullptr if |a|
+  // has an invalid argument type.
+  virtual const ValidatableType* GetArgType(
+      const AidlArgument& a,
+      int arg_index,
+      const std::string& filename,
+      const AidlInterface& interface) const;
+
+  // Returns a pointer to a type corresponding to |interface|.
+  virtual const ValidatableType* GetInterfaceType(
+      const AidlInterface& interface) const = 0;
+
+ protected:
+  TypeNamespace() = default;
+  virtual ~TypeNamespace() = default;
+
+  virtual const ValidatableType* GetValidatableType(
+      const AidlType& type, std::string* error_msg,
+      const AidlInterface& interface) const = 0;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(TypeNamespace);
+};
+
+template<typename T>
+class LanguageTypeNamespace : public TypeNamespace {
+ public:
+  LanguageTypeNamespace() = default;
+  virtual ~LanguageTypeNamespace() = default;
+
+  // Get a pointer to an existing type.  Searches first by fully-qualified
+  // name, and then class name (dropping package qualifiers).
+  const T* Find(const AidlType& aidl_type) const;
+
+  // Find a type by its |name|.  If |name| refers to a container type (e.g.
+  // List<String>) you must turn it into a canonical name first (e.g.
+  // java.util.List<java.lang.String>).
+  const T* FindTypeByCanonicalName(const std::string& name) const;
+  bool HasTypeByCanonicalName(const std::string& type_name) const {
+    return FindTypeByCanonicalName(type_name) != nullptr;
+  }
+  bool HasImportType(const AidlImport& import) const override {
+    return HasTypeByCanonicalName(import.GetNeededClass());
+  }
+  const ValidatableType* GetInterfaceType(
+      const AidlInterface& interface) const override {
+    return FindTypeByCanonicalName(interface.GetCanonicalName());
+  }
+
+  bool MaybeAddContainerType(const AidlType& aidl_type) override;
+  // We dynamically create container types as we discover them in the parse
+  // tree.  Returns false if the contained types cannot be canonicalized.
+  virtual bool AddListType(const std::string& contained_type_name) = 0;
+  virtual bool AddMapType(const std::string& key_type_name,
+                          const std::string& value_type_name) = 0;
+
+ protected:
+  bool Add(const T* type);
+
+ private:
+  // Returns true iff the name can be canonicalized to a container type.
+  virtual bool CanonicalizeContainerType(
+      const AidlType& aidl_type,
+      std::vector<std::string>* container_class,
+      std::vector<std::string>* contained_type_names) const;
+
+  // Returns true if this is a container type, rather than a normal type.
+  bool IsContainerType(const std::string& type_name) const;
+
+  const ValidatableType* GetValidatableType(
+      const AidlType& type, std::string* error_msg,
+      const AidlInterface& interface) const override;
+
+  std::vector<std::unique_ptr<const T>> types_;
+
+  DISALLOW_COPY_AND_ASSIGN(LanguageTypeNamespace);
+};  // class LanguageTypeNamespace
+
+template<typename T>
+bool LanguageTypeNamespace<T>::Add(const T* type) {
+  const T* existing = FindTypeByCanonicalName(type->CanonicalName());
+  if (!existing) {
+    types_.emplace_back(type);
+    return true;
+  }
+
+  if (existing->Kind() == ValidatableType::KIND_BUILT_IN) {
+    LOG(ERROR) << type->DeclFile() << ":" << type->DeclLine()
+               << " attempt to redefine built in class "
+               << type->CanonicalName();
+    return false;
+  }
+
+  if (type->Kind() != existing->Kind()) {
+    LOG(ERROR) << type->DeclFile() << ":" << type->DeclLine()
+               << " attempt to redefine " << type->CanonicalName()
+               << " as " << type->HumanReadableKind();
+    LOG(ERROR) << existing->DeclFile() << ":" << existing->DeclLine()
+               << " previously defined here as "
+               << existing->HumanReadableKind();
+    return false;
+  }
+
+  return true;
+}
+
+template<typename T>
+const T* LanguageTypeNamespace<T>::Find(const AidlType& aidl_type) const {
+  using std::string;
+  using std::vector;
+  using android::base::Join;
+  using android::base::Trim;
+
+  string name = Trim(aidl_type.GetName());
+  if (IsContainerType(name)) {
+    vector<string> container_class;
+    vector<string> contained_type_names;
+    if (!CanonicalizeContainerType(aidl_type, &container_class,
+                                   &contained_type_names)) {
+      return nullptr;
+    }
+    name = Join(container_class, '.') +
+           "<" + Join(contained_type_names, ',') + ">";
+  }
+  // Here, we know that we have the canonical name for this container.
+  return FindTypeByCanonicalName(name);
+}
+
+template<typename T>
+const T* LanguageTypeNamespace<T>::FindTypeByCanonicalName(
+    const std::string& raw_name) const {
+  using android::base::Trim;
+
+  std::string name = Trim(raw_name);
+  const T* ret = nullptr;
+  for (const auto& type : types_) {
+    // Always prefer a exact match if possible.
+    // This works for primitives and class names qualified with a package.
+    if (type->CanonicalName() == name) {
+      ret = type.get();
+      break;
+    }
+    // We allow authors to drop packages when refering to a class name.
+    if (type->ShortName() == name) {
+      ret = type.get();
+    }
+  }
+
+  return ret;
+}
+
+template<typename T>
+bool LanguageTypeNamespace<T>::MaybeAddContainerType(
+    const AidlType& aidl_type) {
+  using android::base::Join;
+
+  const std::string& type_name = aidl_type.GetName();
+  if (!IsContainerType(type_name)) {
+    return true;
+  }
+
+  std::vector<std::string> container_class;
+  std::vector<std::string> contained_type_names;
+  if (!CanonicalizeContainerType(aidl_type, &container_class,
+                                 &contained_type_names)) {
+    return false;
+  }
+
+  const std::string canonical_name = Join(container_class, ".") +
+      "<" + Join(contained_type_names, ",") + ">";
+  if (HasTypeByCanonicalName(canonical_name)) {
+    return true;
+  }
+
+
+  // We only support two types right now and this type is one of them.
+  switch (contained_type_names.size()) {
+    case 1:
+      return AddListType(contained_type_names[0]);
+    case 2:
+      return AddMapType(contained_type_names[0], contained_type_names[1]);
+    default:
+      break;  // Should never get here, will FATAL below.
+  }
+
+  LOG(FATAL) << "aidl internal error";
+  return false;
+}
+
+template<typename T>
+bool LanguageTypeNamespace<T>::IsContainerType(
+    const std::string& type_name) const {
+  const size_t opening_brace = type_name.find('<');
+  const size_t closing_brace = type_name.find('>');
+  if (opening_brace != std::string::npos ||
+      closing_brace != std::string::npos) {
+    return true;  // Neither < nor > appear in normal AIDL types.
+  }
+  return false;
+}
+
+template<typename T>
+bool LanguageTypeNamespace<T>::CanonicalizeContainerType(
+    const AidlType& aidl_type,
+    std::vector<std::string>* container_class,
+    std::vector<std::string>* contained_type_names) const {
+  using android::base::Trim;
+  using android::base::Split;
+
+  std::string name = Trim(aidl_type.GetName());
+  const size_t opening_brace = name.find('<');
+  const size_t closing_brace = name.find('>');
+  if (opening_brace == std::string::npos ||
+      closing_brace == std::string::npos) {
+    return false;
+  }
+
+  if (opening_brace != name.rfind('<') ||
+      closing_brace != name.rfind('>') ||
+      closing_brace != name.length() - 1) {
+    // Nested/invalid templates are forbidden.
+    LOG(ERROR) << "Invalid template type '" << name << "'";
+    return false;
+  }
+
+  std::string container = Trim(name.substr(0, opening_brace));
+  std::string remainder = name.substr(opening_brace + 1,
+                                 (closing_brace - opening_brace) - 1);
+  std::vector<std::string> args = Split(remainder, ",");
+  for (auto& type_name: args) {
+    // Here, we are relying on FindTypeByCanonicalName to do its best when
+    // given a non-canonical name for non-compound type (i.e. not another
+    // container).
+    const T* arg_type = FindTypeByCanonicalName(type_name);
+    if (!arg_type) {
+      return false;
+    }
+
+    // Now get the canonical names for these contained types, remapping them if
+    // necessary.
+    type_name = arg_type->CanonicalName();
+    if (aidl_type.IsUtf8() && type_name == "java.lang.String") {
+      type_name = kUtf8StringCanonicalName;
+    } else if (aidl_type.IsUtf8InCpp() && type_name == "java.lang.String") {
+      type_name = kUtf8InCppStringCanonicalName;
+    }
+  }
+
+  // Map the container name to its canonical form for supported containers.
+  if ((container == "List" || container == "java.util.List") &&
+      args.size() == 1) {
+    *container_class = {"java", "util", "List"};
+    *contained_type_names = args;
+    return true;
+  }
+  if ((container == "Map" || container == "java.util.Map") &&
+      args.size() == 2) {
+    *container_class = {"java", "util", "Map"};
+    *contained_type_names = args;
+    return true;
+  }
+
+  LOG(ERROR) << "Unknown find container with name " << container
+             << " and " << args.size() << "contained types.";
+  return false;
+}
+
+template<typename T>
+const ValidatableType* LanguageTypeNamespace<T>::GetValidatableType(
+    const AidlType& aidl_type, std::string* error_msg,
+    const AidlInterface& interface) const {
+  using android::base::StringPrintf;
+
+  const ValidatableType* type = Find(aidl_type);
+  if (type == nullptr) {
+    *error_msg = "unknown type";
+    return nullptr;
+  }
+
+  if (aidl_type.GetName() == "void") {
+    if (aidl_type.IsArray()) {
+      *error_msg = "void type cannot be an array";
+      return nullptr;
+    }
+    if (aidl_type.IsNullable() || aidl_type.IsUtf8() ||
+        aidl_type.IsUtf8InCpp()) {
+      *error_msg = "void type cannot be annotated";
+      return nullptr;
+    }
+    // We have no more special handling for void.
+    return type;
+  }
+
+  // No type may be annotated with both these annotations.
+  if (aidl_type.IsUtf8() && aidl_type.IsUtf8InCpp()) {
+    *error_msg = StringPrintf("Type cannot be marked as both %s and %s.",
+                              kUtf8Annotation, kUtf8InCppAnnotation);
+    return nullptr;
+  }
+
+  bool utf8 = aidl_type.IsUtf8();
+  bool utf8InCpp = aidl_type.IsUtf8InCpp();
+
+  // Strings inside containers get remapped to appropriate utf8 versions when
+  // we convert the container name to its canonical form and the look up the
+  // type.  However, for non-compound types (i.e. those not in a container) we
+  // must patch them up here.
+  if (IsContainerType(type->CanonicalName())) {
+    utf8 = false;
+    utf8InCpp = false;
+  } else if (aidl_type.GetName() == "String" ||
+             aidl_type.GetName() == "java.lang.String") {
+    utf8 = utf8 || interface.IsUtf8();
+    utf8InCpp = utf8InCpp || interface.IsUtf8InCpp();
+  } else if (utf8 || utf8InCpp) {
+    const char* annotation_literal =
+        (utf8) ? kUtf8Annotation : kUtf8InCppAnnotation;
+    *error_msg = StringPrintf("type '%s' may not be annotated as %s.",
+                              aidl_type.GetName().c_str(),
+                              annotation_literal);
+    return nullptr;
+  }
+
+  if (utf8) {
+    type = FindTypeByCanonicalName(kUtf8StringCanonicalName);
+  } else if (utf8InCpp) {
+    type = FindTypeByCanonicalName(kUtf8InCppStringCanonicalName);
+  }
+
+  // One of our UTF8 transforms made type null
+  if (type == nullptr) {
+    const char* annotation_literal =
+        (utf8) ? kUtf8Annotation : kUtf8InCppAnnotation;
+    *error_msg = StringPrintf(
+        "%s is unsupported when generating code for this language.",
+        annotation_literal);
+    return nullptr;
+  }
+
+  if (!type->CanWriteToParcel()) {
+    *error_msg = "type cannot be marshalled";
+    return nullptr;
+  }
+
+  if (aidl_type.IsArray()) {
+    type = type->ArrayType();
+    if (!type) {
+      *error_msg = StringPrintf("type '%s' cannot be an array",
+                                aidl_type.GetName().c_str());
+      return nullptr;
+    }
+  }
+
+  if (interface.IsNullable()) {
+    const ValidatableType* nullableType = type->NullableType();
+
+    if (nullableType) {
+      return nullableType;
+    }
+  }
+
+  if (aidl_type.IsNullable()) {
+    type = type->NullableType();
+    if (!type) {
+      *error_msg = StringPrintf("type '%s%s' cannot be marked as possibly null",
+                                aidl_type.GetName().c_str(),
+                                (aidl_type.IsArray()) ? "[]" : "");
+      return nullptr;
+    }
+  }
+
+  return type;
+}
+
+}  // namespace aidl
+}  // namespace android
+
+#endif  // AIDL_TYPE_NAMESPACE_H_