diff --git a/aidl/gui/android/view/Surface.aidl b/aidl/gui/android/view/Surface.aidl
index 674c163..7e89220 100644
--- a/aidl/gui/android/view/Surface.aidl
+++ b/aidl/gui/android/view/Surface.aidl
@@ -17,4 +17,4 @@
 
 package android.view;
 
-parcelable Surface cpp_header "gui/Surface.h";
+parcelable Surface cpp_header "gui/view/Surface.h";
diff --git a/cmds/atrace/atrace.cpp b/cmds/atrace/atrace.cpp
index ce0caed..8f2dee1 100644
--- a/cmds/atrace/atrace.cpp
+++ b/cmds/atrace/atrace.cpp
@@ -552,17 +552,13 @@
             hidl_string instanceName = fqInstanceName.substr(n+1, std::string::npos);
             Return<sp<IBase>> interfaceRet = sm->get(fqInterfaceName, instanceName);
             if (!interfaceRet.isOk()) {
-                fprintf(stderr, "failed to get service %s: %s\n",
-                        fqInstanceName.c_str(),
-                        interfaceRet.description().c_str());
+                // ignore
                 continue;
             }
             sp<IBase> interface = interfaceRet;
             auto notifyRet = interface->notifySyspropsChanged();
             if (!notifyRet.isOk()) {
-                fprintf(stderr, "failed to notifySyspropsChanged on service %s: %s\n",
-                        fqInstanceName.c_str(),
-                        notifyRet.description().c_str());
+                // ignore
             }
         }
     });
diff --git a/cmds/dumpstate/Android.mk b/cmds/dumpstate/Android.mk
index efc050b..d1e94ed 100644
--- a/cmds/dumpstate/Android.mk
+++ b/cmds/dumpstate/Android.mk
@@ -103,8 +103,7 @@
 
 LOCAL_MODULE := dumpstate
 
-LOCAL_SHARED_LIBRARIES := $(COMMON_SHARED_LIBRARIES) \
-    android.hardware.vibrator@1.0
+LOCAL_SHARED_LIBRARIES := $(COMMON_SHARED_LIBRARIES)
 
 LOCAL_STATIC_LIBRARIES := $(COMMON_STATIC_LIBRARIES)
 
diff --git a/cmds/dumpstate/dumpstate.cpp b/cmds/dumpstate/dumpstate.cpp
index 67172b6..e33f099 100644
--- a/cmds/dumpstate/dumpstate.cpp
+++ b/cmds/dumpstate/dumpstate.cpp
@@ -42,7 +42,6 @@
 #include <android-base/strings.h>
 #include <android-base/unique_fd.h>
 #include <android/hardware/dumpstate/1.0/IDumpstateDevice.h>
-#include <android/hardware/vibrator/1.0/IVibrator.h>
 #include <cutils/native_handle.h>
 #include <cutils/properties.h>
 #include <openssl/sha.h>
@@ -54,8 +53,6 @@
 #include "dumpstate.h"
 
 using ::android::hardware::dumpstate::V1_0::IDumpstateDevice;
-using ::android::hardware::vibrator::V1_0::IVibrator;
-using VibratorStatus = ::android::hardware::vibrator::V1_0::Status;
 
 // TODO: remove once moved to namespace
 using android::os::dumpstate::CommandOptions;
@@ -1347,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
@@ -1363,6 +1361,16 @@
                    .Build());
 }
 
+static void Vibrate(int duration_ms) {
+    // clang-format off
+    RunCommand("", {"cmd", "vibrator", "vibrate", std::to_string(duration_ms), "dumpstate"},
+               CommandOptions::WithTimeout(10)
+                   .Log("Vibrate: '%s'\n")
+                   .Always()
+                   .Build());
+    // clang-format on
+}
+
 int main(int argc, char *argv[]) {
     int do_add_date = 0;
     int do_zip_file = 0;
@@ -1593,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());
@@ -1608,22 +1616,8 @@
         fclose(cmdline);
     }
 
-    ::android::sp<IVibrator> vibrator = nullptr;
     if (do_vibrate) {
-        vibrator = IVibrator::getService();
-
-        if (vibrator != nullptr) {
-            // cancel previous vibration if any
-            ::android::hardware::Return<VibratorStatus> offStatus = vibrator->off();
-            if (!offStatus.isOk() || offStatus != VibratorStatus::OK) {
-                MYLOGE("Vibrator off failed.");
-            } else {
-                ::android::hardware::Return<VibratorStatus> onStatus = vibrator->on(150);
-                if (!onStatus.isOk() || onStatus != VibratorStatus::OK) {
-                    MYLOGE("Vibrator on failed.");
-                }
-            }
-        }
+        Vibrate(150);
     }
 
     if (do_fb && ds.do_early_screenshot_) {
@@ -1803,21 +1797,9 @@
     }
 
     /* vibrate a few but shortly times to let user know it's finished */
-    if (vibrator != nullptr) {
-        // in case dumpstate magically completes before the above vibration
-        ::android::hardware::Return<VibratorStatus> offStatus = vibrator->off();
-        if (!offStatus.isOk() || offStatus != VibratorStatus::OK) {
-            MYLOGE("Vibrator off failed.");
-        } else {
-            for (int i = 0; i < 3; i++) {
-                ::android::hardware::Return<VibratorStatus> onStatus = vibrator->on(75);
-                if (!onStatus.isOk() || onStatus != VibratorStatus::OK) {
-                    MYLOGE("Vibrator on failed.");
-                    break;
-                }
-                usleep((75 + 50) * 1000);
-            }
-        }
+    for (int i = 0; i < 3; i++) {
+        Vibrate(75);
+        usleep((75 + 50) * 1000);
     }
 
     /* tell activity manager we're done */
@@ -1844,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/dumpsys/Android.bp b/cmds/dumpsys/Android.bp
index c5ae9d2..3476964 100644
--- a/cmds/dumpsys/Android.bp
+++ b/cmds/dumpsys/Android.bp
@@ -15,8 +15,6 @@
         "libutils",
         "liblog",
         "libbinder",
-        "android.hidl.manager@1.0",
-        "libhidlbase"
     ],
 
     clang: true,
diff --git a/cmds/dumpsys/dumpsys.cpp b/cmds/dumpsys/dumpsys.cpp
index 860b7b4..f0e7200 100644
--- a/cmds/dumpsys/dumpsys.cpp
+++ b/cmds/dumpsys/dumpsys.cpp
@@ -45,7 +45,8 @@
 using android::base::unique_fd;
 using android::base::WriteFully;
 
-static int sort_func(const String16* lhs, const String16* rhs) {
+static int sort_func(const String16* lhs, const String16* rhs)
+{
     return lhs->compare(*rhs);
 }
 
@@ -54,11 +55,10 @@
         "usage: dumpsys\n"
             "         To dump all services.\n"
             "or:\n"
-            "       dumpsys [-t TIMEOUT] [--help | --hw | -l | --skip SERVICES | SERVICE [ARGS]]\n"
+            "       dumpsys [-t TIMEOUT] [--help | -l | --skip SERVICES | SERVICE [ARGS]]\n"
             "         --help: shows this help\n"
             "         -l: only list services, do not dump them\n"
             "         -t TIMEOUT: TIMEOUT to use in seconds instead of default 10 seconds\n"
-            "         --hw: list all hw services running on the device\n"
             "         --skip SERVICES: dumps all services but SERVICES (comma-separated list)\n"
             "         SERVICE [ARGS]: dumps only service SERVICE, optionally passing ARGS to it\n");
 }
@@ -72,42 +72,16 @@
     return false;
 }
 
-static void ListHardwareServices(android::hidl::manager::V1_0::IServiceManager* hm) {
-    using android::hardware::hidl_vec;
-    using android::hardware::hidl_string;
-    using android::hardware::Return;
-    using android::sp;
-
-    if (hm == nullptr) {
-        ALOGE("Unable to get hardware service manager!");
-        aerr << "Failed to get hardware service manager!";
-        return;
-    }
-
-    Return<void> ret = hm->list([](const hidl_vec<hidl_string> &registered){
-        aout << "Currently running hardware services:" << endl;
-        for (const auto &service : registered) {
-            aout << "  " << service << endl;
-        }
-    });
-
-    if (!ret.isOk()) {
-        aerr << "Failed to list hardware services: " << ret.description();
-    }
-}
-
 int Dumpsys::main(int argc, char* const argv[]) {
     Vector<String16> services;
     Vector<String16> args;
     Vector<String16> skippedServices;
     bool showListOnly = false;
-    bool listHwOnly = false;
     bool skipServices = false;
     int timeoutArg = 10;
     static struct option longOptions[] = {
         {"skip", no_argument, 0,  0 },
         {"help", no_argument, 0,  0 },
-        {"hw",   no_argument, 0,  0 },
         {     0,           0, 0,  0 }
     };
 
@@ -131,8 +105,6 @@
             } else if (!strcmp(longOptions[optionIndex].name, "help")) {
                 usage();
                 return 0;
-            } else if (!strcmp(longOptions[optionIndex].name, "hw")) {
-                listHwOnly = true;
             }
             break;
 
@@ -171,17 +143,11 @@
     }
 
     if ((skipServices && skippedServices.empty()) ||
-            (showListOnly && (!services.empty() || !skippedServices.empty())) ||
-            (listHwOnly && (skipServices || services.size() > 0 || showListOnly))) {
+            (showListOnly && (!services.empty() || !skippedServices.empty()))) {
         usage();
         return -1;
     }
 
-    if (listHwOnly) {
-        ListHardwareServices(hm_);
-        return 0;
-    }
-
     if (services.empty() || showListOnly) {
         // gets all services
         services = sm_->listServices();
diff --git a/cmds/dumpsys/dumpsys.h b/cmds/dumpsys/dumpsys.h
index 20d515d..2534dde 100644
--- a/cmds/dumpsys/dumpsys.h
+++ b/cmds/dumpsys/dumpsys.h
@@ -17,21 +17,18 @@
 #ifndef FRAMEWORK_NATIVE_CMD_DUMPSYS_H_
 #define FRAMEWORK_NATIVE_CMD_DUMPSYS_H_
 
-#include <android/hidl/manager/1.0/IServiceManager.h>
 #include <binder/IServiceManager.h>
 
 namespace android {
 
 class Dumpsys {
   public:
-    Dumpsys(android::IServiceManager* sm,
-            android::hidl::manager::V1_0::IServiceManager* hm) : sm_(sm), hm_(hm) {
+    Dumpsys(android::IServiceManager* sm) : sm_(sm) {
     }
     int main(int argc, char* const argv[]);
 
   private:
     android::IServiceManager* sm_;
-    android::hidl::manager::V1_0::IServiceManager* hm_;
 };
 }
 
diff --git a/cmds/dumpsys/main.cpp b/cmds/dumpsys/main.cpp
index b180c98..8ba0eba 100644
--- a/cmds/dumpsys/main.cpp
+++ b/cmds/dumpsys/main.cpp
@@ -27,7 +27,6 @@
 #include <stdio.h>
 
 using namespace android;
-using HServiceManager = android::hidl::manager::V1_0::IServiceManager;
 
 int main(int argc, char* const argv[]) {
     signal(SIGPIPE, SIG_IGN);
@@ -39,8 +38,6 @@
         return 20;
     }
 
-    sp<HServiceManager> hm = HServiceManager::getService("manager");
-
-    Dumpsys dumpsys(sm.get(), hm.get());
+    Dumpsys dumpsys(sm.get());
     return dumpsys.main(argc, argv);
 }
diff --git a/cmds/dumpsys/tests/Android.bp b/cmds/dumpsys/tests/Android.bp
index e00444f..7698ed5 100644
--- a/cmds/dumpsys/tests/Android.bp
+++ b/cmds/dumpsys/tests/Android.bp
@@ -5,12 +5,8 @@
     srcs: ["dumpsys_test.cpp"],
 
     shared_libs: [
-        "android.hidl.manager@1.0",
         "libbase",
         "libbinder",
-        "liblog",
-        "libhidlbase",
-        "libhidltransport",
         "libutils",
     ],
 
diff --git a/cmds/dumpsys/tests/dumpsys_test.cpp b/cmds/dumpsys/tests/dumpsys_test.cpp
index 01a2fa3..a61cb00 100644
--- a/cmds/dumpsys/tests/dumpsys_test.cpp
+++ b/cmds/dumpsys/tests/dumpsys_test.cpp
@@ -44,12 +44,6 @@
 using ::testing::internal::GetCapturedStderr;
 using ::testing::internal::GetCapturedStdout;
 
-using android::hardware::hidl_vec;
-using android::hardware::hidl_string;
-using android::hardware::Void;
-using HServiceManager = android::hidl::manager::V1_0::IServiceManager;
-using IServiceNotification = android::hidl::manager::V1_0::IServiceNotification;
-
 class ServiceManagerMock : public IServiceManager {
   public:
     MOCK_CONST_METHOD1(getService, sp<IBinder>(const String16&));
@@ -61,27 +55,6 @@
     MOCK_METHOD0(onAsBinder, IBinder*());
 };
 
-class HardwareServiceManagerMock : public HServiceManager {
-  public:
-    template<typename T>
-    using R = android::hardware::Return<T>; // conflicts with ::testing::Return
-
-    MOCK_METHOD2(get, R<sp<IBase>>(const hidl_string&, const hidl_string&));
-    MOCK_METHOD3(add,
-        R<bool>(const hidl_vec<hidl_string>&,
-                const hidl_string&,
-                const sp<IBase>&));
-    MOCK_METHOD1(list, R<void>(list_cb));
-    MOCK_METHOD2(listByInterface,
-        R<void>(const hidl_string&, listByInterface_cb));
-    MOCK_METHOD3(registerForNotifications,
-        R<bool>(const hidl_string&,
-                const hidl_string&,
-                const sp<IServiceNotification>&));
-    MOCK_METHOD1(debugDump, R<void>(debugDump_cb));
-
-};
-
 class BinderMock : public BBinder {
   public:
     BinderMock() {
@@ -111,26 +84,6 @@
     return MakeAction(new WriteOnFdAction(output));
 }
 
-// gmock black magic to provide a WithArg<0>(List(services)) matcher
-typedef void HardwareListFunction(HServiceManager::list_cb);
-
-class HardwareListAction : public ActionInterface<HardwareListFunction> {
-  public:
-    explicit HardwareListAction(const hidl_vec<hidl_string> &services) : services_(services) {
-    }
-    virtual Result Perform(const ArgumentTuple& args) {
-        auto cb = ::std::tr1::get<0>(args);
-        cb(services_);
-    }
-
-  private:
-    hidl_vec<hidl_string> services_;
-};
-
-Action<HardwareListFunction> HardwareList(const  hidl_vec<hidl_string> &services) {
-    return MakeAction(new HardwareListAction(services));
-}
-
 // Matcher for args using Android's Vector<String16> format
 // TODO: move it to some common testing library
 MATCHER_P(AndroidElementsAre, expected, "") {
@@ -168,7 +121,7 @@
 
 class DumpsysTest : public Test {
   public:
-    DumpsysTest() : sm_(), hm_(), dump_(&sm_, &hm_), stdout_(), stderr_() {
+    DumpsysTest() : sm_(), dump_(&sm_), stdout_(), stderr_() {
     }
 
     void ExpectListServices(std::vector<std::string> services) {
@@ -176,22 +129,9 @@
         for (auto& service : services) {
             services16.add(String16(service.c_str()));
         }
-
         EXPECT_CALL(sm_, listServices()).WillRepeatedly(Return(services16));
     }
 
-    void ExpectListHardwareServices(std::vector<std::string> services) {
-        hidl_vec<hidl_string> hidl_services;
-        hidl_services.resize(services.size());
-        for (size_t i = 0; i < services.size(); i++) {
-            hidl_services[i] = services[i];
-        }
-
-        EXPECT_CALL(hm_, list(_)).WillRepeatedly(DoAll(
-                WithArg<0>(HardwareList(hidl_services)),
-                Return(Void())));
-    }
-
     sp<BinderMock> ExpectCheckService(const char* name, bool running = true) {
         sp<BinderMock> binder_mock;
         if (running) {
@@ -235,10 +175,8 @@
         EXPECT_THAT(status, Eq(0));
     }
 
-    void AssertRunningServices(const std::vector<std::string>& services,
-                               const std::string &message = "Currently running services:") {
-        std::string expected(message);
-        expected.append("\n");
+    void AssertRunningServices(const std::vector<std::string>& services) {
+        std::string expected("Currently running services:\n");
         for (const std::string& service : services) {
             expected.append("  ").append(service).append("\n");
         }
@@ -266,21 +204,12 @@
     }
 
     ServiceManagerMock sm_;
-    HardwareServiceManagerMock hm_;
     Dumpsys dump_;
 
   private:
     std::string stdout_, stderr_;
 };
 
-TEST_F(DumpsysTest, ListHwServices) {
-    ExpectListHardwareServices({"Locksmith", "Valet"});
-
-    CallMain({"--hw"});
-
-    AssertRunningServices({"Locksmith", "Valet"}, "Currently running hardware services:");
-}
-
 // Tests 'dumpsys -l' when all services are running
 TEST_F(DumpsysTest, ListAllServices) {
     ExpectListServices({"Locksmith", "Valet"});
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 bc5eaf2..0000000
--- a/cmds/lshal/lshal.cpp
+++ /dev/null
@@ -1,178 +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>
-
-template <typename A, typename B, typename C, typename D, typename E>
-void printColumn(std::stringstream &stream,
-        const A &a, const B &b, const C &c, const D &d, const E &e) {
-    using namespace ::std;
-    stream << left
-           << setw(70) << a << "\t"
-           << setw(20) << b << "\t"
-           << setw(10) << c << "\t"
-           << setw(5)  << d << "\t"
-           << setw(0)  << e
-           << endl;
-}
-
-std::string toHexString(uint64_t t) {
-    std::ostringstream os;
-    os << std::hex << std::setfill('0') << std::setw(16) << t;
-    return os.str();
-}
-
-::android::status_t 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 ::android::PERMISSION_DENIED;
-    }
-
-    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 ::android::OK;
-}
-
-
-int dump() {
-    using namespace ::std;
-    using namespace ::android::hardware;
-    using namespace ::android::hidl::manager::V1_0;
-
-    std::map<std::string, ::android::sp<IServiceManager>> mapping = {
-            {"hwbinder", defaultServiceManager()},
-            {"passthrough", getPassthroughServiceManager()}
-    };
-
-    std::stringstream stream;
-
-    stream << "All services:" << endl;
-    stream << left;
-    printColumn(stream, "Interface", "Instance", "Transport", "Server", "Clients");
-
-    for (const auto &pair : mapping) {
-        const std::string &mode = pair.first;
-        const ::android::sp<IServiceManager> &manager = pair.second;
-
-        if (manager == nullptr) {
-            cerr << "Failed to get IServiceManager for " << mode << "!" << endl;
-            continue;
-        }
-
-        auto ret = manager->debugDump([&](const auto &registered) {
-            // server pid, .ptr value of binder object, child pids
-            std::map<pid_t, std::map<uint64_t, std::string>> allPids;
-            for (const auto &info : registered) {
-                if (info.pid < 0) {
-                    continue;
-                }
-                pid_t serverPid = info.pid;
-                allPids[serverPid].clear();
-            }
-            for (auto &pair : allPids) {
-                pid_t serverPid = pair.first;
-                if (getReferencedPids(serverPid, &allPids[serverPid]) != ::android::OK) {
-                    std::cerr << "Warning: no information for PID " << serverPid
-                              << ", are you root?" << std::endl;
-                }
-            }
-            for (const auto &info : registered) {
-                printColumn(stream,
-                    info.interfaceName,
-                    info.instanceName.empty() ? "N/A" : info.instanceName,
-                    mode,
-                    info.pid < 0 ? "N/A" : std::to_string(info.pid),
-                    info.pid < 0 || info.ptr == 0 ? "" : allPids[info.pid][info.ptr]);
-            }
-        });
-        if (!ret.isOk()) {
-            cerr << "Failed to list services for " << mode << ": "
-                 << ret.description() << endl;
-        }
-    }
-    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/GraphicBufferAlloc.h b/include/gui/GraphicBufferAlloc.h
index 9e18907..54c9829 100644
--- a/include/gui/GraphicBufferAlloc.h
+++ b/include/gui/GraphicBufferAlloc.h
@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-#ifndef ANDROID_SF_GRAPHIC_BUFFER_ALLOC_H
-#define ANDROID_SF_GRAPHIC_BUFFER_ALLOC_H
+#ifndef ANDROID_GUI_GRAPHIC_BUFFER_ALLOC_H
+#define ANDROID_GUI_GRAPHIC_BUFFER_ALLOC_H
 
 #include <stdint.h>
 #include <sys/types.h>
@@ -25,10 +25,16 @@
 #include <utils/Errors.h>
 
 namespace android {
-// ---------------------------------------------------------------------------
 
 class GraphicBuffer;
 
+/*
+ * Concrete implementation of the IGraphicBufferAlloc interface.
+ *
+ * This can create GraphicBuffer instance across processes. This is mainly used
+ * by surfaceflinger.
+ */
+
 class GraphicBufferAlloc : public BnGraphicBufferAlloc {
 public:
     GraphicBufferAlloc();
@@ -40,7 +46,6 @@
 };
 
 
-// ---------------------------------------------------------------------------
-}; // namespace android
+} // namespace android
 
-#endif // ANDROID_SF_GRAPHIC_BUFFER_ALLOC_H
+#endif // ANDROID_GUI_GRAPHIC_BUFFER_ALLOC_H
diff --git a/include/gui/Surface.h b/include/gui/Surface.h
index 60203f7..a3c2bfa 100644
--- a/include/gui/Surface.h
+++ b/include/gui/Surface.h
@@ -17,8 +17,6 @@
 #ifndef ANDROID_GUI_SURFACE_H
 #define ANDROID_GUI_SURFACE_H
 
-#include <binder/Parcelable.h>
-
 #include <gui/IGraphicBufferProducer.h>
 #include <gui/BufferQueueDefs.h>
 
@@ -137,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,
@@ -150,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;
 
@@ -159,6 +162,7 @@
 
     // Virtual for testing.
     virtual sp<ISurfaceComposer> composerService() const;
+    virtual nsecs_t now() const;
 
 private:
     // can't be copied
@@ -206,9 +210,11 @@
     int dispatchSetSurfaceDamage(va_list args);
     int dispatchSetSharedBufferMode(va_list args);
     int dispatchSetAutoRefresh(va_list args);
-    int dispatchEnableFrameTimestamps(va_list args);
-    int dispatchGetFrameTimestamps(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);
 
 protected:
     virtual int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);
@@ -410,43 +416,6 @@
     std::unique_ptr<ProducerFrameEventHistory> mFrameEventHistory;
 };
 
-namespace view {
-
-/**
- * A simple holder for an IGraphicBufferProducer, to match the managed-side
- * android.view.Surface parcelable behavior.
- *
- * This implements android/view/Surface.aidl
- *
- * TODO: Convert IGraphicBufferProducer into AIDL so that it can be directly
- * used in managed Binder calls.
- */
-class Surface : public Parcelable {
-  public:
-
-    String16 name;
-    sp<IGraphicBufferProducer> graphicBufferProducer;
-
-    virtual status_t writeToParcel(Parcel* parcel) const override;
-    virtual status_t readFromParcel(const Parcel* parcel) override;
-
-    // nameAlreadyWritten set to true by Surface.java, because it splits
-    // Parceling itself between managed and native code, so it only wants a part
-    // of the full parceling to happen on its native side.
-    status_t writeToParcel(Parcel* parcel, bool nameAlreadyWritten) const;
-
-    // nameAlreadyRead set to true by Surface.java, because it splits
-    // Parceling itself between managed and native code, so it only wants a part
-    // of the full parceling to happen on its native side.
-    status_t readFromParcel(const Parcel* parcel, bool nameAlreadyRead);
-
-  private:
-
-    static String16 readMaybeEmptyString16(const Parcel* parcel);
-};
-
-} // namespace view
-
-}; // namespace android
+} // namespace android
 
 #endif  // ANDROID_GUI_SURFACE_H
diff --git a/include/gui/view/Surface.h b/include/gui/view/Surface.h
new file mode 100644
index 0000000..cc64fd4
--- /dev/null
+++ b/include/gui/view/Surface.h
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2010 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_GUI_VIEW_SURFACE_H
+#define ANDROID_GUI_VIEW_SURFACE_H
+
+#include <utils/Errors.h>
+#include <utils/StrongPointer.h>
+#include <utils/String16.h>
+
+#include <binder/Parcelable.h>
+
+namespace android {
+
+class IGraphicBufferProducer;
+
+namespace view {
+
+/**
+ * A simple holder for an IGraphicBufferProducer, to match the managed-side
+ * android.view.Surface parcelable behavior.
+ *
+ * This implements android/view/Surface.aidl
+ *
+ * TODO: Convert IGraphicBufferProducer into AIDL so that it can be directly
+ * used in managed Binder calls.
+ */
+class Surface : public Parcelable {
+  public:
+
+    String16 name;
+    sp<IGraphicBufferProducer> graphicBufferProducer;
+
+    virtual status_t writeToParcel(Parcel* parcel) const override;
+    virtual status_t readFromParcel(const Parcel* parcel) override;
+
+    // nameAlreadyWritten set to true by Surface.java, because it splits
+    // Parceling itself between managed and native code, so it only wants a part
+    // of the full parceling to happen on its native side.
+    status_t writeToParcel(Parcel* parcel, bool nameAlreadyWritten) const;
+
+    // nameAlreadyRead set to true by Surface.java, because it splits
+    // Parceling itself between managed and native code, so it only wants a part
+    // of the full parceling to happen on its native side.
+    status_t readFromParcel(const Parcel* parcel, bool nameAlreadyRead);
+
+  private:
+
+    static String16 readMaybeEmptyString16(const Parcel* parcel);
+};
+
+} // namespace view
+} // namespace android
+
+#endif  // ANDROID_GUI_VIEW_SURFACE_H
diff --git a/include/ui/Fence.h b/include/ui/Fence.h
index 58df24c..37811bc 100644
--- a/include/ui/Fence.h
+++ b/include/ui/Fence.h
@@ -23,8 +23,6 @@
 #include <utils/RefBase.h>
 #include <utils/Timers.h>
 
-#include <experimental/optional>
-
 namespace android {
 
 class String8;
@@ -105,26 +103,29 @@
     // error occurs then SIGNAL_TIME_INVALID is returned.
     nsecs_t getSignalTime() const;
 
-#if __cplusplus > 201103L
-    // hasSignaled returns whether the fence has signaled yet. Prefer this to
+    enum class Status {
+        Invalid,     // Fence is invalid
+        Unsignaled,  // Fence is valid but has not yet signaled
+        Signaled,    // Fence is valid and has signaled
+    };
+
+    // getStatus() returns whether the fence has signaled yet. Prefer this to
     // getSignalTime() or wait() if all you care about is whether the fence has
-    // signaled. Returns an optional bool, which will have a value if there was
-    // no error.
-    inline std::experimental::optional<bool> hasSignaled() {
+    // signaled.
+    inline Status getStatus() {
         // The sync_wait call underlying wait() has been measured to be
         // significantly faster than the sync_fence_info call underlying
         // getSignalTime(), which might otherwise appear to be the more obvious
         // way to check whether a fence has signaled.
         switch (wait(0)) {
             case NO_ERROR:
-                return true;
+                return Status::Signaled;
             case -ETIME:
-                return false;
+                return Status::Unsignaled;
             default:
-                return {};
+                return Status::Invalid;
         }
     }
-#endif
 
     // Flattenable interface
     size_t getFlattenedSize() const;
diff --git a/include/ui/GraphicBuffer.h b/include/ui/GraphicBuffer.h
index 95ca0f3..759c9ec 100644
--- a/include/ui/GraphicBuffer.h
+++ b/include/ui/GraphicBuffer.h
@@ -76,11 +76,6 @@
     GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,
             uint32_t inUsage, std::string requestorName = "<Unknown>");
 
-    // creates w * h buffer with a layer count
-    GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,
-            uint32_t inLayerCount, uint32_t inUsage,
-            std::string requestorName = "<Unknown>");
-
     // creates w * h buffer with a layer count using gralloc1
     GraphicBuffer(uint32_t inWidth, uint32_t inHeight, PixelFormat inFormat,
             uint32_t inLayerCount, uint64_t inProducerUsage,
diff --git a/include/ui/GraphicBufferMapper.h b/include/ui/GraphicBufferMapper.h
index 8e93f72..001769f 100644
--- a/include/ui/GraphicBufferMapper.h
+++ b/include/ui/GraphicBufferMapper.h
@@ -39,7 +39,9 @@
 public:
     static inline GraphicBufferMapper& get() { return getInstance(); }
 
+    // This may NOT work on devices without a valid Gralloc2::Mapper.
     status_t registerBuffer(buffer_handle_t handle);
+
     status_t registerBuffer(const GraphicBuffer* buffer);
 
     status_t unregisterBuffer(buffer_handle_t handle);
diff --git a/libs/gui/Android.bp b/libs/gui/Android.bp
index cb17da4..ddf1072 100644
--- a/libs/gui/Android.bp
+++ b/libs/gui/Android.bp
@@ -96,6 +96,7 @@
         "SurfaceControl.cpp",
         "SurfaceComposerClient.cpp",
         "SyncFeatures.cpp",
+        "view/Surface.cpp",
     ],
 
     shared_libs: [
diff --git a/libs/gui/ConsumerBase.cpp b/libs/gui/ConsumerBase.cpp
index be2b1af..c26de66 100644
--- a/libs/gui/ConsumerBase.cpp
+++ b/libs/gui/ConsumerBase.cpp
@@ -318,16 +318,16 @@
         return OK;
     }
 
-    auto signaled = mSlots[slot].mFence->hasSignaled();
+    auto status = mSlots[slot].mFence->getStatus();
 
-    if (!signaled) {
+    if (status == Fence::Status::Invalid) {
         CB_LOGE("fence has invalid state");
         return BAD_VALUE;
     }
 
-    if (*signaled) {
+    if (status == Fence::Status::Signaled) {
         mSlots[slot].mFence = fence;
-    } else {
+    } else {  // status == Fence::Status::Unsignaled
         char fenceName[32] = {};
         snprintf(fenceName, 32, "%.28s:%d", mName.string(), slot);
         sp<Fence> mergedFence = Fence::merge(
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/GraphicBufferAlloc.cpp b/libs/gui/GraphicBufferAlloc.cpp
index f2d3677..cc7d403 100644
--- a/libs/gui/GraphicBufferAlloc.cpp
+++ b/libs/gui/GraphicBufferAlloc.cpp
@@ -15,21 +15,15 @@
  ** limitations under the License.
  */
 
-#include <log/log.h>
-
-#include <ui/GraphicBuffer.h>
-
 #include <gui/GraphicBufferAlloc.h>
 
-// ----------------------------------------------------------------------------
+#include <log/log.h>
+
+
 namespace android {
-// ----------------------------------------------------------------------------
 
-GraphicBufferAlloc::GraphicBufferAlloc() {
-}
-
-GraphicBufferAlloc::~GraphicBufferAlloc() {
-}
+GraphicBufferAlloc::GraphicBufferAlloc() = default;
+GraphicBufferAlloc::~GraphicBufferAlloc() = default;
 
 sp<GraphicBuffer> GraphicBufferAlloc::createGraphicBuffer(uint32_t width,
         uint32_t height, PixelFormat format, uint32_t layerCount,
@@ -44,15 +38,12 @@
         if (err == NO_MEMORY) {
             GraphicBuffer::dumpAllocationsToSystemLog();
         }
-        ALOGE("GraphicBufferAlloc::createGraphicBuffer(w=%u, h=%u, lc=%u) "
-             "failed (%s), handle=%p",
+        ALOGE("GraphicBufferAlloc::createGraphicBuffer(w=%u, h=%u, lc=%u) failed (%s), handle=%p",
                 width, height, layerCount, strerror(-err),
                 graphicBuffer->handle);
-        return 0;
+        graphicBuffer.clear();
     }
     return graphicBuffer;
 }
 
-// ----------------------------------------------------------------------------
-}; // namespace android
-// ----------------------------------------------------------------------------
+} // namespace android
diff --git a/libs/gui/Sensor.cpp b/libs/gui/Sensor.cpp
index 2fd29d5..e2f733a 100644
--- a/libs/gui/Sensor.cpp
+++ b/libs/gui/Sensor.cpp
@@ -210,6 +210,10 @@
             mFlags |= SENSOR_FLAG_WAKE_UP;
         }
         break;
+    case SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT:
+        mStringType = SENSOR_STRING_TYPE_LOW_LATENCY_OFFBODY_DETECT;
+        mFlags |= SENSOR_FLAG_ON_CHANGE_MODE;
+        break;
     case SENSOR_TYPE_WRIST_TILT_GESTURE:
         mStringType = SENSOR_STRING_TYPE_WRIST_TILT_GESTURE;
         mFlags |= SENSOR_FLAG_SPECIAL_REPORTING_MODE;
diff --git a/libs/gui/SensorManager.cpp b/libs/gui/SensorManager.cpp
index 46eaf28..513b889 100644
--- a/libs/gui/SensorManager.cpp
+++ b/libs/gui/SensorManager.cpp
@@ -196,7 +196,8 @@
         if (type == SENSOR_TYPE_PROXIMITY || type == SENSOR_TYPE_SIGNIFICANT_MOTION ||
             type == SENSOR_TYPE_TILT_DETECTOR || type == SENSOR_TYPE_WAKE_GESTURE ||
             type == SENSOR_TYPE_GLANCE_GESTURE || type == SENSOR_TYPE_PICK_UP_GESTURE ||
-            type == SENSOR_TYPE_WRIST_TILT_GESTURE) {
+            type == SENSOR_TYPE_WRIST_TILT_GESTURE ||
+            type == SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT) {
             wakeUpSensor = true;
         }
         // For now we just return the first sensor of that type we find.
diff --git a/libs/gui/Surface.cpp b/libs/gui/Surface.cpp
index c663620..d285ef0 100644
--- a/libs/gui/Surface.cpp
+++ b/libs/gui/Surface.cpp
@@ -18,9 +18,9 @@
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS
 //#define LOG_NDEBUG 0
 
-#include <android/native_window.h>
+#include <gui/Surface.h>
 
-#include <binder/Parcel.h>
+#include <android/native_window.h>
 
 #include <utils/Log.h>
 #include <utils/Trace.h>
@@ -32,7 +32,6 @@
 
 #include <gui/BufferItem.h>
 #include <gui/IProducerListener.h>
-#include <gui/Surface.h>
 
 #include <gui/ISurfaceComposer.h>
 #include <private/gui/ComposerService.h>
@@ -101,6 +100,10 @@
     return ComposerService::getComposerService();
 }
 
+nsecs_t Surface::now() const {
+    return systemTime();
+}
+
 sp<IGraphicBufferProducer> Surface::getIGraphicBufferProducer() const {
     return mGraphicBufferProducer;
 }
@@ -143,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,
@@ -261,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);
@@ -832,15 +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;
@@ -961,14 +1000,33 @@
     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();
+    return NO_ERROR;
+}
+
 int Surface::dispatchEnableFrameTimestamps(va_list args) {
     bool enable = va_arg(args, int);
     enableFrameTimestamps(enable);
     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) {
-    uint32_t framesAgo = va_arg(args, uint32_t);
+    uint64_t frameId = va_arg(args, uint64_t);
     nsecs_t* outRequestedPresentTime = va_arg(args, int64_t*);
     nsecs_t* outAcquireTime = va_arg(args, int64_t*);
     nsecs_t* outLatchTime = va_arg(args, int64_t*);
@@ -979,18 +1037,13 @@
     nsecs_t* outDisplayRetireTime = va_arg(args, int64_t*);
     nsecs_t* outDequeueReadyTime = va_arg(args, int64_t*);
     nsecs_t* outReleaseTime = va_arg(args, int64_t*);
-    return getFrameTimestamps(getNextFrameNumber() - 1 - framesAgo,
+    return getFrameTimestamps(frameId,
             outRequestedPresentTime, outAcquireTime, outLatchTime,
             outFirstRefreshStartTime, outLastRefreshStartTime,
             outGlCompositionDoneTime, outDisplayPresentTime,
             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);
@@ -1539,74 +1592,4 @@
     return mGraphicBufferProducer->getUniqueId(outId);
 }
 
-namespace view {
-
-status_t Surface::writeToParcel(Parcel* parcel) const {
-    return writeToParcel(parcel, false);
-}
-
-status_t Surface::writeToParcel(Parcel* parcel, bool nameAlreadyWritten) const {
-    if (parcel == nullptr) return BAD_VALUE;
-
-    status_t res = OK;
-
-    if (!nameAlreadyWritten) {
-        res = parcel->writeString16(name);
-        if (res != OK) return res;
-
-        /* isSingleBuffered defaults to no */
-        res = parcel->writeInt32(0);
-        if (res != OK) return res;
-    }
-
-    res = parcel->writeStrongBinder(
-            IGraphicBufferProducer::asBinder(graphicBufferProducer));
-
-    return res;
-}
-
-status_t Surface::readFromParcel(const Parcel* parcel) {
-    return readFromParcel(parcel, false);
-}
-
-status_t Surface::readFromParcel(const Parcel* parcel, bool nameAlreadyRead) {
-    if (parcel == nullptr) return BAD_VALUE;
-
-    status_t res = OK;
-    if (!nameAlreadyRead) {
-        name = readMaybeEmptyString16(parcel);
-        // Discard this for now
-        int isSingleBuffered;
-        res = parcel->readInt32(&isSingleBuffered);
-        if (res != OK) {
-            ALOGE("Can't read isSingleBuffered");
-            return res;
-        }
-    }
-
-    sp<IBinder> binder;
-
-    res = parcel->readNullableStrongBinder(&binder);
-    if (res != OK) {
-        ALOGE("%s: Can't read strong binder", __FUNCTION__);
-        return res;
-    }
-
-    graphicBufferProducer = interface_cast<IGraphicBufferProducer>(binder);
-
-    return OK;
-}
-
-String16 Surface::readMaybeEmptyString16(const Parcel* parcel) {
-    size_t len;
-    const char16_t* str = parcel->readString16Inplace(&len);
-    if (str != nullptr) {
-        return String16(str, len);
-    } else {
-        return String16();
-    }
-}
-
-} // namespace view
-
 }; // namespace android
