diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index b323624..e33f099 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -1344,7 +1344,8 @@
 
     // TODO: explicity setting Shell's component to allow broadcast to launch it.
     // That might break other components that are listening to the bugreport notifications
-    // (android.intent.action.BUGREPORT_STARTED and android.intent.action.BUGREPORT_STOPED), but
+    // (com.android.internal.intent.action.BUGREPORT_STARTED and
+    // com.android.internal.intent.action.BUGREPORT_STOPED), but
     // those should be just handled by Shell anyways.
     // A more generic alternative would be passing the -f 0x01000000 flag (or whatever
     // value is defined by FLAG_RECEIVER_INCLUDE_BACKGROUND), but that would reset the
@@ -1600,7 +1601,7 @@
                      "--ei", "android.intent.extra.MAX", std::to_string(ds.progress_->GetMax()),
                 };
                 // clang-format on
-                SendShellBroadcast("android.intent.action.BUGREPORT_STARTED", am_args);
+                SendShellBroadcast("com.android.internal.intent.action.BUGREPORT_STARTED", am_args);
             }
             if (use_control_socket) {
                 dprintf(ds.control_socket_fd_, "BEGIN:%s\n", ds.path_.c_str());
@@ -1825,9 +1826,10 @@
                 am_args.push_back("--es");
                 am_args.push_back("android.intent.extra.REMOTE_BUGREPORT_HASH");
                 am_args.push_back(SHA256_file_hash(ds.path_));
-                SendShellBroadcast("android.intent.action.REMOTE_BUGREPORT_FINISHED", am_args);
+                SendShellBroadcast("com.android.internal.intent.action.REMOTE_BUGREPORT_FINISHED",
+                                   am_args);
             } else {
-                SendShellBroadcast("android.intent.action.BUGREPORT_FINISHED", am_args);
+                SendShellBroadcast("com.android.internal.intent.action.BUGREPORT_FINISHED", am_args);
             }
         } else {
             MYLOGE("Skipping finished broadcast because bugreport could not be generated\n");
diff --git a/cmds/installd/dexopt.cpp b/cmds/installd/dexopt.cpp
index aa32d6b..0fb207b 100644
--- a/cmds/installd/dexopt.cpp
+++ b/cmds/installd/dexopt.cpp
@@ -854,13 +854,16 @@
     return open(file_name, flags, permissions);
 }
 
-static bool set_permissions_and_ownership(int fd, bool is_public, int uid, const char* path) {
+static bool set_permissions_and_ownership(
+        int fd, bool is_public, int uid, const char* path, bool is_secondary_dex) {
+    // Primary apks are owned by the system. Secondary dex files are owned by the app.
+    int owning_uid = is_secondary_dex ? uid : AID_SYSTEM;
     if (fchmod(fd,
                S_IRUSR|S_IWUSR|S_IRGRP |
                (is_public ? S_IROTH : 0)) < 0) {
         ALOGE("installd cannot chmod '%s' during dexopt\n", path);
         return false;
-    } else if (fchown(fd, AID_SYSTEM, uid) < 0) {
+    } else if (fchown(fd, owning_uid, uid) < 0) {
         ALOGE("installd cannot chown '%s' during dexopt\n", path);
         return false;
     }
@@ -1009,10 +1012,11 @@
 
 // (re)Creates the app image if needed.
 Dex2oatFileWrapper maybe_open_app_image(const char* out_oat_path, bool profile_guided,
-        bool is_public, int uid) {
+        bool is_public, int uid, bool is_secondary_dex) {
     // Use app images only if it is enabled (by a set image format) and we are compiling
     // profile-guided (so the app image doesn't conservatively contain all classes).
-    if (!profile_guided) {
+    // Note that we don't create an image for secondary dex files.
+    if (is_secondary_dex || !profile_guided) {
         return Dex2oatFileWrapper();
     }
 
@@ -1043,7 +1047,7 @@
             }
         }
     } else if (!set_permissions_and_ownership(
-                wrapper_fd.get(), is_public, uid, image_path.c_str())) {
+                wrapper_fd.get(), is_public, uid, image_path.c_str(), is_secondary_dex)) {
         ALOGE("installd cannot set owner '%s' for image during dexopt\n", image_path.c_str());
         wrapper_fd.reset(-1);
     }
@@ -1101,7 +1105,7 @@
 // Opens the vdex files and assigns the input fd to in_vdex_wrapper_fd and the output fd to
 // out_vdex_wrapper_fd. Returns true for success or false in case of errors.
 bool open_vdex_files(const char* apk_path, const char* out_oat_path, int dexopt_needed,
-        const char* instruction_set, bool is_public, int uid,
+        const char* instruction_set, bool is_public, int uid, bool is_secondary_dex,
         Dex2oatFileWrapper* in_vdex_wrapper_fd,
         Dex2oatFileWrapper* out_vdex_wrapper_fd) {
     CHECK(in_vdex_wrapper_fd != nullptr);
@@ -1164,7 +1168,7 @@
         }
     }
     if (!set_permissions_and_ownership(out_vdex_wrapper_fd->get(), is_public, uid,
-            out_vdex_path_str.c_str())) {
+            out_vdex_path_str.c_str(), is_secondary_dex)) {
         ALOGE("installd cannot set owner '%s' for vdex during dexopt\n", out_vdex_path_str.c_str());
         return false;
     }
@@ -1187,7 +1191,8 @@
             [out_oat_path_str]() { unlink(out_oat_path_str.c_str()); });
     if (wrapper_fd.get() < 0) {
         PLOG(ERROR) << "installd cannot open output during dexopt" <<  out_oat_path;
-    } else if (!set_permissions_and_ownership(wrapper_fd.get(), is_public, uid, out_oat_path)) {
+    } else if (!set_permissions_and_ownership(
+                wrapper_fd.get(), is_public, uid, out_oat_path, is_secondary_dex)) {
         ALOGE("installd cannot set owner '%s' for output during dexopt\n", out_oat_path);
         wrapper_fd.reset(-1);
     }
@@ -1445,7 +1450,7 @@
     Dex2oatFileWrapper in_vdex_fd;
     Dex2oatFileWrapper out_vdex_fd;
     if (!open_vdex_files(dex_path, out_oat_path, dexopt_needed, instruction_set, is_public, uid,
-            &in_vdex_fd, &out_vdex_fd)) {
+            is_secondary_dex, &in_vdex_fd, &out_vdex_fd)) {
         return -1;
     }
 
@@ -1454,7 +1459,7 @@
 
     // Create the app image file if needed.
     Dex2oatFileWrapper image_fd =
-            maybe_open_app_image(out_oat_path, profile_guided, is_public, uid);
+            maybe_open_app_image(out_oat_path, profile_guided, is_public, uid, is_secondary_dex);
 
     // Open the reference profile if needed.
     Dex2oatFileWrapper reference_profile_fd =
diff --git a/cmds/lshal/Android.bp b/cmds/lshal/Android.bp
index c380598..5aab35a 100644
--- a/cmds/lshal/Android.bp
+++ b/cmds/lshal/Android.bp
@@ -22,6 +22,6 @@
         "libhidltransport",
     ],
     srcs: [
-        "lshal.cpp"
+        "Lshal.cpp"
     ],
 }
diff --git a/cmds/lshal/Lshal.cpp b/cmds/lshal/Lshal.cpp
new file mode 100644
index 0000000..ce058c8
--- /dev/null
+++ b/cmds/lshal/Lshal.cpp
@@ -0,0 +1,477 @@
+/*
+ * 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 "Lshal.h"
+
+#include <getopt.h>
+
+#include <fstream>
+#include <iomanip>
+#include <iostream>
+#include <map>
+#include <sstream>
+#include <regex>
+
+#include <android-base/parseint.h>
+#include <android/hidl/manager/1.0/IServiceManager.h>
+#include <hidl/ServiceManagement.h>
+
+#include "Timeout.h"
+
+using ::android::hardware::hidl_string;
+using ::android::hidl::manager::V1_0::IServiceManager;
+
+namespace android {
+namespace lshal {
+
+template <typename A>
+std::string join(const A &components, const std::string &separator) {
+    std::stringstream out;
+    bool first = true;
+    for (const auto &component : components) {
+        if (!first) {
+            out << separator;
+        }
+        out << component;
+
+        first = false;
+    }
+    return out.str();
+}
+
+static std::string toHexString(uint64_t t) {
+    std::ostringstream os;
+    os << std::hex << std::setfill('0') << std::setw(16) << t;
+    return os.str();
+}
+
+static std::pair<hidl_string, hidl_string> split(const hidl_string &s, char c) {
+    const char *pos = strchr(s.c_str(), c);
+    if (pos == nullptr) {
+        return {s, {}};
+    }
+    return {hidl_string(s.c_str(), pos - s.c_str()), hidl_string(pos + 1)};
+}
+
+static std::vector<std::string> split(const std::string &s, char c) {
+    std::vector<std::string> components{};
+    size_t startPos = 0;
+    size_t matchPos;
+    while ((matchPos = s.find(c, startPos)) != std::string::npos) {
+        components.push_back(s.substr(startPos, matchPos - startPos));
+        startPos = matchPos + 1;
+    }
+
+    if (startPos <= s.length()) {
+        components.push_back(s.substr(startPos));
+    }
+    return components;
+}
+
+std::string getCmdline(pid_t pid) {
+    std::ifstream ifs("/proc/" + std::to_string(pid) + "/cmdline");
+    std::string cmdline;
+    if (!ifs.is_open()) {
+        return "";
+    }
+    ifs >> cmdline;
+    return cmdline;
+}
+
+const std::string &Lshal::getCmdline(pid_t pid) {
+    auto pair = mCmdlines.find(pid);
+    if (pair != mCmdlines.end()) {
+        return pair->second;
+    }
+    mCmdlines[pid] = ::android::lshal::getCmdline(pid);
+    return mCmdlines[pid];
+}
+
+void Lshal::removeDeadProcesses(Pids *pids) {
+    static const pid_t myPid = getpid();
+    std::remove_if(pids->begin(), pids->end(), [this](auto pid) {
+        return pid == myPid || this->getCmdline(pid).empty();
+    });
+}
+
+bool Lshal::getReferencedPids(
+        pid_t serverPid, std::map<uint64_t, Pids> *objects) const {
+
+    std::ifstream ifs("/d/binder/proc/" + std::to_string(serverPid));
+    if (!ifs.is_open()) {
+        return false;
+    }
+
+    static const std::regex prefix("^\\s*node \\d+:\\s+u([0-9a-f]+)\\s+c([0-9a-f]+)\\s+");
+
+    std::string line;
+    std::smatch match;
+    while(getline(ifs, line)) {
+        if (!std::regex_search(line, match, prefix)) {
+            // the line doesn't start with the correct prefix
+            continue;
+        }
+        std::string ptrString = "0x" + match.str(2); // use number after c
+        uint64_t ptr;
+        if (!::android::base::ParseUint(ptrString.c_str(), &ptr)) {
+            // Should not reach here, but just be tolerant.
+            mErr << "Could not parse number " << ptrString << std::endl;
+            continue;
+        }
+        const std::string proc = " proc ";
+        auto pos = line.rfind(proc);
+        if (pos != std::string::npos) {
+            for (const std::string &pidStr : split(line.substr(pos + proc.size()), ' ')) {
+                int32_t pid;
+                if (!::android::base::ParseInt(pidStr, &pid)) {
+                    mErr << "Could not parse number " << pidStr << std::endl;
+                    continue;
+                }
+                (*objects)[ptr].push_back(pid);
+            }
+        }
+    }
+    return true;
+}
+
+void Lshal::postprocess() {
+    if (mSortColumn) {
+        std::sort(mTable.begin(), mTable.end(), mSortColumn);
+    }
+    for (TableEntry &entry : mTable) {
+        entry.serverCmdline = getCmdline(entry.serverPid);
+        removeDeadProcesses(&entry.clientPids);
+        for (auto pid : entry.clientPids) {
+            entry.clientCmdlines.push_back(this->getCmdline(pid));
+        }
+    }
+}
+
+void Lshal::printLine(
+        const std::string &interfaceName,
+        const std::string &transport, const std::string &server,
+        const std::string &serverCmdline,
+        const std::string &address, const std::string &clients,
+        const std::string &clientCmdlines) const {
+    if (mSelectedColumns & ENABLE_INTERFACE_NAME)
+        mOut << std::setw(80) << interfaceName << "\t";
+    if (mSelectedColumns & ENABLE_TRANSPORT)
+        mOut << std::setw(10) << transport << "\t";
+    if (mSelectedColumns & ENABLE_SERVER_PID) {
+        if (mEnableCmdlines) {
+            mOut << std::setw(15) << serverCmdline << "\t";
+        } else {
+            mOut << std::setw(5)  << server << "\t";
+        }
+    }
+    if (mSelectedColumns & ENABLE_SERVER_ADDR)
+        mOut << std::setw(16) << address << "\t";
+    if (mSelectedColumns & ENABLE_CLIENT_PIDS) {
+        if (mEnableCmdlines) {
+            mOut << std::setw(0)  << clientCmdlines;
+        } else {
+            mOut << std::setw(0)  << clients;
+        }
+    }
+    mOut << std::endl;
+}
+
+void Lshal::dump() const {
+    mOut << "All services:" << std::endl;
+    mOut << std::left;
+    printLine("Interface", "Transport", "Server", "Server CMD", "PTR", "Clients", "Clients CMD");
+    for (const auto &entry : mTable) {
+        printLine(entry.interfaceName,
+                entry.transport,
+                entry.serverPid == NO_PID ? "N/A" : std::to_string(entry.serverPid),
+                entry.serverCmdline,
+                entry.serverObjectAddress == NO_PTR ? "N/A" : toHexString(entry.serverObjectAddress),
+                join(entry.clientPids, " "),
+                join(entry.clientCmdlines, ";"));
+    }
+}
+
+void Lshal::putEntry(TableEntry &&entry) {
+    mTable.push_back(std::forward<TableEntry>(entry));
+}
+
+Status Lshal::fetchAllLibraries(const sp<IServiceManager> &manager) {
+    using namespace ::android::hardware;
+    using namespace ::android::hidl::manager::V1_0;
+    using namespace ::android::hidl::base::V1_0;
+    auto ret = timeoutIPC(manager, &IServiceManager::list, [&] (const auto &fqInstanceNames) {
+        for (const auto &fqInstanceName : fqInstanceNames) {
+            putEntry({
+                .interfaceName = fqInstanceName,
+                .transport = "passthrough",
+                .serverPid = NO_PID,
+                .serverObjectAddress = NO_PTR,
+                .clientPids = {}
+            });
+        }
+    });
+    if (!ret.isOk()) {
+        mErr << "Error: Failed to call list on getPassthroughServiceManager(): "
+             << ret.description() << std::endl;
+        return DUMP_ALL_LIBS_ERROR;
+    }
+    return OK;
+}
+
+Status Lshal::fetchPassthrough(const sp<IServiceManager> &manager) {
+    using namespace ::android::hardware;
+    using namespace ::android::hidl::manager::V1_0;
+    using namespace ::android::hidl::base::V1_0;
+    auto ret = timeoutIPC(manager, &IServiceManager::debugDump, [&] (const auto &infos) {
+        for (const auto &info : infos) {
+            putEntry({
+                .interfaceName =
+                        std::string{info.interfaceName.c_str()} + "/" +
+                        std::string{info.instanceName.c_str()},
+                .transport = "passthrough",
+                .serverPid = info.clientPids.size() == 1 ? info.clientPids[0] : NO_PID,
+                .serverObjectAddress = NO_PTR,
+                .clientPids = info.clientPids
+            });
+        }
+    });
+    if (!ret.isOk()) {
+        mErr << "Error: Failed to call debugDump on defaultServiceManager(): "
+             << ret.description() << std::endl;
+        return DUMP_PASSTHROUGH_ERROR;
+    }
+    return OK;
+}
+
+Status Lshal::fetchBinderized(const sp<IServiceManager> &manager) {
+    using namespace ::std;
+    using namespace ::android::hardware;
+    using namespace ::android::hidl::manager::V1_0;
+    using namespace ::android::hidl::base::V1_0;
+    const std::string mode = "hwbinder";
+    Status status = OK;
+    auto listRet = timeoutIPC(manager, &IServiceManager::list, [&] (const auto &fqInstanceNames) {
+        // server pid, .ptr value of binder object, child pids
+        std::map<std::string, DebugInfo> allDebugInfos;
+        std::map<pid_t, std::map<uint64_t, Pids>> allPids;
+        for (const auto &fqInstanceName : fqInstanceNames) {
+            const auto pair = split(fqInstanceName, '/');
+            const auto &serviceName = pair.first;
+            const auto &instanceName = pair.second;
+            auto getRet = timeoutIPC(manager, &IServiceManager::get, serviceName, instanceName);
+            if (!getRet.isOk()) {
+                mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
+                     << "cannot be fetched from service manager:"
+                     << getRet.description() << std::endl;
+                status |= DUMP_BINDERIZED_ERROR;
+                continue;
+            }
+            sp<IBase> service = getRet;
+            if (service == nullptr) {
+                mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
+                     << "cannot be fetched from service manager (null)";
+                status |= DUMP_BINDERIZED_ERROR;
+                continue;
+            }
+            auto debugRet = timeoutIPC(service, &IBase::getDebugInfo, [&] (const auto &debugInfo) {
+                allDebugInfos[fqInstanceName] = debugInfo;
+                if (debugInfo.pid >= 0) {
+                    allPids[static_cast<pid_t>(debugInfo.pid)].clear();
+                }
+            });
+            if (!debugRet.isOk()) {
+                mErr << "Warning: Skipping \"" << fqInstanceName << "\": "
+                     << "debugging information cannot be retrieved:"
+                     << debugRet.description() << std::endl;
+                status |= DUMP_BINDERIZED_ERROR;
+            }
+        }
+        for (auto &pair : allPids) {
+            pid_t serverPid = pair.first;
+            if (!getReferencedPids(serverPid, &allPids[serverPid])) {
+                mErr << "Warning: no information for PID " << serverPid
+                          << ", are you root?" << std::endl;
+                status |= DUMP_BINDERIZED_ERROR;
+            }
+        }
+        for (const auto &fqInstanceName : fqInstanceNames) {
+            auto it = allDebugInfos.find(fqInstanceName);
+            if (it == allDebugInfos.end()) {
+                putEntry({
+                    .interfaceName = fqInstanceName,
+                    .transport = mode,
+                    .serverPid = NO_PID,
+                    .serverObjectAddress = NO_PTR,
+                    .clientPids = {}
+                });
+                continue;
+            }
+            const DebugInfo &info = it->second;
+            putEntry({
+                .interfaceName = fqInstanceName,
+                .transport = mode,
+                .serverPid = info.pid,
+                .serverObjectAddress = info.ptr,
+                .clientPids = info.pid == NO_PID || info.ptr == NO_PTR
+                        ? Pids{} : allPids[info.pid][info.ptr]
+            });
+        }
+
+    });
+    if (!listRet.isOk()) {
+        mErr << "Error: Failed to list services for " << mode << ": "
+             << listRet.description() << std::endl;
+        status |= DUMP_BINDERIZED_ERROR;
+    }
+    return status;
+}
+
+Status Lshal::fetch() {
+    Status status = OK;
+    auto bManager = ::android::hardware::defaultServiceManager();
+    if (bManager == nullptr) {
+        mErr << "Failed to get defaultServiceManager()!" << std::endl;
+        status |= NO_BINDERIZED_MANAGER;
+    } else {
+        status |= fetchBinderized(bManager);
+        // Passthrough PIDs are registered to the binderized manager as well.
+        status |= fetchPassthrough(bManager);
+    }
+
+    auto pManager = ::android::hardware::getPassthroughServiceManager();
+    if (pManager == nullptr) {
+        mErr << "Failed to get getPassthroughServiceManager()!" << std::endl;
+        status |= NO_PASSTHROUGH_MANAGER;
+    } else {
+        status |= fetchAllLibraries(pManager);
+    }
+    return status;
+}
+
+void Lshal::usage() const {
+    mErr
+        << "usage: lshal" << std::endl
+        << "           Dump all hals with default ordering and columns [-itpc]." << std::endl
+        << "       lshal [--interface|-i] [--transport|-t]" << std::endl
+        << "             [--pid|-p] [--address|-a] [--clients|-c] [--cmdline|-m]" << std::endl
+        << "             [--sort={interface|i|pid|p}]" << std::endl
+        << "           -i, --interface: print the interface name column" << std::endl
+        << "           -n, --instance: print the instance name column" << std::endl
+        << "           -t, --transport: print the transport mode column" << std::endl
+        << "           -p, --pid: print the server PID, or server cmdline if -m is set" << std::endl
+        << "           -a, --address: print the server object address column" << std::endl
+        << "           -c, --clients: print the client PIDs, or client cmdlines if -m is set"
+                                                                              << std::endl
+        << "           -m, --cmdline: print cmdline instead of PIDs" << std::endl
+        << "           --sort=i, --sort=interface: sort by interface name" << std::endl
+        << "           --sort=p, --sort=pid: sort by server pid" << std::endl
+        << "       lshal [-h|--help]" << std::endl
+        << "           -h, --help: show this help information." << std::endl;
+}
+
+Status Lshal::parseArgs(int argc, char **argv) {
+    static struct option longOptions[] = {
+        // long options with short alternatives
+        {"help",      no_argument,       0, 'h' },
+        {"interface", no_argument,       0, 'i' },
+        {"transport", no_argument,       0, 't' },
+        {"pid",       no_argument,       0, 'p' },
+        {"address",   no_argument,       0, 'a' },
+        {"clients",   no_argument,       0, 'c' },
+        {"cmdline",   no_argument,       0, 'm' },
+
+        // long options without short alternatives
+        {"sort",      required_argument, 0, 's' },
+        { 0,          0,                 0,  0  }
+    };
+
+    int optionIndex;
+    int c;
+    optind = 1;
+    for (;;) {
+        // using getopt_long in case we want to add other options in the future
+        c = getopt_long(argc, argv, "hitpacm", longOptions, &optionIndex);
+        if (c == -1) {
+            break;
+        }
+        switch (c) {
+        case 's': {
+            if (strcmp(optarg, "interface") == 0 || strcmp(optarg, "i") == 0) {
+                mSortColumn = TableEntry::sortByInterfaceName;
+            } else if (strcmp(optarg, "pid") == 0 || strcmp(optarg, "p") == 0) {
+                mSortColumn = TableEntry::sortByServerPid;
+            } else {
+                mErr << "Unrecognized sorting column: " << optarg << std::endl;
+                usage();
+                return USAGE;
+            }
+            break;
+        }
+        case 'i': {
+            mSelectedColumns |= ENABLE_INTERFACE_NAME;
+            break;
+        }
+        case 't': {
+            mSelectedColumns |= ENABLE_TRANSPORT;
+            break;
+        }
+        case 'p': {
+            mSelectedColumns |= ENABLE_SERVER_PID;
+            break;
+        }
+        case 'a': {
+            mSelectedColumns |= ENABLE_SERVER_ADDR;
+            break;
+        }
+        case 'c': {
+            mSelectedColumns |= ENABLE_CLIENT_PIDS;
+            break;
+        }
+        case 'm': {
+            mEnableCmdlines = true;
+            break;
+        }
+        case 'h': // falls through
+        default: // see unrecognized options
+            usage();
+            return USAGE;
+        }
+    }
+
+    if (mSelectedColumns == 0) {
+        mSelectedColumns = ENABLE_INTERFACE_NAME
+                | ENABLE_TRANSPORT | ENABLE_SERVER_PID | ENABLE_CLIENT_PIDS;
+    }
+    return OK;
+}
+
+int Lshal::main(int argc, char **argv) {
+    Status status = parseArgs(argc, argv);
+    if (status != OK) {
+        return status;
+    }
+    status = fetch();
+    postprocess();
+    dump();
+    return status;
+}
+
+}  // namespace lshal
+}  // namespace android
+
+int main(int argc, char **argv) {
+    return ::android::lshal::Lshal{}.main(argc, argv);
+}
diff --git a/cmds/lshal/Lshal.h b/cmds/lshal/Lshal.h
new file mode 100644
index 0000000..ead99dc
--- /dev/null
+++ b/cmds/lshal/Lshal.h
@@ -0,0 +1,89 @@
+/*
+ * 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 FRAMEWORK_NATIVE_CMDS_LSHAL_LSHAL_H_
+#define FRAMEWORK_NATIVE_CMDS_LSHAL_LSHAL_H_
+
+#include <stdint.h>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+#include <android/hidl/manager/1.0/IServiceManager.h>
+
+#include "TableEntry.h"
+
+namespace android {
+namespace lshal {
+
+enum : unsigned int {
+    OK                                      = 0,
+    USAGE                                   = 1 << 0,
+    NO_BINDERIZED_MANAGER                   = 1 << 1,
+    NO_PASSTHROUGH_MANAGER                  = 1 << 2,
+    DUMP_BINDERIZED_ERROR                   = 1 << 3,
+    DUMP_PASSTHROUGH_ERROR                  = 1 << 4,
+    DUMP_ALL_LIBS_ERROR                     = 1 << 5,
+};
+using Status = unsigned int;
+
+class Lshal {
+public:
+    int main(int argc, char **argv);
+
+private:
+    Status parseArgs(int argc, char **argv);
+    Status fetch();
+    void postprocess();
+    void dump() const;
+    void usage() const;
+    void putEntry(TableEntry &&entry);
+    Status fetchPassthrough(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+    Status fetchBinderized(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+    Status fetchAllLibraries(const sp<::android::hidl::manager::V1_0::IServiceManager> &manager);
+    bool getReferencedPids(
+        pid_t serverPid, std::map<uint64_t, Pids> *objects) const;
+    void printLine(
+            const std::string &interfaceName,
+            const std::string &transport, const std::string &server,
+            const std::string &serverCmdline,
+            const std::string &address, const std::string &clients,
+            const std::string &clientCmdlines) const ;
+    // Return /proc/{pid}/cmdline if it exists, else empty string.
+    const std::string &getCmdline(pid_t pid);
+    // Call getCmdline on all pid in pids. If it returns empty string, the process might
+    // have died, and the pid is removed from pids.
+    void removeDeadProcesses(Pids *pids);
+
+    Table mTable{};
+    std::ostream &mErr = std::cerr;
+    std::ostream &mOut = std::cout;
+    TableEntryCompare mSortColumn = nullptr;
+    TableEntrySelect mSelectedColumns = 0;
+    // If true, cmdlines will be printed instead of pid.
+    bool mEnableCmdlines;
+    // If an entry does not exist, need to ask /proc/{pid}/cmdline to get it.
+    // If an entry exist but is an empty string, process might have died.
+    // If an entry exist and not empty, it contains the cached content of /proc/{pid}/cmdline.
+    std::map<pid_t, std::string> mCmdlines;
+};
+
+
+}  // namespace lshal
+}  // namespace android
+
+#endif  // FRAMEWORK_NATIVE_CMDS_LSHAL_LSHAL_H_
diff --git a/cmds/lshal/TableEntry.h b/cmds/lshal/TableEntry.h
new file mode 100644
index 0000000..4ec3a0c
--- /dev/null
+++ b/cmds/lshal/TableEntry.h
@@ -0,0 +1,69 @@
+/*
+ * 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 FRAMEWORK_NATIVE_CMDS_LSHAL_TABLE_ENTRY_H_
+#define FRAMEWORK_NATIVE_CMDS_LSHAL_TABLE_ENTRY_H_
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+#include <iostream>
+
+namespace android {
+namespace lshal {
+
+using Pids = std::vector<int32_t>;
+
+struct TableEntry {
+    std::string interfaceName;
+    std::string transport;
+    int32_t serverPid;
+    std::string serverCmdline;
+    uint64_t serverObjectAddress;
+    Pids clientPids;
+    std::vector<std::string> clientCmdlines;
+
+    static bool sortByInterfaceName(const TableEntry &a, const TableEntry &b) {
+        return a.interfaceName < b.interfaceName;
+    };
+    static bool sortByServerPid(const TableEntry &a, const TableEntry &b) {
+        return a.serverPid < b.serverPid;
+    };
+};
+
+using Table = std::vector<TableEntry>;
+using TableEntryCompare = std::function<bool(const TableEntry &, const TableEntry &)>;
+
+enum : unsigned int {
+    ENABLE_INTERFACE_NAME = 1 << 0,
+    ENABLE_TRANSPORT      = 1 << 1,
+    ENABLE_SERVER_PID     = 1 << 2,
+    ENABLE_SERVER_ADDR    = 1 << 3,
+    ENABLE_CLIENT_PIDS    = 1 << 4
+};
+
+using TableEntrySelect = unsigned int;
+
+enum {
+    NO_PID = -1,
+    NO_PTR = 0
+};
+
+}  // namespace lshal
+}  // namespace android
+
+#endif  // FRAMEWORK_NATIVE_CMDS_LSHAL_TABLE_ENTRY_H_
diff --git a/cmds/lshal/Timeout.h b/cmds/lshal/Timeout.h
new file mode 100644
index 0000000..bf883c0
--- /dev/null
+++ b/cmds/lshal/Timeout.h
@@ -0,0 +1,81 @@
+/*
+ * 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 <condition_variable>
+#include <chrono>
+#include <functional>
+#include <mutex>
+#include <thread>
+
+#include <hidl/Status.h>
+
+namespace android {
+namespace lshal {
+
+static constexpr std::chrono::milliseconds IPC_CALL_WAIT{500};
+
+class BackgroundTaskState {
+public:
+    BackgroundTaskState(){}
+    void notify() {
+        std::unique_lock<std::mutex> lock(mMutex);
+        mFinished = true;
+        lock.unlock();
+        mCondVar.notify_all();
+    }
+    template<class C, class D>
+    bool wait(std::chrono::time_point<C, D> end) {
+        std::unique_lock<std::mutex> lock(mMutex);
+        mCondVar.wait_until(lock, end, [this](){ return this->mFinished; });
+        return mFinished;
+    }
+private:
+    std::mutex mMutex;
+    std::condition_variable mCondVar;
+    bool mFinished = false;
+};
+
+template<class R, class P>
+bool timeout(std::chrono::duration<R, P> delay, const std::function<void(void)> &func) {
+    auto now = std::chrono::system_clock::now();
+    BackgroundTaskState state{};
+    std::thread t([&state, &func] {
+        func();
+        state.notify();
+    });
+    t.detach();
+    bool success = state.wait(now + delay);
+    return success;
+}
+
+template<class Function, class I, class... Args>
+typename std::result_of<Function(I *, Args...)>::type
+timeoutIPC(const sp<I> &interfaceObject, Function &&func, Args &&... args) {
+    using ::android::hardware::Status;
+    typename std::result_of<Function(I *, Args...)>::type ret{Status::ok()};
+    auto boundFunc = std::bind(std::forward<Function>(func),
+            interfaceObject.get(), std::forward<Args>(args)...);
+    bool success = timeout(IPC_CALL_WAIT, [&ret, &boundFunc] {
+        ret = boundFunc();
+    });
+    if (!success) {
+        return Status::fromStatusT(TIMED_OUT);
+    }
+    return ret;
+}
+
+}  // namespace lshal
+}  // namespace android
diff --git a/cmds/lshal/lshal.cpp b/cmds/lshal/lshal.cpp
deleted file mode 100644
index 9998a46..0000000
--- a/cmds/lshal/lshal.cpp
+++ /dev/null
@@ -1,306 +0,0 @@
-/*
- * 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 <getopt.h>
-
-#include <map>
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <sstream>
-#include <regex>
-
-#include <android-base/parseint.h>
-#include <android/hidl/manager/1.0/IServiceManager.h>
-#include <hidl/ServiceManagement.h>
-
-using ::android::sp;
-using ::android::hardware::hidl_string;
-using ::android::hidl::manager::V1_0::IServiceManager;
-
-template <typename A, typename B, typename C, typename D, typename E, typename F>
-void printColumn(std::stringstream &stream,
-        const A &a, const B &b, const C &c, const D &d, const E &, const F &f) {
-    using namespace ::std;
-    stream << left
-           << setw(70) << a << "\t"
-           << setw(20) << b << "\t"
-           << setw(10) << c << "\t"
-           << setw(5)  << d << "\t"
-           // TODO(b/34984175): enable selecting columns
-           // << setw(16) << e << "\t"
-           << setw(0)  << f
-           << endl;
-}
-
-template <typename A>
-std::string join(const A &components, const std::string &separator) {
-    std::stringstream out;
-    bool first = true;
-    for (const auto &component : components) {
-        if (!first) {
-            out << separator;
-        }
-        out << component;
-
-        first = false;
-    }
-    return out.str();
-}
-
-std::string toHexString(uint64_t t) {
-    std::ostringstream os;
-    os << std::hex << std::setfill('0') << std::setw(16) << t;
-    return os.str();
-}
-
-std::pair<hidl_string, hidl_string> split(const hidl_string &s, char c) {
-    const char *pos = strchr(s.c_str(), c);
-    if (pos == nullptr) {
-        return {s, {}};
-    }
-    return {hidl_string(s.c_str(), pos - s.c_str()), hidl_string(pos + 1)};
-}
-
-bool getReferencedPids(
-        pid_t serverPid, std::map<uint64_t, std::string> *objects) {
-
-    std::ifstream ifs("/d/binder/proc/" + std::to_string(serverPid));
-    if (!ifs.is_open()) {
-        return false;
-    }
-
-    static const std::regex prefix("^\\s*node \\d+:\\s+u([0-9a-f]+)\\s+c([0-9a-f]+)\\s+");
-
-    std::string line;
-    std::smatch match;
-    while(getline(ifs, line)) {
-        if (!std::regex_search(line, match, prefix)) {
-            // the line doesn't start with the correct prefix
-            continue;
-        }
-        std::string ptrString = "0x" + match.str(2); // use number after c
-        uint64_t ptr;
-        if (!::android::base::ParseUint(ptrString.c_str(), &ptr)) {
-            // Should not reach here, but just be tolerant.
-            std::cerr << "Could not parse number " << ptrString << std::endl;
-            continue;
-        }
-        const std::string proc = " proc ";
-        auto pos = line.rfind(proc);
-        if (pos != std::string::npos) {
-            (*objects)[ptr] += line.substr(pos + proc.size());
-        }
-    }
-    return true;
-}
-
-void dumpAllLibraries(std::stringstream &stream, const std::string &mode,
-            const sp<IServiceManager> &manager) {
-    using namespace ::std;
-    using namespace ::android::hardware;
-    using namespace ::android::hidl::manager::V1_0;
-    using namespace ::android::hidl::base::V1_0;
-    auto ret = manager->list([&] (const auto &fqInstanceNames) {
-        for (const auto &fqInstanceName : fqInstanceNames) {
-            const auto pair = split(fqInstanceName, '/');
-            const auto &serviceName = pair.first;
-            const auto &instanceName = pair.second;
-            printColumn(stream,
-                serviceName,
-                instanceName,
-                mode,
-                "N/A",
-                "N/A",
-                "N/A");
-        }
-    });
-    if (!ret.isOk()) {
-        cerr << "Error: Failed to call debugDump on defaultServiceManager(): "
-             << ret.description() << endl;
-    }
-}
-
-void dumpPassthrough(std::stringstream &stream, const std::string &mode,
-            const sp<IServiceManager> &manager) {
-    using namespace ::std;
-    using namespace ::android::hardware;
-    using namespace ::android::hidl::manager::V1_0;
-    using namespace ::android::hidl::base::V1_0;
-    auto ret = manager->debugDump([&] (const auto &infos) {
-        for (const auto &info : infos) {
-
-            printColumn(stream,
-                info.interfaceName,
-                info.instanceName,
-                mode,
-                info.clientPids.size() == 1 ? std::to_string(info.clientPids[0]) : "N/A",
-                "N/A",
-                join(info.clientPids, " "));
-        }
-    });
-    if (!ret.isOk()) {
-        cerr << "Error: Failed to call debugDump on defaultServiceManager(): "
-             << ret.description() << endl;
-    }
-}
-
-void dumpBinderized(std::stringstream &stream, const std::string &mode,
-            const sp<IServiceManager> &manager) {
-    using namespace ::std;
-    using namespace ::android::hardware;
-    using namespace ::android::hidl::manager::V1_0;
-    using namespace ::android::hidl::base::V1_0;
-    auto listRet = manager->list([&] (const auto &fqInstanceNames) {
-        // server pid, .ptr value of binder object, child pids
-        std::map<std::string, DebugInfo> allDebugInfos;
-        std::map<pid_t, std::map<uint64_t, std::string>> allPids;
-        for (const auto &fqInstanceName : fqInstanceNames) {
-            const auto pair = split(fqInstanceName, '/');
-            const auto &serviceName = pair.first;
-            const auto &instanceName = pair.second;
-            auto getRet = manager->get(serviceName, instanceName);
-            if (!getRet.isOk()) {
-                cerr << "Warning: Skipping \"" << fqInstanceName << "\": "
-                     << "cannot be fetched from service manager:"
-                     << getRet.description() << endl;
-                continue;
-            }
-            sp<IBase> service = getRet;
-            if (service == nullptr) {
-                cerr << "Warning: Skipping \"" << fqInstanceName << "\": "
-                     << "cannot be fetched from service manager (null)";
-                continue;
-            }
-            auto debugRet = service->getDebugInfo([&] (const auto &debugInfo) {
-                allDebugInfos[fqInstanceName] = debugInfo;
-                if (debugInfo.pid >= 0) {
-                    allPids[static_cast<pid_t>(debugInfo.pid)].clear();
-                }
-            });
-            if (!debugRet.isOk()) {
-                cerr << "Warning: Skipping \"" << fqInstanceName << "\": "
-                     << "debugging information cannot be retrieved:"
-                     << debugRet.description() << endl;
-            }
-        }
-        for (auto &pair : allPids) {
-            pid_t serverPid = pair.first;
-            if (!getReferencedPids(serverPid, &allPids[serverPid])) {
-                std::cerr << "Warning: no information for PID " << serverPid
-                          << ", are you root?" << std::endl;
-            }
-        }
-        for (const auto &fqInstanceName : fqInstanceNames) {
-            const auto pair = split(fqInstanceName, '/');
-            const auto &serviceName = pair.first;
-            const auto &instanceName = pair.second;
-            auto it = allDebugInfos.find(fqInstanceName);
-            if (it == allDebugInfos.end()) {
-                printColumn(stream,
-                    serviceName,
-                    instanceName,
-                    mode,
-                    "N/A",
-                    "N/A",
-                    ""
-                );
-                continue;
-            }
-            const DebugInfo &info = it->second;
-            printColumn(stream,
-                serviceName,
-                instanceName,
-                mode,
-                info.pid < 0 ? "N/A" : std::to_string(info.pid),
-                info.ptr == 0 ? "N/A" : toHexString(info.ptr),
-                info.pid < 0 || info.ptr == 0 ? "" : allPids[info.pid][info.ptr]
-            );
-        }
-
-    });
-    if (!listRet.isOk()) {
-        cerr << "Error: Failed to list services for " << mode << ": "
-             << listRet.description() << endl;
-    }
-}
-
-int dump() {
-    using namespace ::std;
-    using namespace ::android::hardware;
-
-    std::stringstream stream;
-
-    stream << "All services:" << endl;
-    stream << left;
-    printColumn(stream, "Interface", "Instance", "Transport", "Server", "PTR", "Clients");
-
-    auto bManager = defaultServiceManager();
-    if (bManager == nullptr) {
-        cerr << "Failed to get defaultServiceManager()!" << endl;
-    } else {
-        dumpBinderized(stream, "hwbinder", bManager);
-        // Passthrough PIDs are registered to the binderized manager as well.
-        dumpPassthrough(stream, "passthrough", bManager);
-    }
-
-    auto pManager = getPassthroughServiceManager();
-    if (pManager == nullptr) {
-        cerr << "Failed to get getPassthroughServiceManager()!" << endl;
-    } else {
-        dumpAllLibraries(stream, "passthrough", pManager);
-    }
-
-    cout << stream.rdbuf();
-    return 0;
-}
-
-int usage() {
-    using namespace ::std;
-    cerr
-        << "usage: lshal" << endl
-        << "           To dump all hals." << endl
-        << "or:" << endl
-        << "       lshal [-h|--help]" << endl
-        << "           -h, --help: show this help information." << endl;
-    return -1;
-}
-
-int main(int argc, char **argv) {
-    static struct option longOptions[] = {
-        {"help", no_argument, 0, 'h' },
-        { 0,               0, 0,  0  }
-    };
-
-    int optionIndex;
-    int c;
-    optind = 1;
-    for (;;) {
-        // using getopt_long in case we want to add other options in the future
-        c = getopt_long(argc, argv, "h", longOptions, &optionIndex);
-        if (c == -1) {
-            break;
-        }
-        switch (c) {
-        case 'h': // falls through
-        default: // see unrecognized options
-            return usage();
-        }
-    }
-    return dump();
-
-}
diff --git a/include/audiomanager/IPlayer.h b/include/audiomanager/IPlayer.h
index 94afae5..de5c1c7 100644
--- a/include/audiomanager/IPlayer.h
+++ b/include/audiomanager/IPlayer.h
@@ -20,6 +20,7 @@
 #include <stdint.h>
 #include <sys/types.h>
 
+#include <media/VolumeShaper.h>
 #include <utils/RefBase.h>
 #include <utils/Errors.h>
 #include <binder/IInterface.h>
@@ -45,6 +46,9 @@
 
     virtual void setStartDelayMs(int delayMs) = 0;
 
+    virtual void applyVolumeShaper(
+            const sp<VolumeShaper::Configuration>& configuration,
+            const sp<VolumeShaper::Operation>& operation) = 0;
 };
 
 // ----------------------------------------------------------------------------
diff --git a/include/gui/FrameTimestamps.h b/include/gui/FrameTimestamps.h
index 46ca2c2..9e1ae94 100644
--- a/include/gui/FrameTimestamps.h
+++ b/include/gui/FrameTimestamps.h
@@ -95,6 +95,11 @@
     std::shared_ptr<FenceTime> releaseFence{FenceTime::NO_FENCE};
 };
 
+struct CompositorTiming {
+    nsecs_t deadline{0};
+    nsecs_t interval{16666667};
+    nsecs_t presentLatency{0};
+};
 
 // A short history of frames that are synchronized between the consumer and
 // producer via deltas.
@@ -111,6 +116,8 @@
 
 protected:
     std::array<FrameEvents, MAX_FRAME_HISTORY> mFrames;
+
+    CompositorTiming mCompositorTiming;
 };
 
 
@@ -119,6 +126,16 @@
 public:
     ~ProducerFrameEventHistory() override;
 
+    // Public for testing.
+    static nsecs_t snapToNextTick(
+            nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval);
+
+    nsecs_t getNextCompositeDeadline(const nsecs_t now) const;
+    nsecs_t getCompositeInterval() const { return mCompositorTiming.interval; }
+    nsecs_t getCompositeToPresentLatency() const {
+        return mCompositorTiming.presentLatency;
+    }
+
     // virtual for testing.
     virtual void updateAcquireFence(
             uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire);
@@ -189,12 +206,15 @@
 public:
     ~ConsumerFrameEventHistory() override;
 
+    void initializeCompositorTiming(const CompositorTiming& compositorTiming);
+
     void addQueue(const NewFrameEventsEntry& newEntry);
     void addLatch(uint64_t frameNumber, nsecs_t latchTime);
     void addPreComposition(uint64_t frameNumber, nsecs_t refreshStartTime);
     void addPostComposition(uint64_t frameNumber,
             const std::shared_ptr<FenceTime>& gpuCompositionDone,
-            const std::shared_ptr<FenceTime>& displayPresent);
+            const std::shared_ptr<FenceTime>& displayPresent,
+            const CompositorTiming& compositorTiming);
     void addRetire(uint64_t frameNumber,
             const std::shared_ptr<FenceTime>& displayRetire);
     void addRelease(uint64_t frameNumber, nsecs_t dequeueReadyTime,
@@ -244,7 +264,7 @@
             size_t& count);
 
 private:
-    static size_t minFlattenedSize();
+    static constexpr size_t minFlattenedSize();
 
     size_t mIndex{0};
     uint64_t mFrameNumber{0};
@@ -306,9 +326,10 @@
             size_t& count);
 
 private:
-    static size_t minFlattenedSize();
+    static constexpr size_t minFlattenedSize();
 
     std::vector<FrameEventsDelta> mDeltas;
+    CompositorTiming mCompositorTiming;
 };
 
 
diff --git a/include/gui/Surface.h b/include/gui/Surface.h
index 966e70d..a3c2bfa 100644
--- a/include/gui/Surface.h
+++ b/include/gui/Surface.h
@@ -135,12 +135,18 @@
     status_t getLastQueuedBuffer(sp<GraphicBuffer>* outBuffer,
             sp<Fence>* outFence, float outTransformMatrix[16]);
 
+    status_t getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration);
+
     /* Enables or disables frame timestamp tracking. It is disabled by default
      * to avoid overhead during queue and dequeue for applications that don't
      * need the feature. If disabled, calls to getFrameTimestamps will fail.
      */
     void enableFrameTimestamps(bool enable);
 
+    status_t getCompositorTiming(
+            nsecs_t* compositeDeadline, nsecs_t* compositeInterval,
+            nsecs_t* compositeToPresentLatency);
+
     // See IGraphicBufferProducer::getFrameTimestamps
     status_t getFrameTimestamps(uint64_t frameNumber,
             nsecs_t* outRequestedPresentTime, nsecs_t* outAcquireTime,
@@ -148,7 +154,6 @@
             nsecs_t* outLastRefreshStartTime, nsecs_t* outGlCompositionDoneTime,
             nsecs_t* outDisplayPresentTime, nsecs_t* outDisplayRetireTime,
             nsecs_t* outDequeueReadyTime, nsecs_t* outReleaseTime);
-    status_t getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration);
 
     status_t getUniqueId(uint64_t* outId) const;
 
@@ -157,6 +162,7 @@
 
     // Virtual for testing.
     virtual sp<ISurfaceComposer> composerService() const;
+    virtual nsecs_t now() const;
 
 private:
     // can't be copied
@@ -204,10 +210,11 @@
     int dispatchSetSurfaceDamage(va_list args);
     int dispatchSetSharedBufferMode(va_list args);
     int dispatchSetAutoRefresh(va_list args);
+    int dispatchGetDisplayRefreshCycleDuration(va_list args);
     int dispatchGetNextFrameId(va_list args);
     int dispatchEnableFrameTimestamps(va_list args);
+    int dispatchGetCompositorTiming(va_list args);
     int dispatchGetFrameTimestamps(va_list args);
-    int dispatchGetDisplayRefreshCycleDuration(va_list args);
 
 protected:
     virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);
diff --git a/libs/gui/FrameTimestamps.cpp b/libs/gui/FrameTimestamps.cpp
index 73537bf..a6fa38a 100644
--- a/libs/gui/FrameTimestamps.cpp
+++ b/libs/gui/FrameTimestamps.cpp
@@ -235,6 +235,23 @@
 
 ProducerFrameEventHistory::~ProducerFrameEventHistory() = default;
 
+nsecs_t ProducerFrameEventHistory::snapToNextTick(
+        nsecs_t timestamp, nsecs_t tickPhase, nsecs_t tickInterval) {
+    nsecs_t tickOffset = (tickPhase - timestamp) % tickInterval;
+    // Integer modulo rounds towards 0 and not -inf before taking the remainder,
+    // so adjust the offset if it is negative.
+    if (tickOffset < 0) {
+        tickOffset += tickInterval;
+    }
+    return timestamp + tickOffset;
+}
+
+nsecs_t ProducerFrameEventHistory::getNextCompositeDeadline(
+        const nsecs_t now) const{
+    return snapToNextTick(
+            now, mCompositorTiming.deadline, mCompositorTiming.interval);
+}
+
 void ProducerFrameEventHistory::updateAcquireFence(
         uint64_t frameNumber, std::shared_ptr<FenceTime>&& acquire) {
     FrameEvents* frame = getFrame(frameNumber, &mAcquireOffset);
@@ -256,6 +273,8 @@
 
 void ProducerFrameEventHistory::applyDelta(
         const FrameEventHistoryDelta& delta) {
+    mCompositorTiming = delta.mCompositorTiming;
+
     for (auto& d : delta.mDeltas) {
         // Avoid out-of-bounds access.
         if (d.mIndex >= mFrames.size()) {
@@ -346,6 +365,11 @@
 
 ConsumerFrameEventHistory::~ConsumerFrameEventHistory() = default;
 
+void ConsumerFrameEventHistory::initializeCompositorTiming(
+        const CompositorTiming& compositorTiming) {
+    mCompositorTiming = compositorTiming;
+}
+
 void ConsumerFrameEventHistory::addQueue(const NewFrameEventsEntry& newEntry) {
     // Overwrite all fields of the frame with default values unless set here.
     FrameEvents newTimestamps;
@@ -393,7 +417,10 @@
 
 void ConsumerFrameEventHistory::addPostComposition(uint64_t frameNumber,
         const std::shared_ptr<FenceTime>& gpuCompositionDone,
-        const std::shared_ptr<FenceTime>& displayPresent) {
+        const std::shared_ptr<FenceTime>& displayPresent,
+        const CompositorTiming& compositorTiming) {
+    mCompositorTiming = compositorTiming;
+
     FrameEvents* frame = getFrame(frameNumber, &mCompositionOffset);
     if (frame == nullptr) {
         ALOGE_IF(mProducerWantsEvents,
@@ -450,6 +477,8 @@
 
 void ConsumerFrameEventHistory::getAndResetDelta(
         FrameEventHistoryDelta* delta) {
+    delta->mCompositorTiming = mCompositorTiming;
+
     // Write these in order of frame number so that it is easy to
     // add them to a FenceTimeline in the proper order producer side.
     delta->mDeltas.reserve(mFramesDirty.size());
@@ -499,9 +528,8 @@
     }
 }
 
-size_t FrameEventsDelta::minFlattenedSize() {
-    constexpr size_t min =
-            sizeof(FrameEventsDelta::mFrameNumber) +
+constexpr size_t FrameEventsDelta::minFlattenedSize() {
+    return sizeof(FrameEventsDelta::mFrameNumber) +
             sizeof(uint8_t) + // mIndex
             sizeof(uint8_t) + // mAddPostCompositeCalled
             sizeof(uint8_t) + // mAddRetireCalled
@@ -512,7 +540,6 @@
             sizeof(FrameEventsDelta::mFirstRefreshStartTime) +
             sizeof(FrameEventsDelta::mLastRefreshStartTime) +
             sizeof(FrameEventsDelta::mDequeueReadyTime);
-    return min;
 }
 
 // Flattenable implementation
@@ -618,6 +645,8 @@
 
 FrameEventHistoryDelta& FrameEventHistoryDelta::operator=(
         FrameEventHistoryDelta&& src) {
+    mCompositorTiming = src.mCompositorTiming;
+
     if (CC_UNLIKELY(!mDeltas.empty())) {
         ALOGE("FrameEventHistoryDelta: Clobbering history.");
     }
@@ -626,8 +655,9 @@
     return *this;
 }
 
-size_t FrameEventHistoryDelta::minFlattenedSize() {
-    return sizeof(uint32_t);
+constexpr size_t FrameEventHistoryDelta::minFlattenedSize() {
+    return sizeof(uint32_t) + // mDeltas.size()
+            sizeof(mCompositorTiming);
 }
 
 size_t FrameEventHistoryDelta::getFlattenedSize() const {
@@ -654,6 +684,8 @@
         return NO_MEMORY;
     }
 
+    FlattenableUtils::write(buffer, size, mCompositorTiming);
+
     FlattenableUtils::write(
             buffer, size, static_cast<uint32_t>(mDeltas.size()));
     for (auto& d : mDeltas) {
@@ -671,6 +703,8 @@
         return NO_MEMORY;
     }
 
+    FlattenableUtils::read(buffer, size, mCompositorTiming);
+
     uint32_t deltaCount = 0;
     FlattenableUtils::read(buffer, size, deltaCount);
     if (deltaCount > FrameEventHistory::MAX_FRAME_HISTORY) {
diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp
index d1f9f6a..d285ef0 100644
--- a/libs/gui/Surface.cpp
+++ b/libs/gui/Surface.cpp
@@ -100,6 +100,10 @@
     return ComposerService::getComposerService();
 }
 
+nsecs_t Surface::now() const {
+    return systemTime();
+}
+
 sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const {
     return mGraphicBufferProducer;
 }
@@ -142,11 +146,51 @@
             outTransformMatrix);
 }
 
+status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) {
+    ATRACE_CALL();
+
+    DisplayStatInfo stats;
+    status_t err = composerService()->getDisplayStats(NULL, &stats);
+
+    *outRefreshDuration = stats.vsyncPeriod;
+
+    return NO_ERROR;
+}
+
 void Surface::enableFrameTimestamps(bool enable) {
     Mutex::Autolock lock(mMutex);
+    // If going from disabled to enabled, get the initial values for
+    // compositor and display timing.
+    if (!mEnableFrameTimestamps && enable) {
+        FrameEventHistoryDelta delta;
+        mGraphicBufferProducer->getFrameTimestamps(&delta);
+        mFrameEventHistory->applyDelta(delta);
+    }
     mEnableFrameTimestamps = enable;
 }
 
+status_t Surface::getCompositorTiming(
+        nsecs_t* compositeDeadline, nsecs_t* compositeInterval,
+        nsecs_t* compositeToPresentLatency) {
+    Mutex::Autolock lock(mMutex);
+    if (!mEnableFrameTimestamps) {
+        return INVALID_OPERATION;
+    }
+
+    if (compositeDeadline != nullptr) {
+        *compositeDeadline =
+                mFrameEventHistory->getNextCompositeDeadline(now());
+    }
+    if (compositeInterval != nullptr) {
+        *compositeInterval = mFrameEventHistory->getCompositeInterval();
+    }
+    if (compositeToPresentLatency != nullptr) {
+        *compositeToPresentLatency =
+                mFrameEventHistory->getCompositeToPresentLatency();
+    }
+    return NO_ERROR;
+}
+
 static bool checkConsumerForUpdates(
         const FrameEvents* e, const uint64_t lastFrameNumber,
         const nsecs_t* outLatchTime,
@@ -260,16 +304,6 @@
 
     return NO_ERROR;
 }
-status_t Surface::getDisplayRefreshCycleDuration(nsecs_t* outRefreshDuration) {
-    ATRACE_CALL();
-
-    DisplayStatInfo stats;
-    status_t err = composerService()->getDisplayStats(NULL, &stats);
-
-    *outRefreshDuration = stats.vsyncPeriod;
-
-    return NO_ERROR;
-}
 
 int Surface::hook_setSwapInterval(ANativeWindow* window, int interval) {
     Surface* c = getSelf(window);
@@ -831,18 +865,21 @@
     case NATIVE_WINDOW_SET_AUTO_REFRESH:
         res = dispatchSetAutoRefresh(args);
         break;
+    case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
+        res = dispatchGetDisplayRefreshCycleDuration(args);
+        break;
     case NATIVE_WINDOW_GET_NEXT_FRAME_ID:
         res = dispatchGetNextFrameId(args);
         break;
     case NATIVE_WINDOW_ENABLE_FRAME_TIMESTAMPS:
         res = dispatchEnableFrameTimestamps(args);
         break;
+    case NATIVE_WINDOW_GET_COMPOSITOR_TIMING:
+        res = dispatchGetCompositorTiming(args);
+        break;
     case NATIVE_WINDOW_GET_FRAME_TIMESTAMPS:
         res = dispatchGetFrameTimestamps(args);
         break;
-    case NATIVE_WINDOW_GET_REFRESH_CYCLE_DURATION:
-        res = dispatchGetDisplayRefreshCycleDuration(args);
-        break;
     default:
         res = NAME_NOT_FOUND;
         break;
@@ -963,6 +1000,11 @@
     return setAutoRefresh(autoRefresh);
 }
 
+int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
+    nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
+    return getDisplayRefreshCycleDuration(outRefreshDuration);
+}
+
 int Surface::dispatchGetNextFrameId(va_list args) {
     uint64_t* nextFrameId = va_arg(args, uint64_t*);
     *nextFrameId = getNextFrameNumber();
@@ -975,6 +1017,14 @@
     return NO_ERROR;
 }
 
+int Surface::dispatchGetCompositorTiming(va_list args) {
+    nsecs_t* compositeDeadline = va_arg(args, int64_t*);
+    nsecs_t* compositeInterval = va_arg(args, int64_t*);
+    nsecs_t* compositeToPresentLatency = va_arg(args, int64_t*);
+    return getCompositorTiming(compositeDeadline, compositeInterval,
+            compositeToPresentLatency);
+}
+
 int Surface::dispatchGetFrameTimestamps(va_list args) {
     uint64_t frameId = va_arg(args, uint64_t);
     nsecs_t* outRequestedPresentTime = va_arg(args, int64_t*);
@@ -994,11 +1044,6 @@
             outDisplayRetireTime, outDequeueReadyTime, outReleaseTime);
 }
 
-int Surface::dispatchGetDisplayRefreshCycleDuration(va_list args) {
-    nsecs_t* outRefreshDuration = va_arg(args, int64_t*);
-    return getDisplayRefreshCycleDuration(outRefreshDuration);
-}
-
 int Surface::connect(int api) {
     static sp<IProducerListener> listener = new DummyProducerListener();
     return connect(api, listener);
diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp
index 3f56665..5298027 100644
--- a/libs/gui/tests/Surface_test.cpp
+++ b/libs/gui/tests/Surface_test.cpp
@@ -479,8 +479,17 @@
         return mFakeSurfaceComposer;
     }
 
+    nsecs_t now() const override {
+        return mNow;
+    }
+
+    void setNow(nsecs_t now) {
+        mNow = now;
+    }
+
 public:
     sp<FakeSurfaceComposer> mFakeSurfaceComposer;
+    nsecs_t mNow = 0;
 
     // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
     // but this raw pointer gives access to test functionality.
@@ -500,10 +509,12 @@
 
     struct RefreshEvents {
         RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
-            : mFenceMap(fenceMap),
-              kStartTime(refreshStart + 1),
-              kGpuCompositionDoneTime(refreshStart + 2),
-              kPresentTime(refreshStart + 3) {}
+          : mFenceMap(fenceMap),
+            kCompositorTiming(
+                {refreshStart, refreshStart + 1, refreshStart + 2 }),
+            kStartTime(refreshStart + 3),
+            kGpuCompositionDoneTime(refreshStart + 4),
+            kPresentTime(refreshStart + 5) {}
 
         void signalPostCompositeFences() {
             mFenceMap.signalAllForTest(
@@ -516,6 +527,8 @@
         FenceAndFenceTime mGpuCompositionDone { mFenceMap };
         FenceAndFenceTime mPresent { mFenceMap };
 
+        const CompositorTiming kCompositorTiming;
+
         const nsecs_t kStartTime;
         const nsecs_t kGpuCompositionDoneTime;
         const nsecs_t kPresentTime;
@@ -592,6 +605,12 @@
         native_window_set_buffer_count(mWindow.get(), 4);
     }
 
+    void disableFrameTimestamps() {
+        mFakeConsumer->mGetFrameTimestampsEnabled = false;
+        native_window_enable_frame_timestamps(mWindow.get(), 0);
+        mFrameTimestampsEnabled = false;
+    }
+
     void enableFrameTimestamps() {
         mFakeConsumer->mGetFrameTimestampsEnabled = true;
         native_window_enable_frame_timestamps(mWindow.get(), 1);
@@ -681,7 +700,8 @@
                     oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
                     FenceTime::NO_FENCE;
             mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
-                    oldFrame->mRefreshes[2].mPresent.mFenceTime);
+                    oldFrame->mRefreshes[2].mPresent.mFenceTime,
+                    oldFrame->mRefreshes[2].kCompositorTiming);
         }
 
         // Latch the new frame.
@@ -698,7 +718,8 @@
                     std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
         }
         mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
-                newFrame->mRefreshes[0].mPresent.mFenceTime);
+                newFrame->mRefreshes[0].mPresent.mFenceTime,
+                newFrame->mRefreshes[0].kCompositorTiming);
 
         // Retire the previous buffer just after compositing the new buffer.
         if (oldFrame != nullptr) {
@@ -710,7 +731,8 @@
                 newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
                 FenceTime::NO_FENCE;
         mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
-                newFrame->mRefreshes[1].mPresent.mFenceTime);
+                newFrame->mRefreshes[1].mPresent.mFenceTime,
+                newFrame->mRefreshes[1].kCompositorTiming);
     }
 
     void QueryPresentRetireSupported(
@@ -740,7 +762,8 @@
     int64_t outDequeueReadyTime = -1;
     int64_t outReleaseTime = -1;
 
-    FrameEvents mFrames[2] { { mFenceMap, 1000 }, { mFenceMap, 2000 } };
+    FrameEvents mFrames[3] {
+        { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
 };
 
 
@@ -773,25 +796,55 @@
     int result = getAllFrameTimestamps(fId);
     EXPECT_EQ(INVALID_OPERATION, result);
     EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
+
+    // Verify compositor timing query fails.
+    nsecs_t compositeDeadline = 0;
+    nsecs_t compositeInterval = 0;
+    nsecs_t compositeToPresentLatency = 0;
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(INVALID_OPERATION, result);
 }
 
 // This test verifies that the frame timestamps are retrieved if explicitly
 // enabled via native_window_enable_frame_timestamps.
 TEST_F(GetFrameTimestampsTest, EnabledSimple) {
+    CompositorTiming initialCompositorTiming {
+        1000000000, // 1s deadline
+        16666667, // 16ms interval
+        50000000, // 50ms present latency
+    };
+    mCfeh->initializeCompositorTiming(initialCompositorTiming);
+
     enableFrameTimestamps();
 
+    // Verify the compositor timing query gets the initial compositor values
+    // after timststamps are enabled; even before the first frame is queued
+    // or dequeued.
+    nsecs_t compositeDeadline = 0;
+    nsecs_t compositeInterval = 0;
+    nsecs_t compositeToPresentLatency = 0;
+    mSurface->setNow(initialCompositorTiming.deadline - 1);
+    int result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
+    EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
+    EXPECT_EQ(initialCompositorTiming.presentLatency,
+              compositeToPresentLatency);
+
     int fence;
     ANativeWindowBuffer* buffer;
 
     EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
-    EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
+    EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
 
     const uint64_t fId1 = getNextFrameId();
 
     // Verify getFrameTimestamps is piggybacked on dequeue.
     ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
     EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
-    EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
+    EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
 
     NewFrameEventsEntry f1;
     f1.frameNumber = 1;
@@ -808,13 +861,13 @@
     ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
     EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
     EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
-    EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
+    EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
 
     // Verify queries for timestamps that the producer doesn't know about
     // triggers a call to see if the consumer has any new timestamps.
-    int result = getAllFrameTimestamps(fId1);
+    result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(NO_ERROR, result);
-    EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
+    EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
 }
 
 void GetFrameTimestampsTest::QueryPresentRetireSupported(
@@ -842,6 +895,234 @@
    QueryPresentRetireSupported(false, true);
 }
 
+TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
+    nsecs_t phase = 4000;
+    nsecs_t interval = 1000;
+
+    // Timestamp in previous interval.
+    nsecs_t timestamp = 3500;
+    EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
+            timestamp, phase, interval));
+
+    // Timestamp in next interval.
+    timestamp = 4500;
+    EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
+            timestamp, phase, interval));
+
+    // Timestamp multiple intervals before.
+    timestamp = 2500;
+    EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
+            timestamp, phase, interval));
+
+    // Timestamp multiple intervals after.
+    timestamp = 6500;
+    EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
+            timestamp, phase, interval));
+
+    // Timestamp on previous interval.
+    timestamp = 3000;
+    EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
+            timestamp, phase, interval));
+
+    // Timestamp on next interval.
+    timestamp = 5000;
+    EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
+            timestamp, phase, interval));
+
+    // Timestamp equal to phase.
+    timestamp = 4000;
+    EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
+            timestamp, phase, interval));
+}
+
+// int(big_timestamp / interval) < 0, which can cause a crash or invalid result
+// if the number of intervals elapsed is internally stored in an int.
+TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
+      nsecs_t phase = 0;
+      nsecs_t interval = 4000;
+      nsecs_t big_timestamp = 8635916564000;
+      int32_t intervals = big_timestamp / interval;
+
+      EXPECT_LT(intervals, 0);
+      EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
+            big_timestamp, phase, interval));
+      EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
+            big_timestamp, big_timestamp, interval));
+}
+
+// This verifies the compositor timing is updated by refresh events
+// and piggy backed on a queue, dequeue, and enabling of timestamps..
+TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
+    CompositorTiming initialCompositorTiming {
+        1000000000, // 1s deadline
+        16666667, // 16ms interval
+        50000000, // 50ms present latency
+    };
+    mCfeh->initializeCompositorTiming(initialCompositorTiming);
+
+    enableFrameTimestamps();
+
+    // We get the initial values before any frames are submitted.
+    nsecs_t compositeDeadline = 0;
+    nsecs_t compositeInterval = 0;
+    nsecs_t compositeToPresentLatency = 0;
+    mSurface->setNow(initialCompositorTiming.deadline - 1);
+    int result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
+    EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
+    EXPECT_EQ(initialCompositorTiming.presentLatency,
+              compositeToPresentLatency);
+
+    const uint64_t fId1 = getNextFrameId();
+    dequeueAndQueue(0);
+    addFrameEvents(true, NO_FRAME_INDEX, 0);
+
+    // Still get the initial values because the frame events for frame 0
+    // didn't get a chance to piggyback on a queue or dequeue yet.
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
+    EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
+    EXPECT_EQ(initialCompositorTiming.presentLatency,
+              compositeToPresentLatency);
+
+    const uint64_t fId2 = getNextFrameId();
+    dequeueAndQueue(1);
+    addFrameEvents(true, 0, 1);
+
+    // Now expect the composite values associated with frame 1.
+    mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
+            compositeDeadline);
+    EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
+            compositeInterval);
+    EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
+            compositeToPresentLatency);
+
+    dequeueAndQueue(2);
+    addFrameEvents(true, 1, 2);
+
+    // Now expect the composite values associated with frame 2.
+    mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
+            compositeDeadline);
+    EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
+            compositeInterval);
+    EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
+            compositeToPresentLatency);
+
+    // Re-enabling frame timestamps should get the latest values.
+    disableFrameTimestamps();
+    enableFrameTimestamps();
+
+    // Now expect the composite values associated with frame 3.
+    mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
+            compositeDeadline);
+    EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
+            compositeInterval);
+    EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
+            compositeToPresentLatency);
+}
+
+// This verifies the compositor deadline properly snaps to the the next
+// deadline based on the current time.
+TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
+    CompositorTiming initialCompositorTiming {
+        1000000000, // 1s deadline
+        16666667, // 16ms interval
+        50000000, // 50ms present latency
+    };
+    mCfeh->initializeCompositorTiming(initialCompositorTiming);
+
+    enableFrameTimestamps();
+
+    nsecs_t compositeDeadline = 0;
+    nsecs_t compositeInterval = 0;
+    nsecs_t compositeToPresentLatency = 0;
+
+    // A "now" just before the deadline snaps to the deadline.
+    mSurface->setNow(initialCompositorTiming.deadline - 1);
+    int result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
+    nsecs_t expectedDeadline = initialCompositorTiming.deadline;
+    EXPECT_EQ(expectedDeadline, compositeDeadline);
+
+    const uint64_t fId1 = getNextFrameId();
+    dequeueAndQueue(0);
+    addFrameEvents(true, NO_FRAME_INDEX, 0);
+
+    // A "now" just after the deadline snaps properly.
+    mSurface->setNow(initialCompositorTiming.deadline + 1);
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    expectedDeadline =
+            initialCompositorTiming.deadline +initialCompositorTiming.interval;
+    EXPECT_EQ(expectedDeadline, compositeDeadline);
+
+    const uint64_t fId2 = getNextFrameId();
+    dequeueAndQueue(1);
+    addFrameEvents(true, 0, 1);
+
+    // A "now" just after the next interval snaps properly.
+    mSurface->setNow(
+            mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
+            mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    expectedDeadline =
+            mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
+            mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
+    EXPECT_EQ(expectedDeadline, compositeDeadline);
+
+    dequeueAndQueue(2);
+    addFrameEvents(true, 1, 2);
+
+    // A "now" over 1 interval before the deadline snaps properly.
+    mSurface->setNow(
+            mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
+            mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    expectedDeadline =
+            mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
+            mFrames[1].mRefreshes[1].kCompositorTiming.interval;
+    EXPECT_EQ(expectedDeadline, compositeDeadline);
+
+    // Re-enabling frame timestamps should get the latest values.
+    disableFrameTimestamps();
+    enableFrameTimestamps();
+
+    // A "now" over 2 intervals before the deadline snaps properly.
+    mSurface->setNow(
+            mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
+            mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
+    result = native_window_get_compositor_timing(mWindow.get(),
+        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
+    EXPECT_EQ(NO_ERROR, result);
+    expectedDeadline =
+            mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
+            mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
+    EXPECT_EQ(expectedDeadline, compositeDeadline);
+}
+
 // This verifies the timestamps recorded in the consumer's
 // FrameTimestampsHistory are properly retrieved by the producer for the
 // correct frames.
diff --git a/libs/vr/libgvr/.clang-format b/libs/vr/libgvr/.clang-format
deleted file mode 100644
index 3287160..0000000
--- a/libs/vr/libgvr/.clang-format
+++ /dev/null
@@ -1,2 +0,0 @@
-Language: Cpp
-DisableFormat: true
diff --git a/libs/vr/libgvr/Android.mk b/libs/vr/libgvr/Android.mk
deleted file mode 100644
index 0daf2ea..0000000
--- a/libs/vr/libgvr/Android.mk
+++ /dev/null
@@ -1,129 +0,0 @@
-# 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.
-LOCAL_PATH := $(call my-dir)
-
-include_dirs := \
-  $(LOCAL_PATH)/include \
-  $(LOCAL_PATH)/prebuilt/include
-
-# Java platform library for the system implementation of the GVR API.
-include $(CLEAR_VARS)
-LOCAL_MODULE := com.google.vr.gvr.platform
-LOCAL_REQUIRED_MODULES := libgvr_system_loader libgvr_system
-LOCAL_SRC_FILES := $(call all-java-files-under, java)
-include $(BUILD_JAVA_LIBRARY)
-
-# Library to perform dlopen on the actual platform library.
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr_system_loader
-LOCAL_SRC_FILES := library_loader.cpp
-include $(BUILD_SHARED_LIBRARY)
-
-# Shared library implementing the GVR API.
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr_system
-
-LOCAL_SRC_FILES := \
-    shim_gvr.cpp \
-    shim_gvr_controller.cpp \
-    shim_gvr_private.cpp \
-    deviceparams/CardboardDevice.nolite.proto
-
-LOCAL_MODULE_CLASS := SHARED_LIBRARIES
-
-LOCAL_C_INCLUDES := $(include_dirs)
-LOCAL_C_INCLUDES += $(call local-generated-sources-dir)/proto/$(LOCAL_PATH)
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(include_dirs)
-
-gvr_api_linker_script := $(LOCAL_PATH)/exported_apis.lds
-LOCAL_ADDITIONAL_DEPENDENCIES := $(gvr_api_linker_script)
-
-LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
-LOCAL_CFLAGS += -DEGL_EGLEXT_PROTOTYPES
-LOCAL_LDFLAGS += -Wl,-version-script,$(gvr_api_linker_script)
-
-LOCAL_SHARED_LIBRARIES := \
-    libandroid_runtime \
-    libbase \
-    libbinder \
-    libcutils \
-    libutils \
-    libgui \
-    libui \
-    libEGL \
-    libGLESv2 \
-    libvulkan \
-    libhardware \
-    liblog \
-    libsync \
-    libprotobuf-cpp-full
-
-LOCAL_STATIC_LIBRARIES := \
-    libdisplay \
-    libbufferhub \
-    libbufferhubqueue \
-    libdvrcommon \
-    libeds \
-    libdvrgraphics \
-    libsensor \
-    libperformance \
-    libpdx_default_transport \
-
-include $(BUILD_SHARED_LIBRARY)
-
-# Prebuilt shared library for libgvr_audio.so
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr_audio
-LOCAL_MODULE_CLASS := SHARED_LIBRARIES
-LOCAL_MODULE_SUFFIX := .so
-LOCAL_MULTILIB := both
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-LOCAL_SRC_FILES_arm := prebuilt/lib/android_arm/libgvr_audio.so
-LOCAL_SRC_FILES_arm64 := prebuilt/lib/android_arm64/libgvr_audio.so
-LOCAL_SRC_FILES_x86 := prebuilt/lib/android_x86/libgvr_audio.so
-LOCAL_SRC_FILES_x86_64 := prebuilt/lib/android_x86_64/libgvr_audio.so
-include $(BUILD_PREBUILT)
-
-# Prebuilt shared library for libgvr.so
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/prebuilt/include
-LOCAL_MODULE_CLASS := SHARED_LIBRARIES
-LOCAL_MODULE_SUFFIX := .so
-LOCAL_MULTILIB := both
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-LOCAL_SRC_FILES_arm := prebuilt/lib/android_arm/libgvr.so
-LOCAL_SRC_FILES_arm64 := prebuilt/lib/android_arm64/libgvr.so
-LOCAL_SRC_FILES_x86 := prebuilt/lib/android_x86/libgvr.so
-LOCAL_SRC_FILES_x86_64 := prebuilt/lib/android_x86_64/libgvr.so
-include $(BUILD_PREBUILT)
-
-# Prebuilt Java static library for common_library.aar
-include $(CLEAR_VARS)
-LOCAL_PREBUILT_STATIC_JAVA_LIBRARIES := \
-    gvr_common_library_aar:prebuilt/lib/common_library.aar
-include $(BUILD_MULTI_PREBUILT)
-
-# Dummy libgvr_ext to be used along side libgvr.so prebuilt.
-# This shall be replaced with Google3 prebuilts in future.
-include $(CLEAR_VARS)
-LOCAL_MODULE := libgvr_ext
-LOCAL_C_INCLUDES := $(LOCAL_PATH)/include
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(LOCAL_PATH)/include
-LOCAL_SRC_FILES := dummy_gvr_ext.cpp
-LOCAL_LDLIBS := -llog
-LOCAL_MODULE_TAGS := optional
-LOCAL_SHARED_LIBRARIES += libgvr
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-include $(BUILD_STATIC_LIBRARY)
diff --git a/libs/vr/libgvr/CPPLINT.cfg b/libs/vr/libgvr/CPPLINT.cfg
deleted file mode 100644
index 2da1c50..0000000
--- a/libs/vr/libgvr/CPPLINT.cfg
+++ /dev/null
@@ -1 +0,0 @@
-filter=-build/header_guard,-build/include_alpha
diff --git a/libs/vr/libgvr/README.dreamos b/libs/vr/libgvr/README.dreamos
deleted file mode 100644
index d847210..0000000
--- a/libs/vr/libgvr/README.dreamos
+++ /dev/null
@@ -1 +0,0 @@
-Files under public/vr/gvr were imported from the public Google VR SDK.
diff --git a/libs/vr/libgvr/com.google.vr.gvr.platform.xml b/libs/vr/libgvr/com.google.vr.gvr.platform.xml
deleted file mode 100644
index 9297c7f..0000000
--- a/libs/vr/libgvr/com.google.vr.gvr.platform.xml
+++ /dev/null
@@ -1,20 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2017 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.
--->
-
-<permissions>
-    <library name="com.google.vr.gvr.platform"
-             file="/system/framework/com.google.vr.gvr.platform.jar" />
-</permissions>
diff --git a/libs/vr/libgvr/deviceparams/CardboardDevice.nolite.proto b/libs/vr/libgvr/deviceparams/CardboardDevice.nolite.proto
deleted file mode 100644
index 77b5d72..0000000
--- a/libs/vr/libgvr/deviceparams/CardboardDevice.nolite.proto
+++ /dev/null
@@ -1,299 +0,0 @@
-
-syntax = "proto2";
-
-option java_package = "com.google.vrtoolkit.cardboard.proto";
-option java_outer_classname = "CardboardDevice";
-option optimize_for = SPEED;
-
-package proto;
-
-
-/**
- * Message describing properties of a VR head mount device (HMD) which uses an
- * interchangeable smartphone as a display (e.g. Google Cardboard).
- *
- * While some properties are certain (e.g. inter_lens_distance), others
- * represent nominal values which may be refined depending on context (e.g.
- * viewport_angles).
- *
- * Lengths are in meters unless noted otherwise.  Fields are _required_
- * unless noted otherwise.
- *
- * Some context on why this set of parameters are deemed necessary and
- * sufficient:
- *    * FOV scale can be reasonably approximated from lens-to-screen distance
- *      and display size (i.e. knowing lens focal length isn't crucial).
- *    * Lenses are assumed to be horizontally centered with respect to
- *      display.
- *    * The display is not necessarily vertically centered.  For interchangeable
- *      phones where the device rests against a tray, we can derive
- *      the vertical offset from tray-to-lens height along with phone-specific
- *      bezel and screen sizes (supplied separately).
- */
-message DeviceParams {
-  // String identifying the device's vendor (e.g. "Google, Inc.").
-  // A device's [vendor, model] pair is expected to be globally unique.
-  optional string vendor = 1;
-
-  // String identifying the device's model, including revision info if
-  // needed (e.g. "Cardboard v1").  A device's [vendor, model] pair is
-  // expected to be globally unique.
-  optional string model = 2;
-
-  // Distance from the display screen to the optical center of lenses.
-  // This is a required field for distortion rendering, and must be positive.
-  optional float screen_to_lens_distance = 3;
-
-  // Horizontal distance between optical center of the lenses.
-  // This is a required field for distortion rendering, and must be positive.
-  optional float inter_lens_distance = 4;
-
-  // Four-element tuple (left, right, bottom, top) of left eye's view extent
-  // angles relative to center, assuming the following:
-  //     * eye is aligned with optical center of lens
-  //     * display screen is equal or larger than extents viewable through lens
-  //     * nominal eye-to-lens distance
-  //     * mirrored field of view will be applied to the right eye
-  // These values are essentially used as an optimization to avoid rendering
-  // pixels which can't be seen.
-  // This is a required field for distortion rendering, and angles must be
-  // positive.
-  repeated float left_eye_field_of_view_angles = 5 [packed = true];
-
-  enum VerticalAlignmentType {
-    BOTTOM = 0;  // phone rests against a fixed bottom tray
-    CENTER = 1;  // phone screen assumed to be centered w.r.t. lenses
-    TOP = 2;     // phone rests against a fixed top tray
-  }
-
-  // Set according to vertical alignment strategy-- see enum comments above.
-  // NOTE: If you set this to CENTER, see special instructions for the
-  // tray_to_lens_distance field below.
-  optional VerticalAlignmentType vertical_alignment = 11 [default = BOTTOM];
-
-  // If the phone is aligned vertically within the device by resting against
-  // a fixed top or bottom tray, this is the distance from the tray to
-  // optical center of the lenses.
-  // This is a required field for distortion rendering, and must be positive.
-  // NOTE: Due to a bug in initial versions of the SDK's, this field
-  // must be set explicitly to .035 when vertical_alignment = CENTER.
-  optional float tray_to_lens_distance = 6;
-
-  // Coefficients Ki for pincushion distortion function which maps
-  // from position on real screen to virtual screen (i.e. texture) relative
-  // to optical center:
-  //
-  //    p' = p (1 + K1 r^2 + K2 r^4 + ... + Kn r^(2n))
-  //
-  // where r is the distance in tan-angle units from the optical center,
-  // p the input point, and p' the output point.  Tan-angle units can be
-  // computed as distance on the screen divided by distance from the
-  // virtual eye to the screen.
-  repeated float distortion_coefficients = 7 [packed = true];
-  // Slots 8, 9 reserved for per-color channel distortion.
-
-  // Optionally, whether the head mount uses a magnet in any part of its
-  // design.  Intended as hint as to whether phone's magnetometer is
-  // available for tasks such as orientation tracking.
-  optional bool has_magnet = 10;
-
-  enum ButtonType {
-    // No physical button, and touch screen is not easily accessible.
-    NONE = 0;
-    // HMD has integrated magnet switch similar to original Cardboard.
-    MAGNET = 1;
-    // At least a portion of touch screen is easily accessible to user for taps.
-    TOUCH = 2;
-    // Touch screen is triggered indirectly via integrated button on the HMD.
-    INDIRECT_TOUCH = 3;
-  }
-
-  // Specify primary input mechanism of the HMD.  Intended for advisory
-  // purposes only, to address simple questions such as "can HMD
-  // be used with apps requiring a physical button event?" or "what icon
-  // should be used to represent button action to the user?".
-  optional ButtonType primary_button = 12 [default = MAGNET];
-
-  // Some internal data for Cardboard.  This data is not intended to be
-  // set or used by developers, and any data in this proto is not guaranteed
-  // to be supported with new SDK updates.
-  optional CardboardInternalParams internal = 1729;
-
-  // Optionally, specifies the additional parameters that are necessary for
-  // a Daydream-ready headset. This field is non-null if the headset is
-  // Daydream-ready.
-  // TODO(b/30112366) The inclusion of this message inside a DeviceParams is a
-  // somewhat ugly result of some historical choices in the SDK. We should
-  // consider refactoring our code to allow us to remove this, and the
-  // CardboardInternalParams messages from this proto.
-  optional DaydreamInternalParams daydream_internal = 196883;
-}
-
-// TODO(b/27108179): CardboardInternalParams should be migrated into its own
-// file, and not live in this file.
-
-/**
- * Message describing parameters that are used internally by Cardboard
- * and VRToolkit. These parameters don't necessarily fit into the DeviceParams
- * notion of a VR viewer combined with user's phone (e.g. case of viewer with
- * dedicated display, etc.) and are not intended to be used by developers
- * and may or may not be supported or changed without notice on new releases
- * of the Cardboard SDK or VR Toolkit.
- */
-message CardboardInternalParams {
-  // Used to specify a per-eye post-process transformation -- an optional
-  // rotation and x-axis reflection -- to be applied after distortion
-  // correction.
-  enum OrientationType {
-    CCW_0_DEGREES = 0;
-    CCW_90_DEGREES = 1;
-    CCW_180_DEGREES = 2;
-    CCW_270_DEGREES = 3;
-    CCW_0_DEGREES_MIRRORED = 4;
-    CCW_90_DEGREES_MIRRORED = 5;
-    CCW_180_DEGREES_MIRRORED = 6;
-    CCW_270_DEGREES_MIRRORED = 7;
-  }
-
-  // Specify a post-process transformation that is applied after the distortion
-  // function. This field is optional, if not specified, CCW_0_DEGREES is
-  // assumed. If repeated, the first orientation is for the left eye, the second
-  // is for the right eye.
-  //
-  // For example, if [CCW_90_DEGREES, CCW_270_DEGREES_MIRRORED] is specified,
-  //
-  // this input:
-  //
-  // ***************** *****************
-  // *1             2* *1             2*
-  // *      *        * *      ***      *
-  // *      *        * *      * *      *
-  // *      ****     * *      *  *     *
-  // *4             3* *4             3*
-  // ***************** *****************
-  //
-  // is rendered on the screen like this:
-  //
-  // ***************** *****************
-  // *2       *     3* *3     *       2*
-  // *        *      * *       **      *
-  // *        *      * *        *      *
-  // *      ***      * *      ***      *
-  // *1             4* *4             1*
-  // ***************** *****************
-  repeated OrientationType eye_orientations = 1 [packed = true];
-
-  // Specify a horizontal offset from the middle of the screen to the center of
-  // the lens, in meters. If one is not provided, half of the inter lens
-  // distance is used.
-  //
-  // This is only necessary if the HMD has some sort of periscope effect, where
-  // the position of the lenses, relative to the screen, is different than
-  // their position relative to the user.
-  //
-  // For example, in the HMD below, two mirrors reflect the image from the
-  // screen to the user, creating a larger inter lens distance than the screen
-  // can support.
-  //
-  // [In the diagram below, S = screen, L = lens]
-  //
-  // screen_center_to_lens_distance
-  //             |--|
-  //
-  // -------------------------
-  // |     SSSSSSSSSSSS      |
-  // |        |  |  |        |
-  // |   /----/  |  \----\   |
-  // |   |       |       |   |
-  // |  LLL             LLL  |
-  //
-  //     |---------------|
-  //    inter_lens_distance
-  //
-  optional float screen_center_to_lens_distance = 2;
-
-  // Optional x-dimension physical pixels per inch of the external display,
-  // assuming landscape orientation. If set, this will override OS-reported
-  // values.
-  optional float x_ppi_override = 3;
-
-  // Optional y-dimension physical pixels per inch of the external display,
-  // assuming landscape orientation.  If set, this will override OS-reported
-  // values.
-  optional float y_ppi_override = 4;
-
-  // Optional string identifying the device's accelerometer and gyroscope.
-  // If either field is filled out, the corresponding sensor (gyroscope or
-  // accelerometer) will be used for head tracking.
-  //
-  // Valid strings are usually found in:
-  // vendor/<vendorname>/<devicename>/xxx/sensors.cpp
-  //
-  // For dynamic sensors, this string will be provided in a separate way.
-  //
-  // NB: Vendors and manufacturers should make the name of the sensor as
-  // specific as possible, since if multiple sensors with the same name are
-  // connected, the first will be used.
-  optional string accelerometer = 5;
-  optional string gyroscope = 6;
-}
-
-/**
- * Message describing the additional properties of a Daydream-ready headset that
- * are not used for a normal cardboard viewer. These parameters are not intended
- * to be used, or consumed, by developers and may or may not be supported or
- * changed without notice on new releases of the Cardboard SDK or VR Toolkit.
- */
-message DaydreamInternalParams {
-  // The version of the Daydream-ready specification to which this device
-  // conforms.
-  optional int32 version = 1;
-
-  // Optionally, specifies the collection of screen alignment markers in the
-  // headset.
-  repeated ScreenAlignmentMarker alignment_markers = 2;
-}
-
-/**
- * Message describing a single screen alignment marker.
- *
- * A screen alignment marker is a capacitive touch point affixed to the headset
- * which is capable of making contact with the screen. The location of the touch
- * point is given in meters, measured along a horizontal axis which passes
- * through the center of both lenses, and a vertical axis which is equidistant
- * from the centers of the lenses. A positive vertical value indicates that the
- * point lies above the horizontal axis, and a positive horizontal value
- * indicates that the point lies to the right, as seen by a user of the headset,
- * of the vertical axis. For example, if the following is a representation of a
- * headset, viewed from the point of view of a user, with three points marked by
- * the numbers 1, 2, and 3.
- *
- * *****************************************************************************
- * *                                    ^                                      *
- * *               _____                |                _____                 *
- * *              /     \               1               /     \                *
- * *             /       \              |              /       \               *
- * *            /         \             |             /         \              *
- * *           /           \            |            /           \             *
- * *          /             \           |           /             \            *
- * *---------|-------*-------|----------+------2---|-------*-------|---------->*
- * *          \             /           |           \             /            *
- * *           \           /            |            \           /             *
- * *            \         /         3   |             \         /              *
- * *             \       /              |              \       /               *
- * *              \_____/               |               \_____/                *
- * *                                    |                                      *
- * *                                    |                                      *
- * *****************************************************************************
- *
- * Then the coordinates of point 1 could be horizontal = 0.0, vertical = 0.035;
- * point 2 could be horizontal = 0.02; and point 3 could be horizontal = -0.01
- * vertical = -0.012
- */
-message ScreenAlignmentMarker {
-  // The horizontal coordinate of the touch point.
-  optional float horizontal = 1;
-
-  // The vertical coordinate of the touch point.
-  optional float vertical = 2;
-}
diff --git a/libs/vr/libgvr/dummy_gvr_ext.cpp b/libs/vr/libgvr/dummy_gvr_ext.cpp
deleted file mode 100644
index f73838d..0000000
--- a/libs/vr/libgvr/dummy_gvr_ext.cpp
+++ /dev/null
@@ -1,29 +0,0 @@
-#include <log/log.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/include/gvr_ext.h>
-#include <vr/gvr/capi/include/gvr_types.h>
-
-gvr_frame_schedule* gvr_frame_schedule_create() { return NULL; }
-
-void gvr_frame_schedule_destroy(gvr_frame_schedule** /* schedule */) {}
-
-uint32_t gvr_frame_schedule_get_vsync_count(
-    gvr_frame_schedule* /* schedule */) {
-  return 0;
-}
-
-gvr_mat4f gvr_get_6dof_head_pose_in_start_space(gvr_context* gvr,
-                                                uint32_t /* vsync_count */) {
-  LOG_ALWAYS_FATAL("gvr_get_6dof_head_pose_in_start_space is not implemented. "
-                   "Use gvr_get_head_space_from_start_space_pose instead.");
-  return gvr_mat4f({{{1.0f, 0.0f, 0.0f, 0.0f},
-                     {0.0f, 1.0f, 0.0f, 0.0f},
-                     {0.0f, 0.0f, 1.0f, 0.0f},
-                     {0.0f, 0.0f, 0.0f, 1.0f}}});
-}
-
-void gvr_wait_next_frame(gvr_swap_chain* /* swap_chain */,
-                         int64_t /* sched_offset_nanos */,
-                         gvr_frame_schedule* /* out_next_frame_schedule */) {
-  LOG_ALWAYS_FATAL("gvr_wait_next_frame is not implemented.");
-}
diff --git a/libs/vr/libgvr/exported_apis.lds b/libs/vr/libgvr/exported_apis.lds
deleted file mode 100644
index 2d19303..0000000
--- a/libs/vr/libgvr/exported_apis.lds
+++ /dev/null
@@ -1,16 +0,0 @@
-{
-  global:
-    # Export GVR APIs, both public and private.
-    gvr_*;
-
-    # Whitelist of DVR APIs required by VrCore for Ambrosia controller support.
-    dvrPoseCreate;
-    dvrPoseDestroy;
-    dvrPoseGet;
-    dvrPoseGetController;
-    dvrPoseGetVsyncCount;
-
-  local:
-    # Hide everything else.
-    *;
-};
diff --git a/libs/vr/libgvr/include/private/dvr/internal_types.h b/libs/vr/libgvr/include/private/dvr/internal_types.h
deleted file mode 100644
index dafdb73..0000000
--- a/libs/vr/libgvr/include/private/dvr/internal_types.h
+++ /dev/null
@@ -1,170 +0,0 @@
-#ifndef ANDROID_DVR_INTERNAL_TYPES_H_
-#define ANDROID_DVR_INTERNAL_TYPES_H_
-
-#include <GLES2/gl2.h>
-#include <atomic>
-#include <memory>
-#include <vector>
-#include <unordered_map>
-
-#include <dvr/graphics.h>
-#include <dvr/pose_client.h>
-#include <gui/Surface.h>
-#include <private/dvr/buffer_hub_queue_core.h>
-#include <private/dvr/display_client.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/include/gvr_types.h>
-#include <vr/gvr/capi/src/gvr_types_experimental.h>
-
-typedef struct gvr_user_prefs_ {
-} gvr_user_prefs;
-
-typedef struct gvr_context_ {
-  int32_t last_error_;
-  JNIEnv* jni_env_;
-  DvrPose* pose_client_;
-  std::unique_ptr<android::dvr::DisplayClient> display_client_;
-  android::dvr::SystemDisplayMetrics display_metrics_;
-  gvr_mat4f left_eye_viewport_transform_;
-  gvr_mat4f right_eye_viewport_transform_;
-  gvr_mat4f next_frame_6dof_pose_;
-  gvr_mat4f next_frame_controller_pose_[2];
-  gvr_user_prefs user_prefs_;
-  bool force_6dof_;
-  std::vector<gvr_swap_chain*> swap_chains_;
-
-  gvr_context_() :
-      last_error_(GVR_ERROR_NONE),
-      jni_env_(nullptr),
-      pose_client_(nullptr),
-      force_6dof_(false) {}
-
-  ~gvr_context_();
-} gvr_context;
-
-typedef struct gvr_buffer_spec_ {
-  gvr_sizei size;
-  int32_t msaa_samples;
-  int32_t color_format;
-  int32_t depth_stencil_format;
-  bool blur_behind;
-  bool initially_visible;
-  int z_order;
-
-  // The default values are configured to match SVR defaults
-  gvr_buffer_spec_()
-      : size{0, 0},
-        msaa_samples(0),
-        color_format(GVR_COLOR_FORMAT_RGBA_8888),
-        depth_stencil_format(GVR_DEPTH_STENCIL_FORMAT_DEPTH_16),
-        blur_behind(true),
-        initially_visible(true),
-        z_order(0) {}
-} gvr_buffer_spec;
-
-// This isn't a public gvr type
-struct gvr_buffer {
-  gvr_buffer_spec spec;
-  GLuint frame_buffer;
-  GLuint color_render_buffer;
-  GLuint depth_stencil_render_buffer;
-
-  // requested_size is used for resizing. It will be {-1, -1} when no resize is
-  // requested. Any other value indicates the app changed the size.
-  gvr_sizei requested_size;
-
-  gvr_buffer();
-  // If creation fails frame_buffer will be 0
-  gvr_buffer(gvr_context* gvr, const gvr_buffer_spec& spec,
-             GLuint texture_id, GLenum texture_target);
-  ~gvr_buffer();
-
-  gvr_buffer(gvr_buffer&& other);
-  gvr_buffer& operator=(gvr_buffer&& other);
-  gvr_buffer(const gvr_buffer& other) = delete;
-  gvr_buffer& operator=(const gvr_buffer& other) = delete;
-
-  // Set default values. Doesn't free GL resources first.
-  void SetDefaults();
-
-  // Frees all GL resources associated with the buffer
-  void FreeGl();
-};
-
-typedef struct gvr_swap_chain_ {
-  gvr_context* context;
-  DvrGraphicsContext* graphics_context_;
-  std::vector<gvr_buffer> buffers_;
-  bool frame_acquired_;
-  bool wait_next_frame_called_by_app_;
-  std::atomic<int32_t> next_external_surface_id_;
-  std::unordered_map<int32_t, gvr_external_surface*> external_surfaces_;
-
-  explicit gvr_swap_chain_(gvr_context* context)
-      : context(context),
-        graphics_context_(nullptr),
-        frame_acquired_(false),
-        wait_next_frame_called_by_app_(false),
-        next_external_surface_id_(0) {}
-  ~gvr_swap_chain_();
-} gvr_swap_chain;
-
-typedef struct gvr_buffer_viewport_ {
-  int32_t buffer_index;
-  gvr_rectf uv;
-  gvr_mat4f transform;
-  int32_t eye;
-  int32_t external_surface_id;
-  gvr_reprojection reprojection;
-
-  gvr_buffer_viewport_()
-      : buffer_index(0),
-        uv{0, 0, 0, 0},
-        transform{{{1.f, 0.f, 0.f, 0.f},
-                   {0.f, 1.f, 0.f, 0.f},
-                   {0.f, 0.f, 1.f, 0.f},
-                   {0.f, 0.f, 0.f, 1.f}}},
-        eye(0),
-        external_surface_id(-1),
-        reprojection(GVR_REPROJECTION_FULL) {}
-
-  gvr_buffer_viewport_(int32_t /* buffer_index */, gvr_rectf uv,
-                       const gvr_mat4f& transform, int32_t eye,
-                       int32_t external_surface_id,
-                       gvr_reprojection reprojection)
-      : buffer_index(0),
-        uv(uv),
-        transform(transform),
-        eye(eye),
-        external_surface_id(external_surface_id),
-        reprojection(reprojection) {}
-
-  bool operator==(const gvr_buffer_viewport_& other) const;
-
-  bool operator!=(const gvr_buffer_viewport_& other) const {
-    return !operator==(other);
-  }
-} gvr_buffer_viewport;
-
-typedef struct gvr_buffer_viewport_list_ {
-  std::vector<gvr_buffer_viewport> viewports;
-} gvr_buffer_viewport_list;
-
-typedef struct gvr_frame_schedule_ {
-  uint32_t vsync_count;
-  gvr_clock_time_point scheduled_finish;
-
-  gvr_frame_schedule_() : vsync_count(0) {
-    scheduled_finish.monotonic_system_time_nanos = 0;
-  }
-} gvr_frame_schedule;
-
-typedef struct gvr_display_synchronizer_ {} gvr_display_synchronizer;
-
-typedef struct gvr_external_surface_ {
-  int32_t id;
-  gvr_swap_chain* swap_chain;
-  DvrVideoMeshSurface* video_surface;
-} gvr_external_surface;
-
-#endif  // ANDROID_DVR_INTERNAL_TYPES_H_
diff --git a/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_ext.h b/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_ext.h
deleted file mode 100644
index 8af434f..0000000
--- a/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_ext.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_EXT_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_EXT_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// Constants that represent GVR error codes.
-typedef enum {
-  // TODO(steventhomas): All errors should be switched to something more
-  // meaningful and this should eventually go away.
-  GVR_ERROR_INTERNAL = 9000,
-} gvr_error_ext;
-
-typedef struct gvr_frame_schedule_ gvr_frame_schedule;
-
-gvr_frame_schedule* gvr_frame_schedule_create();
-
-void gvr_frame_schedule_destroy(gvr_frame_schedule** schedule);
-
-uint32_t gvr_frame_schedule_get_vsync_count(gvr_frame_schedule* schedule);
-
-gvr_clock_time_point gvr_frame_schedule_get_scheduled_finish(
-    gvr_frame_schedule* schedule);
-
-/// Sleep until it's time to render the next frame.
-// |start_delay_ns| adjusts how long this function blocks the app from starting
-// its next frame. If |start_delay_ns| is 0, the function waits until the
-// scheduled frame finish time for the current frame, which gives the app one
-// full vsync period to render the next frame. If the app needs less than a full
-// vysnc period to render the frame, pass in a non-zero |start_delay_ns| to
-// delay the start of frame rendering further. For example, if the vsync period
-// is 11.1ms and the app takes 6ms to render a frame, consider setting this to
-// 5ms (note that the value is in nanoseconds, so 5,000,000ns) so that the app
-// finishes the frame closer to the scheduled frame finish time. Delaying the
-// start of rendering allows the app to use a more up-to-date pose for
-// rendering.
-// |start_delay_ns| must be a positive value or 0. If you're unsure what to set
-// for |start_delay_ns|, use 0.
-/// |out_next_frame_schedule| is an output parameter that will contain the
-/// schedule for the next frame. It can be null.
-void gvr_wait_next_frame(gvr_swap_chain* swap_chain, int64_t start_delay_nanos,
-                         gvr_frame_schedule* out_next_frame_schedule);
-
-gvr_mat4f gvr_get_6dof_head_pose_in_start_space(gvr_context* gvr,
-                                                uint32_t vsync_count);
-
-gvr_mat4f gvr_get_head_space_from_start_space_pose(
-    gvr_context* gvr, const gvr_clock_time_point time);
-
-gvr_mat4f gvr_get_start_space_from_controller_space_pose(
-    gvr_context* gvr, int controller_id, const gvr_clock_time_point time);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-#include <utility>
-
-namespace gvr {
-
-/// Convenience C++ wrapper for gvr_frame_schedule. Frees the underlying
-/// gvr_frame_schedule on destruction.
-class FrameSchedule {
- public:
-  FrameSchedule() { schedule_ = gvr_frame_schedule_create(); }
-
-  ~FrameSchedule() {
-    if (schedule_)
-      gvr_frame_schedule_destroy(&schedule_);
-  }
-
-  FrameSchedule(FrameSchedule&& other) {
-    std::swap(schedule_, other.schedule_);
-  }
-
-  FrameSchedule& operator=(FrameSchedule&& other) {
-    std::swap(schedule_, other.schedule_);
-    return *this;
-  }
-
-  gvr_frame_schedule* cobj() { return schedule_; }
-  const gvr_frame_schedule* cobj() const { return schedule_; }
-
-  uint32_t GetVsyncCount() const {
-    return gvr_frame_schedule_get_vsync_count(schedule_);
-  }
-
-  gvr_clock_time_point GetScheduledFinish() const {
-    return gvr_frame_schedule_get_scheduled_finish(schedule_);
-  }
-
- private:
-  gvr_frame_schedule* schedule_;
-};
-
-}  // namespace gvr
-#endif  // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif  // VR_GVR_CAPI_INCLUDE_GVR_EXT_H_
diff --git a/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_util.h b/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_util.h
deleted file mode 100644
index 1fae611..0000000
--- a/libs/vr/libgvr/include/vr/gvr/capi/include/gvr_util.h
+++ /dev/null
@@ -1,123 +0,0 @@
-#ifndef VR_GVR_CAPI_INCLUDE_GVR_UTIL_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_UTIL_H_
-
-#include <private/dvr/eigen.h>
-#include <private/dvr/numeric.h>
-#include <private/dvr/types.h>
-#include <vr/gvr/capi/include/gvr_types.h>
-
-namespace android {
-namespace dvr {
-
-inline gvr_rectf FovRadiansToDegrees(const gvr_rectf& fov) {
-  return gvr_rectf{ToDeg(fov.left), ToDeg(fov.right), ToDeg(fov.bottom),
-                   ToDeg(fov.top)};
-}
-
-inline gvr_rectf FovDegreesToRadians(const gvr_rectf& fov) {
-  return gvr_rectf{ToRad(fov.left), ToRad(fov.right), ToRad(fov.bottom),
-                   ToRad(fov.top)};
-}
-
-inline FieldOfView GvrToDvrFov(const gvr_rectf& fov) {
-  gvr_rectf fov_rad = FovDegreesToRadians(fov);
-  return FieldOfView(fov_rad.left, fov_rad.right, fov_rad.bottom, fov_rad.top);
-}
-
-inline gvr_rectf DvrToGvrFov(const FieldOfView& fov) {
-  return FovRadiansToDegrees(
-      gvr_rectf{fov.GetLeft(), fov.GetRight(), fov.GetBottom(), fov.GetTop()});
-}
-
-inline gvr_mat4f GvrIdentityMatrix() {
-  gvr_mat4f identity;
-  memset(&identity.m, 0, sizeof(identity.m));
-  for (int i = 0; i < 4; i++)
-    identity.m[i][i] = 1;
-  return identity;
-}
-
-inline gvr_mat4f GvrTranslationMatrix(float x, float y, float z) {
-  gvr_mat4f trans = GvrIdentityMatrix();
-  trans.m[0][3] = x;
-  trans.m[1][3] = y;
-  trans.m[2][3] = z;
-  return trans;
-}
-
-inline gvr_mat4f EigenToGvrMatrix(const mat4& m) {
-  gvr_mat4f ret;
-  for (int i = 0; i < 4; ++i)
-    for (int j = 0; j < 4; ++j)
-      ret.m[i][j] = m(i, j);
-  return ret;
-}
-
-inline mat4 GvrToEigenMatrix(const gvr::Mat4f& m) {
-  mat4 ret;
-  for (int i = 0; i < 4; ++i)
-    for (int j = 0; j < 4; ++j)
-      ret(i, j) = m.m[i][j];
-  return ret;
-}
-
-inline quat GvrToEigenRotation(const gvr_mat4f& m) {
-  mat3 ret;
-  for (int r = 0; r < 3; ++r)
-    for (int c = 0; c < 3; ++c)
-      ret(r, c) = m.m[r][c];
-  return quat(ret.matrix());
-}
-
-inline vec3 GvrToEigenTranslation(const gvr_mat4f& m) {
-  return vec3(m.m[0][3], m.m[1][3], m.m[2][3]);
-}
-
-// Converts a DVR pose to 6DOF head transform as a GVR matrix.
-inline gvr_mat4f PosefToGvrMatrix(const Posef& pose) {
-  return EigenToGvrMatrix(pose.GetObjectFromReferenceMatrix());
-}
-
-// Converts a DVR pose to 3DOF head transform as a GVR matrix by stripping out
-// position translation.
-inline gvr_mat4f PosefTo3DofGvrMatrix(const Posef& pose) {
-  gvr_mat4f ret = PosefToGvrMatrix(pose);
-  ret.m[0][3] = 0;
-  ret.m[1][3] = 0;
-  ret.m[2][3] = 0;
-  return ret;
-}
-
-// Converts a GVR matrix to a DVR pose.
-inline Posef GvrMatrixToPosef(const gvr_mat4f& m) {
-  return Posef(GvrToEigenRotation(m), GvrToEigenTranslation(m)).Inverse();
-}
-
-// Calculates an transform with only the yaw and position components of |pose|.
-// The inverse of this matrix cancels yaw and position without affecting roll or
-// pitch.
-inline mat4 CalculateRecenterTransform(const mat4& pose) {
-  const vec4 z_axis = pose * vec4::UnitZ();
-  const float yaw = std::atan2(z_axis[0], z_axis[2]);
-  const vec3 position = pose.translation();
-  return mat4(Eigen::AngleAxis<float>(yaw, vec3::UnitY())).translate(position);
-}
-
-// Calculates a transform that negates the position component of |pose| and
-// offsets the pose by |position|. The inverse of this matrix cancels the
-// position component of pose and translates by |position| without affecting
-// orientation.
-inline mat4 CalculateOffsetTransform(const mat4& pose, const vec3& position) {
-  // Transform the origin by the pose matrix to produce the offset that cancels
-  // only the position of the pose.
-  //          -1          T
-  // [ R | t ]  [ 0 ] = -R * t
-  // [ 0   1 ]  [ 1 ]
-  const vec3 position_offset = (pose.inverse() * vec4(0, 0, 0, 1)).head<3>();
-  return mat4(mat4::Identity()).translate(position - position_offset);
-}
-
-}  // namespace dvr
-}  // namespace android
-
-#endif  // VR_GVR_CAPI_INCLUDE_GVR_UTIL_H_
diff --git a/libs/vr/libgvr/java/com/google/vr/gvr/platform/Loader.java b/libs/vr/libgvr/java/com/google/vr/gvr/platform/Loader.java
deleted file mode 100644
index 381175c..0000000
--- a/libs/vr/libgvr/java/com/google/vr/gvr/platform/Loader.java
+++ /dev/null
@@ -1,38 +0,0 @@
-package com.google.vr.gvr.platform;
-
-import android.os.SystemProperties;
-
-/**
- * Auxiliary class to load the system implementation of the GVR API.
- * @hide
- */
-public class Loader {
-
-    private static final String VR_MODE_BOOT = "ro.boot.vr";
-
-    /**
-     * Opens a shared library containing the system implementation for the GVR API and returns the
-     * handle to it.
-     *
-     * @return A Long object describing the handle returned by dlopen.
-     */
-    public static Long loadLibrary() {
-        // Note: caller verifications cannot be safely done here. Any app can find and use this API.
-        // Any sensitive functions must have appropriate checks on the service side.
-
-        // Load a thin JNI library that runs dlopen on request.
-        System.loadLibrary("gvr_system_loader");
-
-        // Performs dlopen on the library and returns the handle.
-        return nativeLoadLibrary("libgvr_system.so");
-    }
-
-    /**
-     * Returns true if this device boots directly in VR mode.
-     */
-    public static boolean getVrBoot() {
-        return SystemProperties.getBoolean(VR_MODE_BOOT, false);
-    }
-
-    private static native long nativeLoadLibrary(String library);
-}
diff --git a/libs/vr/libgvr/library_loader.cpp b/libs/vr/libgvr/library_loader.cpp
deleted file mode 100644
index 3cdc7d6..0000000
--- a/libs/vr/libgvr/library_loader.cpp
+++ /dev/null
@@ -1,25 +0,0 @@
-#include <dlfcn.h>
-#include <jni.h>
-
-#include <string>
-
-extern "C" {
-
-JNIEXPORT jlong JNICALL
-Java_com_google_vr_gvr_platform_Loader_nativeLoadLibrary(
-    JNIEnv* env, jclass, jstring java_library) {
-  if (!java_library)
-    return 0;
-
-  // Convert the Java String object to a C++ null-terminated string.
-  const char* data = env->GetStringUTFChars(java_library, NULL);
-  size_t size = env->GetStringUTFLength(java_library);
-  std::string library(data, size);
-  env->ReleaseStringUTFChars(java_library, data);
-
-  // Return the handle to the requested library.
-  return reinterpret_cast<jlong>(
-      dlopen(library.c_str(), RTLD_NOW | RTLD_LOCAL));
-}
-
-}  // extern "C"
diff --git a/libs/vr/libgvr/prebuilt/build_gvr_prebuilts.sh b/libs/vr/libgvr/prebuilt/build_gvr_prebuilts.sh
deleted file mode 100755
index 8e6ca2d..0000000
--- a/libs/vr/libgvr/prebuilt/build_gvr_prebuilts.sh
+++ /dev/null
@@ -1,93 +0,0 @@
-#!/bin/bash
-# Build and copy libgvr from Google3. Make sure that your local Google3 client
-# is up-to-date by running `p4 sync` before executing this script.
-#
-# Usage:
-# build_gvr_prebuilts.sh --google3_dir=<path_google3_client_root>
-
-source gbash.sh || exit
-
-DEFINE_string --required "google3_dir" "" \
-  "Path to the root directory of Google3 client"
-
-BLAZE_COMMON_OPTS=(
-  --compilation_mode=opt
-  --copt=-fdata-sections
-  --copt=-ffunction-sections
-  --define='prod=1'
-  --define='enable_experimental_sdk=1'
-  --linkopt=-Wl,--gc-sections
-)
-
-function copy_file() {
-  cp -v "${1}" ${CURRENT_DIR}/"${2}"
-}
-
-function copy_gvr_headers() {
-  echo "Copy GVR headers ..."
-
-  GVR_HEADER_DIR="include/vr/gvr/capi/include"
-  GVR_SOURCE_DIR="include/vr/gvr/capi/src"
-
-  # GVR public headers
-  copy_file "vr/gvr/capi/include/gvr.h" ${GVR_HEADER_DIR}
-  copy_file "vr/gvr/capi/include/gvr_audio.h" ${GVR_HEADER_DIR}
-  copy_file "vr/gvr/capi/include/gvr_controller.h" ${GVR_HEADER_DIR}
-  copy_file "vr/gvr/capi/include/gvr_types.h" ${GVR_HEADER_DIR}
-
-  # GVR private and experimental headers
-  copy_file "vr/gvr/capi/src/gvr_experimental.h" ${GVR_SOURCE_DIR}
-  copy_file "vr/gvr/capi/src/gvr_private.h" ${GVR_SOURCE_DIR}
-  copy_file "vr/gvr/capi/src/gvr_types_experimental.h" ${GVR_SOURCE_DIR}
-}
-
-function build_gvr_libs() {
-  echo "Build GVR libraries ..."
-
-  blaze build \
-    //java/com/google/vr/sdk/release:common_library.aar \
-    //vr/gvr/platform:libgvr.so \
-    //vr/gvr/platform:libgvr_audio.so \
-    ${BLAZE_COMMON_OPTS[@]} --config=android_arm --symlink_prefix blaze-arm-
-
-  blaze build \
-    //vr/gvr/platform:libgvr.so \
-    //vr/gvr/platform:libgvr_audio.so \
-    ${BLAZE_COMMON_OPTS[@]} --config=android_arm64 --symlink_prefix blaze-arm64-
-
-    blaze build \
-    //java/com/google/vr/sdk/release:common_library.aar \
-    //vr/gvr/platform:libgvr.so \
-    //vr/gvr/platform:libgvr_audio.so \
-    ${BLAZE_COMMON_OPTS[@]} --config=android_x86 --symlink_prefix blaze-x86-
-
-  blaze build \
-    //vr/gvr/platform:libgvr.so \
-    //vr/gvr/platform:libgvr_audio.so \
-    ${BLAZE_COMMON_OPTS[@]} --config=android_x86_64 --symlink_prefix blaze-x86_64-
-
-  copy_file "blaze-arm-genfiles/java/com/google/vr/sdk/release/common_library.aar" \
-    "lib/common_library.aar"
-  copy_file "blaze-arm-genfiles/vr/gvr/platform/libgvr.so" "lib/android_arm"
-  copy_file "blaze-arm-genfiles/vr/gvr/platform/libgvr_audio.so" "lib/android_arm"
-  copy_file "blaze-arm64-genfiles/vr/gvr/platform/libgvr.so" "lib/android_arm64"
-  copy_file "blaze-arm64-genfiles/vr/gvr/platform/libgvr_audio.so" "lib/android_arm64"
-  copy_file "blaze-x86-genfiles/vr/gvr/platform/libgvr.so" "lib/android_x86"
-  copy_file "blaze-x86-genfiles/vr/gvr/platform/libgvr_audio.so" "lib/android_x86"
-  copy_file "blaze-x86_64-genfiles/vr/gvr/platform/libgvr.so" "lib/android_x86_64"
-  copy_file "blaze-x86_64-genfiles/vr/gvr/platform/libgvr_audio.so" "lib/android_x86_64"
-}
-
-function main() {
-  set -ex
-
-  CURRENT_DIR=$(pwd)
-  GOOGLE3_DIR=${FLAGS_google3_dir}
-
-  cd ${GOOGLE3_DIR}
-  copy_gvr_headers
-  build_gvr_libs
-}
-
-gbash::init_google "$@"
-main "$@"
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr.h
deleted file mode 100644
index c459eca..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr.h
+++ /dev/null
@@ -1,1751 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_H_
-
-#ifdef __ANDROID__
-#include <jni.h>
-#endif
-
-#include <stdint.h>
-#include <stdlib.h>
-
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-#include <array>
-#include <memory>
-#include <vector>
-#endif
-
-#include "vr/gvr/capi/include/gvr_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// @defgroup base Google VR Base C API
-/// @brief This is the Google VR C API. It supports clients writing VR
-/// experiences for head mounted displays that consist of a mobile phone and a
-/// VR viewer.
-///
-/// Example API usage:
-///
-///     #ifdef __ANDROID__
-///     // On Android, the gvr_context should almost always be obtained from
-///     // the Java GvrLayout object via
-///     // GvrLayout.getGvrApi().getNativeGvrContext().
-///     gvr_context* gvr = ...;
-///     #else
-///     gvr_context* gvr = gvr_create();
-///     #endif
-///
-///     gvr_initialize_gl(gvr);
-///
-///     gvr_buffer_viewport_list* viewport_list =
-///         gvr_buffer_viewport_list_create(gvr);
-///     gvr_get_recommended_buffer_viewports(gvr, viewport_list);
-///     gvr_buffer_viewport* left_eye_vp = gvr_buffer_viewport_create(gvr);
-///     gvr_buffer_viewport* right_eye_vp = gvr_buffer_viewport_create(gvr);
-///     gvr_buffer_viewport_list_get_item(viewport_list, 0, left_eye_vp);
-///     gvr_buffer_viewport_list_get_item(viewport_list, 1, right_eye_vp);
-///
-///     while (client_app_should_render) {
-///       // A client app should be ready for the render target size to change
-///       // whenever a new QR code is scanned, or a new viewer is paired.
-///       gvr_sizei render_target_size =
-///           gvr_get_maximum_effective_render_target_size(gvr);
-///       // The maximum effective render target size can be very large, most
-///       // applications need to scale down to compensate.
-///       render_target_size.width /= 2;
-///       render_target_size.height /= 2;
-///       gvr_swap_chain_resize_buffer(swap_chain, 0, render_target_size);
-///
-///       // This function will depend on your render loop's implementation.
-///       gvr_clock_time_point next_vsync = AppGetNextVsyncTime();
-///
-///       const gvr_mat4f head_view =
-///           gvr_get_head_space_from_start_space_rotation(gvr, next_vsync);
-///       const gvr_mat4f left_eye_view = MatrixMultiply(
-///           gvr_get_eye_from_head_matrix(gvr, GVR_LEFT_EYE), head_view);
-///       const gvr::Mat4f right_eye_view = MatrixMultiply(
-///           gvr_get_eye_from_head_matrix(gvr, GVR_RIGHT_EYE), head_view);
-///
-///       // Insert client rendering code here.
-///
-///       AppSetRenderTarget(offscreen_texture_id);
-///
-///       AppDoSomeRenderingForEye(
-///           gvr_buffer_viewport_get_source_uv(left_eye_view),
-///           left_eye_matrix);
-///       AppDoSomeRenderingForEye(
-///           gvr_buffer_viewport_get_source_uv(right_eye_view),
-///           right_eye_matrix);
-///       AppSetRenderTarget(primary_display);
-///
-///       gvr_frame_submit(&frame, viewport_list, head_matrix);
-///     }
-///
-///     // Cleanup memory.
-///     gvr_buffer_viewport_list_destroy(&viewport_list);
-///     gvr_buffer_viewport_destroy(&left_eye_vp);
-///     gvr_buffer_viewport_destroy(&right_eye_vp);
-///
-///     #ifdef __ANDROID__
-///     // On Android, The Java GvrLayout owns the gvr_context.
-///     #else
-///     gvr_destroy(gvr);
-///     #endif
-///
-/// Head tracking is enabled by default, and will begin as soon as the
-/// gvr_context is created. The client should call gvr_pause_tracking() and
-/// gvr_resume_tracking() when the app is paused and resumed, respectively.
-///
-/// Note: Unless otherwise noted, the functions in this API may not be
-/// thread-safe with respect to the gvr_context, and it is up the caller to use
-/// the API in a thread-safe manner.
-///
-/// @{
-
-/// Creates a new gvr instance.
-///
-/// The instance must remain valid as long as any GVR object is in use. When
-/// the application no longer needs to use the GVR SDK, call gvr_destroy().
-///
-///
-/// On Android, the gvr_context should *almost always* be obtained from the Java
-/// GvrLayout object, rather than explicitly created here. The GvrLayout should
-/// live in the app's View hierarchy, and its use is required to ensure
-/// consistent behavior across all varieties of GVR-compatible viewers. See
-/// the Java GvrLayout and GvrApi documentation for more details.
-///
-#ifdef __ANDROID__
-/// @param env The JNIEnv associated with the current thread.
-/// @param app_context The Android application context. This must be the
-///     application context, NOT an Activity context (Note: from any Android
-///     Activity in your app, you can call getApplicationContext() to
-///     retrieve the application context).
-/// @param class_loader The class loader to use when loading Java classes.
-///     This must be your app's main class loader (usually accessible through
-///     activity.getClassLoader() on any of your Activities).
-///
-/// @return Pointer to the created gvr instance, NULL on failure.
-gvr_context* gvr_create(JNIEnv* env, jobject app_context, jobject class_loader);
-#else
-/// @return Pointer to the created gvr instance, NULL on failure.
-gvr_context* gvr_create();
-#endif  // #ifdef __ANDROID__
-
-/// Gets the current GVR runtime version.
-///
-/// Note: This runtime version may differ from the version against which the
-/// client app is compiled, as defined by the semantic version components in
-/// gvr_version.h.
-///
-/// @return The version as a gvr_version.
-gvr_version gvr_get_version();
-
-/// Gets a string representation of the current GVR runtime version. This is of
-/// the form "MAJOR.MINOR.PATCH".
-///
-/// Note: This runtime version may differ from the version against which the
-/// client app is compiled, as defined in gvr_version.h by
-/// GVR_SDK_VERSION_STRING.
-///
-/// @return The version as a static char pointer.
-const char* gvr_get_version_string();
-
-/// Gets the current GVR error code, or GVR_ERROR_NONE if there is no error.
-/// This function doesn't clear the error code; see gvr_clear_error().
-///
-/// @param gvr Pointer to the gvr instance.
-/// @return The current gvr_error code, or GVR_ERROR_NONE if no error has
-///    occurred.
-int32_t gvr_get_error(gvr_context* gvr);
-
-/// Clears the current GVR error code, and returns the error code that was
-/// cleared.
-///
-/// @param gvr Pointer to the gvr instance.
-/// @return The gvr_error code that was cleared by this function, or
-/// GVR_ERROR_NONE if no error has occurred.
-int32_t gvr_clear_error(gvr_context* gvr);
-
-/// Gets a human-readable string representing the given error code.
-///
-/// @param error_code The gvr_error code.
-/// @return A human-readable string representing the error code.
-const char* gvr_get_error_string(int32_t error_code);
-
-/// Returns an opaque struct containing information about user preferences.
-///
-/// The returned struct will remain valid as long as the context is valid.
-/// The returned struct may be updated when the user changes their preferences,
-/// so this function only needs to be called once, and calling it multiple
-/// times will return the same object each time.
-///
-/// @param gvr Pointer to the gvr instance.
-/// @return An opaque struct containing information about user preferences.
-const gvr_user_prefs* gvr_get_user_prefs(gvr_context* gvr);
-
-/// Returns the controller handedness of the given gvr_user_prefs struct.
-///
-/// @param user_prefs Pointer to the gvr_user_prefs object returned by
-///     gvr_get_user_prefs.
-/// @return Either GVR_CONTROLLER_RIGHT_HANDED or GVR_CONTROLLER_LEFT_HANDED
-///     depending on which hand the user holds the controller in.
-int32_t gvr_user_prefs_get_controller_handedness(
-    const gvr_user_prefs* user_prefs);
-
-/// Destroys a gvr_context instance.  The parameter will be nulled by this
-/// operation.  Once this function is called, the behavior of any subsequent
-/// call to a GVR SDK function that references objects created from this
-/// context is undefined.
-///
-/// @param gvr Pointer to a pointer to the gvr instance to be destroyed and
-///     nulled.
-void gvr_destroy(gvr_context** gvr);
-
-/// Initializes necessary GL-related objects and uses the current thread and
-/// GL context for rendering. Please make sure that a valid GL context is
-/// available when this function is called.  This should never be called more
-/// than once on the same GL context (doing so would cause resource leaks).
-///
-/// @param gvr Pointer to the gvr instance to be initialized.
-void gvr_initialize_gl(gvr_context* gvr);
-
-/// Gets whether asynchronous reprojection is currently enabled.
-///
-/// If enabled, frames will be collected by the rendering system and
-/// asynchronously re-projected in sync with the scanout of the display. This
-/// feature may not be available on every platform, and requires a
-/// high-priority render thread with special extensions to function properly.
-///
-/// Note: On Android, this feature can be enabled solely via the GvrLayout Java
-/// instance which (indirectly) owns this gvr_context. The corresponding
-/// method call is GvrLayout.setAsyncReprojectionEnabled().
-///
-/// Note: Because of the above requirements, asynchronous reprojection is only
-/// currently available on Daydream-ready Android devices.  This function will
-/// always return false on other devices.
-///
-/// @param gvr Pointer to the gvr instance.
-/// @return Whether async reprojection is enabled. Defaults to false.
-bool gvr_get_async_reprojection_enabled(const gvr_context* gvr);
-
-/// Gets the recommended buffer viewport configuration, populating a previously
-/// allocated gvr_buffer_viewport_list object. The updated values include the
-/// per-eye recommended viewport and field of view for the target.
-///
-/// When the recommended viewports are used for distortion rendering, this
-/// method should always be called after calling refresh_viewer_profile(). That
-/// will ensure that the populated viewports reflect the currently paired
-/// viewer.
-///
-/// @param gvr Pointer to the gvr instance from which to get the viewports.
-/// @param viewport_list Pointer to a previously allocated viewport list. This
-///     will be populated with the recommended buffer viewports and resized if
-///     necessary.
-void gvr_get_recommended_buffer_viewports(
-    const gvr_context* gvr, gvr_buffer_viewport_list* viewport_list);
-
-/// Gets the screen (non-distorted) buffer viewport configuration, populating a
-/// previously allocated gvr_buffer_viewport_list object. The updated values
-/// include the per-eye recommended viewport and field of view for the target.
-///
-/// @param gvr Pointer to the gvr instance from which to get the viewports.
-/// @param viewport_list Pointer to a previously allocated viewport list. This
-///     will be populated with the screen buffer viewports and resized if
-///     necessary.
-void gvr_get_screen_buffer_viewports(const gvr_context* gvr,
-                                     gvr_buffer_viewport_list* viewport_list);
-
-/// Returns the maximum effective size for the client's render target, given the
-/// parameters of the head mounted device selected. At this resolution, we have
-/// a 1:1 ratio between source pixels and screen pixels in the most magnified
-/// region of the screen. Applications should rarely, if ever, need to render
-/// to a larger target, as it will simply result in sampling artifacts.
-///
-/// Note that this is probably too large for most applications to use as a
-/// render target size. Applications should scale this value to be appropriate
-/// to their graphical load.
-///
-/// @param gvr Pointer to the gvr instance from which to get the size.
-///
-/// @return Maximum effective size for the target render target.
-gvr_sizei gvr_get_maximum_effective_render_target_size(const gvr_context* gvr);
-
-/// Returns a non-distorted size for the screen, given the parameters
-/// of the phone and/or the head mounted device selected.
-///
-/// @param gvr Pointer to the gvr instance from which to get the size.
-///
-/// @return Screen (non-distorted) size for the render target.
-gvr_sizei gvr_get_screen_target_size(const gvr_context* gvr);
-
-// Sets the size of the underlying render surface.
-//
-// By default, it is assumed that the display size matches the surface
-// size. If that is the case for the client app, this method need never be
-// called. However, in certain cases (e.g., hardware scaling), this will not
-// always hold, in which case the distortion pass must be informed of the
-// custom surface size.
-//
-// Note that the caller is responsible for resizing any BufferSpec objects
-// created before this function is called. Otherwise there will be rendering
-// artifacts, such as edges appearing pixelated. This function will change the
-// result of get_maximum_effective_render_target_size(), so that function can be
-// used to compute the appropriate size for buffers.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param surface_size_pixels The size in pixels of the display surface. If
-//     non-empty, this will be used in conjunction with the current display to
-//     perform properly scaled distortion. If empty, it is assumed that the
-//     rendering surface dimensions match that of the active display.
-void gvr_set_surface_size(gvr_context* gvr, gvr_sizei surface_size_pixels);
-
-/// Performs postprocessing, including lens distortion, on the contents of the
-/// passed texture and shows the result on the screen. Lens distortion is
-/// determined by the parameters of the viewer encoded in its QR code. The
-/// passed texture is not modified.
-///
-/// If the application does not call gvr_initialize_gl() before calling this
-/// function, the results are undefined.
-///
-/// @deprecated This function exists only to support legacy rendering pathways
-///     for Cardboard devices. It is incompatible with the low-latency
-///     experiences supported by async reprojection. Use the swap chain API
-///     instead.
-///
-/// @param gvr Pointer to the gvr instance which will do the distortion.
-/// @param texture_id The OpenGL ID of the texture that contains the next frame
-///     to be displayed.
-/// @param viewport_list Rendering parameters.
-/// @param head_space_from_start_space This parameter is ignored.
-/// @param target_presentation_time This parameter is ignored.
-void gvr_distort_to_screen(gvr_context* gvr, int32_t texture_id,
-                           const gvr_buffer_viewport_list* viewport_list,
-                           gvr_mat4f head_space_from_start_space,
-                           gvr_clock_time_point target_presentation_time);
-
-/// Queries whether a particular GVR feature is supported by the underlying
-/// platform.
-///
-/// @param gvr The context to query against.
-/// @param feature The gvr_feature type being queried.
-/// @return true if feature is supported, false otherwise.
-bool gvr_is_feature_supported(const gvr_context* gvr, int32_t feature);
-
-/// @}
-
-/////////////////////////////////////////////////////////////////////////////
-// Viewports and viewport lists
-/////////////////////////////////////////////////////////////////////////////
-/// @defgroup viewport Viewports and viewport lists
-/// @brief Objects to define the mapping between the application's rendering
-///     output and the user's field of view.
-/// @{
-
-/// Creates a gvr_buffer_viewport instance.
-gvr_buffer_viewport* gvr_buffer_viewport_create(gvr_context* gvr);
-
-/// Frees a gvr_buffer_viewport instance and clears the pointer.
-void gvr_buffer_viewport_destroy(gvr_buffer_viewport** viewport);
-
-/// Gets the UV coordinates specifying where the output buffer is sampled.
-///
-/// @param viewport The buffer viewport.
-/// @return UV coordinates as a rectangle.
-gvr_rectf gvr_buffer_viewport_get_source_uv(
-    const gvr_buffer_viewport* viewport);
-
-/// Sets the UV coordinates specifying where the output buffer should be
-/// sampled when compositing the final distorted image.
-///
-/// @param viewport The buffer viewport.
-/// @param uv The new UV coordinates for sampling. The coordinates must be
-///     valid, that is, left <= right and bottom <= top. Otherwise an empty
-///     source region is set, which will result in no output for this viewport.
-void gvr_buffer_viewport_set_source_uv(gvr_buffer_viewport* viewport,
-                                       gvr_rectf uv);
-
-/// Retrieves the field of view for the referenced buffer region.
-///
-/// This is a helper that converts the stored projection matrix to a field of
-/// view. Note that if the previously set projection matrix cannot be expressed
-/// as a view frustum aligned with the eye's optical axis, the result will be
-/// incorrect.
-///
-/// @param viewport The buffer viewport.
-/// @return The field of view of the rendered image, in degrees.
-gvr_rectf gvr_buffer_viewport_get_source_fov(
-    const gvr_buffer_viewport* viewport);
-
-/// Sets the field of view for the viewport contents.
-///
-/// This is a helper that sets the projection matrix in such a way that the
-/// viewport's contents fill the specified FOV around the eye's optical axis.
-///
-/// @param viewport The buffer viewport.
-/// @param fov The field of view to use when compositing the rendered image,
-///     in degrees.
-void gvr_buffer_viewport_set_source_fov(gvr_buffer_viewport* viewport,
-                                        gvr_rectf fov);
-
-/// Gets the matrix that positions the viewport in eye space.
-///
-/// @param viewport The buffer viewport.
-/// @return Matrix that transforms a quad with vertices (-1, -1, 0), (1, -1, 0),
-///     (-1, 1, 0), (1, 1, 0) representing the viewport contents to its desired
-///     eye space position for the target eye.
-gvr_mat4f gvr_buffer_viewport_get_transform(
-    const gvr_buffer_viewport* viewport);
-
-/// Sets the matrix that positions the viewport in eye space.
-///
-/// @param viewport The buffer viewport.
-/// @param transform Matrix that transforms a quad with vertices (-1, -1, 0),
-///     (1, -1, 0), (-1, 1, 0), (1, 1, 0) representing the viewport contents to
-///     its desired eye space position for the target eye.
-void gvr_buffer_viewport_set_transform(gvr_buffer_viewport* viewport,
-                                       gvr_mat4f transform);
-
-/// Gets the target logical eye for the specified viewport.
-///
-/// @param viewport The buffer viewport.
-/// @return Index of the target logical eye for this viewport.
-int32_t gvr_buffer_viewport_get_target_eye(const gvr_buffer_viewport* viewport);
-
-/// Sets the target logical eye for the specified viewport.
-///
-/// @param viewport The buffer viewport.
-/// @param index Index of the target logical eye.
-void gvr_buffer_viewport_set_target_eye(gvr_buffer_viewport* viewport,
-                                        int32_t index);
-
-/// Gets the index of the source buffer from which the viewport reads its
-/// undistorted pixels.
-///
-/// @param viewport The buffer viewport.
-/// @return Index of the source buffer. This corresponds to the index in the
-///     list of buffer specs that was passed to gvr_swap_chain_create().
-int32_t gvr_buffer_viewport_get_source_buffer_index(
-    const gvr_buffer_viewport* viewport);
-
-/// Sets the buffer from which the viewport reads its undistorted pixels.
-///
-/// To use the contents of the external surface as buffer contents, associate an
-/// external surface with the viewport by calling
-/// gvr_buffer_viewport_set_external_surface_id(), then call this function and
-/// pass GVR_BUFFER_INDEX_EXTERNAL_SURFACE.
-///
-/// @param viewport The buffer viewport.
-/// @param buffer_index The index of the source buffer. This is either an index
-///     in the list of buffer specs that was passed to
-///     gvr_swap_chain_create(), or GVR_BUFFER_INDEX_EXTERNAL_SURFACE.
-void gvr_buffer_viewport_set_source_buffer_index(
-    gvr_buffer_viewport* viewport, int32_t buffer_index);
-
-/// Gets the ID of the externally-managed Surface texture from which this
-/// viewport reads undistored pixels.
-///
-/// @param viewport The buffer viewport.
-/// @return ID of the externally-managed Surface of undistorted pixels.
-int32_t gvr_buffer_viewport_get_external_surface_id(
-    const gvr_buffer_viewport* viewport);
-
-/// Sets the ID of the externally-managed Surface texture from which this
-/// viewport reads. The ID is issued by GvrLayout.
-///
-/// @param viewport The buffer viewport.
-/// @param external_surface_id The ID of the surface to read from.
-void gvr_buffer_viewport_set_external_surface_id(
-    gvr_buffer_viewport* viewport, int32_t external_surface_id);
-
-/// Gets the type of reprojection to perform on the specified viewport.
-///
-/// @param viewport The buffer viewport.
-/// @return Type of reprojection that is applied to the viewport.
-int32_t gvr_buffer_viewport_get_reprojection(
-    const gvr_buffer_viewport* viewport);
-
-/// Sets the type of reprojection to perform on the specified viewport.
-/// Viewports that display world content should use full reprojection.
-/// Viewports that display head-locked UI should disable reprojection to avoid
-/// excessive judder. The default is to perform full reprojection.
-///
-/// @param viewport The buffer viewport.
-/// @param reprojection Type of reprojection that will be applied to the passed
-///     viewport.
-void gvr_buffer_viewport_set_reprojection(gvr_buffer_viewport* viewport,
-                                          int32_t reprojection);
-
-/// Compares two gvr_buffer_viewport instances and returns true if they specify
-/// the same view mapping.
-///
-/// @param a Instance of a buffer viewport.
-/// @param b Another instance of a buffer viewport.
-/// @return True if the passed viewports are the same.
-bool gvr_buffer_viewport_equal(const gvr_buffer_viewport* a,
-                               const gvr_buffer_viewport* b);
-
-/// Creates a new, empty list of viewports. The viewport list defines how the
-/// application's rendering output should be transformed into the stabilized,
-/// lens-distorted image that is sent to the screen.
-///
-/// The caller should populate the returned viewport using one of:
-///   - gvr_get_recommended_buffer_viewports()
-///   - gvr_get_screen_buffer_viewports()
-///   - gvr_buffer_viewport_list_set_item()
-///
-/// @param gvr Pointer the gvr instance from which to allocate the viewport
-/// list.
-/// @return Pointer to an allocated gvr_buffer_viewport_list object. The caller
-//      is responsible for calling gvr_buffer_viewport_list_destroy() on the
-///     returned object when it is no longer needed.
-gvr_buffer_viewport_list* gvr_buffer_viewport_list_create(
-    const gvr_context* gvr);
-
-/// Destroys a gvr_buffer_viewport_list instance. The parameter will be nulled
-/// by this operation.
-///
-/// @param viewport_list Pointer to a pointer to the viewport list instance to
-///     be destroyed and nulled.
-void gvr_buffer_viewport_list_destroy(gvr_buffer_viewport_list** viewport_list);
-
-/// Returns the size of the given viewport list.
-///
-/// @param viewport_list Pointer to a viewport list.
-/// @return The number of entries in the viewport list.
-size_t gvr_buffer_viewport_list_get_size(
-    const gvr_buffer_viewport_list* viewport_list);
-
-/// Retrieve a buffer viewport entry from a list.
-///
-/// @param viewport_list Pointer to the previously allocated viewport list.
-/// @param index Zero-based index of the viewport entry to query. Must be
-///    smaller than the list size.
-/// @param viewport The buffer viewport structure that will be populated with
-///    retrieved data.
-void gvr_buffer_viewport_list_get_item(
-    const gvr_buffer_viewport_list* viewport_list, size_t index,
-    gvr_buffer_viewport* viewport);
-
-/// Update an element of the viewport list or append a new one at the end.
-///
-/// @param viewport_list Pointer to a previously allocated viewport list.
-/// @param index Index of the buffer viewport entry to update. If the
-///     `viewport_list` size is equal to the index, a new viewport entry will be
-///     added. The `viewport_list` size must *not* be less than the index value.
-/// @param viewport A pointer to the buffer viewport object.
-void gvr_buffer_viewport_list_set_item(gvr_buffer_viewport_list* viewport_list,
-                                       size_t index,
-                                       const gvr_buffer_viewport* viewport);
-
-/// @}
-
-/////////////////////////////////////////////////////////////////////////////
-// Swapchains and frames
-/////////////////////////////////////////////////////////////////////////////
-/// @defgroup swap_chain Swap chains and frames
-/// @brief Functions to create a swap chain, manipulate it and submit frames
-///     for lens distortion and presentation on the screen.
-/// @{
-
-/// Creates a default buffer specification.
-gvr_buffer_spec* gvr_buffer_spec_create(gvr_context* gvr);
-
-/// Destroy the buffer specification and null the pointer.
-void gvr_buffer_spec_destroy(gvr_buffer_spec** spec);
-
-/// Gets the size of the buffer to be created.
-///
-/// @param spec Buffer specification.
-/// @return Size of the pixel buffer. The default is equal to the recommended
-///     render target size at the time when the specification was created.
-gvr_sizei gvr_buffer_spec_get_size(const gvr_buffer_spec* spec);
-
-/// Sets the size of the buffer to be created.
-///
-/// @param spec Buffer specification.
-/// @param size The size. Width and height must both be greater than zero.
-///     Otherwise, the application is aborted.
-void gvr_buffer_spec_set_size(gvr_buffer_spec* spec, gvr_sizei size);
-
-/// Gets the number of samples per pixel in the buffer to be created.
-///
-/// @param spec Buffer specification.
-/// @return Value >= 1 giving the number of samples. 1 means multisampling is
-///     disabled. Negative values and 0 are never returned.
-int32_t gvr_buffer_spec_get_samples(const gvr_buffer_spec* spec);
-
-/// Sets the number of samples per pixel in the buffer to be created.
-///
-/// @param spec Buffer specification.
-/// @param num_samples The number of samples. Negative values are an error.
-///     The values 0 and 1 are treated identically and indicate that
-//      multisampling should be disabled.
-void gvr_buffer_spec_set_samples(gvr_buffer_spec* spec, int32_t num_samples);
-
-/// Sets the color format for the buffer to be created. Default format is
-/// GVR_COLOR_FORMAT_RGBA_8888.
-///
-/// @param spec Buffer specification.
-/// @param color_format The color format for the buffer. Valid formats are in
-///     the gvr_color_format_type enum.
-void gvr_buffer_spec_set_color_format(gvr_buffer_spec* spec,
-                                      int32_t color_format);
-
-/// Sets the depth and stencil format for the buffer to be created. Currently,
-/// only packed stencil formats are supported. Default format is
-/// GVR_DEPTH_STENCIL_FORMAT_DEPTH_16.
-///
-/// @param spec Buffer specification.
-/// @param depth_stencil_format The depth and stencil format for the buffer.
-///     Valid formats are in the gvr_depth_stencil_format_type enum.
-void gvr_buffer_spec_set_depth_stencil_format(gvr_buffer_spec* spec,
-                                              int32_t depth_stencil_format);
-
-/// Creates a swap chain from the given buffer specifications.
-/// This is a potentially time-consuming operation. All frames within the
-/// swapchain will be allocated. Once rendering is stopped, call
-/// gvr_swap_chain_destroy() to free GPU resources. The passed gvr_context must
-/// not be destroyed until then.
-///
-/// Swap chains can have no buffers. This is useful when only displaying
-/// external surfaces. When `count` is zero, `buffers` must be null.
-///
-/// @param gvr GVR instance for which a swap chain will be created.
-/// @param buffers Array of pixel buffer specifications. Each frame in the
-///     swap chain will be composed of these buffers.
-/// @param count Number of buffer specifications in the array.
-/// @return Opaque handle to the newly created swap chain.
-gvr_swap_chain* gvr_swap_chain_create(gvr_context* gvr,
-                                      const gvr_buffer_spec** buffers,
-                                      int32_t count);
-
-/// Destroys the swap chain and nulls the pointer.
-void gvr_swap_chain_destroy(gvr_swap_chain** swap_chain);
-
-/// Gets the number of buffers in each frame of the swap chain.
-int32_t gvr_swap_chain_get_buffer_count(const gvr_swap_chain* swap_chain);
-
-/// Retrieves the size of the specified pixel buffer. Note that if the buffer
-/// was resized while the current frame was acquired, the return value will be
-/// different than the value obtained from the equivalent function for the
-/// current frame.
-///
-/// @param swap_chain The swap chain.
-/// @param index Index of the pixel buffer.
-/// @return Size of the specified pixel buffer in frames that will be returned
-///     from gvr_swap_chain_acquire_frame().
-gvr_sizei gvr_swap_chain_get_buffer_size(gvr_swap_chain* swap_chain,
-                                         int32_t index);
-
-/// Resizes the specified pixel buffer to the given size. The frames are resized
-/// when they are unused, so the currently acquired frame will not be resized
-/// immediately.
-///
-/// @param swap_chain The swap chain.
-/// @param index Index of the pixel buffer to resize.
-/// @param size New size for the specified pixel buffer.
-void gvr_swap_chain_resize_buffer(gvr_swap_chain* swap_chain, int32_t index,
-                                  gvr_sizei size);
-
-/// Acquires a frame from the swap chain for rendering. Buffers that are part of
-/// the frame can then be bound with gvr_frame_bind_buffer(). Once the frame
-/// is finished and all its constituent buffers are ready, call
-/// gvr_frame_submit() to display it while applying lens distortion.
-///
-/// @param swap_chain The swap chain.
-/// @return Handle to the acquired frame. NULL if the swap chain is invalid,
-///     or if acquire has already been called on this swap chain.
-gvr_frame* gvr_swap_chain_acquire_frame(gvr_swap_chain* swap_chain);
-
-/// Binds a pixel buffer that is part of the frame to the OpenGL framebuffer.
-///
-/// @param frame Frame handle acquired from the swap chain.
-/// @param index Index of the pixel buffer to bind. This corresponds to the
-///     index in the buffer spec list that was passed to
-///     gvr_swap_chain_create().
-void gvr_frame_bind_buffer(gvr_frame* frame, int32_t index);
-
-/// Unbinds any buffers bound from this frame and binds the default OpenGL
-/// framebuffer.
-void gvr_frame_unbind(gvr_frame* frame);
-
-/// Returns the dimensions of the pixel buffer with the specified index. Note
-/// that a frame that was acquired before resizing a swap chain buffer will not
-/// be resized until it is submitted to the swap chain.
-///
-/// @param frame Frame handle.
-/// @param index Index of the pixel buffer to inspect.
-/// @return Dimensions of the specified pixel buffer.
-gvr_sizei gvr_frame_get_buffer_size(const gvr_frame* frame, int32_t index);
-
-/// Gets the name (ID) of the framebuffer object associated with the specified
-/// buffer. The OpenGL state is not modified.
-///
-/// @param frame Frame handle.
-/// @param index Index of a pixel buffer.
-/// @return OpenGL object name (ID) of a framebuffer object which can be used
-///     to render into the buffer. The ID is valid only until the frame is
-///     submitted.
-int32_t gvr_frame_get_framebuffer_object(const gvr_frame* frame, int32_t index);
-
-/// Submits the frame for distortion and display on the screen. The passed
-/// pointer is nulled to prevent reuse.
-///
-/// @param frame The frame to submit.
-/// @param list Buffer view configuration to be used for this frame.
-/// @param head_space_from_start_space Transform from start space (space with
-///     head at the origin at last tracking reset) to head space (space with
-///     head at the origin and axes aligned to the view vector).
-void gvr_frame_submit(gvr_frame** frame, const gvr_buffer_viewport_list* list,
-                      gvr_mat4f head_space_from_start_space);
-
-/// Resets the OpenGL framebuffer binding to what it was at the time the
-/// passed gvr_context was created.
-void gvr_bind_default_framebuffer(gvr_context* gvr);
-
-/// @}
-
-/////////////////////////////////////////////////////////////////////////////
-// Head tracking
-/////////////////////////////////////////////////////////////////////////////
-/// @defgroup Headtracking Head tracking
-/// @brief Functions for managing head tracking.
-/// @{
-
-/// Gets the current monotonic system time.
-///
-/// @return The current monotonic system time.
-gvr_clock_time_point gvr_get_time_point_now();
-
-/// Gets the rotation from start space to head space.  The head space is a
-/// space where the head is at the origin and faces the -Z direction.
-///
-/// @param gvr Pointer to the gvr instance from which to get the pose.
-/// @param time The time at which to get the head pose. The time should be in
-///     the future. If the time is not in the future, it will be clamped to now.
-/// @return A matrix representation of the rotation from start space (the space
-///     where the head was last reset) to head space (the space with the head
-///     at the origin, and the axes aligned to the view vector).
-gvr_mat4f gvr_get_head_space_from_start_space_rotation(
-    const gvr_context* gvr, const gvr_clock_time_point time);
-
-/// Applies a simple neck model translation based on the rotation of the
-/// provided head pose.
-///
-/// Note: Neck model application may not be appropriate for all tracking
-/// scenarios, e.g., when tracking is non-biological.
-///
-/// @param gvr Pointer to the context instance from which the pose was obtained.
-/// @param head_space_from_start_space_rotation The head rotation as returned by
-///     gvr_get_head_space_from_start_space_rotation().
-/// @param factor A scaling factor for the neck model offset, clamped from 0 to
-///     1. This should be 1 for most scenarios, while 0 will effectively disable
-///     neck model application. This value can be animated to smoothly
-///     interpolate between alternative (client-defined) neck models.
-/// @return The new head pose with the neck model applied.
-gvr_mat4f gvr_apply_neck_model(const gvr_context* gvr,
-                               gvr_mat4f head_space_from_start_space_rotation,
-                               float factor);
-
-/// Pauses head tracking, disables all sensors (to save power).
-///
-/// @param gvr Pointer to the gvr instance for which tracking will be paused and
-///     sensors disabled.
-void gvr_pause_tracking(gvr_context* gvr);
-
-/// Resumes head tracking, re-enables all sensors.
-///
-/// @param gvr Pointer to the gvr instance for which tracking will be resumed.
-void gvr_resume_tracking(gvr_context* gvr);
-
-/// Resets head tracking.
-///
-/// This API call is deprecated. Use gvr_recenter_tracking instead, which
-/// accomplishes the same effects but avoids the undesirable side-effects of
-/// a full reset (temporary loss of tracking quality).
-///
-/// Only to be used by Cardboard apps. Daydream apps must not call this. On the
-/// Daydream platform, recentering is handled automatically and should never
-/// be triggered programatically by applications. Hybrid apps that support both
-/// Cardboard and Daydream must only call this function when in Cardboard mode
-/// (that is, when the phone is paired with a Cardboard viewer), never in
-/// Daydream mode.
-///
-/// @param gvr Pointer to the gvr instance for which tracking will be reseted.
-/// @deprecated Calls to this method can be safely replaced by calls to
-//    gvr_recenter_tracking.
-void gvr_reset_tracking(gvr_context* gvr);
-
-/// Recenters the head orientation (resets the yaw to zero, leaving pitch and
-/// roll unmodified).
-///
-/// Only to be used by Cardboard apps. Daydream apps must not call this. On the
-/// Daydream platform, recentering is handled automatically and should never
-/// be triggered programatically by applications. Hybrid apps that support both
-/// Cardboard and Daydream must only call this function when in Cardboard mode
-/// (that is, when the phone is paired with a Cardboard viewer), never in
-/// Daydream mode.
-///
-/// @param gvr Pointer to the gvr instance for which tracking will be
-///     recentered.
-void gvr_recenter_tracking(gvr_context* gvr);
-
-/// @}
-
-
-/////////////////////////////////////////////////////////////////////////////
-// Head mounted display.
-/////////////////////////////////////////////////////////////////////////////
-/// @defgroup HMD Head Mounted Display
-/// @brief Functions for managing viewer information.
-/// @{
-
-/// Sets the default viewer profile specified by viewer_profile_uri.
-/// The viewer_profile_uri that is passed in will be ignored if a valid
-/// viewer profile has already been stored on the device that the app
-/// is running on.
-///
-/// Note: This function has the potential of blocking for up to 30 seconds for
-/// each redirect if a shortened URI is passed in as argument. It will try to
-/// unroll the shortened URI for a maximum number of 5 times if the redirect
-/// continues. In that case, it is recommended to create a separate thread to
-/// call this function so that other tasks like rendering will not be blocked
-/// on this. The blocking can be avoided if a standard URI is passed in.
-///
-/// @param gvr Pointer to the gvr instance which to set the profile on.
-/// @param viewer_profile_uri A string that contains either the shortened URI or
-///     the standard URI representing the viewer profile that the app should be
-///     using. If the valid viewer profile can be found on the device, the URI
-///     that is passed in will be ignored and nothing will happen. Otherwise,
-///     gvr will look for the viewer profile specified by viewer_profile_uri,
-///     and it will be stored if found. Also, the values will be applied to gvr.
-///     A valid standard URI can be generated from this page:
-///     https://www.google.com/get/cardboard/viewerprofilegenerator/
-/// @return True if the viewer profile specified by viewer_profile_uri was
-///     successfully stored and applied, false otherwise.
-bool gvr_set_default_viewer_profile(gvr_context* gvr,
-                                    const char* viewer_profile_uri);
-
-/// Refreshes gvr_context with the viewer profile that is stored on the device.
-/// If it can not find the viewer profile, nothing will happen.
-///
-/// @param gvr Pointer to the gvr instance to refresh the profile on.
-void gvr_refresh_viewer_profile(gvr_context* gvr);
-
-/// Gets the name of the viewer vendor.
-///
-/// @param gvr Pointer to the gvr instance from which to get the vendor.
-/// @return A pointer to the vendor name. May be NULL if no viewer is paired.
-///     WARNING: This method guarantees the validity of the returned pointer
-///     only until the next use of the `gvr` context. The string should be
-///     copied immediately if persistence is required.
-const char* gvr_get_viewer_vendor(const gvr_context* gvr);
-
-/// Gets the name of the viewer model.
-///
-/// @param gvr Pointer to the gvr instance from which to get the name.
-/// @return A pointer to the model name. May be NULL if no viewer is paired.
-///     WARNING: This method guarantees the validity of the returned pointer
-///     only until the next use of the `gvr` context. The string should be
-///     copied immediately if persistence is required.
-const char* gvr_get_viewer_model(const gvr_context* gvr);
-
-/// Gets the type of the viewer, as defined by gvr_viewer_type.
-///
-/// @param gvr Pointer to the gvr instance from which to get the viewer type.
-/// @return The gvr_viewer_type of the currently paired viewer.
-int32_t gvr_get_viewer_type(const gvr_context* gvr);
-
-/// Gets the transformation matrix to convert from Head Space to Eye Space for
-/// the given eye.
-///
-/// @param gvr Pointer to the gvr instance from which to get the matrix.
-/// @param eye Selected gvr_eye type.
-/// @return Transformation matrix from Head Space to selected Eye Space.
-gvr_mat4f gvr_get_eye_from_head_matrix(const gvr_context* gvr,
-                                       const int32_t eye);
-
-/// Gets the window bounds.
-///
-/// @param gvr Pointer to the gvr instance from which to get the bounds.
-///
-/// @return Window bounds in physical pixels.
-gvr_recti gvr_get_window_bounds(const gvr_context* gvr);
-
-/// Computes the distorted point for a given point in a given eye.  The
-/// distortion inverts the optical distortion caused by the lens for the eye.
-/// Due to chromatic aberration, the distortion is different for each
-/// color channel.
-///
-/// @param gvr Pointer to the gvr instance which will do the computing.
-/// @param eye The gvr_eye type (left or right).
-/// @param uv_in A point in screen eye Viewport Space in [0,1]^2 with (0, 0)
-///     in the lower left corner of the eye's viewport and (1, 1) in the
-///     upper right corner of the eye's viewport.
-/// @param uv_out A pointer to an array of (at least) 3 elements, with each
-///     element being a Point2f representing a point in render texture eye
-///     Viewport Space in [0,1]^2 with (0, 0) in the lower left corner of the
-///     eye's viewport and (1, 1) in the upper right corner of the eye's
-///     viewport.
-///     `uv_out[0]` is the corrected position of `uv_in` for the red channel
-///     `uv_out[1]` is the corrected position of `uv_in` for the green channel
-///     `uv_out[2]` is the corrected position of `uv_in` for the blue channel
-void gvr_compute_distorted_point(const gvr_context* gvr, const int32_t eye,
-                                 const gvr_vec2f uv_in, gvr_vec2f uv_out[3]);
-
-/// @}
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-namespace gvr {
-
-/// Convenience C++ wrapper for gvr_user_prefs.
-class UserPrefs {
- public:
-  /// Creates a C++ wrapper for a gvr_user_prefs object. Note that unlike most
-  /// of the C++ wrappers in the API, this does not take ownership, as the
-  /// gvr_user_prefs will remain valid for the lifetime of the GVR context.
-  explicit UserPrefs(const gvr_user_prefs* user_prefs)
-      : user_prefs_(user_prefs) {}
-
-  UserPrefs(UserPrefs&& other) : user_prefs_(nullptr) {
-    std::swap(user_prefs_, other.user_prefs_);
-  }
-
-  UserPrefs& operator=(UserPrefs&& other) {
-    std::swap(user_prefs_, other.user_prefs_);
-    return *this;
-  }
-
-  /// For more information, see gvr_user_prefs_get_controller_handedness().
-  ControllerHandedness GetControllerHandedness() const {
-    return static_cast<ControllerHandedness>(
-        gvr_user_prefs_get_controller_handedness(user_prefs_));
-  }
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  const gvr_user_prefs* cobj() const { return user_prefs_; }
-
- private:
-  const gvr_user_prefs* user_prefs_;
-
-  // Disallow copy and assign.
-  UserPrefs(const UserPrefs&);
-  void operator=(const UserPrefs&);
-};
-
-/// Convenience C++ wrapper for the opaque gvr_buffer_viewport type.
-/// The constructor allocates memory, so when used in tight loops, instances
-/// should be reused.
-class BufferViewport {
- public:
-  BufferViewport(BufferViewport&& other)
-      : viewport_(nullptr) {
-    std::swap(viewport_, other.viewport_);
-  }
-
-  BufferViewport& operator=(BufferViewport&& other) {
-    std::swap(viewport_, other.viewport_);
-    return *this;
-  }
-
-  ~BufferViewport() {
-    if (viewport_) gvr_buffer_viewport_destroy(&viewport_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_get_source_fov().
-  Rectf GetSourceFov() const {
-    return gvr_buffer_viewport_get_source_fov(viewport_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_set_source_fov().
-  void SetSourceFov(const Rectf& fov) {
-    gvr_buffer_viewport_set_source_fov(viewport_, fov);
-  }
-
-  /// For more information, see gvr_buffer_viewport_get_transform().
-  Mat4f GetTransform() const {
-    return gvr_buffer_viewport_get_transform(viewport_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_set_transform().
-  void SetTransform(const Mat4f& transform) {
-    gvr_buffer_viewport_set_transform(viewport_, transform);
-  }
-
-  /// For more information, see gvr_buffer_viewport_get_source_uv().
-  Rectf GetSourceUv() const {
-    return gvr_buffer_viewport_get_source_uv(viewport_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_set_source_uv().
-  void SetSourceUv(const Rectf& uv) {
-    gvr_buffer_viewport_set_source_uv(viewport_, uv);
-  }
-
-  /// For more information, see gvr_buffer_viewport_get_target_eye().
-  Eye GetTargetEye() const {
-    return static_cast<Eye>(gvr_buffer_viewport_get_target_eye(viewport_));
-  }
-
-  /// For more information, see gvr_buffer_viewport_set_target_eye().
-  void SetTargetEye(Eye eye) {
-    gvr_buffer_viewport_set_target_eye(viewport_, eye);
-  }
-
-  /// For more information, see gvr_buffer_viewport_get_source_buffer_index().
-  int32_t GetSourceBufferIndex() const {
-    return gvr_buffer_viewport_get_source_buffer_index(viewport_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_set_source_buffer_index().
-  void SetSourceBufferIndex(int32_t buffer_index) {
-    gvr_buffer_viewport_set_source_buffer_index(viewport_, buffer_index);
-  }
-
-  /// For more information, see gvr_buffer_viewport_get_external_surface_id().
-  int32_t GetExternalSurfaceId() const {
-    return gvr_buffer_viewport_get_external_surface_id(viewport_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_set_external_surface_id().
-  void SetExternalSurfaceId(const int32_t external_surface_id) {
-    gvr_buffer_viewport_set_external_surface_id(viewport_, external_surface_id);
-  }
-
-  /// For more information, see gvr_buffer_viewport_get_reprojection().
-  gvr_reprojection GetReprojection() const {
-    return static_cast<gvr_reprojection>(
-        gvr_buffer_viewport_get_reprojection(viewport_));
-  }
-  /// For more information, see gvr_buffer_viewport_set_reprojection().
-  void SetReprojection(gvr_reprojection reprojection) {
-    gvr_buffer_viewport_set_reprojection(viewport_, reprojection);
-  }
-
-  /// For more information, see gvr_buffer_viewport_equal().
-  bool operator==(const BufferViewport& other) const {
-    return gvr_buffer_viewport_equal(viewport_, other.viewport_) ? true : false;
-  }
-  bool operator!=(const BufferViewport& other) const {
-    return !(*this == other);
-  }
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and takes ownership.
-  explicit BufferViewport(gvr_buffer_viewport* viewport)
-      : viewport_(viewport) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_buffer_viewport* cobj() { return viewport_; }
-  const gvr_buffer_viewport* cobj() const { return viewport_; }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_buffer_viewport* release() {
-    auto result = viewport_;
-    viewport_ = nullptr;
-    return result;
-  }
-  /// @}
-
- private:
-  friend class GvrApi;
-  friend class BufferViewportList;
-
-  explicit BufferViewport(gvr_context* gvr)
-      : viewport_(gvr_buffer_viewport_create(gvr)) {}
-
-  gvr_buffer_viewport* viewport_;
-};
-
-/// Convenience C++ wrapper for the opaque gvr_buffer_viewport_list type. This
-/// class will automatically release the wrapped gvr_buffer_viewport_list upon
-/// destruction. It can only be created via a `GvrApi` instance, and its
-/// validity is tied to the lifetime of that instance.
-class BufferViewportList {
- public:
-  BufferViewportList(BufferViewportList&& other)
-      : context_(nullptr), viewport_list_(nullptr) {
-    std::swap(context_, other.context_);
-    std::swap(viewport_list_, other.viewport_list_);
-  }
-
-  BufferViewportList& operator=(BufferViewportList&& other) {
-    std::swap(context_, other.context_);
-    std::swap(viewport_list_, other.viewport_list_);
-    return *this;
-  }
-
-  ~BufferViewportList() {
-    if (viewport_list_) {
-      gvr_buffer_viewport_list_destroy(&viewport_list_);
-    }
-  }
-
-  /// For more information, see gvr_get_recommended_buffer_viewports().
-  void SetToRecommendedBufferViewports() {
-    gvr_get_recommended_buffer_viewports(context_, viewport_list_);
-  }
-
-  /// For more information, see gvr_get_screen_buffer_viewports().
-  void SetToScreenBufferViewports() {
-    gvr_get_screen_buffer_viewports(context_, viewport_list_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_list_set_item().
-  void SetBufferViewport(size_t index, const BufferViewport& viewport) {
-    gvr_buffer_viewport_list_set_item(viewport_list_, index,
-                                      viewport.viewport_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_list_get_item().
-  void GetBufferViewport(size_t index, BufferViewport* viewport) const {
-    gvr_buffer_viewport_list_get_item(viewport_list_, index,
-                                      viewport->viewport_);
-  }
-
-  /// For more information, see gvr_buffer_viewport_list_get_size().
-  size_t GetSize() const {
-    return gvr_buffer_viewport_list_get_size(viewport_list_);
-  }
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and takes ownership.
-  BufferViewportList(gvr_buffer_viewport_list* viewport_list,
-                     gvr_context* context)
-      : context_(context),
-        viewport_list_(viewport_list) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_buffer_viewport_list* cobj() { return viewport_list_; }
-  const gvr_buffer_viewport_list* cobj() const { return viewport_list_; }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_buffer_viewport_list* release() {
-    auto result = viewport_list_;
-    viewport_list_ = nullptr;
-    return result;
-  }
-  /// @}
-
- private:
-  friend class Frame;
-  friend class GvrApi;
-  friend class SwapChain;
-
-  explicit BufferViewportList(gvr_context* context)
-      : context_(context),
-        viewport_list_(gvr_buffer_viewport_list_create(context)) {}
-
-  const gvr_context* context_;
-  gvr_buffer_viewport_list* viewport_list_;
-
-  // Disallow copy and assign.
-  BufferViewportList(const BufferViewportList&) = delete;
-  void operator=(const BufferViewportList&) = delete;
-};
-
-/// Convenience C++ wrapper for gvr_buffer_spec, an opaque pixel buffer
-/// specification. Frees the underlying gvr_buffer_spec on destruction.
-class BufferSpec {
- public:
-  BufferSpec(BufferSpec&& other)
-      : spec_(nullptr) {
-    std::swap(spec_, other.spec_);
-  }
-
-  BufferSpec& operator=(BufferSpec&& other) {
-    std::swap(spec_, other.spec_);
-    return *this;
-  }
-
-  ~BufferSpec() {
-    if (spec_) gvr_buffer_spec_destroy(&spec_);
-  }
-
-  /// Gets the buffer's size. The default value is the recommended render
-  /// target size. For more information, see gvr_buffer_spec_get_size().
-  Sizei GetSize() const {
-    return gvr_buffer_spec_get_size(spec_);
-  }
-
-  /// Sets the buffer's size. For more information, see
-  /// gvr_buffer_spec_set_size().
-  void SetSize(const Sizei& size) {
-    gvr_buffer_spec_set_size(spec_, size);
-  }
-
-  /// Sets the buffer's size to the passed width and height. For more
-  /// information, see gvr_buffer_spec_set_size().
-  ///
-  /// @param width The width in pixels. Must be greater than 0.
-  /// @param height The height in pixels. Must be greater than 0.
-  void SetSize(int32_t width, int32_t height) {
-    gvr_sizei size{width, height};
-    gvr_buffer_spec_set_size(spec_, size);
-  }
-
-  /// Gets the number of samples per pixel in the buffer. For more
-  /// information, see gvr_buffer_spec_get_samples().
-  int32_t GetSamples() const { return gvr_buffer_spec_get_samples(spec_); }
-
-  /// Sets the number of samples per pixel. For more information, see
-  /// gvr_buffer_spec_set_samples().
-  void SetSamples(int32_t num_samples) {
-    gvr_buffer_spec_set_samples(spec_, num_samples);
-  }
-
-  /// Sets the color format for this buffer. For more information, see
-  /// gvr_buffer_spec_set_color_format().
-  void SetColorFormat(ColorFormat color_format) {
-    gvr_buffer_spec_set_color_format(spec_, color_format);
-  }
-
-  /// Sets the depth and stencil format for this buffer. For more
-  /// information, see gvr_buffer_spec_set_depth_stencil_format().
-  void SetDepthStencilFormat(DepthStencilFormat depth_stencil_format) {
-    gvr_buffer_spec_set_depth_stencil_format(spec_, depth_stencil_format);
-  }
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and takes ownership.
-  explicit BufferSpec(gvr_buffer_spec* spec) : spec_(spec) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_buffer_spec* cobj() { return spec_; }
-  const gvr_buffer_spec* cobj() const { return spec_; }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_buffer_spec* release() {
-    auto result = spec_;
-    spec_ = nullptr;
-    return result;
-  }
-  /// @}
-
- private:
-  friend class GvrApi;
-  friend class SwapChain;
-
-  explicit BufferSpec(gvr_context* gvr) {
-    spec_ = gvr_buffer_spec_create(gvr);
-  }
-
-  gvr_buffer_spec* spec_;
-};
-
-/// Convenience C++ wrapper for gvr_frame, which represents a single frame
-/// acquired for rendering from the swap chain.
-class Frame {
- public:
-  Frame(Frame&& other) : frame_(nullptr) {
-    std::swap(frame_, other.frame_);
-  }
-
-  Frame& operator=(Frame&& other) {
-    std::swap(frame_, other.frame_);
-    return *this;
-  }
-
-  ~Frame() {
-    // The swap chain owns the frame, so no clean-up is required.
-  }
-
-  /// For more information, see gvr_frame_get_buffer_size().
-  Sizei GetBufferSize(int32_t index) const {
-    return gvr_frame_get_buffer_size(frame_, index);
-  }
-
-  /// For more information, see gvr_frame_bind_buffer().
-  void BindBuffer(int32_t index) {
-    gvr_frame_bind_buffer(frame_, index);
-  }
-
-  /// For more information, see gvr_frame_unbind().
-  void Unbind() {
-    gvr_frame_unbind(frame_);
-  }
-
-  /// For more information, see gvr_frame_get_framebuffer_object().
-  int32_t GetFramebufferObject(int32_t index) {
-    return gvr_frame_get_framebuffer_object(frame_, index);
-  }
-
-  /// For more information, see gvr_frame_submit().
-  void Submit(const BufferViewportList& viewport_list,
-              const Mat4f& head_space_from_start_space) {
-    gvr_frame_submit(&frame_, viewport_list.viewport_list_,
-                     head_space_from_start_space);
-  }
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and takes ownership.
-  explicit Frame(gvr_frame* frame) : frame_(frame) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_frame* cobj() { return frame_; }
-  const gvr_frame* cobj() const { return frame_; }
-
-  /// Returns whether the wrapped gvr_frame reference is valid.
-  bool is_valid() const { return frame_ != nullptr; }
-  explicit operator bool const() { return is_valid(); }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_frame* release() {
-    auto result = frame_;
-    frame_ = nullptr;
-    return result;
-  }
-  /// @}
-
- private:
-  friend class SwapChain;
-
-  gvr_frame* frame_;
-};
-
-/// Convenience C++ wrapper for gvr_swap_chain, which represents a queue of
-/// frames. The GvrApi object must outlive any SwapChain objects created from
-/// it.
-class SwapChain {
- public:
-  SwapChain(SwapChain&& other)
-      : swap_chain_(nullptr) {
-    std::swap(swap_chain_, other.swap_chain_);
-  }
-
-  SwapChain& operator=(SwapChain&& other) {
-    std::swap(swap_chain_, other.swap_chain_);
-    return *this;
-  }
-
-  ~SwapChain() {
-    if (swap_chain_) gvr_swap_chain_destroy(&swap_chain_);
-  }
-
-  /// For more information, see gvr_swap_chain_get_buffer_count().
-  int32_t GetBufferCount() const {
-    return gvr_swap_chain_get_buffer_count(swap_chain_);
-  }
-
-  /// For more information, see gvr_swap_chain_get_buffer_size().
-  Sizei GetBufferSize(int32_t index) const {
-    return gvr_swap_chain_get_buffer_size(swap_chain_, index);
-  }
-
-  /// For more information, see gvr_swap_chain_resize_buffer().
-  void ResizeBuffer(int32_t index, Sizei size) {
-    gvr_swap_chain_resize_buffer(swap_chain_, index, size);
-  }
-
-  /// For more information, see gvr_swap_chain_acquire_frame().
-  /// Note that if Frame acquisition fails, the returned Frame may not be valid.
-  /// The caller should inspect the returned Frame's validity before using,
-  /// and reschedule frame acquisition upon failure.
-  Frame AcquireFrame() {
-    Frame result(gvr_swap_chain_acquire_frame(swap_chain_));
-    return result;
-  }
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and takes ownership.
-  explicit SwapChain(gvr_swap_chain* swap_chain) : swap_chain_(swap_chain) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_swap_chain* cobj() { return swap_chain_; }
-  const gvr_swap_chain* cobj() const { return swap_chain_; }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_swap_chain* release() {
-    auto result = swap_chain_;
-    swap_chain_ = nullptr;
-    return result;
-  }
-  /// @}
-
- private:
-  friend class GvrApi;
-
-  SwapChain(gvr_context* gvr, const std::vector<BufferSpec>& specs) {
-    std::vector<const gvr_buffer_spec*> c_specs;
-    for (const auto& spec : specs)
-      c_specs.push_back(spec.spec_);
-    swap_chain_ = gvr_swap_chain_create(gvr, c_specs.data(),
-                                        static_cast<int32_t>(c_specs.size()));
-  }
-
-  gvr_swap_chain* swap_chain_;
-
-  // Disallow copy and assign.
-  SwapChain(const SwapChain&);
-  void operator=(const SwapChain&);
-};
-
-/// This is a convenience C++ wrapper for the Google VR C API.
-///
-/// This wrapper strategy prevents ABI compatibility issues between compilers
-/// by ensuring that the interface between client code and the implementation
-/// code in libgvr.so is a pure C interface. The translation from C++ calls
-/// to C calls provided by this wrapper runs entirely in the client's binary
-/// and is compiled by the client's compiler.
-///
-/// Methods in this class are only documented insofar as the C++ wrapping logic
-/// is concerned; for information about the method itself, please refer to the
-/// corresponding function in the C API.
-///
-/// Example API usage:
-///
-///     // Functionality supplied by the application in the example below has
-///     // the "app-" prefix.
-///     #ifdef __ANDROID__
-///     // On Android, the gvr_context should almost always be obtained from the
-///     // Java GvrLayout object via
-///     // GvrLayout.getGvrApi().getNativeGvrContext().
-///     std::unique_ptr<GvrApi> gvr = GvrApi::WrapNonOwned(gvr_context);
-///     #else
-///     std::unique_ptr<GvrApi> gvr = GvrApi::Create();
-///     #endif
-///
-///     gvr->InitializeGl();
-///
-///     gvr::BufferViewportList viewport_list =
-///         gvr->CreateEmptyBufferViewportList();
-///     gvr->GetRecommendedBufferViewports(&viewport_list);
-///     gvr::BufferViewport left_eye_viewport = gvr->CreateBufferViewport();
-///     gvr::BufferViewport right_eye_viewport = gvr->CreateBufferViewport();
-///     viewport_list.Get(0, &left_eye_view);
-///     viewport_list.Get(1, &right_eye_view);
-///
-///     std::vector<gvr::BufferSpec> specs;
-///     specs.push_back(gvr->CreateBufferSpec());
-///     specs[0].SetSamples(app_samples);
-///     gvr::SwapChain swap_chain = gvr->CreateSwapChain(specs);
-///
-///     while (client_app_should_render) {
-///       // A client app should be ready for the render target size to change
-///       // whenever a new QR code is scanned, or a new viewer is paired.
-///       gvr::Sizei render_target_size =
-///           gvr->GetRecommendedRenderTargetSize();
-///       swap_chain.ResizeBuffer(0, render_target_size);
-///       gvr::Frame frame = swap_chain.AcquireFrame();
-///       while (!frame) {
-///         std::this_thread::sleep_for(2ms);
-///         frame = swap_chain.AcquireFrame();
-///       }
-///
-///       // This function will depend on your render loop's implementation.
-///       gvr::ClockTimePoint next_vsync = AppGetNextVsyncTime();
-///
-///       const gvr::Mat4f head_view =
-///           gvr->GetHeadSpaceFromStartSpaceRotation(next_vsync);
-///       const gvr::Mat4f left_eye_view = MatrixMultiply(
-///           gvr->GetEyeFromHeadMatrix(kLeftEye), head_view);
-///       const gvr::Mat4f right_eye_view = MatrixMultiply(
-///           gvr->GetEyeFromHeadMatrix(kRightEye), head_view);
-///
-///       frame.BindBuffer(0);
-///       // App does its rendering to the current framebuffer here.
-///       AppDoSomeRenderingForEye(
-///           left_eye_viewport.GetSourceUv(), left_eye_view);
-///       AppDoSomeRenderingForEye(
-///           right_eye_viewport.GetSourceUv(), right_eye_view);
-///       frame.Unbind();
-///       frame.Submit(viewport_list, head_matrix);
-///     }
-///
-class GvrApi {
- public:
-#ifdef __ANDROID__
-  /// Instantiates and returns a GvrApi instance that owns a gvr_context.
-  ///
-  /// @param env The JNIEnv associated with the current thread.
-  /// @param app_context The Android application context. This must be the
-  ///     application context, NOT an Activity context (Note: from any Android
-  ///     Activity in your app, you can call getApplicationContext() to
-  ///     retrieve the application context).
-  /// @param class_loader The class loader to use when loading Java classes.
-  ///     This must be your app's main class loader (usually accessible through
-  ///     activity.getClassLoader() on any of your Activities).
-  /// @return unique_ptr to the created GvrApi instance, nullptr on failure.
-  static std::unique_ptr<GvrApi> Create(JNIEnv* env, jobject app_context,
-                                        jobject class_loader) {
-    gvr_context* context = gvr_create(env, app_context, class_loader);
-    if (!context) {
-      return nullptr;
-    }
-    return std::unique_ptr<GvrApi>(new GvrApi(context, true /* owned */));
-  }
-#else
-  /// Instantiates and returns a GvrApi instance that owns a gvr_context.
-  ///
-  /// @return unique_ptr to the created GvrApi instance, nullptr on failure.
-  static std::unique_ptr<GvrApi> Create() {
-    gvr_context* context = gvr_create();
-    if (!context) {
-      return nullptr;
-    }
-    return std::unique_ptr<GvrApi>(new GvrApi(context, true /* owned */));
-  }
-#endif  // #ifdef __ANDROID__
-
-  ~GvrApi() {
-    if (context_ && owned_) {
-      gvr_destroy(&context_);
-    }
-  }
-
-  /// @name Error handling
-  /// @{
-
-  /// For more information, see gvr_get_error().
-  Error GetError() { return static_cast<Error>(gvr_get_error(context_)); }
-
-  /// For more information, see gvr_clear_error().
-  Error ClearError() { return static_cast<Error>(gvr_clear_error(context_)); }
-
-  /// For more information, see gvr_get_error_string().
-  static const char* GetErrorString(Error error_code) {
-    return gvr_get_error_string(error_code);
-  }
-
-  /// For more information, see gvr_get_user_prefs().
-  UserPrefs GetUserPrefs() { return UserPrefs(gvr_get_user_prefs(context_)); }
-
-  /// @}
-
-  /// @name Rendering
-  /// @{
-
-  /// For more information, see gvr_initialize_gl().
-  void InitializeGl() { gvr_initialize_gl(context_); }
-
-  /// For more information, see gvr_get_async_reprojection_enabled().
-  bool GetAsyncReprojectionEnabled() const {
-    return gvr_get_async_reprojection_enabled(context_);
-  }
-
-  /// Constructs a C++ wrapper for a gvr_buffer_viewport object.  For more
-  /// information, see gvr_buffer_viewport_create().
-  ///
-  /// @return A new BufferViewport instance with memory allocated for an
-  ///     underlying gvr_buffer_viewport.
-  BufferViewport CreateBufferViewport() const {
-    return BufferViewport(context_);
-  }
-
-  /// Constructs a C++ wrapper for a gvr_buffer_viewport_list object.
-  /// For more information, see gvr_buffer_viewport_list_create().
-  ///
-  /// @return A new, empty BufferViewportList instance.
-  ///     Note: The validity of the returned object is closely tied to the
-  ///     lifetime of the member gvr_context. The caller is responsible for
-  ///     ensuring correct usage accordingly.
-  BufferViewportList CreateEmptyBufferViewportList() const {
-    return BufferViewportList(context_);
-  }
-
-  /// For more information, see gvr_get_maximum_effective_render_target_size().
-  Sizei GetMaximumEffectiveRenderTargetSize() const {
-    return gvr_get_maximum_effective_render_target_size(context_);
-  }
-
-  /// For more information, see gvr_get_screen_target_size().
-  Sizei GetScreenTargetSize() const {
-    return gvr_get_screen_target_size(context_);
-  }
-
-  /// For more information, see gvr_set_surface_size().
-  void SetSurfaceSize(Sizei surface_size_pixels) {
-    gvr_set_surface_size(context_, surface_size_pixels);
-  }
-
-  /// For more information, see gvr_distort_to_screen().
-  void DistortToScreen(int32_t texture_id,
-                       const BufferViewportList& viewport_list,
-                       const Mat4f& rendered_head_pose_in_start_space_matrix,
-                       const ClockTimePoint& texture_presentation_time) {
-    gvr_distort_to_screen(context_, texture_id, viewport_list.viewport_list_,
-                          rendered_head_pose_in_start_space_matrix,
-                          texture_presentation_time);
-  }
-
-  /// For more information, see gvr_is_feature_supported().
-  bool IsFeatureSupported(int32_t feature) {
-    return gvr_is_feature_supported(context_, feature);
-  }
-
-  /// For more information, see gvr_buffer_spec_create().
-  BufferSpec CreateBufferSpec() {
-    return BufferSpec(context_);
-  }
-
-  /// For more information, see gvr_swap_chain_create().
-  SwapChain CreateSwapChain(const std::vector<BufferSpec>& specs) {
-    return SwapChain(context_, specs);
-  }
-
-  /// For more information, see gvr_bind_default_framebuffer().
-  void BindDefaultFramebuffer() {
-    gvr_bind_default_framebuffer(context_);
-  }
-  /// @}
-
-  /// @name Head tracking
-  /// @{
-
-  /// For more information see gvr_get_head_space_from_start_space_rotation.
-  ///
-  /// @param time_point The time at which to calculate the head pose in start
-  ///     space.
-  /// @return The matrix representation of the rotation from start space
-  ///     (the space with the head pose at the last tracking reset at origin) to
-  ///     head space (the space with the head at origin and axes aligned to the
-  ///     view vector).
-  Mat4f GetHeadSpaceFromStartSpaceRotation(const ClockTimePoint& time_point) {
-    return gvr_get_head_space_from_start_space_rotation(context_, time_point);
-  }
-
-  /// For more information, see gvr_apply_neck_model().
-  Mat4f ApplyNeckModel(const Mat4f& head_pose_in_start_space, float factor) {
-    return gvr_apply_neck_model(context_, head_pose_in_start_space, factor);
-  }
-
-  /// For more information, see gvr_pause_tracking().
-  void PauseTracking() { gvr_pause_tracking(context_); }
-
-  /// For more information, see gvr_resume_tracking().
-  void ResumeTracking() { gvr_resume_tracking(context_); }
-
-  /// For more information, see gvr_reset_tracking().
-  void ResetTracking() { gvr_reset_tracking(context_); }
-
-  // For more information, see gvr_recenter_tracking().
-  void RecenterTracking() { gvr_recenter_tracking(context_); }
-
-  /// For more information, see gvr_get_time_point_now().
-  static ClockTimePoint GetTimePointNow() { return gvr_get_time_point_now(); }
-  /// @}
-
-  /// @name Viewer parameters
-  /// @{
-
-  /// For more information, see gvr_set_default_viewer_profile().
-  bool SetDefaultViewerProfile(const char* viewer_profile_uri) {
-    return gvr_set_default_viewer_profile(context_, viewer_profile_uri);
-  }
-
-  /// For more information, see gvr_refresh_viewer_profile().
-  void RefreshViewerProfile() { gvr_refresh_viewer_profile(context_); }
-
-  /// For more information, see gvr_get_viewer_vendor().
-  const char* GetViewerVendor() const {
-    return gvr_get_viewer_vendor(context_);
-  }
-
-  /// For more information, see gvr_get_viewer_model().
-  const char* GetViewerModel() const { return gvr_get_viewer_model(context_); }
-
-  /// For more information, see gvr_get_viewer_type().
-  ViewerType GetViewerType() const {
-    return static_cast<ViewerType>(gvr_get_viewer_type(context_));
-  }
-
-  /// For more information, see gvr_get_eye_from_head_matrix().
-  Mat4f GetEyeFromHeadMatrix(Eye eye) const {
-    return gvr_get_eye_from_head_matrix(context_, eye);
-  }
-
-  /// For more information, see gvr_get_window_bounds().
-  Recti GetWindowBounds() const { return gvr_get_window_bounds(context_); }
-
-  /// For more information, see gvr_compute_distorted_point().
-  std::array<Vec2f, 3> ComputeDistortedPoint(Eye eye, const Vec2f& uv_in) {
-    std::array<Vec2f, 3> uv_out = {{{}}};
-    gvr_compute_distorted_point(context_, eye, uv_in, uv_out.data());
-    return uv_out;
-  }
-  /// @}
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and optionally takes ownership.
-  ///
-  /// @param context C object to wrap.
-  /// @param owned Whether the wrapper will own the underlying C object.
-  explicit GvrApi(gvr_context* context, bool owned = true)
-      : context_(context), owned_(owned) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_context* cobj() { return context_; }
-  const gvr_context* cobj() const { return context_; }
-
-  /// @deprecated Use cobj() instead.
-  gvr_context* GetContext() { return context_; }
-  /// @deprecated Use cobj() instead.
-  const gvr_context* GetContext() const { return context_; }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_context* release() {
-    auto result = context_;
-    context_ = nullptr;
-    return result;
-  }
-
-  /// Instantiates a GvrApi instance that wraps a *non-owned* gvr_context.
-  ///
-  /// Ownership of the provided `context` remains with the caller, and they
-  /// are responsible for ensuring proper disposal of the context.
-  ///
-  /// @param context Pointer to a non-null, non-owned gvr_context instance.
-  /// @return unique_ptr to the created GvrApi instance. Never null.
-  static std::unique_ptr<GvrApi> WrapNonOwned(gvr_context* context) {
-    return std::unique_ptr<GvrApi>(new GvrApi(context, false /* owned */));
-  }
-  /// @}
-
- private:
-  gvr_context* context_;
-
-  // Whether context_ is owned by the GvrApi instance. If owned, the context
-  // will be released upon destruction.
-  const bool owned_;
-
-  // Disallow copy and assign.
-  GvrApi(const GvrApi&);
-  void operator=(const GvrApi&);
-};
-
-}  // namespace gvr
-#endif  // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif  // VR_GVR_CAPI_INCLUDE_GVR_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_audio.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_audio.h
deleted file mode 100644
index d34c84d..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_audio.h
+++ /dev/null
@@ -1,852 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_AUDIO_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_AUDIO_H_
-
-#if __ANDROID__
-#include <jni.h>
-#endif  // __ANDROID__
-
-#include <stdint.h>
-
-#include "vr/gvr/capi/include/gvr.h"
-#include "vr/gvr/capi/include/gvr_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif  // __cplusplus
-
-/// @defgroup Audio Spatial Audio API
-/// @brief This is the GVR Audio C API, a spatial audio rendering engine,
-/// optimized for mobile VR.
-///
-/// It allows the user to spatialize sound sources in 3D space, including
-/// distance and elevation cues. Specifically, the API is capable of playing
-/// back spatial sound in three ways:
-///
-/// - **Sound object rendering**: This allows the user to create a virtual sound
-///   source in 3D space. These sources, while spatialized, are fed with mono
-///   audio data.
-///
-/// - **Ambisonic soundfields**: Ambisonic recordings are multi-channel audio
-///   files which are spatialized all around the listener in 360 degrees. These
-///   can be thought of as recorded or pre-baked soundfields. They can be of
-///   great use for background effects which sound perfectly spatial.  Examples
-///   include rain noise, crowd noise or even the sound of the ocean off to one
-///   side.
-///
-/// - **Stereo Sounds**: This allows the user to directly play back
-///   non-spatialized mono or stereo audio files. This is useful for music and
-///   other such audio.
-///
-/// **Initialization**
-///
-///     gvr_audio_context* gvr_audio_create(int32_t rendering_mode);
-///
-/// The rendering_mode argument corresponds to a `gvr_audio_rendering_mode` enum
-/// value, which specifies a rendering configuration setting:
-///
-/// - `GVR_AUDIO_RENDERING_STEREO_PANNING`:
-///   Stereo panning of all sound objects. This disables HRTF-based rendering.
-/// - `GVR_AUDIO_RENDERING_BINAURAL_LOW_QUALITY`:
-///   This renders sound objects over a virtual array of 8 loudspeakers arranged
-///   in a cube configuration around the listener’s head. HRTF-based rendering
-///   is enabled.
-/// - `GVR_AUDIO_RENDERING_BINAURAL_HIGH_QUALITY`:
-///   This renders sound objects over a virtual array of 16 loudspeakers
-///   arranged in an approximate equidistribution about the listener’s
-///   head. HRTF-based rendering is enabled.
-///
-/// For most modern phones, the high quality mode offers a good balance between
-/// performance and audio quality. To optimize the rendering performance for
-/// headphones *and* speaker playback, the stereo speaker mode can be enabled
-/// which automatically switches to stereo panning when no headphone is plugin.
-/// Note that this can lead to varying CPU usage based on headphone and speaker
-/// playback.
-///
-/// **Sound engine control**
-///
-/// Audio playback on the default audio device can be started and stopped by
-/// calling the following two methods:
-///
-///     void gvr_audio_pause(gvr_audio_context* api);
-///     void gvr_audio_resume(gvr_audio_context* api);
-///
-/// Note that:
-///
-///     void gvr_audio_update(gvr_audio_context* api);
-///
-/// must be called from the main thread at a regular rate. It is used to execute
-/// background operations outside of the audio thread.
-///
-/// **Listener position and rotation**
-///
-/// To ensure that the audio in your application reacts to listener head
-/// movement, it is important to update the listener's head orientation in the
-/// graphics callback using the head orientation matrix.
-///
-/// The following methods can be used to control the listener’s head position
-/// and orientation with the audio engine:
-///
-///     void gvr_audio_set_head_position(gvr_audio_context* api, float x,
-///                                      float y, float z);
-/// or
-///
-///     void gvr_audio_set_head_position_gvr(gvr_audio_context* api,
-///                                          const gvr_vec3f& position);
-///
-/// and
-///
-///     void gvr_audio_set_head_rotation(gvr_audio_context* api,
-///                                      float x, float y, float z, float w);
-/// or
-///
-///     void gvr_audio_set_head_rotation_gvr(gvr_audio_context* api,
-///                                          const gvr_quatf& rotation);
-///
-/// **Preloading Sounds**
-///
-/// Both mono sound files for use with Sound Objects and multi-channel Ambisonic
-/// soundfield files can be preloaded into memory before playback or
-/// alternatively streamed during playback. Preloading can be useful to reduce
-/// CPU usage especially if the same audio clip is likely to be played back many
-/// times. In this case playback latency is also reduced.
-///
-/// Sound files can be preloaded into memory by calling:
-///
-///     bool gvr_audio_preload_soundfile(gvr_audio_context* api,
-///                                      const char* filename);
-///
-/// Unused sound files can be unloaded with a call to:
-///
-///     void gvr_audio_unload_soundfile(gvr_audio_context* api,
-///                                     const char* filename);
-///
-/// NOTE: If a sound object, soundfield or stereo sound is created with a file
-/// that has not been preloaded, that audio will be streamed.
-///
-/// **Spatializtion of sound objects**
-///
-/// The GVR Audio System allows the user to create virtual sound objects which
-/// can be placed anywhere in space around the listener.
-///
-/// To create a new sound object, call:
-///
-///     gvr_audio_source_id
-///     gvr_audio_create_sound_object(gvr_audio_context* api,
-///                                   const char* filename);
-///
-/// This returns a handle that can be used to set properties such as the
-/// position and the volume of the sound object via calls to the following two
-/// functions:
-///
-///     void
-///     gvr_audio_set_sound_object_position(gvr_audio_context* api,
-///                                         gvr_audio_source_id sound_object_id,
-///                                         float x, float y, float z);
-///
-///     void
-///     gvr_audio_set_sound_volume(gvr_audio_context* api,
-///                                gvr_audio_source_id source_id, float volume);
-///
-/// The behavior of Sound Objects with respect to their distance from the
-/// listener can be controlled via calls to the following method:
-///
-///     void gvr_audio_set_sound_object_distance_rolloff_model(
-///         gvr_audio_context* api, gvr_audio_source_id sound_object_id,
-///         int32_t rolloff_model, float min_distance, float max_distance);
-///
-/// This enables a user to choose between logarithmic and linear distance
-/// rolloff methods, or to completely disable distance rolloff effects.
-///
-///
-/// The spatialized playback of a sound object can be triggered with a call to:
-///
-///     void gvr_audio_play_sound(gvr_audio_context* api,
-///                               gvr_audio_source_id source_id,
-///                               bool looping_enabled);
-///
-/// and stopped with a call to:
-///
-///     void gvr_audio_stop_sound(gvr_audio_context* api,
-///                               gvr_audio_source_id source_id);
-///
-/// Note that the sound object handle destroys itself at the moment the sound
-/// playback has stopped. This way, no clean up of sound object handles is
-/// needed. On subsequent calls to this function the corresponding
-/// gvr_audio_source_id no longer refers to a valid sound object.
-///
-/// The following function can be used to check if a sound object is currently
-/// active:
-///
-///     bool gvr_audio_is_sound_playing(const gvr_audio_context* api,
-///                                     gvr_audio_source_id source_id);
-///
-/// **Rendering of ambisonic soundfields**
-///
-/// The GVR Audio System also provides the user with the ability to play back
-/// ambisonic soundfields. Ambisonic soundfields are captured or pre-rendered
-/// 360 degree recordings. It is best to think of them as equivalent to 360
-/// degree video. While they envelop and surround the listener, they only react
-/// to the listener's rotational movement. That is, one cannot walk towards
-/// features in the soundfield. Soundfields are ideal for accompanying 360
-/// degree video playback, for introducing background and environmental effects
-/// such as rain or crowd noise, or even for pre baking 3D audio to reduce
-/// rendering costs.  The GVR Audio System supports full 3D First Order
-/// Ambisonic recordings using ACN channel ordering and SN3D normalization. For
-/// more information please see our Spatial Audio specification at:
-/// https://github.com/google/spatial-media/blob/master/docs/spatial-audio-rfc.md#semantics
-///
-/// Note that Soundfield playback is directly streamed from the sound file and
-/// no sound file preloading is needed.
-///
-/// To obtain a soundfield handler, call:
-///
-///     gvr_audio_source_id gvr_audio_create_soundfield(gvr_audio_context* api,
-///                                                    const char* filename);
-///
-/// This returns a gvr_audio_source_id handle that allows the user to begin
-/// playback of the soundfield, to alter the soundfield’s volume or to stop
-/// soundfield playback and as such destroy the object. These actions can be
-/// achieved with calls to the following functions:
-///
-///     void gvr_audio_play_sound(gvr_audio_context* api,
-///                               gvr_audio_source_id source_id,
-///                               bool looping_enabled);
-///
-///     void gvr_audio_set_sound_volume(gvr_audio_context* api,
-///                                     gvr_audio_source_id source_id,
-///                                     float volume);
-///
-///     void gvr_audio_stop_sound(gvr_audio_context* api,
-///                               gvr_audio_source_id source_id);
-///
-/// Ambisonic soundfields can also be rotated about the listener's head in order
-/// to align the components of the soundfield with the visuals of the game/app.
-///
-/// void gvr_audio_set_soundfield_rotation(gvr_audio_context* api,
-///                                        gvr_audio_source_id soundfield_id,
-///                                        const gvr_quatf&
-///                                        soundfield_rotation);
-///
-/// **Direct Playback of Stereo or Mono Sounds**
-///
-/// The GVR Audio System allows the direct non-spatialized playback of both
-/// stereo and mono audio. Such audio is often used for music or sound effects
-/// that should not be spatialized.
-///
-/// A stereo sound can be created with a call to:
-///
-/// gvr_audio_source_id gvr_audio_create_stereo_sound(gvr_audio_context* api,
-///                                                  const char* filename);
-///
-/// **Paused Sounds and Stopped Sounds**
-///
-/// When using sound sources of any of the above types, the user can ensure that
-/// the given source is currently playing before calling.
-///
-/// bool gvr_audio_is_sound_playing(gvr_audio_source_id source_id);
-///
-/// This method will return false if the source has been either paused or
-/// stopped, and true if the source is currently playing.
-///
-/// Once one is finished with a Sound Object and wish to remove it, a call can
-/// be placed to:
-///
-/// void gvr_audio_stop_sound(gvr_audio_source_id source_id);
-///
-/// Once a source has been stopped it is destroyed and the corresponding
-/// gvr_audio_source_id will be invalid. Sources which have been played with the
-/// |looping_enabled| parameter disabled will also be destroyed once playback
-/// of the full audio clip has completed.
-///
-/// To check whether a given gvr_audio_source_id corresponds to a valid source
-/// which exists and is in a playable state, a call can be made to:
-///
-/// bool gvr_audio_is_source_id_valid(gvr_audio_source_id source_id);
-///
-/// By using this pair of methods a user can differentiate between sources which
-/// have been paused and those which have ceased.
-///
-/// **Room effects**
-///
-/// The GVR Audio System provides a powerful reverb engine which can be used to
-/// create customized room effects by specifying the size of a room and a
-/// material for each surface of the room from the gvr_audio_material_name enum.
-/// Each of these surface materials has unique absorption properties which
-/// differ with frequency. The room created will be centered around the
-/// listener. Note that the Google VR Audio System uses meters as the unit of
-/// distance throughout.
-///
-/// The following methods are used to control room effects:
-///
-///     void gvr_audio_enable_room(gvr_audio_context* api, bool enable);
-///
-/// enables or disables room effects with smooth transitions.
-///
-/// and
-///
-///     void
-///     gvr_audio_set_room_properties(gvr_audio_context* api, float size_x,
-///                                   float size_y, float size_z,
-///                                   gvr_audio_material_name wall_material,
-///                                   gvr_audio_material_name ceiling_material,
-///                                   gvr_audio_material_name floor_material);
-///
-/// allows the user to describe the room based on its dimensions and its surface
-/// properties. For example, one can expect very large rooms to be more
-/// reverberant than smaller rooms, and a room with with hard surface materials
-/// such as brick to be more reverberant than one with soft absorbent materials
-/// such as heavy curtains on every surface.
-///
-/// Note that when a sound source is located outside of the listener's room,
-/// it will sound different from sources located within the room due to
-/// attenuation of both the direct sound and the reverb on that source. Sources
-/// located far outside of the listener's room will not be audible to the
-/// listener.
-///
-/// The following method can be used to subtly adjust the reverb in a room by
-/// changing the gain/attenuation on the reverb, setting a multiplier on the
-/// reverberation time to control the reverb's length, or adjusting the balance
-/// between the low and high frequency components of the reverb.
-///
-/// void gvr_audio_set_room_reverb_adjustments(gvr_audio_context* api,
-///                                            float gain,
-///                                            float time_adjust,
-///                                            float brightness_adjust);
-///
-/// If you are writing C++ code, you might prefer to use the C++ wrapper
-/// rather than implement this C API directly.
-///
-/// **Example usage (C++ API)**
-///
-/// Construction:
-///
-///     std::unique_ptr<gvr::AudioApi> gvr_audio_api(new gvr::AudioApi);
-///     gvr_audio_api->Init(GVR_AUDIO_RENDERING_BINAURAL_HIGH_QUALITY);
-///
-/// Update head rotation in DrawFrame():
-///
-///     head_pose_ = gvr_api_->GetHeadSpaceFromStartSpaceRotation(target_time);
-///     gvr_audio_api_->SetHeadPose(head_pose_);
-///     gvr_audio_api_->Update();
-///
-/// Preload sound file, create sound handle and start playback:
-///
-///     gvr_audio_api->PreloadSoundfile(kSoundFile);
-///     AudioSourceId source_id =
-///                   gvr_audio_api_->CreateSoundObject("sound.wav");
-///     gvr_audio_api->SetSoundObjectPosition(source_id,
-///                                           position_x,
-///                                           position_y,
-///                                           position_z);
-///     gvr_audio_api->PlaySound(source_id, true /* looped playback */);
-///
-
-/// @{
-
-typedef struct gvr_audio_context_ gvr_audio_context;
-
-/// Creates and initializes a gvr_audio_context. This call also initializes
-/// the audio interface and starts the audio engine. Note that the returned
-/// instance must be deleted with gvr_audio_destroy.
-///
-#ifdef __ANDROID__
-/// @param env The JNI Env associated with the current thread.
-/// @param android_context The Android application context. This must be the
-///     application context, NOT an Activity context (Note: from any Android
-///     Activity in your app, you can call getApplicationContext() to
-///     retrieve the application context).
-/// @param class_loader The class loader to use when loading Java
-///     classes. This must be your app's main class loader (usually
-///     accessible through activity.getClassLoader() on any of your Activities).
-/// @param rendering_mode The gvr_audio_rendering_mode value which determines
-///     the rendering configuration preset. This is passed as an int32_t to
-///     ensure API compatibility.
-/// @return gvr_audio_context instance.
-gvr_audio_context* gvr_audio_create(JNIEnv* env, jobject android_context,
-                                    jobject class_loader,
-                                    int32_t rendering_mode);
-#else
-/// @param rendering_mode The gvr_audio_rendering_mode value which determines
-///     the rendering configuration preset. This is passed as an int32_t to
-///     ensure API compatibility.
-/// @return gvr_audio_context instance.
-gvr_audio_context* gvr_audio_create(int32_t rendering_mode);
-#endif  // #ifdef __ANDROID__
-
-/// Destroys a gvr_audio_context that was previously created with
-/// gvr_audio_create or gvr_audio_create_android.
-///
-/// @param api Pointer to a pointer to a gvr_audio_context. The pointer
-///     will be set to NULL after destruction.
-void gvr_audio_destroy(gvr_audio_context** api);
-
-/// Resumes the VR Audio system.
-/// Call this when your app/game loses focus.
-/// Calling this when not paused is a no-op.
-/// Thread-safe (call from any thread).
-///
-/// @param api Pointer to a gvr_audio_context.
-void gvr_audio_resume(gvr_audio_context* api);
-
-/// Pauses the VR Audio system.
-/// Calling this when already paused is a no-op.
-/// Thread-safe (call from any thread).
-///
-/// @param api Pointer to a gvr_audio_context.
-void gvr_audio_pause(gvr_audio_context* api);
-
-/// This method must be called from the main thread at a regular rate. It is
-/// used to execute background operations outside of the audio thread.
-///
-/// @param api Pointer to a gvr_audio_context.
-void gvr_audio_update(gvr_audio_context* api);
-
-/// Preloads a local sound file. Note that the local file access method
-/// depends on the target platform.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename Name of the file, used as identifier.
-/// @return True on success or if file has already been preloaded.
-bool gvr_audio_preload_soundfile(gvr_audio_context* api, const char* filename);
-
-/// Unloads a previously preloaded sample from memory. Note that if the sample
-/// is currently used, the memory is freed at the moment playback stops.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename Name of the file, used as identifier.
-void gvr_audio_unload_soundfile(gvr_audio_context* api, const char* filename);
-
-/// Returns a new sound object. Note that the sample should only contain a
-/// single audio channel (stereo sources are automatically downmixed to mono).
-/// The handle automatically destroys itself at the moment the sound playback
-/// has stopped.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename The path/name of the file to be played.
-/// @return Id of new sound object. Returns kInvalidId if the sound file has not
-///     been preloaded or if the number of input channels is > 1.
-gvr_audio_source_id gvr_audio_create_sound_object(gvr_audio_context* api,
-                                                  const char* filename);
-
-/// Returns a new ambisonic sound field. Note that the sample needs to be
-/// preloaded and must have 4 separate audio channels. The handle automatically
-/// destroys itself at the moment the sound playback has stopped.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename The path/name of the file to be played.
-/// @return Id of new soundfield. Returns kInvalidId if the sound file has not
-///     been preloaded or if the number of input channels does not match that
-///     required.
-gvr_audio_source_id gvr_audio_create_soundfield(gvr_audio_context* api,
-                                                const char* filename);
-
-/// Returns a new stereo non-spatialized source, which directly plays back mono
-/// or stereo audio. Note the sample needs to be preloaded and may contain only
-/// one (mono) or two (stereo) audio channels.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param filename The path/name of the file to be played..
-/// @return Id of new stereo non-spatialized source. Returns kInvalidId if the
-///     sound file has not been preloaded or if the number of input channels is
-///     > 2;
-gvr_audio_source_id gvr_audio_create_stereo_sound(gvr_audio_context* api,
-                                                  const char* filename);
-
-/// Starts the playback of a sound.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be stopped.
-/// @param looping_enabled Enables looped audio playback.
-void gvr_audio_play_sound(gvr_audio_context* api, gvr_audio_source_id source_id,
-                          bool looping_enabled);
-
-/// Pauses the playback of a sound.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be paused.
-void gvr_audio_pause_sound(gvr_audio_context* api,
-                           gvr_audio_source_id source_id);
-
-/// Resumes the playback of a sound.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be resumed.
-void gvr_audio_resume_sound(gvr_audio_context* api,
-                            gvr_audio_source_id source_id);
-
-/// Stops the playback of a sound and destroys the corresponding sound object
-/// or Soundfield.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be stopped.
-void gvr_audio_stop_sound(gvr_audio_context* api,
-                          gvr_audio_source_id source_id);
-
-/// Checks if a sound is playing.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be checked.
-/// @return True if the sound is being played.
-bool gvr_audio_is_sound_playing(const gvr_audio_context* api,
-                                gvr_audio_source_id source_id);
-
-/// Checks if a |source_id| is valid, and that the corresponding source is in a
-/// playable state. Sources that have been stopped will be reported as invalid.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be checked.
-/// @return True if the source exists and is in a playable state.
-bool gvr_audio_is_source_id_valid(const gvr_audio_context* api,
-                                  gvr_audio_source_id source_id);
-
-/// Repositions an existing sound object.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param sound_object_id Id of the sound object to be moved.
-/// @param x X coordinate the sound will be placed at.
-/// @param y Y coordinate the sound will be placed at.
-/// @param z Z coordinate the sound will be placed at.
-void gvr_audio_set_sound_object_position(gvr_audio_context* api,
-                                         gvr_audio_source_id sound_object_id,
-                                         float x, float y, float z);
-
-/// Sets the given ambisonic soundfields's rotation.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param soundfield_id Id of the soundfield source to be rotated.
-/// @param soundfield_rotation Quaternion representing the soundfield rotation.
-void gvr_audio_set_soundfield_rotation(gvr_audio_context* api,
-                                       gvr_audio_source_id soundfield_id,
-                                       const gvr_quatf& soundfield_rotation);
-
-/// Sets the given sound object source's distance attenuation method with
-/// minimum and maximum distances. Maximum distance must be greater than the
-/// minimum distance for the method to be set.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param sound_object_id Id of sound object source.
-/// @param rolloff_model Linear or logarithmic distance rolloff models. Note
-///     setting the rolloff model to |GVR_AUDIO_ROLLOFF_NONE| will allow
-///     distance attenuation values to be set manually.
-/// @param min_distance Minimum distance to apply distance attenuation method.
-/// @param max_distance Maximum distance to apply distance attenuation method.
-void gvr_audio_set_sound_object_distance_rolloff_model(
-    gvr_audio_context* api, gvr_audio_source_id sound_object_id,
-    int32_t rolloff_model, float min_distance, float max_distance);
-
-/// Changes the master volume.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param volume Volume value. Should range from 0 (mute) to 1 (max).
-void gvr_audio_set_master_volume(gvr_audio_context* api, float volume);
-
-/// Changes the volume of an existing sound.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param source_id Id of the audio source to be modified.
-/// @param volume Volume value. Should range from 0 (mute) to 1 (max).
-void gvr_audio_set_sound_volume(gvr_audio_context* api,
-                                gvr_audio_source_id source_id, float volume);
-
-/// Sets the head pose from a matrix representation of the same.
-///
-/// @param api Pointer to a gvr_audio_context on which to set the pose.
-/// @param head_pose_matrix Matrix representing the head transform to be set.
-void gvr_audio_set_head_pose(gvr_audio_context* api,
-                             const gvr_mat4f& head_pose_matrix);
-
-/// Turns on/off the room reverberation effect.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param enable True to enable room effect.
-void gvr_audio_enable_room(gvr_audio_context* api, bool enable);
-
-/// Sets the room properties describing the dimensions and surface materials of
-/// a given room.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param size_x Dimension along X axis.
-/// @param size_y Dimension along Y axis.
-/// @param size_z Dimension along Z axis.
-/// @param wall_material Surface gvr_audio_material_type for the four walls.
-/// @param ceiling_material Surface gvr_audio_material_type for the ceiling.
-/// @param floor_material Surface gvr_audio_material_type for the floor.
-void gvr_audio_set_room_properties(gvr_audio_context* api, float size_x,
-                                   float size_y, float size_z,
-                                   int32_t wall_material,
-                                   int32_t ceiling_material,
-                                   int32_t floor_material);
-
-/// Adjusts the properties of the current reverb, allowing changes to the
-/// reverb's gain, duration and low/high frequency balance.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param gain Reverb volume (linear) adjustment in range [0, 1] for
-///     attenuation, range [1, inf) for gain boost.
-/// @param time_adjust Reverb time adjustment multiplier to scale the
-///     reverberation tail length. This value should be >= 0.
-/// @param brightness_adjust Reverb brightness adjustment that controls the
-///     reverberation ratio across low and high frequency bands.
-void gvr_audio_set_room_reverb_adjustments(gvr_audio_context* api, float gain,
-                                           float time_adjust,
-                                           float brightness_adjust);
-
-/// Enables the stereo speaker mode. It enforces stereo-panning when headphones
-/// are *not* plugged into the phone. This helps to avoid HRTF-based coloring
-/// effects and reduces computational complexity when speaker playback is
-/// active. By default the stereo speaker mode optimization is disabled.
-///
-/// @param api Pointer to a gvr_audio_context.
-/// @param enable True to enable the stereo speaker mode.
-void gvr_audio_enable_stereo_speaker_mode(gvr_audio_context* api, bool enable);
-
-/// @}
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-// Convenience C++ wrapper.
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#include <memory>
-#include <string>
-
-namespace gvr {
-/// This is a convenience C++ wrapper for the Audio C API.
-///
-/// This wrapper strategy prevents ABI compatibility issues between compilers
-/// by ensuring that the interface between client code and the implementation
-/// code in libgvr.so is a pure C interface. The translation from C++ calls
-/// to C calls provided by this wrapper runs entirely in the client's binary
-/// and is compiled by the client's compiler.
-///
-/// Methods in this class are only documented insofar as the C++ wrapping logic
-/// is concerned; for information about the method itself, please refer to the
-/// corresponding function in the C API.
-///
-///
-/// THREADING: this class is thread-safe and reentrant after initialized
-/// with Init().
-class AudioApi {
- public:
-  /// Creates an (uninitialized) ControllerApi object. You must initialize
-  /// it by calling Init() before interacting with it.
-  AudioApi() : context_(nullptr) {}
-
-  ~AudioApi() {
-    if (context_) {
-      gvr_audio_destroy(&context_);
-    }
-  }
-
-/// Creates and initializes a gvr_audio_context.
-/// For more information, see gvr_audio_create().
-#ifdef __ANDROID__
-  bool Init(JNIEnv* env, jobject android_context, jobject class_loader,
-            AudioRenderingMode rendering_mode) {
-    context_ =
-        gvr_audio_create(env, android_context, class_loader, rendering_mode);
-    return context_ != nullptr;
-  }
-#else
-  bool Init(AudioRenderingMode rendering_mode) {
-    context_ = gvr_audio_create(rendering_mode);
-    return context_ != nullptr;
-  }
-#endif  // #ifdef __ANDROID__
-
-  /// Pauses the audio engine.
-  /// For more information, see gvr_audio_pause().
-  void Pause() { gvr_audio_pause(context_); }
-
-  /// Resumes the audio engine.
-  /// For more information, see gvr_audio_resume().
-  void Resume() { gvr_audio_resume(context_); }
-
-  /// For more information, see gvr_audio_update().
-  void Update() { gvr_audio_update(context_); }
-
-  /// Preloads a local sound file.
-  /// For more information, see gvr_audio_preload_soundfile().
-  bool PreloadSoundfile(const std::string& filename) {
-    return gvr_audio_preload_soundfile(context_, filename.c_str());
-  }
-
-  /// Unloads a previously preloaded sample from memory.
-  /// For more information, see gvr_audio_preload_soundfile().
-  void UnloadSoundfile(const std::string& filename) {
-    gvr_audio_unload_soundfile(context_, filename.c_str());
-  }
-
-  /// Returns a new sound object.
-  /// For more information, see gvr_audio_create_sound_object().
-  AudioSourceId CreateSoundObject(const std::string& filename) {
-    return gvr_audio_create_sound_object(context_, filename.c_str());
-  }
-
-  /// Returns a new sound field.
-  /// For more information, see gvr_audio_create_soundfield().
-  AudioSourceId CreateSoundfield(const std::string& filename) {
-    return gvr_audio_create_soundfield(context_, filename.c_str());
-  }
-
-  /// Returns a new stereo sound.
-  /// For more information, see gvr_audio_create_stereo_sound().
-  AudioSourceId CreateStereoSound(const std::string& filename) {
-    return gvr_audio_create_stereo_sound(context_, filename.c_str());
-  }
-
-  /// Starts the playback of a sound.
-  /// For more information, see gvr_audio_play_sound().
-  void PlaySound(AudioSourceId source_id, bool looping_enabled) {
-    gvr_audio_play_sound(context_, source_id, looping_enabled);
-  }
-
-  /// Pauses the playback of a sound.
-  /// For more information, see gvr_audio_pause_sound().
-  void PauseSound(AudioSourceId source_id) {
-    gvr_audio_pause_sound(context_, source_id);
-  }
-
-  /// Resumes the playback of a sound.
-  /// For more information, see gvr_audio_resume_sound().
-  void ResumeSound(AudioSourceId source_id) {
-    gvr_audio_resume_sound(context_, source_id);
-  }
-
-  /// Stops the playback of a sound.
-  /// For more information, see gvr_audio_stop_sound().
-  void StopSound(AudioSourceId source_id) {
-    gvr_audio_stop_sound(context_, source_id);
-  }
-
-  /// Checks if a sound is playing.
-  /// For more information, see gvr_audio_is_sound_playing().
-  bool IsSoundPlaying(AudioSourceId source_id) const {
-    return gvr_audio_is_sound_playing(context_, source_id);
-  }
-
-  /// Checks if a source is in a valid playable state.
-  /// For more information, see gvr_audio_is_source_id_valid().
-  bool IsSourceIdValid(AudioSourceId source_id) {
-    return gvr_audio_is_source_id_valid(context_, source_id);
-  }
-
-  /// Repositions an existing sound object.
-  /// For more information, see gvr_audio_set_sound_object_position().
-  void SetSoundObjectPosition(AudioSourceId sound_object_id, float x, float y,
-                              float z) {
-    gvr_audio_set_sound_object_position(context_, sound_object_id, x, y, z);
-  }
-
-  void SetSoundObjectDistanceRolloffModel(
-      AudioSourceId sound_object_id,
-      gvr_audio_distance_rolloff_type rolloff_model, float min_distance,
-      float max_distance) {
-    gvr_audio_set_sound_object_distance_rolloff_model(
-        context_, sound_object_id, rolloff_model, min_distance, max_distance);
-  }
-
-  /// Rotates an existing soundfield.
-  /// For more information, see gvr_audio_set_soundfield_rotation().
-  void SetSoundfieldRotation(AudioSourceId soundfield_id,
-                             const Quatf& soundfield_rotation) {
-    gvr_audio_set_soundfield_rotation(context_, soundfield_id,
-                                      soundfield_rotation);
-  }
-
-  /// Changes the master volume.
-  /// For more information, see gvr_audio_set_master_volume().
-  void SetMasterVolume(float volume) {
-    gvr_audio_set_master_volume(context_, volume);
-  }
-
-  /// Changes the volume of an existing sound.
-  /// For more information, see gvr_audio_set_sound_volume().
-  void SetSoundVolume(AudioSourceId source_id, float volume) {
-    gvr_audio_set_sound_volume(context_, source_id, volume);
-  }
-
-  /// Sets the head position from a matrix representation.
-  /// For more information, see gvr_audio_set_head_pose().
-  void SetHeadPose(const Mat4f& head_pose_matrix) {
-    gvr_audio_set_head_pose(context_, head_pose_matrix);
-  }
-
-  /// Turns on/off the room reverberation effect.
-  /// For more information, see gvr_audio_enable_room().
-  void EnableRoom(bool enable) { gvr_audio_enable_room(context_, enable); }
-
-  /// Sets the room properties describing the dimensions and surface materials
-  /// of a given room. For more information, see
-  /// gvr_audio_set_room_properties().
-  void SetRoomProperties(float size_x, float size_y, float size_z,
-                         gvr_audio_material_type wall_material,
-                         gvr_audio_material_type ceiling_material,
-                         gvr_audio_material_type floor_material) {
-    gvr_audio_set_room_properties(context_, size_x, size_y, size_z,
-                                  wall_material, ceiling_material,
-                                  floor_material);
-  }
-
-  /// Adjusts the properties of the current reverb, allowing changes to the
-  /// reverb's gain, duration and low/high frequency balance. For more
-  /// information see gvr_audio_set_room_reverb_adjustments().
-  void SetRoomReverbAdjustments(float gain, float time_adjust,
-                                float brightness_adjust) {
-    gvr_audio_set_room_reverb_adjustments(context_, gain, time_adjust,
-                                          brightness_adjust);
-  }
-
-  /// Enables the stereo speaker mode. For more information see
-  /// gvr_audio_enable_stereo_speaker_mode().
-  void EnableStereoSpeakerMode(bool enable) {
-    gvr_audio_enable_stereo_speaker_mode(context_, enable);
-  }
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and takes ownership.
-  explicit AudioApi(gvr_audio_context* context) : context_(context) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_audio_context* cobj() { return context_; }
-  const gvr_audio_context* cobj() const { return context_; }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_audio_context* Release() {
-    auto result = context_;
-    context_ = nullptr;
-    return result;
-  }
-  /// @}
-
- private:
-  gvr_audio_context* context_;
-
-  // Disallow copy and assign:
-  AudioApi(const AudioApi&);
-  void operator=(const AudioApi&);
-};
-
-}  // namespace gvr
-#endif  // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif  // VR_GVR_CAPI_INCLUDE_GVR_AUDIO_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_controller.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_controller.h
deleted file mode 100644
index 8347393..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_controller.h
+++ /dev/null
@@ -1,793 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_CONTROLLER_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_CONTROLLER_H_
-
-#ifdef __ANDROID__
-#include <jni.h>
-#endif
-
-#include <stdint.h>
-
-#include "vr/gvr/capi/include/gvr.h"
-#include "vr/gvr/capi/include/gvr_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// @defgroup Controller Controller API
-/// @brief This is the Controller C API, which allows access to a VR controller.
-///
-/// If you are writing C++ code, you might prefer to use the C++ wrapper rather
-/// than implement this C API directly.
-///
-/// Typical initialization example:
-///
-///     // Get your gvr_context* pointer from GvrLayout:
-///     gvr_context* gvr = ......;  // (get from GvrLayout in Java)
-///
-///     // Set up the API features:
-///     int32_t options = gvr_controller_get_default_options();
-///
-///     // Enable non-default options, if needed:
-///     options |= GVR_CONTROLLER_ENABLE_GYRO | GVR_CONTROLLER_ENABLE_ACCEL;
-///
-///     // Create and init:
-///     gvr_controller_context* context =
-///         gvr_controller_create_and_init(options, gvr);
-///
-///     // Check if init was successful.
-///     if (!context) {
-///       // Handle error.
-///       return;
-///     }
-///
-///     gvr_controller_state* state = gvr_controller_state_create();
-///
-///     // Resume:
-///     gvr_controller_resume(api);
-///
-/// Usage:
-///
-///     void DrawFrame() {
-///       gvr_controller_state_update(context, 0, state);
-///       // ... process controller state ...
-///     }
-///
-///     // When your application gets paused:
-///     void OnPause() {
-///       gvr_controller_pause(context);
-///     }
-///
-///     // When your application gets resumed:
-///     void OnResume() {
-///       gvr_controller_resume(context);
-///     }
-///
-/// To conserve battery, be sure to call gvr_controller_pause and
-/// gvr_controller_resume when your app gets paused and resumed, respectively.
-///
-/// THREADING: unless otherwise noted, all functions are thread-safe, so
-/// you can operate on the same gvr_controller_context object from multiple
-/// threads.
-/// @{
-
-/// Represents a Daydream Controller API object, used to invoke the
-/// Daydream Controller API.
-typedef struct gvr_controller_context_ gvr_controller_context;
-
-/// Returns the default features for the controller API.
-///
-/// @return The set of default features, as bit flags (an OR'ed combination of
-///     the GVR_CONTROLLER_ENABLE_* feature flags).
-int32_t gvr_controller_get_default_options();
-
-/// Creates and initializes a gvr_controller_context instance which can be used
-/// to invoke the Daydream Controller API functions. Important: after creation
-/// the API will be in the paused state (the controller will be inactive).
-/// You must call gvr_controller_resume() explicitly (typically, in your Android
-/// app's onResume() callback).
-///
-/// @param options The API options. To get the defaults, use
-///     gvr_controller_get_default_options().
-/// @param context The GVR Context object to sync with (optional).
-///     This can be nullptr. If provided, the context's state will
-///     be synchronized with the controller's state where possible. For
-///     example, when the user recenters the controller, this will
-///     automatically recenter head tracking as well.
-///     WARNING: the caller is responsible for making sure the pointer
-///     remains valid for the lifetime of this object.
-/// @return A pointer to the initialized API, or NULL if an error occurs.
-gvr_controller_context* gvr_controller_create_and_init(
-    int32_t options, gvr_context* context);
-
-#ifdef __ANDROID__
-/// Creates and initializes a gvr_controller_context instance with an explicit
-/// Android context and class loader.
-///
-/// @param env The JNI Env associated with the current thread.
-/// @param android_context The Android application context. This must be the
-///     application context, NOT an Activity context (Note: from any Android
-///     Activity in your app, you can call getApplicationContext() to
-///     retrieve the application context).
-/// @param class_loader The class loader to use when loading Java
-///     classes. This must be your app's main class loader (usually
-///     accessible through activity.getClassLoader() on any of your Activities).
-/// @param options The API options. To get the defaults, use
-///     gvr_controller_get_default_options().
-/// @param context The GVR Context object to sync with (optional).
-///     This can be nullptr. If provided, the context's state will
-///     be synchronized with the controller's state where possible. For
-///     example, when the user recenters the controller, this will
-///     automatically recenter head tracking as well.
-///     WARNING: the caller is responsible for making sure the pointer
-///     remains valid for the lifetime of this object.
-/// @return A pointer to the initialized API, or NULL if an error occurs.
-gvr_controller_context* gvr_controller_create_and_init_android(
-    JNIEnv *env, jobject android_context, jobject class_loader,
-    int32_t options, gvr_context* context);
-#endif  // #ifdef __ANDROID__
-
-/// Destroys a gvr_controller_context that was previously created with
-/// gvr_controller_init.
-///
-/// @param api Pointer to a pointer to a gvr_controller_context. The pointer
-///     will be set to NULL after destruction.
-void gvr_controller_destroy(gvr_controller_context** api);
-
-/// Pauses the controller, possibly releasing resources.
-/// Call this when your app/game loses focus.
-/// Calling this when already paused is a no-op.
-/// Thread-safe (call from any thread).
-///
-/// @param api Pointer to a pointer to a gvr_controller_context.
-void gvr_controller_pause(gvr_controller_context* api);
-
-/// Resumes the controller. Call this when your app/game regains focus.
-/// Calling this when already resumed is a no-op.
-/// Thread-safe (call from any thread).
-///
-/// @param api Pointer to a pointer to a gvr_controller_context.
-void gvr_controller_resume(gvr_controller_context* api);
-
-/// Convenience to convert an API status code to string. The returned pointer
-/// is static and valid throughout the lifetime of the application.
-///
-/// @param status The gvr_controller_api_status to convert to string.
-/// @return A pointer to a string that describes the value.
-const char* gvr_controller_api_status_to_string(int32_t status);
-
-/// Convenience to convert an connection state to string. The returned pointer
-/// is static and valid throughout the lifetime of the application.
-///
-/// @param state The state to convert to string.
-/// @return A pointer to a string that describes the value.
-const char* gvr_controller_connection_state_to_string(int32_t state);
-
-/// Convenience to convert an connection state to string. The returned pointer
-/// is static and valid throughout the lifetime of the application.
-///
-/// @param button The gvr_controller_button to convert to string.
-/// @return A pointer to a string that describes the value.
-const char* gvr_controller_button_to_string(int32_t button);
-
-/// Creates a gvr_controller_state.
-gvr_controller_state* gvr_controller_state_create();
-
-/// Destroys a a gvr_controller_state that was previously created with
-/// gvr_controller_state_create.
-void gvr_controller_state_destroy(gvr_controller_state** state);
-
-/// Updates the controller state. Reading the controller state is not a
-/// const getter: it has side-effects. In particular, some of the
-/// gvr_controller_state fields (the ones documented as "transient") represent
-/// one-time events and will be true for only one read operation, and false
-/// in subsequente reads.
-///
-/// @param api Pointer to a pointer to a gvr_controller_context.
-/// @param flags Optional flags reserved for future use. A value of 0 should be
-///     used until corresponding flag attributes are defined and documented.
-/// @param out_state A pointer where the controller's state
-///     is to be written. This must have been allocated with
-///     gvr_controller_state_create().
-void gvr_controller_state_update(gvr_controller_context* api, int32_t flags,
-                                 gvr_controller_state* out_state);
-
-/// Gets the API status of the controller state. Returns one of the
-/// gvr_controller_api_status variants, but returned as an int32_t for ABI
-/// compatibility.
-int32_t gvr_controller_state_get_api_status(const gvr_controller_state* state);
-
-/// Gets the connection state of the controller. Returns one of the
-/// gvr_controller_connection_state variants, but returned as an int32_t for ABI
-/// compatibility.
-int32_t gvr_controller_state_get_connection_state(
-    const gvr_controller_state* state);
-
-/// Returns the current controller orientation, in Start Space. The Start Space
-/// is the same space as the headset space and has these three axes
-/// (right-handed):
-///
-/// * The positive X axis points to the right.
-/// * The positive Y axis points upwards.
-/// * The positive Z axis points backwards.
-///
-/// The definition of "backwards" and "to the right" are based on the position
-/// of the controller when tracking started. For Daydream, this is when the
-/// controller was first connected in the "Connect your Controller" screen
-/// which is shown when the user enters VR.
-///
-/// The definition of "upwards" is given by gravity (away from the pull of
-/// gravity). This API may not work in environments without gravity, such
-/// as space stations or near the center of the Earth.
-///
-/// Since the coordinate system is right-handed, rotations are given by the
-/// right-hand rule. For example, rotating the controller counter-clockwise
-/// on a table top as seen from above means a positive rotation about the
-/// Y axis, while clockwise would mean negative.
-///
-/// Note that this is the Start Space for the *controller*, which initially
-/// coincides with the Start Space for the headset, but they may diverge over
-/// time due to controller/headset drift. A recentering operation will bring
-/// the two spaces back into sync.
-///
-/// Remember that a quaternion expresses a rotation. Given a rotation of theta
-/// radians about the (x, y, z) axis, the corresponding quaternion (in
-/// xyzw order) is:
-///
-///     (x * sin(theta/2), y * sin(theta/2), z * sin(theta/2), cos(theta/2))
-///
-/// Here are some examples of orientations of the controller and their
-/// corresponding quaternions, all given in xyzw order:
-///
-///   * Initial pose, pointing forward and lying flat on a surface: identity
-///     quaternion (0, 0, 0, 1). Corresponds to "no rotation".
-///
-///   * Flat on table, rotated 90 degrees counter-clockwise: (0, 0.7071, 0,
-///     0.7071). Corresponds to a +90 degree rotation about the Y axis.
-///
-///   * Flat on table, rotated 90 degrees clockwise: (0, -0.7071, 0, 0.7071).
-///     Corresponds to a -90 degree rotation about the Y axis.
-///
-///   * Flat on table, rotated 180 degrees (pointing backwards): (0, 1, 0, 0).
-///     Corresponds to a 180 degree rotation about the Y axis.
-///
-///   * Pointing straight up towards the sky: (0.7071, 0, 0, 0.7071).
-///     Corresponds to a +90 degree rotation about the X axis.
-///
-///   * Pointing straight down towards the ground: (-0.7071, 0, 0, 0.7071).
-///     Corresponds to a -90 degree rotation about the X axis.
-///
-///   * Banked 90 degrees to the left: (0, 0, 0.7071, 0.7071). Corresponds
-///     to a +90 degree rotation about the Z axis.
-///
-///   * Banked 90 degrees to the right: (0, 0, -0.7071, 0.7071). Corresponds
-///     to a -90 degree rotation about the Z axis.
-gvr_quatf gvr_controller_state_get_orientation(
-    const gvr_controller_state* state);
-
-/// Returns the current controller gyro reading, in Start Space.
-///
-/// The gyro measures the controller's angular speed in radians per second.
-/// Note that this is an angular *speed*, so it reflects how fast the
-/// controller's orientation is changing with time.
-/// In particular, if the controller is not being rotated, the angular speed
-/// will be zero on all axes, regardless of the current pose.
-///
-/// The axes are in the controller's device space. Specifically:
-///
-///    * The X axis points to the right of the controller.
-///    * The Y axis points upwards perpendicular to the top surface of the
-///      controller.
-///    * The Z axis points backwards along the body of the controller,
-///      towards its rear, where the charging port is.
-///
-/// As usual in a right-handed coordinate system, the sign of the angular
-/// velocity is given by the right-hand rule. So, for example:
-///
-///    * If the controller is flat on a table top spinning counter-clockwise
-///      as seen from above, you will read a positive angular velocity
-///      about the Y axis. Clockwise would be negative.
-///    * If the controller is initially pointing forward and lying flat and
-///      is then gradually angled up so that its tip points towards the sky,
-///      it will report a positive angular velocity about the X axis during
-///      that motion. Likewise, angling it down will report a negative angular
-///      velocity about the X axis.
-///    * If the controller is banked (rolled) to the right, this will
-///      report a negative angular velocity about the Z axis during the
-///      motion (remember the Z axis points backwards along the controller).
-///      Banking to the left will report a positive angular velocity about
-///      the Z axis.
-gvr_vec3f gvr_controller_state_get_gyro(const gvr_controller_state* state);
-
-/// Current (latest) controller accelerometer reading, in Start Space.
-///
-/// The accelerometer indicates the direction in which the controller feels
-/// an acceleration, including gravity. The reading is given in meters
-/// per second squared (m/s^2). The axes are the same as for the gyro.
-/// To have an intuition for the signs used in the accelerometer, it is useful
-/// to imagine that, when at rest, the controller is being "pushed" by a
-/// force opposite to gravity. It is as if, by the equivalency princle, it were
-/// on a frame of reference that is accelerating in the opposite direction to
-/// gravity. For example:
-///
-///   * If the controller is lying flat on a table top, it will read a positive
-///     acceleration of about 9.8 m/s^2 along the Y axis, corresponding to
-///     the acceleration of gravity (as if the table were pushing the controller
-///     upwards at 9.8 m/s^2 to counteract gravity).
-///   * If, in that situation, the controller is now accelerated upwards at
-///     3.0 m/s^2, then the reading will be 12.8 m/s^2 along the Y axis,
-///     since the controller will now feel a stronger acceleration corresponding
-///     to the 9.8 m/s^2 plus the upwards push of 3.0 m/s^2.
-///   * If, the controller is accelerated downwards at 5.0 m/s^2, then the
-///     reading will now be 4.8 m/s^2 along the Y axis, since the controller
-///     will now feel a weaker acceleration (as the acceleration is giving in
-///     to gravity).
-///   * If you were to give in to gravity completely, letting the controller
-///     free fall towards the ground, it will read 0 on all axes, as there
-///     will be no force acting on the controller. (Please do not put your
-///     controller in a free-fall situation. This is just a theoretical
-///     example.)
-gvr_vec3f gvr_controller_state_get_accel(const gvr_controller_state* state);
-
-/// Returns whether the user is touching the touchpad.
-bool gvr_controller_state_is_touching(const gvr_controller_state* state);
-
-/// If the user is touching the touchpad, this returns the touch position in
-/// normalized coordinates, where (0,0) is the top-left of the touchpad
-/// and (1,1) is the bottom right. If the user is not touching the touchpad,
-/// then this is the position of the last touch.
-gvr_vec2f gvr_controller_state_get_touch_pos(const gvr_controller_state* state);
-
-/// Returns true if user just started touching touchpad (this is a transient
-/// event:
-/// it is true for only one frame after the event).
-bool gvr_controller_state_get_touch_down(const gvr_controller_state* state);
-
-/// Returns true if user just stopped touching touchpad (this is a transient
-/// event:
-/// it is true for only one frame after the event).
-bool gvr_controller_state_get_touch_up(const gvr_controller_state* state);
-
-/// Returns true if a recenter operation just ended (this is a transient event:
-/// it is true only for one frame after the recenter ended). If this is
-/// true then the `orientation` field is already relative to the new center.
-bool gvr_controller_state_get_recentered(const gvr_controller_state* state);
-
-/// Returns whether the recenter flow is currently in progress.
-///
-/// @deprecated Use gvr_controller_state_get_recentered instead.
-bool gvr_controller_state_get_recentering(const gvr_controller_state* state);
-
-/// Returns whether the given button is currently pressed.
-bool gvr_controller_state_get_button_state(const gvr_controller_state* state,
-
-                                           int32_t button);
-
-/// Returns whether the given button was just pressed (transient).
-bool gvr_controller_state_get_button_down(const gvr_controller_state* state,
-                                          int32_t button);
-
-/// Returns whether the given button was just released (transient).
-bool gvr_controller_state_get_button_up(const gvr_controller_state* state,
-                                        int32_t button);
-
-/// Returns the timestamp (nanos) when the last orientation event was received.
-int64_t gvr_controller_state_get_last_orientation_timestamp(
-    const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last gyro event was received.
-int64_t gvr_controller_state_get_last_gyro_timestamp(
-    const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last accelerometer event was
-/// received.
-int64_t gvr_controller_state_get_last_accel_timestamp(
-    const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last touch event was received.
-int64_t gvr_controller_state_get_last_touch_timestamp(
-    const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last button event was received.
-int64_t gvr_controller_state_get_last_button_timestamp(
-    const gvr_controller_state* state);
-
-// Current (latest) controller simulated position for use with an elbow model.
-gvr_vec3f gvr_controller_state_get_position(const gvr_controller_state* state);
-
-// Returns the timestamp (nanos) when the last position event was received.
-int64_t gvr_controller_state_get_last_position_timestamp(
-    const gvr_controller_state* state);
-
-/// Returns whether the controller battery is currently charging.
-/// This may not be real time information and may be slow to be updated.
-bool gvr_controller_state_get_battery_charging(
-    const gvr_controller_state* state);
-
-/// Returns the bucketed controller battery level.
-/// Note this is a gvr_controller_battery_level and not a percent.
-int32_t gvr_controller_state_get_battery_level(
-    const gvr_controller_state* state);
-
-/// Returns the timestamp (nanos) when the last battery event was received.
-int64_t gvr_controller_state_get_last_battery_timestamp(
-    const gvr_controller_state* state);
-
-/// Convenience to convert a battery level to string. The returned pointer
-/// is static and valid throughout the lifetime of the application.
-///
-/// @param level The gvr_controller_battery_level to convert to string.
-/// @return A pointer to a string that describes the value.
-const char* gvr_controller_battery_level_to_string(int32_t level);
-
-/// @}
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-
-// Convenience C++ wrapper.
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#include <memory>
-
-namespace gvr {
-/// This is a convenience C++ wrapper for the Controller C API.
-///
-/// This wrapper strategy prevents ABI compatibility issues between compilers
-/// by ensuring that the interface between client code and the implementation
-/// code in libgvr.so is a pure C interface. The translation from C++ calls
-/// to C calls provided by this wrapper runs entirely in the client's binary
-/// and is compiled by the client's compiler.
-///
-/// Methods in this class are only documented insofar as the C++ wrapping logic
-/// is concerned; for information about the method itself, please refer to the
-/// corresponding function in the C API.
-///
-/// Typical C++ initialization example:
-///
-///     std::unique_ptr<ControllerApi> controller_api(new ControllerApi);
-///
-///     // Your GVR context pointer (which can be obtained from GvrLayout)
-///     gvr_context* context = .....;  // (get it from GvrLayout)
-///
-///     // Set up the options:
-///     int32_t options = ControllerApi::DefaultOptions();
-///
-///     // Enable non-default options, if you need them:
-///     options |= GVR_CONTROLLER_ENABLE_GYRO;
-///
-///     // Init the ControllerApi object:
-///     bool success = controller_api->Init(options, context);
-///     if (!success) {
-///       // Handle failure.
-///       // Do NOT call other methods (like Resume, etc) if init failed.
-///       return;
-///     }
-///
-///     // Resume the ControllerApi (if your app is on the foreground).
-///     controller_api->Resume();
-///
-///     ControllerState state;
-///
-/// Usage example:
-///
-///     void DrawFrame() {
-///       state.Update(*controller_api);
-///       // ... process controller state ...
-///     }
-///
-///     // When your application gets paused:
-///     void OnPause() {
-///       controller_api->Pause();
-///     }
-///
-///     // When your application gets resumed:
-///     void OnResume() {
-///       controller_api->Resume();
-///     }
-///
-/// To conserve battery, be sure to call Pause() and Resume() when your app
-/// gets paused and resumed, respectively. This will allow the underlying
-/// logic to unbind from the VR service and let the controller sleep when
-/// no apps are using it.
-///
-/// THREADING: this class is thread-safe and reentrant after initialized
-/// with Init().
-class ControllerApi {
- public:
-  /// Creates an (uninitialized) ControllerApi object. You must initialize
-  /// it by calling Init() before interacting with it.
-  ControllerApi() : context_(nullptr) {}
-
-  /// Returns the default controller options.
-  static int32_t DefaultOptions() {
-    return gvr_controller_get_default_options();
-  }
-
-  // Deprecated factory-style create method.
-  // TODO(btco): remove this once no one is using it.
-  static std::unique_ptr<ControllerApi> Create() {
-    return std::unique_ptr<ControllerApi>(new ControllerApi);
-  }
-
-  /// Initializes the controller API.
-  ///
-  /// This method must be called exactly once in the lifetime of this object.
-  /// Other methods in this class may only be called after Init() returns true.
-  /// Note: this does not cause the ControllerApi to be resumed. You must call
-  /// Resume() explicitly in order to start using the controller.
-  ///
-  /// For more information see gvr_controller_create_and_init().
-  ///
-  /// @return True if initialization was successful, false if it failed.
-  ///     Initialization may fail, for example, because invalid options were
-  ///     supplied.
-  bool Init(int32_t options, gvr_context* context) {
-    context_ = gvr_controller_create_and_init(options, context);
-    return context_ != nullptr;
-  }
-
-#ifdef __ANDROID__
-  /// Overload of Init() with explicit Android context and class loader
-  /// (for Android only). For more information, see:
-  /// gvr_controller_create_and_init_android().
-  bool Init(JNIEnv *env, jobject android_context, jobject class_loader,
-            int32_t options, gvr_context* context) {
-    context_ = gvr_controller_create_and_init_android(
-        env, android_context, class_loader, options, context);
-    return context_ != nullptr;
-  }
-#endif  // #ifdef __ANDROID__
-
-  /// Convenience overload that calls Init without a gvr_context.
-  // TODO(btco): remove once it is no longer being used.
-  bool Init(int32_t options) {
-    return Init(options, nullptr);
-  }
-
-  /// Pauses the controller.
-  /// For more information, see gvr_controller_pause().
-  void Pause() {
-    gvr_controller_pause(context_);
-  }
-
-  /// Resumes the controller.
-  /// For more information, see gvr_controller_resume().
-  void Resume() {
-    gvr_controller_resume(context_);
-  }
-
-  /// Destroys this ControllerApi instance.
-  ~ControllerApi() {
-    if (context_) gvr_controller_destroy(&context_);
-  }
-
-  /// Convenience functions to convert enums to strings.
-  /// For more information, see the corresponding functions in the C API.
-  static const char* ToString(ControllerApiStatus status) {
-    return gvr_controller_api_status_to_string(status);
-  }
-
-  static const char* ToString(ControllerConnectionState state) {
-    return gvr_controller_connection_state_to_string(state);
-  }
-
-  static const char* ToString(ControllerButton button) {
-    return gvr_controller_button_to_string(button);
-  }
-
-  static const char* ToString(ControllerBatteryLevel level) {
-    return gvr_controller_battery_level_to_string(level);
-  }
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and takes ownership.
-  explicit ControllerApi(gvr_controller_context* context)
-      : context_(context) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_controller_context* cobj() { return context_; }
-  const gvr_controller_context* cobj() const { return context_; }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_controller_context* release() {
-    auto result = context_;
-    context_ = nullptr;
-    return result;
-  }
-  /// @}
-
- protected:
-  gvr_controller_context* context_;
-
- private:
-  friend class ControllerState;
-
-  // Disallow copy and assign:
-  ControllerApi(const ControllerApi&);
-  void operator=(const ControllerApi&);
-};
-
-/// Convenience C++ wrapper for the opaque gvr_controller_state type. See the
-/// gvr_controller_state functions for more information.
-class ControllerState {
- public:
-  ControllerState() : state_(gvr_controller_state_create()) {}
-
-  ~ControllerState() {
-    if (state_) gvr_controller_state_destroy(&state_);
-  }
-
-  /// For more information, see gvr_controller_state_update().
-  void Update(const ControllerApi& api) {
-    gvr_controller_state_update(api.context_, 0, state_);
-  }
-
-  /// For more information, see gvr_controller_state_update().
-  void Update(const ControllerApi& api, int32_t flags) {
-    gvr_controller_state_update(api.context_, flags, state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_api_status().
-  ControllerApiStatus GetApiStatus() const {
-    return static_cast<ControllerApiStatus>(
-        gvr_controller_state_get_api_status(state_));
-  }
-
-  /// For more information, see gvr_controller_state_get_connection_state().
-  ControllerConnectionState GetConnectionState() const {
-    return static_cast<ControllerConnectionState>(
-        gvr_controller_state_get_connection_state(state_));
-  }
-
-  /// For more information, see gvr_controller_state_get_orientation().
-  gvr_quatf GetOrientation() const {
-    return gvr_controller_state_get_orientation(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_gyro().
-  gvr_vec3f GetGyro() const { return gvr_controller_state_get_gyro(state_); }
-
-  /// For more information, see gvr_controller_state_get_accel().
-  gvr_vec3f GetAccel() const { return gvr_controller_state_get_accel(state_); }
-
-  /// For more information, see gvr_controller_state_is_touching().
-  bool IsTouching() const { return gvr_controller_state_is_touching(state_); }
-
-  /// For more information, see gvr_controller_state_get_touch_pos().
-  gvr_vec2f GetTouchPos() const {
-    return gvr_controller_state_get_touch_pos(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_touch_down().
-  bool GetTouchDown() const {
-    return gvr_controller_state_get_touch_down(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_touch_up().
-  bool GetTouchUp() const { return gvr_controller_state_get_touch_up(state_); }
-
-  /// For more information, see gvr_controller_state_get_recentered().
-  bool GetRecentered() const {
-    return gvr_controller_state_get_recentered(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_recentering().
-  bool GetRecentering() const {
-    return gvr_controller_state_get_recentering(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_button_state().
-  bool GetButtonState(ControllerButton button) const {
-    return gvr_controller_state_get_button_state(state_, button);
-  }
-
-  /// For more information, see gvr_controller_state_get_button_down().
-  bool GetButtonDown(ControllerButton button) const {
-    return gvr_controller_state_get_button_down(state_, button);
-  }
-
-  /// For more information, see gvr_controller_state_get_button_up().
-  bool GetButtonUp(ControllerButton button) const {
-    return gvr_controller_state_get_button_up(state_, button);
-  }
-
-  /// For more information, see
-  /// gvr_controller_state_get_last_orientation_timestamp().
-  int64_t GetLastOrientationTimestamp() const {
-    return gvr_controller_state_get_last_orientation_timestamp(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_last_gyro_timestamp().
-  int64_t GetLastGyroTimestamp() const {
-    return gvr_controller_state_get_last_gyro_timestamp(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_last_accel_timestamp().
-  int64_t GetLastAccelTimestamp() const {
-    return gvr_controller_state_get_last_accel_timestamp(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_last_touch_timestamp().
-  int64_t GetLastTouchTimestamp() const {
-    return gvr_controller_state_get_last_touch_timestamp(state_);
-  }
-
-  /// For more information, see
-  /// gvr_controller_state_get_last_button_timestamp().
-  int64_t GetLastButtonTimestamp() const {
-    return gvr_controller_state_get_last_button_timestamp(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_position().
-  gvr_vec3f GetPosition() const {
-    return gvr_controller_state_get_position(state_);
-  }
-
-  /// For more information, see
-  /// gvr_controller_state_get_last_position_timestamp().
-  int64_t GetLastPositionTimestamp() const {
-    return gvr_controller_state_get_last_position_timestamp(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_battery_charging
-  bool GetBatteryCharging() const {
-    return gvr_controller_state_get_battery_charging(state_);
-  }
-
-  /// For more information, see gvr_controller_state_get_battery_level
-  ControllerBatteryLevel GetBatteryLevel() const {
-    return static_cast<ControllerBatteryLevel>(
-        gvr_controller_state_get_battery_level(state_));
-  }
-
-  /// For more information, see gvr_controller_state_get_last_battery_timestamp
-  int64_t GetLastBatteryTimestamp() const {
-    return gvr_controller_state_get_last_battery_timestamp(state_);
-  }
-
-  /// @name Wrapper manipulation
-  /// @{
-  /// Creates a C++ wrapper for a C object and takes ownership.
-  explicit ControllerState(gvr_controller_state* state) : state_(state) {}
-
-  /// Returns the wrapped C object. Does not affect ownership.
-  gvr_controller_state* cobj() { return state_; }
-  const gvr_controller_state* cobj() const { return state_; }
-
-  /// Returns the wrapped C object and transfers its ownership to the caller.
-  /// The wrapper becomes invalid and should not be used.
-  gvr_controller_state* release() {
-    auto result = state_;
-    state_ = nullptr;
-    return result;
-  }
-  /// @}
-
- private:
-  gvr_controller_state* state_;
-};
-
-}  // namespace gvr
-#endif  // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif  // VR_GVR_CAPI_INCLUDE_GVR_CONTROLLER_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_types.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_types.h
deleted file mode 100644
index cf81b51..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/include/gvr_types.h
+++ /dev/null
@@ -1,658 +0,0 @@
-/* Copyright 2016 Google Inc. All rights reserved.
- *
- * 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 VR_GVR_CAPI_INCLUDE_GVR_TYPES_H_
-#define VR_GVR_CAPI_INCLUDE_GVR_TYPES_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/// @defgroup types Google VR Types
-/// @brief Various types used in the Google VR NDK.
-/// @{
-
-/// Primary context for invoking Google VR APIs.
-typedef struct gvr_context_ gvr_context;
-
-/// An enum for the left and right eye.
-typedef enum {
-  GVR_LEFT_EYE = 0,
-  GVR_RIGHT_EYE,
-  GVR_NUM_EYES
-} gvr_eye;
-
-/// The type of VR viewer.
-typedef enum {
-  /// A Cardboard-compatible viewer. A typical Cardboard viewer supports a
-  /// simple touchscreen-based trigger input mechanism. On most platforms, this
-  // is the default viewer type if no viewer has been explicitly paired.
-  GVR_VIEWER_TYPE_CARDBOARD = 0,
-  /// A Daydream-compatible viewer. A typical Daydream viewer supports 3DOF
-  /// controller input (as defined in gvr_controller.h), and is intended only
-  /// for Daydream-ready platforms. It does *not* support touchscreen-based
-  /// input unless Cardboard emulation is explicitly enabled.
-  GVR_VIEWER_TYPE_DAYDREAM = 1,
-} gvr_viewer_type;
-
-// Types of VR-specific features which may or may not be supported on the
-// underlying platform.
-typedef enum {
-  // Asynchronous reprojection warps the app's rendered frame using the most
-  // recent head pose just before pushing the frame to the display.
-  GVR_FEATURE_ASYNC_REPROJECTION = 0,
-} gvr_feature;
-
-/// @}
-
-/// Version information for the Google VR API.
-typedef struct gvr_version_ {
-  int32_t major;
-  int32_t minor;
-  int32_t patch;
-} gvr_version;
-
-/// An integral 2D size. Used for render target sizes.
-typedef struct gvr_sizei {
-  int32_t width;
-  int32_t height;
-} gvr_sizei;
-
-/// An integral 2D rect. Used for window bounds in pixels.
-typedef struct gvr_recti {
-  int32_t left;
-  int32_t right;
-  int32_t bottom;
-  int32_t top;
-} gvr_recti;
-
-/// A floating point 2D rect. Used for field of view, and also for ranges
-/// in texture space. When used for a field of view, all angles are in positive
-/// degrees from the optical axis.
-typedef struct gvr_rectf {
-  float left;
-  float right;
-  float bottom;
-  float top;
-} gvr_rectf;
-
-/// A floating point 2D vector.
-typedef struct gvr_vec2f {
-  float x;
-  float y;
-} gvr_vec2f;
-
-/// A floating point 3D vector.
-typedef struct gvr_vec3f {
-  float x;
-  float y;
-  float z;
-} gvr_vec3f;
-
-/// A floating point 4x4 matrix.
-typedef struct gvr_mat4f { float m[4][4]; } gvr_mat4f;
-
-/// A floating point quaternion, in JPL format.
-/// We use this simple struct in order not to impose a dependency on a
-/// particular math library. The user of this API is free to encapsulate this
-/// into any math library they want.
-typedef struct gvr_quatf {
-  /// qx, qy, qz are the vector component.
-  float qx;
-  float qy;
-  float qz;
-  /// qw is the linelar component.
-  float qw;
-} gvr_quatf;
-
-/// A *monotonic system time* representation. On Android, this is equivalent to
-/// System.nanoTime(), or clock_gettime(CLOCK_MONOTONIC). If there is any doubt
-/// about how to get the current time for the current platform, simply use
-/// gvr_get_time_point_now().
-typedef struct gvr_clock_time_point {
-  int64_t monotonic_system_time_nanos;
-} gvr_clock_time_point;
-
-/// A structure that ties together a region of a buffer, the field of view
-/// rendered into that region and a target eye index to define part of the
-/// user's field of view. The SDK implementation uses this information to
-/// transform the images generated by the app output into the final display that
-/// is sent to the screen.
-///
-/// A set of these structures will most often be generated by the API, via
-/// gvr_get_recommended_buffer_viewports() or
-/// gvr_get_screen_buffer_viewports(). However, the client may also customize
-/// these values via gvr_buffer_viewport_list_set(), constructing a custom
-/// gvr_buffer_viewport_list for use in the distortion pass.
-typedef struct gvr_buffer_viewport_ gvr_buffer_viewport;
-
-/// List of buffer viewports that completely specifies how to transform the
-/// frame's buffers into the image displayed on the screen.
-typedef struct gvr_buffer_viewport_list_ gvr_buffer_viewport_list;
-
-/// Specification of a pixel buffer. A pixel buffer can have color, depth and
-/// stencil attachments and mostly corresponds to the OpenGL concept of a
-/// framebuffer object. However, since there can be multiple such objects for
-/// each frame, we avoid calling them "framebuffers". Pixel buffers which are
-/// part of the currently acquired frame are immutable, i.e., they cannot be
-/// resized or otherwise reconfigured.
-typedef struct gvr_buffer_spec_ gvr_buffer_spec;
-
-/// Swap chain that contains some number of frames. Frames in the swap chain
-/// can be unused, in the process of being distorted and presented on the
-/// screen, or acquired and being rendered to by the application. The swap chain
-/// ensures that the most recent available frame is always shown and that the
-/// application never has to wait to render the next frame.
-typedef struct gvr_swap_chain_ gvr_swap_chain;
-
-/// A single frame acquired from the swap chain. Each frame is composed of one
-/// or more buffers, which are then lens distorted and composited into the final
-/// output. Buffers are identified by indices that correspond to the position
-/// of their gvr_buffer_spec in the list passed when constructing the swap
-/// chain.
-typedef struct gvr_frame_ gvr_frame;
-
-/// @addtogroup types
-/// @{
-
-/// Constants that represent GVR error codes.
-typedef enum {
-  GVR_ERROR_NONE = 0,
-  GVR_ERROR_CONTROLLER_CREATE_FAILED = 2,
-  GVR_ERROR_NO_FRAME_AVAILABLE = 3,
-} gvr_error;
-
-/// Controller API options (bit flags).
-enum {
-  /// Indicates that controller orientation data should be reported.
-  GVR_CONTROLLER_ENABLE_ORIENTATION = 1 << 0,
-  /// Indicates that controller touchpad data should be reported.
-  GVR_CONTROLLER_ENABLE_TOUCH = 1 << 1,
-  /// Indicates that controller gyroscope data should be reported.
-  GVR_CONTROLLER_ENABLE_GYRO = 1 << 2,
-  /// Indicates that controller accelerometer data should be reported.
-  GVR_CONTROLLER_ENABLE_ACCEL = 1 << 3,
-  /// Indicates that controller gestures should be reported.
-  GVR_CONTROLLER_ENABLE_GESTURES = 1 << 4,
-  /// Indicates that controller pose prediction should be enabled.
-  GVR_CONTROLLER_ENABLE_POSE_PREDICTION = 1 << 5,
-  /// Indicates that controller position data should be reported.
-  GVR_CONTROLLER_ENABLE_POSITION = 1 << 6,
-  /// Indicates that controller battery data should be reported.
-  GVR_CONTROLLER_ENABLE_BATTERY = 1 << 7,
-};
-
-/// Constants that represent the status of the controller API.
-typedef enum {
-  /// API is happy and healthy. This doesn't mean the controller itself
-  /// is connected, it just means that the underlying service is working
-  /// properly.
-  GVR_CONTROLLER_API_OK = 0,
-
-  /// Any other status represents a permanent failure that requires
-  /// external action to fix:
-
-  /// API failed because this device does not support controllers (API is too
-  /// low, or other required feature not present).
-  GVR_CONTROLLER_API_UNSUPPORTED = 1,
-  /// This app was not authorized to use the service (e.g., missing permissions,
-  /// the app is blacklisted by the underlying service, etc).
-  GVR_CONTROLLER_API_NOT_AUTHORIZED = 2,
-  /// The underlying VR service is not present.
-  GVR_CONTROLLER_API_UNAVAILABLE = 3,
-  /// The underlying VR service is too old, needs upgrade.
-  GVR_CONTROLLER_API_SERVICE_OBSOLETE = 4,
-  /// The underlying VR service is too new, is incompatible with current client.
-  GVR_CONTROLLER_API_CLIENT_OBSOLETE = 5,
-  /// The underlying VR service is malfunctioning. Try again later.
-  GVR_CONTROLLER_API_MALFUNCTION = 6,
-} gvr_controller_api_status;
-
-/// Constants that represent the state of the controller.
-typedef enum {
-  /// Controller is disconnected.
-  GVR_CONTROLLER_DISCONNECTED = 0,
-  /// Controller is scanning.
-  GVR_CONTROLLER_SCANNING = 1,
-  /// Controller is connecting.
-  GVR_CONTROLLER_CONNECTING = 2,
-  /// Controller is connected.
-  GVR_CONTROLLER_CONNECTED = 3,
-} gvr_controller_connection_state;
-
-/// Controller buttons.
-typedef enum {
-  GVR_CONTROLLER_BUTTON_NONE = 0,
-  GVR_CONTROLLER_BUTTON_CLICK = 1,  ///< Touchpad Click.
-  GVR_CONTROLLER_BUTTON_HOME = 2,
-  GVR_CONTROLLER_BUTTON_APP = 3,
-  GVR_CONTROLLER_BUTTON_VOLUME_UP = 4,
-  GVR_CONTROLLER_BUTTON_VOLUME_DOWN = 5,
-
-  /// Note: there are 5 buttons on the controller, but the state arrays have
-  /// this many elements due to the inclusion of a dummy "none" button.
-  GVR_CONTROLLER_BUTTON_COUNT = 6,
-} gvr_controller_button;
-
-/// Controller battery states.
-typedef enum {
-  GVR_CONTROLLER_BATTERY_LEVEL_UNKNOWN = 0,
-  GVR_CONTROLLER_BATTERY_LEVEL_CRITICAL_LOW = 1,
-  GVR_CONTROLLER_BATTERY_LEVEL_LOW = 2,
-  GVR_CONTROLLER_BATTERY_LEVEL_MEDIUM = 3,
-  GVR_CONTROLLER_BATTERY_LEVEL_ALMOST_FULL = 4,
-  GVR_CONTROLLER_BATTERY_LEVEL_FULL = 5,
-
-  /// Note: there are 5 distinct levels, but there are 6 due to the inclusion
-  /// of an UNKNOWN state before any battery information is collected, etc.
-  GVR_CONTROLLER_BATTERY_LEVEL_COUNT = 6,
-} gvr_controller_battery_level;
-
-
-/// @}
-
-/// Opaque handle to controller state.
-typedef struct gvr_controller_state_ gvr_controller_state;
-
-/// @addtogroup types
-/// @{
-
-/// Rendering modes define CPU load / rendering quality balances.
-typedef enum {
-  /// Stereo panning of all Sound Objects. This disables HRTF-based rendering.
-  GVR_AUDIO_RENDERING_STEREO_PANNING = 0,
-  /// HRTF-based rendering over a virtual array of 8 loudspeakers arranged in
-  /// a cube configuration around the listener’s head.
-  GVR_AUDIO_RENDERING_BINAURAL_LOW_QUALITY = 1,
-  /// HRTF-based rendering over a virtual array of 16 loudspeakers arranged in
-  /// an approximate equidistribution about the around the listener’s head.
-  GVR_AUDIO_RENDERING_BINAURAL_HIGH_QUALITY = 2,
-} gvr_audio_rendering_mode;
-
-/// Room surface material names, used to set room properties.
-typedef enum {
-  /// Acoustically transparent material, reflects no sound.
-  GVR_AUDIO_MATERIAL_TRANSPARENT = 0,
-  /// Acoustic ceiling tiles, absorbs most frequencies.
-  GVR_AUDIO_MATERIAL_ACOUSTIC_CEILING_TILES = 1,
-  /// Bare brick, relatively reflective.
-  GVR_AUDIO_MATERIAL_BRICK_BARE = 2,
-  /// Painted brick
-  GVR_AUDIO_MATERIAL_BRICK_PAINTED = 3,
-  /// Coarse surface concrete block.
-  GVR_AUDIO_MATERIAL_CONCRETE_BLOCK_COARSE = 4,
-  /// Painted concrete block.
-  GVR_AUDIO_MATERIAL_CONCRETE_BLOCK_PAINTED = 5,
-  /// Heavy curtains.
-  GVR_AUDIO_MATERIAL_CURTAIN_HEAVY = 6,
-  /// Fiber glass insulation.
-  GVR_AUDIO_MATERIAL_FIBER_GLASS_INSULATION = 7,
-  /// Thin glass.
-  GVR_AUDIO_MATERIAL_GLASS_THIN = 8,
-  /// Thick glass.
-  GVR_AUDIO_MATERIAL_GLASS_THICK = 9,
-  /// Grass.
-  GVR_AUDIO_MATERIAL_GRASS = 10,
-  /// Linoleum on concrete.
-  GVR_AUDIO_MATERIAL_LINOLEUM_ON_CONCRETE = 11,
-  /// Marble.
-  GVR_AUDIO_MATERIAL_MARBLE = 12,
-  /// Galvanized sheet metal.
-  GVR_AUDIO_MATERIAL_METAL = 13,
-  /// Wooden parquet on concrete.
-  GVR_AUDIO_MATERIAL_PARQUET_ON_CONCRETE = 14,
-  /// Rough plaster surface.
-  GVR_AUDIO_MATERIAL_PLASTER_ROUGH = 15,
-  /// Smooth plaster surface.
-  GVR_AUDIO_MATERIAL_PLASTER_SMOOTH = 16,
-  /// Plywood panel.
-  GVR_AUDIO_MATERIAL_PLYWOOD_PANEL = 17,
-  /// Polished concrete OR tile surface.
-  GVR_AUDIO_MATERIAL_POLISHED_CONCRETE_OR_TILE = 18,
-  /// Sheet rock.
-  GVR_AUDIO_MATERIAL_SHEET_ROCK = 19,
-  /// Surface of water or ice.
-  GVR_AUDIO_MATERIAL_WATER_OR_ICE_SURFACE = 20,
-  /// Wooden ceiling.
-  GVR_AUDIO_MATERIAL_WOOD_CEILING = 21,
-  /// Wood paneling.
-  GVR_AUDIO_MATERIAL_WOOD_PANEL = 22,
-} gvr_audio_material_type;
-
-/// Distance rolloff models used for distance attenuation.
-typedef enum {
-  /// Logarithmic distance rolloff model.
-  GVR_AUDIO_ROLLOFF_LOGARITHMIC = 0,
-  /// Linear distance rolloff model.
-  GVR_AUDIO_ROLLOFF_LINEAR = 1,
-  /// No distance attenuation will be applied.
-  GVR_AUDIO_ROLLOFF_NONE = 2,
-} gvr_audio_distance_rolloff_type;
-
-/// Sound object and sound field identifier.
-typedef int32_t gvr_audio_source_id;
-
-/// Supported surround sound formats.
-typedef enum {
-  // Enables to initialize a yet undefined rendering mode.
-  GVR_AUDIO_SURROUND_FORMAT_INVALID = 0,
-
-  // Virtual stereo speakers at -30 degrees and +30 degrees.
-  GVR_AUDIO_SURROUND_FORMAT_SURROUND_STEREO = 1,
-
-  // 5.1 surround sound according to the ITU-R BS 775 speaker configuration
-  // recommendation:
-  //   - Front left (FL) at 30 degrees.
-  //   - Front right (FR) at -30 degrees.
-  //   - Front center (FC) at 0 degrees.
-  //   - Low frequency effects (LFE) at front center at 0 degrees.
-  //   - Left side (LS) at 110 degrees.
-  //   - Right side (RS) at -110 degrees.
-  //
-  // The 5.1 channel input layout must matches AAC: FL, FR, FC, LFE, LS, RS.
-  // Note that this differs from the Vorbis/Opus 5.1 channel layout, which
-  // is: FL, FC, FR, LS, RS, LFE.
-  GVR_AUDIO_SURROUND_FORMAT_SURROUND_FIVE_DOT_ONE = 2,
-
-  // First-order ambisonics (AmbiX format: 4 channels, ACN channel ordering,
-  // SN3D normalization).
-  GVR_AUDIO_SURROUND_FORMAT_FIRST_ORDER_AMBISONICS = 3,
-
-  // Second-order ambisonics (AmbiX format: 9 channels, ACN channel ordering,
-  // SN3D normalization).
-  GVR_AUDIO_SURROUND_FORMAT_SECOND_ORDER_AMBISONICS = 4,
-
-  // Third-order ambisonics (AmbiX format: 16 channels, ACN channel ordering,
-  // SN3D normalization).
-  GVR_AUDIO_SURROUND_FORMAT_THIRD_ORDER_AMBISONICS = 5,
-} gvr_audio_surround_format_type;
-
-/// Valid color formats for swap chain buffers.
-typedef enum {
-  /// Equivalent to GL_RGBA8
-  GVR_COLOR_FORMAT_RGBA_8888 = 0,
-  /// Equivalent to GL_RGB565
-  GVR_COLOR_FORMAT_RGB_565 = 1,
-} gvr_color_format_type;
-
-typedef enum {
-  /// No depth or stencil buffer.
-  GVR_DEPTH_STENCIL_FORMAT_NONE = 255,
-  /// Equivalent to GL_DEPTH_COMPONENT16.
-  GVR_DEPTH_STENCIL_FORMAT_DEPTH_16 = 0,
-  /// Equivalent to GL_DEPTH_COMPONENT24.
-  GVR_DEPTH_STENCIL_FORMAT_DEPTH_24 = 1,
-  /// Equivlaent to GL_DEPTH24_STENCIL8.
-  GVR_DEPTH_STENCIL_FORMAT_DEPTH_24_STENCIL_8 = 2,
-  /// Equivalent to GL_DEPTH_COMPONENT32F.
-  GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F = 3,
-  /// Equivalent to GL_DEPTH_32F_STENCIL8.
-  GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F_STENCIL_8 = 4,
-  /// Equivalent to GL_STENCIL8.
-  GVR_DEPTH_STENCIL_FORMAT_STENCIL_8 = 5,
-} gvr_depth_stencil_format_type;
-
-/// Types of asynchronous reprojection.
-typedef enum {
-  /// Do not reproject.
-  GVR_REPROJECTION_NONE = 0,
-  /// Reproject in all dimensions.
-  GVR_REPROJECTION_FULL = 1,
-} gvr_reprojection;
-
-typedef enum {
-  GVR_CONTROLLER_RIGHT_HANDED = 0,
-  GVR_CONTROLLER_LEFT_HANDED = 1,
-} gvr_controller_handedness;
-
-typedef struct gvr_user_prefs_ gvr_user_prefs;
-
-// Anonymous enum for miscellaneous integer constants.
-enum {
-  /// Constant that represents a nonexistent external surface. Pass to
-  /// gvr_buffer_viewport_set_external_surface_id() to disable sampling from
-  /// an external surface.
-  GVR_EXTERNAL_SURFACE_ID_NONE = -1,
-  /// Special index for a source buffer that has the same contents as the
-  /// external surface attached to the given viewport. Pass this to
-  /// gvr_buffer_viewport_set_source_buffer_index() to use the external surface
-  /// as the buffer contents.
-  GVR_BUFFER_INDEX_EXTERNAL_SURFACE = -1,
-};
-
-/// @}
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-// These typedefs convert the C-style names to C++-style names.
-
-namespace gvr {
-
-const int32_t kControllerEnableOrientation =
-    static_cast<int32_t>(GVR_CONTROLLER_ENABLE_ORIENTATION);
-const int32_t kControllerEnableTouch =
-    static_cast<int32_t>(GVR_CONTROLLER_ENABLE_TOUCH);
-const int32_t kControllerEnableGyro =
-    static_cast<int32_t>(GVR_CONTROLLER_ENABLE_GYRO);
-const int32_t kControllerEnableAccel =
-    static_cast<int32_t>(GVR_CONTROLLER_ENABLE_ACCEL);
-const int32_t kControllerEnableGestures =
-    static_cast<int32_t>(GVR_CONTROLLER_ENABLE_GESTURES);
-const int32_t kControllerEnablePosePrediction =
-    static_cast<int32_t>(GVR_CONTROLLER_ENABLE_POSE_PREDICTION);
-const int32_t kControllerEnablePosition =
-    static_cast<int32_t>(GVR_CONTROLLER_ENABLE_POSITION);
-const int32_t kControllerEnableBattery =
-    static_cast<int32_t>(GVR_CONTROLLER_ENABLE_BATTERY);
-
-typedef gvr_controller_api_status ControllerApiStatus;
-const ControllerApiStatus kControllerApiOk =
-    static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_OK);
-const ControllerApiStatus kControllerApiUnsupported =
-    static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_UNSUPPORTED);
-const ControllerApiStatus kControllerApiNotAuthorized =
-    static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_NOT_AUTHORIZED);
-const ControllerApiStatus kControllerApiUnavailable =
-    static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_UNAVAILABLE);
-const ControllerApiStatus kControllerApiServiceObsolete =
-    static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_SERVICE_OBSOLETE);
-const ControllerApiStatus kControllerApiClientObsolete =
-    static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_CLIENT_OBSOLETE);
-const ControllerApiStatus kControllerApiMalfunction =
-    static_cast<ControllerApiStatus>(GVR_CONTROLLER_API_MALFUNCTION);
-
-typedef gvr_controller_connection_state ControllerConnectionState;
-const ControllerConnectionState kControllerDisconnected =
-    static_cast<ControllerConnectionState>(GVR_CONTROLLER_DISCONNECTED);
-const ControllerConnectionState kControllerScanning =
-    static_cast<ControllerConnectionState>(GVR_CONTROLLER_SCANNING);
-const ControllerConnectionState kControllerConnecting =
-    static_cast<ControllerConnectionState>(GVR_CONTROLLER_CONNECTING);
-const ControllerConnectionState kControllerConnected =
-    static_cast<ControllerConnectionState>(GVR_CONTROLLER_CONNECTED);
-
-typedef gvr_controller_button ControllerButton;
-const ControllerButton kControllerButtonNone =
-    static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_NONE);
-const ControllerButton kControllerButtonClick =
-    static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_CLICK);
-const ControllerButton kControllerButtonHome =
-    static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_HOME);
-const ControllerButton kControllerButtonApp =
-    static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_APP);
-const ControllerButton kControllerButtonVolumeUp =
-    static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_VOLUME_UP);
-const ControllerButton kControllerButtonVolumeDown =
-    static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_VOLUME_DOWN);
-const ControllerButton kControllerButtonCount =
-    static_cast<ControllerButton>(GVR_CONTROLLER_BUTTON_COUNT);
-
-typedef gvr_controller_battery_level ControllerBatteryLevel;
-const ControllerBatteryLevel kControllerBatteryLevelUnknown =
-    static_cast<ControllerBatteryLevel>(
-        GVR_CONTROLLER_BATTERY_LEVEL_UNKNOWN);
-const ControllerBatteryLevel kControllerBatteryLevelCriticalLow =
-    static_cast<ControllerBatteryLevel>(
-        GVR_CONTROLLER_BATTERY_LEVEL_CRITICAL_LOW);
-const ControllerBatteryLevel kControllerBatteryLevelLow =
-    static_cast<ControllerBatteryLevel>(
-        GVR_CONTROLLER_BATTERY_LEVEL_LOW);
-const ControllerBatteryLevel kControllerBatteryLevelMedium =
-    static_cast<ControllerBatteryLevel>(
-        GVR_CONTROLLER_BATTERY_LEVEL_MEDIUM);
-const ControllerBatteryLevel kControllerBatteryLevelAlmostFull =
-    static_cast<ControllerBatteryLevel>(
-        GVR_CONTROLLER_BATTERY_LEVEL_ALMOST_FULL);
-const ControllerBatteryLevel kControllerBatteryLevelFull =
-    static_cast<ControllerBatteryLevel>(
-        GVR_CONTROLLER_BATTERY_LEVEL_FULL);
-
-/// An uninitialized external surface ID.
-const int32_t kUninitializedExternalSurface = GVR_BUFFER_INDEX_EXTERNAL_SURFACE;
-/// The default source buffer index for viewports.
-const int32_t kDefaultBufferIndex = 0;
-
-typedef gvr_eye Eye;
-
-typedef gvr_viewer_type ViewerType;
-const ViewerType kViewerTypeCardboard =
-    static_cast<ViewerType>(GVR_VIEWER_TYPE_CARDBOARD);
-const ViewerType kViewerTypeDaydream =
-    static_cast<ViewerType>(GVR_VIEWER_TYPE_DAYDREAM);
-
-typedef gvr_version Version;
-typedef gvr_sizei Sizei;
-typedef gvr_recti Recti;
-typedef gvr_rectf Rectf;
-typedef gvr_vec2f Vec2f;
-typedef gvr_vec3f Vec3f;
-typedef gvr_mat4f Mat4f;
-typedef gvr_quatf Quatf;
-typedef gvr_clock_time_point ClockTimePoint;
-
-typedef gvr_vec2f ControllerVec2;
-typedef gvr_vec3f ControllerVec3;
-typedef gvr_quatf ControllerQuat;
-
-typedef gvr_audio_rendering_mode AudioRenderingMode;
-typedef gvr_audio_material_type AudioMaterialName;
-typedef gvr_audio_distance_rolloff_type AudioRolloffMethod;
-typedef gvr_audio_source_id AudioSourceId;
-typedef gvr_audio_surround_format_type AudioSurroundFormat;
-
-typedef gvr_color_format_type ColorFormat;
-const ColorFormat kColorFormatRgba8888 =
-    static_cast<ColorFormat>(GVR_COLOR_FORMAT_RGBA_8888);
-const ColorFormat kColorFormatRgb565 =
-    static_cast<ColorFormat>(GVR_COLOR_FORMAT_RGB_565);
-
-typedef gvr_depth_stencil_format_type DepthStencilFormat;
-const DepthStencilFormat kDepthStencilFormatNone =
-    static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_NONE);
-const DepthStencilFormat kDepthStencilFormatDepth16 =
-    static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_DEPTH_16);
-const DepthStencilFormat kDepthStencilFormatDepth24 =
-    static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_DEPTH_24);
-const DepthStencilFormat kDepthStencilFormatDepth24Stencil8 =
-    static_cast<DepthStencilFormat>(
-        GVR_DEPTH_STENCIL_FORMAT_DEPTH_24_STENCIL_8);
-const DepthStencilFormat kDepthStencilFormatDepth32f =
-    static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F);
-const DepthStencilFormat kDepthStencilFormatDepth32fStencil8 =
-    static_cast<DepthStencilFormat>(
-        GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F_STENCIL_8);
-const DepthStencilFormat kDepthStencilFormatStencil8 =
-    static_cast<DepthStencilFormat>(GVR_DEPTH_STENCIL_FORMAT_STENCIL_8);
-
-typedef gvr_controller_handedness ControllerHandedness;
-const ControllerHandedness kControllerRightHanded =
-    static_cast<ControllerHandedness>(GVR_CONTROLLER_RIGHT_HANDED);
-const ControllerHandedness kControllerLeftHanded =
-    static_cast<ControllerHandedness>(GVR_CONTROLLER_LEFT_HANDED);
-
-typedef gvr_error Error;
-const Error kErrorNone = static_cast<Error>(GVR_ERROR_NONE);
-const Error kErrorControllerCreateFailed =
-    static_cast<Error>(GVR_ERROR_CONTROLLER_CREATE_FAILED);
-const Error kErrorNoFrameAvailable =
-    static_cast<Error>(GVR_ERROR_NO_FRAME_AVAILABLE);
-
-class AudioApi;
-class BufferSpec;
-class ControllerApi;
-class ControllerState;
-class Frame;
-class GvrApi;
-class BufferViewport;
-class BufferViewportList;
-class SwapChain;
-class UserPrefs;
-
-}  // namespace gvr
-
-// Non-member equality operators for convenience. Since typedefs do not trigger
-// argument-dependent lookup, these operators have to be defined for the
-// underlying types.
-inline bool operator==(const gvr_vec2f& lhs, const gvr_vec2f& rhs) {
-  return lhs.x == rhs.x && lhs.y == rhs.y;
-}
-
-inline bool operator!=(const gvr_vec2f& lhs, const gvr_vec2f& rhs) {
-  return !(lhs == rhs);
-}
-
-inline bool operator==(const gvr_vec3f& lhs, const gvr_vec3f& rhs) {
-  return lhs.x == rhs.x && lhs.y == rhs.y;
-}
-
-inline bool operator!=(const gvr_vec3f& lhs, const gvr_vec3f& rhs) {
-  return !(lhs == rhs);
-}
-
-inline bool operator==(const gvr_recti& lhs, const gvr_recti& rhs) {
-  return lhs.left == rhs.left && lhs.right == rhs.right &&
-         lhs.bottom == rhs.bottom && lhs.top == rhs.top;
-}
-
-inline bool operator!=(const gvr_recti& lhs, const gvr_recti& rhs) {
-  return !(lhs == rhs);
-}
-
-inline bool operator==(const gvr_rectf& lhs, const gvr_rectf& rhs) {
-  return lhs.left == rhs.left && lhs.right == rhs.right &&
-         lhs.bottom == rhs.bottom && lhs.top == rhs.top;
-}
-
-inline bool operator!=(const gvr_rectf& lhs, const gvr_rectf& rhs) {
-  return !(lhs == rhs);
-}
-
-inline bool operator==(const gvr_sizei& lhs, const gvr_sizei& rhs) {
-  return lhs.width == rhs.width && lhs.height == rhs.height;
-}
-
-inline bool operator!=(const gvr_sizei& lhs, const gvr_sizei& rhs) {
-  return !(lhs == rhs);
-}
-
-#endif  // #if defined(__cplusplus) && !defined(GVR_NO_CPP_WRAPPER)
-
-#endif  // VR_GVR_CAPI_INCLUDE_GVR_TYPES_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_experimental.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_experimental.h
deleted file mode 100644
index 5bd6174..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_experimental.h
+++ /dev/null
@@ -1,231 +0,0 @@
-#ifndef VR_GVR_CAPI_SRC_GVR_EXPERIMENTAL_H_
-#define VR_GVR_CAPI_SRC_GVR_EXPERIMENTAL_H_
-
-#include <stdbool.h>
-#include <stdint.h>
-
-#include "vr/gvr/capi/include/gvr_types.h"
-#include "vr/gvr/capi/src/gvr_types_experimental.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// NOTE: APIs added to this file are *not* part of the core GVR library, and
-// should only be used for prototyping or experimental projects. The idea is
-// that APIs added here can be used for testing and development, graduating to
-// the core API (gvr.h or gvr_private.h) after we're ready to commit to them
-// indefinitely.
-
-// ************************************************************************** //
-// *                     DaydreamOS experimental APIs                       * //
-// ************************************************************************** //
-
-/// Gets the position and rotation from start space to head space.  The head
-/// space is a space where the head is at the origin and faces the -Z direction.
-///
-/// @param gvr Pointer to the gvr instance from which to get the pose.
-/// @param time The time at which to get the head pose. The time should be in
-///     the future. If the time is not in the future, it will be clamped to now.
-/// @return A matrix representation of the position and rotation from start
-//      space (the space where the head was last reset) to head space (the space
-///     with the head at the origin, and the axes aligned to the view vector).
-gvr_mat4f gvr_get_head_space_from_start_space_pose(
-    gvr_context* gvr, const gvr_clock_time_point time);
-
-/// Sets the compositor z-order of the swap chain.
-///
-/// @param swap_chain the swap chain to change.
-/// @param z_order Z order, higher values are displayed on top of lower ones,
-///     the default value is 0.
-void gvr_swap_chain_set_z_order(const gvr_swap_chain* swap_chain, int z_order);
-
-/// Creates a gvr_external_surface instance.
-/// An external surface is mainly used to pass external content (such as video
-/// frames, pre-rendered 2D Android UI) into distortion pass for compositing.
-/// The method gvr_external_surface_get_surface can be used to bridge Android
-/// components with GVR distortion pass via a traditional Android Surface
-/// instance.
-///
-/// @param gvr Pointer to the gvr instance from which to create the external
-///     surface.
-/// @return Pointer to an allocated gvr_external_surface object. The caller
-//      is responsible for calling gvr_external_surface_destroy() on the
-///     returned object when it is no longer needed.
-gvr_external_surface* gvr_external_surface_create(gvr_context* gvr);
-
-/// Frees a gvr_external_surface instance and clears the pointer.
-/// Note that once a gvr_external_surface is destroyed, the Java Surface object
-/// returned from gvr_external_surface_get_surface remains to be accessible and
-/// functioning. It's up to Java's garbage collection to release all resources
-/// behind the Java Surface object.
-///
-/// @param surface Pointer to a pointer to the gvr_external_surface instance to
-///     be destroyed and nulled.
-void gvr_external_surface_destroy(gvr_external_surface** surface);
-
-/// Get an Android Surface as a Java object from the gvr_external_surface. This
-/// API is mainly used by standalone display service (aka when
-/// gvr_using_vr_display_service returns true) to access an Android Surface.
-///
-/// @param surface The gvr_external_surface associated with the Android Surface.
-///     Note that this API has to be called within a JNIEnv and is using the
-///     JNIEnv passed in during gvr_create.
-/// @return A jobject that is an instance of the 'android/view/Surface' Java
-///     class, NULL on failure. Note that the return value is really an opaque
-///     handle to a Java object and the life cycle of that object is maintained
-///     by Java (i.e. it will get garbage collected eventually). Thus, there is
-///     no need for an explicit destroy call.
-void* gvr_external_surface_get_surface(const gvr_external_surface* surface);
-
-/// Get the Surface ID associated with the gvr_external_surface. Note that the
-/// returned ID is used for internal bookkeeping only and should not be used
-/// by the app itself for lookups.
-/// @param surface The gvr_external_surface to query the ID for.
-/// @return The external surface ID associated with the gvr_external_surface.
-int32_t gvr_external_surface_get_surface_id(
-    const gvr_external_surface* surface);
-
-/// Sets the z order of the layer to be created.
-/// Note that this API is a short-term workaround for SysUI work and is never
-/// meant to graduate as is to either gvr.h or gvr_private.h. The proper
-/// solution is tracked in b/33946428 and probably involves setting the
-/// attribute on some data structure that represents a layer.
-///
-/// @param spec Buffer specification.
-/// @param z_order Z order, higher values are displayed on top of lower ones,
-///     the default value is 0.
-void gvr_buffer_spec_set_z_order(gvr_buffer_spec* spec, int z_order);
-
-/// Sets the initial visibility of the layer to be created.
-/// Note that this API is a short-term workaround for SysUI work and is never
-/// meant to graduate as is to either gvr.h or gvr_private.h. The proper
-/// solution is tracked in b/33946428 and probably involves setting the
-/// attribute on some data structure that represents a layer.
-///
-/// @param spec Buffer specification.
-/// @param visibility Initial visibility of the layer, defaults to GVR_VISIBLE.
-///     See enum gvr_visibility for possible values.
-void gvr_buffer_spec_set_visibility(gvr_buffer_spec* spec,
-                                    int32_t visibility);
-
-/// Sets whether to blur layers below the layer to be created.
-/// Blurring is applied only to visible layers and only when the layer is
-/// visible.
-/// Note that this API currently is only implemented by the DreamOS
-/// implementation of GVR and is a no-op in other implementations.
-/// TODO(b/33946428): investigate the proper way to surface this feature
-/// to SysUI.
-///
-/// @param spec Buffer specification.
-/// @param blur_behind whether to blur layers behind, defaults to
-///     GVR_BLUR_BEHIND_TRUE. See enum gvr_blur_behind for possible values.
-void gvr_buffer_spec_set_blur_behind(gvr_buffer_spec* spec,
-                                     int32_t blur_behind);
-
-// ************************************************************************** //
-// *                     Daydream PlexEng experimental APIs                 * //
-// ************************************************************************** //
-
-// Registers a new performance event listener that will be invoked on points
-// of interest. By default no event listener is attached.  If multiple event
-// listeners are attached they will all be invoked.  Failures can be checked
-// with gvr_get_error().
-// @param out_handle The pointer to memory where a successfully created handle
-//     will be written.
-// @param gvr The context to register callbacks for.
-// @param user_data The pointer that will be passed back on callbacks for
-//     user_data.
-// @param event_callback The callback to be invoked when an event is observed.
-//     On performance events callback will be invoked with the
-//     user_data passed here, the gvr_perf_event_callback_type, and a float
-//     value (if applicable) or -1.f.
-// @return Returns GVR_EXPERIMENTAL_ERROR_NONE if a handle was created,
-//     GVR_EXPERIMENTAL_ERROR_UNIMPLEMENTED if this feature is disabled,
-//     or GVR_EXPERIMENTAL_ERROR_INVALID_ARGUMENT if a null pointer was passed.
-bool gvr_experimental_register_perf_event_callback(
-    gvr_context* gvr, int* out_handle, void* user_data,
-    void (*event_callback)(void*, int, float));
-
-// Unregisters a previously registered callback by its handle. Failures can be
-// checked with gvr_get_error().
-// @param handle The handle which was returned when registering the callback.
-// @return Returns GVR_EXPERIMENTAL_ERROR_NONE if callback was unregistered,
-//     GVR_EXPERIMENTAL_ERROR_INVALID_ARGUMENT if the if the handle wasn't
-//     previously
-//     registered.  If this feature is not enabled it will return
-//     GVR_EXPERIMENTAL_ERROR_UNIMPLEMENTED.
-bool gvr_experimental_unregister_perf_event_callback(gvr_context* gvr,
-                                                     int handle);
-
-// ************************************************************************** //
-// *                    GVR Analytics experimental APIs                     * //
-// ************************************************************************** //
-// TODO(b/31634289): These functions are experimental because their main client
-// case is the performance monitoring HUD, whose form and function is still
-// under development. Consequently, the analytics API may change as the HUD's
-// needs become clearer.
-//
-// These functions will be moved into the main API (probably gvr_private.h) once
-// the HUD is ready to be shipped as part of the SDK.
-//
-// Contacts: georgelu@
-
-/// Returns whether the "Performance Monitoring" developer option is enabled.
-///
-/// @param user_prefs Pointer to the gvr_user_prefs object returned by
-///     gvr_get_user_prefs.
-/// @return True if the "Performance Monitoring" developer option is enabled.
-bool gvr_user_prefs_get_performance_monitoring_enabled(
-    const gvr_user_prefs* user_prefs);
-
-// Opaque struct returned by gvr_get_analytics that can be queried through
-// gvr_analytics_get* functions.
-//
-// Note: The struct is never actually defined since gvr_analytics is actually
-// just a static_cast of a gvr_context, similar to how gvr_user_prefs works.
-typedef struct gvr_analytics_ gvr_analytics;
-
-// Returns an opaque struct that can be queried for analytics data. The returned
-// struct remains valid as long as the context is valid.
-//
-// @param gvr Pointer to the current gvr_context instance.
-// @return An opaque struct that can be queried through gvr_analytics_*
-//     functions.
-const gvr_analytics* gvr_get_analytics(gvr_context* gvr);
-
-// If the "Performance Monitoring" developer option in VR settings is enabled,
-// returns a gvr_analytics_sample* containing analytics data. Caller is
-// responsible for calling gvr_analytics_destroy_sample on the returned object.
-//
-// @param analytics gvr_analytics* returned by gvr_get_analytics.
-// @return gvr_analytics_sample* containing analytics data.
-const gvr_analytics_sample* gvr_analytics_create_sample(
-    const gvr_analytics* analytics);
-
-// Returns pointer to a buffer containing a serialized AnalyticsSample proto.
-// The buffer is valid only for the lifetime of the gvr_analytics_sample.
-//
-// @param Pointer to a gvr_analytics_sample object.
-// @return Pointer to buffer.
-const char* gvr_analytics_sample_get_buffer(const gvr_analytics_sample* sample);
-
-// Returns the length of the buffer returned by gvr_analytics_sample_get_buffer.
-//
-// @param Pointer to a gvr_analytics_sample object.
-// @return Length of buffer.
-size_t gvr_analytics_sample_get_buffer_length(
-    const gvr_analytics_sample* sample);
-
-// Destroys a gvr_analytics_sample* previously created through
-// gvr_analytics_create_sample.
-//
-// @param sample Pointer to pointer that will be set to null and whose
-//     underlying gvr_analytics_sample will be destroyed.
-void gvr_analytics_destroy_sample(const gvr_analytics_sample** sample);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#endif  // VR_GVR_CAPI_SRC_GVR_EXPERIMENTAL_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_private.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_private.h
deleted file mode 100644
index 0a9d30e..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_private.h
+++ /dev/null
@@ -1,378 +0,0 @@
-#ifndef VR_GVR_CAPI_SRC_GVR_PRIVATE_H_
-#define VR_GVR_CAPI_SRC_GVR_PRIVATE_H_
-
-#include <stddef.h>
-
-#include "vr/gvr/capi/include/gvr_types.h"
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-// Opaque handle to gvr_tracker_state object containing serialized state.
-typedef struct gvr_tracker_state_ gvr_tracker_state;
-
-// Opaque handle to gvr_display_synchronizer object for display synchronization.
-typedef struct gvr_display_synchronizer_ gvr_display_synchronizer;
-
-// Internal Google VR C API methods. These methods are exposed only to internal
-// targets, but should follow all the same backwards-compatible restrictions
-// as the public C API.
-
-/// Sets whether asynchronous reprojection is currently enabled.
-///
-/// If enabled, frames will be collected by the rendering system and
-/// asynchronously re-projected in sync with the scanout of the display. This
-/// feature may not be available on every platform, and requires a
-/// high-priority render thread with special extensions to function properly.
-///
-/// Note: On Android, this feature can be enabled solely via the GvrLayout Java
-/// instance which (indirectly) owns this gvr_context. The corresponding
-/// method call is GvrLayout.setAsyncReprojectionEnabled().
-///
-/// @param gvr Pointer to the gvr instance.
-/// @Param enabled Whether to enable async reprojection.
-/// @return Whether the setting was succesfully applied.
-bool gvr_set_async_reprojection_enabled(gvr_context* gvr, bool enabled);
-
-// Initializes necessary GL-related objects and uses the current thread and
-// GL context for racing the scanline. This function should only be called
-// by the SDK itself, not by any application, unless that application is
-// providing a high-priority thread and GL context for async reprojection.
-//
-// Note: This method is private as it is intended for use solely by the
-// hidden async reprojection implementation in ScanlineRacingRenderer.java,
-// called in onSurfaceCreated().
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_on_surface_created_reprojection_thread(gvr_context* gvr);
-
-// Renders the scanline layer. This function should only be called
-// in the same thread that gvr_initialize_gl_projection_thread was called in.
-// This function should only be called by the SDK itself, not by any
-// application, unless that application is providing a high-priority
-// thread and GL context for async reprojection.
-//
-// Note: This method is private as it is intended for use solely by the
-// hidden async reprojection implementation in ScanlineRacingRenderer.java.
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_render_reprojection_thread(gvr_context* gvr);
-
-// Signals to the reprojection thread that it is paused. This is necessary
-// in case the application render thread is blocked on pending work by the
-// reprojection thread. This function will abort any blocking.
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_on_pause_reprojection_thread(gvr_context* gvr);
-
-// Sets the parameters for the external surface managed by the reprojection
-// thread.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param surface_id The ID of the external Surface managed by the reprojection
-//     thread. The ID is issued by the SurfaceTextureManager.
-// @param texture_id The GL texture ID associated with the external Surface.
-// @param timestamp The timestamp of the most recent frame the Surface holds.
-// @param surface_transfrom Matrix that transforms homogeneous texture coords to
-//     the external surface texture space.
-void gvr_update_surface_reprojection_thread(gvr_context* gvr,
-      int32_t surface_id, int32_t texture_id, gvr_clock_time_point timestamp,
-      gvr_mat4f surface_transform);
-
-// Removes all external surfaces managed by the reprojection thread. This does
-// not destoy the surfaces: it removes tracking by the reprojection thread.
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_remove_all_surfaces_reprojection_thread(gvr_context* gvr);
-
-// Reconnects the sensors when the sensor producers are created internally.
-//
-// Note: This function is not thread-safe, and should be called only on the
-// rendering thread. It is intended to be used internally by GvrLayout when
-// the target presentation display changes.
-//
-// @param gvr Pointer to the gvr_context instance.
-void gvr_reconnect_sensors(gvr_context* gvr);
-
-// Sets VR viewer params for the current context.
-//
-// Note: This function does not update the viewer proto in the common storage
-// location. Rather, it overrides the viewer params solely for the provided
-// gvr_context.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param serialized_viewer_params A pointer to the payload containing the
-//     serialized viewer params proto.
-// @param serialized_viewer_params_size_bytes The length in bytes of the
-//     serialized viewer params payload.
-// @return Whether the serialized viewer params proto was successfully applied.
-bool gvr_set_viewer_params(gvr_context* gvr,
-                           const void* serialized_viewer_params,
-                           size_t serialized_viewer_params_size_bytes);
-
-// Sets the lens offset.
-//
-// @param offset The offset of the lens center from the expected location in
-// screen space.
-void gvr_set_lens_offset(gvr_context* gvr, gvr_vec2f offset);
-
-// Sets display metrics for the current context.
-//
-// Note: This function does not update the phone proto in the commom storage
-// location. Rather, it overrides the internal metrics solely for the provided
-// |gvr| context.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param size_pixels The dimensions in pixels of the active display.
-// @param meters_per_pixel The density of the current display in meters/pixel.
-// @param border_size_meters The size of the border around the display
-//     in meters.  When the device sits on a surface in the proper
-//     orientation this is the distance from the surface to the edge
-//     of the display.
-void gvr_set_display_metrics(gvr_context* gvr, gvr_sizei size_pixels,
-                             gvr_vec2f meters_per_pixel,
-                             float border_size_meters);
-
-// Sets the display rotation offset that is applied at distortion correction
-// time to take into account the device's display orientation.
-//
-// For instance, calling this with display_output_rotation set to 1 allows
-// clients to lock their phone orientation to portrait on an Android phone and
-// still get a correctly rendered VR mode with the two eyes stacked up along the
-// longer phone dimension.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param display_output_rotation Value encoding the rotation used when
-//     performing distortion correction. Supported values are:
-//     0 - Default mode. Eye viewports are positioned side-by-side along the
-//         "width" dimension, with left eye in the x < 0.5 half.
-//     1 - Applies a clock-wise rotation of 90 degrees on the display when
-//         doing distortion correction. Eye viewports are positioned
-//         side-by-side along the "height" dimension, with left eye in the
-//         y > 0.5 half.
-// Rotation modes used when performing distortion correction.
-enum {
-  GVR_PRIVATE_DISPLAY_OUTPUT_ROTATION_0 = 0,
-  GVR_PRIVATE_DISPLAY_OUTPUT_ROTATION_90 = 1,
-};
-void gvr_set_display_output_rotation(gvr_context* gvr,
-                                     int32_t display_output_rotation);
-
-// Gets the size of the border around the display used by the given gvr_context.
-//
-// @param gvr Pointer to the gvr_context instance.
-float gvr_get_border_size_meters(const gvr_context* gvr);
-
-// Returns whether the surface size was changed since the last call to this
-// function (it's changed with gvr_set_surface_size()).
-//
-// @param gvr Pointer to the gvr_context instance.
-// @return Whether the surface size was changed.
-bool gvr_check_surface_size_changed(gvr_context* gvr);
-
-// Returns the current surface size in pixels, or (0, 0) if the surface size
-// matches that of the active display (which is the default).
-//
-// @param gvr Pointer to the gvr_context instance.
-// @return The current surface size in pixels.
-gvr_sizei gvr_get_surface_size(const gvr_context* gvr);
-
-// Sets a handler that is called back when the back gesture is detected,
-// which is when the phone changes from landscape to portrait orientation
-// within a few seconds.
-//
-// @param gvr Pointer to the gvr_context instance.
-// @param handler The event_handler callback. May be null to clear the
-//     registered event_handler.
-// @param user_data An opaque pointer to user_data which will be supplied
-//     as the callback argument. The caller is responsible for ensuring the
-//     validity of this data for the duration of the handler registration.
-typedef void (*event_handler)(void* user_data);
-void gvr_set_back_gesture_event_handler(gvr_context* gvr, event_handler handler,
-                                        void* user_data);
-
-// Internal method to pause head tracking used by GvrLayout. Disables all
-// sensors (to save power) and gets the serialized tracker state.
-//
-// @param gvr Pointer to the gvr instance for which tracking will be paused and
-//     sensors disabled.
-//
-// @return Pointer to a tracker_state object containing the serialized tracker
-//     state. The caller is responsible for calling destroy on the returned
-//     handle.
-gvr_tracker_state* gvr_pause_tracking_get_state(gvr_context* gvr);
-
-// Internal method to resume head tracking used by GvrLayout. Re-enables all
-// sensors and sets the tracker state.
-//
-// @param gvr Pointer to the gvr instance for which tracking will be resumed.
-//     serialized tracker state object.
-// @param tracker_state Pointer to a tracker_state object containing the
-//     serialized tracker state object.
-void gvr_resume_tracking_set_state(
-    gvr_context* gvr, gvr_tracker_state* tracker_state);
-
-// Sets the internal flag that ignores calls to the public API's
-// gvr_pause_tracking and gvr_resume_tracking.
-// When true, the tracker is handled through GvrLayout
-// gvr_pause_tracking_private / gvr_resume_tracking_private direct calls through
-// the GvrApi instance are ignored. This is workaround to temporarily support
-// clients using GvrLayout that manually call pause/ resume tracking.
-// TODO(b/30404822) : clean this up once all existing clients move away from the
-// obsolete behavior.
-//
-// @param gvr Pointer to the gvr instance.
-// @param should_ignore Whether manual pause / resume tracker should be ignored.
-void gvr_set_ignore_manual_tracker_pause_resume(gvr_context* gvr,
-                                                bool should_ignore);
-
-// Creates a new tracker state object from the serialized tracker state buffer.
-//
-// @param tracker_state_buffer Pointer to buffer containing the serialized
-// tracker state.
-// @param buf_size Size of the tracker state buffer.
-//
-// @return Pointer to a tracker_state object containing the serialized tracker
-// state string. The caller is responsible for calling destroy on the returned
-// handle.
-gvr_tracker_state* gvr_tracker_state_create(const char* tracker_state_buffer,
-                                            size_t buf_size);
-
-// Gets the size of the buffer that is required to hold the serialized
-// gvr_tracker_state.
-//
-// @param Pointer to a gvr_tracker_state object containing the serialized
-// tracker state.
-//
-// @return Size of the buffer,
-size_t gvr_tracker_state_get_buffer_size(gvr_tracker_state* tracker_state);
-
-// Gets the buffer that holds the serialized gvr_tracker_state.
-//
-// @param Pointer to a tracker_state object containing the serialized tracker
-// state.
-//
-// @return Pointer to the buffer.
-const char* gvr_tracker_state_get_buffer(gvr_tracker_state* tracker_state);
-
-// Destroys a gvr_tracker_state instance.
-//
-// @param tracker_state Pointer to a pointer of the gvr_tracker_state instance
-// to be destroyed and nulled.
-void gvr_tracker_state_destroy(gvr_tracker_state** tracker_state);
-
-// Creates a new synchronizer instance.
-//
-// @return synchronizer Pointer to the new gvr_display_synchronizer instance.
-gvr_display_synchronizer* gvr_display_synchronizer_create();
-
-// Destroy the synchonronizer instance and null the pointer.
-//
-// @param synchronizer Pointer to a pointer to the gvr_display_synchronizer
-//     instance.
-void gvr_display_synchronizer_destroy(gvr_display_synchronizer** synchronizer);
-
-// Resets the synchronizer with updated vsync timing data.
-//
-// @param synchronizer Pointer to the new gvr_display_synchronizer instance.
-// @param expected_interval_nanos The expected average time between
-//     synchronization times, in nanoseconds, or 0 if unknown.
-// @param vsync_offset_nanos The duration, in nanos, such that the current sync
-//     time minus the display vsync offset is the time when the physical
-//     scan-out hardware begins to read data from the frame buffer.
-void gvr_display_synchronizer_reset(gvr_display_synchronizer* synchronizer,
-                                    int64_t expected_interval_nanos,
-                                    int64_t vsync_offset_nanos);
-
-// Updates the synchronizer with dispplay data for a new frame.
-//
-// @param vsync_time The new frame's vsync time.
-// @param rotation_degrees The screen rotation from sensor space to display
-//     space in degrees.
-void gvr_display_synchronizer_update(gvr_display_synchronizer* synchronizer,
-                                     gvr_clock_time_point vsync_time,
-                                     int32_t rotation);
-
-// Installs the display synchronizer into a GVR context.
-//
-// @param gvr Pointer to the current gvr_context instance.
-// @param synchronizer Pointer to the gvr_display_synchronizer instance, to be
-//     used by the context implementation during rendering.
-void gvr_set_display_synchronizer(gvr_context* gvr,
-                                  gvr_display_synchronizer* synchronizer);
-
-// Sets the current error code. Overwrites any existing error code.
-//
-// @param gvr Pointer to the current gvr_context instance.
-// @param error_code The error code to set.
-void gvr_set_error(gvr_context* gvr, int32_t error_code);
-
-// Called by the platform layer to to indicate the application is paused. (e.g.
-// On Android, this function is called by GvrLayout.OnPause().)
-//
-// @param gvr Pointer to the current gvr_context instance.
-void gvr_pause(gvr_context* gvr);
-
-// Called by the platform layer to to indicate the application has resumed.
-// (e.g. On Android, this function is called by GvrLayout.OnResume().)
-//
-// @param gvr Pointer to the current gvr_context instance.
-void gvr_resume(gvr_context* gvr);
-
-// Dumps additional data to logcat or disk to be included in bug reports.
-//
-// @param gvr Pointer to the current gvr_context instance.
-void gvr_dump_debug_data(gvr_context* gvr);
-
-// Returns true if the libgvr implementation is using the dedicated VR display
-// service, false otherwise.
-//
-// @param gvr Pointer to the current gvr_context instance.
-bool gvr_using_vr_display_service(gvr_context* gvr);
-
-// Creates a new gvr_context using the supplied tracker, only for testing.
-//
-// Note: The pose returned is *in start space*. This is *not* the same space as
-// the pose normally returned by |gvr_get_head_space_from_start_space_rotation|.
-//
-// @param tracker The test pose tracker to use.
-// @param user_data An opaque pointer to user_data which will be supplied
-//     as the callback argument. The caller is responsible for ensuring the
-//     validity of this data for the duration of the handler registration.
-typedef gvr_mat4f (*gvr_test_pose_tracker)(void*, gvr_clock_time_point);
-gvr_context* gvr_create_with_tracker_for_testing(gvr_test_pose_tracker tracker,
-                                                 void* user_data);
-
-// Request resource sharing between the application's OpenGL context and the
-// scanline racing context.  This must be called before gvr_initialize_gl.
-// <p>
-// This is a best effort request rather than an explicit toggle; it is a no-op
-// if the client does not enable async reprojection, or if the platform does not
-// support resource sharing.
-// <p>
-// The only OpenGL resource that we need sharing for is the framebuffer texture
-// that the app renders to, and that distortion samples from.  If resource
-// sharing is disabled, then we use an EGLImage so that it can be accessed from
-// both contexts.
-// <p>
-// Also sets a callback function that is called at the end of gvr_initialize_gl,
-// while the application's OpenGL context is still active on the current thread.
-// This is used internally to notify the scanline racing renderer that the
-// application's OpenGL context has been created.
-//
-// @param gvr Pointer to the current gvr_context instance.
-// @param handler Callback that gets called when the app context becomes ready.
-// @param user_data An opaque pointer to user data which will be supplied
-//     as the callback argument. The caller is responsible for ensuring the
-//     validity of this data for the duration of the handler registration.
-typedef void (*gvr_egl_context_listener)(void*);
-void gvr_request_context_sharing(gvr_context* gvr,
-                                 gvr_egl_context_listener handler,
-                                 void* user_data);
-
-#ifdef __cplusplus
-}  // extern "C"
-#endif
-
-#endif  // VR_GVR_CAPI_SRC_GVR_PRIVATE_H_
diff --git a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_types_experimental.h b/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_types_experimental.h
deleted file mode 100644
index f7ae6a5..0000000
--- a/libs/vr/libgvr/prebuilt/include/vr/gvr/capi/src/gvr_types_experimental.h
+++ /dev/null
@@ -1,66 +0,0 @@
-#ifndef VR_GVR_CAPI_SRC_GVR_TYPES_EXPERIMENTAL_H_
-#define VR_GVR_CAPI_SRC_GVR_TYPES_EXPERIMENTAL_H_
-
-#include <string>
-
-// ************************************************************************** //
-// *                     DaydreamOS experimental Types                * //
-// ************************************************************************** //
-
-// Visibility of a layer.
-typedef enum {
-  GVR_INVISIBLE = 0,
-  GVR_VISIBLE = 1,
-} gvr_visibility;
-
-// Whether to blur layers behind a layer.
-typedef enum {
-  GVR_BLUR_BEHIND_FALSE = 0,
-  GVR_BLUR_BEHIND_TRUE = 1,
-} gvr_blur_behind;
-
-// GVR external surface
-typedef struct gvr_external_surface_ gvr_external_surface;
-
-// ************************************************************************** //
-// *                     Daydream PlexEng experimental Types                * //
-// ************************************************************************** //
-
-// Types of events that can have callbacks registered.
-// If documented, type will return a payload value when called, or will
-// otherwise be invoked with -1.f.
-// This enum has to be duplicated because there is no way to include from
-// /vr/gvr/render/performance_registry.h.  Duplicate changes made here there.
-typedef enum {
-  // Will be invoked with value -1.f.
-  GVR_ON_ASYNC_REPROJECTION_FRAME_START = 0,
-  // Will be invoked with value -1.f.
-  GVR_ON_ASYNC_REPROJECTION_FRAME_STOP = 1,
-  // When invoked will be called with how late in microseconds the frame was.
-  GVR_ON_ASYNC_REPROJECTION_FRAME_DROP = 2,
-  // The number of types of performance events you can have.
-  // Also note that this value is considered invalid.
-  GVR_NUM_PERF_EVENT_CALLBACK_TYPES = 3,
-} gvr_perf_event_callback_type;
-
-// Experimental VR-specific features which may or may not be supported on the
-// underlying platform.  These values should not overlap with current or future
-// gvr_feature values, so we're starting with 1000000 and increasing upward.
-typedef enum {
-  // Head tracking with 6 degrees of freedom (position & rotation)
-  GVR_FEATURE_HEAD_POSE_6DOF = 1000000,
-} gvr_experimental_feature;
-
-// ************************************************************************** //
-// *                    GVR Analytics experimental APIs                     * //
-// ************************************************************************** //
-
-// Opaque struct returned by gvr_analytics_create_sample, used to transmit an
-// AnaylticsSample proto across the native layer.
-typedef struct gvr_analytics_sample_ {
-  // Serialized AnalyticsSample proto. Note that this is not a C string, meaning
-  // it is not null-terminated and may contain non-terminating nulls.
-  std::string serialized_proto;
-} gvr_analytics_sample;
-
-#endif  // VR_GVR_CAPI_SRC_GVR_TYPES_EXPERIMENTAL_H_
diff --git a/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr.so b/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr.so
deleted file mode 100644
index bfd5956..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr_audio.so b/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr_audio.so
deleted file mode 100644
index c3012b1..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_arm/libgvr_audio.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr.so b/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr.so
deleted file mode 100644
index 6608c25..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr_audio.so b/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr_audio.so
deleted file mode 100644
index b1d7690..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_arm64/libgvr_audio.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr.so b/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr.so
deleted file mode 100644
index f7f7786..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr_audio.so b/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr_audio.so
deleted file mode 100644
index 97aec40..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_x86/libgvr_audio.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr.so b/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr.so
deleted file mode 100644
index 2e2dbc1..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr_audio.so b/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr_audio.so
deleted file mode 100644
index cd8d0e0..0000000
--- a/libs/vr/libgvr/prebuilt/lib/android_x86_64/libgvr_audio.so
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/prebuilt/lib/common_library.aar b/libs/vr/libgvr/prebuilt/lib/common_library.aar
deleted file mode 100644
index 9c1fbd0..0000000
--- a/libs/vr/libgvr/prebuilt/lib/common_library.aar
+++ /dev/null
Binary files differ
diff --git a/libs/vr/libgvr/shim_gvr.cpp b/libs/vr/libgvr/shim_gvr.cpp
deleted file mode 100644
index 5eb6e3d..0000000
--- a/libs/vr/libgvr/shim_gvr.cpp
+++ /dev/null
@@ -1,1352 +0,0 @@
-#define LOG_TAG "libgvr_shim"
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#include <GLES3/gl31.h>
-#include <GLES3/gl3ext.h>
-#include <algorithm>
-#include <cmath>
-
-#ifdef __ARM_NEON
-#include <arm_neon.h>
-#else
-#ifndef __FLOAT32X4T_86
-#define __FLOAT32X4T_86
-typedef float float32x4_t __attribute__ ((__vector_size__ (16)));
-typedef struct float32x4x4_t { float32x4_t val[4]; };
-#endif
-#endif
-
-#include <dvr/graphics.h>
-#include <dvr/performance_client_api.h>
-#include <dvr/pose_client.h>
-#include <log/log.h>
-#include <private/dvr/buffer_hub_queue_core.h>
-#include <private/dvr/buffer_hub_queue_producer.h>
-#include <private/dvr/clock_ns.h>
-#include <private/dvr/display_client.h>
-#include <private/dvr/graphics_private.h>
-#include <private/dvr/internal_types.h>
-#include <private/dvr/numeric.h>
-#include <private/dvr/types.h>
-#include <private/dvr/video_mesh_surface_client.h>
-#include <sys/system_properties.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/include/gvr_ext.h>
-#include <vr/gvr/capi/include/gvr_util.h>
-#include <vr/gvr/capi/src/gvr_experimental.h>
-#include <vr/gvr/capi/src/gvr_private.h>
-
-#include <android_runtime/android_view_Surface.h>
-#include <gui/Surface.h>
-
-using android::dvr::DisplayClient;
-using android::dvr::EigenToGvrMatrix;
-using android::dvr::FieldOfView;
-using android::dvr::FovRadiansToDegrees;
-using android::dvr::GetSystemClockNs;
-using android::dvr::GvrIdentityMatrix;
-using android::dvr::GvrMatrixToPosef;
-using android::dvr::GvrToDvrFov;
-using android::dvr::GvrToEigenMatrix;
-using android::dvr::GvrToEigenRotation;
-using android::dvr::GvrTranslationMatrix;
-using android::dvr::IsEqual;
-using android::dvr::PosefToGvrMatrix;
-using android::dvr::mat3;
-using android::dvr::mat4;
-using android::dvr::Posef;
-using android::dvr::quat;
-using android::dvr::vec3;
-
-namespace {
-
-constexpr static int32_t GVR_SDK_MAJOR_VERSION = 2;
-constexpr static int32_t GVR_SDK_MINOR_VERSION = 0;
-constexpr static int32_t GVR_SDK_PATCH_VERSION = 0;
-
-// The "DaydreamOS" part has been appended to make easier to see when VrCore
-// dynamic GVR API loading is effectively working.
-static const char* kVersionString = "2.0.0 DaydreamOS";
-static const char* kViewerVendor = "Google";
-static const char* kViewerModel = "Lucid";
-
-// Experimental system property used to provide 6DoF information on 3DoF APIs.
-static const char* kForce6DofProp = "experimental.force_6dof";
-
-static constexpr int kControllerCount = 2;
-
-gvr_frame* GetFrameFromSwapChain(gvr_swap_chain* swap_chain) {
-  return reinterpret_cast<gvr_frame*>(swap_chain);
-}
-
-gvr_swap_chain* GetSwapChainForFrame(gvr_frame* frame) {
-  return reinterpret_cast<gvr_swap_chain*>(frame);
-}
-
-const gvr_swap_chain* GetSwapChainForFrame(const gvr_frame* frame) {
-  return reinterpret_cast<const gvr_swap_chain*>(frame);
-}
-
-// Returns the world to head transform as a Posef.
-Posef ToPosef(const DvrPoseAsync& pose) {
-  return Posef(
-      quat(pose.orientation[3], pose.orientation[0], pose.orientation[1],
-           pose.orientation[2]),
-      vec3(pose.translation[0], pose.translation[1], pose.translation[2]));
-}
-
-// Returns the world to head transform, with 0 position, as a gvr matrix
-gvr_mat4f Gvr6dofTo3dof(const gvr_mat4f& pose) {
-  gvr_mat4f ret = pose;
-  ret.m[0][3] = 0;
-  ret.m[1][3] = 0;
-  ret.m[2][3] = 0;
-  return ret;
-}
-
-void GvrToDvrPose(gvr_mat4f world_to_head_transform,
-                  /*out*/ float32x4_t* orientation,
-                  /*out */ float32x4_t* translation) {
-  Posef pose = GvrMatrixToPosef(world_to_head_transform);
-  (*orientation)[0] = pose.GetRotation().x();
-  (*orientation)[1] = pose.GetRotation().y();
-  (*orientation)[2] = pose.GetRotation().z();
-  (*orientation)[3] = pose.GetRotation().w();
-  (*translation)[0] = pose.GetPosition().x();
-  (*translation)[1] = pose.GetPosition().y();
-  (*translation)[2] = pose.GetPosition().z();
-  (*translation)[3] = 0;
-}
-
-bool MatricesAlmostEqual(const gvr_mat4f& m1, const gvr_mat4f& m2,
-                         float tolerance) {
-  for (int row = 0; row < 4; ++row) {
-    for (int col = 0; col < 4; ++col) {
-      if (!IsEqual(m1.m[row][col], m2.m[row][col], tolerance))
-        return false;
-    }
-  }
-  return true;
-}
-
-gvr_mat4f FovToViewportTransform(const gvr_rectf& fov) {
-  // Depth range (1 1000) is chosen to match gvr impl in google3, which is
-  // chosen to match Unity integration.
-  return EigenToGvrMatrix(
-      GvrToDvrFov(fov).GetProjectionMatrix(1.f, 1000.f).inverse());
-}
-
-gvr_rectf ViewportTransformToFov(const gvr_mat4f& transform) {
-  return DvrToGvrFov(
-      FieldOfView::FromProjectionMatrix(GvrToEigenMatrix(transform).inverse()));
-}
-
-bool GetGlColorFormat(int32_t gvr_color_format,
-                      /*out*/ GLenum* gl_color_format) {
-  switch (gvr_color_format) {
-    case GVR_COLOR_FORMAT_RGBA_8888:
-      *gl_color_format = GL_RGBA8;
-      break;
-    case GVR_COLOR_FORMAT_RGB_565:
-      *gl_color_format = GL_RGB565;
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-
-bool GetGlDepthFormat(int32_t gvr_depth_format,
-                      /*out*/ GLenum* gl_depth_format) {
-  switch (gvr_depth_format) {
-    case GVR_DEPTH_STENCIL_FORMAT_DEPTH_16:
-      *gl_depth_format = GL_DEPTH_COMPONENT16;
-      break;
-    case GVR_DEPTH_STENCIL_FORMAT_DEPTH_24:
-      *gl_depth_format = GL_DEPTH_COMPONENT24;
-      break;
-    case GVR_DEPTH_STENCIL_FORMAT_DEPTH_24_STENCIL_8:
-      *gl_depth_format = GL_DEPTH24_STENCIL8;
-      break;
-    case GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F:
-      *gl_depth_format = GL_DEPTH_COMPONENT32F;
-      break;
-    case GVR_DEPTH_STENCIL_FORMAT_DEPTH_32_F_STENCIL_8:
-      *gl_depth_format = GL_DEPTH32F_STENCIL8;
-      break;
-    default:
-      return false;
-  }
-  return true;
-}
-
-// Returns true on success, false on failure. If the swap_chain already has a
-// DvrGraphicsContext and gvr buffer, they'll be freed first. If creation fails,
-// the DvrGraphicsContext in the swap_chain will be set to null and the
-// corresponding gvr buffer will be freed.
-bool CreateDvrGraphicsContextAndGvrBuffer(gvr_swap_chain* swap_chain) {
-  if (swap_chain->buffers_.empty()) {
-    ALOGE("Can't create a graphics context for an empty swap chain");
-    return false;
-  }
-
-  // We currently only render the first gvr buffer. Create a DvrGraphicsContext
-  // for the first buffer only.
-  gvr_buffer& buf = swap_chain->buffers_[0];
-  buf.FreeGl();
-
-  bool visible;
-  int z_order;
-  if (swap_chain->graphics_context_ != nullptr) {
-    visible = dvrGraphicsSurfaceGetVisible(swap_chain->graphics_context_);
-    z_order = dvrGraphicsSurfaceGetZOrder(swap_chain->graphics_context_);
-    dvrGraphicsContextDestroy(swap_chain->graphics_context_);
-    swap_chain->graphics_context_ = nullptr;
-  } else {
-    visible = buf.spec.initially_visible;
-    z_order = buf.spec.z_order;
-  }
-
-  int width = 0, height = 0;
-  GLuint texture_id = 0;
-  GLenum texture_target = 0;
-  DvrSurfaceParameter surface_params[] = {
-      DVR_SURFACE_PARAMETER_IN(DISABLE_DISTORTION, false),
-      DVR_SURFACE_PARAMETER_IN(CREATE_GL_CONTEXT, 0),
-      DVR_SURFACE_PARAMETER_IN(WIDTH, buf.spec.size.width),
-      DVR_SURFACE_PARAMETER_IN(HEIGHT, buf.spec.size.height),
-      DVR_SURFACE_PARAMETER_IN(BLUR_BEHIND, buf.spec.blur_behind),
-      DVR_SURFACE_PARAMETER_IN(VISIBLE, visible),
-      DVR_SURFACE_PARAMETER_IN(Z_ORDER, z_order),
-      DVR_SURFACE_PARAMETER_OUT(SURFACE_WIDTH, &width),
-      DVR_SURFACE_PARAMETER_OUT(SURFACE_HEIGHT, &height),
-      DVR_SURFACE_PARAMETER_OUT(SURFACE_TEXTURE_TARGET_TYPE, &texture_target),
-      DVR_SURFACE_PARAMETER_OUT(SURFACE_TEXTURE_TARGET_ID, &texture_id),
-      DVR_SURFACE_PARAMETER_LIST_END,
-  };
-
-  DvrGraphicsContext* graphics_context;
-  int ret = dvrGraphicsContextCreate(surface_params, &graphics_context);
-  if (ret < 0) {
-    ALOGE("dvrGraphicsContextCreate failed: %d (%s)", ret, strerror(-ret));
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    return false;
-  }
-
-  // Sanity check that the size of the buffer we allocated from the system is
-  // what we expect
-  if (buf.spec.size != gvr_sizei{width, height}) {
-    ALOGE(
-        "The created surface is the wrong size."
-        " Should be %dx%d, instead got %dx%d.",
-        buf.spec.size.width, buf.spec.size.height, width, height);
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    dvrGraphicsContextDestroy(graphics_context);
-    return false;
-  }
-
-  buf = gvr_buffer(swap_chain->context, buf.spec, texture_id, texture_target);
-  if (buf.frame_buffer == 0) {
-    dvrGraphicsContextDestroy(graphics_context);
-    return false;
-  }
-
-  swap_chain->graphics_context_ = graphics_context;
-  return true;
-}
-
-bool SwapChainResizeBuffer(gvr_swap_chain* swap_chain, int buffer_index) {
-  gvr_buffer& buf = swap_chain->buffers_[buffer_index];
-  buf.FreeGl();
-  gvr_sizei orig_size = buf.spec.size;
-  buf.spec.size = buf.requested_size;
-  bool resize_successful = false;
-  if (buffer_index == 0) {
-    resize_successful = CreateDvrGraphicsContextAndGvrBuffer(swap_chain);
-  } else {
-    buf = gvr_buffer(swap_chain->context, buf.spec, 0, GL_TEXTURE_2D);
-    resize_successful = buf.frame_buffer != 0;
-  }
-
-  if (resize_successful) {
-    // The resize was successful, so clear the resize request
-    buf.requested_size = {-1, -1};
-  } else {
-    ALOGE("Failed to resize buffer. orig_size=%dx%d requested_size=%dx%d.",
-          orig_size.width, orig_size.height, buf.requested_size.width,
-          buf.requested_size.height);
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    buf.spec.size = orig_size;
-  }
-
-  return resize_successful;
-}
-
-void WaitNextFrame(gvr_swap_chain* swap_chain, int64_t start_delay_nanos,
-                   gvr_frame_schedule* out_next_frame_schedule,
-                   bool called_by_app) {
-  if (called_by_app)
-    swap_chain->wait_next_frame_called_by_app_ = true;
-
-  DvrFrameSchedule dvr_schedule;
-  int ret = dvrGraphicsWaitNextFrame(swap_chain->graphics_context_,
-                                     start_delay_nanos, &dvr_schedule);
-  if (ret < 0) {
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    return;
-  }
-  if (out_next_frame_schedule) {
-    out_next_frame_schedule->vsync_count = dvr_schedule.vsync_count;
-    out_next_frame_schedule->scheduled_finish.monotonic_system_time_nanos =
-        dvr_schedule.scheduled_frame_finish_ns;
-  }
-
-  DvrPoseAsync pose;
-  ret = dvrPoseGet(swap_chain->context->pose_client_, dvr_schedule.vsync_count,
-                   &pose);
-  if (ret < 0) {
-    ALOGW("dvrPoseGet failed: %d", ret);
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    return;
-  }
-
-  swap_chain->context->next_frame_6dof_pose_ = PosefToGvrMatrix(ToPosef(pose));
-
-  for (int i = 0; i < kControllerCount; ++i) {
-    ret = dvrPoseGetController(swap_chain->context->pose_client_, i,
-                               dvr_schedule.vsync_count, &pose);
-    if (ret == 0) {
-      // Silently fail when there are no controllers.
-      swap_chain->context->next_frame_controller_pose_[i] =
-          PosefToGvrMatrix(ToPosef(pose).Inverse());
-    }
-  }
-}
-
-bool VerifyBufferIndex(const std::string& function_name,
-                       const gvr_swap_chain* swap_chain, int index) {
-  if (index > static_cast<int32_t>(swap_chain->buffers_.size())) {
-    ALOGE("%s out of range buffer index. index=%d num_buffers=%zu.",
-          function_name.c_str(), index, swap_chain->buffers_.size());
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    return false;
-  }
-  return true;
-}
-
-}  // anonymous namespace
-
-gvr_context* gvr_create(JNIEnv* env, jobject /* app_context */,
-                        jobject /* class_loader */) {
-  std::unique_ptr<gvr_context> context(new gvr_context);
-
-  // Set cpu set to avoid default scheduling randomness.
-  dvrSetCpuPartition(0, "/application/performance");
-
-  context->jni_env_ = env;
-  context->pose_client_ = dvrPoseCreate();
-  if (!context->pose_client_) {
-    ALOGE("Failed to create pose client");
-    return nullptr;
-  }
-
-  context->display_client_ = DisplayClient::Create();
-  if (!context->display_client_) {
-    ALOGE("Failed to create display client");
-    return nullptr;
-  }
-
-  int ret =
-      context->display_client_->GetDisplayMetrics(&context->display_metrics_);
-  if (ret < 0) {
-    ALOGE("Failed to get display metrics: %d (%s)", ret, strerror(-ret));
-    return nullptr;
-  }
-
-  const float* left_fov = context->display_metrics_.left_fov_lrbt.data();
-  context->left_eye_viewport_transform_ =
-      FovToViewportTransform(FovRadiansToDegrees(
-          gvr_rectf{left_fov[0], left_fov[1], left_fov[2], left_fov[3]}));
-
-  const float* right_fov = context->display_metrics_.right_fov_lrbt.data();
-  context->right_eye_viewport_transform_ =
-      FovToViewportTransform(FovRadiansToDegrees(
-          gvr_rectf{right_fov[0], right_fov[1], right_fov[2], right_fov[3]}));
-
-  context->next_frame_6dof_pose_ = GvrIdentityMatrix();
-
-  for (int i = 0; i < kControllerCount; ++i) {
-    context->next_frame_controller_pose_[i] = GvrIdentityMatrix();
-  }
-
-  // Check the system property to force 6DoF when requested 3DoF.
-  char prop_buffer[PROP_VALUE_MAX];
-  if (__system_property_get(kForce6DofProp, prop_buffer) &&
-      (!strncasecmp("1", prop_buffer, PROP_VALUE_MAX) ||
-       !strncasecmp("true", prop_buffer, PROP_VALUE_MAX))) {
-    context->force_6dof_ = true;
-  }
-
-  return context.release();
-}
-
-gvr_version gvr_get_version() {
-  gvr_version version = {};
-  version.major = GVR_SDK_MAJOR_VERSION;
-  version.minor = GVR_SDK_MINOR_VERSION;
-  version.patch = GVR_SDK_PATCH_VERSION;
-  return version;
-}
-
-const char* gvr_get_version_string() { return kVersionString; }
-
-int32_t gvr_get_error(gvr_context* gvr) { return gvr->last_error_; }
-
-int32_t gvr_clear_error(gvr_context* gvr) {
-  int32_t last_error = gvr->last_error_;
-  gvr->last_error_ = GVR_ERROR_NONE;
-  return last_error;
-}
-
-const char* gvr_get_error_string(int32_t error_code) {
-  switch (error_code) {
-    case GVR_ERROR_NONE:
-      return "No error";
-    case GVR_ERROR_CONTROLLER_CREATE_FAILED:
-      return "Creation of GVR controller context failed";
-    case GVR_ERROR_NO_FRAME_AVAILABLE:
-      return "No frame available in swap chain";
-    case GVR_ERROR_INTERNAL:
-      return "Internal error";
-    default:
-      return "(Internal error: unknown error code)";
-  }
-}
-
-const gvr_user_prefs* gvr_get_user_prefs(gvr_context* gvr) {
-  return &gvr->user_prefs_;
-}
-
-int32_t gvr_user_prefs_get_controller_handedness(
-    const gvr_user_prefs* /* user_prefs */) {
-  return GVR_CONTROLLER_RIGHT_HANDED;
-}
-
-gvr_context_::~gvr_context_() {
-  for (gvr_swap_chain* swap_chain : swap_chains_)
-    swap_chain->context = nullptr;
-  if (pose_client_)
-    dvrPoseDestroy(pose_client_);
-}
-
-void gvr_destroy(gvr_context** gvr) {
-  if (!gvr || !(*gvr)) {
-    ALOGW("gvr_destroy: Invalid gvr_context pointer.");
-    return;
-  }
-  delete *gvr;
-  *gvr = nullptr;
-}
-
-void gvr_initialize_gl(gvr_context* /* gvr */) {}
-
-bool gvr_get_async_reprojection_enabled(const gvr_context* /* gvr */) {
-  return true;
-}
-
-void gvr_get_recommended_buffer_viewports(
-    const gvr_context* gvr, gvr_buffer_viewport_list* viewport_list) {
-  gvr_buffer_viewport left(
-      /*buffer_index*/ 0,
-      /*uv*/ {0, .5f, 0, 1}, gvr->left_eye_viewport_transform_, GVR_LEFT_EYE,
-      GVR_EXTERNAL_SURFACE_ID_NONE, GVR_REPROJECTION_FULL);
-
-  gvr_buffer_viewport right(
-      /*buffer_index*/ 0,
-      /*uv*/ {.5f, 1, 0, 1}, gvr->right_eye_viewport_transform_, GVR_RIGHT_EYE,
-      GVR_EXTERNAL_SURFACE_ID_NONE, GVR_REPROJECTION_FULL);
-
-  viewport_list->viewports.resize(2);
-  viewport_list->viewports[0] = left;
-  viewport_list->viewports[1] = right;
-}
-
-void gvr_get_screen_buffer_viewports(const gvr_context* gvr,
-                                     gvr_buffer_viewport_list* viewport_list) {
-  gvr_get_recommended_buffer_viewports(gvr, viewport_list);
-}
-
-gvr_sizei gvr_get_maximum_effective_render_target_size(const gvr_context* gvr) {
-  return gvr_sizei{
-      static_cast<int32_t>(gvr->display_metrics_.distorted_width),
-      static_cast<int32_t>(gvr->display_metrics_.distorted_height)};
-}
-
-gvr_sizei gvr_get_screen_target_size(const gvr_context* gvr) {
-  // DisplayMetrics returns native_width and native_height for the display in
-  // portrait orientation, which our device is never in. Swap the width and
-  // height to account for this.
-  return gvr_sizei{
-      static_cast<int32_t>(gvr->display_metrics_.display_native_height),
-      static_cast<int32_t>(gvr->display_metrics_.display_native_width)};
-}
-
-void gvr_set_surface_size(gvr_context* gvr,
-                          gvr_sizei /* surface_size_pixels */) {
-  // TODO(leandrogracia): this needs to be properly implemented.
-  ALOGE("gvr_set_surface_size not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-void gvr_distort_to_screen(
-    gvr_context* gvr, int32_t /* texture_id */,
-    const gvr_buffer_viewport_list* /* viewport_list */,
-    gvr_mat4f /* head_space_from_start_space */,
-    gvr_clock_time_point /* target_presentation_time */) {
-  // TODO(leandrogracia): this needs to be properly implemented.
-  ALOGE("gvr_distort_to_screen not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-bool gvr_is_feature_supported(const gvr_context* /*gvr*/, int32_t feature) {
-  return feature == GVR_FEATURE_ASYNC_REPROJECTION ||
-      feature == GVR_FEATURE_HEAD_POSE_6DOF;
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Viewports and viewport lists
-/////////////////////////////////////////////////////////////////////////////
-
-bool gvr_buffer_viewport::operator==(const gvr_buffer_viewport_& other) const {
-  return buffer_index == other.buffer_index && uv == other.uv &&
-         eye == other.eye && external_surface_id == other.external_surface_id &&
-         reprojection == other.reprojection &&
-         MatricesAlmostEqual(transform, other.transform, 1e-5f);
-}
-
-gvr_buffer_viewport* gvr_buffer_viewport_create(gvr_context* /* gvr */) {
-  return new gvr_buffer_viewport;
-}
-
-void gvr_buffer_viewport_destroy(gvr_buffer_viewport** viewport) {
-  if (viewport) {
-    delete *viewport;
-    *viewport = nullptr;
-  }
-}
-
-gvr_rectf gvr_buffer_viewport_get_source_uv(
-    const gvr_buffer_viewport* viewport) {
-  return viewport->uv;
-}
-
-void gvr_buffer_viewport_set_source_uv(gvr_buffer_viewport* viewport,
-                                       gvr_rectf uv) {
-  viewport->uv = uv;
-}
-
-gvr_rectf gvr_buffer_viewport_get_source_fov(
-    const gvr_buffer_viewport* viewport) {
-  return ViewportTransformToFov(viewport->transform);
-}
-
-void gvr_buffer_viewport_set_source_fov(gvr_buffer_viewport* viewport,
-                                        gvr_rectf fov) {
-  viewport->transform = FovToViewportTransform(fov);
-}
-
-gvr_mat4f gvr_buffer_viewport_get_transform(
-    const gvr_buffer_viewport* viewport) {
-  return viewport->transform;
-}
-
-void gvr_buffer_viewport_set_transform(gvr_buffer_viewport* viewport,
-                                       gvr_mat4f transform) {
-  viewport->transform = transform;
-}
-
-int32_t gvr_buffer_viewport_get_target_eye(
-    const gvr_buffer_viewport* viewport) {
-  return viewport->eye;
-}
-
-void gvr_buffer_viewport_set_target_eye(gvr_buffer_viewport* viewport,
-                                        int32_t index) {
-  viewport->eye = index;
-}
-
-int32_t gvr_buffer_viewport_get_source_buffer_index(
-    const gvr_buffer_viewport* viewport) {
-  return viewport->buffer_index;
-}
-
-void gvr_buffer_viewport_set_source_buffer_index(gvr_buffer_viewport* viewport,
-                                                 int32_t buffer_index) {
-  viewport->buffer_index = buffer_index;
-}
-
-int32_t gvr_buffer_viewport_get_external_surface_id(
-    const gvr_buffer_viewport* viewport) {
-  return viewport->external_surface_id;
-}
-
-void gvr_buffer_viewport_set_external_surface_id(gvr_buffer_viewport* viewport,
-                                                 int32_t external_surface_id) {
-  viewport->external_surface_id = external_surface_id;
-}
-
-int32_t gvr_buffer_viewport_get_reprojection(
-    const gvr_buffer_viewport* viewport) {
-  return viewport->reprojection;
-}
-
-void gvr_buffer_viewport_set_reprojection(gvr_buffer_viewport* viewport,
-                                          int32_t reprojection) {
-  viewport->reprojection = static_cast<gvr_reprojection>(reprojection);
-}
-
-bool gvr_buffer_viewport_equal(const gvr_buffer_viewport* a,
-                               const gvr_buffer_viewport* b) {
-  return *a == *b;
-}
-
-gvr_buffer_viewport_list* gvr_buffer_viewport_list_create(
-    const gvr_context* /* gvr */) {
-  return new gvr_buffer_viewport_list;
-}
-
-void gvr_buffer_viewport_list_destroy(
-    gvr_buffer_viewport_list** viewport_list) {
-  if (!viewport_list || !(*viewport_list)) {
-    ALOGW("gvr_buffer_viewport_list_destroy: Invalid list pointer.");
-    return;
-  }
-  delete *viewport_list;
-  *viewport_list = nullptr;
-}
-
-size_t gvr_buffer_viewport_list_get_size(
-    const gvr_buffer_viewport_list* viewport_list) {
-  return viewport_list->viewports.size();
-}
-
-void gvr_buffer_viewport_list_get_item(
-    const gvr_buffer_viewport_list* viewport_list, size_t index,
-    gvr_buffer_viewport* viewport) {
-  *viewport = viewport_list->viewports[index];
-}
-
-void gvr_buffer_viewport_list_set_item(gvr_buffer_viewport_list* viewport_list,
-                                       size_t index,
-                                       const gvr_buffer_viewport* viewport) {
-  if (index < viewport_list->viewports.size())
-    viewport_list->viewports[index] = *viewport;
-  else
-    viewport_list->viewports.push_back(*viewport);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Swapchains and frames
-/////////////////////////////////////////////////////////////////////////////
-
-gvr_buffer_spec* gvr_buffer_spec_create(gvr_context* /* gvr */) {
-  return new gvr_buffer_spec;
-}
-
-void gvr_buffer_spec_destroy(gvr_buffer_spec** spec) {
-  if (spec) {
-    delete *spec;
-    *spec = nullptr;
-  }
-}
-
-gvr_sizei gvr_buffer_spec_get_size(const gvr_buffer_spec* spec) {
-  return spec->size;
-}
-
-void gvr_buffer_spec_set_size(gvr_buffer_spec* spec, gvr_sizei size) {
-  spec->size = size;
-}
-
-int32_t gvr_buffer_spec_get_samples(const gvr_buffer_spec* spec) {
-  return spec->msaa_samples;
-}
-
-void gvr_buffer_spec_set_samples(gvr_buffer_spec* spec, int32_t num_samples) {
-  spec->msaa_samples = num_samples;
-}
-
-void gvr_buffer_spec_set_color_format(gvr_buffer_spec* spec,
-                                      int32_t color_format) {
-  spec->color_format = color_format;
-}
-
-void gvr_buffer_spec_set_depth_stencil_format(gvr_buffer_spec* spec,
-                                              int32_t depth_stencil_format) {
-  spec->depth_stencil_format = depth_stencil_format;
-}
-
-void gvr_buffer_spec_set_z_order(gvr_buffer_spec* spec, int z_order) {
-  spec->z_order = z_order;
-}
-
-void gvr_buffer_spec_set_visibility(gvr_buffer_spec* spec,
-                                    int32_t visibility) {
-  spec->initially_visible = (visibility != GVR_INVISIBLE);
-}
-
-void gvr_buffer_spec_set_blur_behind(gvr_buffer_spec* spec,
-                                     int32_t blur_behind) {
-  spec->blur_behind = (blur_behind != GVR_BLUR_BEHIND_FALSE);
-}
-
-void gvr_buffer::SetDefaults() {
-  spec = gvr_buffer_spec();
-  frame_buffer = 0;
-  color_render_buffer = 0;
-  depth_stencil_render_buffer = 0;
-  requested_size = {-1, -1};
-}
-
-gvr_buffer::gvr_buffer() { SetDefaults(); }
-
-gvr_buffer::gvr_buffer(gvr_context* gvr, const gvr_buffer_spec& spec_in,
-                       GLuint texture_id, GLenum texture_target) {
-  SetDefaults();
-  spec = spec_in;
-
-  glGetError();  // Clear error state
-  glGenFramebuffers(1, &frame_buffer);
-  glBindFramebuffer(GL_FRAMEBUFFER, frame_buffer);
-
-  if (texture_id == 0) {
-    GLenum gl_color_format;
-    if (!GetGlColorFormat(spec.color_format, &gl_color_format)) {
-      ALOGE("Unknown color format: %d", spec.color_format);
-      gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-      FreeGl();
-      return;
-    }
-
-    glGenRenderbuffers(1, &color_render_buffer);
-    glBindRenderbuffer(GL_RENDERBUFFER, color_render_buffer);
-    if (spec.msaa_samples < 2) {
-      glRenderbufferStorage(GL_RENDERBUFFER, gl_color_format, spec.size.width,
-                            spec.size.height);
-    } else {
-      glRenderbufferStorageMultisample(GL_RENDERBUFFER, spec.msaa_samples,
-                                       gl_color_format, spec.size.width,
-                                       spec.size.height);
-    }
-    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                              GL_RENDERBUFFER, color_render_buffer);
-  } else {
-    if (spec.msaa_samples < 2) {
-      glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                             texture_target, texture_id, 0);
-    } else {
-      glFramebufferTexture2DMultisampleEXT(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
-                                           texture_target, texture_id, 0,
-                                           spec.msaa_samples);
-    }
-  }
-
-  if (spec.depth_stencil_format != GVR_DEPTH_STENCIL_FORMAT_NONE) {
-    GLenum gl_depth_format;
-    if (!GetGlDepthFormat(spec.depth_stencil_format, &gl_depth_format)) {
-      ALOGE("Unknown depth/stencil format: %d", spec.depth_stencil_format);
-      gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-      FreeGl();
-      return;
-    }
-
-    glGenRenderbuffers(1, &depth_stencil_render_buffer);
-    glBindRenderbuffer(GL_RENDERBUFFER, depth_stencil_render_buffer);
-    if (spec.msaa_samples < 2) {
-      glRenderbufferStorage(GL_RENDERBUFFER, gl_depth_format, spec.size.width,
-                            spec.size.height);
-    } else {
-      glRenderbufferStorageMultisample(GL_RENDERBUFFER, spec.msaa_samples,
-                                       gl_depth_format, spec.size.width,
-                                       spec.size.height);
-    }
-    glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
-                              GL_RENDERBUFFER, depth_stencil_render_buffer);
-  }
-
-  GLenum gl_error = glGetError();
-  if (gl_error != GL_NO_ERROR) {
-    ALOGE("GL error after creating framebuffer: %d", gl_error);
-    gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-    FreeGl();
-    return;
-  }
-
-  GLenum framebuffer_complete_result = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-  if (framebuffer_complete_result != GL_FRAMEBUFFER_COMPLETE) {
-    ALOGE("Framebuffer setup failed. glCheckFramebufferStatus returned %d",
-          framebuffer_complete_result);
-    gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-    FreeGl();
-    return;
-  }
-}
-
-void gvr_buffer::FreeGl() {
-  if (frame_buffer != 0) {
-    glDeleteFramebuffers(1, &frame_buffer);
-    frame_buffer = 0;
-  }
-  if (color_render_buffer != 0) {
-    glDeleteRenderbuffers(1, &color_render_buffer);
-    color_render_buffer = 0;
-  }
-  if (depth_stencil_render_buffer != 0) {
-    glDeleteRenderbuffers(1, &depth_stencil_render_buffer);
-    depth_stencil_render_buffer = 0;
-  }
-}
-
-gvr_buffer::~gvr_buffer() { FreeGl(); }
-
-gvr_buffer::gvr_buffer(gvr_buffer&& other) {
-  spec = other.spec;
-  frame_buffer = other.frame_buffer;
-  color_render_buffer = other.color_render_buffer;
-  depth_stencil_render_buffer = other.depth_stencil_render_buffer;
-  requested_size = other.requested_size;
-  other.SetDefaults();
-}
-
-gvr_buffer& gvr_buffer::operator=(gvr_buffer&& other) {
-  if (this == &other)
-    return *this;
-  spec = other.spec;
-  frame_buffer = other.frame_buffer;
-  color_render_buffer = other.color_render_buffer;
-  depth_stencil_render_buffer = other.depth_stencil_render_buffer;
-  requested_size = other.requested_size;
-  other.SetDefaults();
-  return *this;
-}
-
-gvr_swap_chain* gvr_swap_chain_create(gvr_context* gvr,
-                                      const gvr_buffer_spec** buffers,
-                                      int32_t count) {
-  if (count == 0) {
-    ALOGE("At least one buffer must be requested");
-    gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-    return nullptr;
-  }
-
-  // We only support one buffer, but it's common for gvr apps to use more than
-  // one. Print an error to the log if the app requests more than one buffer,
-  // but continue on. We'll only render the first buffer in that case.
-  if (count > 1) {
-    ALOGE(
-        "Only one buffer is supported but the app requested %d."
-        " Only the first buffer will be rendered.",
-        count);
-  }
-
-  std::unique_ptr<gvr_swap_chain> swap_chain(new gvr_swap_chain(gvr));
-
-  // The first buffer gets a DvrGraphicsContext, which contains the surface we
-  // pass to displayd for rendering.
-  swap_chain->buffers_.push_back(gvr_buffer());
-  swap_chain->buffers_.back().spec = *buffers[0];
-  if (!CreateDvrGraphicsContextAndGvrBuffer(swap_chain.get()))
-    return nullptr;
-
-  // The rest of the buffers, which we don't render for now, get color render
-  // buffers.
-  for (int i = 1; i < count; ++i) {
-    swap_chain->buffers_.push_back(
-        gvr_buffer(gvr, *buffers[i], 0, GL_TEXTURE_2D));
-    if (swap_chain->buffers_.back().frame_buffer == 0)
-      return nullptr;
-  }
-
-  gvr->swap_chains_.push_back(swap_chain.get());
-  return swap_chain.release();
-}
-
-gvr_swap_chain_::~gvr_swap_chain_() {
-  if (context) {
-    auto iter = std::find(std::begin(context->swap_chains_),
-                          std::end(context->swap_chains_), this);
-    if (iter != context->swap_chains_.end())
-      context->swap_chains_.erase(iter);
-  }
-  buffers_.clear();
-  if (graphics_context_ != nullptr)
-    dvrGraphicsContextDestroy(graphics_context_);
-}
-
-void gvr_swap_chain_destroy(gvr_swap_chain** swap_chain) {
-  if (!swap_chain || !(*swap_chain)) {
-    ALOGW("gvr_swap_chain_destroy: Invalid swap chain pointer.");
-    return;
-  }
-  delete *swap_chain;
-  *swap_chain = nullptr;
-}
-
-int32_t gvr_swap_chain_get_buffer_count(const gvr_swap_chain* swap_chain) {
-  return swap_chain ? static_cast<int32_t>(swap_chain->buffers_.size()) : 0;
-}
-
-gvr_sizei gvr_swap_chain_get_buffer_size(gvr_swap_chain* swap_chain,
-                                         int32_t index) {
-  if (!VerifyBufferIndex("gvr_swap_chain_get_buffer_size", swap_chain, index))
-    return gvr_sizei{0, 0};
-
-  gvr_buffer& buf = swap_chain->buffers_[index];
-  if (buf.requested_size != gvr_sizei{-1, -1})
-    return buf.requested_size;
-  else
-    return buf.spec.size;
-}
-
-void gvr_swap_chain_resize_buffer(gvr_swap_chain* swap_chain, int32_t index,
-                                  gvr_sizei size) {
-  if (!VerifyBufferIndex("gvr_swap_chain_resize_buffer", swap_chain, index))
-    return;
-
-  gvr_buffer& buf = swap_chain->buffers_[index];
-  if (size != buf.spec.size)
-    buf.requested_size = size;
-  else
-    buf.requested_size = {-1, -1};
-}
-
-gvr_frame* gvr_swap_chain_acquire_frame(gvr_swap_chain* swap_chain) {
-  if (!swap_chain)
-    return nullptr;
-
-  if (swap_chain->frame_acquired_) {
-    gvr_set_error(swap_chain->context, GVR_ERROR_NO_FRAME_AVAILABLE);
-    return nullptr;
-  }
-
-  // Resize buffers if necessary
-  for (int i = 0; i < static_cast<int>(swap_chain->buffers_.size()); ++i) {
-    gvr_buffer& buf = swap_chain->buffers_[i];
-    if (buf.requested_size != gvr_sizei{-1, -1}) {
-      if (!SwapChainResizeBuffer(swap_chain, i))
-        return nullptr;
-    }
-  }
-
-  // Only call gvr_wait_next_frame() if the app didn't call it already.
-  if (!swap_chain->wait_next_frame_called_by_app_)
-    WaitNextFrame(swap_chain, 0, nullptr, /*called_by_app*/ false);
-
-  int ret = dvrBeginRenderFrame(swap_chain->graphics_context_);
-  if (ret < 0) {
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    return nullptr;
-  }
-
-  swap_chain->frame_acquired_ = true;
-  return GetFrameFromSwapChain(swap_chain);
-}
-
-void gvr_frame_bind_buffer(gvr_frame* frame, int32_t index) {
-  gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
-  if (!VerifyBufferIndex("gvr_frame_bind_buffer", swap_chain, index))
-    return;
-  glBindFramebuffer(GL_FRAMEBUFFER, swap_chain->buffers_[index].frame_buffer);
-}
-
-void gvr_frame_unbind(gvr_frame* /* frame */) {
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-gvr_sizei gvr_frame_get_buffer_size(const gvr_frame* frame, int32_t index) {
-  const gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
-  if (!VerifyBufferIndex("gvr_frame_get_buffer_size", swap_chain, index))
-    return gvr_sizei{0, 0};
-  return swap_chain->buffers_[index].spec.size;
-}
-
-int32_t gvr_frame_get_framebuffer_object(const gvr_frame* frame,
-                                         int32_t index) {
-  const gvr_swap_chain* swap_chain = GetSwapChainForFrame(frame);
-  if (!VerifyBufferIndex("gvr_frame_get_framebuffer_object", swap_chain, index))
-    return 0;
-  return swap_chain->buffers_[index].frame_buffer;
-}
-
-void gvr_frame_submit(gvr_frame** frame, const gvr_buffer_viewport_list* list,
-                      gvr_mat4f head_space_from_start_space) {
-  if (!frame)
-    return;
-
-  gvr_swap_chain* swap_chain = GetSwapChainForFrame(*frame);
-
-  if (!swap_chain->frame_acquired_) {
-    ALOGE("Frame was never acquired before being submitted");
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    return;
-  }
-
-  *frame = nullptr;
-  swap_chain->frame_acquired_ = false;
-
-  // Currently, support for arbitrary buffer viewport configs is very limited.
-  // We assume that the first two viewports have to be the recommended color
-  // buffer viewports, followed by pairs of external external buffer viewports
-  // for video rendering.
-  gvr_buffer_viewport_list supported_viewports;
-  gvr_get_recommended_buffer_viewports(swap_chain->context,
-                                       &supported_viewports);
-  for (size_t i = 0; i < supported_viewports.viewports.size(); ++i) {
-    if (i >= list->viewports.size() ||
-        supported_viewports.viewports[i] != list->viewports[i]) {
-      ALOGE("Custom viewport configurations are not fully supported.");
-      gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-      return;
-    }
-  }
-
-  for (size_t i = supported_viewports.viewports.size();
-       i < list->viewports.size(); ++i) {
-    int32_t external_surface_id = list->viewports[i].external_surface_id;
-    // Ignore additional custom buffer viewport for now, only those buffer
-    // viewports backed by external surfaces are supported.
-    // TODO(b/31442094, b/31771861, 28954457) Add full GVR buffer viewport
-    // support.
-    if (external_surface_id == GVR_EXTERNAL_SURFACE_ID_NONE)
-      continue;
-
-    auto surface_it = swap_chain->external_surfaces_.find(external_surface_id);
-    if (surface_it == swap_chain->external_surfaces_.end()) {
-      ALOGE("Cannot find external_surface by id: %d.", external_surface_id);
-      gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-      return;
-    }
-
-    // Pass the transfrom matrix of video mesh to displayd.
-    dvrGraphicsVideoMeshSurfacePresent(
-        swap_chain->graphics_context_, surface_it->second->video_surface,
-        list->viewports[i].eye,
-        GvrToEigenMatrix(list->viewports[i].transform).data());
-  }
-
-  float32x4_t pose_orientation, pose_translation;
-  GvrToDvrPose(head_space_from_start_space, &pose_orientation,
-               &pose_translation);
-  int ret = dvrSetEdsPose(swap_chain->graphics_context_, pose_orientation,
-                          pose_translation);
-  if (ret < 0)
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-
-  ret = dvrPresent(swap_chain->graphics_context_);
-  if (ret < 0) {
-    gvr_set_error(swap_chain->context, GVR_ERROR_INTERNAL);
-    return;
-  }
-}
-
-void gvr_bind_default_framebuffer(gvr_context* /* gvr */) {
-  glBindFramebuffer(GL_FRAMEBUFFER, 0);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Head tracking
-/////////////////////////////////////////////////////////////////////////////
-
-gvr_clock_time_point gvr_get_time_point_now() {
-  return gvr_clock_time_point{GetSystemClockNs()};
-}
-
-gvr_mat4f gvr_get_head_space_from_start_space_rotation(
-    const gvr_context* gvr, const gvr_clock_time_point /* time */) {
-  // TODO(steventhomas): Implement prediction according to the supplied time
-  // value.
-  return gvr->force_6dof_ ? gvr->next_frame_6dof_pose_
-                          : Gvr6dofTo3dof(gvr->next_frame_6dof_pose_);
-}
-
-gvr_mat4f gvr_apply_neck_model(const gvr_context* /* gvr */,
-                               gvr_mat4f head_space_from_start_space_rotation,
-                               float /* factor */) {
-  // TODO(leandrogracia): this needs to be properly implemented.
-  ALOGE("gvr_apply_neck_model not implemented.");
-  return head_space_from_start_space_rotation;
-}
-
-// This is used to turn off sensors to save power. Not relevant for our all in
-// one device.
-void gvr_pause_tracking(gvr_context* /* gvr */) {}
-
-// This is used to turn on sensors. Not relevant for our all in one device.
-void gvr_resume_tracking(gvr_context* /* gvr */) {}
-
-void gvr_reset_tracking(gvr_context* gvr) {
-  // TODO(leandrogracia): this needs to be properly implemented.
-  ALOGE("gvr_reset_tracking not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-void gvr_recenter_tracking(gvr_context* gvr) {
-  // TODO(leandrogracia): this needs to be properly implemented.
-  ALOGE("gvr_recenter_tracking not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// Head mounted display
-/////////////////////////////////////////////////////////////////////////////
-
-bool gvr_set_default_viewer_profile(gvr_context* gvr,
-                                    const char* /* viewer_profile_uri */) {
-  // TODO(leandrogracia): this needs to be properly implemented.
-  ALOGE("gvr_set_default_viewer_profile not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-  return false;
-}
-
-void gvr_refresh_viewer_profile(gvr_context* /* gvr */) {}
-
-const char* gvr_get_viewer_vendor(const gvr_context* /* gvr */) {
-  return kViewerVendor;
-}
-
-const char* gvr_get_viewer_model(const gvr_context* /* gvr */) {
-  return kViewerModel;
-}
-
-int32_t gvr_get_viewer_type(const gvr_context* /* gvr */) {
-  // TODO(leandrogracia): this needs to be properly implemented.
-  // In this case, we will probably need to define a new viewer type that
-  // has 6DoF support.
-  return GVR_VIEWER_TYPE_DAYDREAM;
-}
-
-gvr_mat4f gvr_get_eye_from_head_matrix(const gvr_context* gvr,
-                                       const int32_t eye) {
-  float eye_mult = eye == GVR_LEFT_EYE ? 1 : -1;
-  return GvrTranslationMatrix(
-      .5f * eye_mult * gvr->display_metrics_.inter_lens_distance_m, 0, 0);
-}
-
-gvr_recti gvr_get_window_bounds(const gvr_context* gvr) {
-  // Our app windows are always full screen
-  gvr_sizei screen_size = gvr_get_screen_target_size(gvr);
-  return gvr_recti{0, screen_size.width, 0, screen_size.height};
-}
-
-void gvr_compute_distorted_point(const gvr_context* /* gvr */,
-                                 const int32_t /* eye */,
-                                 const gvr_vec2f /* uv_in */,
-                                 gvr_vec2f /* uv_out */[3]) {
-  // TODO(leandrogracia): this needs to be properly implemented.
-  ALOGE("gvr_compute_distorted_point not implemented.");
-}
-
-/////////////////////////////////////////////////////////////////////////////
-// GVR API extension (from gvr_ext.h)
-/////////////////////////////////////////////////////////////////////////////
-
-gvr_frame_schedule* gvr_frame_schedule_create() {
-  return new gvr_frame_schedule;
-}
-
-void gvr_frame_schedule_destroy(gvr_frame_schedule** schedule) {
-  if (!schedule || !(*schedule)) {
-    ALOGW("gvr_frame_schedule_destroy: Invalid frame schedule pointer.");
-    return;
-  }
-  delete *schedule;
-  *schedule = nullptr;
-}
-
-uint32_t gvr_frame_schedule_get_vsync_count(gvr_frame_schedule* schedule) {
-  return schedule->vsync_count;
-}
-
-gvr_clock_time_point gvr_frame_schedule_get_scheduled_finish(
-    gvr_frame_schedule* schedule) {
-  return schedule->scheduled_finish;
-}
-
-void gvr_wait_next_frame(gvr_swap_chain* swap_chain, int64_t start_delay_nanos,
-                         gvr_frame_schedule* out_next_frame_schedule) {
-  WaitNextFrame(swap_chain, start_delay_nanos, out_next_frame_schedule,
-                /*called_by_app*/ true);
-}
-
-gvr_mat4f gvr_get_6dof_head_pose_in_start_space(gvr_context* gvr,
-                                                uint32_t vsync_count) {
-  DvrPoseAsync pose;
-  int ret = dvrPoseGet(gvr->pose_client_, vsync_count, &pose);
-  if (ret < 0) {
-    ALOGW("dvrPoseGet failed: %d", ret);
-    gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-    return GvrIdentityMatrix();
-  }
-
-  return PosefToGvrMatrix(ToPosef(pose));
-}
-
-gvr_mat4f gvr_get_head_space_from_start_space_pose(
-    gvr_context* gvr, const gvr_clock_time_point /* time */) {
-  // TODO(leandrogracia): implement prediction based on the provided time.
-  // We need to do the same for the 3dof version too.
-  return gvr->next_frame_6dof_pose_;
-}
-
-void gvr_swap_chain_set_z_order(const gvr_swap_chain* swap_chain, int z_order) {
-  dvrGraphicsSurfaceSetZOrder(swap_chain->graphics_context_, z_order);
-}
-
-bool gvr_experimental_register_perf_event_callback(
-    gvr_context* gvr, int* /* out_handle */, void* /* user_data */,
-    void (* /* event_callback */)(void*, int, float)) {
-  ALOGE("gvr_experimental_register_perf_event_callback not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-  return false;
-}
-
-bool gvr_experimental_unregister_perf_event_callback(gvr_context* gvr,
-                                                     int /* handle */) {
-  ALOGE("gvr_experimental_unregister_perf_event_callback not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-  return false;
-}
-
-const gvr_analytics* gvr_get_analytics(gvr_context* gvr) {
-  ALOGE("gvr_get_analytics not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-  return nullptr;
-}
-
-const gvr_analytics_sample* gvr_analytics_create_sample(
-    const gvr_analytics* analytics) {
-  ALOGE("gvr_analytics_create_sample not implemented.");
-  return nullptr;
-}
-
-const char* gvr_analytics_sample_get_buffer(const gvr_analytics_sample* sample) {
-  ALOGE("gvr_analytics_sample_get_buffer not implemented.");
-  return nullptr;
-}
-
-size_t gvr_analytics_sample_get_buffer_length(
-    const gvr_analytics_sample* sample) {
-  ALOGE("gvr_analytics_sample_get_buffer_length not implemented.");
-  return 0;
-}
-
-void gvr_analytics_destroy_sample(const gvr_analytics_sample** sample) {
-  ALOGE("gvr_analytics_destroy_sample not implemented.");
-}
-
-bool gvr_user_prefs_get_performance_monitoring_enabled(
-    const gvr_user_prefs* /* user_prefs */) {
-  ALOGW("gvr_user_prefs_get_performance_monitoring_enabled not implemented.");
-  return false;
-}
-
-void gvr_enable_context_sharing(gvr_context* gvr,
-                                gvr_egl_context_listener /* handler */,
-                                void* /* user_data */) {
-  ALOGW("gvr_enable_context_sharing not implemented.");
-  gvr_set_error(gvr, GVR_ERROR_INTERNAL);
-}
-
-gvr_mat4f gvr_get_start_space_from_controller_space_pose(
-    gvr_context* gvr, int controller_id,
-    const gvr_clock_time_point /* time */) {
-  if (controller_id < 0 || controller_id >= kControllerCount) {
-    return GvrIdentityMatrix();
-  }
-
-  // TODO(leandrogracia): implement prediction based on the provided time.
-  // We need to do the same for the 3dof version too.
-  return gvr->next_frame_controller_pose_[controller_id];
-}
-
-gvr_external_surface* gvr_external_surface_create(gvr_context* context) {
-  // A |gvr_external_surface| is bound to a DVR Graphics context at the
-  // moment, which means we need an |gvr_swap_chain| created prior to the call
-  // of |gvr_external_surface_create|. Check whether the current GVR context
-  // has |gvr_swap_chain| created. Fail if there is no swap chain created
-  // already.
-  if (context->swap_chains_.empty()) {
-    ALOGE("gvr_external_surface_create: No swapchain has been created yet.");
-    return nullptr;
-  }
-
-  // In case there are multiple swap chains in the context, the first is
-  // implicitly chosen. Actually, this should not happen as current scanline
-  // racing based GVR implementation only supports single swap chain per GVR
-  // context.
-  if (context->swap_chains_.size() > 1) {
-    ALOGW("gvr_external_surface_create: Multiple swap chains detected. "
-          "Choosing the first one but this may yield unexpected results.");
-  }
-  gvr_swap_chain* swap_chain = context->swap_chains_[0];
-  DvrVideoMeshSurface* video_surface = dvrGraphicsVideoMeshSurfaceCreate(
-      swap_chain->graphics_context_);
-
-  if (video_surface == nullptr) {
-    ALOGE("gvr_external_surface_create: Failed to create video mesh surface.");
-    return nullptr;
-  }
-
-  gvr_external_surface* surface = new gvr_external_surface;
-  surface->id = swap_chain->next_external_surface_id_++;
-  surface->swap_chain = swap_chain;
-  surface->video_surface = video_surface;
-
-  // Insert the surface into a lookup table in swap_chain. This will be
-  // needed to by the external_surface_id in |gvr_buffer_viewport|.
-  swap_chain->external_surfaces_.insert({surface->id, surface});
-  return surface;
-}
-
-void gvr_external_surface_destroy(gvr_external_surface** surface) {
-  if (!surface || !(*surface)) {
-    ALOGW("gvr_external_surface_destroy: Invalid external surface pointer.");
-    return;
-  }
-
-  (*surface)->swap_chain->external_surfaces_.erase((*surface)->id);
-  if ((*surface)->video_surface != nullptr) {
-    dvrGraphicsVideoMeshSurfaceDestroy((*surface)->video_surface);
-  }
-
-  delete *surface;
-  *surface = nullptr;
-}
-
-void* gvr_external_surface_get_surface(const gvr_external_surface* surface) {
-  LOG_ALWAYS_FATAL_IF(surface->swap_chain == nullptr ||
-                          surface->swap_chain->context == nullptr ||
-                          surface->swap_chain->context->jni_env_ == nullptr,
-                      "gvr_external_surface_get_surface: Surface must be "
-                      "constructed within a JNIEnv. Check |gvr_create| call.");
-
-  LOG_ALWAYS_FATAL_IF(surface->video_surface == nullptr,
-                      "gvr_external_surface_get_surface: Invalid surface.");
-
-  std::shared_ptr<android::dvr::ProducerQueue> producer_queue =
-      surface->video_surface->client->GetProducerQueue();
-  std::shared_ptr<android::dvr::BufferHubQueueCore> core =
-      android::dvr::BufferHubQueueCore::Create(producer_queue);
-
-  return android_view_Surface_createFromIGraphicBufferProducer(
-      surface->swap_chain->context->jni_env_,
-      new android::dvr::BufferHubQueueProducer(core));
-}
-
-int32_t gvr_external_surface_get_surface_id(
-    const gvr_external_surface* surface) {
-  return surface->id;
-}
diff --git a/libs/vr/libgvr/shim_gvr_controller.cpp b/libs/vr/libgvr/shim_gvr_controller.cpp
deleted file mode 100644
index 0f55903..0000000
--- a/libs/vr/libgvr/shim_gvr_controller.cpp
+++ /dev/null
@@ -1,168 +0,0 @@
-#define LOG_TAG "libgvr_controller_shim"
-
-#include <log/log.h>
-#include <vr/gvr/capi/include/gvr_controller.h>
-#include <vr/gvr/capi/include/gvr_types.h>
-
-gvr_controller_context* gvr_controller_create_and_init(int32_t options,
-                                                       gvr_context* context) {
-  ALOGE("gvr_controller_create_and_init not implemented.");
-  return nullptr;
-}
-
-gvr_controller_context* gvr_controller_create_and_init_android(
-    JNIEnv* env, jobject android_context, jobject class_loader, int32_t options,
-    gvr_context* context) {
-  ALOGE("gvr_controller_create_and_init_android not implemented.");
-  return nullptr;
-}
-
-void gvr_controller_destroy(gvr_controller_context** api) {
-  ALOGE("gvr_controller_destroy not implemented.");
-}
-
-gvr_controller_state* gvr_controller_state_create() {
-  ALOGE("gvr_controller_state_create not implemented.");
-  return nullptr;
-}
-
-void gvr_controller_state_destroy(gvr_controller_state** state) {
-  ALOGE("gvr_controller_state_destroy not implemented.");
-}
-
-void gvr_controller_state_update(gvr_controller_context* api, int32_t flags,
-                                 gvr_controller_state* out_state) {
-  ALOGE("gvr_controller_state_update not implemented.");
-}
-
-int64_t gvr_controller_state_get_last_button_timestamp(
-    const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_last_button_timestamp not implemented.");
-  return 0;
-}
-
-bool gvr_controller_state_get_button_state(const gvr_controller_state* state,
-                                           int32_t button) {
-  ALOGE("gvr_controller_state_get_button_state not implemented.");
-  return false;
-}
-
-bool gvr_controller_state_get_button_down(const gvr_controller_state* state,
-                                          int32_t button) {
-  ALOGE("gvr_controller_state_get_button_down not implemented.");
-  return false;
-}
-
-bool gvr_controller_state_get_button_up(const gvr_controller_state* state,
-                                        int32_t button) {
-  ALOGE("gvr_controller_state_get_button_up not implemented.");
-  return false;
-}
-
-bool gvr_controller_state_is_touching(const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_is_touching not implemented.");
-  return false;
-}
-
-gvr_vec2f gvr_controller_state_get_touch_pos(
-    const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_touch_pos not implemented.");
-  return {0.0f, 0.0f};
-}
-
-bool gvr_controller_state_get_touch_down(const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_touch_down not implemented.");
-  return false;
-}
-
-bool gvr_controller_state_get_touch_up(const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_touch_up not implemented.");
-  return false;
-}
-
-int64_t gvr_controller_state_get_last_touch_timestamp(
-    const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_last_touch_timestamp not implemented.");
-  return 0;
-}
-
-gvr_quatf gvr_controller_state_get_orientation(
-    const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_orientation not implemented.");
-  return {0.0f, 0.0f, 0.0f, 0.0f};
-}
-
-int64_t gvr_controller_state_get_last_orientation_timestamp(
-    const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_last_orientation_timestamp not implemented.");
-  return 0;
-}
-
-const char* gvr_controller_api_status_to_string(int32_t status) {
-  ALOGE("gvr_controller_api_status_to_string not implemented.");
-  return nullptr;
-}
-
-const char* gvr_controller_connection_state_to_string(int32_t state) {
-  ALOGE("gvr_controller_connection_state_to_string not implemented.");
-  return nullptr;
-}
-
-const char* gvr_controller_button_to_string(int32_t button) {
-  ALOGE("gvr_controller_button_to_string not implemented.");
-  return nullptr;
-}
-
-int32_t gvr_controller_get_default_options() {
-  ALOGE("gvr_controller_get_default_options not implemented.");
-  return 0;
-}
-
-void gvr_controller_pause(gvr_controller_context* api) {
-  ALOGE("gvr_controller_pause not implemented.");
-}
-
-void gvr_controller_resume(gvr_controller_context* api) {
-  ALOGE("gvr_controller_resume not implemented.");
-}
-
-int32_t gvr_controller_state_get_api_status(const gvr_controller_state* state) {
-  return GVR_CONTROLLER_API_OK;
-}
-
-int32_t gvr_controller_state_get_connection_state(
-    const gvr_controller_state* state) {
-  return GVR_CONTROLLER_CONNECTED;
-}
-
-gvr_vec3f gvr_controller_state_get_gyro(const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_gyro not implemented.");
-  return {0.0, 0.0, 0.0};
-}
-
-gvr_vec3f gvr_controller_state_get_accel(const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_accel not implemented.");
-  return {0.0, 0.0, 0.0};
-}
-
-int64_t gvr_controller_state_get_last_gyro_timestamp(
-    const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_last_gyro_timestamp not implemented.");
-  return 0;
-}
-
-int64_t gvr_controller_state_get_last_accel_timestamp(
-    const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_last_accel_timestamp not implemented.");
-  return 0;
-}
-
-bool gvr_controller_state_get_recentered(const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_recentered not implemented.");
-  return false;
-}
-
-bool gvr_controller_state_get_recentering(const gvr_controller_state* state) {
-  ALOGE("gvr_controller_state_get_recentering not implemented.");
-  return false;
-}
diff --git a/libs/vr/libgvr/shim_gvr_private.cpp b/libs/vr/libgvr/shim_gvr_private.cpp
deleted file mode 100644
index 25a5110..0000000
--- a/libs/vr/libgvr/shim_gvr_private.cpp
+++ /dev/null
@@ -1,234 +0,0 @@
-#define LOG_TAG "libgvr_shim_private"
-
-#include <log/log.h>
-#include <private/dvr/display_rpc.h>
-#include <private/dvr/internal_types.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/src/gvr_private.h>
-
-#include <pdx/rpc/remote_method.h>
-#include "deviceparams/CardboardDevice.nolite.pb.h"
-
-bool gvr_set_async_reprojection_enabled(gvr_context* /* gvr */,
-                                        bool /* enabled */) {
-  return true;
-}
-
-void gvr_on_surface_created_reprojection_thread(gvr_context* /* gvr */) {}
-
-void gvr_render_reprojection_thread(gvr_context* /* gvr */) {}
-
-void gvr_on_pause_reprojection_thread(gvr_context* /* gvr */) {}
-
-void gvr_update_surface_reprojection_thread(
-    gvr_context* /* gvr */, int32_t /* surface_id */, int32_t /* texture_id */,
-    gvr_clock_time_point /* timestamp */, gvr_mat4f /* surface_transform */) {
-  ALOGE("gvr_update_surface_reprojection_thread not implemented");
-}
-
-void gvr_remove_all_surfaces_reprojection_thread(gvr_context* /* gvr */) {
-  ALOGE("gvr_remove_all_surfaces_reprojection_thread not implemented");
-}
-
-void gvr_reconnect_sensors(gvr_context* /* gvr */) {
-  ALOGE("gvr_reconnect_sensors not implemented");
-}
-
-bool gvr_set_viewer_params(gvr_context* gvr,
-                           const void* serialized_viewer_params,
-                           size_t serialized_viewer_params_size_bytes) {
-  std::string serialized_device_params_string(
-      reinterpret_cast<const char*>(serialized_viewer_params),
-      serialized_viewer_params_size_bytes);
-  std::unique_ptr<proto::DeviceParams> device_params(new proto::DeviceParams);
-  if (!device_params->ParseFromString(serialized_device_params_string)) {
-    ALOGE("Invalid serialized Cardboard DeviceParams");
-    return false;
-  }
-
-  android::dvr::ViewerParams viewer_params;
-
-  viewer_params.screen_to_lens_distance =
-      device_params->screen_to_lens_distance();
-  viewer_params.inter_lens_distance = device_params->inter_lens_distance();
-  for (int i = 0; i < device_params->left_eye_field_of_view_angles_size();
-       ++i) {
-    viewer_params.left_eye_field_of_view_angles.push_back(
-        device_params->left_eye_field_of_view_angles(i));
-  }
-
-  viewer_params.vertical_alignment =
-      static_cast<android::dvr::ViewerParams::VerticalAlignmentType>(
-          device_params->vertical_alignment());
-  viewer_params.tray_to_lens_distance = device_params->tray_to_lens_distance();
-
-  // TODO(hendrikw) Leave the g and b coefficients empty until we support
-  // chromatic aberration correction.
-  for (int i = 0; i < device_params->distortion_coefficients_size(); ++i) {
-    viewer_params.distortion_coefficients_r.push_back(
-        device_params->distortion_coefficients(i));
-  }
-
-  viewer_params.screen_center_to_lens_distance =
-      viewer_params.inter_lens_distance / 2.0;
-  if (device_params->has_internal()) {
-    for (int i = 0; i < device_params->internal().eye_orientations_size();
-         ++i) {
-      viewer_params.eye_orientations.push_back(
-          static_cast<android::dvr::ViewerParams::EyeOrientation>(
-              device_params->internal().eye_orientations(i)));
-    }
-
-    if (device_params->internal().has_screen_center_to_lens_distance())
-      viewer_params.screen_center_to_lens_distance =
-          device_params->internal().screen_center_to_lens_distance();
-  }
-
-  if (device_params->has_daydream_internal()) {
-    viewer_params.daydream_internal.version =
-        device_params->daydream_internal().version();
-    for (int i = 0;
-         i < device_params->daydream_internal().alignment_markers_size(); ++i) {
-      viewer_params.daydream_internal.alignment_markers.push_back(
-          {device_params->daydream_internal().alignment_markers(i).horizontal(),
-           device_params->daydream_internal().alignment_markers(i).vertical()});
-    }
-  }
-
-  gvr->display_client_->SetViewerParams(viewer_params);
-  return true;
-}
-
-void gvr_set_lens_offset(gvr_context* /* gvr */, gvr_vec2f /* offset */) {
-  ALOGE("gvr_set_lens_offset not implemented");
-}
-
-void gvr_set_display_metrics(gvr_context* /* gvr */,
-                             gvr_sizei /* size_pixels */,
-                             gvr_vec2f /* meters_per_pixel */,
-                             float /* border_size_meters */) {
-  ALOGE("gvr_set_display_metrics not implemented");
-}
-
-void gvr_set_display_output_rotation(gvr_context* /* gvr */,
-                                     int /* display_output_rotation */) {
-  ALOGE("gvr_set_display_output_rotation not implemented");
-}
-
-float gvr_get_border_size_meters(const gvr_context* /* gvr */) {
-  ALOGE("gvr_get_border_size_meters not implemented");
-  return 0.0f;
-}
-
-bool gvr_check_surface_size_changed(gvr_context* /* gvr */) { return false; }
-
-gvr_sizei gvr_get_surface_size(const gvr_context* /* gvr */) {
-  ALOGE("gvr_get_surface_size not implemented");
-  return {0, 0};
-}
-
-void gvr_set_back_gesture_event_handler(gvr_context* /* gvr */,
-                                        event_handler /* handler */,
-                                        void* /* user_data */) {
-  ALOGE("gvr_set_back_gesture_event_handler not implemented");
-}
-
-gvr_tracker_state* gvr_pause_tracking_get_state(gvr_context* /* gvr */) {
-  ALOGE("gvr_pause_tracking_get_state not implemented");
-  return nullptr;
-}
-
-void gvr_resume_tracking_set_state(gvr_context* /* gvr */,
-                                   gvr_tracker_state* /* tracker_state */) {
-  ALOGE("gvr_resume_tracking_set_state not implemented");
-}
-
-void gvr_set_ignore_manual_tracker_pause_resume(gvr_context* /* gvr */,
-                                                bool /* should_ignore */) {
-  ALOGE("gvr_set_ignore_manual_tracker_pause_resume not implemented");
-}
-
-gvr_tracker_state* gvr_tracker_state_create(
-    const char* /* tracker_state_buffer */, size_t /* buf_size */) {
-  ALOGE("gvr_tracker_state_create not implemented");
-  return nullptr;
-}
-
-size_t gvr_tracker_state_get_buffer_size(
-    gvr_tracker_state* /* tracker_state */) {
-  ALOGE("gvr_tracker_state_get_buffer_size not implemented");
-  return 0;
-}
-
-const char* gvr_tracker_state_get_buffer(
-    gvr_tracker_state* /* tracker_state */) {
-  ALOGE("gvr_tracker_state_get_buffer not implemented");
-  return nullptr;
-}
-
-void gvr_tracker_state_destroy(gvr_tracker_state** /* tracker_state */) {
-  ALOGE("gvr_tracker_state_destroy not implemented");
-}
-
-gvr_display_synchronizer* gvr_display_synchronizer_create() {
-  // We don't actually support (or need) any of the synchronizer functionality,
-  // but if we return null here the gvr setup code in the app fails. Instead
-  // return a dummy object that does nothing, which allows gvr apps to work.
-  return new gvr_display_synchronizer;
-}
-
-void gvr_display_synchronizer_destroy(gvr_display_synchronizer** synchronizer) {
-  if (synchronizer) {
-    delete *synchronizer;
-    *synchronizer = nullptr;
-  }
-}
-
-void gvr_display_synchronizer_reset(
-    gvr_display_synchronizer* /* synchronizer */,
-    int64_t /* expected_interval_nanos */, int64_t /* vsync_offset_nanos */) {}
-
-void gvr_display_synchronizer_update(
-    gvr_display_synchronizer* /* synchronizer */,
-    gvr_clock_time_point /* vsync_time */, int32_t /* rotation */) {}
-
-void gvr_set_display_synchronizer(
-    gvr_context* /* gvr */, gvr_display_synchronizer* /* synchronizer */) {}
-
-void gvr_set_error(gvr_context* gvr, int32_t error_code) {
-  if (gvr->last_error_ != GVR_ERROR_NONE) {
-    ALOGW("Overwriting existing error code: %d (%s)", gvr->last_error_,
-          gvr_get_error_string(gvr->last_error_));
-  }
-  gvr->last_error_ = error_code;
-}
-
-void gvr_pause(gvr_context* gvr) {
-  if (gvr == nullptr) {
-    ALOGW("gvr_pause called with a null gvr_context. This is a bug.");
-    return;
-  }
-  for (gvr_swap_chain* swap_chain : gvr->swap_chains_) {
-    if (swap_chain->graphics_context_)
-      dvrGraphicsSurfaceSetVisible(swap_chain->graphics_context_, 0);
-  }
-}
-
-void gvr_resume(gvr_context* gvr) {
-  if (gvr == nullptr) {
-    ALOGW("gvr_resume called with a null gvr_context. This is a bug.");
-    return;
-  }
-  for (gvr_swap_chain* swap_chain : gvr->swap_chains_) {
-    if (swap_chain->graphics_context_)
-      dvrGraphicsSurfaceSetVisible(swap_chain->graphics_context_, 1);
-  }
-}
-
-void gvr_dump_debug_data(gvr_context* /* gvr */) {}
-
-bool gvr_using_vr_display_service(gvr_context* /* gvr */) { return true; }
-
-void gvr_request_context_sharing(gvr_context* /* gvr */,
-                                 gvr_egl_context_listener /* handler */,
-                                 void* /* user_data */) {}
diff --git a/opengl/include/EGL/eglext.h b/opengl/include/EGL/eglext.h
index 5a81f7c..df84c93 100644
--- a/opengl/include/EGL/eglext.h
+++ b/opengl/include/EGL/eglext.h
@@ -642,24 +642,31 @@
 #ifndef EGL_ANDROID_get_frame_timestamps
 #define EGL_ANDROID_get_frame_timestamps 1
 #define EGL_TIMESTAMPS_ANDROID 0x314D
-#define EGL_REQUESTED_PRESENT_TIME_ANDROID 0x314E
-#define EGL_RENDERING_COMPLETE_TIME_ANDROID 0x314F
-#define EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3150
-#define EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3151
-#define EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3152
-#define EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID 0x3153
-#define EGL_DISPLAY_PRESENT_TIME_ANDROID 0x3154
-#define EGL_DISPLAY_RETIRE_TIME_ANDROID 0x3155
-#define EGL_DEQUEUE_READY_TIME_ANDROID 0x3156
-#define EGL_READS_DONE_TIME_ANDROID 0x3157
+#define EGL_COMPOSITE_DEADLINE_ANDROID 0x314E
+#define EGL_COMPOSITE_INTERVAL_ANDROID 0x314F
+#define EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID 0x3150
+#define EGL_REQUESTED_PRESENT_TIME_ANDROID 0x3151
+#define EGL_RENDERING_COMPLETE_TIME_ANDROID 0x3152
+#define EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3153
+#define EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3154
+#define EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3155
+#define EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID 0x3156
+#define EGL_DISPLAY_PRESENT_TIME_ANDROID 0x3157
+#define EGL_DISPLAY_RETIRE_TIME_ANDROID 0x3158
+#define EGL_DEQUEUE_READY_TIME_ANDROID 0x3159
+#define EGL_READS_DONE_TIME_ANDROID 0x315A
 #ifdef EGL_EGLEXT_PROTOTYPES
 EGLAPI EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
+EGLAPI EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values);
+EGLAPI EGLBoolean eglGetCompositorTimingSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint name);
 EGLAPI EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
-EGLAPI EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+EGLAPI EGLBoolean eglGetFrameTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
 #else
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETNEXTFRAMEIDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR *frameId);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCOMPOSITORTIMINGANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETCOMPOSITORTIMINGSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint name);
 typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSANDROID) (EGLDisplay dpy, EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYTIMESTAMPSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
 #endif
 #endif
 
diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp
index 2422177..ef3d7a3 100644
--- a/opengl/libs/EGL/eglApi.cpp
+++ b/opengl/libs/EGL/eglApi.cpp
@@ -57,8 +57,6 @@
 
 using namespace android;
 
-#define ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS 0
-
 // ----------------------------------------------------------------------------
 
 namespace android {
@@ -90,9 +88,7 @@
         "EGL_ANDROID_create_native_client_buffer "
         "EGL_ANDROID_get_native_client_buffer "
         "EGL_ANDROID_front_buffer_auto_refresh "
-#if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
         "EGL_ANDROID_get_frame_timestamps "
-#endif
         ;
 extern char const * const gExtensionString  =
         "EGL_KHR_image "                        // mandatory
@@ -224,10 +220,14 @@
     // EGL_ANDROID_get_frame_timestamps
     { "eglGetNextFrameIdANDROID",
             (__eglMustCastToProperFunctionPointerType)&eglGetNextFrameIdANDROID },
+    { "eglGetCompositorTimingANDROID",
+            (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingANDROID },
+    { "eglGetCompositorTimingSupportedANDROID",
+            (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingSupportedANDROID },
     { "eglGetFrameTimestampsANDROID",
             (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampsANDROID },
-    { "eglQueryTimestampSupportedANDROID",
-            (__eglMustCastToProperFunctionPointerType)&eglQueryTimestampSupportedANDROID },
+    { "eglGetFrameTimestampSupportedANDROID",
+            (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampSupportedANDROID },
 };
 
 /*
@@ -1248,7 +1248,6 @@
             setError(EGL_BAD_SURFACE, EGL_FALSE);
     }
 
-#if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
     if (attribute == EGL_TIMESTAMPS_ANDROID) {
         if (!s->win.get()) {
             return setError(EGL_BAD_SURFACE, EGL_FALSE);
@@ -1258,7 +1257,6 @@
         return (err == NO_ERROR) ? EGL_TRUE :
             setError(EGL_BAD_SURFACE, EGL_FALSE);
     }
-#endif
 
     if (s->cnx->egl.eglSurfaceAttrib) {
         return s->cnx->egl.eglSurfaceAttrib(
@@ -2101,6 +2099,95 @@
     return EGL_TRUE;
 }
 
+EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy, EGLSurface surface,
+        EGLint numTimestamps, const EGLint *names, EGLnsecsANDROID *values)
+{
+    clearError();
+
+    const egl_display_ptr dp = validate_display(dpy);
+    if (!dp) {
+        return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+    }
+
+    SurfaceRef _s(dp.get(), surface);
+    if (!_s.get()) {
+        return setError(EGL_BAD_SURFACE, EGL_FALSE);
+    }
+
+    egl_surface_t const * const s = get_surface(surface);
+
+    if (!s->win.get()) {
+        return setError(EGL_BAD_SURFACE, EGL_FALSE);
+    }
+
+    nsecs_t* compositeDeadline = nullptr;
+    nsecs_t* compositeInterval = nullptr;
+    nsecs_t* compositeToPresentLatency = nullptr;
+
+    for (int i = 0; i < numTimestamps; i++) {
+        switch (names[i]) {
+            case EGL_COMPOSITE_DEADLINE_ANDROID:
+                compositeDeadline = &values[i];
+                break;
+            case EGL_COMPOSITE_INTERVAL_ANDROID:
+                compositeInterval = &values[i];
+                break;
+            case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID:
+                compositeToPresentLatency = &values[i];
+                break;
+            default:
+                return setError(EGL_BAD_PARAMETER, EGL_FALSE);
+        }
+    }
+
+    status_t ret = native_window_get_compositor_timing(s->win.get(),
+            compositeDeadline, compositeInterval, compositeToPresentLatency);
+
+    switch (ret) {
+      case NO_ERROR:
+        return EGL_TRUE;
+      case INVALID_OPERATION:
+        return setError(EGL_BAD_SURFACE, EGL_FALSE);
+      default:
+        // This should not happen. Return an error that is not in the spec
+        // so it's obvious something is very wrong.
+        ALOGE("eglGetCompositorTiming: Unexpected error.");
+        return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
+    }
+}
+
+EGLBoolean eglGetCompositorTimingSupportedANDROID(
+        EGLDisplay dpy, EGLSurface surface, EGLint name)
+{
+    clearError();
+
+    const egl_display_ptr dp = validate_display(dpy);
+    if (!dp) {
+        return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+    }
+
+    SurfaceRef _s(dp.get(), surface);
+    if (!_s.get()) {
+        return setError(EGL_BAD_SURFACE, EGL_FALSE);
+    }
+
+    egl_surface_t const * const s = get_surface(surface);
+
+    ANativeWindow* window = s->win.get();
+    if (!window) {
+        return setError(EGL_BAD_SURFACE, EGL_FALSE);
+    }
+
+    switch (name) {
+        case EGL_COMPOSITE_DEADLINE_ANDROID:
+        case EGL_COMPOSITE_INTERVAL_ANDROID:
+        case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID:
+            return EGL_TRUE;
+        default:
+            return EGL_FALSE;
+    }
+}
+
 EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface,
         EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps,
         EGLnsecsANDROID *values)
@@ -2193,8 +2280,8 @@
     }
 }
 
-EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface,
-        EGLint timestamp)
+EGLBoolean eglGetFrameTimestampSupportedANDROID(
+        EGLDisplay dpy, EGLSurface surface, EGLint timestamp)
 {
     clearError();
 
@@ -2216,7 +2303,9 @@
     }
 
     switch (timestamp) {
-#if ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS
+        case EGL_COMPOSITE_DEADLINE_ANDROID:
+        case EGL_COMPOSITE_INTERVAL_ANDROID:
+        case EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID:
         case EGL_REQUESTED_PRESENT_TIME_ANDROID:
         case EGL_RENDERING_COMPLETE_TIME_ANDROID:
         case EGL_COMPOSITION_LATCH_TIME_ANDROID:
@@ -2238,7 +2327,6 @@
                     NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_RETIRE, &value);
             return value == 0 ? EGL_FALSE : EGL_TRUE;
         }
-#endif
         default:
             return EGL_FALSE;
     }
diff --git a/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt b/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt
index f24d634..d0ed8e1 100644
--- a/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt
+++ b/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt
@@ -8,11 +8,19 @@
 
 Contributors
 
+    Brian Anderson
+    Dan Stoza
     Pablo Ceballos
+    Jesse Hall
+    Fabien Sanglard
 
 Contact
 
+    Brian Anderson, Google Inc. (brianderson 'at' google.com)
+    Dan Stoza, Google Inc. (stoza 'at' google.com)
     Pablo Ceballos, Google Inc. (pceballos 'at' google.com)
+    Jesse Hall, Google Inc. (jessehall 'at' google.com)
+    Fabien Sanglard, Google Inc. (sanglardf 'at' google.com)
 
 Status
 
@@ -20,7 +28,7 @@
 
 Version
 
-    Version 1, May 31, 2016
+    Version 1, January 13, 2017
 
 Number
 
@@ -60,26 +68,33 @@
     EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface,
             EGLuint64KHR *frameId);
 
+    EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy,
+            EGLSurface surface, EGLint numTimestamps,
+            const EGLint *names, EGLnsecsANDROID *values);
+
     EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface,
             EGLuint64KHR frameId, EGLint numTimestamps,
             const EGLint *timestamps, EGLnsecsANDROID *values);
 
-    EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface
-            surface, EGLint timestamp);
+    EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy,
+            EGLSurface surface, EGLint timestamp);
 
 New Tokens
 
     EGL_TIMESTAMPS_ANDROID 0x314D
-    EGL_REQUESTED_PRESENT_TIME_ANDROID 0x314E
-    EGL_RENDERING_COMPLETE_TIME_ANDROID 0x314F
-    EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3150
-    EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3151
-    EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3152
-    EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID 0x3153
-    EGL_DISPLAY_PRESENT_TIME_ANDROID 0x3154
-    EGL_DISPLAY_RETIRE_TIME_ANDROID 0x3155
-    EGL_DEQUEUE_READY_TIME_ANDROID 0x3156
-    EGL_READS_DONE_TIME_ANDROID 0x3157
+    EGL_COMPOSITE_DEADLINE_ANDROID 0x314E
+    EGL_COMPOSITE_INTERVAL_ANDROID 0x314F
+    EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID 0x3150
+    EGL_REQUESTED_PRESENT_TIME_ANDROID 0x3151
+    EGL_RENDERING_COMPLETE_TIME_ANDROID 0x3152
+    EGL_COMPOSITION_LATCH_TIME_ANDROID 0x3153
+    EGL_FIRST_COMPOSITION_START_TIME_ANDROID 0x3154
+    EGL_LAST_COMPOSITION_START_TIME_ANDROID 0x3155
+    EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID 0x3156
+    EGL_DISPLAY_PRESENT_TIME_ANDROID 0x3157
+    EGL_DISPLAY_RETIRE_TIME_ANDROID 0x3158
+    EGL_DEQUEUE_READY_TIME_ANDROID 0x3159
+    EGL_READS_DONE_TIME_ANDROID 0x315A
 
 Add to the list of supported tokens for eglSurfaceAttrib in section 3.5.6
 "Surface Attributes", page 43:
@@ -89,7 +104,6 @@
     enables timestamp collection, while a value of EGL_FALSE disables it. The
     initial value is false. If surface is not a window surface this has no
     effect.
-
 Changes to Chapter 3 of the EGL 1.5 Specification (EGL Functions and Errors)
 
     Add a new subsection under Section 3,
@@ -108,6 +122,29 @@
 
     The function
 
+        EGLBoolean eglGetCompositorTimingANDROID(EGLDisplay dpy,
+                EGLSurface surface, EGLint numTimestamps,
+                const EGLint *names, EGLnsecsANDROID *values);
+
+    allows querying anticipated timestamps and durations related to the
+    composition and display of a window surface. The values are not associated
+    with a particular frame and can be retrieved before the first swap.
+
+    The eglGetCompositorTimingANDROID function takes an array of names to
+    query and returns their values in the corresponding indices of the values
+    array. The possible names that can be queried are:
+        - EGL_COMPOSITE_DEADLINE_ANDROID - The timestamp of the next time the
+          compositor will begin composition. This is effectively the deadline
+          for when the compositor must receive a newly queued frame.
+        - EGL_COMPOSITE_INTERVAL_ANDROID - The time delta between subsequent
+          composition events.
+        - EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID - The time delta between
+          the start of composition and the expected present time of that
+          composition. This can be used to estimate the latency of the
+          actual present time.
+
+    The function
+
         EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy,
             EGLSurface surface, EGLuint64KHR frameId, EGLint numTimestamps,
             const EGLint *timestamps, EGLnsecsANDROID *values);
@@ -124,6 +161,12 @@
     supported will generate an EGL_BAD_PARAMETER error. If any error is
     generated the function will return EGL_FALSE.
 
+    The application can poll for the timestamp of particular events by calling
+    eglGetFrameTimestamps over and over without needing to call any other EGL
+    function between calls. This is true even for the most recently swapped
+    frame. eglGetFrameTimestamps is thread safe and can be called from a
+    different thread than the swapping thread.
+
     The eglGetFrameTimestampsANDROID function takes an array of timestamps to
     query and returns timestamps in the corresponding indices of the values
     array. The possible timestamps that can be queried are:
@@ -162,12 +205,19 @@
           purpose of display/composition were completed for this frame.
 
     Not all implementations may support all of the above timestamp queries. The
-    function
+    functions
 
-        EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface
-            surface, EGLint timestamp);
+        EGLBoolean eglGetCompositorTimingSupportedANDROID(EGLDisplay dpy,
+            EGLSurface surface, EGLint name);
 
-    allows querying which timestamps are supported on the implementation."
+    and
+
+        EGLBoolean eglGetFrameTimestampsSupportedANDROID(EGLDisplay dpy,
+            EGLSurface surface, EGLint timestamp);
+
+    allows querying which values are supported by the implementations of
+    eglGetCompositoTimingANDROID and eglGetFrameTimestampsSupportedANDROID
+    respectively."
 
 Issues
 
@@ -175,17 +225,21 @@
 
 Revision History
 
-#1 (Pablo Ceballos, May 31, 2016)
-    - Initial draft.
+#5 (Brian Anderson, January 13, 2017)
+    - Add eglGetCompositorTimingANDROID.
 
-#2 (Brian Anderson, July 22, 2016)
-    - Replace EGL_QUEUE_TIME_ANDROID with EGL_REQUESTED_PRESENT_TIME_ANDROID.
-    - Add DISPLAY_PRESENT_TIME_ANDROID.
+#4 (Brian Anderson, January 10, 2017)
+    - Use an absolute frameId rather than a relative framesAgo.
 
 #3 (Brian Anderson, November 30, 2016)
     - Add EGL_COMPOSITION_LATCH_TIME_ANDROID,
       EGL_LAST_COMPOSITION_START_TIME_ANDROID, and
       EGL_DEQUEUE_READY_TIME_ANDROID.
 
-#4 (Brian Anderson, January 10, 2017)
-    - Use an absolute frameId rather than a relative framesAgo.
+#2 (Brian Anderson, July 22, 2016)
+    - Replace EGL_QUEUE_TIME_ANDROID with EGL_REQUESTED_PRESENT_TIME_ANDROID.
+    - Add DISPLAY_PRESENT_TIME_ANDROID.
+
+#1 (Pablo Ceballos, May 31, 2016)
+    - Initial draft.
+
diff --git a/opengl/specs/README b/opengl/specs/README
index 1853214..0c49023 100644
--- a/opengl/specs/README
+++ b/opengl/specs/README
@@ -20,14 +20,17 @@
 0x314B               EGL_IMAGE_CROP_BOTTOM_ANDROID (EGL_ANDROID_image_crop)
 0x314C               EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID (EGL_ANDROID_front_buffer_auto_refresh)
 0x314D               EGL_TIMESTAMPS_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x314E               EGL_REQUESTED_PRESENT_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x314F               EGL_RENDERING_COMPLETE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3150               EGL_COMPOSITION_LATCH_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3151               EGL_FIRST_COMPOSITION_START_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3152               EGL_LAST_COMPOSITION_START_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3153               EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3154               EGL_DISPLAY_PRESENT_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3155               EGL_DISPLAY_RETIRE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3156               EGL_DEQUEUE_READY_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3157               EGL_READS_DONE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
-0x3158 - 0x315F      (unused)
+0x314E               EGL_COMPOSITE_DEADLINE_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x314F               EGL_COMPOSITE_INTERVAL_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3150               EGL_COMPOSITE_TO_PRESENT_LATENCY_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3151               EGL_REQUESTED_PRESENT_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3152               EGL_RENDERING_COMPLETE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3153               EGL_COMPOSITION_LATCH_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3154               EGL_FIRST_COMPOSITION_START_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3155               EGL_LAST_COMPOSITION_START_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3156               EGL_FIRST_COMPOSITION_FINISHED_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3157               EGL_DISPLAY_PRESENT_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3158               EGL_DISPLAY_RETIRE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x3159               EGL_DEQUEUE_READY_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x315A               EGL_READS_DONE_TIME_ANDROID (EGL_ANDROID_get_frame_timestamps)
+0x315B - 0x315F      (unused)
diff --git a/services/audiomanager/IPlayer.cpp b/services/audiomanager/IPlayer.cpp
index 47edc4b..e8a9c34 100644
--- a/services/audiomanager/IPlayer.cpp
+++ b/services/audiomanager/IPlayer.cpp
@@ -35,6 +35,7 @@
     SET_VOLUME = IBinder::FIRST_CALL_TRANSACTION + 3,
     SET_PAN    = IBinder::FIRST_CALL_TRANSACTION + 4,
     SET_START_DELAY_MS = IBinder::FIRST_CALL_TRANSACTION + 5,
+    APPLY_VOLUME_SHAPER = IBinder::FIRST_CALL_TRANSACTION + 6,
 };
 
 class BpPlayer : public BpInterface<IPlayer>
@@ -88,6 +89,36 @@
         data.writeInt32(delayMs);
         remote()->transact(SET_START_DELAY_MS, data, &reply);
     }
+
+    virtual void applyVolumeShaper(
+            const sp<VolumeShaper::Configuration>& configuration,
+            const sp<VolumeShaper::Operation>& operation) {
+        Parcel data, reply;
+        data.writeInterfaceToken(IPlayer::getInterfaceDescriptor());
+
+        status_t status = configuration.get() == nullptr
+                ? data.writeInt32(0)
+                :  data.writeInt32(1)
+                    ?: configuration->writeToParcel(&data);
+        if (status != NO_ERROR) {
+            ALOGW("applyVolumeShaper failed configuration parceling: %d", status);
+            return; // ignore error
+        }
+
+        status = operation.get() == nullptr
+                ? status = data.writeInt32(0)
+                : data.writeInt32(1)
+                    ?: operation->writeToParcel(&data);
+        if (status != NO_ERROR) {
+            ALOGW("applyVolumeShaper failed operation parceling: %d", status);
+            return; // ignore error
+        }
+
+        status = remote()->transact(APPLY_VOLUME_SHAPER, data, &reply);
+
+        ALOGW_IF(status != NO_ERROR, "applyVolumeShaper failed transact: %d", status);
+        return; // one way transaction, ignore error
+    }
 };
 
 IMPLEMENT_META_INTERFACE(Player, "android.media.IPlayer");
@@ -128,6 +159,28 @@
             setStartDelayMs(data.readInt32());
             return NO_ERROR;
         } break;
+        case APPLY_VOLUME_SHAPER: {
+            CHECK_INTERFACE(IPlayer, data, reply);
+            sp<VolumeShaper::Configuration> configuration;
+            sp<VolumeShaper::Operation> operation;
+
+            int32_t present;
+            status_t status = data.readInt32(&present);
+            if (status == NO_ERROR && present != 0) {
+                configuration = new VolumeShaper::Configuration();
+                status = configuration->readFromParcel(data);
+            }
+            status = status ?: data.readInt32(&present);
+            if (status == NO_ERROR && present != 0) {
+                operation = new VolumeShaper::Operation();
+                status = operation->readFromParcel(data);
+            }
+            if (status == NO_ERROR) {
+                // one way transaction, no error returned
+                applyVolumeShaper(configuration, operation);
+            }
+            return NO_ERROR;
+        } break;
         default:
             return BBinder::onTransact(code, data, reply, flags);
     }
diff --git a/services/surfaceflinger/Android.mk b/services/surfaceflinger/Android.mk
index aa8f189..9e81a8c 100644
--- a/services/surfaceflinger/Android.mk
+++ b/services/surfaceflinger/Android.mk
@@ -133,6 +133,7 @@
 
 LOCAL_STATIC_LIBRARIES := \
     libhwcomposer-command-buffer \
+    android.hardware.configstore-utils \
     libtrace_proto \
     libvkjson \
     libvr_manager \
diff --git a/services/surfaceflinger/DisplayDevice.cpp b/services/surfaceflinger/DisplayDevice.cpp
index 6c18ef7..9af4402 100644
--- a/services/surfaceflinger/DisplayDevice.cpp
+++ b/services/surfaceflinger/DisplayDevice.cpp
@@ -47,6 +47,9 @@
 #include "SurfaceFlinger.h"
 #include "Layer.h"
 
+#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
+#include <configstore/Utils.h>
+
 // ----------------------------------------------------------------------------
 using namespace android;
 // ----------------------------------------------------------------------------
@@ -57,6 +60,14 @@
 static constexpr bool kEGLAndroidSwapRectangle = false;
 #endif
 
+// retrieve triple buffer setting from configstore
+using namespace android::hardware::configstore;
+using namespace android::hardware::configstore::V1_0;
+
+static bool useTripleFramebuffer = getBool<
+        ISurfaceFlingerConfigs,
+        &ISurfaceFlingerConfigs::useTripleFramebuffer>(false);
+
 #if !defined(EGL_EGLEXT_PROTOTYPES) || !defined(EGL_ANDROID_swap_rectangle)
 // Dummy implementation in case it is missing.
 inline void eglSetSwapRectangleANDROID (EGLDisplay, EGLSurface, EGLint, EGLint, EGLint, EGLint) {
@@ -165,9 +176,9 @@
     // initialize the display orientation transform.
     setProjection(DisplayState::eOrientationDefault, mViewport, mFrame);
 
-#ifdef NUM_FRAMEBUFFER_SURFACE_BUFFERS
-    surface->allocateBuffers();
-#endif
+    if (useTripleFramebuffer) {
+        surface->allocateBuffers();
+    }
 }
 
 DisplayDevice::~DisplayDevice() {
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index 6e0a489..a854aec 100644
--- a/services/surfaceflinger/Layer.cpp
+++ b/services/surfaceflinger/Layer.cpp
@@ -155,6 +155,10 @@
             flinger->getHwComposer().getRefreshPeriod(HWC_DISPLAY_PRIMARY);
 #endif
     mFrameTracker.setDisplayRefreshPeriod(displayPeriod);
+
+    CompositorTiming compositorTiming;
+    flinger->getCompositorTiming(&compositorTiming);
+    mFrameEventHistory.initializeCompositorTiming(compositorTiming);
 }
 
 void Layer::onFirstRef() {
@@ -1882,10 +1886,10 @@
     return mQueuedFrames > 0 || mSidebandStreamChanged || mAutoRefresh;
 }
 
-bool Layer::onPostComposition(
-        const std::shared_ptr<FenceTime>& glDoneFence,
+bool Layer::onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence,
         const std::shared_ptr<FenceTime>& presentFence,
-        const std::shared_ptr<FenceTime>& retireFence) {
+        const std::shared_ptr<FenceTime>& retireFence,
+        const CompositorTiming& compositorTiming) {
     mAcquireTimeline.updateSignalTimes();
     mReleaseTimeline.updateSignalTimes();
 
@@ -1898,7 +1902,7 @@
     {
         Mutex::Autolock lock(mFrameEventHistoryMutex);
         mFrameEventHistory.addPostComposition(mCurrentFrameNumber,
-                glDoneFence, presentFence);
+                glDoneFence, presentFence, compositorTiming);
         mFrameEventHistory.addRetire(mPreviousFrameNumber,
                 retireFence);
     }
diff --git a/services/surfaceflinger/Layer.h b/services/surfaceflinger/Layer.h
index 12166a8..8227dae 100644
--- a/services/surfaceflinger/Layer.h
+++ b/services/surfaceflinger/Layer.h
@@ -296,10 +296,10 @@
      * called after composition.
      * returns true if the layer latched a new buffer this frame.
      */
-    bool onPostComposition(
-            const std::shared_ptr<FenceTime>& glDoneFence,
+    bool onPostComposition(const std::shared_ptr<FenceTime>& glDoneFence,
             const std::shared_ptr<FenceTime>& presentFence,
-            const std::shared_ptr<FenceTime>& retireFence);
+            const std::shared_ptr<FenceTime>& retireFence,
+            const CompositorTiming& compositorTiming);
 
 #ifdef USE_HWC2
     // If a buffer was replaced this frame, release the former buffer
diff --git a/services/surfaceflinger/SurfaceFlinger.cpp b/services/surfaceflinger/SurfaceFlinger.cpp
index cbc209d..462e5a6 100644
--- a/services/surfaceflinger/SurfaceFlinger.cpp
+++ b/services/surfaceflinger/SurfaceFlinger.cpp
@@ -87,6 +87,7 @@
 #include <cutils/compiler.h>
 
 #include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
+#include <configstore/Utils.h>
 
 #define DISPLAY_COUNT       1
 
@@ -100,22 +101,9 @@
 
 namespace android {
 
+using namespace android::hardware::configstore;
 using namespace android::hardware::configstore::V1_0;
 
-static sp<ISurfaceFlingerConfigs> getConfigs() {
-    static sp<ISurfaceFlingerConfigs> configs
-            = ISurfaceFlingerConfigs::getService();
-    return configs;
-}
-
-static int64_t getVsyncEventPhaseOffsetNs() {
-    int64_t ret = 1000000; // default value
-    getConfigs()->vsyncEventPhaseOffsetNs([&](OptionalInt64 value) {
-          if (value.specified) ret = value.value;
-    });
-    return ret;
-}
-
 // This is the phase offset in nanoseconds of the software vsync event
 // relative to the vsync event reported by HWComposer.  The software vsync
 // event is when SurfaceFlinger and Choreographer-based applications run each
@@ -136,10 +124,12 @@
 // the latency will end up being an additional vsync period, and animations
 // will hiccup.  Therefore, this latency should be tuned somewhat
 // conservatively (or at least with awareness of the trade-off being made).
-static int64_t vsyncPhaseOffsetNs = getVsyncEventPhaseOffsetNs();
+static int64_t vsyncPhaseOffsetNs = getInt64<
+        ISurfaceFlingerConfigs,
+        &ISurfaceFlingerConfigs::vsyncEventPhaseOffsetNs>(1000000);
 
 // This is the phase offset at which SurfaceFlinger's composition runs.
-static const int64_t sfVsyncPhaseOffsetNs = SF_VSYNC_EVENT_PHASE_OFFSET_NS;
+static constexpr int64_t sfVsyncPhaseOffsetNs = SF_VSYNC_EVENT_PHASE_OFFSET_NS;
 
 // ---------------------------------------------------------------------------
 
@@ -1126,6 +1116,11 @@
     }
 }
 
+void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
+    std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+    *compositorTiming = mCompositorTiming;
+}
+
 void SurfaceFlinger::onHotplugReceived(int32_t disp, bool connected) {
     ALOGV("onHotplugReceived(%d, %s)", disp, connected ? "true" : "false");
     if (disp == DisplayDevice::DISPLAY_PRIMARY) {
@@ -1261,11 +1256,13 @@
     ATRACE_CALL();
     switch (what) {
         case MessageQueue::INVALIDATE: {
-            updateVrMode();
+            // TODO(eieio): Disabled until SELinux issues are resolved.
+            //updateVrMode();
 
             bool frameMissed = !mHadClientComposition &&
                     mPreviousPresentFence != Fence::NO_FENCE &&
-                    mPreviousPresentFence->getSignalTime() == INT64_MAX;
+                    (mPreviousPresentFence->getSignalTime() ==
+                            Fence::SIGNAL_TIME_PENDING);
             ATRACE_INT("FrameMissed", static_cast<int>(frameMissed));
             if (mPropagateBackpressure && frameMissed) {
                 signalLayerUpdate();
@@ -1314,7 +1311,7 @@
     setUpHWComposer();
     doDebugFlashRegions();
     doComposition();
-    postComposition();
+    postComposition(refreshStartTime);
 
     mPreviousPresentFence = mHwc->getPresentFence(HWC_DISPLAY_PRIMARY);
 
@@ -1389,7 +1386,61 @@
     }
 }
 
-void SurfaceFlinger::postComposition()
+void SurfaceFlinger::updateCompositorTiming(
+        nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
+        std::shared_ptr<FenceTime>& presentFenceTime) {
+    // Update queue of past composite+present times and determine the
+    // most recently known composite to present latency.
+    mCompositePresentTimes.push({compositeTime, presentFenceTime});
+    nsecs_t compositeToPresentLatency = -1;
+    while (!mCompositePresentTimes.empty()) {
+        CompositePresentTime& cpt = mCompositePresentTimes.front();
+        // Cached values should have been updated before calling this method,
+        // which helps avoid duplicate syscalls.
+        nsecs_t displayTime = cpt.display->getCachedSignalTime();
+        if (displayTime == Fence::SIGNAL_TIME_PENDING) {
+            break;
+        }
+        compositeToPresentLatency = displayTime - cpt.composite;
+        mCompositePresentTimes.pop();
+    }
+
+    // Don't let mCompositePresentTimes grow unbounded, just in case.
+    while (mCompositePresentTimes.size() > 16) {
+        mCompositePresentTimes.pop();
+    }
+
+    // Integer division and modulo round toward 0 not -inf, so we need to
+    // treat negative and positive offsets differently.
+    nsecs_t idealLatency = (sfVsyncPhaseOffsetNs >= 0) ?
+            (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
+            ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
+
+    // Snap the latency to a value that removes scheduling jitter from the
+    // composition and present times, which often have >1ms of jitter.
+    // Reducing jitter is important if an app attempts to extrapolate
+    // something (such as user input) to an accurate diasplay time.
+    // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
+    // with (presentLatency % interval).
+    nsecs_t snappedCompositeToPresentLatency = -1;
+    if (compositeToPresentLatency >= 0) {
+        nsecs_t bias = vsyncInterval / 2;
+        int64_t extraVsyncs =
+                (compositeToPresentLatency - idealLatency + bias) /
+                vsyncInterval;
+        nsecs_t extraLatency = extraVsyncs * vsyncInterval;
+        snappedCompositeToPresentLatency = idealLatency + extraLatency;
+    }
+
+    std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+    mCompositorTiming.deadline = vsyncPhase - idealLatency;
+    mCompositorTiming.interval = vsyncInterval;
+    if (snappedCompositeToPresentLatency >= 0) {
+        mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
+    }
+}
+
+void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
 {
     ATRACE_CALL();
     ALOGV("postComposition");
@@ -1424,9 +1475,19 @@
     } else {
         retireFenceTime = &displayFenceTime;
     }
+
+    nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
+    nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
+
+    // We use the refreshStartTime which might be sampled a little later than
+    // when we started doing work for this frame, but that should be okay
+    // since updateCompositorTiming has snapping logic.
+    updateCompositorTiming(
+        vsyncPhase, vsyncInterval, refreshStartTime, displayFenceTime);
+
     mDrawingState.traverseInZOrder([&](Layer* layer) {
         bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
-                *presentFenceTime, *retireFenceTime);
+                *presentFenceTime, *retireFenceTime, mCompositorTiming);
         if (frameLatched) {
             recordBufferingStats(layer->getName().string(),
                     layer->getOccupancyHistory(false));
@@ -1471,9 +1532,8 @@
     if (mHasPoweredOff) {
         mHasPoweredOff = false;
     } else {
-        nsecs_t period = mPrimaryDispSync.getPeriod();
         nsecs_t elapsedTime = currentTime - mLastSwapTime;
-        size_t numPeriods = static_cast<size_t>(elapsedTime / period);
+        size_t numPeriods = static_cast<size_t>(elapsedTime / vsyncInterval);
         if (numPeriods < NUM_BUCKETS - 1) {
             mFrameBuckets[numPeriods] += elapsedTime;
         } else {
@@ -2876,6 +2936,11 @@
     const auto& activeConfig = mHwc->getActiveConfig(HWC_DISPLAY_PRIMARY);
     const nsecs_t period = activeConfig->getVsyncPeriod();
     mAnimFrameTracker.setDisplayRefreshPeriod(period);
+
+    {
+        std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+        mCompositorTiming.interval = period;
+    }
 }
 
 void SurfaceFlinger::initializeDisplays() {
diff --git a/services/surfaceflinger/SurfaceFlinger.h b/services/surfaceflinger/SurfaceFlinger.h
index 02e4a0c..f52bd2d 100644
--- a/services/surfaceflinger/SurfaceFlinger.h
+++ b/services/surfaceflinger/SurfaceFlinger.h
@@ -42,6 +42,7 @@
 #include <ui/PixelFormat.h>
 #include <ui/mat4.h>
 
+#include <gui/FrameTimestamps.h>
 #include <gui/ISurfaceComposer.h>
 #include <gui/ISurfaceComposerClient.h>
 #include <gui/OccupancyTracker.h>
@@ -65,7 +66,10 @@
 #include "Effects/Daltonizer.h"
 
 #include <map>
+#include <mutex>
+#include <queue>
 #include <string>
+#include <utility>
 
 namespace android {
 
@@ -413,7 +417,10 @@
             Region& dirtyRegion, Region& opaqueRegion);
 
     void preComposition(nsecs_t refreshStartTime);
-    void postComposition();
+    void postComposition(nsecs_t refreshStartTime);
+    void updateCompositorTiming(
+            nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
+            std::shared_ptr<FenceTime>& presentFenceTime);
     void rebuildLayerStacks();
     void setUpHWComposer();
     void doComposition();
@@ -434,12 +441,13 @@
     /* ------------------------------------------------------------------------
      * VSync
      */
-     void enableHardwareVsync();
-     void resyncToHardwareVsync(bool makeAvailable);
-     void disableHardwareVsync(bool makeUnavailable);
+    void enableHardwareVsync();
+    void resyncToHardwareVsync(bool makeAvailable);
+    void disableHardwareVsync(bool makeUnavailable);
 
 public:
-     void resyncWithRateLimit();
+    void resyncWithRateLimit();
+    void getCompositorTiming(CompositorTiming* compositorTiming);
 private:
 
     /* ------------------------------------------------------------------------
@@ -581,6 +589,17 @@
     bool mPrimaryHWVsyncEnabled;
     bool mHWVsyncAvailable;
 
+    // protected by mCompositorTimingLock;
+    mutable std::mutex mCompositeTimingLock;
+    CompositorTiming mCompositorTiming;
+
+    // Only accessed from the main thread.
+    struct CompositePresentTime {
+        nsecs_t composite { -1 };
+        std::shared_ptr<FenceTime> display { FenceTime::NO_FENCE };
+    };
+    std::queue<CompositePresentTime> mCompositePresentTimes;
+
     /* ------------------------------------------------------------------------
      * Feature prototyping
      */
diff --git a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
index 40a27e8..477eb27 100644
--- a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
+++ b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
@@ -1036,6 +1036,11 @@
     }
 }
 
+void SurfaceFlinger::getCompositorTiming(CompositorTiming* compositorTiming) {
+    std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+    *compositorTiming = mCompositorTiming;
+}
+
 void SurfaceFlinger::onHotplugReceived(int type, bool connected) {
     if (mEventThread == NULL) {
         // This is a temporary workaround for b/7145521.  A non-null pointer
@@ -1114,7 +1119,7 @@
     setUpHWComposer();
     doDebugFlashRegions();
     doComposition();
-    postComposition();
+    postComposition(refreshStartTime);
 }
 
 void SurfaceFlinger::doDebugFlashRegions()
@@ -1171,7 +1176,61 @@
     }
 }
 
-void SurfaceFlinger::postComposition()
+void SurfaceFlinger::updateCompositorTiming(
+        nsecs_t vsyncPhase, nsecs_t vsyncInterval, nsecs_t compositeTime,
+        std::shared_ptr<FenceTime>& presentFenceTime) {
+    // Update queue of past composite+present times and determine the
+    // most recently known composite to present latency.
+    mCompositePresentTimes.push({compositeTime, presentFenceTime});
+    nsecs_t compositeToPresentLatency = -1;
+    while (!mCompositePresentTimes.empty()) {
+        CompositePresentTime& cpt = mCompositePresentTimes.front();
+        // Cached values should have been updated before calling this method,
+        // which helps avoid duplicate syscalls.
+        nsecs_t displayTime = cpt.display->getCachedSignalTime();
+        if (displayTime == Fence::SIGNAL_TIME_PENDING) {
+            break;
+        }
+        compositeToPresentLatency = displayTime - cpt.composite;
+        mCompositePresentTimes.pop();
+    }
+
+    // Don't let mCompositePresentTimes grow unbounded, just in case.
+    while (mCompositePresentTimes.size() > 16) {
+        mCompositePresentTimes.pop();
+    }
+
+    // Integer division and modulo round toward 0 not -inf, so we need to
+    // treat negative and positive offsets differently.
+    nsecs_t idealLatency = (sfVsyncPhaseOffsetNs >= 0) ?
+            (vsyncInterval - (sfVsyncPhaseOffsetNs % vsyncInterval)) :
+            ((-sfVsyncPhaseOffsetNs) % vsyncInterval);
+
+    // Snap the latency to a value that removes scheduling jitter from the
+    // composition and present times, which often have >1ms of jitter.
+    // Reducing jitter is important if an app attempts to extrapolate
+    // something (such as user input) to an accurate diasplay time.
+    // Snapping also allows an app to precisely calculate sfVsyncPhaseOffsetNs
+    // with (presentLatency % interval).
+    nsecs_t snappedCompositeToPresentLatency = -1;
+    if (compositeToPresentLatency >= 0) {
+        nsecs_t bias = vsyncInterval / 2;
+        int64_t extraVsyncs =
+                (compositeToPresentLatency - idealLatency + bias) /
+                vsyncInterval;
+        nsecs_t extraLatency = extraVsyncs * vsyncInterval;
+        snappedCompositeToPresentLatency = idealLatency + extraLatency;
+    }
+
+    std::lock_guard<std::mutex> lock(mCompositeTimingLock);
+    mCompositorTiming.deadline = vsyncPhase - idealLatency;
+    mCompositorTiming.interval = vsyncInterval;
+    if (snappedCompositeToPresentLatency >= 0) {
+        mCompositorTiming.presentLatency = snappedCompositeToPresentLatency;
+    }
+}
+
+void SurfaceFlinger::postComposition(nsecs_t refreshStartTime)
 {
     const HWComposer& hwc = getHwComposer();
     const sp<const DisplayDevice> hw(getDefaultDisplayDevice());
@@ -1192,10 +1251,18 @@
     mDisplayTimeline.push(retireFenceTime);
     mDisplayTimeline.updateSignalTimes();
 
+    nsecs_t vsyncPhase = mPrimaryDispSync.computeNextRefresh(0);
+    nsecs_t vsyncInterval = mPrimaryDispSync.getPeriod();
+
+    // We use the refreshStartTime which might be sampled a little later than
+    // when we started doing work for this frame, but that should be okay
+    // since updateCompositorTiming has snapping logic.
+    updateCompositorTiming(
+        vsyncPhase, vsyncInterval, refreshStartTime, retireFenceTime);
+
     mDrawingState.traverseInZOrder([&](Layer* layer) {
         bool frameLatched = layer->onPostComposition(glCompositionDoneFenceTime,
-                presentFenceTime, retireFenceTime);
-
+                presentFenceTime, retireFenceTime, mCompositorTiming);
         if (frameLatched) {
             recordBufferingStats(layer->getName().string(),
                     layer->getOccupancyHistory(false));
diff --git a/services/vr/sensord/sensord.rc b/services/vr/sensord/sensord.rc
index 0311474..d868a7e 100644
--- a/services/vr/sensord/sensord.rc
+++ b/services/vr/sensord/sensord.rc
@@ -1,3 +1,7 @@
+on init
+  mkdir /dev/socket/pdx/system/vr/pose 0775 system system
+  mkdir /dev/socket/pdx/system/vr/sensors 0775 system system
+
 service sensord /system/bin/sensord
   class core
   user system
diff --git a/services/vr/vr_window_manager/Android.mk b/services/vr/vr_window_manager/Android.mk
index 85f8e1f..e9552bc 100644
--- a/services/vr/vr_window_manager/Android.mk
+++ b/services/vr/vr_window_manager/Android.mk
@@ -37,33 +37,18 @@
 LOCAL_MODULE_TAGS := optional
 include $(BUILD_STATIC_LIBRARY)
 
-
 native_src := \
   application.cpp \
   controller_mesh.cpp \
   elbow_model.cpp \
   hwc_callback.cpp \
   reticle.cpp \
-  render_thread.cpp \
   shell_view.cpp \
   surface_flinger_view.cpp \
   texture.cpp \
   vr_window_manager.cpp \
   ../virtual_touchpad/aidl/android/dvr/VirtualTouchpadService.aidl \
 
-src := \
-  vr_window_manager_jni.cpp \
-  application.cpp \
-  controller_mesh.cpp \
-  elbow_model.cpp \
-  hwc_callback.cpp \
-  reticle.cpp \
-  render_thread.cpp \
-  shell_view.cpp \
-  surface_flinger_view.cpp \
-  texture.cpp \
-  ../virtual_touchpad/aidl/android/dvr/VirtualTouchpadService.aidl \
-
 static_libs := \
   libdisplay \
   libbufferhub \
@@ -86,6 +71,7 @@
   libbinder \
   libinput \
   libhardware \
+  libhwbinder \
   libsync \
   libutils \
   libgui \
@@ -97,62 +83,19 @@
   libhidlbase \
   libhidltransport
 
-
-include $(CLEAR_VARS)
-LOCAL_SRC_FILES := $(src)
-LOCAL_STATIC_LIBRARIES := $(static_libs)
-LOCAL_SHARED_LIBRARIES := $(shared_libs)
-LOCAL_SHARED_LIBRARIES += libgvr
-LOCAL_STATIC_LIBRARIES += libgvr_ext
-LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
-LOCAL_CFLAGS += -DEGL_EGLEXT_PROTOTYPES
-LOCAL_CFLAGS += -DLOG_TAG=\"VrWindowManager\"
-LOCAL_LDLIBS := -llog
-LOCAL_MODULE := libvr_window_manager_jni
-LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-LOCAL_MULTILIB := 64
-LOCAL_CXX_STL := libc++_static
-include $(BUILD_SHARED_LIBRARY)
-
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES := $(native_src)
 LOCAL_STATIC_LIBRARIES := $(static_libs) libvrwm_binder
 LOCAL_SHARED_LIBRARIES := $(shared_libs)
-LOCAL_SHARED_LIBRARIES += libgvr
-LOCAL_STATIC_LIBRARIES += libgvr_ext
 LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES
 LOCAL_CFLAGS += -DEGL_EGLEXT_PROTOTYPES
 LOCAL_CFLAGS += -DLOG_TAG=\"VrWindowManager\"
 LOCAL_LDLIBS := -llog
 LOCAL_MODULE := vr_wm
 LOCAL_MODULE_TAGS := optional
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
 LOCAL_INIT_RC := vr_wm.rc
 include $(BUILD_EXECUTABLE)
 
-include $(CLEAR_VARS)
-LOCAL_PACKAGE_NAME := VrWindowManager
-
-# We need to be priveleged to run as the system user, which is necessary for
-# getting hmd input events and doing input injection.
-LOCAL_CERTIFICATE := platform
-LOCAL_PRIVILEGED_MODULE := true
-
-LOCAL_MODULE_TAGS := optional
-LOCAL_SRC_FILES := $(call all-java-files-under, java)
-LOCAL_JNI_SHARED_LIBRARIES := libvr_window_manager_jni
-LOCAL_STATIC_JAVA_AAR_LIBRARIES := gvr_common_library_aar
-# gvr_common_library_aar depends on nano version of libprotobuf
-LOCAL_STATIC_JAVA_LIBRARIES := libprotobuf-java-nano
-# Make sure that libgvr's resources are loaded
-LOCAL_AAPT_FLAGS += --auto-add-overlay
-LOCAL_AAPT_FLAGS += --extra-packages com.google.vr.cardboard
-LOCAL_PROGUARD_FLAG_FILES := proguard.flags
-LOCAL_MODULE_TARGET_ARCH := arm arm64 x86 x86_64
-include $(BUILD_PACKAGE)
-
-
 cmd_src := \
   vr_wm_ctl.cpp \
   aidl/android/service/vr/IVrWindowManager.aidl
diff --git a/services/vr/vr_window_manager/AndroidManifest.xml b/services/vr/vr_window_manager/AndroidManifest.xml
deleted file mode 100644
index d5008a3..0000000
--- a/services/vr/vr_window_manager/AndroidManifest.xml
+++ /dev/null
@@ -1,34 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<manifest xmlns:android="http://schemas.android.com/apk/res/android"
-          package="com.google.vr.windowmanager"
-          coreApp="true"
-          android:sharedUserId="android.uid.system"
-          android:versionCode="1"
-          android:versionName="1.0" >
-
-  <!-- The GVR SDK requires API 19+ and OpenGL ES 2+. -->
-  <uses-sdk android:minSdkVersion="19" android:targetSdkVersion="24" />
-  <uses-feature android:glEsVersion="0x00020000" android:required="true" />
-
-  <!-- We need the DIAGNOSTIC permission to read HMD button events. DIAGNOSTIC
-       ensures our process runs with the "input" group, so we can access
-       /dev/input. See frameworks/base/data/etc/platform.xml for the permission
-       to group mappings.
-
-       TODO(steventhomas): We shouldn't use this DIAGNOSTIC permission. Figure
-       out the correct way to get access to the HMD buttons.
-       Bug: b/33253485. -->
-  <uses-permission android:name="android.permission.DIAGNOSTIC"/>
-  <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
-
-  <application
-      android:label="vr_window_manager"
-      android:theme="@style/AppStyle">
-    <service android:name=".VrWindowManagerService" />
-    <receiver android:name="com.google.vr.windowmanager.BootCompletedReceiver">
-      <intent-filter>
-        <!-- action android:name="android.intent.action.BOOT_COMPLETED" / -->
-      </intent-filter>
-    </receiver>
-  </application>
-</manifest>
diff --git a/services/vr/vr_window_manager/application.cpp b/services/vr/vr_window_manager/application.cpp
index 895f25f..33cd499 100644
--- a/services/vr/vr_window_manager/application.cpp
+++ b/services/vr/vr_window_manager/application.cpp
@@ -16,25 +16,18 @@
 namespace android {
 namespace dvr {
 
-Application::Application()
-    : controller_api_status_logged_(false),
-      controller_connection_state_logged_(false) {}
+Application::Application() {}
 
 Application::~Application() {
 }
 
-int Application::Initialize(JNIEnv* env, jobject app_context,
-                            jobject class_loader) {
+int Application::Initialize() {
   dvrSetCpuPartition(0, "/application/performance");
 
   bool is_right_handed = true;  // TODO: retrieve setting from system
   elbow_model_.Enable(ElbowModel::kDefaultNeckPosition, is_right_handed);
   last_frame_time_ = std::chrono::system_clock::now();
 
-  java_env_ = env;
-  app_context_ = app_context;
-  class_loader_ = class_loader;
-
   return 0;
 }
 
@@ -100,42 +93,10 @@
   fov_[1] = FieldOfView(lens_info.right_fov[0], lens_info.right_fov[1],
                         lens_info.right_fov[2], lens_info.right_fov[3]);
 
-  if (java_env_) {
-    int ret = InitializeController();
-    if (ret)
-      return ret;
-  }
-
-  return 0;
-}
-
-int Application::InitializeController() {
-  gvr_context_ = gvr::GvrApi::Create(java_env_, app_context_, class_loader_);
-  if (gvr_context_ == nullptr) {
-    ALOGE("Gvr context creation failed");
-    return 1;
-  }
-
-  int32_t options = gvr_controller_get_default_options();
-  options |= GVR_CONTROLLER_ENABLE_GYRO | GVR_CONTROLLER_ENABLE_ACCEL;
-
-  controller_.reset(new gvr::ControllerApi);
-  if (!controller_->Init(java_env_, app_context_, class_loader_, options,
-                         gvr_context_->cobj())) {
-    ALOGE("Gvr controller init failed");
-    return 1;
-  }
-
-  controller_state_.reset(new gvr::ControllerState);
-
   return 0;
 }
 
 void Application::DeallocateResources() {
-  gvr_context_.reset();
-  controller_.reset();
-  controller_state_.reset();
-
   if (graphics_context_)
     dvrGraphicsContextDestroy(graphics_context_);
 
@@ -162,8 +123,8 @@
         break;
       case MainThreadTask::EnteringVrMode:
         if (!initialized_) {
-          if (AllocateResources())
-            ALOGE("Failed to allocate resources");
+          LOG_ALWAYS_FATAL_IF(AllocateResources(),
+                              "Failed to allocate resources");
         }
         break;
       case MainThreadTask::ExitingVrMode:
@@ -309,47 +270,6 @@
       return;
     }
   }
-
-  if (!controller_)
-    return;
-
-  controller_state_->Update(*controller_);
-  gvr::ControllerApiStatus new_api_status = controller_state_->GetApiStatus();
-  gvr::ControllerConnectionState new_connection_state =
-      controller_state_->GetConnectionState();
-
-  if (!controller_api_status_logged_) {
-    controller_api_status_logged_ = true;
-    ALOGI("Controller api status: %s",
-          gvr::ControllerApi::ToString(new_api_status));
-  } else if (new_api_status != controller_api_status_) {
-    ALOGI("Controller api status changed: %s --> %s",
-          gvr::ControllerApi::ToString(controller_api_status_),
-          gvr::ControllerApi::ToString(new_api_status));
-  }
-
-  if (new_api_status == gvr::kControllerApiOk) {
-    if (!controller_connection_state_logged_) {
-      controller_connection_state_logged_ = true;
-      ALOGI("Controller connection state: %s",
-            gvr::ControllerApi::ToString(new_connection_state));
-    } else if (new_connection_state != controller_connection_state_) {
-      ALOGI("Controller connection state changed: %s --> %s",
-            gvr::ControllerApi::ToString(controller_connection_state_),
-            gvr::ControllerApi::ToString(new_connection_state));
-    }
-  } else {
-    controller_connection_state_logged_ = false;
-  }
-
-  if (new_api_status == gvr::kControllerApiOk) {
-    gvr_quatf orientation = controller_state_->GetOrientation();
-    controller_orientation_ =
-        quat(orientation.qw, orientation.qx, orientation.qy, orientation.qz);
-  }
-
-  controller_api_status_ = new_api_status;
-  controller_connection_state_ = new_connection_state;
 }
 
 void Application::SetVisibility(bool visible) {
@@ -357,12 +277,6 @@
   if (changed) {
     is_visible_ = visible;
     dvrGraphicsSurfaceSetVisible(graphics_context_, is_visible_);
-    if (controller_) {
-      if (is_visible_)
-        controller_->Resume();
-      else
-        controller_->Pause();
-    }
     OnVisibilityChanged(is_visible_);
   }
 }
diff --git a/services/vr/vr_window_manager/application.h b/services/vr/vr_window_manager/application.h
index 0c6385f..c7aa4dd 100644
--- a/services/vr/vr_window_manager/application.h
+++ b/services/vr/vr_window_manager/application.h
@@ -1,15 +1,13 @@
 #ifndef VR_WINDOW_MANAGER_APPLICATION_H_
 #define VR_WINDOW_MANAGER_APPLICATION_H_
 
-#include <jni.h>
 #include <memory>
 #include <private/dvr/types.h>
 #include <stdint.h>
-#include <vr/gvr/capi/include/gvr.h>
-#include <vr/gvr/capi/include/gvr_controller.h>
 
 #include <chrono>
 #include <mutex>
+#include <vector>
 
 #include "controller_data_provider.h"
 #include "elbow_model.h"
@@ -25,8 +23,7 @@
   Application();
   virtual ~Application();
 
-  virtual int Initialize(JNIEnv* env, jobject app_context,
-                         jobject class_loader);
+  virtual int Initialize();
 
   virtual int AllocateResources();
   virtual void DeallocateResources();
@@ -59,8 +56,6 @@
 
   void QueueTask(MainThreadTask task);
 
-  int InitializeController();
-
   DvrGraphicsContext* graphics_context_ = nullptr;
   DvrPose* pose_client_ = nullptr;
 
@@ -69,15 +64,8 @@
   FieldOfView fov_[2];
   Posef last_pose_;
 
-  std::unique_ptr<gvr::GvrApi> gvr_context_;
-  std::unique_ptr<gvr::ControllerApi> controller_;
-  std::unique_ptr<gvr::ControllerState> controller_state_;
-  gvr::ControllerApiStatus controller_api_status_;
-  gvr::ControllerConnectionState controller_connection_state_;
   quat controller_orientation_;
   bool shmem_controller_active_ = false;
-  bool controller_api_status_logged_;
-  bool controller_connection_state_logged_;
   uint64_t shmem_controller_buttons_;
 
   bool is_visible_ = false;
@@ -95,11 +83,6 @@
   bool initialized_ = false;
   std::vector<MainThreadTask> main_thread_tasks_;
 
-  // Java Resources.
-  JNIEnv* java_env_;
-  jobject app_context_;
-  jobject class_loader_;
-
   // Controller data provider from shared memory buffer.
   ControllerDataProvider* controller_data_provider_ = nullptr;
 
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp b/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp
index 5f8168d..1096a37 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp
+++ b/services/vr/vr_window_manager/composer/impl/vr_composer_view.cpp
@@ -3,7 +3,9 @@
 namespace android {
 namespace dvr {
 
-VrComposerView::VrComposerView() : composer_view_(nullptr) {}
+VrComposerView::VrComposerView(
+    std::unique_ptr<VrComposerView::Callback> callback)
+    : composer_view_(nullptr), callback_(std::move(callback)) {}
 
 VrComposerView::~VrComposerView() {
   composer_view_->UnregisterObserver(this);
@@ -14,66 +16,19 @@
   composer_view_->RegisterObserver(this);
 }
 
-Return<void> VrComposerView::registerCallback(
-    const sp<IVrComposerCallback>& callback) {
-  callback_ = callback;
-  return Void();
-}
-
-Return<void> VrComposerView::releaseFrame() {
+void VrComposerView::ReleaseFrame() {
+  LOG_ALWAYS_FATAL_IF(!composer_view_, "VrComposerView not initialized");
   composer_view_->ReleaseFrame();
-  return Void();
 }
 
 void VrComposerView::OnNewFrame(const ComposerView::Frame& frame) {
+  std::lock_guard<std::mutex> guard(mutex_);
   if (!callback_.get()) {
-    releaseFrame();
+    ReleaseFrame();
     return;
   }
 
-  std::vector<IVrComposerCallback::Layer> layers;
-  std::vector<native_handle_t*> fences;
-  for (size_t i = 0; i < frame.size(); ++i) {
-    native_handle_t* fence;
-    if (frame[i].fence->isValid()) {
-      fence = native_handle_create(1, 0);
-      fence->data[0] = frame[i].fence->dup();
-    } else {
-      fence = native_handle_create(0, 0);
-    }
-    fences.push_back(fence);
-
-    layers.push_back(IVrComposerCallback::Layer{
-      .buffer = hidl_handle(frame[i].buffer->getNativeBuffer()->handle),
-      .fence = hidl_handle(fence),
-      .display_frame = frame[i].display_frame,
-      .crop = frame[i].crop,
-      .blend_mode= frame[i].blend_mode,
-      .alpha = frame[i].alpha,
-      .type = frame[i].type,
-      .app_id = frame[i].app_id,
-    });
-  }
-
-  auto status =
-      callback_->onNewFrame(hidl_vec<IVrComposerCallback::Layer>(layers));
-  if (!status.isOk()) {
-    ALOGE("Failed to send onNewFrame: %s", status.description().c_str());
-    releaseFrame();
-  }
-
-  for (size_t i = 0; i < fences.size(); ++i) {
-    native_handle_close(fences[i]);
-    native_handle_delete(fences[i]);
-  }
-}
-
-VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view) {
-  return static_cast<VrComposerView*>(view);
-}
-
-IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name) {
-  return new VrComposerView();
+  callback_->OnNewFrame(frame);
 }
 
 }  // namespace dvr
diff --git a/services/vr/vr_window_manager/composer/impl/vr_composer_view.h b/services/vr/vr_window_manager/composer/impl/vr_composer_view.h
index 133bbc8..5a938e9 100644
--- a/services/vr/vr_window_manager/composer/impl/vr_composer_view.h
+++ b/services/vr/vr_window_manager/composer/impl/vr_composer_view.h
@@ -1,41 +1,37 @@
 #ifndef VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
 #define VR_WINDOW_MANAGER_COMPOSER_IMPL_VR_COMPOSER_VIEW_H_
 
-#include <android/dvr/composer/1.0/IVrComposerCallback.h>
-#include <android/dvr/composer/1.0/IVrComposerView.h>
+#include <memory>
 
 #include "vr_hwc.h"
 
 namespace android {
 namespace dvr {
 
-using composer::V1_0::IVrComposerView;
-using composer::V1_0::IVrComposerCallback;
-
-class VrComposerView : public IVrComposerView, public ComposerView::Observer {
+class VrComposerView : public ComposerView::Observer {
  public:
-  VrComposerView();
+  class Callback {
+   public:
+    virtual ~Callback() = default;
+    virtual void OnNewFrame(const ComposerView::Frame& frame) = 0;
+  };
+
+  VrComposerView(std::unique_ptr<Callback> callback);
   ~VrComposerView() override;
 
   void Initialize(ComposerView* composer_view);
 
-  // IVrComposerView
-  Return<void> registerCallback(const sp<IVrComposerCallback>& callback)
-      override;
-  Return<void> releaseFrame() override;
+  void ReleaseFrame();
 
   // ComposerView::Observer
   void OnNewFrame(const ComposerView::Frame& frame) override;
 
  private:
   ComposerView* composer_view_;
-  sp<IVrComposerCallback> callback_;
+  std::unique_ptr<Callback> callback_;
+  std::mutex mutex_;
 };
 
-VrComposerView* GetVrComposerViewFromIVrComposerView(IVrComposerView* view);
-
-IVrComposerView* HIDL_FETCH_IVrComposerView(const char* name);
-
 }  // namespace dvr
 }  // namespace android
 
diff --git a/services/vr/vr_window_manager/hwc_callback.cpp b/services/vr/vr_window_manager/hwc_callback.cpp
index 12a76d8..b29d175 100644
--- a/services/vr/vr_window_manager/hwc_callback.cpp
+++ b/services/vr/vr_window_manager/hwc_callback.cpp
@@ -12,11 +12,16 @@
 namespace {
 
 sp<GraphicBuffer> GetBufferFromHandle(const native_handle_t* handle) {
+  GraphicBufferMapper& mapper = GraphicBufferMapper::get();
+  if (mapper.registerBuffer(handle) != OK) {
+    ALOGE("Failed to register buffer");
+    return nullptr;
+  }
+
   uint32_t width = 0, height = 0, stride = 0, layer_count = 1;
   uint64_t producer_usage = 0, consumer_usage = 0;
   int32_t format = 0;
 
-  GraphicBufferMapper& mapper = GraphicBufferMapper::get();
   if (mapper.getDimensions(handle, &width, &height) ||
       mapper.getStride(handle, &stride) ||
       mapper.getFormat(handle, &format) ||
@@ -33,10 +38,6 @@
   sp<GraphicBuffer> buffer = new GraphicBuffer(
       width, height, format, layer_count, producer_usage, consumer_usage,
       stride, native_handle_clone(handle), true);
-  if (mapper.registerBuffer(buffer.get()) != OK) {
-    ALOGE("Failed to register buffer");
-    return nullptr;
-  }
 
   return buffer;
 }
@@ -62,27 +63,18 @@
 
 }  // namespace
 
-HwcCallback::HwcCallback(IVrComposerView* composer_view, Client* client)
-    : composer_view_(composer_view),
-      client_(client) {
-  composer_view_->registerCallback(this);
+HwcCallback::HwcCallback(Client* client) : client_(client) {
 }
 
 HwcCallback::~HwcCallback() {
-  composer_view_->registerCallback(nullptr);
 }
 
-Return<void> HwcCallback::onNewFrame(
-    const hidl_vec<IVrComposerCallback::Layer>& frame) {
-
+void HwcCallback::OnNewFrame(const ComposerView::Frame& frame) {
   std::vector<HwcLayer> hwc_frame(frame.size());
   for (size_t i = 0; i < frame.size(); ++i) {
-    int fence = frame[i].fence.getNativeHandle()->numFds ?
-        dup(frame[i].fence.getNativeHandle()->data[0]) : -1;
-
     hwc_frame[i] = HwcLayer{
-      .fence = new Fence(fence),
-      .buffer = GetBufferFromHandle(frame[i].buffer.getNativeHandle()),
+      .fence = frame[i].fence,
+      .buffer = frame[i].buffer,
       .crop = frame[i].crop,
       .display_frame = frame[i].display_frame,
       .blending = static_cast<int32_t>(frame[i].blend_mode),
@@ -92,10 +84,7 @@
     };
   }
 
-  std::lock_guard<std::mutex> guard(mutex_);
   client_->OnFrame(std::make_unique<Frame>(std::move(hwc_frame)));
-
-  return Void();
 }
 
 HwcCallback::Frame::Frame(std::vector<HwcLayer>&& layers)
diff --git a/services/vr/vr_window_manager/hwc_callback.h b/services/vr/vr_window_manager/hwc_callback.h
index 05a889b..d4d6e66 100644
--- a/services/vr/vr_window_manager/hwc_callback.h
+++ b/services/vr/vr_window_manager/hwc_callback.h
@@ -6,8 +6,7 @@
 #include <mutex>
 #include <vector>
 
-#include <android/dvr/composer/1.0/IVrComposerCallback.h>
-#include <android/dvr/composer/1.0/IVrComposerView.h>
+#include <impl/vr_composer_view.h>
 #include <impl/vr_hwc.h>
 
 namespace android {
@@ -20,10 +19,7 @@
 using Recti = ComposerView::ComposerLayer::Recti;
 using Rectf = ComposerView::ComposerLayer::Rectf;
 
-using composer::V1_0::IVrComposerCallback;
-using composer::V1_0::IVrComposerView;
-
-class HwcCallback : public IVrComposerCallback {
+class HwcCallback : public VrComposerView::Callback {
  public:
   struct HwcLayer {
     enum LayerType : uint32_t {
@@ -86,19 +82,12 @@
     virtual void OnFrame(std::unique_ptr<Frame>) = 0;
   };
 
-  explicit HwcCallback(IVrComposerView* composer_view, Client* client);
+  explicit HwcCallback(Client* client);
   ~HwcCallback() override;
 
  private:
-  // This is the only method called on the binder thread. Everything else is
-  // called on the render thread.
-  Return<void> onNewFrame(const hidl_vec<IVrComposerCallback::Layer>& frame)
-      override;
-
-  IVrComposerView* composer_view_;
+  void OnNewFrame(const ComposerView::Frame& frame) override;
   Client *client_;
-  std::mutex mutex_;
-
 
   HwcCallback(const HwcCallback&) = delete;
   void operator=(const HwcCallback&) = delete;
diff --git a/services/vr/vr_window_manager/java/com/google/vr/windowmanager/BootCompletedReceiver.java b/services/vr/vr_window_manager/java/com/google/vr/windowmanager/BootCompletedReceiver.java
deleted file mode 100644
index 01d1bdb..0000000
--- a/services/vr/vr_window_manager/java/com/google/vr/windowmanager/BootCompletedReceiver.java
+++ /dev/null
@@ -1,17 +0,0 @@
-package com.google.vr.windowmanager;
-
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.util.Log;
-
-public class BootCompletedReceiver extends BroadcastReceiver {
-  private static final String TAG = BootCompletedReceiver.class.getSimpleName();
-
-  @Override
-  public void onReceive(Context context, Intent intent) {
-    Log.i(TAG, "Starting VRWindowManager");
-    Intent vrWindowManagerIntent = new Intent(context, VrWindowManagerService.class);
-    context.startService(vrWindowManagerIntent);
-  }
-}
diff --git a/services/vr/vr_window_manager/java/com/google/vr/windowmanager/VrWindowManagerService.java b/services/vr/vr_window_manager/java/com/google/vr/windowmanager/VrWindowManagerService.java
deleted file mode 100644
index 1d815ca..0000000
--- a/services/vr/vr_window_manager/java/com/google/vr/windowmanager/VrWindowManagerService.java
+++ /dev/null
@@ -1,87 +0,0 @@
-package com.google.vr.windowmanager;
-
-import android.app.Service;
-import android.content.BroadcastReceiver;
-import android.content.Context;
-import android.content.Intent;
-import android.content.IntentFilter;
-import android.os.Handler;
-import android.os.IBinder;
-import android.util.Log;
-
-public class VrWindowManagerService extends Service {
-  private static final String TAG = VrWindowManagerService.class.getSimpleName();
-  private long nativeVrWindowManager;
-
-  // This is a temporary debugging tool for development only.
-  // It allows us to show VrWindowManager in debug mode via command line.
-  private final BroadcastReceiver debugReceiver = new BroadcastReceiver() {
-    @Override
-    public void onReceive(Context context, Intent intent) {
-      String action = intent.getAction();
-      if (action.equals("com.google.vr.windowmanager.intent.SHOW")) {
-        nativeEnableDebug(nativeVrWindowManager);
-      } else if (action.equals("com.google.vr.windowmanager.intent.HIDE")) {
-        nativeDisableDebug(nativeVrWindowManager);
-      } else if (action.equals("com.google.vr.windowmanager.intent.ENTER_VR")) {
-        nativeEnterVrMode(nativeVrWindowManager);
-      } else if (action.equals("com.google.vr.windowmanager.intent.EXIT_VR")) {
-        nativeExitVrMode(nativeVrWindowManager);
-      }
-    }
-  };
-
-  static {
-    System.loadLibrary("vr_window_manager_jni");
-  }
-
-  @Override
-  public void onCreate() {
-    super.onCreate();
-    destroyRenderer();
-    nativeVrWindowManager = nativeCreate(getClass().getClassLoader(), getApplicationContext());
-    if (nativeVrWindowManager == 0) {
-      Log.e(TAG, "Failed to create native renderer");
-    }
-
-    // For development, testing and debugging.
-    IntentFilter filter = new IntentFilter();
-    filter.addAction("com.google.vr.windowmanager.intent.SHOW");
-    filter.addAction("com.google.vr.windowmanager.intent.HIDE");
-    filter.addAction("com.google.vr.windowmanager.intent.ENTER_VR");
-    filter.addAction("com.google.vr.windowmanager.intent.EXIT_VR");
-    registerReceiver(debugReceiver, filter);
-  }
-
-  @Override
-  public int onStartCommand(Intent intent, int flags, int startId) {
-    return START_STICKY;
-  }
-
-  @Override
-  public IBinder onBind(Intent intent) {
-    Log.i(TAG, "Ignoring bind request");
-    return null;
-  }
-
-  @Override
-  public void onDestroy() {
-    super.onDestroy();
-    unregisterReceiver(debugReceiver);
-    destroyRenderer();
-  }
-
-  private void destroyRenderer() {
-    if (nativeVrWindowManager != 0) {
-      nativeDestroy(nativeVrWindowManager);
-      nativeVrWindowManager = 0;
-    }
-  }
-
-  private native long nativeCreate(ClassLoader appClassLoader, Context context);
-  private native void nativeDestroy(long nativeVrWindowManager);
-  private native void nativeEnableDebug(long nativeVrWindowManager);
-  private native void nativeDisableDebug(long nativeVrWindowManager);
-  private native void nativeEnterVrMode(long nativeVrWindowManager);
-  private native void nativeExitVrMode(long nativeVrWindowManager);
-}
diff --git a/services/vr/vr_window_manager/render_thread.cpp b/services/vr/vr_window_manager/render_thread.cpp
deleted file mode 100644
index b67a051..0000000
--- a/services/vr/vr_window_manager/render_thread.cpp
+++ /dev/null
@@ -1,91 +0,0 @@
-#include <jni.h>
-#include <log/log.h>
-#include <future>
-
-#include "render_thread.h"
-#include "shell_view.h"
-
-namespace android {
-namespace dvr {
-
-RenderThread::RenderThread(JNIEnv* env, jobject class_loader,
-                           jobject android_context)
-    : jvm_(nullptr),
-      class_loader_global_ref_(0),
-      android_context_global_ref_(0),
-      quit_(false) {
-  env->GetJavaVM(&jvm_);
-
-  // Create global references so we can access these objects on the render
-  // thread
-  class_loader_global_ref_ = env->NewGlobalRef(class_loader);
-  android_context_global_ref_ = env->NewGlobalRef(android_context);
-
-  std::promise<int> render_thread_init_result_promise;
-  thread_ = std::thread([this, &render_thread_init_result_promise] {
-    JNIEnv* render_thread_jni_env = nullptr;
-    jvm_->AttachCurrentThread(&render_thread_jni_env, nullptr);
-    RunRenderLoop(&render_thread_init_result_promise);
-    jvm_->DetachCurrentThread();
-  });
-
-  // Wait to see if the render thread started successfully. If not bail.
-  int render_thread_init_result =
-      render_thread_init_result_promise.get_future().get();
-  LOG_ALWAYS_FATAL_IF(render_thread_init_result != 0,
-                      "Failed initializing render thread. result=%d",
-                      render_thread_init_result);
-}
-
-RenderThread::~RenderThread() { Quit(); }
-
-void RenderThread::Quit() {
-  if (thread_.joinable()) {
-    quit_ = true;
-    thread_.join();
-  }
-
-  JNIEnv* env = GetJniEnv();
-  if (class_loader_global_ref_ != 0) {
-    env->DeleteGlobalRef(class_loader_global_ref_);
-    class_loader_global_ref_ = 0;
-  }
-  if (android_context_global_ref_ != 0) {
-    env->DeleteGlobalRef(android_context_global_ref_);
-    android_context_global_ref_ = 0;
-  }
-}
-
-void RenderThread::EnableDebug(bool debug) { shell_view_.EnableDebug(debug); }
-
-void RenderThread::VrMode(bool mode) { shell_view_.VrMode(mode); }
-
-JNIEnv* RenderThread::GetJniEnv() {
-  JNIEnv* env;
-  jvm_->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);
-  return env;
-}
-
-void RenderThread::RunRenderLoop(
-    std::promise<int>* init_result_promise) {
-  // TODO(steventhomas): Create local refs to work around b/33251144. Remove
-  // once that bug is fixed.
-  JNIEnv* env = GetJniEnv();
-  jobject class_loader = env->NewLocalRef(class_loader_global_ref_);
-  jobject android_context = env->NewLocalRef(android_context_global_ref_);
-
-  int init_result = shell_view_.Initialize(env, android_context, class_loader);
-  init_result_promise->set_value(init_result);
-  if (init_result == 0) {
-    while (!quit_)
-      shell_view_.DrawFrame();
-  } else {
-    ALOGE("Failed to initialize ShellView");
-  }
-
-  env->DeleteLocalRef(class_loader);
-  env->DeleteLocalRef(android_context);
-}
-
-}  // namespace dvr
-}  // namespace android
diff --git a/services/vr/vr_window_manager/render_thread.h b/services/vr/vr_window_manager/render_thread.h
deleted file mode 100644
index e193643..0000000
--- a/services/vr/vr_window_manager/render_thread.h
+++ /dev/null
@@ -1,47 +0,0 @@
-#ifndef VR_WINDOW_MANAGER_RENDER_THREAD_H_
-#define VR_WINDOW_MANAGER_RENDER_THREAD_H_
-
-#include <atomic>
-#include <future>
-#include <jni.h>
-#include <thread>
-
-#include "shell_view.h"
-
-namespace android {
-namespace dvr {
-
-class RenderThread {
- public:
-  RenderThread(JNIEnv* env, jobject class_loader, jobject android_context);
-  ~RenderThread();
-  void Quit();
-  void EnableDebug(bool debug);
-  void VrMode(bool mode);
-
-  RenderThread(const RenderThread&) = delete;
-  void operator=(const RenderThread&) = delete;
-
- private:
-  // Called by both the main thread and render thread. Will return the correct
-  // JNIEnv for the current thread.
-  JNIEnv* GetJniEnv();
-
-  void RunRenderLoop(std::promise<int>* init_result_promise);
-
-  // Accessed only by the main thread.
-  std::thread thread_;
-
-  // The vars below are accessed by both the main thread and the render thread.
-  JavaVM* jvm_;
-  jobject class_loader_global_ref_;
-  jobject android_context_global_ref_;
-  std::atomic_bool quit_;
-
-  ShellView shell_view_;
-};
-
-}  // namespace dvr
-}  // namespace android
-
-#endif  // VR_WINDOW_MANAGER_RENDER_THREAD_H_
diff --git a/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon.png b/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon.png
deleted file mode 100644
index 06f896d..0000000
--- a/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon.png
+++ /dev/null
Binary files differ
diff --git a/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon_background.png b/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon_background.png
deleted file mode 100644
index d336da3..0000000
--- a/services/vr/vr_window_manager/res/drawable-nodpi/vr_icon_background.png
+++ /dev/null
Binary files differ
diff --git a/services/vr/vr_window_manager/res/values/styles.xml b/services/vr/vr_window_manager/res/values/styles.xml
deleted file mode 100644
index 8a1a74b..0000000
--- a/services/vr/vr_window_manager/res/values/styles.xml
+++ /dev/null
@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources>
-<add-resource type="style" name="AppStyle"></add-resource>
-<style name="AppStyle"
-    parent="@android:style/Theme.Holo.NoActionBar.Fullscreen">
-  <item name="android:windowDisablePreview">true</item>
-</style>
-</resources>
diff --git a/services/vr/vr_window_manager/shell_view.cpp b/services/vr/vr_window_manager/shell_view.cpp
index 29ade64..84b8467 100644
--- a/services/vr/vr_window_manager/shell_view.cpp
+++ b/services/vr/vr_window_manager/shell_view.cpp
@@ -238,9 +238,8 @@
 
 ShellView::~ShellView() {}
 
-int ShellView::Initialize(JNIEnv* env, jobject app_context,
-                          jobject class_loader) {
-  int ret = Application::Initialize(env, app_context, class_loader);
+int ShellView::Initialize() {
+  int ret = Application::Initialize();
   if (ret)
     return ret;
 
@@ -604,10 +603,7 @@
   vec3 pointer_location = last_pose_.GetPosition();
   quat view_quaternion = last_pose_.GetRotation();
 
-  bool gvr_api_active =
-      controller_ && controller_api_status_ == gvr::kControllerApiOk;
-
-  if (gvr_api_active || shmem_controller_active_) {
+  if (shmem_controller_active_) {
     view_quaternion = controller_orientation_;
     vec4 controller_location = controller_translate_ * vec4(0, 0, 0, 1);
     pointer_location = vec3(controller_location.x(), controller_location.y(),
@@ -635,18 +631,6 @@
         }
         buttons >>= 4;
       }
-    } else if (controller_) {
-      if (controller_state_->GetButtonDown(gvr::kControllerButtonClick))
-        OnClick(true);
-
-      if (controller_state_->GetButtonUp(gvr::kControllerButtonClick))
-        OnClick(false);
-
-      if (controller_state_->GetButtonDown(gvr::kControllerButtonApp))
-        OnTouchpadButton(true, AMOTION_EVENT_BUTTON_BACK);
-
-      if (controller_state_->GetButtonUp(gvr::kControllerButtonApp))
-        OnTouchpadButton(false, AMOTION_EVENT_BUTTON_BACK);
     }
   }
 
@@ -676,7 +660,7 @@
 
 void ShellView::DrawController(const mat4& perspective, const mat4& eye_matrix,
                                const mat4& head_matrix) {
-  if (!controller_ && !shmem_controller_active_)
+  if (!shmem_controller_active_)
     return;
 
   controller_program_->Use();
diff --git a/services/vr/vr_window_manager/shell_view.h b/services/vr/vr_window_manager/shell_view.h
index 14ad0f3..39b5451 100644
--- a/services/vr/vr_window_manager/shell_view.h
+++ b/services/vr/vr_window_manager/shell_view.h
@@ -28,8 +28,7 @@
   ShellView();
   virtual ~ShellView();
 
-  int Initialize(JNIEnv* env, jobject app_context,
-                 jobject class_loader) override;
+  int Initialize() override;
 
   int AllocateResources() override;
   void DeallocateResources() override;
diff --git a/services/vr/vr_window_manager/surface_flinger_view.cpp b/services/vr/vr_window_manager/surface_flinger_view.cpp
index b15d262..d42d3ff 100644
--- a/services/vr/vr_window_manager/surface_flinger_view.cpp
+++ b/services/vr/vr_window_manager/surface_flinger_view.cpp
@@ -1,6 +1,5 @@
 #include "surface_flinger_view.h"
 
-#include <binder/IServiceManager.h>
 #include <impl/vr_composer_view.h>
 #include <private/dvr/native_buffer.h>
 
@@ -15,23 +14,33 @@
 SurfaceFlingerView::~SurfaceFlingerView() {}
 
 bool SurfaceFlingerView::Initialize(HwcCallback::Client *client) {
-  const char instance[] = "DaydreamDisplay";
-  composer_service_ = IVrComposerView::getService(instance);
-  if (composer_service_ == nullptr) {
-    ALOGE("Failed to initialize composer service");
+  const char vr_hwcomposer_name[] = "vr_hwcomposer";
+  vr_hwcomposer_ = HIDL_FETCH_IComposer(vr_hwcomposer_name);
+  if (!vr_hwcomposer_.get()) {
+    ALOGE("Failed to get vr_hwcomposer");
     return false;
   }
 
-  if (!composer_service_->isRemote()) {
-    ALOGE("Composer service is not remote");
+  if (vr_hwcomposer_->isRemote()) {
+    ALOGE("vr_hwcomposer service is remote");
     return false;
   }
 
+  const android::status_t vr_hwcomposer_status =
+      vr_hwcomposer_->registerAsService(vr_hwcomposer_name);
+  if (vr_hwcomposer_status != OK) {
+    ALOGE("Failed to register vr_hwcomposer service");
+    return false;
+  }
+
+  vr_composer_view_ =
+      std::make_unique<VrComposerView>(std::make_unique<HwcCallback>(client));
+  vr_composer_view_->Initialize(GetComposerViewFromIComposer(
+      vr_hwcomposer_.get()));
+
   // TODO(dnicoara): Query this from the composer service.
   width_ = 1920;
   height_ = 1080;
-
-  composer_observer_.reset(new HwcCallback(composer_service_.get(), client));
   return true;
 }
 
@@ -76,7 +85,7 @@
 }
 
 void SurfaceFlingerView::ReleaseFrame() {
-  composer_service_->releaseFrame();
+  vr_composer_view_->ReleaseFrame();
 }
 
 }  // namespace dvr
diff --git a/services/vr/vr_window_manager/surface_flinger_view.h b/services/vr/vr_window_manager/surface_flinger_view.h
index 2e36ec1..9c16192 100644
--- a/services/vr/vr_window_manager/surface_flinger_view.h
+++ b/services/vr/vr_window_manager/surface_flinger_view.h
@@ -1,10 +1,10 @@
 #ifndef APPLICATIONS_EXPERIMENTS_SURFACE_FLINGER_DEMO_SURFACE_FLINGER_VIEW_H_
 #define APPLICATIONS_EXPERIMENTS_SURFACE_FLINGER_DEMO_SURFACE_FLINGER_VIEW_H_
 
-#include <utils/StrongPointer.h>
-
 #include <memory>
 
+#include <impl/vr_composer_view.h>
+
 #include "hwc_callback.h"
 
 namespace android {
@@ -39,9 +39,8 @@
   void ReleaseFrame();
 
  private:
-  sp<IVrComposerView> composer_service_;
-  std::unique_ptr<HwcCallback> composer_observer_;
-
+  sp<IComposer> vr_hwcomposer_;
+  std::unique_ptr<VrComposerView> vr_composer_view_;
   int width_ = 0;
   int height_ = 0;
 
diff --git a/services/vr/vr_window_manager/vr_window_manager.cpp b/services/vr/vr_window_manager/vr_window_manager.cpp
index c51ddee..6636dc5 100644
--- a/services/vr/vr_window_manager/vr_window_manager.cpp
+++ b/services/vr/vr_window_manager/vr_window_manager.cpp
@@ -1,33 +1,48 @@
 #include <binder/IPCThreadState.h>
 #include <binder/IServiceManager.h>
 #include <binder/ProcessState.h>
+#include <hwbinder/IPCThreadState.h>
+#include <impl/vr_composer_view.h>
+#include <impl/vr_hwc.h>
 
 #include "shell_view.h"
 #include "vr_window_manager_binder.h"
 
+using namespace android;
+using namespace android::dvr;
+
 int main(int /* argc */, char** /* argv */) {
-  android::dvr::ShellView app;
-  const int app_status = app.Initialize(nullptr, nullptr, nullptr);
-  LOG_ALWAYS_FATAL_IF(app_status != 0, "failed to initialize: %d", app_status);
-
-  android::service::vr::VrWindowManagerBinder service(app);
-  const int status = service.Initialize();
-  LOG_ALWAYS_FATAL_IF(status != 0, "initialization failed: %d", status);
-
   android::ProcessState::self()->startThreadPool();
 
+  // ShellView needs to be created after vr_hwcomposer.
+  android::dvr::ShellView app;
+  const int app_status = app.Initialize();
+  LOG_ALWAYS_FATAL_IF(app_status != 0, "failed to initialize: %d", app_status);
+
+  // Create vr_wm_binder.
+  android::service::vr::VrWindowManagerBinder vr_wm_binder(app);
+  const int status = vr_wm_binder.Initialize();
+  LOG_ALWAYS_FATAL_IF(status != 0, "initialization failed: %d", status);
+
   android::sp<android::IServiceManager> sm(android::defaultServiceManager());
-  const android::status_t service_status = sm->addService(
-      android::service::vr::VrWindowManagerBinder::SERVICE_NAME(), &service,
-      false /*allowIsolated*/);
-  LOG_ALWAYS_FATAL_IF(service_status != android::OK, "service not added: %d",
-                      static_cast<int>(service_status));
+  const android::status_t vr_wm_binder_status =
+      sm->addService(
+          android::service::vr::VrWindowManagerBinder::SERVICE_NAME(),
+          &vr_wm_binder, false /*allowIsolated*/);
+  LOG_ALWAYS_FATAL_IF(vr_wm_binder_status != android::OK,
+                      "vr_wm_binder service not added: %d",
+                      static_cast<int>(vr_wm_binder_status));
 
-  app.SetControllerDataProvider(&service);
+  app.SetControllerDataProvider(&vr_wm_binder);
 
-  while (true)
+  android::hardware::ProcessState::self()->startThreadPool();
+
+  while (true) {
     app.DrawFrame();
+  }
 
+  android::hardware::IPCThreadState::self()->joinThreadPool();
   android::IPCThreadState::self()->joinThreadPool();
+
   return 0;
 }
diff --git a/services/vr/vr_window_manager/vr_window_manager_jni.cpp b/services/vr/vr_window_manager/vr_window_manager_jni.cpp
deleted file mode 100644
index 49eaba1..0000000
--- a/services/vr/vr_window_manager/vr_window_manager_jni.cpp
+++ /dev/null
@@ -1,58 +0,0 @@
-#include <jni.h>
-#include <log/log.h>
-
-#include <memory>
-
-#include "render_thread.h"
-
-#define JNI_METHOD(return_type, method_name) \
-  JNIEXPORT return_type JNICALL              \
-      Java_com_google_vr_windowmanager_VrWindowManagerService_##method_name
-
-namespace {
-
-inline jlong jptr(android::dvr::RenderThread* native_vr_window_manager) {
-  return reinterpret_cast<intptr_t>(native_vr_window_manager);
-}
-
-inline android::dvr::RenderThread* native(jlong ptr) {
-  return reinterpret_cast<android::dvr::RenderThread*>(ptr);
-}
-
-}  // namespace
-
-extern "C" {
-
-JNI_METHOD(jlong, nativeCreate)(JNIEnv* env, jclass /*clazz*/,
-                                jobject class_loader,
-                                jobject android_context) {
-  return jptr(new android::dvr::RenderThread(
-      env, class_loader, android_context));
-}
-
-JNI_METHOD(void, nativeDestroy)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
-  delete native(native_render_thread);
-}
-
-JNI_METHOD(void, nativeEnableDebug)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
-  native(native_render_thread)->EnableDebug(true);
-}
-
-JNI_METHOD(void, nativeDisableDebug)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
-  native(native_render_thread)->EnableDebug(false);
-}
-
-JNI_METHOD(void, nativeEnterVrMode)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
-  native(native_render_thread)->VrMode(true);
-}
-
-JNI_METHOD(void, nativeExitVrMode)
-(JNIEnv* /*env*/, jclass /*clazz*/, jlong native_render_thread) {
-  native(native_render_thread)->VrMode(false);
-}
-
-}  // extern "C"
diff --git a/services/vr/vr_window_manager/vr_wm.rc b/services/vr/vr_window_manager/vr_wm.rc
index 143b916..951515b 100644
--- a/services/vr/vr_window_manager/vr_wm.rc
+++ b/services/vr/vr_window_manager/vr_wm.rc
@@ -3,7 +3,3 @@
   user system
   group system graphics input
   cpuset /system
-  disabled
-
-on property:persist.daydream.vr_wm=1
-  enable vr_wm
diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp
index a23056c..32f777d 100644
--- a/vulkan/libvulkan/driver.cpp
+++ b/vulkan/libvulkan/driver.cpp
@@ -739,10 +739,8 @@
     const InstanceData& data = GetData(physicalDevice);
     static const std::array<VkExtensionProperties, 2> loader_extensions = {{
         // WSI extensions
-#if 0 // Remove this "#if 0" once the VK_KHR_incremental_present extension is ratified
         {VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME,
          VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION},
-#endif
         {VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME,
          VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION},
     }};