diff --git a/libs/gui/tests/Surface_test.cpp b/libs/gui/tests/Surface_test.cpp
index 412c0f6..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,14 +605,20 @@
         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);
         mFrameTimestampsEnabled = true;
     }
 
-    int getAllFrameTimestamps(uint32_t framesAgo) {
-        return native_window_get_frame_timestamps(mWindow.get(), framesAgo,
+    int getAllFrameTimestamps(uint64_t frameId) {
+        return native_window_get_frame_timestamps(mWindow.get(), frameId,
                 &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
                 &outFirstRefreshStartTime, &outLastRefreshStartTime,
                 &outGpuCompositionDoneTime, &outDisplayPresentTime,
@@ -619,6 +638,13 @@
         outReleaseTime = -1;
     }
 
+    uint64_t getNextFrameId() {
+        uint64_t frameId = -1;
+        int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
+        EXPECT_EQ(status, NO_ERROR);
+        return frameId;
+    }
+
     void dequeueAndQueue(uint64_t frameIndex) {
         int fence = -1;
         ANativeWindowBuffer* buffer = nullptr;
@@ -674,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.
@@ -691,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) {
@@ -703,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(
@@ -733,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 } };
 };
 
 
@@ -748,6 +778,8 @@
     EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
     EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
 
+    const uint64_t fId = getNextFrameId();
+
     // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
     ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
     EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
@@ -761,27 +793,58 @@
     EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
 
     // Verify attempts to get frame timestamps fail.
-    const uint32_t framesAgo = 0;
-    int result = getAllFrameTimestamps(framesAgo);
+    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;
@@ -798,14 +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.
-    const uint32_t framesAgo = 0;
-    int result = getAllFrameTimestamps(framesAgo);
+    result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(NO_ERROR, result);
-    EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
+    EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
 }
 
 void GetFrameTimestampsTest::QueryPresentRetireSupported(
@@ -833,16 +895,245 @@
    QueryPresentRetireSupported(false, true);
 }
 
-// This test verifies that:
-// 1) The timestamps recorded in the consumer's FrameTimestampsHistory are
-//    properly retrieved by the producer for the correct frames.
-// 2) When framesAgo is 0, it is querying for the most recently queued frame.
+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.
 TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
     enableFrameTimestamps();
 
+    const uint64_t fId1 = getNextFrameId();
     dequeueAndQueue(0);
     mFrames[0].signalQueueFences();
 
+    const uint64_t fId2 = getNextFrameId();
     dequeueAndQueue(1);
     mFrames[1].signalQueueFences();
 
@@ -853,9 +1144,8 @@
     mFrames[1].signalRefreshFences();
 
     // Verify timestamps are correct for frame 1.
-    uint32_t framesAgo = 1;
     resetTimestamps();
-    int result = getAllFrameTimestamps(framesAgo);
+    int result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
     EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
@@ -870,9 +1160,8 @@
     EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
 
     // Verify timestamps are correct for frame 2.
-    framesAgo = 0;
     resetTimestamps();
-    result = getAllFrameTimestamps(framesAgo);
+    result = getAllFrameTimestamps(fId2);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
     EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
@@ -893,9 +1182,8 @@
     enableFrameTimestamps();
     mSurface->mFakeSurfaceComposer->setSupportedTimestamps(true, true);
 
-    const uint32_t framesAgo = 0;
-
     // Dequeue and queue frame 1.
+    const uint64_t fId1 = getNextFrameId();
     dequeueAndQueue(0);
 
     // Verify queue-related timestamps for f1 are available immediately in the
@@ -903,7 +1191,7 @@
     // acquire fence.
     resetTimestamps();
     int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    int result = native_window_get_frame_timestamps(mWindow.get(), framesAgo,
+    int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
             &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
     EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
@@ -915,7 +1203,7 @@
     mFrames[0].signalQueueFences();
 
     oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    result = native_window_get_frame_timestamps(mWindow.get(), framesAgo,
+    result = native_window_get_frame_timestamps(mWindow.get(), fId1,
             &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
     EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
@@ -924,6 +1212,7 @@
     EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
 
     // Dequeue and queue frame 2.
+    const uint64_t fId2 = getNextFrameId();
     dequeueAndQueue(1);
 
     // Verify queue-related timestamps for f2 are available immediately in the
@@ -931,7 +1220,7 @@
     // acquire fence.
     resetTimestamps();
     oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    result = native_window_get_frame_timestamps(mWindow.get(), framesAgo,
+    result = native_window_get_frame_timestamps(mWindow.get(), fId2,
             &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
     EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
@@ -943,7 +1232,7 @@
     mFrames[1].signalQueueFences();
 
     oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    result = native_window_get_frame_timestamps(mWindow.get(), framesAgo,
+    result = native_window_get_frame_timestamps(mWindow.get(), fId2,
             &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
     EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
@@ -961,6 +1250,7 @@
     mFrames[0].signalQueueFences();
 
     // Dequeue and queue frame 2.
+    const uint64_t fId2 = getNextFrameId();
     dequeueAndQueue(1);
     mFrames[1].signalQueueFences();
 
@@ -971,9 +1261,8 @@
     mFrames[1].signalRefreshFences();
 
     // Verify a request for no timestamps doesn't result in a sync call.
-    const uint32_t framesAgo = 0;
     int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    int result = native_window_get_frame_timestamps(mWindow.get(), framesAgo,
+    int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
             nullptr, nullptr, nullptr);
     EXPECT_EQ(NO_ERROR, result);
@@ -987,6 +1276,7 @@
     mSurface->mFakeSurfaceComposer->setSupportedTimestamps(true, true);
 
     // Dequeue and queue frame 1.
+    const uint64_t fId1 = getNextFrameId();
     dequeueAndQueue(0);
     mFrames[0].signalQueueFences();
 
@@ -1001,10 +1291,9 @@
     // fence has been signaled.
     // Note: A sync call is necessary here since the events triggered by
     // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
-    uint32_t framesAgo = 1;
     resetTimestamps();
     int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    int result = getAllFrameTimestamps(framesAgo);
+    int result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
@@ -1021,10 +1310,9 @@
     // Verify available timestamps are correct for frame 1 again, before any
     // fence has been signaled.
     // This time a sync call should not be necessary.
-    framesAgo = 1;
     resetTimestamps();
     oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    result = getAllFrameTimestamps(framesAgo);
+    result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
@@ -1043,10 +1331,9 @@
     mFrames[0].signalReleaseFences();
 
     // Verify all timestamps are available without a sync call.
-    framesAgo = 1;
     resetTimestamps();
     oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    result = getAllFrameTimestamps(framesAgo);
+    result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
@@ -1069,9 +1356,8 @@
     enableFrameTimestamps();
     mSurface->mFakeSurfaceComposer->setSupportedTimestamps(true, true);
 
-    const uint32_t framesAgo = 1;
-
     // Dequeue and queue frame 1.
+    const uint64_t fId1 = getNextFrameId();
     dequeueAndQueue(0);
     mFrames[0].signalQueueFences();
 
@@ -1088,7 +1374,7 @@
     // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
     resetTimestamps();
     int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    int result = getAllFrameTimestamps(framesAgo);
+    int result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
@@ -1110,7 +1396,7 @@
     // sync call.
     resetTimestamps();
     oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    result = getAllFrameTimestamps(framesAgo);
+    result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
@@ -1132,10 +1418,12 @@
     mSurface->mFakeSurfaceComposer->setSupportedTimestamps(true, true);
 
     // Dequeue and queue frame 1.
+    const uint64_t fId1 = getNextFrameId();
     dequeueAndQueue(0);
     mFrames[0].signalQueueFences();
 
     // Dequeue and queue frame 2.
+    const uint64_t fId2 = getNextFrameId();
     dequeueAndQueue(1);
     mFrames[1].signalQueueFences();
 
@@ -1146,10 +1434,9 @@
     // fence has been signaled.
     // Note: A sync call is necessary here since the events triggered by
     // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
-    uint32_t framesAgo = 1;
     resetTimestamps();
     int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    int result = getAllFrameTimestamps(framesAgo);
+    int result = getAllFrameTimestamps(fId1);
     EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
@@ -1167,15 +1454,14 @@
     mFrames[0].signalReleaseFences();
     mFrames[1].signalRefreshFences();
 
-    // Verify querying for all timestmaps of f2 does not do a sync call.
-    // Even though the lastRefresh, retire, dequeueReady, and release times aren't
+    // Verify querying for all timestmaps of f2 does not do a sync call. Even
+    // though the lastRefresh, retire, dequeueReady, and release times aren't
     // available, a sync call should not occur because it's not possible for f2
     // to encounter the final value for those events until another frame is
     // queued.
-    framesAgo = 0;
     resetTimestamps();
     oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    result = getAllFrameTimestamps(framesAgo);
+    result = getAllFrameTimestamps(fId2);
     EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
     EXPECT_EQ(NO_ERROR, result);
     EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
@@ -1200,14 +1486,14 @@
         displayPresentSupported, displayRetireSupported);
 
     // Dequeue and queue frame 1.
+    const uint64_t fId1 = getNextFrameId();
     dequeueAndQueue(0);
 
     // Verify a query for the Present and Retire times do not trigger
     // a sync call if they are not supported.
-    const uint32_t framesAgo = 0;
     resetTimestamps();
     int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
-    int result = native_window_get_frame_timestamps(mWindow.get(), framesAgo,
+    int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
             nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
             displayPresentSupported ? nullptr : &outDisplayPresentTime,
             displayRetireSupported ? nullptr : &outDisplayRetireTime,
diff --git a/libs/gui/view/Surface.cpp b/libs/gui/view/Surface.cpp
new file mode 100644
index 0000000..5ed3d3b
--- /dev/null
+++ b/libs/gui/view/Surface.cpp
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#define LOG_TAG "Surface"
+
+#include <gui/view/Surface.h>
+
+#include <binder/Parcel.h>
+
+#include <utils/Log.h>
+
+#include <gui/IGraphicBufferProducer.h>
+
+namespace android {
+namespace view {
+
+status_t Surface::writeToParcel(Parcel* parcel) const {
+    return writeToParcel(parcel, false);
+}
+
+status_t Surface::writeToParcel(Parcel* parcel, bool nameAlreadyWritten) const {
+    if (parcel == nullptr) return BAD_VALUE;
+
+    status_t res = OK;
+
+    if (!nameAlreadyWritten) {
+        res = parcel->writeString16(name);
+        if (res != OK) return res;
+
+        /* isSingleBuffered defaults to no */
+        res = parcel->writeInt32(0);
+        if (res != OK) return res;
+    }
+
+    res = parcel->writeStrongBinder(
+            IGraphicBufferProducer::asBinder(graphicBufferProducer));
+
+    return res;
+}
+
+status_t Surface::readFromParcel(const Parcel* parcel) {
+    return readFromParcel(parcel, false);
+}
+
+status_t Surface::readFromParcel(const Parcel* parcel, bool nameAlreadyRead) {
+    if (parcel == nullptr) return BAD_VALUE;
+
+    status_t res = OK;
+    if (!nameAlreadyRead) {
+        name = readMaybeEmptyString16(parcel);
+        // Discard this for now
+        int isSingleBuffered;
+        res = parcel->readInt32(&isSingleBuffered);
+        if (res != OK) {
+            ALOGE("Can't read isSingleBuffered");
+            return res;
+        }
+    }
+
+    sp<IBinder> binder;
+
+    res = parcel->readNullableStrongBinder(&binder);
+    if (res != OK) {
+        ALOGE("%s: Can't read strong binder", __FUNCTION__);
+        return res;
+    }
+
+    graphicBufferProducer = interface_cast<IGraphicBufferProducer>(binder);
+
+    return OK;
+}
+
+String16 Surface::readMaybeEmptyString16(const Parcel* parcel) {
+    size_t len;
+    const char16_t* str = parcel->readString16Inplace(&len);
+    if (str != nullptr) {
+        return String16(str, len);
+    } else {
+        return String16();
+    }
+}
+
+} // namespace view
+} // namespace android
diff --git a/libs/ui/GraphicBuffer.cpp b/libs/ui/GraphicBuffer.cpp
index 5ef95ec..b544426 100644
--- a/libs/ui/GraphicBuffer.cpp
+++ b/libs/ui/GraphicBuffer.cpp
@@ -50,8 +50,8 @@
     height =
     stride =
     format =
-    layerCount =
     usage  = 0;
+    layerCount = 0;
     handle = NULL;
 }
 
@@ -64,8 +64,8 @@
     height =
     stride =
     format =
-    layerCount =
     usage  = 0;
+    layerCount = 0;
     handle = NULL;
     mInitCheck = initSize(inWidth, inHeight, inFormat, 1, inUsage, inUsage,
             std::move(requestorName));
@@ -81,8 +81,8 @@
     height =
     stride =
     format =
-    layerCount =
     usage  = 0;
+    layerCount = 0;
     handle = NULL;
     mInitCheck = initSize(inWidth, inHeight, inFormat, inLayerCount,
             producerUsage, consumerUsage, std::move(requestorName));
diff --git a/libs/ui/GraphicBufferMapper.cpp b/libs/ui/GraphicBufferMapper.cpp
index b0ed2df..a3b6e18 100644
--- a/libs/ui/GraphicBufferMapper.cpp
+++ b/libs/ui/GraphicBufferMapper.cpp
@@ -63,7 +63,14 @@
     if (mMapper->valid()) {
         error = static_cast<gralloc1_error_t>(mMapper->retain(handle));
     } else {
+        // This always returns GRALLOC1_BAD_HANDLE when handle is from a
+        // remote process and mDevice is backed by Gralloc1On0Adapter.
         error = mDevice->retain(handle);
+        if (error == GRALLOC1_ERROR_BAD_HANDLE &&
+                mDevice->hasCapability(GRALLOC1_CAPABILITY_ON_ADAPTER)) {
+            ALOGE("registerBuffer by handle is not supported with "
+                  "Gralloc1On0Adapter");
+        }
     }
 
     ALOGW_IF(error != GRALLOC1_ERROR_NONE, "registerBuffer(%p) failed: %d",
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/services/vr/vr_manager/Android.mk b/libs/vr/libvr_manager/Android.mk
similarity index 79%
rename from services/vr/vr_manager/Android.mk
rename to libs/vr/libvr_manager/Android.mk
index 54b1c1a..e9987f7 100644
--- a/services/vr/vr_manager/Android.mk
+++ b/libs/vr/libvr_manager/Android.mk
@@ -14,11 +14,16 @@
 
 LOCAL_PATH := $(call my-dir)
 
+exported_include_dirs := \
+  $(LOCAL_PATH)/include
+
+include_dirs := \
+  frameworks/native/include/vr/vr_manager \
+  $(exported_include_dirs)
+
 src_files := \
   vr_manager.cpp \
-
-inc_files := \
-  frameworks/native/include/vr/vr_manager
+  trusted_uids.cpp
 
 static_libs := \
   libutils \
@@ -26,13 +31,12 @@
 
 include $(CLEAR_VARS)
 LOCAL_SRC_FILES := $(src_files)
-LOCAL_C_INCLUDES := $(inc_files)
+LOCAL_C_INCLUDES := $(include_dirs)
+LOCAL_EXPORT_C_INCLUDE_DIRS := $(exported_include_dirs)
 LOCAL_CFLAGS += -Wall
 LOCAL_CFLAGS += -Werror
 LOCAL_CFLAGS += -Wunused
 LOCAL_CFLAGS += -Wunreachable-code
-LOCAL_EXPORT_C_INCLUDE_DIRS := $(inc_files)
-#LOCAL_SHARED_LIBRARIES := $(sharedLibraries)
 LOCAL_STATIC_LIBRARIES := $(static_libs)
 LOCAL_MODULE := libvr_manager
 include $(BUILD_STATIC_LIBRARY)
diff --git a/libs/vr/libvr_manager/include/private/dvr/trusted_uids.h b/libs/vr/libvr_manager/include/private/dvr/trusted_uids.h
new file mode 100644
index 0000000..4496fbf
--- /dev/null
+++ b/libs/vr/libvr_manager/include/private/dvr/trusted_uids.h
@@ -0,0 +1,33 @@
+#ifndef ANDROID_DVR_TRUSTED_UIDS_H_
+#define ANDROID_DVR_TRUSTED_UIDS_H_
+
+#include <sys/types.h>
+
+namespace android {
+namespace dvr {
+
+/**
+ * Tells if a provided UID can be trusted to access restricted VR APIs.
+ *
+ * UID trust is based on the android.permission.RESTRICTED_VR_ACCESS permission.
+ * AID_SYSTEM and AID_ROOT are automatically trusted by Android.
+ *
+ * UIDs are guaranteed not to be reused until the next reboot even in case
+ * of package reinstall. For performance reasons this method caches results by
+ * default, as otherwise every check would trigger a Java call.
+ *
+ * This function is thread-safe.
+ *
+ * @param uid The uid to check.
+ * @param use_cache If true any cached result for the provided uid will be
+ *     reused. If false this call will reach the Application Manager Service
+ *     in Java to get updated values. Any updates will be stored in the cache.
+ * @return true if the uid is trusted, false if not or if the VR Manager Service
+ *         could not be reached to verify the uid.
+ */
+bool IsTrustedUid(uid_t uid, bool use_cache = true);
+
+}  // namespace dvr
+}  // namespace android
+
+#endif  // ANDROID_DVR_TRUSTED_UIDS_H_
diff --git a/libs/vr/libvr_manager/trusted_uids.cpp b/libs/vr/libvr_manager/trusted_uids.cpp
new file mode 100644
index 0000000..4228a05
--- /dev/null
+++ b/libs/vr/libvr_manager/trusted_uids.cpp
@@ -0,0 +1,51 @@
+#include "private/dvr/trusted_uids.h"
+
+#include <mutex>
+#include <unordered_map>
+
+#include <binder/IPermissionController.h>
+#include <binder/IServiceManager.h>
+#include <private/android_filesystem_config.h>
+#include <utils/String16.h>
+#include <vr/vr_manager/vr_manager.h>
+
+namespace android {
+namespace dvr {
+
+bool IsTrustedUid(uid_t uid, bool use_cache) {
+  static std::unordered_map<uid_t, bool> uid_cache;
+  static std::mutex uid_cache_mutex;
+
+  // Whitelist requests from the system UID.
+  // These are already whitelisted by the permission service, but it might not
+  // be available if the ActivityManagerService is up during boot.
+  // This ensures the correct result for system services while booting up.
+  if (uid == AID_SYSTEM)
+    return true;
+
+  std::lock_guard<std::mutex> lock(uid_cache_mutex);
+
+  if (use_cache) {
+    auto it = uid_cache.find(uid);
+    if (it != uid_cache.end())
+      return it->second;
+  }
+
+  sp<IBinder> binder = defaultServiceManager()->getService(String16("permission"));
+  if (binder == 0) {
+    ALOGW("Could not access permission service");
+    return false;
+  }
+
+  // Note: we ignore the pid because it's only used to automatically reply
+  // true if the caller is the Activity Manager Service.
+  bool trusted = interface_cast<IPermissionController>(binder)->checkPermission(
+      String16("android.permission.RESTRICTED_VR_ACCESS"), -1, uid);
+
+  // Cache the information for this uid to avoid future Java calls.
+  uid_cache[uid] = trusted;
+  return trusted;
+}
+
+}  // namespace dvr
+}  // namespace android
diff --git a/services/vr/vr_manager/vr_manager.cpp b/libs/vr/libvr_manager/vr_manager.cpp
similarity index 100%
rename from services/vr/vr_manager/vr_manager.cpp
rename to libs/vr/libvr_manager/vr_manager.cpp
diff --git a/libs/vr/libvrflinger/Android.mk b/libs/vr/libvrflinger/Android.mk
index 6b5e7cc..1706f30 100644
--- a/libs/vr/libvrflinger/Android.mk
+++ b/libs/vr/libvrflinger/Android.mk
@@ -45,6 +45,7 @@
 	libperformance \
 	libsensor \
 	libpdx_default_transport \
+	libvr_manager \
 
 sharedLibraries := \
 	android.dvr.composer@1.0 \
@@ -76,11 +77,6 @@
 LOCAL_CFLAGS += -DTRACE=0
 LOCAL_CFLAGS += -DATRACE_TAG=ATRACE_TAG_GRAPHICS
 LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES
-ifeq ($(TARGET_USES_QCOM_BSP), true)
-    LOCAL_C_INCLUDES += hardware/qcom/display/libgralloc
-    LOCAL_C_INCLUDES += hardware/qcom/display/libqdutils
-    LOCAL_SHARED_LIBRARIES += libqdutils
-endif
 LOCAL_SHARED_LIBRARIES := $(sharedLibraries)
 LOCAL_WHOLE_STATIC_LIBRARIES := $(staticLibraries)
 LOCAL_MODULE := libvrflinger
diff --git a/libs/vr/libvrflinger/display_service.cpp b/libs/vr/libvrflinger/display_service.cpp
index c464c98..5309acf 100644
--- a/libs/vr/libvrflinger/display_service.cpp
+++ b/libs/vr/libvrflinger/display_service.cpp
@@ -318,6 +318,10 @@
   return hardware_composer_.SetDisplaySurfaces(std::move(visible_surfaces));
 }
 
+void DisplayService::OnHardwareComposerRefresh() {
+  hardware_composer_.OnHardwareComposerRefresh();
+}
+
 void DisplayService::SetDisplayConfigurationUpdateNotifier(
     DisplayConfigurationUpdateNotifier update_notifier) {
   update_notifier_ = update_notifier;
diff --git a/libs/vr/libvrflinger/display_service.h b/libs/vr/libvrflinger/display_service.h
index ebd97de..5de4f1d 100644
--- a/libs/vr/libvrflinger/display_service.h
+++ b/libs/vr/libvrflinger/display_service.h
@@ -68,6 +68,8 @@
     }
   }
 
+  void OnHardwareComposerRefresh();
+
  private:
   friend BASE;
   friend DisplaySurface;
diff --git a/libs/vr/libvrflinger/hardware_composer.cpp b/libs/vr/libvrflinger/hardware_composer.cpp
index 5253b26..e6ed665 100644
--- a/libs/vr/libvrflinger/hardware_composer.cpp
+++ b/libs/vr/libvrflinger/hardware_composer.cpp
@@ -1287,6 +1287,10 @@
   // TODO(eieio): implement display hotplug callbacks.
 }
 
+void HardwareComposer::OnHardwareComposerRefresh() {
+  // TODO(steventhomas): Handle refresh.
+}
+
 void HardwareComposer::SetBacklightBrightness(int brightness) {
   if (backlight_brightness_fd_) {
     std::array<char, 32> text;
diff --git a/libs/vr/libvrflinger/hardware_composer.h b/libs/vr/libvrflinger/hardware_composer.h
index 33f090d..b6aa807 100644
--- a/libs/vr/libvrflinger/hardware_composer.h
+++ b/libs/vr/libvrflinger/hardware_composer.h
@@ -224,6 +224,8 @@
 
   Compositor* GetCompositor() { return &compositor_; }
 
+  void OnHardwareComposerRefresh();
+
  private:
   int32_t EnableVsync(bool enabled);
 
diff --git a/libs/vr/libvrflinger/include/dvr/vr_flinger.h b/libs/vr/libvrflinger/include/dvr/vr_flinger.h
index 04c8363..17dce96 100644
--- a/libs/vr/libvrflinger/include/dvr/vr_flinger.h
+++ b/libs/vr/libvrflinger/include/dvr/vr_flinger.h
@@ -21,6 +21,7 @@
 
   void EnterVrMode();
   void ExitVrMode();
+  void OnHardwareComposerRefresh();
 
  private:
   std::thread displayd_thread_;
diff --git a/libs/vr/libvrflinger/screenshot_service.cpp b/libs/vr/libvrflinger/screenshot_service.cpp
index e174943..fd1c582 100644
--- a/libs/vr/libvrflinger/screenshot_service.cpp
+++ b/libs/vr/libvrflinger/screenshot_service.cpp
@@ -3,7 +3,9 @@
 #include <utils/Trace.h>
 
 #include <pdx/default_transport/service_endpoint.h>
+#include <private/android_filesystem_config.h>
 #include <private/dvr/display_types.h>
+#include <private/dvr/trusted_uids.h>
 
 using android::pdx::Message;
 using android::pdx::MessageInfo;
@@ -40,6 +42,12 @@
 
 ScreenshotData ScreenshotService::OnTakeScreenshot(pdx::Message& message,
                                                    int layer_index) {
+  // Also allow AID_SHELL to support vrscreencap commands.
+  if (message.GetEffectiveUserId() != AID_SHELL &&
+      !IsTrustedUid(message.GetEffectiveUserId())) {
+    REPLY_ERROR_RETURN(message, EACCES, {});
+  }
+
   AddWaiter(std::move(message), layer_index);
   return {};
 }
diff --git a/libs/vr/libvrflinger/vr_flinger.cpp b/libs/vr/libvrflinger/vr_flinger.cpp
index 82ce067..9163e71 100644
--- a/libs/vr/libvrflinger/vr_flinger.cpp
+++ b/libs/vr/libvrflinger/vr_flinger.cpp
@@ -106,5 +106,13 @@
   }
 }
 
+void VrFlinger::OnHardwareComposerRefresh() {
+  if (display_service_) {
+    display_service_->OnHardwareComposerRefresh();
+  } else {
+    ALOGE("OnHardwareComposerRefresh failed : Display service is not started.");
+  }
+}
+
 }  // namespace dvr
 }  // namespace android
diff --git a/opengl/include/EGL/eglext.h b/opengl/include/EGL/eglext.h
index 027c18d..df84c93 100644
--- a/opengl/include/EGL/eglext.h
+++ b/opengl/include/EGL/eglext.h
@@ -619,6 +619,16 @@
 #endif
 #endif
 
+#ifndef EGL_ANDROID_get_native_client_buffer
+#define EGL_ANDROID_get_native_client_buffer 1
+struct AHardwareBuffer;
+#ifdef EGL_EGLEXT_PROTOTYPES
+EGLAPI EGLClientBuffer eglGetNativeClientBufferANDROID (const AHardwareBuffer *buffer);
+#else
+typedef EGLClientBuffer (EGLAPIENTRYP PFNEGLGETNATIVECLIENTBUFFERANDROID) (const AHardwareBuffer *buffer);
+#endif
+#endif
+
 #ifndef EGL_ANDROID_front_buffer_auto_refresh
 #define EGL_ANDROID_front_buffer_auto_refresh 1
 #define EGL_FRONT_BUFFER_AUTO_REFRESH_ANDROID 0x314C
@@ -632,22 +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 eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface, EGLint framesAgo, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
-EGLAPI EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+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 eglGetFrameTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
 #else
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLGETFRAMETIMESTAMPSANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint framesAgo, EGLint numTimestamps, const EGLint *timestamps, EGLnsecsANDROID *values);
-typedef EGLBoolean (EGLAPIENTRYP PFNEGLQUERYTIMESTAMPSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
+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 PFNEGLGETFRAMETIMESTAMPSUPPORTEDANDROID) (EGLDisplay dpy, EGLSurface surface, EGLint timestamp);
 #endif
 #endif
 
diff --git a/opengl/libs/EGL/eglApi.cpp b/opengl/libs/EGL/eglApi.cpp
index 2782ed7..ef3d7a3 100644
--- a/opengl/libs/EGL/eglApi.cpp
+++ b/opengl/libs/EGL/eglApi.cpp
@@ -27,6 +27,7 @@
 #include <EGL/egl.h>
 #include <EGL/eglext.h>
 
+#include <android/hardware_buffer.h>
 #include <cutils/atomic.h>
 #include <cutils/compiler.h>
 #include <cutils/memory.h>
@@ -56,8 +57,6 @@
 
 using namespace android;
 
-#define ENABLE_EGL_ANDROID_GET_FRAME_TIMESTAMPS 0
-
 // ----------------------------------------------------------------------------
 
 namespace android {
@@ -87,10 +86,9 @@
         "EGL_ANDROID_presentation_time "
         "EGL_KHR_swap_buffers_with_damage "
         "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
@@ -182,10 +180,14 @@
     { "eglSwapBuffersWithDamageKHR",
             (__eglMustCastToProperFunctionPointerType)&eglSwapBuffersWithDamageKHR },
 
-    // EGL_ANDROID_native_client_buffer
+    // EGL_ANDROID_create_native_client_buffer
     { "eglCreateNativeClientBufferANDROID",
             (__eglMustCastToProperFunctionPointerType)&eglCreateNativeClientBufferANDROID },
 
+    // EGL_ANDROID_get_native_client_buffer
+    { "eglGetNativeClientBufferANDROID",
+            (__eglMustCastToProperFunctionPointerType)&eglGetNativeClientBufferANDROID },
+
     // EGL_KHR_partial_update
     { "eglSetDamageRegionKHR",
             (__eglMustCastToProperFunctionPointerType)&eglSetDamageRegionKHR },
@@ -216,10 +218,16 @@
             (__eglMustCastToProperFunctionPointerType)&eglCreateStreamFromFileDescriptorKHR },
 
     // EGL_ANDROID_get_frame_timestamps
+    { "eglGetNextFrameIdANDROID",
+            (__eglMustCastToProperFunctionPointerType)&eglGetNextFrameIdANDROID },
+    { "eglGetCompositorTimingANDROID",
+            (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingANDROID },
+    { "eglGetCompositorTimingSupportedANDROID",
+            (__eglMustCastToProperFunctionPointerType)&eglGetCompositorTimingSupportedANDROID },
     { "eglGetFrameTimestampsANDROID",
             (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampsANDROID },
-    { "eglQueryTimestampSupportedANDROID",
-            (__eglMustCastToProperFunctionPointerType)&eglQueryTimestampSupportedANDROID },
+    { "eglGetFrameTimestampSupportedANDROID",
+            (__eglMustCastToProperFunctionPointerType)&eglGetFrameTimestampSupportedANDROID },
 };
 
 /*
@@ -1240,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);
@@ -1250,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(
@@ -1980,6 +1986,17 @@
     return setError(EGL_BAD_ALLOC, (EGLClientBuffer)0);
 }
 
+EGLClientBuffer eglGetNativeClientBufferANDROID(const AHardwareBuffer *buffer) {
+    clearError();
+
+    if (!buffer) return setError(EGL_BAD_PARAMETER, (EGLClientBuffer)0);
+
+    // FIXME: remove this dangerous reinterpret_cast.
+    const GraphicBuffer* graphicBuffer =
+            reinterpret_cast<const GraphicBuffer*>(buffer);
+    return static_cast<EGLClientBuffer>(graphicBuffer->getNativeBuffer());
+}
+
 // ----------------------------------------------------------------------------
 // NVIDIA extensions
 // ----------------------------------------------------------------------------
@@ -2048,8 +2065,131 @@
     return EGL_FALSE;
 }
 
+EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface,
+            EGLuint64KHR *frameId) {
+    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);
+    }
+
+    uint64_t nextFrameId = 0;
+    status_t ret = native_window_get_next_frame_id(s->win.get(), &nextFrameId);
+
+    if (ret != NO_ERROR) {
+        // This should not happen. Return an error that is not in the spec
+        // so it's obvious something is very wrong.
+        ALOGE("eglGetNextFrameId: Unexpected error.");
+        return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
+    }
+
+    *frameId = nextFrameId;
+    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,
-        EGLint framesAgo, EGLint numTimestamps, const EGLint *timestamps,
+        EGLuint64KHR frameId, EGLint numTimestamps, const EGLint *timestamps,
         EGLnsecsANDROID *values)
 {
     clearError();
@@ -2118,7 +2258,7 @@
         }
     }
 
-    status_t ret = native_window_get_frame_timestamps(s->win.get(), framesAgo,
+    status_t ret = native_window_get_frame_timestamps(s->win.get(), frameId,
             requestedPresentTime, acquireTime, latchTime, firstRefreshStartTime,
             lastRefreshStartTime, GLCompositionDoneTime, displayPresentTime,
             displayRetireTime, dequeueReadyTime, releaseTime);
@@ -2135,12 +2275,13 @@
       default:
         // This should not happen. Return an error that is not in the spec
         // so it's obvious something is very wrong.
+        ALOGE("eglGetFrameTimestamps: Unexpected error.");
         return setError(EGL_NOT_INITIALIZED, EGL_FALSE);
     }
 }
 
-EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface surface,
-        EGLint timestamp)
+EGLBoolean eglGetFrameTimestampSupportedANDROID(
+        EGLDisplay dpy, EGLSurface surface, EGLint timestamp)
 {
     clearError();
 
@@ -2162,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:
@@ -2184,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/libs/EGL/egl_entries.in b/opengl/libs/EGL/egl_entries.in
index 2b56718..b587a16 100644
--- a/opengl/libs/EGL/egl_entries.in
+++ b/opengl/libs/EGL/egl_entries.in
@@ -81,6 +81,7 @@
 EGL_ENTRY(EGLClientBuffer, eglGetRenderBufferANDROID, EGLDisplay, EGLSurface)
 EGL_ENTRY(EGLint, eglDupNativeFenceFDANDROID, EGLDisplay, EGLSyncKHR)
 EGL_ENTRY(EGLClientBuffer, eglCreateNativeClientBufferANDROID, const EGLint *)
+EGL_ENTRY(EGLClientBuffer, eglGetNativeClientBufferANDROID, const AHardwareBuffer *)
 
 /* NVIDIA extensions */
 
diff --git a/opengl/libs/libEGL.map.txt b/opengl/libs/libEGL.map.txt
index c8b83f5..89269a0 100644
--- a/opengl/libs/libEGL.map.txt
+++ b/opengl/libs/libEGL.map.txt
@@ -28,6 +28,7 @@
     eglGetCurrentSurface;
     eglGetDisplay;
     eglGetError;
+    eglGetNativeClientBufferANDROID; # introduced=26
     eglGetProcAddress;
     eglGetStreamFileDescriptorKHR; # introduced=23
     eglGetSyncAttribKHR; # introduced-arm=18 introduced-arm64=21 introduced-mips=18 introduced-mips64=21 introduced-x86=18 introduced-x86_64=21
diff --git a/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt b/opengl/specs/EGL_ANDROID_get_frame_timestamps.txt
index 7aa0d30..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
 
@@ -57,26 +65,36 @@
 
 New Procedures and Functions
 
-    EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface surface,
-            EGLint framesAgo, EGLint numTimestamps, const EGLint *timestamps,
-            EGLnsecsANDROID *values);
+    EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface,
+            EGLuint64KHR *frameId);
 
-    EGLBoolean eglQueryTimestampSupportedANDROID(EGLDisplay dpy, EGLSurface
-            surface, EGLint timestamp);
+    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);
 
 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:
@@ -86,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,
@@ -95,23 +112,60 @@
 
     The function
 
-        EGLBoolean eglGetFrameTimestampsANDROID(EGLDisplay dpy, EGLSurface
-            surface, EGLint framesAgo, EGLint numTimestamps,
+        EGLBoolean eglGetNextFrameIdANDROID(EGLDisplay dpy, EGLSurface surface,
+            EGLuint64KHR *frameId);
+
+    Returns an identifier for the next frame to be swapped. The identifier can
+    be used to correlate a particular eglSwapBuffers with its timestamps in
+    eglGetFrameTimestampsANDROID. If any error is generated, the function will
+    return EGL_FALSE.
+
+    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);
 
-    allows querying various timestamps related to the composition and display of
-    a window surface.
+    allows querying various timestamps related to the composition and display
+    of specific frames of a window surface.
 
-    The framesAgo parameter indicates how many frames before the last queued
-    frame to query. So a value of zero would indicate that the query is for the
-    last queued frame. Note that the implementation maintains a limited history
-    of timestamp data. If a query is made for a frame whose timestamp history
-    no longer exists then EGL_BAD_ACCESS is generated. If timestamp collection
-    has not been enabled for the surface then EGL_BAD_SURFACE is generated.
-    Timestamps for events that will not occur or have not yet occurred will be
-    zero. Timestamp queries that are not supported will generate an
-    EGL_BAD_PARAMETER error. If any error is generated the function will return
-    EGL_FALSE.
+    The frameId indicates which frame to query. The implementation maintains a
+    limited history of timestamp data. If a query is made for a frame whose
+    timestamp history no longer exists then EGL_BAD_ACCESS is generated. If
+    timestamp collection has not been enabled for the surface then
+    EGL_BAD_SURFACE is generated.  Timestamps for events that will not occur or
+    have not yet occurred will be zero. Timestamp queries that are not
+    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
@@ -151,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
 
@@ -164,14 +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.
+
+#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/EGL_ANDROID_get_native_client_buffer.txt b/opengl/specs/EGL_ANDROID_get_native_client_buffer.txt
new file mode 100644
index 0000000..de012a0
--- /dev/null
+++ b/opengl/specs/EGL_ANDROID_get_native_client_buffer.txt
@@ -0,0 +1,96 @@
+Name
+
+    ANDROID_get_native_client_buffer
+
+Name Strings
+
+    EGL_ANDROID_get_native_client_buffer
+
+Contributors
+
+    Craig Donner
+
+Contact
+
+    Craig Donner, Google Inc. (cdonner 'at' google.com)
+
+Status
+
+    Draft
+
+Version
+
+    Version 1.0, January 27, 2017
+
+Number
+
+    EGL Extension #XXX
+
+Dependencies
+
+    Requires EGL 1.2.
+
+    EGL_ANDROID_image_native_buffer and EGL_KHR_image_base are required.
+
+    This extension is written against the wording of the EGL 1.2
+    Specification as modified by EGL_KHR_image_base and
+    EGL_ANDROID_image_native_buffer.
+
+Overview
+
+    This extension allows creating an EGLClientBuffer from an Android
+    AHardwareBuffer object which can be later used to create an EGLImage.
+
+New Types
+
+struct AHardwareBuffer
+
+New Procedures and Functions
+
+EGLClientBuffer eglGetNativeClientBufferANDROID(const AHardwareBuffer *buffer)
+
+New Tokens
+
+    None
+
+Changes to Chapter 3 of the EGL 1.2 Specification (EGL Functions and Errors)
+
+    Add the following to section 2.5.1 "EGLImage Specification" (as modified by
+    the EGL_KHR_image_base and EGL_ANDROID_image_native_buffer specifications),
+    below the description of eglCreateImageKHR:
+
+   "The command
+
+        EGLClientBuffer eglGeteNativeClientBufferANDROID(
+                                AHardwareBuffer *buffer)
+
+    may be used to create an EGLClientBuffer from an AHardwareBuffer object.
+    EGL implementations must guarantee that the lifetime of the returned
+    EGLClientBuffer is at least as long as the EGLImage(s) it is bound to,
+    following the lifetime semantics described below in section 2.5.2; the
+    EGLClientBuffer must be destroyed no earlier than when all of its associated
+    EGLImages are destroyed by eglDestroyImageKHR.
+
+    Errors
+
+        If eglGeteNativeClientBufferANDROID fails, NULL will be returned, no
+        memory will be allocated, and the following error will be generated:
+
+       * If the value of buffer is NULL, the error EGL_BAD_PARAMETER is
+         generated.
+
+Issues
+
+    1. Should this extension define what particular AHardwareBuffer formats EGL
+    implementations are required to support?
+
+    RESOLVED: No.
+
+    The set of valid formats is implementation-specific and may depend on
+    additional EGL extensions. The particular valid combinations for a given
+    Android version and implementation should be documented by that version.
+
+Revision History
+
+#1 (Craig Donner, January 27, 2017)
+    - Initial draft.
diff --git a/opengl/specs/README b/opengl/specs/README
index 8a3a7aa..0c49023 100644
--- a/opengl/specs/README
+++ b/opengl/specs/README
@@ -1,5 +1,5 @@
 This directory contains OpenGL ES and EGL extension specifications that have
-been or are being defined for Android.  
+been or are being defined for Android.
 
 The table below tracks usage of EGL enumerant values that have been reserved
 for use by Android extensions.
@@ -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/sensorservice/Android.mk b/services/sensorservice/Android.mk
index c41630a..d61f26f 100644
--- a/services/sensorservice/Android.mk
+++ b/services/sensorservice/Android.mk
@@ -10,6 +10,7 @@
     OrientationSensor.cpp \
     RecentEventLogger.cpp \
     RotationVectorSensor.cpp \
+    SensorDevice.cpp \
     SensorDirectConnection.cpp \
     SensorEventConnection.cpp \
     SensorFusion.cpp \
@@ -25,13 +26,6 @@
 
 LOCAL_CFLAGS += -fvisibility=hidden
 
-ifeq ($(ENABLE_TREBLE), true)
-LOCAL_SRC_FILES += SensorDeviceTreble.cpp
-LOCAL_CFLAGS += -DENABLE_TREBLE=1
-else
-LOCAL_SRC_FILES += SensorDevice.cpp
-endif
-
 LOCAL_SHARED_LIBRARIES := \
     libcutils \
     libhardware \
@@ -42,10 +36,6 @@
     libui \
     libgui \
     libcrypto \
-
-ifeq ($(ENABLE_TREBLE), true)
-
-LOCAL_SHARED_LIBRARIES += \
     libbase \
     libhidlbase \
     libhidltransport \
@@ -55,8 +45,6 @@
 LOCAL_STATIC_LIBRARIES := \
     android.hardware.sensors@1.0-convert
 
-endif  # ENABLE_TREBLE
-
 LOCAL_MODULE:= libsensorservice
 
 include $(BUILD_SHARED_LIBRARY)
diff --git a/services/sensorservice/SensorDevice.cpp b/services/sensorservice/SensorDevice.cpp
index de0321d..3edd50b 100644
--- a/services/sensorservice/SensorDevice.cpp
+++ b/services/sensorservice/SensorDevice.cpp
@@ -14,138 +14,167 @@
  * limitations under the License.
  */
 
+#include <inttypes.h>
+#include <math.h>
+#include <stdint.h>
+#include <sys/types.h>
 
-#include "SensorDevice.h"
-#include "SensorService.h"
-
-
-#include <binder/BinderService.h>
-#include <binder/Parcel.h>
-#include <binder/IServiceManager.h>
-#include <cutils/ashmem.h>
-#include <hardware/sensors.h>
+#include <android-base/logging.h>
 #include <utils/Atomic.h>
 #include <utils/Errors.h>
 #include <utils/Singleton.h>
 
-#include <inttypes.h>
-#include <math.h>
-#include <sys/mman.h>
-#include <stdint.h>
-#include <sys/types.h>
-#include <sstream>
-#include <unistd.h>
+#include "SensorDevice.h"
+#include "SensorService.h"
+
+#include <sensors/convert.h>
+
+using android::hardware::hidl_vec;
+
+using namespace android::hardware::sensors::V1_0;
+using namespace android::hardware::sensors::V1_0::implementation;
 
 namespace android {
 // ---------------------------------------------------------------------------
 
 ANDROID_SINGLETON_STATIC_INSTANCE(SensorDevice)
 
-SensorDevice::SensorDevice()
-    :  mSensorDevice(0),
-       mSensorModule(0) {
-    status_t err = hw_get_module(SENSORS_HARDWARE_MODULE_ID,
-            (hw_module_t const**)&mSensorModule);
-
-    ALOGE_IF(err, "couldn't load %s module (%s)",
-            SENSORS_HARDWARE_MODULE_ID, strerror(-err));
-
-    if (mSensorModule) {
-        err = sensors_open_1(&mSensorModule->common, &mSensorDevice);
-
-        ALOGE_IF(err, "couldn't open device for module %s (%s)",
-                SENSORS_HARDWARE_MODULE_ID, strerror(-err));
-
-        if (mSensorDevice) {
-
-            sensor_t const* list;
-            ssize_t count = mSensorModule->get_sensors_list(mSensorModule, &list);
-
-            if (mSensorDevice->common.version < SENSORS_DEVICE_API_VERSION_1_3) {
-                ALOGE(">>>> WARNING <<< Upgrade sensor HAL to version 1_3, ignoring sensors reported by this device");
-                count = 0;
-            }
-
-            mActivationCount.setCapacity(count);
-            Info model;
-            for (size_t i=0 ; i<size_t(count) ; i++) {
-                mActivationCount.add(list[i].handle, model);
-                mSensorDevice->activate(
-                        reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
-                        list[i].handle, 0);
-            }
-        }
+static status_t StatusFromResult(Result result) {
+    switch (result) {
+        case Result::OK:
+            return OK;
+        case Result::BAD_VALUE:
+            return BAD_VALUE;
+        case Result::PERMISSION_DENIED:
+            return PERMISSION_DENIED;
+        case Result::INVALID_OPERATION:
+            return INVALID_OPERATION;
+        case Result::NO_MEMORY:
+            return NO_MEMORY;
     }
 }
 
+SensorDevice::SensorDevice() {
+    mSensors = ISensors::getService();
+
+    if (mSensors == NULL) {
+        return;
+    }
+
+    mSensors->getSensorsList(
+            [&](const auto &list) {
+                const size_t count = list.size();
+
+                mActivationCount.setCapacity(count);
+                Info model;
+                for (size_t i=0 ; i < count; i++) {
+                    sensor_t sensor;
+                    convertToSensor(list[i], &sensor);
+                    mSensorList.push_back(sensor);
+
+                    mActivationCount.add(list[i].sensorHandle, model);
+
+                    mSensors->activate(list[i].sensorHandle, 0 /* enabled */);
+                }
+            });
+
+    mIsDirectReportSupported =
+           (mSensors->unregisterDirectChannel(-1) != Result::INVALID_OPERATION);
+}
+
 void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {
     if (connected) {
         Info model;
         mActivationCount.add(handle, model);
-        mSensorDevice->activate(
-                reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice), handle, 0);
+        mSensors->activate(handle, 0 /* enabled */);
     } else {
         mActivationCount.removeItem(handle);
     }
 }
 
 std::string SensorDevice::dump() const {
-    if (!mSensorModule) return "HAL not initialized\n";
+    if (mSensors == NULL) return "HAL not initialized\n";
 
     String8 result;
-    sensor_t const* list;
-    int count = mSensorModule->get_sensors_list(mSensorModule, &list);
+    mSensors->getSensorsList([&](const auto &list) {
+            const size_t count = list.size();
 
-    result.appendFormat("HAL: %s (%s), version %#010x\n",
-                        mSensorModule->common.name,
-                        mSensorModule->common.author,
-                        getHalDeviceVersion());
-    result.appendFormat("Total %d h/w sensors, %zu running:\n", count, mActivationCount.size());
+            result.appendFormat(
+                "Total %zu h/w sensors, %zu running:\n",
+                count,
+                mActivationCount.size());
 
-    Mutex::Autolock _l(mLock);
-    for (int i = 0 ; i < count ; i++) {
-        const Info& info = mActivationCount.valueFor(list[i].handle);
-        if (info.batchParams.isEmpty()) continue;
-        result.appendFormat("0x%08x) active-count = %zu; ", list[i].handle,
-                            info.batchParams.size());
+            Mutex::Autolock _l(mLock);
+            for (size_t i = 0 ; i < count ; i++) {
+                const Info& info = mActivationCount.valueFor(
+                    list[i].sensorHandle);
 
-        result.append("sampling_period(ms) = {");
-        for (size_t j = 0; j < info.batchParams.size(); j++) {
-            const BatchParams& params = info.batchParams.valueAt(j);
-            result.appendFormat("%.1f%s", params.batchDelay / 1e6f,
-                                j < info.batchParams.size() - 1 ? ", " : "");
-        }
-        result.appendFormat("}, selected = %.1f ms; ", info.bestBatchParams.batchDelay / 1e6f);
+                if (info.batchParams.isEmpty()) continue;
+                result.appendFormat(
+                    "0x%08x) active-count = %zu; ",
+                    list[i].sensorHandle,
+                    info.batchParams.size());
 
-        result.append("batching_period(ms) = {");
-        for (size_t j = 0; j < info.batchParams.size(); j++) {
-            BatchParams params = info.batchParams.valueAt(j);
-            result.appendFormat("%.1f%s", params.batchTimeout / 1e6f,
-                                j < info.batchParams.size() - 1 ? ", " : "");
-        }
-        result.appendFormat("}, selected = %.1f ms\n", info.bestBatchParams.batchTimeout / 1e6f);
-    }
+                result.append("sampling_period(ms) = {");
+                for (size_t j = 0; j < info.batchParams.size(); j++) {
+                    const BatchParams& params = info.batchParams.valueAt(j);
+                    result.appendFormat(
+                        "%.1f%s",
+                        params.batchDelay / 1e6f,
+                        j < info.batchParams.size() - 1 ? ", " : "");
+                }
+                result.appendFormat(
+                        "}, selected = %.1f ms; ",
+                        info.bestBatchParams.batchDelay / 1e6f);
+
+                result.append("batching_period(ms) = {");
+                for (size_t j = 0; j < info.batchParams.size(); j++) {
+                    BatchParams params = info.batchParams.valueAt(j);
+
+                    result.appendFormat(
+                            "%.1f%s",
+                            params.batchTimeout / 1e6f,
+                            j < info.batchParams.size() - 1 ? ", " : "");
+                }
+
+                result.appendFormat(
+                        "}, selected = %.1f ms\n",
+                        info.bestBatchParams.batchTimeout / 1e6f);
+            }
+        });
+
     return result.string();
 }
 
 ssize_t SensorDevice::getSensorList(sensor_t const** list) {
-    if (!mSensorModule) return NO_INIT;
-    ssize_t count = mSensorModule->get_sensors_list(mSensorModule, list);
-    return count;
+    *list = &mSensorList[0];
+
+    return mSensorList.size();
 }
 
 status_t SensorDevice::initCheck() const {
-    return mSensorDevice && mSensorModule ? NO_ERROR : NO_INIT;
+    return mSensors != NULL ? NO_ERROR : NO_INIT;
 }
 
 ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
-    if (!mSensorDevice) return NO_INIT;
-    ssize_t c;
-    do {
-        c = mSensorDevice->poll(reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice),
-                                buffer, count);
-    } while (c == -EINTR);
-    return c;
+    if (mSensors == NULL) return NO_INIT;
+
+    ssize_t err;
+
+    mSensors->poll(
+            count,
+            [&](auto result,
+                const auto &events,
+                const auto &dynamicSensorsAdded) {
+                if (result == Result::OK) {
+                    convertToSensorEvents(events, dynamicSensorsAdded, buffer);
+                    err = (ssize_t)events.size();
+                } else {
+                    err = StatusFromResult(result);
+                }
+            });
+
+    return err;
 }
 
 void SensorDevice::autoDisable(void *ident, int handle) {
@@ -155,7 +184,8 @@
 }
 
 status_t SensorDevice::activate(void* ident, int handle, int enabled) {
-    if (!mSensorDevice) return NO_INIT;
+    if (mSensors == NULL) return NO_INIT;
+
     status_t err(NO_ERROR);
     bool actuateHardware = false;
 
@@ -187,24 +217,30 @@
     } else {
         ALOGD_IF(DEBUG_CONNECTIONS, "disable index=%zd", info.batchParams.indexOfKey(ident));
 
+        // If a connected dynamic sensor is deactivated, remove it from the
+        // dictionary.
+        auto it = mConnectedDynamicSensors.find(handle);
+        if (it != mConnectedDynamicSensors.end()) {
+            delete it->second;
+            mConnectedDynamicSensors.erase(it);
+        }
+
         if (info.removeBatchParamsForIdent(ident) >= 0) {
             if (info.numActiveClients() == 0) {
                 // This is the last connection, we need to de-activate the underlying h/w sensor.
                 actuateHardware = true;
             } else {
-                const int halVersion = getHalDeviceVersion();
-                if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
-                    // Call batch for this sensor with the previously calculated best effort
-                    // batch_rate and timeout. One of the apps has unregistered for sensor
-                    // events, and the best effort batch parameters might have changed.
-                    ALOGD_IF(DEBUG_CONNECTIONS,
-                             "\t>>> actuating h/w batch %d %d %" PRId64 " %" PRId64, handle,
-                             info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
-                             info.bestBatchParams.batchTimeout);
-                    mSensorDevice->batch(mSensorDevice, handle,info.bestBatchParams.flags,
-                                         info.bestBatchParams.batchDelay,
-                                         info.bestBatchParams.batchTimeout);
-                }
+                // Call batch for this sensor with the previously calculated best effort
+                // batch_rate and timeout. One of the apps has unregistered for sensor
+                // events, and the best effort batch parameters might have changed.
+                ALOGD_IF(DEBUG_CONNECTIONS,
+                         "\t>>> actuating h/w batch %d %d %" PRId64 " %" PRId64, handle,
+                         info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
+                         info.bestBatchParams.batchTimeout);
+                mSensors->batch(
+                        handle,
+                        info.bestBatchParams.batchDelay,
+                        info.bestBatchParams.batchTimeout);
             }
         } else {
             // sensor wasn't enabled for this ident
@@ -218,8 +254,7 @@
     if (actuateHardware) {
         ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle,
                  enabled);
-        err = mSensorDevice->activate(
-                reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice), handle, enabled);
+        err = StatusFromResult(mSensors->activate(handle, enabled));
         ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,
                  strerror(-err));
 
@@ -229,31 +264,21 @@
         }
     }
 
-    // On older devices which do not support batch, call setDelay().
-    if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1 && info.numActiveClients() > 0) {
-        ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w setDelay %d %" PRId64, handle,
-                 info.bestBatchParams.batchDelay);
-        mSensorDevice->setDelay(
-                reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
-                handle, info.bestBatchParams.batchDelay);
-    }
     return err;
 }
 
-status_t SensorDevice::batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
-                             int64_t maxBatchReportLatencyNs) {
-    if (!mSensorDevice) return NO_INIT;
+status_t SensorDevice::batch(
+        void* ident,
+        int handle,
+        int flags,
+        int64_t samplingPeriodNs,
+        int64_t maxBatchReportLatencyNs) {
+    if (mSensors == NULL) return NO_INIT;
 
     if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
         samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
     }
 
-    const int halVersion = getHalDeviceVersion();
-    if (halVersion < SENSORS_DEVICE_API_VERSION_1_1 && maxBatchReportLatencyNs != 0) {
-        // Batch is not supported on older devices return invalid operation.
-        return INVALID_OPERATION;
-    }
-
     ALOGD_IF(DEBUG_CONNECTIONS,
              "SensorDevice::batch: ident=%p, handle=0x%08x, flags=%d, period_ns=%" PRId64 " timeout=%" PRId64,
              ident, handle, flags, samplingPeriodNs, maxBatchReportLatencyNs);
@@ -282,21 +307,17 @@
     status_t err(NO_ERROR);
     // If the min period or min timeout has changed since the last batch call, call batch.
     if (prevBestBatchParams != info.bestBatchParams) {
-        if (halVersion >= SENSORS_DEVICE_API_VERSION_1_1) {
-            ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH %d %d %" PRId64 " %" PRId64, handle,
-                     info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
-                     info.bestBatchParams.batchTimeout);
-            err = mSensorDevice->batch(mSensorDevice, handle, info.bestBatchParams.flags,
-                                       info.bestBatchParams.batchDelay,
-                                       info.bestBatchParams.batchTimeout);
-        } else {
-            // For older devices which do not support batch, call setDelay() after activate() is
-            // called. Some older devices may not support calling setDelay before activate(), so
-            // call setDelay in SensorDevice::activate() method.
-        }
+        ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH %d %d %" PRId64 " %" PRId64, handle,
+                 info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
+                 info.bestBatchParams.batchTimeout);
+        err = StatusFromResult(
+                mSensors->batch(
+                    handle,
+                    info.bestBatchParams.batchDelay,
+                    info.bestBatchParams.batchTimeout));
         if (err != NO_ERROR) {
             ALOGE("sensor batch failed %p %d %d %" PRId64 " %" PRId64 " err=%s",
-                  mSensorDevice, handle,
+                  mSensors.get(), handle,
                   info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
                   info.bestBatchParams.batchTimeout, strerror(-err));
             info.removeBatchParamsForIdent(ident);
@@ -306,7 +327,7 @@
 }
 
 status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs) {
-    if (!mSensorDevice) return NO_INIT;
+    if (mSensors == NULL) return NO_INIT;
     if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
         samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
     }
@@ -325,22 +346,20 @@
     BatchParams& params = info.batchParams.editValueAt(index);
     params.batchDelay = samplingPeriodNs;
     info.selectBatchParams();
-    return mSensorDevice->setDelay(reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
-                                   handle, info.bestBatchParams.batchDelay);
+
+    return StatusFromResult(
+            mSensors->batch(handle, info.bestBatchParams.batchDelay, 0));
 }
 
 int SensorDevice::getHalDeviceVersion() const {
-    if (!mSensorDevice) return -1;
-    return mSensorDevice->common.version;
+    if (mSensors == NULL) return -1;
+    return SENSORS_DEVICE_API_VERSION_1_4;
 }
 
 status_t SensorDevice::flush(void* ident, int handle) {
-    if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_1) {
-        return INVALID_OPERATION;
-    }
     if (isClientDisabled(ident)) return INVALID_OPERATION;
     ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
-    return mSensorDevice->flush(mSensorDevice, handle);
+    return StatusFromResult(mSensors->flush(handle));
 }
 
 bool SensorDevice::isClientDisabled(void* ident) {
@@ -356,7 +375,6 @@
     Mutex::Autolock _l(mLock);
     mDisabledClients.clear();
     ALOGI("cleared mDisabledClients");
-    const int halVersion = getHalDeviceVersion();
     for (size_t i = 0; i< mActivationCount.size(); ++i) {
         Info& info = mActivationCount.editValueAt(i);
         if (info.batchParams.isEmpty()) continue;
@@ -364,42 +382,32 @@
         const int sensor_handle = mActivationCount.keyAt(i);
         ALOGD_IF(DEBUG_CONNECTIONS, "\t>> reenable actuating h/w sensor enable handle=%d ",
                    sensor_handle);
-        status_t err(NO_ERROR);
-        if (halVersion > SENSORS_DEVICE_API_VERSION_1_0) {
-            err = mSensorDevice->batch(mSensorDevice, sensor_handle,
-                 info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
-                 info.bestBatchParams.batchTimeout);
-            ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));
-        }
+        status_t err = StatusFromResult(
+                mSensors->batch(
+                    sensor_handle,
+                    info.bestBatchParams.batchDelay,
+                    info.bestBatchParams.batchTimeout));
+        ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));
 
         if (err == NO_ERROR) {
-            err = mSensorDevice->activate(
-                    reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
-                    sensor_handle, 1);
+            err = StatusFromResult(
+                    mSensors->activate(sensor_handle, 1 /* enabled */));
             ALOGE_IF(err, "Error activating sensor %d (%s)", sensor_handle, strerror(-err));
         }
-
-        if (halVersion <= SENSORS_DEVICE_API_VERSION_1_0) {
-             err = mSensorDevice->setDelay(
-                    reinterpret_cast<struct sensors_poll_device_t *>(mSensorDevice),
-                    sensor_handle, info.bestBatchParams.batchDelay);
-             ALOGE_IF(err, "Error calling setDelay sensor %d (%s)", sensor_handle, strerror(-err));
-        }
     }
 }
 
 void SensorDevice::disableAllSensors() {
     Mutex::Autolock _l(mLock);
-    for (size_t i = 0; i< mActivationCount.size(); ++i) {
+   for (size_t i = 0; i< mActivationCount.size(); ++i) {
         const Info& info = mActivationCount.valueAt(i);
         // Check if this sensor has been activated previously and disable it.
         if (info.batchParams.size() > 0) {
            const int sensor_handle = mActivationCount.keyAt(i);
            ALOGD_IF(DEBUG_CONNECTIONS, "\t>> actuating h/w sensor disable handle=%d ",
                    sensor_handle);
-           mSensorDevice->activate(
-                   reinterpret_cast<struct sensors_poll_device_t *> (mSensorDevice),
-                   sensor_handle, 0);
+           mSensors->activate(sensor_handle, 0 /* enabled */);
+
            // Add all the connections that were registered for this sensor to the disabled
            // clients list.
            for (size_t j = 0; j < info.batchParams.size(); ++j) {
@@ -410,25 +418,27 @@
     }
 }
 
-status_t SensorDevice::injectSensorData(const sensors_event_t *injected_sensor_event) {
-      ALOGD_IF(DEBUG_CONNECTIONS,
-              "sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
-               injected_sensor_event->sensor,
-               injected_sensor_event->timestamp, injected_sensor_event->data[0],
-               injected_sensor_event->data[1], injected_sensor_event->data[2],
-               injected_sensor_event->data[3], injected_sensor_event->data[4],
-               injected_sensor_event->data[5]);
-      if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4) {
-          return INVALID_OPERATION;
-      }
-      return mSensorDevice->inject_sensor_data(mSensorDevice, injected_sensor_event);
+status_t SensorDevice::injectSensorData(
+        const sensors_event_t *injected_sensor_event) {
+    ALOGD_IF(DEBUG_CONNECTIONS,
+            "sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
+            injected_sensor_event->sensor,
+            injected_sensor_event->timestamp, injected_sensor_event->data[0],
+            injected_sensor_event->data[1], injected_sensor_event->data[2],
+            injected_sensor_event->data[3], injected_sensor_event->data[4],
+            injected_sensor_event->data[5]);
+
+    Event ev;
+    convertFromSensorEvent(*injected_sensor_event, &ev);
+
+    return StatusFromResult(mSensors->injectSensorData(ev));
 }
 
 status_t SensorDevice::setMode(uint32_t mode) {
-     if (getHalDeviceVersion() < SENSORS_DEVICE_API_VERSION_1_4) {
-          return INVALID_OPERATION;
-     }
-     return mSensorModule->set_operation_mode(mode);
+
+     return StatusFromResult(
+             mSensors->setOperationMode(
+                 static_cast<hardware::sensors::V1_0::OperationMode>(mode)));
 }
 
 // ---------------------------------------------------------------------------
@@ -491,44 +501,139 @@
 }
 
 int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {
-
-    if (!isDirectReportSupported()) {
-        return INVALID_OPERATION;
-    }
-
     Mutex::Autolock _l(mLock);
 
-    int32_t channelHandle = mSensorDevice->register_direct_channel(
-            mSensorDevice, memory, -1 /*channel_handle*/);
-    return channelHandle;
+    SharedMemType type;
+    switch (memory->type) {
+        case SENSOR_DIRECT_MEM_TYPE_ASHMEM:
+            type = SharedMemType::ASHMEM;
+            break;
+        case SENSOR_DIRECT_MEM_TYPE_GRALLOC:
+            type = SharedMemType::GRALLOC;
+            break;
+        default:
+            return BAD_VALUE;
+    }
+
+    SharedMemFormat format;
+    if (memory->format != SENSOR_DIRECT_FMT_SENSORS_EVENT) {
+        return BAD_VALUE;
+    }
+    format = SharedMemFormat::SENSORS_EVENT;
+
+    SharedMemInfo mem = {
+        .type = type,
+        .format = format,
+        .size = static_cast<uint32_t>(memory->size),
+        .memoryHandle = memory->handle,
+    };
+
+    int32_t ret;
+    mSensors->registerDirectChannel(mem,
+            [&ret](auto result, auto channelHandle) {
+                if (result == Result::OK) {
+                    ret = channelHandle;
+                } else {
+                    ret = StatusFromResult(result);
+                }
+            });
+    return ret;
 }
 
 void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {
     Mutex::Autolock _l(mLock);
-
-    mSensorDevice->register_direct_channel(mSensorDevice, nullptr, channelHandle);
+    mSensors->unregisterDirectChannel(channelHandle);
 }
 
-int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
-        const struct sensors_direct_cfg_t *config) {
-
-    if (!isDirectReportSupported()) {
-        return INVALID_OPERATION;
-    }
-
+int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle,
+        int32_t channelHandle, const struct sensors_direct_cfg_t *config) {
     Mutex::Autolock _l(mLock);
 
-    int32_t ret = mSensorDevice->config_direct_report(
-            mSensorDevice, sensorHandle, channelHandle, config);
-    ALOGE_IF(ret < 0, "SensorDevice::configureDirectChannel ret %d", ret);
+    RateLevel rate;
+    switch(config->rate_level) {
+        case SENSOR_DIRECT_RATE_STOP:
+            rate = RateLevel::STOP;
+            break;
+        case SENSOR_DIRECT_RATE_NORMAL:
+            rate = RateLevel::NORMAL;
+            break;
+        case SENSOR_DIRECT_RATE_FAST:
+            rate = RateLevel::FAST;
+            break;
+        case SENSOR_DIRECT_RATE_VERY_FAST:
+            rate = RateLevel::VERY_FAST;
+            break;
+        default:
+            return BAD_VALUE;
+    }
+
+    int32_t ret;
+    mSensors->configDirectReport(sensorHandle, channelHandle, rate,
+            [&ret, rate] (auto result, auto token) {
+                if (rate == RateLevel::STOP) {
+                    ret = StatusFromResult(result);
+                } else {
+                    if (result == Result::OK) {
+                        ret = token;
+                    } else {
+                        ret = StatusFromResult(result);
+                    }
+                }
+            });
+
     return ret;
 }
 
 bool SensorDevice::isDirectReportSupported() const {
-    bool ret = mSensorDevice->register_direct_channel != nullptr
-            && mSensorDevice->config_direct_report != nullptr;
-    return ret;
+    return mIsDirectReportSupported;
 }
+
+void SensorDevice::convertToSensorEvent(
+        const Event &src, sensors_event_t *dst) {
+    ::android::hardware::sensors::V1_0::implementation::convertToSensorEvent(
+            src, dst);
+
+    if (src.sensorType == SensorType::DYNAMIC_SENSOR_META) {
+        const DynamicSensorInfo &dyn = src.u.dynamic;
+
+        dst->dynamic_sensor_meta.connected = dyn.connected;
+        dst->dynamic_sensor_meta.handle = dyn.sensorHandle;
+        if (dyn.connected) {
+            auto it = mConnectedDynamicSensors.find(dyn.sensorHandle);
+            CHECK(it != mConnectedDynamicSensors.end());
+
+            dst->dynamic_sensor_meta.sensor = it->second;
+
+            memcpy(dst->dynamic_sensor_meta.uuid,
+                   dyn.uuid.data(),
+                   sizeof(dst->dynamic_sensor_meta.uuid));
+        }
+    }
+}
+
+void SensorDevice::convertToSensorEvents(
+        const hidl_vec<Event> &src,
+        const hidl_vec<SensorInfo> &dynamicSensorsAdded,
+        sensors_event_t *dst) {
+    // Allocate a sensor_t structure for each dynamic sensor added and insert
+    // it into the dictionary of connected dynamic sensors keyed by handle.
+    for (size_t i = 0; i < dynamicSensorsAdded.size(); ++i) {
+        const SensorInfo &info = dynamicSensorsAdded[i];
+
+        auto it = mConnectedDynamicSensors.find(info.sensorHandle);
+        CHECK(it == mConnectedDynamicSensors.end());
+
+        sensor_t *sensor = new sensor_t;
+        convertToSensor(info, sensor);
+
+        mConnectedDynamicSensors.insert(
+                std::make_pair(sensor->handle, sensor));
+    }
+
+    for (size_t i = 0; i < src.size(); ++i) {
+        convertToSensorEvent(src[i], &dst[i]);
+    }
+}
+
 // ---------------------------------------------------------------------------
 }; // namespace android
-
diff --git a/services/sensorservice/SensorDevice.h b/services/sensorservice/SensorDevice.h
index 7dd256a..7f95429 100644
--- a/services/sensorservice/SensorDevice.h
+++ b/services/sensorservice/SensorDevice.h
@@ -20,19 +20,16 @@
 #include "SensorServiceUtils.h"
 
 #include <gui/Sensor.h>
+#include <stdint.h>
+#include <sys/types.h>
 #include <utils/KeyedVector.h>
 #include <utils/Singleton.h>
 #include <utils/String8.h>
 
-#include <stdint.h>
-#include <sys/types.h>
 #include <string>
-
-#ifdef ENABLE_TREBLE
 #include <map>
 
 #include "android/hardware/sensors/1.0/ISensors.h"
-#endif
 
 // ---------------------------------------------------------------------------
 
@@ -76,14 +73,10 @@
     virtual std::string dump() const;
 private:
     friend class Singleton<SensorDevice>;
-#ifdef ENABLE_TREBLE
+
     sp<android::hardware::sensors::V1_0::ISensors> mSensors;
     Vector<sensor_t> mSensorList;
     std::map<int32_t, sensor_t*> mConnectedDynamicSensors;
-#else
-    sensors_poll_device_1_t* mSensorDevice;
-    struct sensors_module_t* mSensorModule;
-#endif
 
     static const nsecs_t MINIMUM_EVENTS_PERIOD =   1000000; // 1000 Hz
     mutable Mutex mLock; // protect mActivationCount[].batchParams
@@ -138,7 +131,6 @@
     bool isClientDisabled(void* ident);
     bool isClientDisabledLocked(void* ident);
 
-#ifdef ENABLE_TREBLE
     using Event = hardware::sensors::V1_0::Event;
     using SensorInfo = hardware::sensors::V1_0::SensorInfo;
 
@@ -150,7 +142,6 @@
             sensors_event_t *dst);
 
     bool mIsDirectReportSupported;
-#endif  // ENABLE_TREBLE
 };
 
 // ---------------------------------------------------------------------------
diff --git a/services/sensorservice/SensorDeviceTreble.cpp b/services/sensorservice/SensorDeviceTreble.cpp
deleted file mode 100644
index 3edd50b..0000000
--- a/services/sensorservice/SensorDeviceTreble.cpp
+++ /dev/null
@@ -1,639 +0,0 @@
-/*
- * Copyright (C) 2010 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 <inttypes.h>
-#include <math.h>
-#include <stdint.h>
-#include <sys/types.h>
-
-#include <android-base/logging.h>
-#include <utils/Atomic.h>
-#include <utils/Errors.h>
-#include <utils/Singleton.h>
-
-#include "SensorDevice.h"
-#include "SensorService.h"
-
-#include <sensors/convert.h>
-
-using android::hardware::hidl_vec;
-
-using namespace android::hardware::sensors::V1_0;
-using namespace android::hardware::sensors::V1_0::implementation;
-
-namespace android {
-// ---------------------------------------------------------------------------
-
-ANDROID_SINGLETON_STATIC_INSTANCE(SensorDevice)
-
-static status_t StatusFromResult(Result result) {
-    switch (result) {
-        case Result::OK:
-            return OK;
-        case Result::BAD_VALUE:
-            return BAD_VALUE;
-        case Result::PERMISSION_DENIED:
-            return PERMISSION_DENIED;
-        case Result::INVALID_OPERATION:
-            return INVALID_OPERATION;
-        case Result::NO_MEMORY:
-            return NO_MEMORY;
-    }
-}
-
-SensorDevice::SensorDevice() {
-    mSensors = ISensors::getService();
-
-    if (mSensors == NULL) {
-        return;
-    }
-
-    mSensors->getSensorsList(
-            [&](const auto &list) {
-                const size_t count = list.size();
-
-                mActivationCount.setCapacity(count);
-                Info model;
-                for (size_t i=0 ; i < count; i++) {
-                    sensor_t sensor;
-                    convertToSensor(list[i], &sensor);
-                    mSensorList.push_back(sensor);
-
-                    mActivationCount.add(list[i].sensorHandle, model);
-
-                    mSensors->activate(list[i].sensorHandle, 0 /* enabled */);
-                }
-            });
-
-    mIsDirectReportSupported =
-           (mSensors->unregisterDirectChannel(-1) != Result::INVALID_OPERATION);
-}
-
-void SensorDevice::handleDynamicSensorConnection(int handle, bool connected) {
-    if (connected) {
-        Info model;
-        mActivationCount.add(handle, model);
-        mSensors->activate(handle, 0 /* enabled */);
-    } else {
-        mActivationCount.removeItem(handle);
-    }
-}
-
-std::string SensorDevice::dump() const {
-    if (mSensors == NULL) return "HAL not initialized\n";
-
-    String8 result;
-    mSensors->getSensorsList([&](const auto &list) {
-            const size_t count = list.size();
-
-            result.appendFormat(
-                "Total %zu h/w sensors, %zu running:\n",
-                count,
-                mActivationCount.size());
-
-            Mutex::Autolock _l(mLock);
-            for (size_t i = 0 ; i < count ; i++) {
-                const Info& info = mActivationCount.valueFor(
-                    list[i].sensorHandle);
-
-                if (info.batchParams.isEmpty()) continue;
-                result.appendFormat(
-                    "0x%08x) active-count = %zu; ",
-                    list[i].sensorHandle,
-                    info.batchParams.size());
-
-                result.append("sampling_period(ms) = {");
-                for (size_t j = 0; j < info.batchParams.size(); j++) {
-                    const BatchParams& params = info.batchParams.valueAt(j);
-                    result.appendFormat(
-                        "%.1f%s",
-                        params.batchDelay / 1e6f,
-                        j < info.batchParams.size() - 1 ? ", " : "");
-                }
-                result.appendFormat(
-                        "}, selected = %.1f ms; ",
-                        info.bestBatchParams.batchDelay / 1e6f);
-
-                result.append("batching_period(ms) = {");
-                for (size_t j = 0; j < info.batchParams.size(); j++) {
-                    BatchParams params = info.batchParams.valueAt(j);
-
-                    result.appendFormat(
-                            "%.1f%s",
-                            params.batchTimeout / 1e6f,
-                            j < info.batchParams.size() - 1 ? ", " : "");
-                }
-
-                result.appendFormat(
-                        "}, selected = %.1f ms\n",
-                        info.bestBatchParams.batchTimeout / 1e6f);
-            }
-        });
-
-    return result.string();
-}
-
-ssize_t SensorDevice::getSensorList(sensor_t const** list) {
-    *list = &mSensorList[0];
-
-    return mSensorList.size();
-}
-
-status_t SensorDevice::initCheck() const {
-    return mSensors != NULL ? NO_ERROR : NO_INIT;
-}
-
-ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
-    if (mSensors == NULL) return NO_INIT;
-
-    ssize_t err;
-
-    mSensors->poll(
-            count,
-            [&](auto result,
-                const auto &events,
-                const auto &dynamicSensorsAdded) {
-                if (result == Result::OK) {
-                    convertToSensorEvents(events, dynamicSensorsAdded, buffer);
-                    err = (ssize_t)events.size();
-                } else {
-                    err = StatusFromResult(result);
-                }
-            });
-
-    return err;
-}
-
-void SensorDevice::autoDisable(void *ident, int handle) {
-    Info& info( mActivationCount.editValueFor(handle) );
-    Mutex::Autolock _l(mLock);
-    info.removeBatchParamsForIdent(ident);
-}
-
-status_t SensorDevice::activate(void* ident, int handle, int enabled) {
-    if (mSensors == NULL) return NO_INIT;
-
-    status_t err(NO_ERROR);
-    bool actuateHardware = false;
-
-    Mutex::Autolock _l(mLock);
-    Info& info( mActivationCount.editValueFor(handle) );
-
-    ALOGD_IF(DEBUG_CONNECTIONS,
-             "SensorDevice::activate: ident=%p, handle=0x%08x, enabled=%d, count=%zu",
-             ident, handle, enabled, info.batchParams.size());
-
-    if (enabled) {
-        ALOGD_IF(DEBUG_CONNECTIONS, "enable index=%zd", info.batchParams.indexOfKey(ident));
-
-        if (isClientDisabledLocked(ident)) {
-            ALOGE("SensorDevice::activate, isClientDisabledLocked(%p):true, handle:%d",
-                    ident, handle);
-            return INVALID_OPERATION;
-        }
-
-        if (info.batchParams.indexOfKey(ident) >= 0) {
-          if (info.numActiveClients() == 1) {
-              // This is the first connection, we need to activate the underlying h/w sensor.
-              actuateHardware = true;
-          }
-        } else {
-            // Log error. Every activate call should be preceded by a batch() call.
-            ALOGE("\t >>>ERROR: activate called without batch");
-        }
-    } else {
-        ALOGD_IF(DEBUG_CONNECTIONS, "disable index=%zd", info.batchParams.indexOfKey(ident));
-
-        // If a connected dynamic sensor is deactivated, remove it from the
-        // dictionary.
-        auto it = mConnectedDynamicSensors.find(handle);
-        if (it != mConnectedDynamicSensors.end()) {
-            delete it->second;
-            mConnectedDynamicSensors.erase(it);
-        }
-
-        if (info.removeBatchParamsForIdent(ident) >= 0) {
-            if (info.numActiveClients() == 0) {
-                // This is the last connection, we need to de-activate the underlying h/w sensor.
-                actuateHardware = true;
-            } else {
-                // Call batch for this sensor with the previously calculated best effort
-                // batch_rate and timeout. One of the apps has unregistered for sensor
-                // events, and the best effort batch parameters might have changed.
-                ALOGD_IF(DEBUG_CONNECTIONS,
-                         "\t>>> actuating h/w batch %d %d %" PRId64 " %" PRId64, handle,
-                         info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
-                         info.bestBatchParams.batchTimeout);
-                mSensors->batch(
-                        handle,
-                        info.bestBatchParams.batchDelay,
-                        info.bestBatchParams.batchTimeout);
-            }
-        } else {
-            // sensor wasn't enabled for this ident
-        }
-
-        if (isClientDisabledLocked(ident)) {
-            return NO_ERROR;
-        }
-    }
-
-    if (actuateHardware) {
-        ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle,
-                 enabled);
-        err = StatusFromResult(mSensors->activate(handle, enabled));
-        ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,
-                 strerror(-err));
-
-        if (err != NO_ERROR && enabled) {
-            // Failure when enabling the sensor. Clean up on failure.
-            info.removeBatchParamsForIdent(ident);
-        }
-    }
-
-    return err;
-}
-
-status_t SensorDevice::batch(
-        void* ident,
-        int handle,
-        int flags,
-        int64_t samplingPeriodNs,
-        int64_t maxBatchReportLatencyNs) {
-    if (mSensors == NULL) return NO_INIT;
-
-    if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
-        samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
-    }
-
-    ALOGD_IF(DEBUG_CONNECTIONS,
-             "SensorDevice::batch: ident=%p, handle=0x%08x, flags=%d, period_ns=%" PRId64 " timeout=%" PRId64,
-             ident, handle, flags, samplingPeriodNs, maxBatchReportLatencyNs);
-
-    Mutex::Autolock _l(mLock);
-    Info& info(mActivationCount.editValueFor(handle));
-
-    if (info.batchParams.indexOfKey(ident) < 0) {
-        BatchParams params(flags, samplingPeriodNs, maxBatchReportLatencyNs);
-        info.batchParams.add(ident, params);
-    } else {
-        // A batch has already been called with this ident. Update the batch parameters.
-        info.setBatchParamsForIdent(ident, flags, samplingPeriodNs, maxBatchReportLatencyNs);
-    }
-
-    BatchParams prevBestBatchParams = info.bestBatchParams;
-    // Find the minimum of all timeouts and batch_rates for this sensor.
-    info.selectBatchParams();
-
-    ALOGD_IF(DEBUG_CONNECTIONS,
-             "\t>>> curr_period=%" PRId64 " min_period=%" PRId64
-             " curr_timeout=%" PRId64 " min_timeout=%" PRId64,
-             prevBestBatchParams.batchDelay, info.bestBatchParams.batchDelay,
-             prevBestBatchParams.batchTimeout, info.bestBatchParams.batchTimeout);
-
-    status_t err(NO_ERROR);
-    // If the min period or min timeout has changed since the last batch call, call batch.
-    if (prevBestBatchParams != info.bestBatchParams) {
-        ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH %d %d %" PRId64 " %" PRId64, handle,
-                 info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
-                 info.bestBatchParams.batchTimeout);
-        err = StatusFromResult(
-                mSensors->batch(
-                    handle,
-                    info.bestBatchParams.batchDelay,
-                    info.bestBatchParams.batchTimeout));
-        if (err != NO_ERROR) {
-            ALOGE("sensor batch failed %p %d %d %" PRId64 " %" PRId64 " err=%s",
-                  mSensors.get(), handle,
-                  info.bestBatchParams.flags, info.bestBatchParams.batchDelay,
-                  info.bestBatchParams.batchTimeout, strerror(-err));
-            info.removeBatchParamsForIdent(ident);
-        }
-    }
-    return err;
-}
-
-status_t SensorDevice::setDelay(void* ident, int handle, int64_t samplingPeriodNs) {
-    if (mSensors == NULL) return NO_INIT;
-    if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
-        samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
-    }
-    Mutex::Autolock _l(mLock);
-    if (isClientDisabledLocked(ident)) return INVALID_OPERATION;
-    Info& info( mActivationCount.editValueFor(handle) );
-    // If the underlying sensor is NOT in continuous mode, setDelay() should return an error.
-    // Calling setDelay() in batch mode is an invalid operation.
-    if (info.bestBatchParams.batchTimeout != 0) {
-      return INVALID_OPERATION;
-    }
-    ssize_t index = info.batchParams.indexOfKey(ident);
-    if (index < 0) {
-        return BAD_INDEX;
-    }
-    BatchParams& params = info.batchParams.editValueAt(index);
-    params.batchDelay = samplingPeriodNs;
-    info.selectBatchParams();
-
-    return StatusFromResult(
-            mSensors->batch(handle, info.bestBatchParams.batchDelay, 0));
-}
-
-int SensorDevice::getHalDeviceVersion() const {
-    if (mSensors == NULL) return -1;
-    return SENSORS_DEVICE_API_VERSION_1_4;
-}
-
-status_t SensorDevice::flush(void* ident, int handle) {
-    if (isClientDisabled(ident)) return INVALID_OPERATION;
-    ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
-    return StatusFromResult(mSensors->flush(handle));
-}
-
-bool SensorDevice::isClientDisabled(void* ident) {
-    Mutex::Autolock _l(mLock);
-    return isClientDisabledLocked(ident);
-}
-
-bool SensorDevice::isClientDisabledLocked(void* ident) {
-    return mDisabledClients.indexOf(ident) >= 0;
-}
-
-void SensorDevice::enableAllSensors() {
-    Mutex::Autolock _l(mLock);
-    mDisabledClients.clear();
-    ALOGI("cleared mDisabledClients");
-    for (size_t i = 0; i< mActivationCount.size(); ++i) {
-        Info& info = mActivationCount.editValueAt(i);
-        if (info.batchParams.isEmpty()) continue;
-        info.selectBatchParams();
-        const int sensor_handle = mActivationCount.keyAt(i);
-        ALOGD_IF(DEBUG_CONNECTIONS, "\t>> reenable actuating h/w sensor enable handle=%d ",
-                   sensor_handle);
-        status_t err = StatusFromResult(
-                mSensors->batch(
-                    sensor_handle,
-                    info.bestBatchParams.batchDelay,
-                    info.bestBatchParams.batchTimeout));
-        ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));
-
-        if (err == NO_ERROR) {
-            err = StatusFromResult(
-                    mSensors->activate(sensor_handle, 1 /* enabled */));
-            ALOGE_IF(err, "Error activating sensor %d (%s)", sensor_handle, strerror(-err));
-        }
-    }
-}
-
-void SensorDevice::disableAllSensors() {
-    Mutex::Autolock _l(mLock);
-   for (size_t i = 0; i< mActivationCount.size(); ++i) {
-        const Info& info = mActivationCount.valueAt(i);
-        // Check if this sensor has been activated previously and disable it.
-        if (info.batchParams.size() > 0) {
-           const int sensor_handle = mActivationCount.keyAt(i);
-           ALOGD_IF(DEBUG_CONNECTIONS, "\t>> actuating h/w sensor disable handle=%d ",
-                   sensor_handle);
-           mSensors->activate(sensor_handle, 0 /* enabled */);
-
-           // Add all the connections that were registered for this sensor to the disabled
-           // clients list.
-           for (size_t j = 0; j < info.batchParams.size(); ++j) {
-               mDisabledClients.add(info.batchParams.keyAt(j));
-               ALOGI("added %p to mDisabledClients", info.batchParams.keyAt(j));
-           }
-        }
-    }
-}
-
-status_t SensorDevice::injectSensorData(
-        const sensors_event_t *injected_sensor_event) {
-    ALOGD_IF(DEBUG_CONNECTIONS,
-            "sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
-            injected_sensor_event->sensor,
-            injected_sensor_event->timestamp, injected_sensor_event->data[0],
-            injected_sensor_event->data[1], injected_sensor_event->data[2],
-            injected_sensor_event->data[3], injected_sensor_event->data[4],
-            injected_sensor_event->data[5]);
-
-    Event ev;
-    convertFromSensorEvent(*injected_sensor_event, &ev);
-
-    return StatusFromResult(mSensors->injectSensorData(ev));
-}
-
-status_t SensorDevice::setMode(uint32_t mode) {
-
-     return StatusFromResult(
-             mSensors->setOperationMode(
-                 static_cast<hardware::sensors::V1_0::OperationMode>(mode)));
-}
-
-// ---------------------------------------------------------------------------
-
-int SensorDevice::Info::numActiveClients() {
-    SensorDevice& device(SensorDevice::getInstance());
-    int num = 0;
-    for (size_t i = 0; i < batchParams.size(); ++i) {
-        if (!device.isClientDisabledLocked(batchParams.keyAt(i))) {
-            ++num;
-        }
-    }
-    return num;
-}
-
-status_t SensorDevice::Info::setBatchParamsForIdent(void* ident, int flags,
-                                                    int64_t samplingPeriodNs,
-                                                    int64_t maxBatchReportLatencyNs) {
-    ssize_t index = batchParams.indexOfKey(ident);
-    if (index < 0) {
-        ALOGE("Info::setBatchParamsForIdent(ident=%p, period_ns=%" PRId64 " timeout=%" PRId64 ") failed (%s)",
-              ident, samplingPeriodNs, maxBatchReportLatencyNs, strerror(-index));
-        return BAD_INDEX;
-    }
-    BatchParams& params = batchParams.editValueAt(index);
-    params.flags = flags;
-    params.batchDelay = samplingPeriodNs;
-    params.batchTimeout = maxBatchReportLatencyNs;
-    return NO_ERROR;
-}
-
-void SensorDevice::Info::selectBatchParams() {
-    BatchParams bestParams(0, -1, -1);
-    SensorDevice& device(SensorDevice::getInstance());
-
-    for (size_t i = 0; i < batchParams.size(); ++i) {
-        if (device.isClientDisabledLocked(batchParams.keyAt(i))) continue;
-        BatchParams params = batchParams.valueAt(i);
-        if (bestParams.batchDelay == -1 || params.batchDelay < bestParams.batchDelay) {
-            bestParams.batchDelay = params.batchDelay;
-        }
-        if (bestParams.batchTimeout == -1 || params.batchTimeout < bestParams.batchTimeout) {
-            bestParams.batchTimeout = params.batchTimeout;
-        }
-    }
-    bestBatchParams = bestParams;
-}
-
-ssize_t SensorDevice::Info::removeBatchParamsForIdent(void* ident) {
-    ssize_t idx = batchParams.removeItem(ident);
-    if (idx >= 0) {
-        selectBatchParams();
-    }
-    return idx;
-}
-
-void SensorDevice::notifyConnectionDestroyed(void* ident) {
-    Mutex::Autolock _l(mLock);
-    mDisabledClients.remove(ident);
-}
-
-int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {
-    Mutex::Autolock _l(mLock);
-
-    SharedMemType type;
-    switch (memory->type) {
-        case SENSOR_DIRECT_MEM_TYPE_ASHMEM:
-            type = SharedMemType::ASHMEM;
-            break;
-        case SENSOR_DIRECT_MEM_TYPE_GRALLOC:
-            type = SharedMemType::GRALLOC;
-            break;
-        default:
-            return BAD_VALUE;
-    }
-
-    SharedMemFormat format;
-    if (memory->format != SENSOR_DIRECT_FMT_SENSORS_EVENT) {
-        return BAD_VALUE;
-    }
-    format = SharedMemFormat::SENSORS_EVENT;
-
-    SharedMemInfo mem = {
-        .type = type,
-        .format = format,
-        .size = static_cast<uint32_t>(memory->size),
-        .memoryHandle = memory->handle,
-    };
-
-    int32_t ret;
-    mSensors->registerDirectChannel(mem,
-            [&ret](auto result, auto channelHandle) {
-                if (result == Result::OK) {
-                    ret = channelHandle;
-                } else {
-                    ret = StatusFromResult(result);
-                }
-            });
-    return ret;
-}
-
-void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {
-    Mutex::Autolock _l(mLock);
-    mSensors->unregisterDirectChannel(channelHandle);
-}
-
-int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle,
-        int32_t channelHandle, const struct sensors_direct_cfg_t *config) {
-    Mutex::Autolock _l(mLock);
-
-    RateLevel rate;
-    switch(config->rate_level) {
-        case SENSOR_DIRECT_RATE_STOP:
-            rate = RateLevel::STOP;
-            break;
-        case SENSOR_DIRECT_RATE_NORMAL:
-            rate = RateLevel::NORMAL;
-            break;
-        case SENSOR_DIRECT_RATE_FAST:
-            rate = RateLevel::FAST;
-            break;
-        case SENSOR_DIRECT_RATE_VERY_FAST:
-            rate = RateLevel::VERY_FAST;
-            break;
-        default:
-            return BAD_VALUE;
-    }
-
-    int32_t ret;
-    mSensors->configDirectReport(sensorHandle, channelHandle, rate,
-            [&ret, rate] (auto result, auto token) {
-                if (rate == RateLevel::STOP) {
-                    ret = StatusFromResult(result);
-                } else {
-                    if (result == Result::OK) {
-                        ret = token;
-                    } else {
-                        ret = StatusFromResult(result);
-                    }
-                }
-            });
-
-    return ret;
-}
-
-bool SensorDevice::isDirectReportSupported() const {
-    return mIsDirectReportSupported;
-}
-
-void SensorDevice::convertToSensorEvent(
-        const Event &src, sensors_event_t *dst) {
-    ::android::hardware::sensors::V1_0::implementation::convertToSensorEvent(
-            src, dst);
-
-    if (src.sensorType == SensorType::DYNAMIC_SENSOR_META) {
-        const DynamicSensorInfo &dyn = src.u.dynamic;
-
-        dst->dynamic_sensor_meta.connected = dyn.connected;
-        dst->dynamic_sensor_meta.handle = dyn.sensorHandle;
-        if (dyn.connected) {
-            auto it = mConnectedDynamicSensors.find(dyn.sensorHandle);
-            CHECK(it != mConnectedDynamicSensors.end());
-
-            dst->dynamic_sensor_meta.sensor = it->second;
-
-            memcpy(dst->dynamic_sensor_meta.uuid,
-                   dyn.uuid.data(),
-                   sizeof(dst->dynamic_sensor_meta.uuid));
-        }
-    }
-}
-
-void SensorDevice::convertToSensorEvents(
-        const hidl_vec<Event> &src,
-        const hidl_vec<SensorInfo> &dynamicSensorsAdded,
-        sensors_event_t *dst) {
-    // Allocate a sensor_t structure for each dynamic sensor added and insert
-    // it into the dictionary of connected dynamic sensors keyed by handle.
-    for (size_t i = 0; i < dynamicSensorsAdded.size(); ++i) {
-        const SensorInfo &info = dynamicSensorsAdded[i];
-
-        auto it = mConnectedDynamicSensors.find(info.sensorHandle);
-        CHECK(it == mConnectedDynamicSensors.end());
-
-        sensor_t *sensor = new sensor_t;
-        convertToSensor(info, sensor);
-
-        mConnectedDynamicSensors.insert(
-                std::make_pair(sensor->handle, sensor));
-    }
-
-    for (size_t i = 0; i < src.size(); ++i) {
-        convertToSensorEvent(src[i], &dst[i]);
-    }
-}
-
-// ---------------------------------------------------------------------------
-}; // namespace android
diff --git a/services/sensorservice/SensorServiceUtils.cpp b/services/sensorservice/SensorServiceUtils.cpp
index 1996a00..34cd8dd 100644
--- a/services/sensorservice/SensorServiceUtils.cpp
+++ b/services/sensorservice/SensorServiceUtils.cpp
@@ -54,6 +54,7 @@
         case SENSOR_TYPE_STATIONARY_DETECT:
         case SENSOR_TYPE_MOTION_DETECT:
         case SENSOR_TYPE_HEART_BEAT:
+        case SENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT:
             return 1;
 
         default:
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/DisplayHardware/HWC2On1Adapter.cpp b/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.cpp
index 2b603cc..a6171f5 100644
--- a/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWC2On1Adapter.cpp
@@ -2010,7 +2010,8 @@
     mZ(0),
     mReleaseFence(),
     mHwc1Id(0),
-    mHasUnsupportedPlaneAlpha(false) {}
+    mHasUnsupportedPlaneAlpha(false),
+    mHasUnsupportedBackgroundColor(false) {}
 
 bool HWC2On1Adapter::SortLayersByZ::operator()(
         const std::shared_ptr<Layer>& lhs, const std::shared_ptr<Layer>& rhs)
@@ -2466,7 +2467,7 @@
         }
     }
 
-    if (mHwc1DisplayMap.count(0) == 0) {
+    if (mHwc1DisplayMap.count(HWC_DISPLAY_PRIMARY) == 0) {
         ALOGE("prepareAllDisplays: Unable to find primary HWC1 display");
         return false;
     }
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.cpp b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
index 1c99036..4a281d4 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.cpp
@@ -60,9 +60,8 @@
 
 // ---------------------------------------------------------------------------
 
-HWComposer::HWComposer(const sp<SurfaceFlinger>& flinger, bool useVrComposer)
-    : mFlinger(flinger),
-      mAdapter(),
+HWComposer::HWComposer(bool useVrComposer)
+    : mAdapter(),
       mHwcDevice(),
       mDisplayData(2),
       mFreeDisplaySlots(),
@@ -211,7 +210,7 @@
 }
 
 void HWComposer::invalidate(const std::shared_ptr<HWC2::Display>& /*display*/) {
-    mFlinger->repaintEverything();
+    mEventHandler->onInvalidateReceived(this);
 }
 
 void HWComposer::vsync(const std::shared_ptr<HWC2::Display>& display,
@@ -257,7 +256,7 @@
     snprintf(tag, sizeof(tag), "HW_VSYNC_%1u", disp);
     ATRACE_INT(tag, ++mVSyncCounts[disp] & 1);
 
-    mEventHandler->onVSyncReceived(disp, timestamp);
+    mEventHandler->onVSyncReceived(this, disp, timestamp);
 }
 
 status_t HWComposer::allocateVirtualDisplay(uint32_t width, uint32_t height,
@@ -915,6 +914,10 @@
         const sp<GraphicBuffer>& buffer,
         uint32_t* outSlot, sp<GraphicBuffer>* outBuffer)
 {
+#ifdef BYPASS_IHWC
+    *outSlot = slot;
+    *outBuffer = buffer;
+#else
     if (slot == BufferQueue::INVALID_BUFFER_SLOT || slot < 0) {
         // default to slot 0
         slot = 0;
@@ -935,6 +938,7 @@
         // update cache
         mBuffers[slot] = buffer;
     }
+#endif
 }
 
 // ---------------------------------------------------------------------------
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer.h b/services/surfaceflinger/DisplayHardware/HWComposer.h
index 7b61e0e..0713709 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer.h
@@ -64,15 +64,16 @@
 class NativeHandle;
 class Region;
 class String8;
-class SurfaceFlinger;
 
 class HWComposer
 {
 public:
     class EventHandler {
         friend class HWComposer;
-        virtual void onVSyncReceived(int32_t disp, nsecs_t timestamp) = 0;
+        virtual void onVSyncReceived(
+            HWComposer* composer, int32_t disp, nsecs_t timestamp) = 0;
         virtual void onHotplugReceived(int32_t disp, bool connected) = 0;
+        virtual void onInvalidateReceived(HWComposer* composer) = 0;
     protected:
         virtual ~EventHandler() {}
     };
@@ -80,7 +81,7 @@
     // useVrComposer is passed to the composer HAL. When true, the composer HAL
     // will use the vr composer service, otherwise it uses the real hardware
     // composer.
-    HWComposer(const sp<SurfaceFlinger>& flinger, bool useVrComposer);
+    HWComposer(bool useVrComposer);
 
     ~HWComposer();
 
@@ -211,7 +212,6 @@
         HWC2::Vsync vsyncEnabled;
     };
 
-    sp<SurfaceFlinger>              mFlinger;
     std::unique_ptr<HWC2On1Adapter> mAdapter;
     std::unique_ptr<HWC2::Device>   mHwcDevice;
     std::vector<DisplayData>        mDisplayData;
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.cpp b/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.cpp
index e0946a7..bb815cc 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.cpp
+++ b/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.cpp
@@ -277,7 +277,7 @@
 }
 
 void HWComposer::invalidate() {
-    mFlinger->repaintEverything();
+    mEventHandler.onInvalidateReceived(this);
 }
 
 void HWComposer::vsync(int disp, int64_t timestamp) {
@@ -302,7 +302,7 @@
         snprintf(tag, sizeof(tag), "HW_VSYNC_%1u", disp);
         ATRACE_INT(tag, ++mVSyncCounts[disp] & 1);
 
-        mEventHandler.onVSyncReceived(disp, timestamp);
+        mEventHandler.onVSyncReceived(this, disp, timestamp);
     }
 }
 
@@ -1319,7 +1319,7 @@
     } while (err<0 && errno == EINTR);
 
     if (err == 0) {
-        mHwc.mEventHandler.onVSyncReceived(0, next_vsync);
+        mHwc.mEventHandler.onVSyncReceived(&mHwc, 0, next_vsync);
     }
 
     return true;
diff --git a/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.h b/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.h
index bca25ac..a94bc1e 100644
--- a/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.h
+++ b/services/surfaceflinger/DisplayHardware/HWComposer_hwc1.h
@@ -62,8 +62,10 @@
 public:
     class EventHandler {
         friend class HWComposer;
-        virtual void onVSyncReceived(int disp, nsecs_t timestamp) = 0;
+        virtual void onVSyncReceived(
+            HWComposer* composer, int32_t disp, nsecs_t timestamp) = 0;
         virtual void onHotplugReceived(int disp, bool connected) = 0;
+        virtual void onInvalidateReceived(HWComposer* composer) = 0;
     protected:
         virtual ~EventHandler() {}
     };
diff --git a/services/surfaceflinger/Layer.cpp b/services/surfaceflinger/Layer.cpp
index bb1fca6..0eef708 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() {
@@ -427,7 +431,9 @@
     Rect bounds = win;
     const auto& p = getParent();
     if (p != nullptr) {
-        bounds = p->computeScreenBounds();
+        // Look in computeScreenBounds recursive call for explanation of
+        // why we pass false here.
+        bounds = p->computeScreenBounds(false /* reduceTransparentRegion */);
     }
 
     Transform t = getTransform();
@@ -1881,10 +1887,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();
 
@@ -1897,7 +1903,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 8af0357..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;
 
 // ---------------------------------------------------------------------------
 
@@ -219,8 +209,8 @@
     mUseHwcVirtualDisplays = atoi(value);
     ALOGI_IF(!mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
 
-    property_get("ro.sf.disable_triple_buffer", value, "0");
-    mLayerTripleBufferingDisabled = !atoi(value);
+    property_get("ro.sf.disable_triple_buffer", value, "1");
+    mLayerTripleBufferingDisabled = atoi(value);
     ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
 }
 
@@ -579,7 +569,7 @@
     // the lock because on creation, it will call back into SurfaceFlinger to
     // initialize the primary display.
     LOG_ALWAYS_FATAL_IF(mEnterVrMode, "Starting in vr mode is not currently supported.");
-    mRealHwc = new HWComposer(this, false);
+    mRealHwc = new HWComposer(false);
     mHwc = mRealHwc;
     mHwc->setEventHandler(static_cast<HWComposer::EventHandler*>(this));
 
@@ -1102,7 +1092,14 @@
     }
 }
 
-void SurfaceFlinger::onVSyncReceived(int32_t type, nsecs_t timestamp) {
+void SurfaceFlinger::onVSyncReceived(HWComposer* composer, int32_t type,
+                                     nsecs_t timestamp) {
+    Mutex::Autolock lock(mStateLock);
+    // Ignore any vsyncs from the non-active hardware composer.
+    if (composer != mHwc) {
+        return;
+    }
+
     bool needsHwVsync = false;
 
     { // Scope for the lock
@@ -1119,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) {
@@ -1163,6 +1165,20 @@
     }
 }
 
+void SurfaceFlinger::onInvalidateReceived(HWComposer* composer) {
+    Mutex::Autolock lock(mStateLock);
+    if (composer == mHwc) {
+        repaintEverything();
+    } else {
+        // This isn't from our current hardware composer. If it's a callback
+        // from the real composer, forward the refresh request to vr
+        // flinger. Otherwise ignore it.
+        if (!composer->isUsingVrComposer()) {
+            mVrFlinger->OnHardwareComposerRefresh();
+        }
+    }
+}
+
 void SurfaceFlinger::setVsyncEnabled(int disp, int enabled) {
     ATRACE_CALL();
     getHwComposer().setVsyncEnabled(disp,
@@ -1209,7 +1225,7 @@
             }
 
             if (!mVrHwc) {
-                mVrHwc = new HWComposer(this, true);
+                mVrHwc = new HWComposer(true);
                 ALOGV("Vr HWC created");
             }
 
@@ -1240,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();
@@ -1293,7 +1311,7 @@
     setUpHWComposer();
     doDebugFlashRegions();
     doComposition();
-    postComposition();
+    postComposition(refreshStartTime);
 
     mPreviousPresentFence = mHwc->getPresentFence(HWC_DISPLAY_PRIMARY);
 
@@ -1368,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");
@@ -1403,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));
@@ -1450,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 {
@@ -2855,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 6dfdf08..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 {
 
@@ -247,8 +251,9 @@
     /* ------------------------------------------------------------------------
      * HWComposer::EventHandler interface
      */
-    virtual void onVSyncReceived(int type, nsecs_t timestamp);
+    virtual void onVSyncReceived(HWComposer* composer, int type, nsecs_t timestamp);
     virtual void onHotplugReceived(int disp, bool connected);
+    virtual void onInvalidateReceived(HWComposer* composer);
 
     /* ------------------------------------------------------------------------
      * Message handling
@@ -412,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();
@@ -433,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:
 
     /* ------------------------------------------------------------------------
@@ -580,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 faa68e8..477eb27 100644
--- a/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
+++ b/services/surfaceflinger/SurfaceFlinger_hwc1.cpp
@@ -192,8 +192,8 @@
     mUseHwcVirtualDisplays = atoi(value);
     ALOGI_IF(!mUseHwcVirtualDisplays, "Enabling HWC virtual displays");
 
-    property_get("ro.sf.disable_triple_buffer", value, "0");
-    mLayerTripleBufferingDisabled = !atoi(value);
+    property_get("ro.sf.disable_triple_buffer", value, "1");
+    mLayerTripleBufferingDisabled = atoi(value);
     ALOGI_IF(mLayerTripleBufferingDisabled, "Disabling Triple Buffering");
 }
 
@@ -1018,7 +1018,8 @@
     }
 }
 
-void SurfaceFlinger::onVSyncReceived(int type, nsecs_t timestamp) {
+void SurfaceFlinger::onVSyncReceived(HWComposer* /*composer*/, int type,
+                                     nsecs_t timestamp) {
     bool needsHwVsync = false;
 
     { // Scope for the lock
@@ -1035,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
@@ -1058,6 +1064,10 @@
     }
 }
 
+void SurfaceFlinger::onInvalidateReceived(HWComposer* /*composer*/) {
+    repaintEverything();
+}
+
 void SurfaceFlinger::eventControl(int disp, int event, int enabled) {
     ATRACE_CALL();
     getHwComposer().eventControl(disp, event, enabled);
@@ -1109,7 +1119,7 @@
     setUpHWComposer();
     doDebugFlashRegions();
     doComposition();
-    postComposition();
+    postComposition(refreshStartTime);
 }
 
 void SurfaceFlinger::doDebugFlashRegions()
@@ -1166,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());
@@ -1187,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/Android.mk b/services/vr/sensord/Android.mk
index 36d8400..e213bd6 100644
--- a/services/vr/sensord/Android.mk
+++ b/services/vr/sensord/Android.mk
@@ -46,21 +46,10 @@
 cFlags := -DLOG_TAG=\"sensord\" \
           -DTRACE=0
 
-ifeq ($(TARGET_USES_QCOM_BSP), true)
-ifneq ($(TARGET_QCOM_DISPLAY_VARIANT),)
-    platform := .
-else
-    platform := $(TARGET_BOARD_PLATFORM)
-endif
-    cFlags += -DQCOM_B_FAMILY \
-              -DQCOM_BSP
-endif
-
 include $(CLEAR_VARS)
 # Don't strip symbols so we see stack traces in logcat.
 LOCAL_STRIP_MODULE := false
 LOCAL_SRC_FILES := $(sourceFiles)
-PLATFORM := $(platform)
 LOCAL_CFLAGS := $(cFlags)
 LOCAL_STATIC_LIBRARIES := $(staticLibraries)
 LOCAL_SHARED_LIBRARIES := $(sharedLibraries)
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 47d9dcc..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,29 +83,10 @@
   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_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\"
@@ -129,27 +96,6 @@
 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
-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/api/vulkan.api b/vulkan/api/vulkan.api
index 5a67d36..eed44ad 100644
--- a/vulkan/api/vulkan.api
+++ b/vulkan/api/vulkan.api
@@ -153,6 +153,8 @@
 @extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_SPEC_VERSION 1
 @extension("VK_KHR_shared_presentable_image") define VK_KHR_SHARED_PRESENTABLE_IMAGE_EXTENSION_NAME "VK_KHR_shared_presentable_image"
 
+@extension("VK_EXT_HDR_METADATA_SPEC_VERSION") define VK_EXT_HDR_METADATA_SPEC_VERSION 1
+@extension("VK_EXT_HDR_METADATA_EXTENSION_NAME") define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
 
 
 /////////////
@@ -2908,14 +2910,20 @@
     platform.HWND                               hwnd
 }
 
+@internal class Gralloc1Usage {
+    u64                                         consumer
+    u64                                         producer
+}
+
 @extension("VK_ANDROID_native_buffer")
 class VkNativeBufferANDROID {
     VkStructureType                             sType
     const void*                                 pNext
     platform.buffer_handle_t                    handle
-    int                                         stride
-    int                                         format
-    int                                         usage
+    s32                                         stride
+    s32                                         format
+    s32                                         usage
+    Gralloc1Usage                               usage2
 }
 
 @extension("VK_ANDROID_native_buffer")
@@ -3297,6 +3305,24 @@
     VkShaderStageFlags                          stageFlags
 }
 
+@extension("VK_EXT_hdr_metadata")
+class VkXYColorEXT {
+    f32    x
+    f32    y
+}
+
+@extension("VK_EXT_hdr_metadata")
+class VkHdrMetadataEXT {
+    VkXYColorEXT    displayPrimaryRed
+    VkXYColorEXT    displayPrimaryGreen
+    VkXYColorEXT    displayPrimaryBlue
+    VkXYColorEXT    whitePoint
+    f32             maxLuminance
+    f32             minLuminance
+    f32             maxContentLightLevel
+    f32             maxFrameAverageLightLevel
+}
+
 
 
 ////////////////
@@ -5833,21 +5859,24 @@
 }
 
 @extension("VK_ANDROID_native_buffer")
+@optional
 cmd VkResult vkGetSwapchainGrallocUsageANDROID(
         VkDevice                                device,
         VkFormat                                format,
         VkImageUsageFlags                       imageUsage,
-        int*                                    grallocUsage) {
+        s32*                                    grallocUsage) {
     return ?
 }
 
 @extension("VK_ANDROID_native_buffer")
+@optional
 cmd VkResult vkGetSwapchainGrallocUsage2ANDROID(
         VkDevice                                device,
         VkFormat                                format,
         VkImageUsageFlags                       imageUsage,
         VkSwapchainImageUsageFlagsANDROID       swapchainImageUsage,
-        int*                                    grallocUsage) {
+        u64*                                    grallocConsumerUsage,
+        u64*                                    grallocProducerUsage) {
     return ?
 }
 
@@ -6138,6 +6167,14 @@
     return ?
 }
 
+@extension("VK_EXT_hdr_metadata")
+cmd void  vkSetHdrMetadataEXT(
+    VkDevice                                        device,
+    u32                                             swapchainCount,
+    const VkSwapchainKHR*                           pSwapchains,
+    const VkHdrMetadataEXT*                         pMetadata) {
+}
+
 
 ////////////////
 // Validation //
diff --git a/vulkan/doc/implementors_guide/implementors_guide.adoc b/vulkan/doc/implementors_guide/implementors_guide.adoc
index 009472a..24af950 100644
--- a/vulkan/doc/implementors_guide/implementors_guide.adoc
+++ b/vulkan/doc/implementors_guide/implementors_guide.adoc
@@ -47,19 +47,7 @@
 
 The +vk_wsi_swapchin+ and +vk_wsi_device_swapchain+ extensions are primarily be implemented by the platform and live in +libvulkan.so+. The +VkSwapchain+ object and all interaction with +ANativeWindow+ will be handled by the platform and not exposed to drivers. The WSI implementation will rely on a few private interfaces to the driver for this implementation. These will be loaded through the driver's +vkGetDeviceProcAddr+ functions, after passing through any enabled layers.
 
-Implementations may need swapchain buffers to be allocated with implementation-defined private gralloc usage flags. When creating a swapchain, the platform will ask the driver to translate the requested format and image usage flags into gralloc usage flags by calling
-[source,c]
-----
-VkResult VKAPI vkGetSwapchainGrallocUsageANDROID(
-    VkDevice            device,
-    VkFormat            format,
-    VkImageUsageFlags   imageUsage,
-    int*                grallocUsage
-);
-----
-The +format+ and +imageUsage+ parameters are taken from the +VkSwapchainCreateInfoKHR+ structure. The driver should fill +*grallocUsage+ with the gralloc usage flags it requires for that format and usage. These will be combined with the usage flags requested by the swapchain consumer when allocating buffers.
-
-Implementations may further need swapchain buffers to be allocated with implementation-defined private gralloc usage flags that depend not only on +format+ and +imageUsage+, but also on the intended usage of the swapchain. The additional usage bits are defined as
+Implementations may need swapchain buffers to be allocated with implementation-defined private gralloc usage flags that depend not only on +format+ and +imageUsage+, but also on the intended usage of the swapchain. The swapchain usage bits are defined as
 [source,c]
 ----
 typedef enum VkSwapchainImageUsageFlagBitsANDROID {
@@ -69,7 +57,7 @@
 typedef VkFlags VkSwapchainImageUsageFlagsANDROID;
 ----
 
-If the driver provides the +vkGetSwapchainGrallocUsage2ANDROID+ function, the platform will use it in preference to +vkGetSwapchainGrallocUsageANDROID+ when translating a requested format, image usage flags, and swapchain image usage flags into gralloc usage flags. +vkGetSwapchainGrallocUsage2ANDROID+ behaves in the same way as +vkGetSwapchainGrallocUsageANDROID+, and is declared as
+Implementations may need swapchain buffers to be allocated with implementation-defined private gralloc usage flags. When creating a swapchain, the platform will ask the driver to translate the requested format and image usage flags into gralloc usage flags by calling
 [source,c]
 ----
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsage2ANDROID(
@@ -77,6 +65,19 @@
     VkFormat            format,
     VkImageUsageFlags   imageUsage,
     VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
+    uint64_t*           grallocConsumerUsage,
+    uint64_t*           grallocProducerUsage,
+);
+----
+The +format+ and +imageUsage+ parameters are taken from the +VkSwapchainCreateInfoKHR+ structure. The driver should fill +*grallocConsumerUsage+ and +*grallocProducerUsage+ with the gralloc usage flags it requires for that format and usage. These will be combined with the usage flags requested by the swapchain consumer when allocating buffers.
+
+An older version of this function is deprecated but still supported for backwards compatibility; it will be used if +vkGetSwapchainGrallocUsage2ANDROID+ is not supported:
+[source,c]
+----
+VkResult VKAPI vkGetSwapchainGrallocUsageANDROID(
+    VkDevice            device,
+    VkFormat            format,
+    VkImageUsageFlags   imageUsage,
     int*                grallocUsage
 );
 ----
@@ -95,7 +96,11 @@
 
     // Gralloc format and usage requested when the buffer was allocated.
     int                         format;
-    int                         usage;
+    int                         usage; // deprecated
+    struct {
+        uint64_t                consumer;
+        uint64_t                producer;
+    } usage2;
 } VkNativeBufferANDROID;
 ----
 
@@ -200,3 +205,5 @@
    * Added VkSwapchainImageUsageFlagBitsANDROID
    * Added vkGetSwapchainGrallocUsage2ANDROID
    * Added VkSwapchainImageCreateInfoANDROID
+. *2017-02-09*
+   * Extended vkGetSwapchainGrallocUsage2ANDROID and VkNativeBufferANDROID to use gralloc1-style usage bitfields.
\ No newline at end of file
diff --git a/vulkan/doc/implementors_guide/implementors_guide.html b/vulkan/doc/implementors_guide/implementors_guide.html
index 4e74a78..9fecce5 100644
--- a/vulkan/doc/implementors_guide/implementors_guide.html
+++ b/vulkan/doc/implementors_guide/implementors_guide.html
@@ -730,7 +730,7 @@
 /*]]>*/
 </script>
 </head>
-<body class="article">
+<body class="book">
 <div id="header">
 <h1>Vulkan on Android Implementor&#8217;s Guide</h1>
 <span id="revnumber">version 5</span>
@@ -793,20 +793,7 @@
 <h2 id="_window_system_integration">2. Window System Integration</h2>
 <div class="sectionbody">
 <div class="paragraph"><p>The <span class="monospaced">vk_wsi_swapchin</span> and <span class="monospaced">vk_wsi_device_swapchain</span> extensions are primarily be implemented by the platform and live in <span class="monospaced">libvulkan.so</span>. The <span class="monospaced">VkSwapchain</span> object and all interaction with <span class="monospaced">ANativeWindow</span> will be handled by the platform and not exposed to drivers. The WSI implementation will rely on a few private interfaces to the driver for this implementation. These will be loaded through the driver&#8217;s <span class="monospaced">vkGetDeviceProcAddr</span> functions, after passing through any enabled layers.</p></div>
-<div class="paragraph"><p>Implementations may need swapchain buffers to be allocated with implementation-defined private gralloc usage flags. When creating a swapchain, the platform will ask the driver to translate the requested format and image usage flags into gralloc usage flags by calling</p></div>
-<div class="listingblock">
-<div class="content"><!-- Generator: GNU source-highlight 3.1.6
-by Lorenzo Bettini
-http://www.lorenzobettini.it
-http://www.gnu.org/software/src-highlite -->
-<pre><tt>VkResult <span style="color: #008080">VKAPI</span> <span style="font-weight: bold"><span style="color: #000000">vkGetSwapchainGrallocUsageANDROID</span></span><span style="color: #990000">(</span>
-    <span style="color: #008080">VkDevice</span>            device<span style="color: #990000">,</span>
-    <span style="color: #008080">VkFormat</span>            format<span style="color: #990000">,</span>
-    <span style="color: #008080">VkImageUsageFlags</span>   imageUsage<span style="color: #990000">,</span>
-    <span style="color: #009900">int</span><span style="color: #990000">*</span>                grallocUsage
-<span style="color: #990000">);</span></tt></pre></div></div>
-<div class="paragraph"><p>The <span class="monospaced">format</span> and <span class="monospaced">imageUsage</span> parameters are taken from the <span class="monospaced">VkSwapchainCreateInfoKHR</span> structure. The driver should fill <span class="monospaced">*grallocUsage</span> with the gralloc usage flags it requires for that format and usage. These will be combined with the usage flags requested by the swapchain consumer when allocating buffers.</p></div>
-<div class="paragraph"><p>Implementations may further need swapchain buffers to be allocated with implementation-defined private gralloc usage flags that depend not only on <span class="monospaced">format</span> and <span class="monospaced">imageUsage</span>, but also on the intended usage of the swapchain. The additional usage bits are defined as</p></div>
+<div class="paragraph"><p>Implementations may need swapchain buffers to be allocated with implementation-defined private gralloc usage flags that depend not only on <span class="monospaced">format</span> and <span class="monospaced">imageUsage</span>, but also on the intended usage of the swapchain. The swapchain usage bits are defined as</p></div>
 <div class="listingblock">
 <div class="content"><!-- Generator: GNU source-highlight 3.1.6
 by Lorenzo Bettini
@@ -817,7 +804,7 @@
     VK_SWAPCHAIN_IMAGE_USAGE_FLAG_BITS_MAX_ENUM <span style="color: #990000">=</span> <span style="color: #993399">0x7FFFFFFF</span>
 <span style="color: #FF0000">}</span> VkSwapchainImageUsageFlagBitsANDROID<span style="color: #990000">;</span>
 <span style="font-weight: bold"><span style="color: #0000FF">typedef</span></span> <span style="color: #008080">VkFlags</span> VkSwapchainImageUsageFlagsANDROID<span style="color: #990000">;</span></tt></pre></div></div>
-<div class="paragraph"><p>If the driver provides the <span class="monospaced">vkGetSwapchainGrallocUsage2ANDROID</span> function, the platform will use it in preference to <span class="monospaced">vkGetSwapchainGrallocUsageANDROID</span> when translating a requested format, image usage flags, and swapchain image usage flags into gralloc usage flags. <span class="monospaced">vkGetSwapchainGrallocUsage2ANDROID</span> behaves in the same way as <span class="monospaced">vkGetSwapchainGrallocUsageANDROID</span>, and is declared as</p></div>
+<div class="paragraph"><p>Implementations may need swapchain buffers to be allocated with implementation-defined private gralloc usage flags. When creating a swapchain, the platform will ask the driver to translate the requested format and image usage flags into gralloc usage flags by calling</p></div>
 <div class="listingblock">
 <div class="content"><!-- Generator: GNU source-highlight 3.1.6
 by Lorenzo Bettini
@@ -828,6 +815,20 @@
     <span style="color: #008080">VkFormat</span>            format<span style="color: #990000">,</span>
     <span style="color: #008080">VkImageUsageFlags</span>   imageUsage<span style="color: #990000">,</span>
     <span style="color: #008080">VkSwapchainImageUsageFlagsANDROID</span> swapchainImageUsage<span style="color: #990000">,</span>
+    uint64_t<span style="color: #990000">*</span>           grallocConsumerUsage<span style="color: #990000">,</span>
+    uint64_t<span style="color: #990000">*</span>           grallocProducerUsage<span style="color: #990000">,</span>
+<span style="color: #990000">);</span></tt></pre></div></div>
+<div class="paragraph"><p>The <span class="monospaced">format</span> and <span class="monospaced">imageUsage</span> parameters are taken from the <span class="monospaced">VkSwapchainCreateInfoKHR</span> structure. The driver should fill <span class="monospaced">*grallocConsumerUsage</span> and <span class="monospaced">*grallocProducerUsage</span> with the gralloc usage flags it requires for that format and usage. These will be combined with the usage flags requested by the swapchain consumer when allocating buffers.</p></div>
+<div class="paragraph"><p>An older version of this function is deprecated but still supported for backwards compatibility; it will be used if <span class="monospaced">vkGetSwapchainGrallocUsage2ANDROID</span> is not supported:</p></div>
+<div class="listingblock">
+<div class="content"><!-- Generator: GNU source-highlight 3.1.6
+by Lorenzo Bettini
+http://www.lorenzobettini.it
+http://www.gnu.org/software/src-highlite -->
+<pre><tt>VkResult <span style="color: #008080">VKAPI</span> <span style="font-weight: bold"><span style="color: #000000">vkGetSwapchainGrallocUsageANDROID</span></span><span style="color: #990000">(</span>
+    <span style="color: #008080">VkDevice</span>            device<span style="color: #990000">,</span>
+    <span style="color: #008080">VkFormat</span>            format<span style="color: #990000">,</span>
+    <span style="color: #008080">VkImageUsageFlags</span>   imageUsage<span style="color: #990000">,</span>
     <span style="color: #009900">int</span><span style="color: #990000">*</span>                grallocUsage
 <span style="color: #990000">);</span></tt></pre></div></div>
 <div class="paragraph"><p><span class="monospaced">VkNativeBufferANDROID</span> is a <span class="monospaced">vkCreateImage</span> extension structure for creating an image backed by a gralloc buffer. This structure is provided to <span class="monospaced">vkCreateImage</span> in the <span class="monospaced">VkImageCreateInfo</span> structure chain. Calls to <span class="monospaced">vkCreateImage</span> with this structure will happen during the first call to <span class="monospaced">vkGetSwapChainInfoWSI(.. VK_SWAP_CHAIN_INFO_TYPE_IMAGES_WSI ..)</span>. The WSI implementation will allocate the number of native buffers requested for the swapchain, then create a <span class="monospaced">VkImage</span> for each one.</p></div>
@@ -846,7 +847,11 @@
 
     <span style="font-style: italic"><span style="color: #9A1900">// Gralloc format and usage requested when the buffer was allocated.</span></span>
     <span style="color: #009900">int</span>                         format<span style="color: #990000">;</span>
-    <span style="color: #009900">int</span>                         usage<span style="color: #990000">;</span>
+    <span style="color: #009900">int</span>                         usage<span style="color: #990000">;</span> <span style="font-style: italic"><span style="color: #9A1900">// deprecated</span></span>
+    <span style="font-weight: bold"><span style="color: #0000FF">struct</span></span> <span style="color: #FF0000">{</span>
+        <span style="color: #008080">uint64_t</span>                consumer<span style="color: #990000">;</span>
+        <span style="color: #008080">uint64_t</span>                producer<span style="color: #990000">;</span>
+    <span style="color: #FF0000">}</span> usage2<span style="color: #990000">;</span>
 <span style="color: #FF0000">}</span> VkNativeBufferANDROID<span style="color: #990000">;</span></tt></pre></div></div>
 <div class="paragraph"><p>When creating a gralloc-backed image, the <span class="monospaced">VkImageCreateInfo</span> will have:</p></div>
 <div class="listingblock">
@@ -1044,6 +1049,18 @@
 </li>
 </ul></div>
 </li>
+<li>
+<p>
+<strong>2017-02-09</strong>
+</p>
+<div class="ulist"><ul>
+<li>
+<p>
+Extended vkGetSwapchainGrallocUsage2ANDROID and VkNativeBufferANDROID to use gralloc1-style usage bitfields.
+</p>
+</li>
+</ul></div>
+</li>
 </ol></div>
 </div>
 </div>
@@ -1052,7 +1069,7 @@
 <div id="footer">
 <div id="footer-text">
 Version 5<br>
-Last updated 2017-01-12 14:25:30 NZDT
+Last updated 2017-02-09 22:40:30 PST
 </div>
 </div>
 </body>
diff --git a/vulkan/include/vulkan/vk_android_native_buffer.h b/vulkan/include/vulkan/vk_android_native_buffer.h
index db23e79..d7c5a07 100644
--- a/vulkan/include/vulkan/vk_android_native_buffer.h
+++ b/vulkan/include/vulkan/vk_android_native_buffer.h
@@ -27,6 +27,16 @@
 #define VK_ANDROID_native_buffer 1
 
 #define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NUMBER 11
+/* NOTE ON VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION 6
+ *
+ * This version of the extension transitions from gralloc0 to gralloc1 usage
+ * flags (int -> 2x uint64_t). The WSI implementation will temporarily continue
+ * to fill out deprecated fields in VkNativeBufferANDROID, and will call the
+ * deprecated vkGetSwapchainGrallocUsageANDROID if the new
+ * vkGetSwapchainGrallocUsage2ANDROID is not supported. This transitionary
+ * backwards-compatibility support is temporary, and will likely be removed in
+ * (along with all gralloc0 support) in a future release.
+ */
 #define VK_ANDROID_NATIVE_BUFFER_SPEC_VERSION     6
 #define VK_ANDROID_NATIVE_BUFFER_EXTENSION_NAME   "VK_ANDROID_native_buffer"
 
@@ -50,7 +60,12 @@
 
     // Gralloc format and usage requested when the buffer was allocated.
     int                         format;
-    int                         usage;
+    int                         usage; // DEPRECATED in SPEC_VERSION 6
+    // -- Added in SPEC_VERSION 6 --
+    struct {
+        uint64_t                consumer;
+        uint64_t                producer;
+    } usage2;
 } VkNativeBufferANDROID;
 
 typedef struct {
@@ -60,24 +75,30 @@
     VkSwapchainImageUsageFlagsANDROID      usage;
 } VkSwapchainImageCreateInfoANDROID;
 
+// -- DEPRECATED in SPEC_VERSION 6 --
 typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsageANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
-typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsage2ANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, int* grallocUsage);
+// -- ADDED in SPEC_VERSION 6 --
+typedef VkResult (VKAPI_PTR *PFN_vkGetSwapchainGrallocUsage2ANDROID)(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage);
 typedef VkResult (VKAPI_PTR *PFN_vkAcquireImageANDROID)(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
 typedef VkResult (VKAPI_PTR *PFN_vkQueueSignalReleaseImageANDROID)(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);
 
 #ifndef VK_NO_PROTOTYPES
+
+// -- DEPRECATED in SPEC_VERSION 6 --
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsageANDROID(
     VkDevice            device,
     VkFormat            format,
     VkImageUsageFlags   imageUsage,
     int*                grallocUsage
 );
+// -- ADDED in SPEC_VERSION 6 --
 VKAPI_ATTR VkResult VKAPI_CALL vkGetSwapchainGrallocUsage2ANDROID(
     VkDevice            device,
     VkFormat            format,
     VkImageUsageFlags   imageUsage,
     VkSwapchainImageUsageFlagsANDROID swapchainImageUsage,
-    int*                grallocUsage
+    uint64_t*           grallocConsumerUsage,
+    uint64_t*           grallocProducerUsage
 );
 VKAPI_ATTR VkResult VKAPI_CALL vkAcquireImageANDROID(
     VkDevice            device,
@@ -93,17 +114,6 @@
     VkImage             image,
     int*                pNativeFenceFd
 );
-// -- DEPRECATED --
-VKAPI_ATTR VkResult VKAPI_CALL vkImportNativeFenceANDROID(
-    VkDevice            device,
-    VkSemaphore         semaphore,
-    int                 nativeFenceFd
-);
-VKAPI_ATTR VkResult VKAPI_CALL vkQueueSignalNativeFenceANDROID(
-    VkQueue             queue,
-    int*                pNativeFenceFd
-);
-// ----------------
 #endif
 
 #ifdef __cplusplus
diff --git a/vulkan/include/vulkan/vulkan.h b/vulkan/include/vulkan/vulkan.h
index 8d24aa7..16f43e5 100644
--- a/vulkan/include/vulkan/vulkan.h
+++ b/vulkan/include/vulkan/vulkan.h
@@ -6,7 +6,7 @@
 #endif
 
 /*
-** Copyright (c) 2015-2016 The Khronos Group Inc.
+** Copyright (c) 2015-2017 The Khronos Group Inc.
 **
 ** Licensed under the Apache License, Version 2.0 (the "License");
 ** you may not use this file except in compliance with the License.
@@ -4608,6 +4608,39 @@
     VkDeviceGeneratedCommandsLimitsNVX*         pLimits);
 #endif
 
+#define VK_EXT_hdr_metadata 1
+#define VK_EXT_HDR_METADATA_SPEC_VERSION  0
+#define VK_EXT_HDR_METADATA_EXTENSION_NAME "VK_EXT_hdr_metadata"
+
+typedef struct VkXYColorEXT {
+    float    x;
+    float    y;
+} VkXYColorEXT;
+
+typedef struct VkHdrMetadataEXT {
+    VkStructureType    sType;
+    const void*        pNext;
+    VkXYColorEXT       displayPrimaryRed;
+    VkXYColorEXT       displayPrimaryGreen;
+    VkXYColorEXT       displayPrimaryBlue;
+    VkXYColorEXT       whitePoint;
+    float              maxLuminance;
+    float              minLuminance;
+    float              maxContentLightLevel;
+    float              maxFrameAverageLightLevel;
+} VkHdrMetadataEXT;
+
+
+typedef void (VKAPI_PTR *PFN_vkSetHdrMetadataEXT)(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata);
+
+#ifndef VK_NO_PROTOTYPES
+VKAPI_ATTR void VKAPI_CALL vkSetHdrMetadataEXT(
+    VkDevice                                    device,
+    uint32_t                                    swapchainCount,
+    const VkSwapchainKHR*                       pSwapchains,
+    const VkHdrMetadataEXT*                     pMetadata);
+#endif
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/vulkan/libvulkan/code-generator.tmpl b/vulkan/libvulkan/code-generator.tmpl
index 501877c..caf38bc 100644
--- a/vulkan/libvulkan/code-generator.tmpl
+++ b/vulkan/libvulkan/code-generator.tmpl
@@ -413,13 +413,14 @@
   {{AssertType $ "Function"}}
 
   {{$ext := GetAnnotation $ "extension"}}
-  {{$required := (Macro "IsRequiredFunction" $)}}
   {{if $ext}}
-    INIT_PROC_EXT({{Macro "BaseName" $ext}}, {{$required}}, §
+    INIT_PROC_EXT({{Macro "BaseName" $ext}}, §
   {{else}}
-    INIT_PROC({{$required}}, §
+    INIT_PROC(§
   {{end}}
 
+  {{if GetAnnotation $ "optional"}}false{{else}}true{{end}}, §
+
   {{if (Macro "IsInstanceDispatched" $)}}
     instance, §
   {{else}}
@@ -432,25 +433,6 @@
 
 {{/*
 ------------------------------------------------------------------------------
-  Emits true if a function /must/ be resolved. The only time this is not
-  the case is for extension-added functions added in a later revision of the
-  extension, and where we have to cope with drivers written against an older
-  revision.
-------------------------------------------------------------------------------
-*/}}
-{{define "IsRequiredFunction"}}
-  {{AssertType $ "Function"}}
-
-  {{if eq $.Name "vkGetSwapchainGrallocUsage2ANDROID"}}
-    false
-  {{else}}
-    true
-  {{end}}
-{{end}}
-
-
-{{/*
-------------------------------------------------------------------------------
   Emits true if a function is exported and instance-dispatched.
 ------------------------------------------------------------------------------
 */}}
@@ -700,11 +682,12 @@
 {{define "driver.InterceptedExtensions"}}
 VK_ANDROID_native_buffer
 VK_EXT_debug_report
+VK_EXT_hdr_metadata
+VK_GOOGLE_display_timing
 VK_KHR_android_surface
 VK_KHR_incremental_present
 VK_KHR_surface
 VK_KHR_swapchain
-VK_GOOGLE_display_timing
 VK_KHR_shared_presentable_image
 {{end}}
 
@@ -981,6 +964,8 @@
     {{else if eq $.Name "vkCreateImage"}}true
     {{else if eq $.Name "vkDestroyImage"}}true
 
+    {{else if eq $.Name "vkGetPhysicalDeviceProperties"}}true
+
     {{end}}
 
     {{$ext := GetAnnotation $ "extension"}}
@@ -1143,8 +1128,9 @@
 
 {{/*
 ------------------------------------------------------------------------------
-  Reports whether an extension is implemented entirely by the loader,
-  so drivers should not enumerate it.
+  Reports whether an extension has functions exported by the loader.
+  E.g. applications can directly link to an extension function.
+  Currently only support WSI extensions this way.
 ------------------------------------------------------------------------------
 */}}
 {{define "IsExtensionExported"}}
diff --git a/vulkan/libvulkan/driver.cpp b/vulkan/libvulkan/driver.cpp
index 991c3ed..71bfecf 100644
--- a/vulkan/libvulkan/driver.cpp
+++ b/vulkan/libvulkan/driver.cpp
@@ -472,6 +472,9 @@
                 hook_extensions_.set(ext_bit);
                 // return now as these extensions do not require HAL support
                 return;
+            case ProcHook::EXT_hdr_metadata:
+                hook_extensions_.set(ext_bit);
+                break;
             case ProcHook::EXTENSION_UNKNOWN:
                 // HAL's extensions
                 break;
@@ -737,12 +740,14 @@
     uint32_t* pPropertyCount,
     VkExtensionProperties* pProperties) {
     const InstanceData& data = GetData(physicalDevice);
-    static const std::array<VkExtensionProperties, 2> loader_extensions = {{
+    static const std::array<VkExtensionProperties, 3> loader_extensions = {{
         // WSI extensions
         {VK_KHR_INCREMENTAL_PRESENT_EXTENSION_NAME,
          VK_KHR_INCREMENTAL_PRESENT_SPEC_VERSION},
         {VK_GOOGLE_DISPLAY_TIMING_EXTENSION_NAME,
          VK_GOOGLE_DISPLAY_TIMING_SPEC_VERSION},
+        {VK_EXT_HDR_METADATA_EXTENSION_NAME,
+         VK_EXT_HDR_METADATA_SPEC_VERSION},
     }};
 
     // enumerate our extensions first
@@ -899,7 +904,29 @@
 
         return VK_ERROR_INCOMPATIBLE_DRIVER;
     }
+
+    // sanity check ANDROID_native_buffer implementation, whose set of
+    // entrypoints varies according to the spec version.
+    if ((wrapper.GetHalExtensions()[ProcHook::ANDROID_native_buffer]) &&
+        !data->driver.GetSwapchainGrallocUsageANDROID &&
+        !data->driver.GetSwapchainGrallocUsage2ANDROID) {
+        ALOGE("Driver's implementation of ANDROID_native_buffer is broken;"
+              " must expose at least one of "
+              "vkGetSwapchainGrallocUsageANDROID or "
+              "vkGetSwapchainGrallocUsage2ANDROID");
+
+        data->driver.DestroyDevice(dev, pAllocator);
+        FreeDeviceData(data, data_allocator);
+
+        return VK_ERROR_INCOMPATIBLE_DRIVER;
+    }
+
+    VkPhysicalDeviceProperties properties;
+    instance_data.driver.GetPhysicalDeviceProperties(physicalDevice,
+                                                     &properties);
+
     data->driver_device = dev;
+    data->driver_version = properties.driverVersion;
 
     *pDevice = dev;
 
diff --git a/vulkan/libvulkan/driver.h b/vulkan/libvulkan/driver.h
index e058439..5383f59 100644
--- a/vulkan/libvulkan/driver.h
+++ b/vulkan/libvulkan/driver.h
@@ -102,6 +102,7 @@
 
     VkDevice driver_device;
     DeviceDriverTable driver;
+    uint32_t driver_version;
 };
 
 bool Debuggable();
diff --git a/vulkan/libvulkan/driver_gen.cpp b/vulkan/libvulkan/driver_gen.cpp
index 689a228..59964fb 100644
--- a/vulkan/libvulkan/driver_gen.cpp
+++ b/vulkan/libvulkan/driver_gen.cpp
@@ -102,6 +102,14 @@
     }
 }
 
+VKAPI_ATTR void checkedSetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pMetadata) {
+    if (GetData(device).hook_extensions[ProcHook::EXT_hdr_metadata]) {
+        SetHdrMetadataEXT(device, swapchainCount, pSwapchains, pMetadata);
+    } else {
+        Logger(device).Err(device, "VK_EXT_hdr_metadata not enabled. vkSetHdrMetadataEXT not executed.");
+    }
+}
+
 // clang-format on
 
 const ProcHook g_proc_hooks[] = {
@@ -330,6 +338,13 @@
         nullptr,
         nullptr,
     },
+    {
+        "vkSetHdrMetadataEXT",
+        ProcHook::DEVICE,
+        ProcHook::EXT_hdr_metadata,
+        reinterpret_cast<PFN_vkVoidFunction>(SetHdrMetadataEXT),
+        reinterpret_cast<PFN_vkVoidFunction>(checkedSetHdrMetadataEXT),
+    },
     // clang-format on
 };
 
@@ -349,11 +364,12 @@
     // clang-format off
     if (strcmp(name, "VK_ANDROID_native_buffer") == 0) return ProcHook::ANDROID_native_buffer;
     if (strcmp(name, "VK_EXT_debug_report") == 0) return ProcHook::EXT_debug_report;
+    if (strcmp(name, "VK_EXT_hdr_metadata") == 0) return ProcHook::EXT_hdr_metadata;
+    if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing;
     if (strcmp(name, "VK_KHR_android_surface") == 0) return ProcHook::KHR_android_surface;
     if (strcmp(name, "VK_KHR_incremental_present") == 0) return ProcHook::KHR_incremental_present;
     if (strcmp(name, "VK_KHR_surface") == 0) return ProcHook::KHR_surface;
     if (strcmp(name, "VK_KHR_swapchain") == 0) return ProcHook::KHR_swapchain;
-    if (strcmp(name, "VK_GOOGLE_display_timing") == 0) return ProcHook::GOOGLE_display_timing;
     if (strcmp(name, "VK_KHR_shared_presentable_image") == 0) return ProcHook::KHR_shared_presentable_image;
     // clang-format on
     return ProcHook::EXTENSION_UNKNOWN;
@@ -387,6 +403,7 @@
     INIT_PROC(true, instance, DestroyInstance);
     INIT_PROC(true, instance, EnumeratePhysicalDevices);
     INIT_PROC(true, instance, GetInstanceProcAddr);
+    INIT_PROC(true, instance, GetPhysicalDeviceProperties);
     INIT_PROC(true, instance, CreateDevice);
     INIT_PROC(true, instance, EnumerateDeviceExtensionProperties);
     INIT_PROC_EXT(EXT_debug_report, true, instance, CreateDebugReportCallbackEXT);
@@ -410,7 +427,7 @@
     INIT_PROC(true, dev, CreateImage);
     INIT_PROC(true, dev, DestroyImage);
     INIT_PROC(true, dev, AllocateCommandBuffers);
-    INIT_PROC_EXT(ANDROID_native_buffer, true, dev, GetSwapchainGrallocUsageANDROID);
+    INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsageANDROID);
     INIT_PROC_EXT(ANDROID_native_buffer, false, dev, GetSwapchainGrallocUsage2ANDROID);
     INIT_PROC_EXT(ANDROID_native_buffer, true, dev, AcquireImageANDROID);
     INIT_PROC_EXT(ANDROID_native_buffer, true, dev, QueueSignalReleaseImageANDROID);
diff --git a/vulkan/libvulkan/driver_gen.h b/vulkan/libvulkan/driver_gen.h
index 9f3b705..273e796 100644
--- a/vulkan/libvulkan/driver_gen.h
+++ b/vulkan/libvulkan/driver_gen.h
@@ -35,11 +35,12 @@
     enum Extension {
         ANDROID_native_buffer,
         EXT_debug_report,
+        EXT_hdr_metadata,
+        GOOGLE_display_timing,
         KHR_android_surface,
         KHR_incremental_present,
         KHR_surface,
         KHR_swapchain,
-        GOOGLE_display_timing,
         KHR_shared_presentable_image,
 
         EXTENSION_CORE,  // valid bit
@@ -60,6 +61,7 @@
     PFN_vkDestroyInstance DestroyInstance;
     PFN_vkEnumeratePhysicalDevices EnumeratePhysicalDevices;
     PFN_vkGetInstanceProcAddr GetInstanceProcAddr;
+    PFN_vkGetPhysicalDeviceProperties GetPhysicalDeviceProperties;
     PFN_vkCreateDevice CreateDevice;
     PFN_vkEnumerateDeviceExtensionProperties EnumerateDeviceExtensionProperties;
     PFN_vkCreateDebugReportCallbackEXT CreateDebugReportCallbackEXT;
diff --git a/vulkan/libvulkan/swapchain.cpp b/vulkan/libvulkan/swapchain.cpp
index f4ee375..b1e3d61 100644
--- a/vulkan/libvulkan/swapchain.cpp
+++ b/vulkan/libvulkan/swapchain.cpp
@@ -20,7 +20,7 @@
 #include <gui/BufferQueue.h>
 #include <sync/sync.h>
 #include <utils/StrongPointer.h>
-#include <utils/SortedVector.h>
+#include <utils/Vector.h>
 
 #include "driver.h"
 
@@ -108,19 +108,11 @@
 
 class TimingInfo {
    public:
-    TimingInfo()
-        : vals_{0, 0, 0, 0, 0},
-          timestamp_desired_present_time_(0),
-          timestamp_actual_present_time_(0),
-          timestamp_render_complete_time_(0),
-          timestamp_composition_latch_time_(0) {}
-    TimingInfo(const VkPresentTimeGOOGLE* qp)
+    TimingInfo() = default;
+    TimingInfo(const VkPresentTimeGOOGLE* qp, uint64_t nativeFrameId)
         : vals_{qp->presentID, qp->desiredPresentTime, 0, 0, 0},
-          timestamp_desired_present_time_(0),
-          timestamp_actual_present_time_(0),
-          timestamp_render_complete_time_(0),
-          timestamp_composition_latch_time_(0) {}
-    bool ready() {
+          native_frame_id_(nativeFrameId) {}
+    bool ready() const {
         return (timestamp_desired_present_time_ &&
                 timestamp_actual_present_time_ &&
                 timestamp_render_complete_time_ &&
@@ -148,27 +140,20 @@
         vals_.earliestPresentTime = early_time;
         vals_.presentMargin = margin;
     }
-    void get_values(VkPastPresentationTimingGOOGLE* values) { *values = vals_; }
+    void get_values(VkPastPresentationTimingGOOGLE* values) const {
+        *values = vals_;
+    }
 
    public:
-    VkPastPresentationTimingGOOGLE vals_;
+    VkPastPresentationTimingGOOGLE vals_ { 0, 0, 0, 0, 0 };
 
-    uint64_t timestamp_desired_present_time_;
-    uint64_t timestamp_actual_present_time_;
-    uint64_t timestamp_render_complete_time_;
-    uint64_t timestamp_composition_latch_time_;
+    uint64_t native_frame_id_ { 0 };
+    uint64_t timestamp_desired_present_time_ { 0 };
+    uint64_t timestamp_actual_present_time_ { 0 };
+    uint64_t timestamp_render_complete_time_ { 0 };
+    uint64_t timestamp_composition_latch_time_ { 0 };
 };
 
-static inline int compare_type(const TimingInfo& lhs, const TimingInfo& rhs) {
-    // TODO(ianelliott): Change this from presentID to the frame ID once
-    // brianderson lands the appropriate patch:
-    if (lhs.vals_.presentID < rhs.vals_.presentID)
-        return -1;
-    if (lhs.vals_.presentID > rhs.vals_.presentID)
-        return 1;
-    return 0;
-}
-
 // ----------------------------------------------------------------------------
 
 struct Surface {
@@ -191,11 +176,13 @@
 enum { MIN_NUM_FRAMES_AGO = 5 };
 
 struct Swapchain {
-    Swapchain(Surface& surface_, uint32_t num_images_)
+    Swapchain(Surface& surface_,
+              uint32_t num_images_,
+              VkPresentModeKHR present_mode)
         : surface(surface_),
           num_images(num_images_),
+          mailbox_mode(present_mode == VK_PRESENT_MODE_MAILBOX_KHR),
           frame_timestamps_enabled(false) {
-        timing.clear();
         ANativeWindow* window = surface.window.get();
         int64_t rdur;
         native_window_get_refresh_cycle_duration(
@@ -206,6 +193,7 @@
 
     Surface& surface;
     uint32_t num_images;
+    bool mailbox_mode;
     bool frame_timestamps_enabled;
     uint64_t refresh_duration;
 
@@ -221,7 +209,7 @@
         bool dequeued;
     } images[android::BufferQueue::NUM_BUFFER_SLOTS];
 
-    android::SortedVector<TimingInfo> timing;
+    android::Vector<TimingInfo> timing;
 };
 
 VkSwapchainKHR HandleFromSwapchain(Swapchain* swapchain) {
@@ -293,73 +281,64 @@
 }
 
 uint32_t get_num_ready_timings(Swapchain& swapchain) {
-    uint32_t num_ready = 0;
-    uint32_t num_timings = static_cast<uint32_t>(swapchain.timing.size());
-    uint32_t frames_ago = num_timings;
-    for (uint32_t i = 0; i < num_timings; i++) {
-        TimingInfo* ti = &swapchain.timing.editItemAt(i);
-        if (ti) {
-            if (ti->ready()) {
-                // This TimingInfo is ready to be reported to the user.  Add it
-                // to the num_ready.
-                num_ready++;
-            } else {
-                // This TimingInfo is not yet ready to be reported to the user,
-                // and so we should look for any available timestamps that
-                // might make it ready.
-                int64_t desired_present_time = 0;
-                int64_t render_complete_time = 0;
-                int64_t composition_latch_time = 0;
-                int64_t actual_present_time = 0;
-                for (uint32_t f = MIN_NUM_FRAMES_AGO; f < frames_ago; f++) {
-                    // Obtain timestamps:
-                    int ret = native_window_get_frame_timestamps(
-                        swapchain.surface.window.get(), f,
-                        &desired_present_time, &render_complete_time,
-                        &composition_latch_time,
-                        NULL,  //&first_composition_start_time,
-                        NULL,  //&last_composition_start_time,
-                        NULL,  //&composition_finish_time,
-                        // TODO(ianelliott): Maybe ask if this one is
-                        // supported, at startup time (since it may not be
-                        // supported):
-                        &actual_present_time,
-                        NULL,  //&display_retire_time,
-                        NULL,  //&dequeue_ready_time,
-                        NULL /*&reads_done_time*/);
-                    if (ret) {
-                        break;
-                    } else if (!ret) {
-                        // We obtained at least one valid timestamp.  See if it
-                        // is for the present represented by this TimingInfo:
-                        if (static_cast<uint64_t>(desired_present_time) ==
-                            ti->vals_.desiredPresentTime) {
-                            // Record the timestamp(s) we received, and then
-                            // see if this TimingInfo is ready to be reported
-                            // to the user:
-                            ti->timestamp_desired_present_time_ =
-                                static_cast<uint64_t>(desired_present_time);
-                            ti->timestamp_actual_present_time_ =
-                                static_cast<uint64_t>(actual_present_time);
-                            ti->timestamp_render_complete_time_ =
-                                static_cast<uint64_t>(render_complete_time);
-                            ti->timestamp_composition_latch_time_ =
-                                static_cast<uint64_t>(composition_latch_time);
+    if (swapchain.timing.size() < MIN_NUM_FRAMES_AGO) {
+        return 0;
+    }
 
-                            if (ti->ready()) {
-                                // The TimingInfo has received enough
-                                // timestamps, and should now use those
-                                // timestamps to calculate the info that should
-                                // be reported to the user:
-                                //
-                                ti->calculate(swapchain.refresh_duration);
-                                num_ready++;
-                            }
-                            break;
-                        }
-                    }
-                }
-            }
+    uint32_t num_ready = 0;
+    const size_t num_timings = swapchain.timing.size() - MIN_NUM_FRAMES_AGO + 1;
+    for (uint32_t i = 0; i < num_timings; i++) {
+        TimingInfo& ti = swapchain.timing.editItemAt(i);
+        if (ti.ready()) {
+            // This TimingInfo is ready to be reported to the user.  Add it
+            // to the num_ready.
+            num_ready++;
+            continue;
+        }
+        // This TimingInfo is not yet ready to be reported to the user,
+        // and so we should look for any available timestamps that
+        // might make it ready.
+        int64_t desired_present_time = 0;
+        int64_t render_complete_time = 0;
+        int64_t composition_latch_time = 0;
+        int64_t actual_present_time = 0;
+        // Obtain timestamps:
+        int ret = native_window_get_frame_timestamps(
+            swapchain.surface.window.get(), ti.native_frame_id_,
+            &desired_present_time, &render_complete_time,
+            &composition_latch_time,
+            NULL,  //&first_composition_start_time,
+            NULL,  //&last_composition_start_time,
+            NULL,  //&composition_finish_time,
+            // TODO(ianelliott): Maybe ask if this one is
+            // supported, at startup time (since it may not be
+            // supported):
+            &actual_present_time,
+            NULL,  //&display_retire_time,
+            NULL,  //&dequeue_ready_time,
+            NULL /*&reads_done_time*/);
+
+        if (ret != android::NO_ERROR) {
+            continue;
+        }
+
+        // Record the timestamp(s) we received, and then see if this TimingInfo
+        // is ready to be reported to the user:
+        ti.timestamp_desired_present_time_ =
+            static_cast<uint64_t>(desired_present_time);
+        ti.timestamp_actual_present_time_ =
+            static_cast<uint64_t>(actual_present_time);
+        ti.timestamp_render_complete_time_ =
+            static_cast<uint64_t>(render_complete_time);
+        ti.timestamp_composition_latch_time_ =
+               static_cast<uint64_t>(composition_latch_time);
+
+        if (ti.ready()) {
+            // The TimingInfo has received enough timestamps, and should now
+            // use those timestamps to calculate the info that should be
+            // reported to the user:
+            ti.calculate(swapchain.refresh_duration);
+            num_ready++;
         }
     }
     return num_ready;
@@ -369,29 +348,35 @@
 void copy_ready_timings(Swapchain& swapchain,
                         uint32_t* count,
                         VkPastPresentationTimingGOOGLE* timings) {
-    uint32_t num_copied = 0;
-    uint32_t num_timings = static_cast<uint32_t>(swapchain.timing.size());
-    if (*count < num_timings) {
-        num_timings = *count;
+    if (swapchain.timing.empty()) {
+        *count = 0;
+        return;
     }
-    for (uint32_t i = 0; i < num_timings; i++) {
-        TimingInfo* ti = &swapchain.timing.editItemAt(i);
-        if (ti && ti->ready()) {
-            ti->get_values(&timings[num_copied]);
-            num_copied++;
-            // We only report the values for a given present once, so remove
-            // them from swapchain.timing:
-            //
-            // TODO(ianelliott): SEE WHAT HAPPENS TO THE LOOP WHEN THE
-            // FOLLOWING IS DONE:
-            swapchain.timing.removeAt(i);
-            i--;
-            num_timings--;
-            if (*count == num_copied) {
-                break;
-            }
+
+    size_t last_ready = swapchain.timing.size() - 1;
+    while (!swapchain.timing[last_ready].ready()) {
+        if (last_ready == 0) {
+            *count = 0;
+            return;
         }
+        last_ready--;
     }
+
+    uint32_t num_copied = 0;
+    size_t num_to_remove = 0;
+    for (uint32_t i = 0; i <= last_ready && num_copied < *count; i++) {
+        const TimingInfo& ti = swapchain.timing[i];
+        if (ti.ready()) {
+            ti.get_values(&timings[num_copied]);
+            num_copied++;
+        }
+        num_to_remove++;
+    }
+
+    // Discard old frames that aren't ready if newer frames are ready.
+    // We don't expect to get the timing info for those old frames.
+    swapchain.timing.removeItemsAt(0, num_to_remove);
+
     *count = num_copied;
 }
 
@@ -812,13 +797,35 @@
 
     int gralloc_usage = 0;
     if (dispatch.GetSwapchainGrallocUsage2ANDROID) {
-        result = dispatch.GetSwapchainGrallocUsage2ANDROID(
-            device, create_info->imageFormat, create_info->imageUsage,
-            swapchain_image_usage, &gralloc_usage);
+        uint64_t consumer_usage, producer_usage;
+        if (GetData(device).driver_version == 256587285) {
+            // HACK workaround for loader/driver mismatch during transition to
+            // vkGetSwapchainGrallocUsage2ANDROID.
+            typedef VkResult(VKAPI_PTR *
+                             PFN_vkGetSwapchainGrallocUsage2ANDROID_HACK)(
+                VkDevice device, VkFormat format, VkImageUsageFlags imageUsage,
+                uint64_t * grallocConsumerUsage,
+                uint64_t * grallocProducerUsage);
+            auto get_swapchain_gralloc_usage =
+                reinterpret_cast<PFN_vkGetSwapchainGrallocUsage2ANDROID_HACK>(
+                    dispatch.GetSwapchainGrallocUsage2ANDROID);
+            result = get_swapchain_gralloc_usage(
+                device, create_info->imageFormat, create_info->imageUsage,
+                &consumer_usage, &producer_usage);
+        } else {
+            result = dispatch.GetSwapchainGrallocUsage2ANDROID(
+                device, create_info->imageFormat, create_info->imageUsage,
+                swapchain_image_usage, &consumer_usage, &producer_usage);
+        }
         if (result != VK_SUCCESS) {
             ALOGE("vkGetSwapchainGrallocUsage2ANDROID failed: %d", result);
             return VK_ERROR_INITIALIZATION_FAILED;
         }
+        // TODO: This is the same translation done by Gralloc1On0Adapter.
+        // Remove it once ANativeWindow has been updated to take gralloc1-style
+        // usages.
+        gralloc_usage =
+            static_cast<int>(consumer_usage) | static_cast<int>(producer_usage);
     } else if (dispatch.GetSwapchainGrallocUsageANDROID) {
         result = dispatch.GetSwapchainGrallocUsageANDROID(
             device, create_info->imageFormat, create_info->imageUsage,
@@ -827,8 +834,6 @@
             ALOGE("vkGetSwapchainGrallocUsageANDROID failed: %d", result);
             return VK_ERROR_INITIALIZATION_FAILED;
         }
-    } else {
-        gralloc_usage = GRALLOC_USAGE_HW_RENDER | GRALLOC_USAGE_HW_TEXTURE;
     }
     err = native_window_set_usage(surface.window.get(), gralloc_usage);
     if (err != 0) {
@@ -857,7 +862,8 @@
                                          VK_SYSTEM_ALLOCATION_SCOPE_OBJECT);
     if (!mem)
         return VK_ERROR_OUT_OF_HOST_MEMORY;
-    Swapchain* swapchain = new (mem) Swapchain(surface, num_images);
+    Swapchain* swapchain =
+        new (mem) Swapchain(surface, num_images, create_info->presentMode);
 
     // -- Dequeue all buffers and create a VkImage for each --
     // Any failures during or after this must cancel the dequeued buffers.
@@ -918,6 +924,12 @@
         image_native_buffer.stride = img.buffer->stride;
         image_native_buffer.format = img.buffer->format;
         image_native_buffer.usage = img.buffer->usage;
+        // TODO: Adjust once ANativeWindowBuffer supports gralloc1-style usage.
+        // For now, this is the same translation Gralloc1On0Adapter does.
+        image_native_buffer.usage2.consumer =
+            static_cast<uint64_t>(img.buffer->usage);
+        image_native_buffer.usage2.producer =
+            static_cast<uint64_t>(img.buffer->usage);
 
         result =
             dispatch.CreateImage(device, &image_create, nullptr, &img.image);
@@ -1153,7 +1165,8 @@
             *SwapchainFromHandle(present_info->pSwapchains[sc]);
         uint32_t image_idx = present_info->pImageIndices[sc];
         Swapchain::Image& img = swapchain.images[image_idx];
-        const VkPresentRegionKHR* region = (regions) ? &regions[sc] : nullptr;
+        const VkPresentRegionKHR* region =
+            (regions && !swapchain.mailbox_mode) ? &regions[sc] : nullptr;
         const VkPresentTimeGOOGLE* time = (times) ? &times[sc] : nullptr;
         VkResult swapchain_result = VK_SUCCESS;
         VkResult result;
@@ -1219,13 +1232,20 @@
                         native_window_enable_frame_timestamps(window, true);
                         swapchain.frame_timestamps_enabled = true;
                     }
-                    // Record this presentID and desiredPresentTime so it can
-                    // be later correlated to this present.
-                    TimingInfo timing_record(time);
-                    swapchain.timing.add(timing_record);
-                    uint32_t num_timings =
-                        static_cast<uint32_t>(swapchain.timing.size());
-                    if (num_timings > MAX_TIMING_INFOS) {
+
+                    // Record the nativeFrameId so it can be later correlated to
+                    // this present.
+                    uint64_t nativeFrameId = 0;
+                    err = native_window_get_next_frame_id(
+                            window, &nativeFrameId);
+                    if (err != android::NO_ERROR) {
+                        ALOGE("Failed to get next native frame ID.");
+                    }
+
+                    // Add a new timing record with the user's presentID and
+                    // the nativeFrameId.
+                    swapchain.timing.push_back(TimingInfo(time, nativeFrameId));
+                    while (swapchain.timing.size() > MAX_TIMING_INFOS) {
                         swapchain.timing.removeAt(0);
                     }
                     if (time->desiredPresentTime) {
@@ -1331,5 +1351,18 @@
     return result;
 }
 
+VKAPI_ATTR void SetHdrMetadataEXT(
+    VkDevice device,
+    uint32_t swapchainCount,
+    const VkSwapchainKHR* pSwapchains,
+    const VkHdrMetadataEXT* pHdrMetadataEXTs) {
+    // TODO: courtneygo: implement actual function
+    (void)device;
+    (void)swapchainCount;
+    (void)pSwapchains;
+    (void)pHdrMetadataEXTs;
+    return;
+}
+
 }  // namespace driver
 }  // namespace vulkan
diff --git a/vulkan/libvulkan/swapchain.h b/vulkan/libvulkan/swapchain.h
index 91d7219..4d9f18f 100644
--- a/vulkan/libvulkan/swapchain.h
+++ b/vulkan/libvulkan/swapchain.h
@@ -37,6 +37,7 @@
 VKAPI_ATTR VkResult GetRefreshCycleDurationGOOGLE(VkDevice device, VkSwapchainKHR swapchain, VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties);
 VKAPI_ATTR VkResult GetPastPresentationTimingGOOGLE(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pPresentationTimingCount, VkPastPresentationTimingGOOGLE* pPresentationTimings);
 VKAPI_ATTR VkResult GetSwapchainStatusKHR(VkDevice device, VkSwapchainKHR swapchain);
+VKAPI_ATTR void SetHdrMetadataEXT(VkDevice device, uint32_t swapchainCount, const VkSwapchainKHR* pSwapchains, const VkHdrMetadataEXT* pHdrMetadataEXTs);
 // clang-format on
 
 }  // namespace driver
diff --git a/vulkan/nulldrv/null_driver.cpp b/vulkan/nulldrv/null_driver.cpp
index 55f7f19..e03ee0a 100644
--- a/vulkan/nulldrv/null_driver.cpp
+++ b/vulkan/nulldrv/null_driver.cpp
@@ -906,9 +906,11 @@
                                           VkFormat,
                                           VkImageUsageFlags,
                                           VkSwapchainImageUsageFlagsANDROID,
-                                          int* grallocUsage) {
+                                          uint64_t* grallocConsumerUsage,
+                                          uint64_t* grallocProducerUsage) {
     // The null driver never reads or writes the gralloc buffer
-    *grallocUsage = 0;
+    *grallocConsumerUsage = 0;
+    *grallocProducerUsage = 0;
     return VK_SUCCESS;
 }
 
diff --git a/vulkan/nulldrv/null_driver_gen.h b/vulkan/nulldrv/null_driver_gen.h
index cfc14dd..d73bf14 100644
--- a/vulkan/nulldrv/null_driver_gen.h
+++ b/vulkan/nulldrv/null_driver_gen.h
@@ -165,8 +165,8 @@
 VKAPI_ATTR void CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents);
 VKAPI_ATTR void CmdEndRenderPass(VkCommandBuffer commandBuffer);
 VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers);
-VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int* grallocUsage);
-VKAPI_ATTR VkResult GetSwapchainGrallocUsage2ANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, int* grallocUsage);
+VKAPI_ATTR VkResult GetSwapchainGrallocUsageANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, int32_t* grallocUsage);
+VKAPI_ATTR VkResult GetSwapchainGrallocUsage2ANDROID(VkDevice device, VkFormat format, VkImageUsageFlags imageUsage, VkSwapchainImageUsageFlagsANDROID swapchainImageUsage, uint64_t* grallocConsumerUsage, uint64_t* grallocProducerUsage);
 VKAPI_ATTR VkResult AcquireImageANDROID(VkDevice device, VkImage image, int nativeFenceFd, VkSemaphore semaphore, VkFence fence);
 VKAPI_ATTR VkResult QueueSignalReleaseImageANDROID(VkQueue queue, uint32_t waitSemaphoreCount, const VkSemaphore* pWaitSemaphores, VkImage image, int* pNativeFenceFd);
 VKAPI_ATTR VkResult CreateDebugReportCallbackEXT(VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDebugReportCallbackEXT* pCallback);