diff --git a/AUTHORS b/AUTHORS
index d7f0a3d..d231ba2 100644
--- a/AUTHORS
+++ b/AUTHORS

@@ -667,6 +667,7 @@
 Ravi Nanjundappa <nravi.n@samsung.com>
 Ravi Phaneendra Kasibhatla <r.kasibhatla@samsung.com>
 Ravi Phaneendra Kasibhatla <ravi.kasibhatla@motorola.com>
+Réda Housni Alaoui <alaoui.rda@gmail.com>
 Refael Ackermann <refack@gmail.com>
 Renata Hodovan <rhodovan.u-szeged@partner.samsung.com>
 Rene Bolldorf <rb@radix.io>
@@ -913,6 +914,7 @@
 Canonical Limited <*@canonical.com>
 Code Aurora Forum <*@codeaurora.org>
 Comodo CA Limited
+Cosium <*@cosium.com>
 Endless Mobile, Inc. <*@endlessm.com>
 Facebook, Inc. <*@fb.com>
 Facebook, Inc. <*@oculus.com>

diff --git a/DEPS b/DEPS
index eb1ccf36..d0c9c7e 100644
--- a/DEPS
+++ b/DEPS

@@ -74,11 +74,11 @@
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling Skia
   # and whatever else without interference from each other.
-  'skia_revision': '67a86d50f38d3a646ed165f7c6a7d58fda45cbab',
+  'skia_revision': '29c14a760682e2c449fa043b5e8b69937cb58f3a',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling V8
   # and whatever else without interference from each other.
-  'v8_revision': 'a49f2ad6c11516683d2be26e0203dba776c84cd3',
+  'v8_revision': 'eaa72a5e2c1eb2b4d1a4d1c28ffa31568e496680',
   # Three lines of non-changing comments so that
   # the commit queue can handle CLs rolling swarming_client
   # and whatever else without interference from each other.
@@ -288,7 +288,7 @@
     Var('boringssl_git') + '/boringssl.git' + '@' +  Var('boringssl_revision'),
 
   'src/third_party/breakpad/breakpad':
-    Var('chromium_git') + '/breakpad/breakpad.git' + '@' + 'a61afe7a3e865f1da7ff7185184fe23977c2adca',
+    Var('chromium_git') + '/breakpad/breakpad.git' + '@' + 'c283630201acedb25190d3b73ad0416fb55e4639',
 
   'src/third_party/catapult':
     Var('chromium_git') + '/catapult.git' + '@' + Var('catapult_revision'),

diff --git a/base/compiler_specific.h b/base/compiler_specific.h
index e4f005f..2b9cd02e 100644
--- a/base/compiler_specific.h
+++ b/base/compiler_specific.h

@@ -187,13 +187,6 @@
 #endif
 #endif
 
-// DISABLE_CFI_ICALL -- Disable Control Flow Integrity indirect call checks.
-#if !defined(DISABLE_CFI_ICALL) && defined(__clang__)
-#define DISABLE_CFI_ICALL __attribute__((no_sanitize("cfi-icall")))
-#else
-#define DISABLE_CFI_ICALL
-#endif
-
 // Macro useful for writing cross-platform function pointers.
 #if !defined(CDECL)
 #if defined(OS_WIN)

diff --git a/chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc b/chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc
index 459ac99..13de1a2 100644
--- a/chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc
+++ b/chrome/browser/browsing_data/chrome_browsing_data_remover_delegate_unittest.cc

@@ -942,11 +942,6 @@
     last_origin_filter_ = origin_filter;
   }
 
-  bool RequestIsUpload(const net::URLRequest& request) override {
-    NOTREACHED();
-    return true;
-  }
-
   int remove_calls() const { return remove_calls_; }
   int last_data_type_mask() const { return last_data_type_mask_; }
   base::Callback<bool(const GURL&)> last_origin_filter() const {

diff --git a/chrome/browser/media/router/discovery/BUILD.gn b/chrome/browser/media/router/discovery/BUILD.gn
index 4620d634..8c9d161 100644
--- a/chrome/browser/media/router/discovery/BUILD.gn
+++ b/chrome/browser/media/router/discovery/BUILD.gn

@@ -33,8 +33,12 @@
     "dial/dial_registry.h",
     "dial/dial_service.cc",
     "dial/dial_service.h",
+    "dial/parsed_dial_app_info.cc",
+    "dial/parsed_dial_app_info.h",
     "dial/parsed_dial_device_description.cc",
     "dial/parsed_dial_device_description.h",
+    "dial/safe_dial_app_info_parser.cc",
+    "dial/safe_dial_app_info_parser.h",
     "dial/safe_dial_device_description_parser.cc",
     "dial/safe_dial_device_description_parser.h",
     "mdns/cast_media_sink_service.cc",

diff --git a/chrome/browser/media/router/discovery/dial/README.md b/chrome/browser/media/router/discovery/dial/README.md
index 2efcb12..5b2ef44 100644
--- a/chrome/browser/media/router/discovery/dial/README.md
+++ b/chrome/browser/media/router/discovery/dial/README.md

@@ -8,3 +8,7 @@
 
 * [Dial Discovery design doc](https://docs.google.com/a/chromium.org/document/d/1vLpUgp5mJi6KFaCV3HEMQEZYDKtbcGdwcKNADuzuLzw/edit?usp=sharing)
 * [Media Router design doc](https://www.chromium.org/developers/design-documents/media-router)
+
+## DIAL specification
+
+* [DIAL Protocol Specification](http://www.dial-multiscreen.org/dial-protocol-specification)

diff --git a/chrome/browser/media/router/discovery/dial/parsed_dial_app_info.cc b/chrome/browser/media/router/discovery/dial/parsed_dial_app_info.cc
new file mode 100644
index 0000000..60cfad2
--- /dev/null
+++ b/chrome/browser/media/router/discovery/dial/parsed_dial_app_info.cc

@@ -0,0 +1,12 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/media/router/discovery/dial/parsed_dial_app_info.h"
+
+namespace media_router {
+
+ParsedDialAppInfo::ParsedDialAppInfo() = default;
+ParsedDialAppInfo::~ParsedDialAppInfo() = default;
+
+}  // namespace media_router

diff --git a/chrome/browser/media/router/discovery/dial/parsed_dial_app_info.h b/chrome/browser/media/router/discovery/dial/parsed_dial_app_info.h
new file mode 100644
index 0000000..baaa783
--- /dev/null
+++ b/chrome/browser/media/router/discovery/dial/parsed_dial_app_info.h

@@ -0,0 +1,52 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_PARSED_DIAL_APP_INFO_H_
+#define CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_PARSED_DIAL_APP_INFO_H_
+
+#include <map>
+#include <string>
+
+namespace media_router {
+
+// Possible states of a DIAL application.
+enum class DialAppState {
+  kUnknown = 0,
+
+  // The application is installed and either starting or running.
+  kRunning,
+
+  // The application is installed and not running.
+  kStopped
+};
+
+struct ParsedDialAppInfo {
+  ParsedDialAppInfo();
+  ~ParsedDialAppInfo();
+
+  // Identifies the DIAL protocol version associated with the response.
+  std::string dial_version;
+
+  // The application name. Mandatory.
+  std::string name;
+
+  // Whether the DELETE operation is supported to stop a running application.
+  bool allow_stop = true;
+
+  // The reported state of the application.
+  DialAppState state = DialAppState::kUnknown;
+
+  // If the applications's state is RUNNING, the resource name for the running
+  // application.
+  std::string href;
+
+  // Application-specific data included with the GET response that is not part
+  // of the official specifications. Map of additional data value keyed by XML
+  // tag name.
+  std::map<std::string, std::string> extra_data;
+};
+
+}  // namespace media_router
+
+#endif  // CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_PARSED_DIAL_APP_INFO_H_

diff --git a/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser.cc b/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser.cc
new file mode 100644
index 0000000..6b4b187
--- /dev/null
+++ b/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser.cc

@@ -0,0 +1,160 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser.h"
+
+#include <utility>
+
+#include "base/bind.h"
+#include "base/memory/ptr_util.h"
+#include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
+#include "base/unguessable_token.h"
+#include "services/data_decoder/public/cpp/safe_xml_parser.h"
+#include "url/gurl.h"
+
+namespace media_router {
+
+namespace {
+
+DialAppState ParseDialAppState(const std::string& app_state) {
+  if (base::ToLowerASCII(app_state) == "running") {
+    return DialAppState::kRunning;
+  } else if (base::ToLowerASCII(app_state) == "stopped") {
+    return DialAppState::kStopped;
+  }
+  return DialAppState::kUnknown;
+}
+
+// Parses |child_element| content, and sets corresponding fields of
+// |out_app_info|. Returns ParsingError::kNone if parsing succeeds.
+SafeDialAppInfoParser::ParsingError ProcessChildElement(
+    const base::Value& child_element,
+    ParsedDialAppInfo* out_app_info) {
+  std::string tag_name;
+  if (!data_decoder::GetXmlElementTagName(child_element, &tag_name))
+    return SafeDialAppInfoParser::ParsingError::kInvalidXML;
+
+  if (tag_name == "name") {
+    if (!data_decoder::GetXmlElementText(child_element, &out_app_info->name))
+      return SafeDialAppInfoParser::ParsingError::kFailToReadName;
+  } else if (tag_name == "options") {
+    out_app_info->allow_stop = data_decoder::GetXmlElementAttribute(
+                                   child_element, "allowStop") != "false";
+  } else if (tag_name == "link") {
+    out_app_info->href =
+        data_decoder::GetXmlElementAttribute(child_element, "href");
+  } else if (tag_name == "state") {
+    std::string state;
+    if (!data_decoder::GetXmlElementText(child_element, &state))
+      return SafeDialAppInfoParser::ParsingError::kFailToReadState;
+    out_app_info->state = ParseDialAppState(state);
+  } else {
+    std::string extra_data;
+    if (!data_decoder::GetXmlElementText(child_element, &extra_data)) {
+      DVLOG(2) << "Fail to read extra data, <" << tag_name << ">"
+               << " is not a plain text element.";
+    } else {
+      out_app_info->extra_data[tag_name] = extra_data;
+    }
+  }
+
+  return SafeDialAppInfoParser::ParsingError::kNone;
+}
+
+// Returns ParsingError::kNone if mandatory fields (name, state) are valid.
+// |app_info|: app info object to be validated.
+SafeDialAppInfoParser::ParsingError ValidateParsedAppInfo(
+    const ParsedDialAppInfo& app_info) {
+  if (app_info.name.empty())
+    return SafeDialAppInfoParser::ParsingError::kMissingName;
+
+  if (app_info.state == DialAppState::kUnknown)
+    return SafeDialAppInfoParser::ParsingError::kInvalidState;
+
+  return SafeDialAppInfoParser::ParsingError::kNone;
+}
+
+}  // namespace
+
+// Note we generate a random batch ID so that parsing operations started from
+// this SafeDialAppInfoParser instance run in the same utility process.
+SafeDialAppInfoParser::SafeDialAppInfoParser(
+    service_manager::Connector* connector)
+    : connector_(connector),
+      xml_parser_batch_id_(base::UnguessableToken::Create().ToString()),
+      weak_factory_(this) {}
+
+SafeDialAppInfoParser::~SafeDialAppInfoParser() {}
+
+void SafeDialAppInfoParser::Parse(const std::string& xml_text,
+                                  ParseCallback callback) {
+  DVLOG(2) << "Parsing app info...";
+  DCHECK(callback);
+
+  data_decoder::ParseXml(
+      connector_, xml_text,
+      base::BindOnce(&SafeDialAppInfoParser::OnXmlParsingDone,
+                     weak_factory_.GetWeakPtr(), std::move(callback)),
+      xml_parser_batch_id_);
+}
+
+void SafeDialAppInfoParser::OnXmlParsingDone(
+    SafeDialAppInfoParser::ParseCallback callback,
+    std::unique_ptr<base::Value> value,
+    const base::Optional<std::string>& error) {
+  if (error) {
+    DVLOG(1) << "Fail to parse XML in utility process, error: "
+             << error.value();
+  }
+
+  if (!value || !value->is_dict()) {
+    std::move(callback).Run(nullptr, ParsingError::kInvalidXML);
+    return;
+  }
+
+  // NOTE: enforce namespace check for <service> element in future. Namespace
+  // value will be "urn:dial-multiscreen-org:schemas:dial".
+  bool unique_service = true;
+  const base::Value* service_element =
+      data_decoder::FindXmlElementPath(*value, {"service"}, &unique_service);
+  if (!service_element || !unique_service) {
+    std::move(callback).Run(nullptr, ParsingError::kInvalidXML);
+    return;
+  }
+
+  // Read optional @dialVer.
+  std::unique_ptr<ParsedDialAppInfo> app_info =
+      base::MakeUnique<ParsedDialAppInfo>();
+  app_info->dial_version =
+      data_decoder::GetXmlElementAttribute(*service_element, "dialVer");
+
+  // Fetch all the children of <service> element.
+  const base::Value* child_elements =
+      data_decoder::GetXmlElementChildren(*service_element);
+  if (!child_elements || !child_elements->is_list()) {
+    std::move(callback).Run(nullptr, ParsingError::kInvalidXML);
+    return;
+  }
+
+  ParsingError parsing_error = ParsingError::kNone;
+  for (const auto& child_element : child_elements->GetList()) {
+    parsing_error = ProcessChildElement(child_element, app_info.get());
+    if (parsing_error != ParsingError::kNone) {
+      std::move(callback).Run(nullptr, parsing_error);
+      return;
+    }
+  }
+
+  // Validate mandatory fields (name, state).
+  parsing_error = ValidateParsedAppInfo(*app_info);
+  if (parsing_error != ParsingError::kNone) {
+    std::move(callback).Run(nullptr, parsing_error);
+    return;
+  }
+
+  std::move(callback).Run(std::move(app_info), ParsingError::kNone);
+}
+
+}  // namespace media_router

diff --git a/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser.h b/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser.h
new file mode 100644
index 0000000..dc90eea
--- /dev/null
+++ b/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser.h

@@ -0,0 +1,81 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_SAFE_DIAL_APP_INFO_PARSER_H_
+#define CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_SAFE_DIAL_APP_INFO_PARSER_H_
+
+#include <memory>
+#include <string>
+
+#include "base/callback.h"
+#include "base/macros.h"
+#include "base/memory/weak_ptr.h"
+#include "base/optional.h"
+#include "base/values.h"
+#include "chrome/browser/media/router/discovery/dial/parsed_dial_app_info.h"
+
+namespace service_manager {
+class Connector;
+}
+
+namespace media_router {
+
+// SafeDialAppInfoParser parses the given app info XML file safely via a utility
+// process.
+// Spec for DIAL app info XML:
+// http://www.dial-multiscreen.org/dial-protocol-specification
+// Section 6.1.2 Server response.
+class SafeDialAppInfoParser {
+ public:
+  enum class ParsingError {
+    kNone = 0,
+    kInvalidXML = 1,
+    kFailToReadName = 2,
+    kFailToReadState = 3,
+    kMissingName = 4,
+    kInvalidState = 5
+  };
+
+  // |connector| should be a valid connector to the ServiceManager.
+  explicit SafeDialAppInfoParser(service_manager::Connector* connector);
+  ~SafeDialAppInfoParser();
+
+  // Callback function invoked when done parsing DIAL app info XML.
+  // |app_info|: app info object. Empty if parsing failed.
+  // |parsing_error|: error encountered while parsing the DIAL app info XML.
+  using ParseCallback =
+      base::OnceCallback<void(std::unique_ptr<ParsedDialAppInfo> app_info,
+                              ParsingError parsing_error)>;
+
+  // Parses the DIAL app info in |xml_text| in a utility process.
+  // If the parsing succeeds, invokes callback with a valid
+  // |app_info|, otherwise invokes callback with an empty
+  // |app_info| and sets parsing error to detail the failure.
+  // Note that it's safe to call this method multiple times and when making
+  // multiple calls they may be grouped in the same utility process. The
+  // utility process is still cleaned up automatically if unused after some
+  // time, even if this object is still alive.
+  // Note also that the callback is not called if the object is deleted.
+  void Parse(const std::string& xml_text, ParseCallback callback);
+
+ private:
+  void OnXmlParsingDone(ParseCallback callback,
+                        std::unique_ptr<base::Value> value,
+                        const base::Optional<std::string>& error);
+
+  // Connector to the ServiceManager, used to retrieve the XmlParser service.
+  service_manager::Connector* const connector_;
+
+  // The batch ID used to group XML parsing calls to SafeXmlParser into a single
+  // process.
+  std::string xml_parser_batch_id_;
+
+  base::WeakPtrFactory<SafeDialAppInfoParser> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(SafeDialAppInfoParser);
+};
+
+}  // namespace media_router
+
+#endif  // CHROME_BROWSER_MEDIA_ROUTER_DISCOVERY_DIAL_SAFE_DIAL_APP_INFO_PARSER_H_

diff --git a/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser_unittest.cc b/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser_unittest.cc
new file mode 100644
index 0000000..702bc28
--- /dev/null
+++ b/chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser_unittest.cc

@@ -0,0 +1,189 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+#include "chrome/browser/media/router/discovery/dial/safe_dial_app_info_parser.h"
+
+#include <string>
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/run_loop.h"
+#include "base/strings/string_util.h"
+#include "content/public/test/test_browser_thread_bundle.h"
+#include "services/data_decoder/data_decoder_service.h"
+#include "services/data_decoder/public/cpp/safe_xml_parser.h"
+#include "services/service_manager/public/cpp/test/test_connector_factory.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace media_router {
+
+namespace {
+
+constexpr char kValidAppInfoXml[] =
+    R"(<?xml version="1.0" encoding="UTF-8"?>
+       <service xmlns="urn:dial-multiscreen-org:schemas:dial">
+        <name>YouTube</name>
+        <options allowStop="false"/>
+        <state>running</state>
+        <link rel="run" href="run"/>
+       </service>
+    )";
+
+constexpr char kValidAppInfoXmlExtraData[] =
+    R"(<?xml version="1.0" encoding="UTF-8"?>
+       <service xmlns="urn:dial-multiscreen-org:schemas:dial">
+         <name>YouTube</name>
+         <state>Running</state>
+         <options allowStop="false"/>
+         <link rel="run" href="run"/>
+         <port>8080</port>
+         <capabilities>websocket</capabilities>
+         <additionalData>
+           <screenId>e5n3112oskr42pg0td55b38nh4</screenId>
+           <otherField>2</otherField>
+         </additionalData>
+       </service>
+    )";
+
+constexpr char kInvalidXmlNoState[] =
+    R"(<?xml version="1.0" encoding="UTF-8"?>
+       <service xmlns="urn:dial-multiscreen-org:schemas:dial">
+         <name>YouTube</name>
+         <state></state>
+         <options allowStop="false"/>
+         <link rel="run" href="run"/>
+       </service>
+    )";
+
+constexpr char kInvalidXmlInvalidState[] =
+    R"(<?xml version="1.0" encoding="UTF-8"?>
+       <service xmlns="urn:dial-multiscreen-org:schemas:dial">
+         <name>YouTube</name>
+         <options allowStop="false"/>
+         <state>xyzzy</state>
+         <link rel="run" href="run"/>
+       </service>
+    )";
+
+constexpr char kInvalidXmlNoName[] =
+    R"(<?xml version="1.0" encoding="UTF-8"?>
+       <service xmlns="urn:dial-multiscreen-org:schemas:dial">
+         <options allowStop="false"/>
+         <state>running</state>
+         <link rel="run" href="run"/>
+       </service>
+    )";
+
+constexpr char kInvalidXmlMultipleServices[] =
+    R"(<?xml version="1.0" encoding="UTF-8"?>
+       <root>
+         <service xmlns="urn:dial-multiscreen-org:schemas:dial">
+           <name>YouTube</name>
+           <options allowStop="false"/>
+           <state>running</state>
+         </service>
+         <service xmlns="urn:dial-multiscreen-org:schemas:dial">
+           <name>Netflix</name>
+           <options allowStop="false"/>
+           <state>running</state>
+         </service>
+       </root>
+    )";
+
+}  // namespace
+
+class SafeDialAppInfoParserTest : public testing::Test {
+ public:
+  SafeDialAppInfoParserTest()
+      : connector_factory_(
+            std::make_unique<data_decoder::DataDecoderService>()) {
+    connector_ = connector_factory_.CreateConnector();
+  }
+
+  std::unique_ptr<ParsedDialAppInfo> Parse(
+      const std::string& xml,
+      SafeDialAppInfoParser::ParsingError expected_error) {
+    base::RunLoop run_loop;
+    SafeDialAppInfoParser parser(connector_.get());
+    parser.Parse(xml,
+                 base::BindOnce(&SafeDialAppInfoParserTest::OnParsingCompleted,
+                                base::Unretained(this), expected_error));
+    base::RunLoop().RunUntilIdle();
+    return std::move(app_info_);
+  }
+
+  void OnParsingCompleted(SafeDialAppInfoParser::ParsingError expected_error,
+                          std::unique_ptr<ParsedDialAppInfo> app_info,
+                          SafeDialAppInfoParser::ParsingError error) {
+    app_info_ = std::move(app_info);
+    EXPECT_EQ(expected_error, error);
+  }
+
+ private:
+  content::TestBrowserThreadBundle test_browser_thread_bundle_;
+  std::unique_ptr<service_manager::Connector> connector_;
+  service_manager::TestConnectorFactory connector_factory_;
+  std::unique_ptr<ParsedDialAppInfo> app_info_;
+  DISALLOW_COPY_AND_ASSIGN(SafeDialAppInfoParserTest);
+};
+
+TEST_F(SafeDialAppInfoParserTest, TestInvalidXmlNoService) {
+  std::unique_ptr<ParsedDialAppInfo> app_info =
+      Parse("", SafeDialAppInfoParser::ParsingError::kInvalidXML);
+  EXPECT_FALSE(app_info);
+}
+
+TEST_F(SafeDialAppInfoParserTest, TestValidXml) {
+  std::string xml_text(kValidAppInfoXml);
+  std::unique_ptr<ParsedDialAppInfo> app_info =
+      Parse(xml_text, SafeDialAppInfoParser::ParsingError::kNone);
+
+  EXPECT_EQ("YouTube", app_info->name);
+  EXPECT_EQ(DialAppState::kRunning, app_info->state);
+  EXPECT_FALSE(app_info->allow_stop);
+  EXPECT_EQ("run", app_info->href);
+  EXPECT_TRUE(app_info->extra_data.empty());
+}
+
+TEST_F(SafeDialAppInfoParserTest, TestValidXmlExtraData) {
+  std::string xml_text(kValidAppInfoXmlExtraData);
+  std::unique_ptr<ParsedDialAppInfo> app_info =
+      Parse(xml_text, SafeDialAppInfoParser::ParsingError::kNone);
+
+  EXPECT_EQ("YouTube", app_info->name);
+  EXPECT_EQ(DialAppState::kRunning, app_info->state);
+  EXPECT_EQ(2u, app_info->extra_data.size());
+  EXPECT_EQ("8080", app_info->extra_data["port"]);
+  EXPECT_EQ("websocket", app_info->extra_data["capabilities"]);
+}
+
+TEST_F(SafeDialAppInfoParserTest, TestInvalidXmlNoState) {
+  std::string xml_text(kInvalidXmlNoState);
+  std::unique_ptr<ParsedDialAppInfo> app_info =
+      Parse(xml_text, SafeDialAppInfoParser::ParsingError::kFailToReadState);
+  EXPECT_FALSE(app_info);
+}
+
+TEST_F(SafeDialAppInfoParserTest, TestInvalidXmlInvalidState) {
+  std::string xml_text(kInvalidXmlInvalidState);
+  std::unique_ptr<ParsedDialAppInfo> app_info =
+      Parse(xml_text, SafeDialAppInfoParser::ParsingError::kInvalidState);
+  EXPECT_FALSE(app_info);
+}
+
+TEST_F(SafeDialAppInfoParserTest, TestInvalidXmlNoName) {
+  std::string xml_text(kInvalidXmlNoName);
+  std::unique_ptr<ParsedDialAppInfo> app_info =
+      Parse(xml_text, SafeDialAppInfoParser::ParsingError::kMissingName);
+  EXPECT_FALSE(app_info);
+}
+
+TEST_F(SafeDialAppInfoParserTest, TestInvalidXmlMultipleServices) {
+  std::string xml_text(kInvalidXmlMultipleServices);
+  std::unique_ptr<ParsedDialAppInfo> app_info =
+      Parse(xml_text, SafeDialAppInfoParser::ParsingError::kInvalidXML);
+  EXPECT_FALSE(app_info);
+}
+
+}  // namespace media_router

diff --git a/chrome/browser/resources/local_ntp/local_ntp.js b/chrome/browser/resources/local_ntp/local_ntp.js
index 985543b..17bbafb 100644
--- a/chrome/browser/resources/local_ntp/local_ntp.js
+++ b/chrome/browser/resources/local_ntp/local_ntp.js

@@ -398,6 +398,15 @@
  * them to the iframe.
  */
 function reloadTiles() {
+  // Don't attempt to load tiles if the MV data isn't available yet - this can
+  // happen occasionally, see https://crbug.com/794942. In that case, we should
+  // get an onMostVisitedChange call once they are available.
+  // Note that MV data being available is different from having > 0 tiles. There
+  // can legitimately be 0 tiles, e.g. if the user blacklisted them all.
+  if (!ntpApiHandle.mostVisitedAvailable) {
+    return;
+  }
+
   var pages = ntpApiHandle.mostVisited;
   var cmds = [];
   for (var i = 0; i < Math.min(MAX_NUM_TILES_TO_SHOW, pages.length); ++i) {

diff --git a/chrome/browser/resources/local_ntp/most_visited_single.js b/chrome/browser/resources/local_ntp/most_visited_single.js
index 3a74405..c4c0bfe 100644
--- a/chrome/browser/resources/local_ntp/most_visited_single.js
+++ b/chrome/browser/resources/local_ntp/most_visited_single.js

@@ -199,6 +199,8 @@
   if (cmd == 'tile') {
     addTile(data);
   } else if (cmd == 'show') {
+    // TODO(treib): If this happens before we have finished loading the previous
+    // tiles, we probably get into a bad state.
     showTiles(data);
   } else if (cmd == 'updateTheme') {
     updateTheme(data);

diff --git a/chrome/renderer/resources/extensions/media_router_bindings.js b/chrome/renderer/resources/extensions/media_router_bindings.js
index 936e2a200..6d5f113 100644
--- a/chrome/renderer/resources/extensions/media_router_bindings.js
+++ b/chrome/renderer/resources/extensions/media_router_bindings.js

@@ -497,7 +497,7 @@
     'domain': sink.domain,
     'sinkId': sink.id,
     'iconType': sinkIconTypeToMojo(sink.iconType),
-    'provider_id': mediaRouter.mojom.MediaRouteProvider.Id.EXTENSION,
+    'providerId': mediaRouter.mojom.MediaRouteProvider.Id.EXTENSION,
   });
 }
 

diff --git a/chrome/renderer/searchbox/searchbox.cc b/chrome/renderer/searchbox/searchbox.cc
index fe5638d3..575c605 100644
--- a/chrome/renderer/searchbox/searchbox.cc
+++ b/chrome/renderer/searchbox/searchbox.cc

@@ -219,6 +219,7 @@
       is_input_in_progress_(false),
       is_key_capture_enabled_(false),
       most_visited_items_cache_(kMaxInstantMostVisitedItemCacheSize),
+      has_received_most_visited_(false),
       weak_ptr_factory_(this) {
   // Connect to the embedded search interface in the browser.
   chrome::mojom::EmbeddedSearchConnectorAssociatedPtr connector;
@@ -282,6 +283,10 @@
   most_visited_items_cache_.GetCurrentItems(items);
 }
 
+bool SearchBox::AreMostVisitedItemsAvailable() const {
+  return has_received_most_visited_;
+}
+
 bool SearchBox::GetMostVisitedItemWithID(
     InstantRestrictedID most_visited_item_id,
     InstantMostVisitedItem* item) const {
@@ -368,6 +373,8 @@
 
 void SearchBox::MostVisitedChanged(
     const std::vector<InstantMostVisitedItem>& items) {
+  has_received_most_visited_ = true;
+
   std::vector<InstantMostVisitedItemIDPair> last_known_items;
   GetMostVisitedItems(&last_known_items);
 

diff --git a/chrome/renderer/searchbox/searchbox.h b/chrome/renderer/searchbox/searchbox.h
index aaade1b..2f7394d3 100644
--- a/chrome/renderer/searchbox/searchbox.h
+++ b/chrome/renderer/searchbox/searchbox.h

@@ -95,6 +95,8 @@
   void GetMostVisitedItems(
       std::vector<InstantMostVisitedItemIDPair>* items) const;
 
+  bool AreMostVisitedItemsAvailable() const;
+
   // If the |most_visited_item_id| is found in the cache, sets |item| to it
   // and returns true.
   bool GetMostVisitedItemWithID(InstantRestrictedID most_visited_item_id,
@@ -165,6 +167,7 @@
   bool is_input_in_progress_;
   bool is_key_capture_enabled_;
   InstantRestrictedIDCache<InstantMostVisitedItem> most_visited_items_cache_;
+  bool has_received_most_visited_;
   ThemeBackgroundInfo theme_info_;
 
   base::WeakPtrFactory<SearchBox> weak_ptr_factory_;

diff --git a/chrome/renderer/searchbox/searchbox_extension.cc b/chrome/renderer/searchbox/searchbox_extension.cc
index b83fd3d..3525182 100644
--- a/chrome/renderer/searchbox/searchbox_extension.cc
+++ b/chrome/renderer/searchbox/searchbox_extension.cc

@@ -549,6 +549,7 @@
   // Handlers for JS properties.
   static bool IsInputInProgress();
   static v8::Local<v8::Value> GetMostVisited(v8::Isolate* isolate);
+  static bool GetMostVisitedAvailable(v8::Isolate* isolate);
   static v8::Local<v8::Value> GetThemeBackgroundInfo(v8::Isolate* isolate);
 
   // Handlers for JS functions visible to all NTPs.
@@ -592,6 +593,8 @@
   return gin::Wrappable<NewTabPageBindings>::GetObjectTemplateBuilder(isolate)
       .SetProperty("isInputInProgress", &NewTabPageBindings::IsInputInProgress)
       .SetProperty("mostVisited", &NewTabPageBindings::GetMostVisited)
+      .SetProperty("mostVisitedAvailable",
+                   &NewTabPageBindings::GetMostVisitedAvailable)
       .SetProperty("themeBackgroundInfo",
                    &NewTabPageBindings::GetThemeBackgroundInfo)
       .SetMethod("checkIsUserSignedIntoChromeAs",
@@ -659,6 +662,15 @@
 }
 
 // static
+bool NewTabPageBindings::GetMostVisitedAvailable(v8::Isolate* isolate) {
+  const SearchBox* search_box = GetSearchBoxForCurrentContext();
+  if (!search_box)
+    return false;
+
+  return search_box->AreMostVisitedItemsAvailable();
+}
+
+// static
 v8::Local<v8::Value> NewTabPageBindings::GetThemeBackgroundInfo(
     v8::Isolate* isolate) {
   const SearchBox* search_box = GetSearchBoxForCurrentContext();

diff --git a/chrome/test/BUILD.gn b/chrome/test/BUILD.gn
index 105b8177..3374481b 100644
--- a/chrome/test/BUILD.gn
+++ b/chrome/test/BUILD.gn

@@ -2959,6 +2959,7 @@
       "../browser/media/router/discovery/dial/dial_media_sink_service_unittest.cc",
       "../browser/media/router/discovery/dial/dial_registry_unittest.cc",
       "../browser/media/router/discovery/dial/dial_service_unittest.cc",
+      "../browser/media/router/discovery/dial/safe_dial_app_info_parser_unittest.cc",
       "../browser/media/router/discovery/dial/safe_dial_device_description_parser_unittest.cc",
       "../browser/media/router/discovery/mdns/cast_media_sink_service_impl_unittest.cc",
       "../browser/media/router/discovery/mdns/cast_media_sink_service_unittest.cc",

diff --git a/content/browser/webrtc/webrtc_image_capture_browsertest.cc b/content/browser/webrtc/webrtc_image_capture_browsertest.cc
index f4757d0..2028b32 100644
--- a/content/browser/webrtc/webrtc_image_capture_browsertest.cc
+++ b/content/browser/webrtc/webrtc_image_capture_browsertest.cc

@@ -46,13 +46,26 @@
 
 static const char kImageCaptureHtmlFile[] = "/media/image_capture_test.html";
 
+enum class Camera {
+  FAKE,
+  DEFAULT,
+#if defined(OS_WIN)
+  // Media Foundation is only available in Windows versions >= 7, below that the
+  // following flag has no effect
+  WIN_MEDIA_FOUNDATION
+#endif
+};
+
 // TODO(mcasas): enable real-camera tests by disabling the Fake Device for
 // platforms where the ImageCaptureCode is landed, https://crbug.com/656810
 static struct TargetCamera {
-  bool use_fake;
-} const kTargetCameras[] = {{true},
+  Camera camera;
+} const kTargetCameras[] = {{Camera::FAKE},
 #if defined(OS_LINUX) || defined(OS_MACOSX) || defined(OS_ANDROID)
-                            {false}
+                            {Camera::DEFAULT},
+#endif
+#if defined(OS_WIN)
+                            {Camera::WIN_MEDIA_FOUNDATION}
 #endif
 };
 
@@ -145,11 +158,23 @@
   void SetUpCommandLine(base::CommandLine* command_line) override {
     WebRtcImageCaptureBrowserTestBase::SetUpCommandLine(command_line);
 
-    if (std::get<0>(GetParam()).use_fake) {
-      base::CommandLine::ForCurrentProcess()->AppendSwitch(
-          switches::kUseFakeDeviceForMediaStream);
-      ASSERT_TRUE(base::CommandLine::ForCurrentProcess()->HasSwitch(
-          switches::kUseFakeDeviceForMediaStream));
+    switch (std::get<0>(GetParam()).camera) {
+      case Camera::FAKE:
+        base::CommandLine::ForCurrentProcess()->AppendSwitch(
+            switches::kUseFakeDeviceForMediaStream);
+        ASSERT_TRUE(base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kUseFakeDeviceForMediaStream));
+        break;
+#if defined(OS_WIN)
+      case Camera::WIN_MEDIA_FOUNDATION:
+        base::CommandLine::ForCurrentProcess()->AppendSwitch(
+            switches::kForceMediaFoundationVideoCapture);
+        ASSERT_TRUE(base::CommandLine::ForCurrentProcess()->HasSwitch(
+            switches::kForceMediaFoundationVideoCapture));
+        break;
+#endif
+      default:
+        break;
     }
   }
 
@@ -157,7 +182,7 @@
     // TODO(chfremer): Enable test cases using the video capture service with
     // real cameras as soon as root cause for https://crbug.com/733582 is
     // understood and resolved.
-    if ((!std::get<0>(GetParam()).use_fake) &&
+    if ((std::get<0>(GetParam()).camera != Camera::FAKE) &&
         (std::get<1>(GetParam()).use_video_capture_service)) {
       LOG(INFO) << "Skipping this test case";
       return true;

diff --git a/content/test/data/media/image_capture_test.html b/content/test/data/media/image_capture_test.html
index beb85fa..5239163 100644
--- a/content/test/data/media/image_capture_test.html
+++ b/content/test/data/media/image_capture_test.html

@@ -6,7 +6,7 @@
 <body>
 <script type="text/javascript" src="webrtc_test_utilities.js"></script>
 <script>
-const WIDTH = 320;
+const WIDTH = 640;
 /** @const */ var CONSTRAINTS = { width: { max : WIDTH } };
 
 // Returns a Promise resolved with |object| after a delay of |delayInMs|.

diff --git a/gpu/command_buffer/service/passthrough_program_cache.cc b/gpu/command_buffer/service/passthrough_program_cache.cc
index 207c679..ea257fa7 100644
--- a/gpu/command_buffer/service/passthrough_program_cache.cc
+++ b/gpu/command_buffer/service/passthrough_program_cache.cc

@@ -31,7 +31,7 @@
 bool ProgramCacheControlExtensionAvailable() {
 #if defined(USE_EGL)
   // The display should be initialized if the extension is available.
-  return gl::g_driver_egl->ext.b_EGL_ANGLE_program_cache_control;
+  return gl::g_driver_egl.ext.b_EGL_ANGLE_program_cache_control;
 #else
   return false;
 #endif  // defined(USE_EGL)

diff --git a/gpu/command_buffer/service/texture_definition.cc b/gpu/command_buffer/service/texture_definition.cc
index f1d424af..4105482a 100644
--- a/gpu/command_buffer/service/texture_definition.cc
+++ b/gpu/command_buffer/service/texture_definition.cc

@@ -155,8 +155,8 @@
   DCHECK_NE(EGL_NO_DISPLAY, egl_display);
   DCHECK(glIsTexture(texture_id));
 
-  DCHECK(gl::g_driver_egl->ext.b_EGL_KHR_image_base &&
-         gl::g_driver_egl->ext.b_EGL_KHR_gl_texture_2D_image &&
+  DCHECK(gl::g_driver_egl.ext.b_EGL_KHR_image_base &&
+         gl::g_driver_egl.ext.b_EGL_KHR_gl_texture_2D_image &&
          gl::g_current_gl_driver->ext.b_GL_OES_EGL_image);
 
   const EGLint egl_attrib_list[] = {

diff --git a/ios/web/BUILD.gn b/ios/web/BUILD.gn
index 7971d32..2f6b241 100644
--- a/ios/web/BUILD.gn
+++ b/ios/web/BUILD.gn

@@ -257,6 +257,7 @@
     "navigation/placeholder_navigation_util_unittest.mm",
     "navigation/serializable_user_data_manager_impl_unittest.mm",
     "navigation/wk_based_navigation_manager_impl_unittest.mm",
+    "navigation/wk_based_restore_session_util_unittest.mm",
   ]
 }
 

diff --git a/ios/web/navigation/BUILD.gn b/ios/web/navigation/BUILD.gn
index f0e1216..d90958c 100644
--- a/ios/web/navigation/BUILD.gn
+++ b/ios/web/navigation/BUILD.gn

@@ -43,6 +43,8 @@
     "time_smoother.h",
     "wk_based_navigation_manager_impl.h",
     "wk_based_navigation_manager_impl.mm",
+    "wk_based_restore_session_util.h",
+    "wk_based_restore_session_util.mm",
   ]
 
   configs += [ "//build/config/compiler:enable_arc" ]

diff --git a/ios/web/navigation/wk_based_navigation_manager_impl.mm b/ios/web/navigation/wk_based_navigation_manager_impl.mm
index f582e51..cbcf1b2 100644
--- a/ios/web/navigation/wk_based_navigation_manager_impl.mm
+++ b/ios/web/navigation/wk_based_navigation_manager_impl.mm

@@ -7,23 +7,19 @@
 #import <Foundation/Foundation.h>
 #include <memory>
 
-#include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/mac/bundle_locations.h"
 #include "base/memory/ptr_util.h"
-#include "base/strings/stringprintf.h"
-#include "base/strings/sys_string_conversions.h"
-#include "base/values.h"
 #import "ios/web/navigation/crw_navigation_item_holder.h"
 #import "ios/web/navigation/navigation_item_impl.h"
 #include "ios/web/navigation/navigation_item_impl_list.h"
 #import "ios/web/navigation/navigation_manager_delegate.h"
+#include "ios/web/navigation/wk_based_restore_session_util.h"
 #include "ios/web/public/load_committed_details.h"
 #import "ios/web/public/navigation_item.h"
 #import "ios/web/public/web_client.h"
 #import "ios/web/web_state/ui/crw_web_view_navigation_proxy.h"
 #import "net/base/mac/url_conversions.h"
-#include "net/base/url_util.h"
 
 #if !defined(__has_feature) || !__has_feature(objc_arc)
 #error "This file requires ARC support."
@@ -383,38 +379,17 @@
   // TODO(crbug.com/771200): Retain these original NavigationItems restored from
   // storage and associate them with new WKBackForwardListItems created after
   // history restore so information such as scroll position is restored.
-
-  // The URLs and titles of the restored entries are stored in two separate
-  // lists instead of a single list of objects to reduce the size of the JSON
-  // string to be included in the query parameter.
-  base::Value restored_urls(base::Value::Type::LIST);
-  base::Value restored_titles(base::Value::Type::LIST);
-  restored_urls.GetList().reserve(items.size());
-  restored_titles.GetList().reserve(items.size());
-  for (size_t index = 0; index < items.size(); index++) {
-    restored_urls.GetList().push_back(
-        base::Value(items[index]->GetURL().spec()));
-    restored_titles.GetList().push_back(base::Value(items[index]->GetTitle()));
-  }
-  base::Value session(base::Value::Type::DICTIONARY);
-  int offset = last_committed_item_index + 1 - items.size();
-  session.SetKey("offset", base::Value(offset));
-  session.SetKey("urls", std::move(restored_urls));
-  session.SetKey("titles", std::move(restored_titles));
-
-  std::string session_json;
-  base::JSONWriter::Write(session, &session_json);
-
-  std::string restore_session_resource_path = base::SysNSStringToUTF8(
-      [base::mac::FrameworkBundle() pathForResource:@"restore_session"
-                                             ofType:@"html"]);
-  std::string url_spec = base::StringPrintf(
-      "%s://%s", url::kFileScheme, restore_session_resource_path.c_str());
-  GURL url = net::AppendQueryParameter(GURL(url_spec), "session", session_json);
+  GURL url = CreateRestoreSessionUrl(last_committed_item_index, items);
 
   WebLoadParams params(url);
+  // It's not clear how this transition type will be used and what's the impact.
+  // For now, use RELOAD because restoring history is kind of like a reload of
+  // the current page.
   params.transition_type = ui::PAGE_TRANSITION_RELOAD;
   LoadURLWithParams(params);
+
+  GetPendingItemImpl()->SetVirtualURL(
+      items[last_committed_item_index]->GetVirtualURL());
 }
 
 NavigationItemImpl* WKBasedNavigationManagerImpl::GetNavigationItemImplAtIndex(
@@ -444,6 +419,20 @@
           net::GURLWithNSURL(prev_wk_item.URL),
           nullptr /* use default rewriters only */);
   new_item->SetTimestamp(time_smoother_.GetSmoothedTime(base::Time::Now()));
+  const GURL& url = new_item->GetURL();
+  // If this navigation item has a restore_session.html URL, then it was created
+  // to restore session history and will redirect to the target URL encoded in
+  // the query parameter automatically. Set virtual URL to the target URL so the
+  // internal restore_session.html is not exposed in the UI and to URL-sensing
+  // components outside of //ios/web layer.
+  if (IsRestoreSessionUrl(url)) {
+    GURL virtual_url;
+    bool success = ExtractTargetURL(url, &virtual_url);
+    DCHECK(success);
+    if (success)
+      new_item->SetVirtualURL(virtual_url);
+  }
+
   SetNavigationItemInWKItem(wk_item, std::move(new_item));
   return GetNavigationItemFromWKItem(wk_item);
 }

diff --git a/ios/web/navigation/wk_based_navigation_manager_impl_unittest.mm b/ios/web/navigation/wk_based_navigation_manager_impl_unittest.mm
index 1b74274..f658b2a7 100644
--- a/ios/web/navigation/wk_based_navigation_manager_impl_unittest.mm
+++ b/ios/web/navigation/wk_based_navigation_manager_impl_unittest.mm

@@ -8,10 +8,12 @@
 #include <memory>
 
 #include "base/memory/ptr_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #import "ios/web/navigation/navigation_manager_delegate.h"
 #import "ios/web/navigation/navigation_manager_impl.h"
+#include "ios/web/navigation/wk_based_restore_session_util.h"
 #include "ios/web/public/load_committed_details.h"
 #include "ios/web/public/navigation_item.h"
 #include "ios/web/public/test/fakes/test_browser_state.h"
@@ -583,9 +585,11 @@
   GURL pending_url = pending_item->GetURL();
   EXPECT_TRUE(pending_url.SchemeIsFile());
   EXPECT_EQ("restore_session.html", pending_url.ExtractFileName());
+  EXPECT_EQ("http://www.0.com/", pending_item->GetVirtualURL());
 
   std::string session_json;
-  net::GetValueForKeyInQuery(pending_url, "session", &session_json);
+  net::GetValueForKeyInQuery(pending_url, kRestoreSessionSessionQueryKey,
+                             &session_json);
   EXPECT_EQ(
       "{\"offset\":-1,\"titles\":[\"Test Website 0\",\"\"],"
       "\"urls\":[\"http://www.0.com/\",\"http://www.1.com/\"]}",
@@ -660,4 +664,19 @@
   ASSERT_EQ(nullptr, manager_->GetPendingItem());
 }
 
+// Tests that the virtual URL of a restore_session redirect item is updated to
+// the target URL.
+TEST_F(WKBasedNavigationManagerTest, HideInternalRedirectUrl) {
+  GURL target_url = GURL("http://www.1.com?query=special%26chars");
+  GURL url = net::AppendQueryParameter(GetRestoreSessionBaseUrl(),
+                                       kRestoreSessionTargetUrlQueryKey,
+                                       target_url.spec());
+  NSString* url_spec = base::SysUTF8ToNSString(url.spec());
+  [mock_wk_list_ setCurrentURL:url_spec];
+  NavigationItem* item = manager_->GetItemAtIndex(0);
+  ASSERT_TRUE(item);
+  EXPECT_EQ(target_url, item->GetVirtualURL());
+  EXPECT_EQ(url, item->GetURL());
+}
+
 }  // namespace web

diff --git a/ios/web/navigation/wk_based_restore_session_util.h b/ios/web/navigation/wk_based_restore_session_util.h
new file mode 100644
index 0000000..7cf27f1
--- /dev/null
+++ b/ios/web/navigation/wk_based_restore_session_util.h

@@ -0,0 +1,48 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// This file contains utility functions for WKBasedNavigationManagerImpl.
+
+#ifndef IOS_WEB_NAVIGATION_WK_BASED_RESTORE_SESSION_UTIL_H_
+#define IOS_WEB_NAVIGATION_WK_BASED_RESTORE_SESSION_UTIL_H_
+
+#include <memory>
+#include <vector>
+
+#include "url/gurl.h"
+
+namespace web {
+
+class NavigationItem;
+
+// Query parameter key used to encode the session history to inject in a
+// restore_session.html URL.
+extern const char kRestoreSessionSessionQueryKey[];
+
+// Query parameter key used to encode target URL in a restore_session.html URL.
+extern const char kRestoreSessionTargetUrlQueryKey[];
+
+// Returns a file:// URL that points to the magic restore_session.html file.
+// This is used in unit tests.
+GURL GetRestoreSessionBaseUrl();
+
+// Creates a restore_session.html URL with the provided session history encoded
+// in the query argument, such that when this URL is loaded in the web view,
+// recreates all the history entries in |items| and the current loaded item is
+// the entry at |last_committed_item_index|.
+GURL CreateRestoreSessionUrl(
+    int last_committed_item_index,
+    const std::vector<std::unique_ptr<NavigationItem>>& items);
+
+// Returns true if the base URL of |url| is restore_session.html.
+bool IsRestoreSessionUrl(const GURL& url);
+
+// Extracts the URL encoded in the 'targetUrl' query component of
+// |restore_session_url| to |target_url| and returns true. If no such query
+// component exists, returns false.
+bool ExtractTargetURL(const GURL& restore_session_url, GURL* target_url);
+
+}  // namespace web
+
+#endif  // IOS_WEB_NAVIGATION_WK_BASED_RESTORE_SESSION_UTIL_H_

diff --git a/ios/web/navigation/wk_based_restore_session_util.mm b/ios/web/navigation/wk_based_restore_session_util.mm
new file mode 100644
index 0000000..be5788b6
--- /dev/null
+++ b/ios/web/navigation/wk_based_restore_session_util.mm

@@ -0,0 +1,77 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ios/web/navigation/wk_based_restore_session_util.h"
+
+#include "base/json/json_writer.h"
+#include "base/mac/bundle_locations.h"
+#include "base/strings/sys_string_conversions.h"
+#include "base/values.h"
+#import "ios/web/public/navigation_item.h"
+#include "net/base/url_util.h"
+#include "url/url_constants.h"
+
+namespace web {
+
+const char kRestoreSessionSessionQueryKey[] = "session";
+const char kRestoreSessionTargetUrlQueryKey[] = "targetUrl";
+
+GURL GetRestoreSessionBaseUrl() {
+  std::string restore_session_resource_path = base::SysNSStringToUTF8(
+      [base::mac::FrameworkBundle() pathForResource:@"restore_session"
+                                             ofType:@"html"]);
+  GURL::Replacements replacements;
+  replacements.SetSchemeStr(url::kFileScheme);
+  replacements.SetPathStr(restore_session_resource_path);
+  return GURL(url::kAboutBlankURL).ReplaceComponents(replacements);
+}
+
+GURL CreateRestoreSessionUrl(
+    int last_committed_item_index,
+    const std::vector<std::unique_ptr<NavigationItem>>& items) {
+  DCHECK(last_committed_item_index >= 0 &&
+         last_committed_item_index < static_cast<int>(items.size()));
+
+  // The URLs and titles of the restored entries are stored in two separate
+  // lists instead of a single list of objects to reduce the size of the JSON
+  // string to be included in the query parameter.
+  base::Value restored_urls(base::Value::Type::LIST);
+  base::Value restored_titles(base::Value::Type::LIST);
+  restored_urls.GetList().reserve(items.size());
+  restored_titles.GetList().reserve(items.size());
+  for (size_t index = 0; index < items.size(); index++) {
+    restored_urls.GetList().push_back(
+        base::Value(items[index]->GetURL().spec()));
+    restored_titles.GetList().push_back(base::Value(items[index]->GetTitle()));
+  }
+  base::Value session(base::Value::Type::DICTIONARY);
+  int offset = last_committed_item_index + 1 - items.size();
+  session.SetKey("offset", base::Value(offset));
+  session.SetKey("urls", std::move(restored_urls));
+  session.SetKey("titles", std::move(restored_titles));
+
+  std::string session_json;
+  base::JSONWriter::Write(session, &session_json);
+  return net::AppendQueryParameter(
+      GetRestoreSessionBaseUrl(), kRestoreSessionSessionQueryKey, session_json);
+}
+
+bool IsRestoreSessionUrl(const GURL& url) {
+  return url.SchemeIsFile() && url.path() == GetRestoreSessionBaseUrl().path();
+}
+
+bool ExtractTargetURL(const GURL& restore_session_url, GURL* target_url) {
+  DCHECK(IsRestoreSessionUrl(restore_session_url))
+      << restore_session_url.possibly_invalid_spec()
+      << " is not a restore session URL";
+  std::string target_url_spec;
+  bool success = net::GetValueForKeyInQuery(
+      restore_session_url, kRestoreSessionTargetUrlQueryKey, &target_url_spec);
+  if (success)
+    *target_url = GURL(target_url_spec);
+
+  return success;
+}
+
+}  // namespace web

diff --git a/ios/web/navigation/wk_based_restore_session_util_unittest.mm b/ios/web/navigation/wk_based_restore_session_util_unittest.mm
new file mode 100644
index 0000000..ebc6fd3
--- /dev/null
+++ b/ios/web/navigation/wk_based_restore_session_util_unittest.mm

@@ -0,0 +1,60 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "ios/web/navigation/wk_based_restore_session_util.h"
+
+#include <memory>
+#include <vector>
+
+#include "base/strings/utf_string_conversions.h"
+#import "ios/web/navigation/navigation_item_impl.h"
+#include "net/base/url_util.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "testing/platform_test.h"
+
+namespace web {
+
+typedef PlatformTest WKBasedRestoreSessionUtilTest;
+
+TEST_F(WKBasedRestoreSessionUtilTest, CreateRestoreSessionUrl) {
+  auto item0 = std::make_unique<NavigationItemImpl>();
+  item0->SetURL(GURL("http://www.0.com"));
+  item0->SetTitle(base::ASCIIToUTF16("Test Website 0"));
+  auto item1 = std::make_unique<NavigationItemImpl>();
+  item1->SetURL(GURL("http://www.1.com"));
+
+  std::vector<std::unique_ptr<NavigationItem>> items;
+  items.push_back(std::move(item0));
+  items.push_back(std::move(item1));
+
+  GURL restore_session_url =
+      CreateRestoreSessionUrl(0 /* last_committed_item_index */, items);
+  ASSERT_TRUE(IsRestoreSessionUrl(restore_session_url));
+
+  std::string session_json;
+  net::GetValueForKeyInQuery(restore_session_url,
+                             kRestoreSessionSessionQueryKey, &session_json);
+  EXPECT_EQ(
+      "{\"offset\":-1,\"titles\":[\"Test Website 0\",\"\"],"
+      "\"urls\":[\"http://www.0.com/\",\"http://www.1.com/\"]}",
+      session_json);
+}
+
+TEST_F(WKBasedRestoreSessionUtilTest, IsNotRestoreSessionUrl) {
+  EXPECT_FALSE(IsRestoreSessionUrl(GURL()));
+  EXPECT_FALSE(IsRestoreSessionUrl(GURL("file://somefile")));
+  EXPECT_FALSE(IsRestoreSessionUrl(GURL("http://www.1.com")));
+}
+
+TEST_F(WKBasedRestoreSessionUtilTest, ExtractTargetURL) {
+  GURL target_url = GURL("http://www.1.com?query=special%26chars");
+  GURL url = net::AppendQueryParameter(GetRestoreSessionBaseUrl(),
+                                       kRestoreSessionTargetUrlQueryKey,
+                                       target_url.spec());
+  GURL extracted_url;
+  ASSERT_TRUE(ExtractTargetURL(url, &extracted_url));
+  EXPECT_EQ(target_url, extracted_url);
+}
+
+}  // namespace web

diff --git a/media/capture/video/video_capture_device_unittest.cc b/media/capture/video/video_capture_device_unittest.cc
index c9d9cf4..7ab13dcc 100644
--- a/media/capture/video/video_capture_device_unittest.cc
+++ b/media/capture/video/video_capture_device_unittest.cc

@@ -28,9 +28,11 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if defined(OS_WIN)
+#include <mfcaptureengine.h>
 #include "base/win/scoped_com_initializer.h"
 #include "base/win/windows_version.h"  // For fine-grained suppression.
 #include "media/capture/video/win/video_capture_device_factory_win.h"
+#include "media/capture/video/win/video_capture_device_mf_win.h"
 #endif
 
 #if defined(OS_MACOSX)
@@ -88,9 +90,16 @@
 #define MAYBE_GetPhotoState DISABLED_GetPhotoState
 #endif
 
+// Wrap the TEST_P macro into another one to allow to preprocess |test_name|
+// macros. Needed until https://github.com/google/googletest/issues/389 is
+// fixed.
+#define WRAPPED_TEST_P(test_case_name, test_name) \
+  TEST_P(test_case_name, test_name)
+
 using ::testing::_;
 using ::testing::Invoke;
 using ::testing::SaveArg;
+using ::testing::Return;
 
 namespace media {
 namespace {
@@ -116,6 +125,35 @@
 };
 #endif
 
+enum VideoCaptureImplementationTweak {
+  NONE,
+#if defined(OS_WIN)
+  WIN_MEDIA_FOUNDATION
+#endif
+};
+
+#if defined(OS_WIN)
+class MockMFPhotoCallback final : public IMFCaptureEngineOnSampleCallback {
+ public:
+  ~MockMFPhotoCallback() {}
+
+  MOCK_METHOD2(DoQueryInterface, HRESULT(REFIID, void**));
+  MOCK_METHOD0(DoAddRef, ULONG(void));
+  MOCK_METHOD0(DoRelease, ULONG(void));
+  MOCK_METHOD1(DoOnSample, HRESULT(IMFSample*));
+
+  STDMETHOD(QueryInterface)(REFIID riid, void** object) override {
+    return DoQueryInterface(riid, object);
+  }
+
+  STDMETHOD_(ULONG, AddRef)() override { return DoAddRef(); }
+
+  STDMETHOD_(ULONG, Release)() override { return DoRelease(); }
+
+  STDMETHOD(OnSample)(IMFSample* sample) override { return DoOnSample(sample); }
+};
+#endif
+
 class MockVideoCaptureClient : public VideoCaptureDevice::Client {
  public:
   MOCK_METHOD0(DoReserveOutputBuffer, void(void));
@@ -261,7 +299,19 @@
 
 }  // namespace
 
-class VideoCaptureDeviceTest : public testing::TestWithParam<gfx::Size> {
+class VideoCaptureDeviceTest
+    : public testing::TestWithParam<
+          std::tuple<gfx::Size, VideoCaptureImplementationTweak>> {
+ public:
+#if defined(OS_WIN)
+  scoped_refptr<IMFCaptureEngineOnSampleCallback> CreateMockPhotoCallback(
+      MockMFPhotoCallback* mock_photo_callback,
+      VideoCaptureDevice::TakePhotoCallback callback,
+      VideoCaptureFormat format) {
+    return scoped_refptr<IMFCaptureEngineOnSampleCallback>(mock_photo_callback);
+  }
+#endif
+
  protected:
   typedef VideoCaptureDevice::Client Client;
 
@@ -294,6 +344,10 @@
     static_cast<VideoCaptureDeviceFactoryAndroid*>(
         video_capture_device_factory_.get())
         ->ConfigureForTesting();
+#elif defined(OS_WIN)
+    static_cast<VideoCaptureDeviceFactoryWin*>(
+        video_capture_device_factory_.get())
+        ->set_use_media_foundation_for_testing(UseWinMediaFoundation());
 #endif
     EXPECT_CALL(*video_capture_client_, DoReserveOutputBuffer()).Times(0);
     EXPECT_CALL(*video_capture_client_, DoOnIncomingCapturedBuffer()).Times(0);
@@ -301,6 +355,12 @@
         .Times(0);
   }
 
+#if defined(OS_WIN)
+  bool UseWinMediaFoundation() {
+    return std::get<1>(GetParam()) == WIN_MEDIA_FOUNDATION;
+  }
+#endif
+
   void ResetWithNewClient() {
     video_capture_client_.reset(new MockVideoCaptureClient(base::Bind(
         &VideoCaptureDeviceTest::OnFrameCaptured, base::Unretained(this))));
@@ -407,7 +467,7 @@
 #define MAYBE_OpenInvalidDevice OpenInvalidDevice
 #endif
 // Tries to allocate an invalid device and verifies it doesn't work.
-TEST_F(VideoCaptureDeviceTest, MAYBE_OpenInvalidDevice) {
+WRAPPED_TEST_P(VideoCaptureDeviceTest, MAYBE_OpenInvalidDevice) {
   VideoCaptureDeviceDescriptor invalid_descriptor;
   invalid_descriptor.device_id = "jibberish";
   invalid_descriptor.display_name = "jibberish";
@@ -439,12 +499,12 @@
 }
 
 // Allocates the first enumerated device, and expects a frame.
-TEST_P(VideoCaptureDeviceTest, CaptureWithSize) {
+WRAPPED_TEST_P(VideoCaptureDeviceTest, CaptureWithSize) {
   const auto descriptor = FindUsableDeviceDescriptor();
   if (!descriptor)
     return;
 
-  const gfx::Size& size = GetParam();
+  const gfx::Size& size = std::get<0>(GetParam());
   if (!IsCaptureSizeSupported(*descriptor, size))
     return;
   const int width = size.width();
@@ -474,14 +534,22 @@
 }
 
 const gfx::Size kCaptureSizes[] = {gfx::Size(640, 480), gfx::Size(1280, 720)};
+const VideoCaptureImplementationTweak kCaptureImplementationTweaks[] = {
+    NONE,
+#if defined(OS_WIN)
+    WIN_MEDIA_FOUNDATION
+#endif
+};
 
-INSTANTIATE_TEST_CASE_P(VideoCaptureDeviceTests,
-                        VideoCaptureDeviceTest,
-                        testing::ValuesIn(kCaptureSizes));
+INSTANTIATE_TEST_CASE_P(
+    VideoCaptureDeviceTests,
+    VideoCaptureDeviceTest,
+    testing::Combine(testing::ValuesIn(kCaptureSizes),
+                     testing::ValuesIn(kCaptureImplementationTweaks)));
 
 // Allocates a device with an uncommon resolution and verifies frames are
 // captured in a close, much more typical one.
-TEST_F(VideoCaptureDeviceTest, MAYBE_AllocateBadSize) {
+WRAPPED_TEST_P(VideoCaptureDeviceTest, MAYBE_AllocateBadSize) {
   const auto descriptor = FindUsableDeviceDescriptor();
   if (!descriptor)
     return;
@@ -508,7 +576,7 @@
 }
 
 // Cause hangs on Windows, Linux. Fails Android. https://crbug.com/417824
-TEST_F(VideoCaptureDeviceTest, DISABLED_ReAllocateCamera) {
+WRAPPED_TEST_P(VideoCaptureDeviceTest, DISABLED_ReAllocateCamera) {
   const auto descriptor = FindUsableDeviceDescriptor();
   if (!descriptor)
     return;
@@ -552,7 +620,7 @@
 }
 
 // Starts the camera in 720p to try and capture MJPEG format.
-TEST_F(VideoCaptureDeviceTest, MAYBE_CaptureMjpeg) {
+WRAPPED_TEST_P(VideoCaptureDeviceTest, MAYBE_CaptureMjpeg) {
   std::unique_ptr<VideoCaptureDeviceDescriptor> device_descriptor =
       GetFirstDeviceDescriptorSupportingPixelFormat(PIXEL_FORMAT_MJPEG);
   if (!device_descriptor) {
@@ -589,7 +657,7 @@
   device->StopAndDeAllocate();
 }
 
-TEST_F(VideoCaptureDeviceTest, NoCameraSupportsPixelFormatMax) {
+WRAPPED_TEST_P(VideoCaptureDeviceTest, NoCameraSupportsPixelFormatMax) {
   // Use PIXEL_FORMAT_MAX to iterate all device names for testing
   // GetDeviceSupportedFormats().
   std::unique_ptr<VideoCaptureDeviceDescriptor> device_descriptor =
@@ -601,7 +669,7 @@
 
 // Starts the camera and verifies that a photo can be taken. The correctness of
 // the photo is enforced by MockImageCaptureClient.
-TEST_F(VideoCaptureDeviceTest, MAYBE_TakePhoto) {
+WRAPPED_TEST_P(VideoCaptureDeviceTest, MAYBE_TakePhoto) {
   const auto descriptor = FindUsableDeviceDescriptor();
   if (!descriptor)
     return;
@@ -650,7 +718,7 @@
 }
 
 // Starts the camera and verifies that the photo capabilities can be retrieved.
-TEST_F(VideoCaptureDeviceTest, MAYBE_GetPhotoState) {
+WRAPPED_TEST_P(VideoCaptureDeviceTest, MAYBE_GetPhotoState) {
   const auto descriptor = FindUsableDeviceDescriptor();
   if (!descriptor)
     return;
@@ -701,4 +769,64 @@
   device->StopAndDeAllocate();
 }
 
+#if defined(OS_WIN)
+// Verifies that the photo callback is correctly released by MediaFoundation
+WRAPPED_TEST_P(VideoCaptureDeviceTest, CheckPhotoCallbackRelease) {
+  if (!UseWinMediaFoundation())
+    return;
+
+  std::unique_ptr<VideoCaptureDeviceDescriptor> descriptor =
+      GetFirstDeviceDescriptorSupportingPixelFormat(PIXEL_FORMAT_MJPEG);
+  if (!descriptor) {
+    DVLOG(1) << "No usable media foundation device descriptor. Exiting test.";
+    return;
+  }
+
+  EXPECT_CALL(*video_capture_client_, OnError(_, _)).Times(0);
+  EXPECT_CALL(*video_capture_client_, OnStarted());
+
+  std::unique_ptr<VideoCaptureDevice> device(
+      video_capture_device_factory_->CreateDevice(*descriptor));
+  ASSERT_TRUE(device);
+
+  VideoCaptureParams capture_params;
+  capture_params.requested_format.frame_size.SetSize(320, 240);
+  capture_params.requested_format.frame_rate = 30;
+  capture_params.requested_format.pixel_format = PIXEL_FORMAT_MJPEG;
+  device->AllocateAndStart(capture_params, std::move(video_capture_client_));
+
+  if (!static_cast<VideoCaptureDeviceMFWin*>(device.get())
+           ->get_use_photo_stream_to_take_photo_for_testing()) {
+    DVLOG(1) << "The device is not using the MediaFoundation photo callback. "
+                "Exiting test.";
+    device->StopAndDeAllocate();
+    return;
+  }
+
+  MockMFPhotoCallback* callback = new MockMFPhotoCallback();
+  EXPECT_CALL(*callback, DoQueryInterface(_, _)).WillRepeatedly(Return(S_OK));
+  EXPECT_CALL(*callback, DoAddRef()).WillOnce(Return(1U));
+  EXPECT_CALL(*callback, DoRelease()).WillOnce(Return(1U));
+  EXPECT_CALL(*callback, DoOnSample(_)).WillOnce(Return(S_OK));
+  static_cast<VideoCaptureDeviceMFWin*>(device.get())
+      ->set_create_mf_photo_callback_for_testing(
+          base::BindRepeating(&VideoCaptureDeviceTest::CreateMockPhotoCallback,
+                              base::Unretained(this), callback));
+
+  VideoCaptureDevice::TakePhotoCallback scoped_callback = base::BindOnce(
+      &MockImageCaptureClient::DoOnPhotoTaken, image_capture_client_);
+
+  base::RunLoop run_loop;
+  base::RepeatingClosure quit_closure =
+      BindToCurrentLoop(run_loop.QuitClosure());
+  EXPECT_CALL(*image_capture_client_.get(), OnCorrectPhotoTaken())
+      .WillOnce(RunClosure(quit_closure));
+
+  device->TakePhoto(std::move(scoped_callback));
+  run_loop.Run();
+
+  device->StopAndDeAllocate();
+}
+#endif
+
 };  // namespace media

diff --git a/media/capture/video/win/video_capture_device_factory_win.cc b/media/capture/video/win/video_capture_device_factory_win.cc
index fec2ed9..8f6168f 100644
--- a/media/capture/video/win/video_capture_device_factory_win.cc
+++ b/media/capture/video/win/video_capture_device_factory_win.cc

@@ -69,10 +69,9 @@
 
 static bool LoadMediaFoundationDlls() {
   static const wchar_t* const kMfDLLs[] = {
-      L"%WINDIR%\\system32\\mf.dll",
-      L"%WINDIR%\\system32\\mfplat.dll",
+      L"%WINDIR%\\system32\\mf.dll", L"%WINDIR%\\system32\\mfplat.dll",
       L"%WINDIR%\\system32\\mfreadwrite.dll",
-  };
+      L"%WINDIR%\\system32\\MFCaptureEngine.dll"};
 
   for (const wchar_t* kMfDLL : kMfDLLs) {
     wchar_t path[MAX_PATH] = {0};
@@ -86,8 +85,13 @@
 static bool PrepareVideoCaptureAttributesMediaFoundation(
     IMFAttributes** attributes,
     int count) {
-  if (!InitializeMediaFoundation())
+  // Once https://bugs.chromium.org/p/chromium/issues/detail?id=791615 is fixed,
+  // we must make sure that this method succeeds in capture_unittests context
+  // when MediaFoundation is enabled.
+  if (!VideoCaptureDeviceFactoryWin::PlatformSupportsMediaFoundation() ||
+      !InitializeMediaFoundation()) {
     return false;
+  }
 
   if (FAILED(MFCreateAttributes(attributes, count)))
     return false;
@@ -286,8 +290,9 @@
 
   DWORD stream_index = 0;
   ComPtr<IMFMediaType> type;
-  while (SUCCEEDED(reader->GetNativeMediaType(kFirstVideoStream, stream_index,
-                                              type.GetAddressOf()))) {
+  while (SUCCEEDED(hr = reader->GetNativeMediaType(
+                       static_cast<DWORD>(MF_SOURCE_READER_FIRST_VIDEO_STREAM),
+                       stream_index, type.GetAddressOf()))) {
     UINT32 width, height;
     hr = MFGetAttributeSize(type.Get(), MF_MT_FRAME_SIZE, &width, &height);
     if (FAILED(hr)) {

diff --git a/media/capture/video/win/video_capture_device_factory_win.h b/media/capture/video/win/video_capture_device_factory_win.h
index 9afcc64..a7d36783 100644
--- a/media/capture/video/win/video_capture_device_factory_win.h
+++ b/media/capture/video/win/video_capture_device_factory_win.h

@@ -30,10 +30,12 @@
       const VideoCaptureDeviceDescriptor& device_descriptor,
       VideoCaptureFormats* supported_formats) override;
 
+  void set_use_media_foundation_for_testing(bool use) {
+    use_media_foundation_ = use;
+  }
+
  private:
-  // Media Foundation is available in Win7 and later, use it if explicitly
-  // forced via flag, else use DirectShow.
-  const bool use_media_foundation_;
+  bool use_media_foundation_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoCaptureDeviceFactoryWin);
 };

diff --git a/media/capture/video/win/video_capture_device_mf_win.cc b/media/capture/video/win/video_capture_device_mf_win.cc
index 73a144b..2161651 100644
--- a/media/capture/video/win/video_capture_device_mf_win.cc
+++ b/media/capture/video/win/video_capture_device_mf_win.cc

@@ -7,7 +7,9 @@
 #include <mfapi.h>
 #include <mferror.h>
 #include <stddef.h>
+#include <wincodec.h>
 
+#include <thread>
 #include <utility>
 
 #include "base/location.h"
@@ -17,14 +19,102 @@
 #include "base/synchronization/waitable_event.h"
 #include "base/win/scoped_co_mem.h"
 #include "base/win/windows_version.h"
+#include "media/capture/video/blob_utils.h"
 #include "media/capture/video/win/capability_list_win.h"
 #include "media/capture/video/win/sink_filter_win.h"
 
 using base::win::ScopedCoMem;
+using Microsoft::WRL::ComPtr;
+using base::Location;
 
 namespace media {
 
-static bool GetFrameSize(IMFMediaType* type, gfx::Size* frame_size) {
+namespace {
+class MFPhotoCallback final
+    : public base::RefCountedThreadSafe<MFPhotoCallback>,
+      public IMFCaptureEngineOnSampleCallback {
+ public:
+  MFPhotoCallback(VideoCaptureDevice::TakePhotoCallback callback,
+                  VideoCaptureFormat format)
+      : callback_(std::move(callback)), format_(format) {}
+
+  STDMETHOD(QueryInterface)(REFIID riid, void** object) override {
+    if (riid == IID_IUnknown || riid == IID_IMFCaptureEngineOnSampleCallback) {
+      AddRef();
+      *object = static_cast<IMFCaptureEngineOnSampleCallback*>(this);
+      return S_OK;
+    }
+    return E_NOINTERFACE;
+  }
+
+  STDMETHOD_(ULONG, AddRef)() override {
+    base::RefCountedThreadSafe<MFPhotoCallback>::AddRef();
+    return 1U;
+  }
+
+  STDMETHOD_(ULONG, Release)() override {
+    base::RefCountedThreadSafe<MFPhotoCallback>::Release();
+    return 1U;
+  }
+
+  STDMETHOD(OnSample)(IMFSample* sample) override {
+    if (!sample)
+      return S_OK;
+
+    DWORD buffer_count = 0;
+    sample->GetBufferCount(&buffer_count);
+
+    for (DWORD i = 0; i < buffer_count; ++i) {
+      ComPtr<IMFMediaBuffer> buffer;
+      sample->GetBufferByIndex(i, buffer.GetAddressOf());
+      if (!buffer)
+        continue;
+
+      BYTE* data = nullptr;
+      DWORD max_length = 0;
+      DWORD length = 0;
+      buffer->Lock(&data, &max_length, &length);
+      mojom::BlobPtr blob = Blobify(data, length, format_);
+      buffer->Unlock();
+      if (blob) {
+        std::move(callback_).Run(std::move(blob));
+        // What is it supposed to mean if there is more than one buffer sent to
+        // us as a response to requesting a single still image? Are we supposed
+        // to somehow concatenate the buffers? Or is it safe to ignore extra
+        // buffers? For now, we ignore extra buffers.
+        break;
+      }
+    }
+    return S_OK;
+  }
+
+ private:
+  friend class base::RefCountedThreadSafe<MFPhotoCallback>;
+  ~MFPhotoCallback() = default;
+
+  VideoCaptureDevice::TakePhotoCallback callback_;
+  const VideoCaptureFormat format_;
+
+  DISALLOW_COPY_AND_ASSIGN(MFPhotoCallback);
+};
+
+scoped_refptr<IMFCaptureEngineOnSampleCallback> CreateMFPhotoCallback(
+    VideoCaptureDevice::TakePhotoCallback callback,
+    VideoCaptureFormat format) {
+  return scoped_refptr<IMFCaptureEngineOnSampleCallback>(
+      new MFPhotoCallback(std::move(callback), format));
+}
+}  // namespace
+
+void LogError(const Location& from_here, HRESULT hr) {
+#if !defined(NDEBUG)
+  DPLOG(ERROR) << from_here.ToString()
+               << " hr = " << logging::SystemErrorCodeToString(hr);
+#endif
+}
+
+static bool GetFrameSizeFromMediaType(IMFMediaType* type,
+                                      gfx::Size* frame_size) {
   UINT32 width32, height32;
   if (FAILED(MFGetAttributeSize(type, MF_MT_FRAME_SIZE, &width32, &height32)))
     return false;
@@ -32,7 +122,7 @@
   return true;
 }
 
-static bool GetFrameRate(IMFMediaType* type, float* frame_rate) {
+static bool GetFrameRateFromMediaType(IMFMediaType* type, float* frame_rate) {
   UINT32 numerator, denominator;
   if (FAILED(MFGetAttributeRatio(type, MF_MT_FRAME_RATE, &numerator,
                                  &denominator)) ||
@@ -43,12 +133,20 @@
   return true;
 }
 
-static bool FillFormat(IMFMediaType* type, VideoCaptureFormat* format) {
-  GUID type_guid;
-  if (FAILED(type->GetGUID(MF_MT_SUBTYPE, &type_guid)) ||
-      !GetFrameSize(type, &format->frame_size) ||
-      !GetFrameRate(type, &format->frame_rate) ||
-      !VideoCaptureDeviceMFWin::FormatFromGuid(type_guid,
+static bool GetFormatFromMediaType(IMFMediaType* type,
+                                   bool photo,
+                                   VideoCaptureFormat* format) {
+  GUID major_type_guid;
+  if (FAILED(type->GetGUID(MF_MT_MAJOR_TYPE, &major_type_guid)) ||
+      (major_type_guid != MFMediaType_Image &&
+       (photo || !GetFrameRateFromMediaType(type, &format->frame_rate)))) {
+    return false;
+  }
+
+  GUID sub_type_guid;
+  if (FAILED(type->GetGUID(MF_MT_SUBTYPE, &sub_type_guid)) ||
+      !GetFrameSizeFromMediaType(type, &format->frame_size) ||
+      !VideoCaptureDeviceMFWin::FormatFromGuid(sub_type_guid,
                                                &format->pixel_format)) {
     return false;
   }
@@ -56,60 +154,149 @@
   return true;
 }
 
-HRESULT FillCapabilities(IMFSourceReader* source,
-                         CapabilityList* capabilities) {
-  DWORD stream_index = 0;
-  Microsoft::WRL::ComPtr<IMFMediaType> type;
-  HRESULT hr;
-  while (SUCCEEDED(hr = source->GetNativeMediaType(
-                       kFirstVideoStream, stream_index, type.GetAddressOf()))) {
-    VideoCaptureFormat format;
-    if (FillFormat(type.Get(), &format))
-      capabilities->emplace_back(stream_index, format);
-    type.Reset();
-    ++stream_index;
-  }
+static HRESULT CopyAttribute(IMFAttributes* source_attributes,
+                             IMFAttributes* destination_attributes,
+                             const GUID& key) {
+  PROPVARIANT var;
+  PropVariantInit(&var);
+  HRESULT hr = source_attributes->GetItem(key, &var);
+  if (FAILED(hr))
+    return hr;
 
-  if (capabilities->empty() && (SUCCEEDED(hr) || hr == MF_E_NO_MORE_TYPES))
-    hr = HRESULT_FROM_WIN32(ERROR_EMPTY);
+  hr = destination_attributes->SetItem(key, var);
+  PropVariantClear(&var);
+  return hr;
+}
+
+static HRESULT ConvertToPhotoJpegMediaType(
+    IMFMediaType* source_media_type,
+    IMFMediaType* destination_media_type) {
+  HRESULT hr =
+      destination_media_type->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Image);
+  if (FAILED(hr))
+    return hr;
+
+  hr = destination_media_type->SetGUID(MF_MT_SUBTYPE, GUID_ContainerFormatJpeg);
+  if (FAILED(hr))
+    return hr;
+
+  return CopyAttribute(source_media_type, destination_media_type,
+                       MF_MT_FRAME_SIZE);
+}
+
+static const CapabilityWin& GetBestMatchedPhotoCapability(
+    ComPtr<IMFMediaType> current_media_type,
+    gfx::Size requested_size,
+    const CapabilityList& capabilities) {
+  gfx::Size current_size;
+  GetFrameSizeFromMediaType(current_media_type.Get(), &current_size);
+
+  int requested_height = requested_size.height() > 0 ? requested_size.height()
+                                                     : current_size.height();
+  int requested_width = requested_size.width() > 0 ? requested_size.width()
+                                                   : current_size.width();
+
+  const CapabilityWin* best_match = &(*capabilities.begin());
+  for (const CapabilityWin& capability : capabilities) {
+    int height = capability.supported_format.frame_size.height();
+    int width = capability.supported_format.frame_size.width();
+    int best_height = best_match->supported_format.frame_size.height();
+    int best_width = best_match->supported_format.frame_size.width();
+
+    if (std::abs(height - requested_height) <= std::abs(height - best_height) &&
+        std::abs(width - requested_width) <= std::abs(width - best_width)) {
+      best_match = &capability;
+    }
+  }
+  return *best_match;
+}
+
+HRESULT GetAvailableDeviceMediaType(IMFCaptureSource* source,
+                                    DWORD stream_index,
+                                    DWORD media_type_index,
+                                    IMFMediaType** type) {
+  HRESULT hr;
+  // Rarely, for some unknown reason, GetAvailableDeviceMediaType returns an
+  // undocumented MF_E_INVALIDREQUEST. Retrying solves the issue.
+  int retry_count = 0;
+  do {
+    hr = source->GetAvailableDeviceMediaType(stream_index, media_type_index,
+                                             type);
+    if (FAILED(hr))
+      base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(50));
+
+    // Give up after ~10 seconds
+  } while (hr == MF_E_INVALIDREQUEST && retry_count++ < 200);
+
+  return hr;
+}
+
+HRESULT FillCapabilities(DWORD stream,
+                         IMFCaptureSource* source,
+                         bool photo,
+                         CapabilityList* capabilities) {
+  DWORD media_type_index = 0;
+  ComPtr<IMFMediaType> type;
+  HRESULT hr;
+
+  while (
+      SUCCEEDED(hr = GetAvailableDeviceMediaType(
+                    source, stream, media_type_index, type.GetAddressOf()))) {
+    VideoCaptureFormat format;
+    if (GetFormatFromMediaType(type.Get(), photo, &format))
+      capabilities->emplace_back(media_type_index, format);
+    type.Reset();
+    ++media_type_index;
+  }
 
   return (hr == MF_E_NO_MORE_TYPES) ? S_OK : hr;
 }
 
-class MFReaderCallback final
-    : public base::RefCountedThreadSafe<MFReaderCallback>,
-      public IMFSourceReaderCallback {
+class MFVideoCallback final
+    : public base::RefCountedThreadSafe<MFVideoCallback>,
+      public IMFCaptureEngineOnSampleCallback,
+      public IMFCaptureEngineOnEventCallback {
  public:
-  MFReaderCallback(VideoCaptureDeviceMFWin* observer)
-      : observer_(observer), wait_event_(NULL) {}
-
-  void SetSignalOnFlush(base::WaitableEvent* event) { wait_event_ = event; }
+  MFVideoCallback(VideoCaptureDeviceMFWin* observer) : observer_(observer) {}
 
   STDMETHOD(QueryInterface)(REFIID riid, void** object) override {
-    if (riid != IID_IUnknown && riid != IID_IMFSourceReaderCallback)
-      return E_NOINTERFACE;
-    *object = static_cast<IMFSourceReaderCallback*>(this);
-    AddRef();
-    return S_OK;
+    HRESULT hr = E_NOINTERFACE;
+    if (riid == IID_IUnknown) {
+      *object = this;
+      hr = S_OK;
+    } else if (riid == IID_IMFCaptureEngineOnSampleCallback) {
+      *object = static_cast<IMFCaptureEngineOnSampleCallback*>(this);
+      hr = S_OK;
+    } else if (riid == IID_IMFCaptureEngineOnEventCallback) {
+      *object = static_cast<IMFCaptureEngineOnEventCallback*>(this);
+      hr = S_OK;
+    }
+    if (SUCCEEDED(hr))
+      AddRef();
+
+    return hr;
   }
 
   STDMETHOD_(ULONG, AddRef)() override {
-    base::RefCountedThreadSafe<MFReaderCallback>::AddRef();
+    base::RefCountedThreadSafe<MFVideoCallback>::AddRef();
     return 1U;
   }
 
   STDMETHOD_(ULONG, Release)() override {
-    base::RefCountedThreadSafe<MFReaderCallback>::Release();
+    base::RefCountedThreadSafe<MFVideoCallback>::Release();
     return 1U;
   }
 
-  STDMETHOD(OnReadSample)
-  (HRESULT status,
-   DWORD stream_index,
-   DWORD stream_flags,
-   LONGLONG raw_time_stamp,
-   IMFSample* sample) override {
+  STDMETHOD(OnEvent)(IMFMediaEvent* media_event) override {
+    observer_->OnEvent(media_event);
+    return S_OK;
+  }
+
+  STDMETHOD(OnSample)(IMFSample* sample) override {
     base::TimeTicks reference_time(base::TimeTicks::Now());
+
+    LONGLONG raw_time_stamp = 0;
+    sample->GetSampleTime(&raw_time_stamp);
     base::TimeDelta timestamp =
         base::TimeDelta::FromMicroseconds(raw_time_stamp / 10);
     if (!sample) {
@@ -121,9 +308,9 @@
     sample->GetBufferCount(&count);
 
     for (DWORD i = 0; i < count; ++i) {
-      Microsoft::WRL::ComPtr<IMFMediaBuffer> buffer;
+      ComPtr<IMFMediaBuffer> buffer;
       sample->GetBufferByIndex(i, buffer.GetAddressOf());
-      if (buffer.Get()) {
+      if (buffer) {
         DWORD length = 0, max_length = 0;
         BYTE* data = NULL;
         buffer->Lock(&data, &max_length, &length);
@@ -135,25 +322,10 @@
     return S_OK;
   }
 
-  STDMETHOD(OnFlush)(DWORD stream_index) override {
-    if (wait_event_) {
-      wait_event_->Signal();
-      wait_event_ = NULL;
-    }
-    return S_OK;
-  }
-
-  STDMETHOD(OnEvent)(DWORD stream_index, IMFMediaEvent* event) override {
-    NOTIMPLEMENTED();
-    return S_OK;
-  }
-
  private:
-  friend class base::RefCountedThreadSafe<MFReaderCallback>;
-  ~MFReaderCallback() {}
-
+  friend class base::RefCountedThreadSafe<MFVideoCallback>;
+  ~MFVideoCallback() {}
   VideoCaptureDeviceMFWin* observer_;
-  base::WaitableEvent* wait_event_;
 };
 
 // static
@@ -169,6 +341,7 @@
       {MFVideoFormat_RGB24, PIXEL_FORMAT_RGB24},
       {MFVideoFormat_ARGB32, PIXEL_FORMAT_ARGB},
       {MFVideoFormat_MJPG, PIXEL_FORMAT_MJPEG},
+      {GUID_ContainerFormatJpeg, PIXEL_FORMAT_MJPEG},
       {MFVideoFormat_YV12, PIXEL_FORMAT_YV12},
       {kMediaSubTypeY16, PIXEL_FORMAT_Y16},
       {kMediaSubTypeZ16, PIXEL_FORMAT_Y16},
@@ -187,7 +360,14 @@
 
 VideoCaptureDeviceMFWin::VideoCaptureDeviceMFWin(
     const VideoCaptureDeviceDescriptor& device_descriptor)
-    : descriptor_(device_descriptor), capture_(0) {
+    : descriptor_(device_descriptor),
+      create_mf_photo_callback_(base::BindRepeating(&CreateMFPhotoCallback)),
+      is_started_(false),
+      video_stream_index_(static_cast<DWORD>(
+          MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_VIDEO_PREVIEW)),
+      photo_stream_index_(static_cast<DWORD>(
+          MF_CAPTURE_ENGINE_PREFERRED_SOURCE_STREAM_FOR_PHOTO)),
+      use_photo_stream_to_take_photo_(false) {
   DETACH_FROM_SEQUENCE(sequence_checker_);
 }
 
@@ -195,20 +375,44 @@
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
 }
 
-bool VideoCaptureDeviceMFWin::Init(
-    const Microsoft::WRL::ComPtr<IMFMediaSource>& source) {
+bool VideoCaptureDeviceMFWin::Init(const ComPtr<IMFMediaSource>& source) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  DCHECK(!reader_.Get());
+  DCHECK(!engine_);
 
-  Microsoft::WRL::ComPtr<IMFAttributes> attributes;
+  HRESULT hr = S_OK;
+  ComPtr<IMFAttributes> attributes;
+  ComPtr<IMFCaptureEngineClassFactory> capture_engine_class_factory;
   MFCreateAttributes(attributes.GetAddressOf(), 1);
-  DCHECK(attributes.Get());
+  DCHECK(attributes);
 
-  callback_ = new MFReaderCallback(this);
-  attributes->SetUnknown(MF_SOURCE_READER_ASYNC_CALLBACK, callback_.get());
+  hr = CoCreateInstance(
+      CLSID_MFCaptureEngineClassFactory, NULL, CLSCTX_INPROC_SERVER,
+      IID_PPV_ARGS(capture_engine_class_factory.GetAddressOf()));
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return false;
+  }
+  hr = capture_engine_class_factory->CreateInstance(
+      CLSID_MFCaptureEngine, IID_PPV_ARGS(engine_.GetAddressOf()));
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return false;
+  }
 
-  return SUCCEEDED(MFCreateSourceReaderFromMediaSource(
-      source.Get(), attributes.Get(), reader_.GetAddressOf()));
+  video_callback_ = new MFVideoCallback(this);
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return false;
+  }
+
+  hr = engine_->Initialize(video_callback_.get(), attributes.Get(), nullptr,
+                           source.Get());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return false;
+  }
+
+  return true;
 }
 
 void VideoCaptureDeviceMFWin::AllocateAndStart(
@@ -219,65 +423,350 @@
   base::AutoLock lock(lock_);
 
   client_ = std::move(client);
-  DCHECK_EQ(capture_, false);
+  DCHECK_EQ(false, is_started_);
 
-  CapabilityList capabilities;
-  HRESULT hr = S_OK;
-  if (reader_.Get()) {
-    hr = FillCapabilities(reader_.Get(), &capabilities);
-    if (SUCCEEDED(hr)) {
-      const CapabilityWin found_capability =
-          GetBestMatchedCapability(params.requested_format, capabilities);
-      Microsoft::WRL::ComPtr<IMFMediaType> type;
-      hr = reader_->GetNativeMediaType(kFirstVideoStream,
-                                       found_capability.stream_index,
-                                       type.GetAddressOf());
-      if (SUCCEEDED(hr)) {
-        hr = reader_->SetCurrentMediaType(kFirstVideoStream, NULL, type.Get());
-        if (SUCCEEDED(hr)) {
-          hr =
-              reader_->ReadSample(kFirstVideoStream, 0, NULL, NULL, NULL, NULL);
-          if (SUCCEEDED(hr)) {
-            capture_format_ = found_capability.supported_format;
-            client_->OnStarted();
-            capture_ = true;
-            return;
-          }
-        }
-      }
-    }
+  if (!engine_) {
+    OnError(FROM_HERE, E_FAIL);
+    return;
   }
 
-  OnError(FROM_HERE, hr);
+  ComPtr<IMFCaptureSource> source;
+  HRESULT hr = engine_->GetSource(source.GetAddressOf());
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  DWORD stream_count = 0;
+  source->GetDeviceStreamCount(&stream_count);
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  // In some situations, stream 0 is the only one. (i.e. Logitech HD Pro Webcam
+  // C920 on Windows 2012 R2)
+  if (stream_count < 2) {
+    video_stream_index_ = 0;
+    photo_stream_index_ = 0;
+  }
+
+  CapabilityList photo_capabilities;
+  hr = FillCapabilities(photo_stream_index_, source.Get(), true,
+                        &photo_capabilities);
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+  use_photo_stream_to_take_photo_ = !photo_capabilities.empty();
+
+  CapabilityList video_capabilities;
+  hr = FillCapabilities(video_stream_index_, source.Get(), false,
+                        &video_capabilities);
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  const CapabilityWin found_capability =
+      GetBestMatchedCapability(params.requested_format, video_capabilities);
+  ComPtr<IMFMediaType> type;
+  hr = GetAvailableDeviceMediaType(source.Get(), video_stream_index_,
+                                   found_capability.stream_index,
+                                   type.GetAddressOf());
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  hr = source->SetCurrentDeviceMediaType(video_stream_index_, type.Get());
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  ComPtr<IMFCaptureSink> sink;
+  hr = engine_->GetSink(MF_CAPTURE_ENGINE_SINK_TYPE_PREVIEW,
+                        sink.GetAddressOf());
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  ComPtr<IMFCapturePreviewSink> preview_sink;
+  hr = sink->QueryInterface(IID_PPV_ARGS(preview_sink.GetAddressOf()));
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  hr = preview_sink->RemoveAllStreams();
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  DWORD dw_sink_stream_index = 0;
+  hr = preview_sink->AddStream(video_stream_index_, type.Get(), NULL,
+                               &dw_sink_stream_index);
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  hr = preview_sink->SetSampleCallback(dw_sink_stream_index,
+                                       video_callback_.get());
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  hr = engine_->StartPreview();
+  if (FAILED(hr)) {
+    OnError(FROM_HERE, hr);
+    return;
+  }
+
+  capture_video_format_ = found_capability.supported_format;
+  client_->OnStarted();
+  is_started_ = true;
 }
 
 void VideoCaptureDeviceMFWin::StopAndDeAllocate() {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  base::WaitableEvent flushed(base::WaitableEvent::ResetPolicy::AUTOMATIC,
-                              base::WaitableEvent::InitialState::NOT_SIGNALED);
-  const int kFlushTimeOutInMs = 1000;
-  bool wait = false;
-  {
-    base::AutoLock lock(lock_);
-    if (capture_) {
-      capture_ = false;
-      callback_->SetSignalOnFlush(&flushed);
-      wait = SUCCEEDED(
-          reader_->Flush(static_cast<DWORD>(MF_SOURCE_READER_ALL_STREAMS)));
-      if (!wait) {
-        callback_->SetSignalOnFlush(NULL);
-      }
-    }
-    client_.reset();
+  base::AutoLock lock(lock_);
+
+  if (is_started_ && engine_)
+    engine_->StopPreview();
+  is_started_ = false;
+
+  client_.reset();
+}
+
+void VideoCaptureDeviceMFWin::TakePhoto(TakePhotoCallback callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+  base::AutoLock lock(lock_);
+
+  if (!is_started_)
+    return;
+
+  if (!use_photo_stream_to_take_photo_) {
+    video_stream_take_photo_callbacks_.push(std::move(callback));
+    return;
   }
 
-  // If the device has been unplugged, the Flush() won't trigger the event
-  // and a timeout will happen.
-  // TODO(tommi): Hook up the IMFMediaEventGenerator notifications API and
-  // do not wait at all after getting MEVideoCaptureDeviceRemoved event.
-  // See issue/226396.
-  if (wait)
-    flushed.TimedWait(base::TimeDelta::FromMilliseconds(kFlushTimeOutInMs));
+  ComPtr<IMFCaptureSource> source;
+  HRESULT hr = engine_->GetSource(source.GetAddressOf());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  ComPtr<IMFMediaType> current_media_type;
+  hr = source->GetCurrentDeviceMediaType(photo_stream_index_,
+                                         current_media_type.GetAddressOf());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  ComPtr<IMFMediaType> photo_media_type;
+  hr = MFCreateMediaType(photo_media_type.GetAddressOf());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  hr = ConvertToPhotoJpegMediaType(current_media_type.Get(),
+                                   photo_media_type.Get());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  hr = source->SetCurrentDeviceMediaType(photo_stream_index_,
+                                         photo_media_type.Get());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  VideoCaptureFormat format;
+  hr = GetFormatFromMediaType(photo_media_type.Get(), true, &format) ? S_OK
+                                                                     : E_FAIL;
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  ComPtr<IMFCaptureSink> sink;
+  hr = engine_->GetSink(MF_CAPTURE_ENGINE_SINK_TYPE_PHOTO, sink.GetAddressOf());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  ComPtr<IMFCapturePhotoSink> photo_sink;
+  hr = sink->QueryInterface(IID_PPV_ARGS(photo_sink.GetAddressOf()));
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  hr = photo_sink->RemoveAllStreams();
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  DWORD dw_sink_stream_index = 0;
+  hr = photo_sink->AddStream(photo_stream_index_, photo_media_type.Get(), NULL,
+                             &dw_sink_stream_index);
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  scoped_refptr<IMFCaptureEngineOnSampleCallback> photo_callback =
+      create_mf_photo_callback_.Run(std::move(callback), format);
+  hr = photo_sink->SetSampleCallback(photo_callback.get());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  hr = engine_->TakePhoto();
+  if (FAILED(hr))
+    LogError(FROM_HERE, hr);
+}
+
+void VideoCaptureDeviceMFWin::GetPhotoState(GetPhotoStateCallback callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  if (!is_started_)
+    return;
+
+  ComPtr<IMFCaptureSource> source;
+  HRESULT hr = engine_->GetSource(source.GetAddressOf());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  CapabilityList capabilities;
+  if (use_photo_stream_to_take_photo_)
+    hr = FillCapabilities(photo_stream_index_, source.Get(), true,
+                          &capabilities);
+
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  ComPtr<IMFMediaType> current_media_type;
+  hr = source->GetCurrentDeviceMediaType(use_photo_stream_to_take_photo_
+                                             ? photo_stream_index_
+                                             : video_stream_index_,
+                                         current_media_type.GetAddressOf());
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  auto photo_capabilities = mojom::PhotoState::New();
+  gfx::Size current_size;
+  GetFrameSizeFromMediaType(current_media_type.Get(), &current_size);
+
+  gfx::Size min_size = gfx::Size(current_size.width(), current_size.height());
+  gfx::Size max_size = gfx::Size(current_size.width(), current_size.height());
+  for (const CapabilityWin& capability : capabilities) {
+    min_size.SetToMin(capability.supported_format.frame_size);
+    max_size.SetToMax(capability.supported_format.frame_size);
+  }
+
+  photo_capabilities->height = mojom::Range::New(
+      max_size.height(), min_size.height(), current_size.height(), 1);
+  photo_capabilities->width = mojom::Range::New(
+      max_size.width(), min_size.width(), current_size.width(), 1);
+
+  photo_capabilities->exposure_compensation = mojom::Range::New();
+  photo_capabilities->color_temperature = mojom::Range::New();
+  photo_capabilities->iso = mojom::Range::New();
+  photo_capabilities->brightness = mojom::Range::New();
+  photo_capabilities->contrast = mojom::Range::New();
+  photo_capabilities->saturation = mojom::Range::New();
+  photo_capabilities->sharpness = mojom::Range::New();
+  photo_capabilities->zoom = mojom::Range::New();
+  photo_capabilities->red_eye_reduction = mojom::RedEyeReduction::NEVER;
+
+  photo_capabilities->torch = false;
+  std::move(callback).Run(std::move(photo_capabilities));
+}
+
+void VideoCaptureDeviceMFWin::SetPhotoOptions(
+    mojom::PhotoSettingsPtr settings,
+    SetPhotoOptionsCallback callback) {
+  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
+
+  if (!is_started_)
+    return;
+
+  HRESULT hr = S_OK;
+  ComPtr<IMFCaptureSource> source;
+  hr = engine_->GetSource(source.GetAddressOf());
+
+  if (FAILED(hr)) {
+    LogError(FROM_HERE, hr);
+    return;
+  }
+
+  if (use_photo_stream_to_take_photo_ &&
+      (settings->has_height || settings->has_width)) {
+    CapabilityList capabilities;
+    hr = FillCapabilities(photo_stream_index_, source.Get(), true,
+                          &capabilities);
+
+    if (FAILED(hr)) {
+      LogError(FROM_HERE, hr);
+      return;
+    }
+
+    ComPtr<IMFMediaType> current_media_type;
+    hr = source->GetCurrentDeviceMediaType(photo_stream_index_,
+                                           current_media_type.GetAddressOf());
+
+    if (FAILED(hr)) {
+      LogError(FROM_HERE, hr);
+      return;
+    }
+
+    gfx::Size requested_size = gfx::Size();
+    if (settings->has_height)
+      requested_size.set_height(settings->height);
+
+    if (settings->has_width)
+      requested_size.set_width(settings->width);
+
+    const CapabilityWin best_match = GetBestMatchedPhotoCapability(
+        current_media_type, requested_size, capabilities);
+
+    ComPtr<IMFMediaType> type;
+    hr = GetAvailableDeviceMediaType(source.Get(), photo_stream_index_,
+                                     best_match.stream_index,
+                                     type.GetAddressOf());
+    if (FAILED(hr)) {
+      LogError(FROM_HERE, hr);
+      return;
+    }
+
+    hr = source->SetCurrentDeviceMediaType(photo_stream_index_, type.Get());
+    if (FAILED(hr)) {
+      LogError(FROM_HERE, hr);
+      return;
+    }
+  }
+
+  std::move(callback).Run(true);
 }
 
 void VideoCaptureDeviceMFWin::OnIncomingCapturedData(
@@ -287,27 +776,42 @@
     base::TimeTicks reference_time,
     base::TimeDelta timestamp) {
   base::AutoLock lock(lock_);
-  if (data && client_.get()) {
-    client_->OnIncomingCapturedData(data, length, capture_format_, rotation,
-                                    reference_time, timestamp);
+
+  if (!data)
+    return;
+
+  if (client_.get()) {
+    client_->OnIncomingCapturedData(data, length, capture_video_format_,
+                                    rotation, reference_time, timestamp);
   }
 
-  if (capture_) {
-    HRESULT hr =
-        reader_->ReadSample(kFirstVideoStream, 0, NULL, NULL, NULL, NULL);
-    if (FAILED(hr)) {
-      // If running the *VideoCap* unit tests on repeat, this can sometimes
-      // fail with HRESULT_FROM_WINHRESULT_FROM_WIN32(ERROR_INVALID_FUNCTION).
-      // It's not clear to me why this is, but it is possible that it has
-      // something to do with this bug:
-      // http://support.microsoft.com/kb/979567
-      OnError(FROM_HERE, hr);
-    }
+  while (!video_stream_take_photo_callbacks_.empty()) {
+    TakePhotoCallback cb =
+        std::move(video_stream_take_photo_callbacks_.front());
+    video_stream_take_photo_callbacks_.pop();
+
+    mojom::BlobPtr blob = Blobify(data, length, capture_video_format_);
+    if (!blob)
+      continue;
+
+    std::move(cb).Run(std::move(blob));
   }
 }
 
-void VideoCaptureDeviceMFWin::OnError(const base::Location& from_here,
-                                      HRESULT hr) {
+void VideoCaptureDeviceMFWin::OnEvent(IMFMediaEvent* media_event) {
+  base::AutoLock lock(lock_);
+
+  GUID event_type;
+  HRESULT hr = media_event->GetExtendedType(&event_type);
+
+  if (SUCCEEDED(hr) && event_type == MF_CAPTURE_ENGINE_ERROR)
+    media_event->GetStatus(&hr);
+
+  if (FAILED(hr))
+    OnError(FROM_HERE, hr);
+}
+
+void VideoCaptureDeviceMFWin::OnError(const Location& from_here, HRESULT hr) {
   if (client_.get()) {
     client_->OnError(
         from_here,
@@ -316,4 +820,4 @@
   }
 }
 
-}  // namespace media
+}  // namespace media
\ No newline at end of file

diff --git a/media/capture/video/win/video_capture_device_mf_win.h b/media/capture/video/win/video_capture_device_mf_win.h
index 93534f9..72b5b74b 100644
--- a/media/capture/video/win/video_capture_device_mf_win.h
+++ b/media/capture/video/win/video_capture_device_mf_win.h

@@ -3,12 +3,13 @@
 // found in the LICENSE file.
 
 // Windows specific implementation of VideoCaptureDevice.
-// DirectShow is used for capturing. DirectShow provide its own threads
-// for capturing.
+// MediaFoundation is used for capturing. MediaFoundation provides its own
+// threads for capturing.
 
 #ifndef MEDIA_CAPTURE_VIDEO_WIN_VIDEO_CAPTURE_DEVICE_MF_WIN_H_
 #define MEDIA_CAPTURE_VIDEO_WIN_VIDEO_CAPTURE_DEVICE_MF_WIN_H_
 
+#include <mfcaptureengine.h>
 #include <mfidl.h>
 #include <mfreadwrite.h>
 #include <stdint.h>
@@ -16,9 +17,9 @@
 
 #include <vector>
 
+#include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/sequence_checker.h"
-#include "base/synchronization/lock.h"
 #include "media/capture/capture_export.h"
 #include "media/capture/video/video_capture_device.h"
 
@@ -30,10 +31,7 @@
 
 namespace media {
 
-class MFReaderCallback;
-
-const DWORD kFirstVideoStream =
-    static_cast<DWORD>(MF_SOURCE_READER_FIRST_VIDEO_STREAM);
+class MFVideoCallback;
 
 class CAPTURE_EXPORT VideoCaptureDeviceMFWin : public VideoCaptureDevice {
  public:
@@ -51,6 +49,10 @@
       const VideoCaptureParams& params,
       std::unique_ptr<VideoCaptureDevice::Client> client) override;
   void StopAndDeAllocate() override;
+  void TakePhoto(TakePhotoCallback callback) override;
+  void GetPhotoState(GetPhotoStateCallback callback) override;
+  void SetPhotoOptions(mojom::PhotoSettingsPtr settings,
+                       SetPhotoOptionsCallback callback) override;
 
   // Captured new video data.
   void OnIncomingCapturedData(const uint8_t* data,
@@ -58,19 +60,41 @@
                               int rotation,
                               base::TimeTicks reference_time,
                               base::TimeDelta timestamp);
+  void OnEvent(IMFMediaEvent* media_event);
+
+  using CreateMFPhotoCallbackCB =
+      base::RepeatingCallback<scoped_refptr<IMFCaptureEngineOnSampleCallback>(
+          VideoCaptureDevice::TakePhotoCallback callback,
+          VideoCaptureFormat format)>;
+
+  bool get_use_photo_stream_to_take_photo_for_testing() {
+    return use_photo_stream_to_take_photo_;
+  }
+
+  void set_create_mf_photo_callback_for_testing(CreateMFPhotoCallbackCB cb) {
+    create_mf_photo_callback_ = cb;
+  }
 
  private:
   void OnError(const base::Location& from_here, HRESULT hr);
 
   VideoCaptureDeviceDescriptor descriptor_;
-  Microsoft::WRL::ComPtr<IMFActivate> device_;
-  scoped_refptr<MFReaderCallback> callback_;
+  CreateMFPhotoCallbackCB create_mf_photo_callback_;
+  scoped_refptr<MFVideoCallback> video_callback_;
 
-  base::Lock lock_;  // Used to guard the below variables.
+  // Guards the below variables from concurrent access between methods running
+  // on |sequence_checker_| and calls to OnIncomingCapturedData() and OnEvent()
+  // made by MediaFoundation on threads outside of our control.
+  base::Lock lock_;
+
   std::unique_ptr<VideoCaptureDevice::Client> client_;
-  Microsoft::WRL::ComPtr<IMFSourceReader> reader_;
-  VideoCaptureFormat capture_format_;
-  bool capture_;
+  Microsoft::WRL::ComPtr<IMFCaptureEngine> engine_;
+  VideoCaptureFormat capture_video_format_;
+  bool is_started_;
+  DWORD video_stream_index_;
+  DWORD photo_stream_index_;
+  bool use_photo_stream_to_take_photo_;
+  base::queue<TakePhotoCallback> video_stream_take_photo_callbacks_;
 
   SEQUENCE_CHECKER(sequence_checker_);
 

diff --git a/media/gpu/dxva_video_decode_accelerator_win.cc b/media/gpu/dxva_video_decode_accelerator_win.cc
index bbc143f..10a7388d 100644
--- a/media/gpu/dxva_video_decode_accelerator_win.cc
+++ b/media/gpu/dxva_video_decode_accelerator_win.cc

@@ -690,7 +690,7 @@
   }
 
   RETURN_AND_NOTIFY_ON_FAILURE(
-      gl::g_driver_egl->ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle,
+      gl::g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle,
       "EGL_ANGLE_surface_d3d_texture_2d_share_handle unavailable",
       PLATFORM_FAILURE, false);
 
@@ -1741,10 +1741,10 @@
       use_dx11_ && gl::GLSurfaceEGL::HasEGLExtension("EGL_ANGLE_keyed_mutex");
 
   if (!use_dx11_ ||
-      !gl::g_driver_egl->ext.b_EGL_ANGLE_stream_producer_d3d_texture ||
-      !gl::g_driver_egl->ext.b_EGL_KHR_stream ||
-      !gl::g_driver_egl->ext.b_EGL_KHR_stream_consumer_gltexture ||
-      !gl::g_driver_egl->ext.b_EGL_NV_stream_consumer_gltexture_yuv) {
+      !gl::g_driver_egl.ext.b_EGL_ANGLE_stream_producer_d3d_texture ||
+      !gl::g_driver_egl.ext.b_EGL_KHR_stream ||
+      !gl::g_driver_egl.ext.b_EGL_KHR_stream_consumer_gltexture ||
+      !gl::g_driver_egl.ext.b_EGL_NV_stream_consumer_gltexture_yuv) {
     support_share_nv12_textures_ = false;
     support_copy_nv12_textures_ = false;
   }

diff --git a/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc b/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc
index f6cd336c..ca08a99 100644
--- a/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc
+++ b/media/gpu/v4l2/v4l2_slice_video_decode_accelerator.cc

@@ -561,7 +561,7 @@
       return false;
     }
 
-    if (!gl::g_driver_egl->ext.b_EGL_KHR_fence_sync) {
+    if (!gl::g_driver_egl.ext.b_EGL_KHR_fence_sync) {
       VLOGF(1) << "context does not have EGL_KHR_fence_sync";
       return false;
     }

diff --git a/media/gpu/v4l2/v4l2_video_decode_accelerator.cc b/media/gpu/v4l2/v4l2_video_decode_accelerator.cc
index a561028..63a3d54 100644
--- a/media/gpu/v4l2/v4l2_video_decode_accelerator.cc
+++ b/media/gpu/v4l2/v4l2_video_decode_accelerator.cc

@@ -237,7 +237,7 @@
 
 // TODO(posciak): https://crbug.com/450898.
 #if defined(ARCH_CPU_ARMEL)
-    if (!gl::g_driver_egl->ext.b_EGL_KHR_fence_sync) {
+    if (!gl::g_driver_egl.ext.b_EGL_KHR_fence_sync) {
       LOGF(ERROR) << "context does not have EGL_KHR_fence_sync";
       return false;
     }

diff --git a/net/network_error_logging/network_error_logging_service.cc b/net/network_error_logging/network_error_logging_service.cc
index f5ccd0d..e0125fe2 100644
--- a/net/network_error_logging/network_error_logging_service.cc
+++ b/net/network_error_logging/network_error_logging_service.cc

@@ -171,12 +171,6 @@
   if (!reporting_service_)
     return;
 
-  // It is expected for Reporting uploads to terminate with ERR_ABORTED, since
-  // the ReportingUploader cancels them after receiving the response code and
-  // headers.
-  if (details.is_reporting_upload && details.type == ERR_ABORTED)
-    return;
-
   url::Origin origin = url::Origin::Create(details.uri);
 
   // NEL is only available to secure origins, so ignore network errors from

diff --git a/net/network_error_logging/network_error_logging_service_unittest.cc b/net/network_error_logging/network_error_logging_service_unittest.cc
index 246a831..b0c7a63 100644
--- a/net/network_error_logging/network_error_logging_service_unittest.cc
+++ b/net/network_error_logging/network_error_logging_service_unittest.cc

@@ -80,11 +80,6 @@
     NOTREACHED();
   }
 
-  bool RequestIsUpload(const URLRequest& request) override {
-    NOTREACHED();
-    return true;
-  }
-
  private:
   std::vector<Report> reports_;
 

diff --git a/net/reporting/reporting_service.cc b/net/reporting/reporting_service.cc
index 4de9d44..b9ef140 100644
--- a/net/reporting/reporting_service.cc
+++ b/net/reporting/reporting_service.cc

@@ -16,7 +16,6 @@
 #include "net/reporting/reporting_context.h"
 #include "net/reporting/reporting_delegate.h"
 #include "net/reporting/reporting_header_parser.h"
-#include "net/reporting/reporting_uploader.h"
 #include "url/gurl.h"
 
 namespace net {
@@ -28,8 +27,6 @@
   ReportingServiceImpl(std::unique_ptr<ReportingContext> context)
       : context_(std::move(context)) {}
 
-  // ReportingService implementation:
-
   ~ReportingServiceImpl() override = default;
 
   void QueueReport(const GURL& url,
@@ -55,10 +52,6 @@
         context_->cache(), data_type_mask, origin_filter);
   }
 
-  bool RequestIsUpload(const URLRequest& request) override {
-    return context_->uploader()->RequestIsUpload(request);
-  }
-
  private:
   std::unique_ptr<ReportingContext> context_;
 

diff --git a/net/reporting/reporting_service.h b/net/reporting/reporting_service.h
index 71f775a..33cfb04 100644
--- a/net/reporting/reporting_service.h
+++ b/net/reporting/reporting_service.h

@@ -22,7 +22,6 @@
 
 class ReportingContext;
 struct ReportingPolicy;
-class URLRequest;
 class URLRequestContext;
 
 // The external interface to the Reporting system, used by the embedder of //net
@@ -66,10 +65,6 @@
       int data_type_mask,
       base::RepeatingCallback<bool(const GURL&)> origin_filter) = 0;
 
-  // Checks whether |request| is a Reporting upload, to avoid loops of reporting
-  // about report uploads.
-  virtual bool RequestIsUpload(const URLRequest& request) = 0;
-
  protected:
   ReportingService() {}
 

diff --git a/net/reporting/reporting_test_util.cc b/net/reporting/reporting_test_util.cc
index 17671b21a..1425069 100644
--- a/net/reporting/reporting_test_util.cc
+++ b/net/reporting/reporting_test_util.cc

@@ -105,11 +105,6 @@
       base::BindOnce(&ErasePendingUpload, &pending_uploads_)));
 }
 
-bool TestReportingUploader::RequestIsUpload(const URLRequest& request) {
-  NOTIMPLEMENTED();
-  return true;
-}
-
 TestReportingDelegate::TestReportingDelegate() = default;
 
 TestReportingDelegate::~TestReportingDelegate() = default;

diff --git a/net/reporting/reporting_test_util.h b/net/reporting/reporting_test_util.h
index f2dff8f..35216c0 100644
--- a/net/reporting/reporting_test_util.h
+++ b/net/reporting/reporting_test_util.h

@@ -68,13 +68,10 @@
   }
 
   // ReportingUploader implementation:
-
   void StartUpload(const GURL& url,
                    const std::string& json,
                    UploadCallback callback) override;
 
-  bool RequestIsUpload(const URLRequest& request) override;
-
  private:
   std::vector<std::unique_ptr<PendingUpload>> pending_uploads_;
 

diff --git a/net/reporting/reporting_uploader.cc b/net/reporting/reporting_uploader.cc
index 2220858c..c7cbb92 100644
--- a/net/reporting/reporting_uploader.cc
+++ b/net/reporting/reporting_uploader.cc

@@ -23,15 +23,6 @@
 
 namespace {
 
-class UploadUserData : public base::SupportsUserData::Data {
- public:
-  static const void* const kUserDataKey;
-};
-
-// SetUserData needs a unique const void* to serve as the key, so create a const
-// void* and use its own address as the unique pointer.
-const void* const UploadUserData::kUserDataKey = &UploadUserData::kUserDataKey;
-
 ReportingUploader::Outcome ResponseCodeToOutcome(int response_code) {
   if (response_code >= 200 && response_code <= 299)
     return ReportingUploader::Outcome::SUCCESS;
@@ -94,9 +85,6 @@
     request->set_upload(
         ElementsUploadDataStream::CreateWithReader(std::move(reader), 0));
 
-    request->SetUserData(UploadUserData::kUserDataKey,
-                         std::make_unique<UploadUserData>());
-
     // This inherently sets mode = "no-cors", but that doesn't matter, because
     // the origins that are included in the upload don't actually get to see
     // the response.
@@ -110,11 +98,6 @@
     *upload = std::make_unique<Upload>(std::move(request), std::move(callback));
   }
 
-  // static
-  bool RequestIsUpload(const net::URLRequest& request) override {
-    return request.GetUserData(UploadUserData::kUserDataKey);
-  }
-
   // URLRequest::Delegate implementation:
 
   void OnReceivedRedirect(URLRequest* request,

diff --git a/net/reporting/reporting_uploader.h b/net/reporting/reporting_uploader.h
index f6c65c7..505b24db 100644
--- a/net/reporting/reporting_uploader.h
+++ b/net/reporting/reporting_uploader.h

@@ -15,7 +15,6 @@
 
 namespace net {
 
-class URLRequest;
 class URLRequestContext;
 
 // Uploads already-serialized reports and converts responses to one of the
@@ -36,9 +35,6 @@
                            const std::string& json,
                            UploadCallback callback) = 0;
 
-  // Returns whether |request| is an upload request sent by this uploader.
-  virtual bool RequestIsUpload(const URLRequest& request) = 0;
-
   // Creates a real implementation of |ReportingUploader| that uploads reports
   // using |context|.
   static std::unique_ptr<ReportingUploader> Create(

diff --git a/net/url_request/network_error_logging_delegate.h b/net/url_request/network_error_logging_delegate.h
index d61ec42..ec2238c 100644
--- a/net/url_request/network_error_logging_delegate.h
+++ b/net/url_request/network_error_logging_delegate.h

@@ -38,8 +38,6 @@
     int status_code;
     base::TimeDelta elapsed_time;
     Error type;
-
-    bool is_reporting_upload;
   };
 
   static const char kHeaderName[];

diff --git a/net/url_request/url_request.cc b/net/url_request/url_request.cc
index 3b76938..7b99fc9 100644
--- a/net/url_request/url_request.cc
+++ b/net/url_request/url_request.cc

@@ -31,7 +31,6 @@
 #include "net/log/net_log.h"
 #include "net/log/net_log_event_type.h"
 #include "net/log/net_log_source_type.h"
-#include "net/reporting/reporting_service.h"
 #include "net/ssl/ssl_cert_request_info.h"
 #include "net/url_request/redirect_info.h"
 #include "net/url_request/redirect_util.h"
@@ -1195,10 +1194,6 @@
       base::TimeTicks::Now() - load_timing_info_.request_start;
   details.type = status().ToNetError();
 
-  details.is_reporting_upload =
-      context()->reporting_service() &&
-      context()->reporting_service()->RequestIsUpload(*this);
-
   delegate->OnNetworkError(details);
 }
 #endif  // BUILDFLAG(ENABLE_REPORTING)

diff --git a/net/url_request/url_request_unittest.cc b/net/url_request/url_request_unittest.cc
index 4e518ff..9d82eb5 100644
--- a/net/url_request/url_request_unittest.cc
+++ b/net/url_request/url_request_unittest.cc

@@ -7043,11 +7043,6 @@
     NOTIMPLEMENTED();
   }
 
-  bool RequestIsUpload(const URLRequest& request) override {
-    NOTIMPLEMENTED();
-    return true;
-  }
-
  private:
   std::vector<Header> headers_;
 };

diff --git a/services/data_decoder/public/cpp/safe_xml_parser.cc b/services/data_decoder/public/cpp/safe_xml_parser.cc
index 821bfd1d..54d7585 100644
--- a/services/data_decoder/public/cpp/safe_xml_parser.cc
+++ b/services/data_decoder/public/cpp/safe_xml_parser.cc

@@ -76,15 +76,15 @@
   delete this;
 }
 
-const base::Value* GetChildren(const base::Value& element) {
+}  // namespace
+
+const base::Value* GetXmlElementChildren(const base::Value& element) {
   if (!element.is_dict())
     return nullptr;
   return element.FindKeyOfType(mojom::XmlParser::kChildrenKey,
                                base::Value::Type::LIST);
 }
 
-}  // namespace
-
 std::string GetXmlQualifiedName(const std::string& name_space,
                                 const std::string& name) {
   return name_space.empty() ? name : name_space + ":" + name;
@@ -127,7 +127,7 @@
 
 bool GetXmlElementText(const base::Value& element, std::string* text) {
   DCHECK(text);
-  const base::Value* children = GetChildren(element);
+  const base::Value* children = GetXmlElementChildren(element);
   if (!children)
     return false;
 
@@ -171,7 +171,7 @@
 
 int GetXmlElementChildrenCount(const base::Value& element,
                                const std::string& name) {
-  const base::Value* children = GetChildren(element);
+  const base::Value* children = GetXmlElementChildren(element);
   if (!children)
     return 0;
   int child_count = 0;
@@ -187,7 +187,7 @@
 
 const base::Value* GetXmlElementChildWithType(const base::Value& element,
                                               const std::string& type) {
-  const base::Value* children = GetChildren(element);
+  const base::Value* children = GetXmlElementChildren(element);
   if (!children)
     return nullptr;
   for (const base::Value& value : children->GetList()) {
@@ -201,7 +201,7 @@
 
 const base::Value* GetXmlElementChildWithTag(const base::Value& element,
                                              const std::string& tag) {
-  const base::Value* children = GetChildren(element);
+  const base::Value* children = GetXmlElementChildren(element);
   if (!children)
     return nullptr;
   for (const base::Value& value : children->GetList()) {
@@ -216,7 +216,7 @@
     const base::Value& element,
     const std::string& tag,
     std::vector<const base::Value*>* children_out) {
-  const base::Value* children = GetChildren(element);
+  const base::Value* children = GetXmlElementChildren(element);
   if (!children)
     return false;
   bool found = false;

diff --git a/services/data_decoder/public/cpp/safe_xml_parser.h b/services/data_decoder/public/cpp/safe_xml_parser.h
index f9d61ae1..2dd7d4b1 100644
--- a/services/data_decoder/public/cpp/safe_xml_parser.h
+++ b/services/data_decoder/public/cpp/safe_xml_parser.h

@@ -52,6 +52,9 @@
 // Below are convenience methods for handling the elements returned by
 // ParseXml().
 
+// Returns all the children of |element|.
+const base::Value* GetXmlElementChildren(const base::Value& element);
+
 // Returns the qualified name |name_space|:|name| or simply |name| if
 // |name_space| is empty.
 std::string GetXmlQualifiedName(const std::string& name_space,

diff --git a/services/service_manager/sandbox/mac/common_v2.sb b/services/service_manager/sandbox/mac/common_v2.sb
index e5a9781f..ecc5076 100644
--- a/services/service_manager/sandbox/mac/common_v2.sb
+++ b/services/service_manager/sandbox/mac/common_v2.sb

@@ -44,7 +44,10 @@
   (string-append (param homedir-as-literal) subpath))
 
 ; Allow logging for all processes.
-(allow file-write* (path (param log-file-path)))
+(allow file-write*
+  (require-all
+    (path (param log-file-path))
+    (vnode-type REGULAR-FILE)))
 
 ; Allow component builds to work.
 (if (param-defined? component-path)
@@ -77,7 +80,10 @@
 (allow file-read-data (path "/private/etc/passwd"))
 
 ; Access to /dev.
-(allow file-ioctl file-read-data file-write-data (path "/dev/dtracehelper"))
+(allow file-ioctl file-read-data file-write-data
+  (require-all
+    (path "/dev/dtracehelper")
+    (vnode-type CHARACTER-DEVICE)))
 
 (allow file-read-data
   (path "/dev/null")

diff --git a/services/service_manager/sandbox/mac/renderer_v2.sb b/services/service_manager/sandbox/mac/renderer_v2.sb
index 5d56ee23..6fb66b7 100644
--- a/services/service_manager/sandbox/mac/renderer_v2.sb
+++ b/services/service_manager/sandbox/mac/renderer_v2.sb

@@ -19,7 +19,10 @@
   (path "/dev/autofs_nowait")
   (path "/dev/fd"))
 
-(allow file-write-data (path "/dev/null"))
+(allow file-write-data
+  (require-all
+    (path "/dev/null")
+    (vnode-type CHARACTER-DEVICE)))
 
 ; Reads from /Library.
 (allow file-read-data (subpath "/Library/Fonts"))

diff --git a/testing/buildbot/chromium.webkit.json b/testing/buildbot/chromium.webkit.json
index f24443a..5a5194e 100644
--- a/testing/buildbot/chromium.webkit.json
+++ b/testing/buildbot/chromium.webkit.json

@@ -302,25 +302,49 @@
     "gtest_tests": [
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.10.5"
+            }
+          ]
         },
         "test": "blink_heap_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.10.5"
+            }
+          ]
         },
         "test": "blink_platform_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.10.5"
+            }
+          ]
         },
         "test": "webkit_unit_tests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.10.5"
+            }
+          ]
         },
         "test": "wtf_unittests"
       }
@@ -363,25 +387,49 @@
     "gtest_tests": [
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.11.6"
+            }
+          ]
         },
         "test": "blink_heap_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.11.6"
+            }
+          ]
         },
         "test": "blink_platform_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.11.6"
+            }
+          ]
         },
         "test": "webkit_unit_tests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.11.6"
+            }
+          ]
         },
         "test": "wtf_unittests"
       }
@@ -424,25 +472,49 @@
     "gtest_tests": [
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.11.6"
+            }
+          ]
         },
         "test": "blink_heap_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.11.6"
+            }
+          ]
         },
         "test": "blink_platform_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.11.6"
+            }
+          ]
         },
         "test": "webkit_unit_tests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "none",
+              "os": "Mac-10.11.6"
+            }
+          ]
         },
         "test": "wtf_unittests"
       }
@@ -488,25 +560,57 @@
     "gtest_tests": [
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6821",
+              "hidpi": "1",
+              "os": "Mac-10.12.6",
+              "pool": "Chrome-GPU"
+            }
+          ]
         },
         "test": "blink_heap_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6821",
+              "hidpi": "1",
+              "os": "Mac-10.12.6",
+              "pool": "Chrome-GPU"
+            }
+          ]
         },
         "test": "blink_platform_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6821",
+              "hidpi": "1",
+              "os": "Mac-10.12.6",
+              "pool": "Chrome-GPU"
+            }
+          ]
         },
         "test": "webkit_unit_tests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "1002:6821",
+              "hidpi": "1",
+              "os": "Mac-10.12.6",
+              "pool": "Chrome-GPU"
+            }
+          ]
         },
         "test": "wtf_unittests"
       }
@@ -551,25 +655,53 @@
     "gtest_tests": [
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a2e",
+              "hidpi": "0",
+              "os": "Mac-10.12.6"
+            }
+          ]
         },
         "test": "blink_heap_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a2e",
+              "hidpi": "0",
+              "os": "Mac-10.12.6"
+            }
+          ]
         },
         "test": "blink_platform_unittests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a2e",
+              "hidpi": "0",
+              "os": "Mac-10.12.6"
+            }
+          ]
         },
         "test": "webkit_unit_tests"
       },
       {
         "swarming": {
-          "can_use_on_swarming_builders": false
+          "can_use_on_swarming_builders": true,
+          "dimension_sets": [
+            {
+              "gpu": "8086:0a2e",
+              "hidpi": "0",
+              "os": "Mac-10.12.6"
+            }
+          ]
         },
         "test": "wtf_unittests"
       }

diff --git a/testing/buildbot/test_suite_exceptions.pyl b/testing/buildbot/test_suite_exceptions.pyl
index f6dfe61..6542c1e5 100644
--- a/testing/buildbot/test_suite_exceptions.pyl
+++ b/testing/buildbot/test_suite_exceptions.pyl

@@ -286,32 +286,6 @@
           'hard_timeout': 120,
         },
       },
-      # chromium.webkit
-      'WebKit Mac10.10': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (dbg)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (retina)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.12': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
     },
   },
   'blink_platform_unittests': {
@@ -344,34 +318,6 @@
       'Win10 Tests x64',
       'Win7 Tests (dbg)(1)',
     ],
-    'modifications': {
-      # on chromium.webkit
-      'WebKit Mac10.10': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (dbg)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (retina)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.12': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-    }
   },
   'boringssl_crypto_tests': {
     'remove_from': [
@@ -588,32 +534,6 @@
           'shards': 20,
         },
       },
-      # on chromium.webkit
-      'WebKit Mac10.10': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (dbg)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (retina)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.12': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
       # client.v8.chromium
       'Linux - Future (dbg)': {
         'swarming': {
@@ -4347,23 +4267,11 @@
       },
       'WebKit Mac10.10': {
         'swarming': {
-          'dimension_sets': [
-            {
-              'gpu': 'none',
-              'os': 'Mac-10.10.5',
-            }
-          ],
           'shards': 4,
         },
       },
       'WebKit Mac10.11': {
         'swarming': {
-          'dimension_sets': [
-            {
-              'gpu': 'none',
-              'os': 'Mac-10.11.6',
-            }
-          ],
           'shards': 4,
         },
       },
@@ -4372,37 +4280,16 @@
           '--debug',
         ],
         'swarming': {
-          'dimension_sets': [
-            {
-              'gpu': 'none',
-              'os': 'Mac-10.11.6',
-            }
-          ],
           'shards': 4,
         },
       },
       'WebKit Mac10.11 (retina)': {
         'swarming': {
-          'dimension_sets': [
-            {
-              'gpu': '1002:6821',
-              'hidpi': '1',
-              'os': 'Mac-10.12.6',
-              'pool': 'Chrome-GPU',
-            }
-          ],
           'shards': 4,
         },
       },
       'WebKit Mac10.12': {
         'swarming': {
-          'dimension_sets': [
-            {
-              'gpu': '8086:0a2e',
-              'hidpi': '0',
-              'os': 'Mac-10.12.6',
-            },
-          ],
           'shards': 4,
         },
       },
@@ -4542,31 +4429,6 @@
       'Win7 Tests (dbg)(1)',
     ],
     'modifications': {
-      'WebKit Mac10.10': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (dbg)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (retina)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.12': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
       # chromium.memory
       'Linux ASan LSan Tests (1)': {
         # These are very slow on the ASAN trybot for some reason.
@@ -4760,33 +4622,6 @@
       'Win10 Tests x64',
       'Win7 Tests (dbg)(1)',
     ],
-    'modifications': {
-      'WebKit Mac10.10': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (dbg)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.11 (retina)': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-      'WebKit Mac10.12': {
-        'swarming': {
-          'can_use_on_swarming_builders': False,
-        },
-      },
-    },
   },
   'zucchini_unittests': {
     'remove_from': [

diff --git a/testing/buildbot/waterfalls.pyl b/testing/buildbot/waterfalls.pyl
index ca6358e..efedc77 100644
--- a/testing/buildbot/waterfalls.pyl
+++ b/testing/buildbot/waterfalls.pyl

@@ -1678,6 +1678,14 @@
           'isolated_scripts': 'chromium_webkit_isolated_scripts',
           'scripts': 'chromium_webkit_scripts',
         },
+        'swarming': {
+          'dimension_sets': [
+            {
+              'gpu': 'none',
+              'os': 'Mac-10.10.5',
+            }
+          ],
+        },
       },
       'WebKit Mac10.11': {
         'test_suites': {
@@ -1685,6 +1693,14 @@
           'isolated_scripts': 'chromium_webkit_isolated_scripts',
           'scripts': 'chromium_webkit_scripts',
         },
+        'swarming': {
+          'dimension_sets': [
+            {
+              'gpu': 'none',
+              'os': 'Mac-10.11.6',
+            }
+          ],
+        },
       },
       'WebKit Mac10.11 (dbg)': {
         'test_suites': {
@@ -1692,6 +1708,14 @@
           'isolated_scripts': 'chromium_webkit_isolated_scripts',
           'scripts': 'chromium_webkit_scripts',
         },
+        'swarming': {
+          'dimension_sets': [
+            {
+              'gpu': 'none',
+              'os': 'Mac-10.11.6',
+            }
+          ],
+        },
       },
       'WebKit Mac10.11 (retina)': {
         'test_suites': {
@@ -1699,6 +1723,16 @@
           'isolated_scripts': 'chromium_webkit_isolated_scripts',
           'scripts': 'chromium_webkit_scripts',
         },
+        'swarming': {
+          'dimension_sets': [
+            {
+              'gpu': '1002:6821',
+              'hidpi': '1',
+              'os': 'Mac-10.12.6',
+              'pool': 'Chrome-GPU',
+            }
+          ],
+        },
       },
       'WebKit Mac10.12': {
         'test_suites': {
@@ -1706,6 +1740,15 @@
           'isolated_scripts': 'chromium_webkit_isolated_scripts',
           'scripts': 'chromium_webkit_scripts',
         },
+        'swarming': {
+          'dimension_sets': [
+            {
+              'gpu': '8086:0a2e',
+              'hidpi': '0',
+              'os': 'Mac-10.12.6',
+            },
+          ],
+        },
       },
       'WebKit Win x64 Builder': {
         'test_suites': {

diff --git a/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-navigated-expected.txt b/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-navigated-expected.txt
index 5637e5d..48d4e3f0 100644
--- a/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-navigated-expected.txt
+++ b/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-navigated-expected.txt

@@ -54,8 +54,8 @@
 PASS window.cached_navigator_serviceWorker.onmessage is null
 PASS window.cached_navigator_usb.onconnect is null
 PASS window.cached_navigator_usb.ondisconnect is null
-PASS window.cached_navigator_vr.ondeviceconnect is null
-PASS window.cached_navigator_vr.ondevicedisconnect is null
+PASS window.cached_navigator_xr.ondeviceconnect is null
+PASS window.cached_navigator_xr.ondevicedisconnect is null
 PASS window.cached_performance.onresourcetimingbufferfull is null
 PASS window.cached_performance_navigation.redirectCount is 0
 PASS window.cached_performance_navigation.type is 0

diff --git a/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-removed-and-gced-expected.txt b/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-removed-and-gced-expected.txt
index 89e5f92..973346a 100644
--- a/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-removed-and-gced-expected.txt
+++ b/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-removed-and-gced-expected.txt

@@ -54,8 +54,8 @@
 PASS window.cached_navigator_serviceWorker.onmessage is null
 PASS window.cached_navigator_usb.onconnect is null
 PASS window.cached_navigator_usb.ondisconnect is null
-PASS window.cached_navigator_vr.ondeviceconnect is null
-PASS window.cached_navigator_vr.ondevicedisconnect is null
+PASS window.cached_navigator_xr.ondeviceconnect is null
+PASS window.cached_navigator_xr.ondevicedisconnect is null
 PASS window.cached_performance.onresourcetimingbufferfull is null
 PASS window.cached_performance_navigation.redirectCount is 0
 PASS window.cached_performance_navigation.type is 0

diff --git a/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-removed-expected.txt b/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-removed-expected.txt
index a4878cc..5ef8fd7 100644
--- a/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-removed-expected.txt
+++ b/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-properties-after-frame-removed-expected.txt

@@ -54,8 +54,8 @@
 PASS window.cached_navigator_serviceWorker.onmessage is null
 PASS window.cached_navigator_usb.onconnect is null
 PASS window.cached_navigator_usb.ondisconnect is null
-PASS window.cached_navigator_vr.ondeviceconnect is null
-PASS window.cached_navigator_vr.ondevicedisconnect is null
+PASS window.cached_navigator_xr.ondeviceconnect is null
+PASS window.cached_navigator_xr.ondevicedisconnect is null
 PASS window.cached_performance.onresourcetimingbufferfull is null
 PASS window.cached_performance_navigation.redirectCount is 0
 PASS window.cached_performance_navigation.type is 0

diff --git a/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-window-after-frame-navigated-expected.txt b/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-window-after-frame-navigated-expected.txt
index 81a6c0f..72ca4664 100644
--- a/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-window-after-frame-navigated-expected.txt
+++ b/third_party/WebKit/LayoutTests/fast/dom/Window/property-access-on-cached-window-after-frame-navigated-expected.txt

@@ -63,8 +63,8 @@
 PASS oldChildWindow.navigator.userAgent is newChildWindow.navigator.userAgent
 PASS oldChildWindow.navigator.vendor is newChildWindow.navigator.vendor
 PASS oldChildWindow.navigator.vendorSub is newChildWindow.navigator.vendorSub
-PASS oldChildWindow.navigator.vr.ondeviceconnect is newChildWindow.navigator.vr.ondeviceconnect
-PASS oldChildWindow.navigator.vr.ondevicedisconnect is newChildWindow.navigator.vr.ondevicedisconnect
+PASS oldChildWindow.navigator.xr.ondeviceconnect is newChildWindow.navigator.xr.ondeviceconnect
+PASS oldChildWindow.navigator.xr.ondevicedisconnect is newChildWindow.navigator.xr.ondevicedisconnect
 PASS oldChildWindow.onabort is newChildWindow.onabort
 PASS oldChildWindow.onafterprint is newChildWindow.onafterprint
 PASS oldChildWindow.onanimationend is newChildWindow.onanimationend

diff --git a/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_called.html b/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_called.html
deleted file mode 100644
index 20fc1458..0000000
--- a/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_called.html
+++ /dev/null

@@ -1,28 +0,0 @@
-<!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
-<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
-<script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
-<script>
-let fakeDisplays = fakeVRDisplays();
-
-vr_session_test( (t, session) => {
-  // Session must have a baseLayer or frame requests will be ignored.
-  session.baseLayer = new VRWebGLLayer(session, gl);
-
-  function onFrame(vrFrame) {
-    t.step( () => {
-      assert_true(vrFrame instanceof VRPresentationFrame);
-    });
-    t.done();
-  }
-
-  session.requestFrame(onFrame);
-}, fakeDisplays["Pixel"], { exclusive: true },
-"VRSession requestFrame properly calls the provided callback");
-
-</script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_blocked_by_getVRDisplays.html b/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_blocked_by_getVRDisplays.html
deleted file mode 100644
index 9dbc7ce..0000000
--- a/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_blocked_by_getVRDisplays.html
+++ /dev/null

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script>
-
-promise_test(t => navigator.getVRDisplays().then(() => {
-  assert_true(navigator.vr == null);
-}), "Test that access to navigator.vr is blocked once navigator.getVRDisplays has been called.");
-
-</script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_blocks_getVRDisplays.html b/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_blocks_getVRDisplays.html
deleted file mode 100644
index 43de3b0..0000000
--- a/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_blocks_getVRDisplays.html
+++ /dev/null

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script>
-
-promise_test(t => navigator.vr.requestDevice().then(() => {
-  return promise_rejects(t, "InvalidStateError", navigator.getVRDisplays());
-}), "Test that calls to navigator.getVRDisplays are blocked once navigator.vr has been accessed.");
-
-</script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_detached.html b/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_detached.html
deleted file mode 100644
index 0d9b51e..0000000
--- a/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_detached.html
+++ /dev/null

@@ -1,20 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<title>Detached use of navigator.vr</title>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-</head>
-<body>
-<iframe sandbox="allow-same-origin" id="subframe"></iframe>
-<script>
-
-promise_test(t => {
-  var nav_vr = window.frames[0].navigator.vr;
-  document.getElementById("subframe").remove();
-  return promise_rejects(t, "InvalidStateError", nav_vr.requestDevice());
-}, "Check that navigator.vr.requestDevice rejects on a detached navigator.");
-
-</script>
-</body>
-</html>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_early_detached.html b/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_early_detached.html
deleted file mode 100644
index a993783b..0000000
--- a/third_party/WebKit/LayoutTests/vr/latest/navigator_vr_early_detached.html
+++ /dev/null

@@ -1,20 +0,0 @@
-<!DOCTYPE html>
-<html>
-<head>
-<title>Detached use of navigator.vr()</title>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-</head>
-<body>
-<iframe sandbox="allow-same-origin" id="subframe"></iframe>
-<script>
-//This test ensures that if a navigator.vr gets called on a detached navigator the renderer does not crash.
-test(function() {
-  var nav = window.frames[0].navigator;
-  document.getElementById("subframe").remove();
-  // If all goes well, nav.vr should just be null, otherwise the renderer will crash. 
-  assert_equals(nav.vr, null);
-}, "navigator.vr does not crash");
-</script>
-</body>
-</html>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/requestDevice_always_resolves.html b/third_party/WebKit/LayoutTests/vr/latest/requestDevice_always_resolves.html
deleted file mode 100644
index 7081f93..0000000
--- a/third_party/WebKit/LayoutTests/vr/latest/requestDevice_always_resolves.html
+++ /dev/null

@@ -1,10 +0,0 @@
-<!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script>
-
-promise_test(t => navigator.vr.requestDevice().then(device => {
-  assert_true(device == null);
-}), "Test that navigator.vr.requestDevice always resolves with at least a null.");
-
-</script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/requestDevice_zero_devices.html b/third_party/WebKit/LayoutTests/vr/latest/requestDevice_zero_devices.html
deleted file mode 100644
index 70aa2ed..0000000
--- a/third_party/WebKit/LayoutTests/vr/latest/requestDevice_zero_devices.html
+++ /dev/null

@@ -1,27 +0,0 @@
-<!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
-<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
-<script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
-<script>
-let fakeDisplays = fakeVRDisplays();
-
-vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
-    t.step( () => {
-      assert_true(device == null);
-    }, "requestDevice returned correct results");
-  }, (err) => {
-    t.step( () => {
-      assert_unreached("requestDevice rejected");
-    });
-  }).then( () => {
-    t.done();
-  });
-}, [],
-"navigator.vr.requestDevice properly returns zero devices");
-
-</script>
\ No newline at end of file

diff --git a/third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js b/third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js
index d8ef9a11..3f395cb 100644
--- a/third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js
+++ b/third_party/WebKit/LayoutTests/vr/resources/mock-vr-service.js

@@ -174,32 +174,39 @@
   func(t, mockVRService);
 }
 
-function vr_session_test(func, vrDevice, sessionOptions, name, properties) {
+// TODO(offenwanger) Remove this when we switch over to promise tests.
+function xr_session_test(func, vrDevice, sessionOptions, name, properties) {
   mockVRService.setVRDisplays([vrDevice]);
   let t = async_test(name, properties);
 
-  navigator.vr.requestDevice().then( (device) => {
-    // Perform the session request in a user gesture.
-    function thunk() {
-      document.removeEventListener("keypress", thunk, false);
+  navigator.xr.requestDevice().then(
+      (device) => {
+        // Perform the session request in a user gesture.
+        function thunk() {
+          document.removeEventListener('keypress', thunk, false);
 
-      device.requestSession(sessionOptions).then( (session) => {
-        func(t, session, mockVRService);
-      }, (err) => {
-        t.step( () => {
-          assert_unreached("requestSession rejected");
+          device.requestSession(sessionOptions)
+              .then(
+                  (session) => {
+                    func(t, session, mockVRService);
+                  },
+                  (err) => {
+                    t.step(() => {
+                      assert_unreached('requestSession rejected');
+                    });
+                    t.done();
+                  });
+        }
+        document.addEventListener('keypress', thunk, false);
+        eventSender.keyDown(' ', []);
+      },
+      (err) => {
+        t.step(() => {
+          assert_unreached(
+              'navigator.xr.getDevices rejected in xr_session_test');
         });
         t.done();
       });
-    }
-    document.addEventListener("keypress", thunk, false);
-    eventSender.keyDown(" ", []);
-  }, (err) => {
-    t.step( () => {
-      assert_unreached("navigator.vr.getDevices rejected in vr_session_test");
-    });
-    t.done();
-  });
 }
 
 // Gets the corresponding transform matrix for a WebVR 1.1 pose

diff --git a/third_party/WebKit/LayoutTests/webexposed/global-interface-listing-expected.txt b/third_party/WebKit/LayoutTests/webexposed/global-interface-listing-expected.txt
index d919b3fe..8ef99c3a 100644
--- a/third_party/WebKit/LayoutTests/webexposed/global-interface-listing-expected.txt
+++ b/third_party/WebKit/LayoutTests/webexposed/global-interface-listing-expected.txt

@@ -4499,9 +4499,9 @@
     getter userAgent
     getter vendor
     getter vendorSub
-    getter vr
     getter webkitPersistentStorage
     getter webkitTemporaryStorage
+    getter xr
     method cancelKeyboardLock
     method constructor
     method getBattery
@@ -7204,34 +7204,6 @@
     getter bytesWritten
     getter status
     method constructor
-interface VR : EventTarget
-    attribute @@toStringTag
-    getter ondeviceconnect
-    getter ondevicedisconnect
-    method constructor
-    method requestDevice
-    setter ondeviceconnect
-    setter ondevicedisconnect
-interface VRCoordinateSystem
-    attribute @@toStringTag
-    method constructor
-    method getTransformTo
-interface VRDevice : EventTarget
-    attribute @@toStringTag
-    getter deviceName
-    getter isExternal
-    method constructor
-    method requestSession
-    method supportsSession
-interface VRDeviceEvent : Event
-    attribute @@toStringTag
-    getter device
-    method constructor
-interface VRDevicePose
-    attribute @@toStringTag
-    getter poseModelMatrix
-    method constructor
-    method getViewMatrix
 interface VRDisplay : EventTarget
     attribute @@toStringTag
     getter capabilities
@@ -7278,14 +7250,6 @@
     getter rightProjectionMatrix
     getter rightViewMatrix
     method constructor
-interface VRFrameOfReference : VRCoordinateSystem
-    attribute @@toStringTag
-    getter bounds
-    getter emulatedHeight
-    method constructor
-interface VRLayer
-    attribute @@toStringTag
-    method constructor
 interface VRPose
     attribute @@toStringTag
     getter angularAcceleration
@@ -7295,80 +7259,12 @@
     getter orientation
     getter position
     method constructor
-interface VRPresentationFrame
-    attribute @@toStringTag
-    getter session
-    getter views
-    method constructor
-    method getDevicePose
-interface VRSession : EventTarget
-    attribute @@toStringTag
-    getter baseLayer
-    getter depthFar
-    getter depthNear
-    getter device
-    getter exclusive
-    getter onblur
-    getter onend
-    getter onfocus
-    getter onresetpose
-    method cancelFrame
-    method constructor
-    method end
-    method requestFrame
-    method requestFrameOfReference
-    setter baseLayer
-    setter depthFar
-    setter depthNear
-    setter onblur
-    setter onend
-    setter onfocus
-    setter onresetpose
-interface VRSessionEvent : Event
-    attribute @@toStringTag
-    getter session
-    method constructor
-interface VRStageBounds
-    attribute @@toStringTag
-    getter geometry
-    method constructor
-interface VRStageBoundsPoint
-    attribute @@toStringTag
-    getter x
-    getter z
-    method constructor
 interface VRStageParameters
     attribute @@toStringTag
     getter sittingToStandingTransform
     getter sizeX
     getter sizeZ
     method constructor
-interface VRView
-    attribute @@toStringTag
-    getter eye
-    getter projectionMatrix
-    method constructor
-    method getViewport
-interface VRViewport
-    attribute @@toStringTag
-    getter height
-    getter width
-    getter x
-    getter y
-    method constructor
-interface VRWebGLLayer : VRLayer
-    attribute @@toStringTag
-    getter alpha
-    getter antialias
-    getter context
-    getter depth
-    getter framebuffer
-    getter framebufferHeight
-    getter framebufferWidth
-    getter multiview
-    getter stencil
-    method constructor
-    method requestViewportScaling
 interface VTTCue : TextTrackCue
     attribute @@toStringTag
     getter align
@@ -8990,6 +8886,110 @@
     method constructor
     method iterateNext
     method snapshotItem
+interface XR : EventTarget
+    attribute @@toStringTag
+    getter ondeviceconnect
+    getter ondevicedisconnect
+    method constructor
+    method requestDevice
+    setter ondeviceconnect
+    setter ondevicedisconnect
+interface XRCoordinateSystem
+    attribute @@toStringTag
+    method constructor
+    method getTransformTo
+interface XRDevice : EventTarget
+    attribute @@toStringTag
+    getter deviceName
+    getter isExternal
+    method constructor
+    method requestSession
+    method supportsSession
+interface XRDeviceEvent : Event
+    attribute @@toStringTag
+    getter device
+    method constructor
+interface XRDevicePose
+    attribute @@toStringTag
+    getter poseModelMatrix
+    method constructor
+    method getViewMatrix
+interface XRFrameOfReference : XRCoordinateSystem
+    attribute @@toStringTag
+    getter bounds
+    getter emulatedHeight
+    method constructor
+interface XRLayer
+    attribute @@toStringTag
+    method constructor
+interface XRPresentationFrame
+    attribute @@toStringTag
+    getter session
+    getter views
+    method constructor
+    method getDevicePose
+interface XRSession : EventTarget
+    attribute @@toStringTag
+    getter baseLayer
+    getter depthFar
+    getter depthNear
+    getter device
+    getter exclusive
+    getter onblur
+    getter onend
+    getter onfocus
+    getter onresetpose
+    method cancelFrame
+    method constructor
+    method end
+    method requestFrame
+    method requestFrameOfReference
+    setter baseLayer
+    setter depthFar
+    setter depthNear
+    setter onblur
+    setter onend
+    setter onfocus
+    setter onresetpose
+interface XRSessionEvent : Event
+    attribute @@toStringTag
+    getter session
+    method constructor
+interface XRStageBounds
+    attribute @@toStringTag
+    getter geometry
+    method constructor
+interface XRStageBoundsPoint
+    attribute @@toStringTag
+    getter x
+    getter z
+    method constructor
+interface XRView
+    attribute @@toStringTag
+    getter eye
+    getter projectionMatrix
+    method constructor
+    method getViewport
+interface XRViewport
+    attribute @@toStringTag
+    getter height
+    getter width
+    getter x
+    getter y
+    method constructor
+interface XRWebGLLayer : XRLayer
+    attribute @@toStringTag
+    getter alpha
+    getter antialias
+    getter context
+    getter depth
+    getter framebuffer
+    getter framebufferHeight
+    getter framebufferWidth
+    getter multiview
+    getter stencil
+    method constructor
+    method requestViewportScaling
 interface XSLTProcessor
     attribute @@toStringTag
     method clearParameters

diff --git a/third_party/WebKit/LayoutTests/vr/latest/events_deviceconnect.html b/third_party/WebKit/LayoutTests/xr/events_deviceconnect.html
similarity index 64%
rename from third_party/WebKit/LayoutTests/vr/latest/events_deviceconnect.html
rename to third_party/WebKit/LayoutTests/xr/events_deviceconnect.html
index dcba829..54356d3 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/events_deviceconnect.html
+++ b/third_party/WebKit/LayoutTests/xr/events_deviceconnect.html

@@ -1,17 +1,17 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
 <canvas id="webgl-canvas"></canvas>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test((t, mockService) => {
   let watcherDone = new Event("watcherdone");
-  let eventWatcher = new EventWatcher(t, navigator.vr, ["deviceconnect",
+  let eventWatcher = new EventWatcher(t, navigator.xr, ["deviceconnect",
                                                         "watcherdone"]);
   eventWatcher.wait_for(["deviceconnect", "watcherdone"])
     .then( () => {
@@ -19,14 +19,14 @@
     });
 
   // The event should fire when a listener is added even if the devices are not
-  // explicity queried with navigator.vr.requestDevice().
+  // explicity queried with navigator.xr.requestDevice().
   function onDeviceConnect(event) {
     t.step( () => {
       assert_equals(event.device.deviceName, 'Google, Inc. Daydream View');
-      navigator.vr.dispatchEvent(watcherDone);
+      navigator.xr.dispatchEvent(watcherDone);
     });
   }
-  navigator.vr.addEventListener("deviceconnect", onDeviceConnect, false);
+  navigator.xr.addEventListener("deviceconnect", onDeviceConnect, false);
 
 }, [fakeDisplays["Pixel"]],
 "Test deviceconnect fires when devices are connected.");

diff --git a/third_party/WebKit/LayoutTests/vr/latest/events_session_end.html b/third_party/WebKit/LayoutTests/xr/events_session_end.html
similarity index 78%
rename from third_party/WebKit/LayoutTests/vr/latest/events_session_end.html
rename to third_party/WebKit/LayoutTests/xr/events_session_end.html
index 2f6c560..0003e36 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/events_session_end.html
+++ b/third_party/WebKit/LayoutTests/xr/events_session_end.html

@@ -1,19 +1,19 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test((t, mockService) => {
   let watcherDone = new Event("watcherdone");
 
-  navigator.vr.requestDevice().then( (device) => {
+  navigator.xr.requestDevice().then( (device) => {
     runWithUserGesture( () => {
       device.requestSession({ exclusive: true }).then( (session) => {
         let eventWatcher = new EventWatcher(t, session, ["end", "watcherdone"]);

diff --git a/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_called.html b/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_called.html
new file mode 100644
index 0000000..bebf33cd
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_called.html

@@ -0,0 +1,28 @@
+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/vr_service.mojom.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<canvas id="webgl-canvas"></canvas>
+<script src="../vr/resources/presentation-setup.js"></script>
+<script>
+let fakeDisplays = fakeVRDisplays();
+
+xr_session_test( (t, session) => {
+  // Session must have a baseLayer or frame requests will be ignored.
+  session.baseLayer = new XRWebGLLayer(session, gl);
+
+  function onFrame(xrFrame) {
+    t.step( () => {
+      assert_true(xrFrame instanceof XRPresentationFrame);
+    });
+    t.done();
+  }
+
+  session.requestFrame(onFrame);
+}, fakeDisplays["Pixel"], { exclusive: true },
+"XRSession requestFrame properly calls the provided callback");
+
+</script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_invalidhandle.html b/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_invalidhandle.html
similarity index 69%
rename from third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_invalidhandle.html
rename to third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_invalidhandle.html
index b9267c8..a6dcf73 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_invalidhandle.html
+++ b/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_invalidhandle.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
-vr_session_test( (t, session) => {
+xr_session_test( (t, session) => {
   // Session must have a baseLayer or frame requests will be ignored.
-  session.baseLayer = new VRWebGLLayer(session, gl);
+  session.baseLayer = new XRWebGLLayer(session, gl);
 
   let counter = 0;
 
@@ -36,6 +36,6 @@
   session.cancelFrame(0.5);
   session.cancelFrame(null);
 }, fakeDisplays["Pixel"], { exclusive: true },
-"VRSession cancelFrame does not have unexpected behavior when given invalid handles");
+"XRSession cancelFrame does not have unexpected behavior when given invalid handles");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_nolayer.html b/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_nolayer.html
similarity index 70%
rename from third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_nolayer.html
rename to third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_nolayer.html
index 43ee171..399006b 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_nolayer.html
+++ b/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_nolayer.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
-vr_session_test( (t, session) => {
+xr_session_test( (t, session) => {
   // Session must have a baseLayer or frame requests will be ignored.
-  let webglLayer = new VRWebGLLayer(session, gl);
+  let webglLayer = new XRWebGLLayer(session, gl);
 
   function onBadFrame(vrFrame) {
     t.step( () => {
@@ -42,6 +42,6 @@
     assert_not_equals(goodHandle, 0);
   });
 }, fakeDisplays["Pixel"], { exclusive: true },
-"VRSession requestFrame must fail if the session has no baseLayer");
+"XRSession requestFrame must fail if the session has no baseLayer");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_unregister.html b/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_unregister.html
similarity index 75%
rename from third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_unregister.html
rename to third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_unregister.html
index 249a29c..9151c8b 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/exclusive_requestFrame_unregister.html
+++ b/third_party/WebKit/LayoutTests/xr/exclusive_requestFrame_unregister.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
-vr_session_test( (t, session) => {
+xr_session_test( (t, session) => {
   // Session must have a baseLayer or frame requests will be ignored.
-  session.baseLayer = new VRWebGLLayer(session, gl);
+  session.baseLayer = new XRWebGLLayer(session, gl);
 
   function onFrameBad(vrFrame) {
     t.step( () => {
@@ -48,6 +48,6 @@
   session.requestFrame(onFrameGood);
   handle2 = session.requestFrame(onFrameBad);
 }, fakeDisplays["Pixel"], { exclusive: true },
-"VRSession requestFrame callbacks can be unregistered with cancelFrame");
+"XRSession requestFrame callbacks can be unregistered with cancelFrame");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/getDevicePose_oneframeupdate.html b/third_party/WebKit/LayoutTests/xr/getDevicePose_oneframeupdate.html
similarity index 74%
rename from third_party/WebKit/LayoutTests/vr/latest/getDevicePose_oneframeupdate.html
rename to third_party/WebKit/LayoutTests/xr/getDevicePose_oneframeupdate.html
index 0737052..26b98fc 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/getDevicePose_oneframeupdate.html
+++ b/third_party/WebKit/LayoutTests/xr/getDevicePose_oneframeupdate.html

@@ -1,19 +1,19 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
-vr_session_test( (t, session, mockService) => {
+xr_session_test( (t, session, mockService) => {
   // Session must have a baseLayer or else frame requests will be ignored.
-  session.baseLayer = new VRWebGLLayer(session, gl);
+  session.baseLayer = new XRWebGLLayer(session, gl);
 
   session.requestFrameOfReference("eyeLevel").then((frameOfRef) => {
     let expected_pose = VALID_POSE;
@@ -48,6 +48,6 @@
     session.requestFrame(onFrame);
   });
 }, fakeDisplays["Pixel"], { exclusive: true },
-"VRPresentationFrame getDevicePose updates on the next frame");
+"XRPresentationFrame getDevicePose updates on the next frame");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/xr/navigator_xr_blocked_by_getVRDisplays.html b/third_party/WebKit/LayoutTests/xr/navigator_xr_blocked_by_getVRDisplays.html
new file mode 100644
index 0000000..7a84f4855
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/xr/navigator_xr_blocked_by_getVRDisplays.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script>
+
+promise_test(t => navigator.getVRDisplays().then(() => {
+  assert_true(navigator.xr == null);
+}), "Test that access to navigator.xr is blocked once navigator.getVRDisplays has been called.");
+
+</script>

diff --git a/third_party/WebKit/LayoutTests/xr/navigator_xr_blocks_getVRDisplays.html b/third_party/WebKit/LayoutTests/xr/navigator_xr_blocks_getVRDisplays.html
new file mode 100644
index 0000000..14039e9
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/xr/navigator_xr_blocks_getVRDisplays.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script>
+
+promise_test(t => navigator.xr.requestDevice().then(() => {
+  return promise_rejects(t, "InvalidStateError", navigator.getVRDisplays());
+}), "Test that calls to navigator.getVRDisplays are blocked once navigator.xr has been accessed.");
+
+</script>

diff --git a/third_party/WebKit/LayoutTests/xr/navigator_xr_detached.html b/third_party/WebKit/LayoutTests/xr/navigator_xr_detached.html
new file mode 100644
index 0000000..4a657d8
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/xr/navigator_xr_detached.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Detached use of navigator.xr</title>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+</head>
+<body>
+<iframe sandbox="allow-same-origin" id="subframe"></iframe>
+<script>
+
+promise_test(t => {
+  var nav_xr = window.frames[0].navigator.xr;
+  document.getElementById("subframe").remove();
+  return promise_rejects(t, "InvalidStateError", nav_xr.requestDevice());
+}, "Check that navigator.xr.requestDevice rejects on a detached navigator.");
+
+</script>
+</body>
+</html>

diff --git a/third_party/WebKit/LayoutTests/xr/navigator_xr_early_detached.html b/third_party/WebKit/LayoutTests/xr/navigator_xr_early_detached.html
new file mode 100644
index 0000000..b2e52af
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/xr/navigator_xr_early_detached.html

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+<head>
+<title>Detached use of navigator.xr()</title>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+</head>
+<body>
+<iframe sandbox="allow-same-origin" id="subframe"></iframe>
+<script>
+//This test ensures that if a navigator.xr gets called on a detached navigator the renderer does not crash.
+test(function() {
+  var nav = window.frames[0].navigator;
+  document.getElementById("subframe").remove();
+  // If all goes well, nav.xr should just be null, otherwise the renderer will crash. 
+  assert_equals(nav.xr, null);
+}, "navigator.xr does not crash");
+</script>
+</body>
+</html>

diff --git a/third_party/WebKit/LayoutTests/xr/requestDevice_always_resolves.html b/third_party/WebKit/LayoutTests/xr/requestDevice_always_resolves.html
new file mode 100644
index 0000000..060e80d
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/xr/requestDevice_always_resolves.html

@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script>
+
+promise_test(t => navigator.xr.requestDevice().then(device => {
+  assert_true(device == null);
+}), "Test that navigator.xr.requestDevice always resolves with at least a null.");
+
+</script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/requestDevice_one_device.html b/third_party/WebKit/LayoutTests/xr/requestDevice_one_device.html
similarity index 60%
rename from third_party/WebKit/LayoutTests/vr/latest/requestDevice_one_device.html
rename to third_party/WebKit/LayoutTests/xr/requestDevice_one_device.html
index 06920c4..40229191 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/requestDevice_one_device.html
+++ b/third_party/WebKit/LayoutTests/xr/requestDevice_one_device.html

@@ -1,16 +1,16 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
     t.step( () => {
       assert_true(device != null);
       assert_equals(device.deviceName, 'Google, Inc. Daydream View');
@@ -24,6 +24,6 @@
     t.done();
   });
 }, [fakeDisplays["Pixel"]],
-"navigator.vr.requestDevice properly returns a single device");
+"navigator.xr.requestDevice properly returns a single device");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/requestDevice_two_devices.html b/third_party/WebKit/LayoutTests/xr/requestDevice_two_devices.html
similarity index 67%
rename from third_party/WebKit/LayoutTests/vr/latest/requestDevice_two_devices.html
rename to third_party/WebKit/LayoutTests/xr/requestDevice_two_devices.html
index f7c71ab..82edaf58 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/requestDevice_two_devices.html
+++ b/third_party/WebKit/LayoutTests/xr/requestDevice_two_devices.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 vr_test( (t) => {
   // TODO(offenwanger) When we know how to we want to select which device to
   // return, update this test.
 
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
     t.step( () => {
       assert_true(device != null);
     }, "requestDevice returned result");
@@ -29,6 +29,6 @@
     t.done();
   });
 }, [fakeDisplays["Pixel"], fakeDisplays["FakeMagicWindowOnly"]],
-"navigator.vr.requestDevice properly returns one device when there are two");
+"navigator.xr.requestDevice properly returns one device when there are two");
 </script>
 

diff --git a/third_party/WebKit/LayoutTests/xr/requestDevice_zero_devices.html b/third_party/WebKit/LayoutTests/xr/requestDevice_zero_devices.html
new file mode 100644
index 0000000..6334f19
--- /dev/null
+++ b/third_party/WebKit/LayoutTests/xr/requestDevice_zero_devices.html

@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
+<script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
+<script src="file:///gen/device/vr/vr_service.mojom.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
+<script>
+let fakeDisplays = fakeVRDisplays();
+
+vr_test( (t) => {
+  return navigator.xr.requestDevice().then( (device) => {
+    t.step( () => {
+      assert_true(device == null);
+    }, "requestDevice returned correct results");
+  }, (err) => {
+    t.step( () => {
+      assert_unreached("requestDevice rejected");
+    });
+  }).then( () => {
+    t.done();
+  });
+}, [],
+"navigator.xr.requestDevice properly returns zero devices");
+
+</script>
\ No newline at end of file

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_no_gesture.html b/third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_no_gesture.html
similarity index 63%
rename from third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_no_gesture.html
rename to third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_no_gesture.html
index 5e46bdf..9e48a21d 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_no_gesture.html
+++ b/third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_no_gesture.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
 
     device.requestSession({ exclusive: true }).then(() => {
       assert_unreached("requestSession resolved unexpectedly");

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_supported.html b/third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_supported.html
similarity index 68%
rename from third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_supported.html
rename to third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_supported.html
index e1736029..84bfc45 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_supported.html
+++ b/third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_supported.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
 
     runWithUserGesture( () => {
       device.requestSession({ exclusive: true }).then( (session) => {

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_unsupported.html b/third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_unsupported.html
similarity index 65%
rename from third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_unsupported.html
rename to third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_unsupported.html
index 30a7a8f1..faee322 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_requestSession_exclusive_unsupported.html
+++ b/third_party/WebKit/LayoutTests/xr/xrDevice_requestSession_exclusive_unsupported.html

@@ -1,17 +1,17 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (magicWindowOnlyDevice) => {
+  return navigator.xr.requestDevice().then( (magicWindowOnlyDevice) => {
     runWithUserGesture( () => {
 
       magicWindowOnlyDevice.requestSession({ exclusive: true }).then(() => {

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_exclusive_rejects.html b/third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_exclusive_rejects.html
similarity index 67%
rename from third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_exclusive_rejects.html
rename to third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_exclusive_rejects.html
index e563716..186b85f 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_exclusive_rejects.html
+++ b/third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_exclusive_rejects.html

@@ -1,16 +1,16 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (magicWindowOnlyDevice) => {
+  return navigator.xr.requestDevice().then( (magicWindowOnlyDevice) => {
 
     magicWindowOnlyDevice.supportsSession({ exclusive: true }).then( () => {
       t.step( () => {

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_exclusive_resolves.html b/third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_exclusive_resolves.html
similarity index 66%
rename from third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_exclusive_resolves.html
rename to third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_exclusive_resolves.html
index 7322bdbf..53ad8939 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_exclusive_resolves.html
+++ b/third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_exclusive_resolves.html

@@ -1,16 +1,16 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
 
     device.supportsSession({ exclusive: true }).then( () => {
       // Expected result

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_non_exclusive.html b/third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_non_exclusive.html
similarity index 67%
rename from third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_non_exclusive.html
rename to third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_non_exclusive.html
index 812da2e8..493dd7a 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrDevice_supportsSession_non_exclusive.html
+++ b/third_party/WebKit/LayoutTests/xr/xrDevice_supportsSession_non_exclusive.html

@@ -1,16 +1,16 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
 
     device.supportsSession().then( () => {
       t.step( () => {

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrSession_exclusive.html b/third_party/WebKit/LayoutTests/xr/xrSession_exclusive.html
similarity index 71%
rename from third_party/WebKit/LayoutTests/vr/latest/vrSession_exclusive.html
rename to third_party/WebKit/LayoutTests/xr/xrSession_exclusive.html
index 15626987..7faf007 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrSession_exclusive.html
+++ b/third_party/WebKit/LayoutTests/xr/xrSession_exclusive.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
     runWithUserGesture( () => {
       device.requestSession({ exclusive: true }).then( (session) => {
         t.step( () => {

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrSession_prevent_multiple_exclusive.html b/third_party/WebKit/LayoutTests/xr/xrSession_prevent_multiple_exclusive.html
similarity index 80%
rename from third_party/WebKit/LayoutTests/vr/latest/vrSession_prevent_multiple_exclusive.html
rename to third_party/WebKit/LayoutTests/xr/xrSession_prevent_multiple_exclusive.html
index 7134cf4..a318235 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrSession_prevent_multiple_exclusive.html
+++ b/third_party/WebKit/LayoutTests/xr/xrSession_prevent_multiple_exclusive.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
     runWithUserGesture( () => {
       device.requestSession({ exclusive: true }).then( (session) => {
         runWithUserGesture( () => {

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrSession_requestFrameOfReference.html b/third_party/WebKit/LayoutTests/xr/xrSession_requestFrameOfReference.html
similarity index 71%
rename from third_party/WebKit/LayoutTests/vr/latest/vrSession_requestFrameOfReference.html
rename to third_party/WebKit/LayoutTests/xr/xrSession_requestFrameOfReference.html
index be4a377af..16a298a6 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrSession_requestFrameOfReference.html
+++ b/third_party/WebKit/LayoutTests/xr/xrSession_requestFrameOfReference.html

@@ -1,18 +1,18 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 vr_test( (t) => {
-  return navigator.vr.requestDevice().then( (device) => {
+  return navigator.xr.requestDevice().then( (device) => {
     runWithUserGesture( () => {
       device.requestSession({ exclusive: true }).then( (session) => {
 
@@ -24,8 +24,8 @@
         return Promise.all([
           session.requestFrameOfReference("headModel").then( (frameOfRef) => {
             t.step( () => {
-              assert_true(frameOfRef instanceof VRCoordinateSystem);
-              assert_true(frameOfRef instanceof VRFrameOfReference);
+              assert_true(frameOfRef instanceof XRCoordinateSystem);
+              assert_true(frameOfRef instanceof XRFrameOfReference);
             }, "'headModel' Frame of Reference is the correct type.");
           }, (err) => {
             t.step( () => {
@@ -35,8 +35,8 @@
 
           session.requestFrameOfReference("eyeLevel").then( (frameOfRef) => {
             t.step( () => {
-              assert_true(frameOfRef instanceof VRCoordinateSystem);
-              assert_true(frameOfRef instanceof VRFrameOfReference);
+              assert_true(frameOfRef instanceof XRCoordinateSystem);
+              assert_true(frameOfRef instanceof XRFrameOfReference);
             }, "'eyeLevel' Frame of Reference is the correct type.");
           }, (err) => {
             t.step( () => {
@@ -46,8 +46,8 @@
 
           session.requestFrameOfReference("stage").then( (frameOfRef) => {
             t.step( () => {
-              assert_true(frameOfRef instanceof VRCoordinateSystem);
-              assert_true(frameOfRef instanceof VRFrameOfReference);
+              assert_true(frameOfRef instanceof XRCoordinateSystem);
+              assert_true(frameOfRef instanceof XRFrameOfReference);
             }, "'stage' Frame of Reference is the correct type.");
           }, (err) => {
             t.step( () => {

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrView_match.html b/third_party/WebKit/LayoutTests/xr/xrView_match.html
similarity index 64%
rename from third_party/WebKit/LayoutTests/vr/latest/vrView_match.html
rename to third_party/WebKit/LayoutTests/xr/xrView_match.html
index 2d7de532..a0715b2 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrView_match.html
+++ b/third_party/WebKit/LayoutTests/xr/xrView_match.html

@@ -1,34 +1,34 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
-vr_session_test( (t, session, mockService) => {
+xr_session_test( (t, session, mockService) => {
   // Session must have a baseLayer or frame requests will be ignored.
-  let webglLayer = new VRWebGLLayer(session, gl);
+  let webglLayer = new XRWebGLLayer(session, gl);
   session.baseLayer = webglLayer;
 
   session.requestFrameOfReference("eyeLevel").then((frameOfRef) => {
-    function onFrame(vrFrame) {
+    function onFrame(xrFrame) {
       t.step( () => {
         // Ensure that two views are provided.
-        assert_not_equals(vrFrame.views, null);
-        assert_equals(vrFrame.views.length, 2);
+        assert_not_equals(xrFrame.views, null);
+        assert_equals(xrFrame.views.length, 2);
 
-        let leftView = vrFrame.views[0];
-        let rightView = vrFrame.views[1];
+        let leftView = xrFrame.views[0];
+        let rightView = xrFrame.views[1];
 
         // Ensure that the views are the right type.
-        assert_true(leftView instanceof VRView);
-        assert_true(rightView instanceof VRView);
+        assert_true(leftView instanceof XRView);
+        assert_true(rightView instanceof XRView);
 
         // Ensure that they have the expected eye enums.
         assert_equals(leftView.eye, "left");
@@ -48,13 +48,13 @@
 
         assert_matrices_approx_equal(leftView.projectionMatrix, expectedLeftProjection);
         assert_matrices_approx_equal(rightView.projectionMatrix, expectedRightProjection);
-      }, "VRView attributes match the expected values");
+      }, "XRView attributes match the expected values");
       t.done();
     }
 
     session.requestFrame(onFrame);
   });
 }, fakeDisplays["Pixel"], { exclusive: true },
-"VRPresentationFrame contains the expected views");
+"XRPresentationFrame contains the expected views");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrView_oneframeupdate.html b/third_party/WebKit/LayoutTests/xr/xrView_oneframeupdate.html
similarity index 80%
rename from third_party/WebKit/LayoutTests/vr/latest/vrView_oneframeupdate.html
rename to third_party/WebKit/LayoutTests/xr/xrView_oneframeupdate.html
index 96b9a433..469c2e5 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrView_oneframeupdate.html
+++ b/third_party/WebKit/LayoutTests/xr/xrView_oneframeupdate.html

@@ -1,29 +1,29 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
 let displayLeftEye = fakeDisplays["Pixel"].leftEye;
 let displayRightEye = fakeDisplays["Pixel"].rightEye;
 
-vr_session_test( (t, session, mockService) => {
+xr_session_test( (t, session, mockService) => {
   // Session must have a baseLayer or frame requests will be ignored.
-  session.baseLayer = new VRWebGLLayer(session, gl);
+  session.baseLayer = new XRWebGLLayer(session, gl);
 
   session.requestFrameOfReference("eyeLevel").then((frameOfRef) => {
     let counter = 0;
 
-    function onFrame(vrFrame) {
-      let leftView = vrFrame.views[0];
-      let rightView = vrFrame.views[1];
+    function onFrame(xrFrame) {
+      let leftView = xrFrame.views[0];
+      let rightView = xrFrame.views[1];
 
       if (counter == 0) {
         session.requestFrame(onFrame);
@@ -69,6 +69,6 @@
     session.requestFrame(onFrame);
   });
 }, fakeDisplays["Pixel"], { exclusive: true },
-"VRView projection matrices update near and far depths on the next frame");
+"XRView projection matrices update near and far depths on the next frame");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrViewport_valid.html b/third_party/WebKit/LayoutTests/xr/xrViewport_valid.html
similarity index 74%
rename from third_party/WebKit/LayoutTests/vr/latest/vrViewport_valid.html
rename to third_party/WebKit/LayoutTests/xr/xrViewport_valid.html
index ad25633b..dd83bd3 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrViewport_valid.html
+++ b/third_party/WebKit/LayoutTests/xr/xrViewport_valid.html

@@ -1,33 +1,33 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
-vr_session_test( (t, session, mockService) => {
+xr_session_test( (t, session, mockService) => {
   // Session must have a baseLayer or frame requests will be ignored.
-  let webglLayer = new VRWebGLLayer(session, gl);
+  let webglLayer = new XRWebGLLayer(session, gl);
   session.baseLayer = webglLayer;
 
   session.requestFrameOfReference("eyeLevel").then((frameOfRef) => {
-    function onFrame(vrFrame) {
-      let leftView = vrFrame.views[0];
-      let rightView = vrFrame.views[1];
+    function onFrame(xrFrame) {
+      let leftView = xrFrame.views[0];
+      let rightView = xrFrame.views[1];
 
       let leftViewport = leftView.getViewport(webglLayer);
       let rightViewport = rightView.getViewport(webglLayer);
 
       // Ensure the views report the expected viewports into the WebGL layer.
       t.step( () => {
-        assert_true(leftViewport instanceof VRViewport);
-        assert_true(rightViewport instanceof VRViewport);
+        assert_true(leftViewport instanceof XRViewport);
+        assert_true(rightViewport instanceof XRViewport);
 
         assert_not_equals(leftViewport, null);
         assert_not_equals(rightViewport, null);
@@ -58,13 +58,13 @@
         // Assumes that the left viewport will always be physically to the left
         // of the right viewport.
         assert_less_than_equal(leftViewport.x + leftViewport.width, rightViewport.x);
-      }, "VRViewports do not overlap");
+      }, "XRViewports do not overlap");
       t.done();
     }
 
     session.requestFrame(onFrame);
   });
 }, fakeDisplays["Pixel"], { exclusive: true },
-"VRViewport attributes are valid");
+"XRViewport attributes are valid");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrWebGLLayer_framebuffer_draw.html b/third_party/WebKit/LayoutTests/xr/xrWebGLLayer_framebuffer_draw.html
similarity index 79%
rename from third_party/WebKit/LayoutTests/vr/latest/vrWebGLLayer_framebuffer_draw.html
rename to third_party/WebKit/LayoutTests/xr/xrWebGLLayer_framebuffer_draw.html
index ee66b87..2640136 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrWebGLLayer_framebuffer_draw.html
+++ b/third_party/WebKit/LayoutTests/xr/xrWebGLLayer_framebuffer_draw.html

@@ -1,13 +1,13 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
@@ -31,7 +31,7 @@
   return program;
 }
 
-vr_session_test( (t, session, mockService) => {
+xr_session_test( (t, session, mockService) => {
   // Setup simple WebGL geometry to draw with.
   let program = setupProgram(gl,
     "attribute vec4 vPosition; void main() { gl_Position = vPosition; }",
@@ -49,17 +49,17 @@
   gl.bufferData(gl.ELEMENT_ARRAY_BUFFER, new Uint16Array([ 0, 1, 2]), gl.STATIC_DRAW);
 
   // Session must have a baseLayer or frame requests will be ignored.
-  let webglLayer = new VRWebGLLayer(session, gl);
+  let webglLayer = new XRWebGLLayer(session, gl);
   session.baseLayer = webglLayer;
 
-  let vrFramebuffer = webglLayer.framebuffer;
+  let xrFramebuffer = webglLayer.framebuffer;
 
   function runDrawTests(t, expectedError) {
     t.step( () => {
       // Make sure we're starting with a clean error slate.
       assert_equals(gl.getError(), gl.NO_ERROR);
 
-      gl.bindFramebuffer(gl.FRAMEBUFFER, vrFramebuffer);
+      gl.bindFramebuffer(gl.FRAMEBUFFER, xrFramebuffer);
       assert_equals(gl.getError(), gl.NO_ERROR);
     }, "Framebuffer must be bindable");
 
@@ -82,16 +82,16 @@
     }, `Test drawElements, expect ${expectedError}`);
   }
 
-  // Drawing operations outside of a VR frame should fail.
+  // Drawing operations outside of a XR frame should fail.
   runDrawTests(t, "INVALID_FRAMEBUFFER_OPERATION");
 
-  // Drawing operations within a VR frame should succeed.
-  session.requestFrame((vrFrame) => {
+  // Drawing operations within a XR frame should succeed.
+  session.requestFrame((xrFrame) => {
     runDrawTests(t, "NO_ERROR");
     t.done();
   });
 
 }, fakeDisplays["Pixel"], { exclusive: true },
-"Ensure a WebGL layer's framebuffer can only be drawn to inside a VR frame");
+"Ensure a WebGL layer's framebuffer can only be drawn to inside a XR frame");
 
 </script>

diff --git a/third_party/WebKit/LayoutTests/vr/latest/vrWebGLLayer_opaque_framebuffer.html b/third_party/WebKit/LayoutTests/xr/xrWebGLLayer_opaque_framebuffer.html
similarity index 80%
rename from third_party/WebKit/LayoutTests/vr/latest/vrWebGLLayer_opaque_framebuffer.html
rename to third_party/WebKit/LayoutTests/xr/xrWebGLLayer_opaque_framebuffer.html
index 8c5ae6e..202b98bd 100644
--- a/third_party/WebKit/LayoutTests/vr/latest/vrWebGLLayer_opaque_framebuffer.html
+++ b/third_party/WebKit/LayoutTests/xr/xrWebGLLayer_opaque_framebuffer.html

@@ -1,42 +1,42 @@
 <!DOCTYPE html>
-<script src="../../resources/testharness.js"></script>
-<script src="../../resources/testharnessreport.js"></script>
-<script src="../resources/fake-vr-displays.js"></script>
+<script src="../resources/testharness.js"></script>
+<script src="../resources/testharnessreport.js"></script>
+<script src="../vr/resources/fake-vr-displays.js"></script>
 <script src="file:///gen/layout_test_data/mojo/public/js/mojo_bindings.js"></script>
 <script src="file:///gen/device/vr/vr_service.mojom.js"></script>
-<script src="../resources/mock-vr-service.js"></script>
-<script src="../resources/test-constants.js"></script>
+<script src="../vr/resources/mock-vr-service.js"></script>
+<script src="../vr/resources/test-constants.js"></script>
 <canvas id="webgl-canvas"></canvas>
-<script src="../resources/presentation-setup.js"></script>
+<script src="../vr/resources/presentation-setup.js"></script>
 <script>
 let fakeDisplays = fakeVRDisplays();
 
-vr_session_test( (t, session, mockService) => {
+xr_session_test( (t, session, mockService) => {
   // Session must have a baseLayer or frame requests will be ignored.
-  let webglLayer = new VRWebGLLayer(session, gl);
+  let webglLayer = new XRWebGLLayer(session, gl);
   session.baseLayer = webglLayer;
 
-  let vrFramebuffer = webglLayer.framebuffer;
+  let xrFramebuffer = webglLayer.framebuffer;
 
   t.step( () => {
     // Make sure we're starting with a clean error slate.
     assert_equals(gl.getError(), gl.NO_ERROR);
 
-    assert_not_equals(vrFramebuffer, null);
+    assert_not_equals(xrFramebuffer, null);
     assert_greater_than(webglLayer.framebufferWidth, 0);
     assert_greater_than(webglLayer.framebufferHeight, 0);
 
-    gl.bindFramebuffer(gl.FRAMEBUFFER, vrFramebuffer);
+    gl.bindFramebuffer(gl.FRAMEBUFFER, xrFramebuffer);
     assert_equals(gl.getError(), gl.NO_ERROR);
   }, "Framebuffer must be non-null, non-zero size, bindable.");
 
   t.step( () => {
-    gl.deleteFramebuffer(vrFramebuffer);
+    gl.deleteFramebuffer(xrFramebuffer);
     assert_equals(gl.getError(), gl.INVALID_OPERATION);
 
     // Make sure the framebuffer is still bound after failed attempt to delete.
     let boundFramebuffer = gl.getParameter(gl.FRAMEBUFFER_BINDING);
-    assert_equals(vrFramebuffer, boundFramebuffer);
+    assert_equals(xrFramebuffer, boundFramebuffer);
     assert_equals(gl.getError(), gl.NO_ERROR);
   }, "Ensure the framebuffer cannot be deleted");
 
@@ -93,12 +93,12 @@
 
   t.step( () => {
     assert_equals(gl.checkFramebufferStatus(gl.FRAMEBUFFER), gl.FRAMEBUFFER_UNSUPPORTED);
-  }, "Framebuffer status must be unsupported outside of a VR frame callback");
+  }, "Framebuffer status must be unsupported outside of a XR frame callback");
 
-  session.requestFrame((vrFrame) => {
+  session.requestFrame((xrFrame) => {
     t.step( () => {
       assert_equals(gl.checkFramebufferStatus(gl.FRAMEBUFFER), gl.FRAMEBUFFER_COMPLETE);
-    }, "Framebuffer status must be complete inside of a VR frame callback");
+    }, "Framebuffer status must be complete inside of a XR frame callback");
 
     t.done();
   });

diff --git a/third_party/WebKit/Source/bindings/modules/BUILD.gn b/third_party/WebKit/Source/bindings/modules/BUILD.gn
index cc39640..4443a9e 100644
--- a/third_party/WebKit/Source/bindings/modules/BUILD.gn
+++ b/third_party/WebKit/Source/bindings/modules/BUILD.gn

@@ -54,14 +54,14 @@
     "//third_party/WebKit/Source/modules/speech/SpeechSynthesisEvent.idl",
     "//third_party/WebKit/Source/modules/storage/StorageEvent.idl",
     "//third_party/WebKit/Source/modules/vr/VRDisplayEvent.idl",
-    "//third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.idl",
-    "//third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.idl",
     "//third_party/WebKit/Source/modules/webaudio/AudioProcessingEvent.idl",
     "//third_party/WebKit/Source/modules/webaudio/OfflineAudioCompletionEvent.idl",
     "//third_party/WebKit/Source/modules/webgl/WebGLContextEvent.idl",
     "//third_party/WebKit/Source/modules/webmidi/MIDIConnectionEvent.idl",
     "//third_party/WebKit/Source/modules/webmidi/MIDIMessageEvent.idl",
     "//third_party/WebKit/Source/modules/websockets/CloseEvent.idl",
+    "//third_party/WebKit/Source/modules/xr/XRDeviceEvent.idl",
+    "//third_party/WebKit/Source/modules/xr/XRSessionEvent.idl",
   ]
   output_file = "event_modules_names.json5"
   suffix = "Modules"

diff --git a/third_party/WebKit/Source/bindings/modules/v8/generated.gni b/third_party/WebKit/Source/bindings/modules/v8/generated.gni
index 357c8b5..af45f24 100644
--- a/third_party/WebKit/Source/bindings/modules/v8/generated.gni
+++ b/third_party/WebKit/Source/bindings/modules/v8/generated.gni

@@ -105,8 +105,8 @@
   "$bindings_modules_v8_output_dir/v8_position_error_callback.h",
   "$bindings_modules_v8_output_dir/v8_remote_playback_availability_callback.cc",
   "$bindings_modules_v8_output_dir/v8_remote_playback_availability_callback.h",
-  "$bindings_modules_v8_output_dir/v8_vr_frame_request_callback.cc",
-  "$bindings_modules_v8_output_dir/v8_vr_frame_request_callback.h",
+  "$bindings_modules_v8_output_dir/v8_xr_frame_request_callback.cc",
+  "$bindings_modules_v8_output_dir/v8_xr_frame_request_callback.h",
 ]
 
 bindings_generated_v8_context_snapshot_external_references_file =

diff --git a/third_party/WebKit/Source/modules/BUILD.gn b/third_party/WebKit/Source/modules/BUILD.gn
index 291e8749..19eb45f 100644
--- a/third_party/WebKit/Source/modules/BUILD.gn
+++ b/third_party/WebKit/Source/modules/BUILD.gn

@@ -160,6 +160,7 @@
     "//third_party/WebKit/Source/modules/webshare",
     "//third_party/WebKit/Source/modules/websockets",
     "//third_party/WebKit/Source/modules/webusb",
+    "//third_party/WebKit/Source/modules/xr",
     "//third_party/icu",
     "//third_party/sqlite",
     "//third_party/zlib",

diff --git a/third_party/WebKit/Source/modules/event_target_modules_names.json5 b/third_party/WebKit/Source/modules/event_target_modules_names.json5
index 6c490b9..3713fd9 100644
--- a/third_party/WebKit/Source/modules/event_target_modules_names.json5
+++ b/third_party/WebKit/Source/modules/event_target_modules_names.json5

@@ -45,14 +45,14 @@
     "modules/speech/SpeechSynthesis",
     "modules/speech/SpeechSynthesisUtterance",
     "modules/vr/VRDisplay",
-    "modules/vr/latest/VR",
-    "modules/vr/latest/VRDevice",
-    "modules/vr/latest/VRSession",
     "modules/webaudio/AudioContext",
     "modules/webaudio/AudioNode",
     "modules/webmidi/MIDIAccess",
     "modules/webmidi/MIDIInput",
     "modules/webmidi/MIDIPort",
+    "modules/xr/XR",
+    "modules/xr/XRDevice",
+    "modules/xr/XRSession",
     {
       name: "modules/websockets/WebSocket",
       ImplementedAs: "DOMWebSocket",

diff --git a/third_party/WebKit/Source/modules/modules_idl_files.gni b/third_party/WebKit/Source/modules/modules_idl_files.gni
index 40aab5c..925c67b 100644
--- a/third_party/WebKit/Source/modules/modules_idl_files.gni
+++ b/third_party/WebKit/Source/modules/modules_idl_files.gni

@@ -301,21 +301,6 @@
           "vr/VRFrameData.idl",
           "vr/VRPose.idl",
           "vr/VRStageParameters.idl",
-          "vr/latest/VR.idl",
-          "vr/latest/VRCoordinateSystem.idl",
-          "vr/latest/VRDevice.idl",
-          "vr/latest/VRDevicePose.idl",
-          "vr/latest/VRDeviceEvent.idl",
-          "vr/latest/VRFrameOfReference.idl",
-          "vr/latest/VRLayer.idl",
-          "vr/latest/VRPresentationFrame.idl",
-          "vr/latest/VRSession.idl",
-          "vr/latest/VRSessionEvent.idl",
-          "vr/latest/VRStageBounds.idl",
-          "vr/latest/VRStageBoundsPoint.idl",
-          "vr/latest/VRView.idl",
-          "vr/latest/VRViewport.idl",
-          "vr/latest/VRWebGLLayer.idl",
           "webaudio/AnalyserNode.idl",
           "webaudio/AudioBuffer.idl",
           "webaudio/AudioBufferSourceNode.idl",
@@ -434,11 +419,26 @@
           "webusb/USBIsochronousOutTransferPacket.idl",
           "webusb/USBIsochronousOutTransferResult.idl",
           "webusb/USBOutTransferResult.idl",
+          "xr/XR.idl",
+          "xr/XRCoordinateSystem.idl",
+          "xr/XRDevice.idl",
+          "xr/XRDevicePose.idl",
+          "xr/XRDeviceEvent.idl",
+          "xr/XRFrameOfReference.idl",
+          "xr/XRLayer.idl",
+          "xr/XRPresentationFrame.idl",
+          "xr/XRSession.idl",
+          "xr/XRSessionEvent.idl",
+          "xr/XRStageBounds.idl",
+          "xr/XRStageBoundsPoint.idl",
+          "xr/XRView.idl",
+          "xr/XRViewport.idl",
+          "xr/XRWebGLLayer.idl",
         ],
         "abspath")
 
 modules_callback_function_idl_files =
-    get_path_info([ "vr/latest/VRFrameRequestCallback.idl" ], "abspath")
+    get_path_info([ "xr/XRFrameRequestCallback.idl" ], "abspath")
 
 modules_dictionary_idl_files =
     get_path_info([
@@ -586,11 +586,6 @@
                     "storage/StorageEventInit.idl",
                     "vr/VRDisplayEventInit.idl",
                     "vr/VRLayerInit.idl",
-                    "vr/latest/VRDeviceEventInit.idl",
-                    "vr/latest/VRFrameOfReferenceOptions.idl",
-                    "vr/latest/VRSessionCreationOptions.idl",
-                    "vr/latest/VRSessionEventInit.idl",
-                    "vr/latest/VRWebGLLayerInit.idl",
                     "webaudio/AnalyserOptions.idl",
                     "webaudio/AudioBufferOptions.idl",
                     "webaudio/AudioBufferSourceOptions.idl",
@@ -630,6 +625,11 @@
                     "webusb/USBControlTransferParameters.idl",
                     "webusb/USBDeviceFilter.idl",
                     "webusb/USBDeviceRequestOptions.idl",
+                    "xr/XRDeviceEventInit.idl",
+                    "xr/XRFrameOfReferenceOptions.idl",
+                    "xr/XRSessionCreationOptions.idl",
+                    "xr/XRSessionEventInit.idl",
+                    "xr/XRWebGLLayerInit.idl",
                   ],
                   "abspath")
 

diff --git a/third_party/WebKit/Source/modules/vr/BUILD.gn b/third_party/WebKit/Source/modules/vr/BUILD.gn
index 3b0ee8a..d00089e6 100644
--- a/third_party/WebKit/Source/modules/vr/BUILD.gn
+++ b/third_party/WebKit/Source/modules/vr/BUILD.gn

@@ -26,40 +26,6 @@
     "VRPose.h",
     "VRStageParameters.cpp",
     "VRStageParameters.h",
-    "latest/VR.cpp",
-    "latest/VR.h",
-    "latest/VRCoordinateSystem.cpp",
-    "latest/VRCoordinateSystem.h",
-    "latest/VRDevice.cpp",
-    "latest/VRDevice.h",
-    "latest/VRDeviceEvent.cpp",
-    "latest/VRDeviceEvent.h",
-    "latest/VRDevicePose.cpp",
-    "latest/VRDevicePose.h",
-    "latest/VRFrameOfReference.cpp",
-    "latest/VRFrameOfReference.h",
-    "latest/VRFrameProvider.cpp",
-    "latest/VRFrameProvider.h",
-    "latest/VRFrameRequestCallbackCollection.cpp",
-    "latest/VRFrameRequestCallbackCollection.h",
-    "latest/VRLayer.cpp",
-    "latest/VRLayer.h",
-    "latest/VRPresentationFrame.cpp",
-    "latest/VRPresentationFrame.h",
-    "latest/VRSession.cpp",
-    "latest/VRSession.h",
-    "latest/VRSessionEvent.cpp",
-    "latest/VRSessionEvent.h",
-    "latest/VRStageBounds.cpp",
-    "latest/VRStageBounds.h",
-    "latest/VRStageBoundsPoint.h",
-    "latest/VRView.cpp",
-    "latest/VRView.h",
-    "latest/VRViewport.h",
-    "latest/VRWebGLDrawingBuffer.cpp",
-    "latest/VRWebGLDrawingBuffer.h",
-    "latest/VRWebGLLayer.cpp",
-    "latest/VRWebGLLayer.h",
   ]
 
   deps = [

diff --git a/third_party/WebKit/Source/modules/vr/NavigatorVR.cpp b/third_party/WebKit/Source/modules/vr/NavigatorVR.cpp
index befb48f..4283e05 100644
--- a/third_party/WebKit/Source/modules/vr/NavigatorVR.cpp
+++ b/third_party/WebKit/Source/modules/vr/NavigatorVR.cpp

@@ -19,7 +19,7 @@
 #include "modules/vr/VRDisplay.h"
 #include "modules/vr/VRGetDevicesCallback.h"
 #include "modules/vr/VRPose.h"
-#include "modules/vr/latest/VR.h"
+#include "modules/xr/XR.h"
 #include "platform/feature_policy/FeaturePolicy.h"
 #include "platform/wtf/PtrUtil.h"
 #include "public/platform/Platform.h"
@@ -39,7 +39,7 @@
     "The object is no longer associated with a document.";
 
 const char kCannotUseBothNewAndOldAPIMessage[] =
-    "Cannot use navigator.getVRDisplays if the latest VR API is already in "
+    "Cannot use navigator.getVRDisplays if the XR API is already in "
     "use.";
 
 }  // namespace
@@ -61,21 +61,21 @@
   return *supplement;
 }
 
-VR* NavigatorVR::vr(Navigator& navigator) {
+XR* NavigatorVR::xr(Navigator& navigator) {
   // Always return null when the navigator is detached.
   if (!navigator.GetFrame())
     return nullptr;
 
-  return NavigatorVR::From(navigator).vr();
+  return NavigatorVR::From(navigator).xr();
 }
 
-VR* NavigatorVR::vr() {
+XR* NavigatorVR::xr() {
   LocalFrame* frame = GetSupplementable()->GetFrame();
   // Always return null when the navigator is detached.
   if (!frame)
     return nullptr;
 
-  if (!vr_) {
+  if (!xr_) {
     // For the sake of simplicity we're going to block developers from using the
     // new API if they've already made calls to the legacy API.
     if (controller_) {
@@ -87,9 +87,9 @@
       return nullptr;
     }
 
-    vr_ = VR::Create(*frame);
+    xr_ = XR::Create(*frame);
   }
-  return vr_;
+  return xr_;
 }
 
 ScriptPromise NavigatorVR::getVRDisplays(ScriptState* script_state,
@@ -134,7 +134,7 @@
 
   // Similar to the restriciton above, we're going to block developers from
   // using the legacy API if they've already made calls to the new API.
-  if (vr_) {
+  if (xr_) {
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(kInvalidStateError,
                                            kCannotUseBothNewAndOldAPIMessage));
@@ -176,7 +176,7 @@
 }
 
 void NavigatorVR::Trace(blink::Visitor* visitor) {
-  visitor->Trace(vr_);
+  visitor->Trace(xr_);
   visitor->Trace(controller_);
   Supplement<Navigator>::Trace(visitor);
 }
@@ -225,7 +225,7 @@
 void NavigatorVR::DidAddEventListener(LocalDOMWindow* window,
                                       const AtomicString& event_type) {
   // Don't bother if we're using the newer API
-  if (vr_)
+  if (xr_)
     return;
 
   if (event_type == EventTypeNames::vrdisplayactivate) {
@@ -241,7 +241,7 @@
 void NavigatorVR::DidRemoveEventListener(LocalDOMWindow* window,
                                          const AtomicString& event_type) {
   // Don't bother if we're using the newer API
-  if (vr_)
+  if (xr_)
     return;
 
   if (event_type == EventTypeNames::vrdisplayactivate &&
@@ -252,7 +252,7 @@
 }
 
 void NavigatorVR::DidRemoveAllEventListeners(LocalDOMWindow* window) {
-  if (vr_ || !controller_)
+  if (xr_ || !controller_)
     return;
 
   controller_->SetListeningForActivate(false);

diff --git a/third_party/WebKit/Source/modules/vr/NavigatorVR.h b/third_party/WebKit/Source/modules/vr/NavigatorVR.h
index c9f78aae..ffae86f 100644
--- a/third_party/WebKit/Source/modules/vr/NavigatorVR.h
+++ b/third_party/WebKit/Source/modules/vr/NavigatorVR.h

@@ -20,7 +20,7 @@
 
 class Document;
 class Navigator;
-class VR;
+class XR;
 class VRController;
 
 class MODULES_EXPORT NavigatorVR final
@@ -36,9 +36,11 @@
   static NavigatorVR& From(Navigator&);
   ~NavigatorVR() override;
 
-  // Latest API
-  static VR* vr(Navigator&);
-  VR* vr();
+  // XR API
+  // TODO(offenwanger) Should eventually move this out into it's own separate
+  // Navigator supplement.
+  static XR* xr(Navigator&);
+  XR* xr();
 
   // Legacy API
   static ScriptPromise getVRDisplays(ScriptState*, Navigator&);
@@ -74,7 +76,7 @@
 
   void FireVRDisplayPresentChange(VRDisplay*);
 
-  Member<VR> vr_;
+  Member<XR> xr_;
   Member<VRController> controller_;
 
   // Whether this page is listening for vrdisplayactivate event.

diff --git a/third_party/WebKit/Source/modules/vr/NavigatorVR.idl b/third_party/WebKit/Source/modules/vr/NavigatorVR.idl
index c6ce9d8..e4b9311 100644
--- a/third_party/WebKit/Source/modules/vr/NavigatorVR.idl
+++ b/third_party/WebKit/Source/modules/vr/NavigatorVR.idl

@@ -7,7 +7,7 @@
     ImplementedAs=NavigatorVR
 ] partial interface Navigator {
     // Latest API
-    [SecureContext, RuntimeEnabled=WebXR] readonly attribute VR vr;
+    [SecureContext, RuntimeEnabled=WebXR] readonly attribute XR xr;
 
     // Legacy API
     [OriginTrialEnabled=WebVR, CallWith=ScriptState] Promise getVRDisplays();

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.idl b/third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.idl
deleted file mode 100644
index 7f1e7a6..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.idl
+++ /dev/null

@@ -1,11 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrcoordinatesystem-interface
-[
-    SecureContext,
-    RuntimeEnabled=WebXR
-] interface VRCoordinateSystem {
-  Float32Array? getTransformTo(VRCoordinateSystem other);
-};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.cpp b/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.cpp
deleted file mode 100644
index 006bfe1..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.cpp
+++ /dev/null

@@ -1,32 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "modules/vr/latest/VRDeviceEvent.h"
-
-namespace blink {
-
-VRDeviceEvent::VRDeviceEvent() {}
-
-VRDeviceEvent::VRDeviceEvent(const AtomicString& type, VRDevice* device)
-    : Event(type, true, false), device_(device) {}
-
-VRDeviceEvent::VRDeviceEvent(const AtomicString& type,
-                             const VRDeviceEventInit& initializer)
-    : Event(type, initializer) {
-  if (initializer.hasDevice())
-    device_ = initializer.device();
-}
-
-VRDeviceEvent::~VRDeviceEvent() {}
-
-const AtomicString& VRDeviceEvent::InterfaceName() const {
-  return EventNames::VRDeviceEvent;
-}
-
-void VRDeviceEvent::Trace(blink::Visitor* visitor) {
-  visitor->Trace(device_);
-  Event::Trace(visitor);
-}
-
-}  // namespace blink

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.h b/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.h
deleted file mode 100644
index f3ddb54a..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.h
+++ /dev/null

@@ -1,46 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef VRDeviceEvent_h
-#define VRDeviceEvent_h
-
-#include "modules/EventModules.h"
-#include "modules/vr/latest/VRDevice.h"
-#include "modules/vr/latest/VRDeviceEventInit.h"
-
-namespace blink {
-
-class VRDeviceEvent final : public Event {
-  DEFINE_WRAPPERTYPEINFO();
-
- public:
-  static VRDeviceEvent* Create() { return new VRDeviceEvent; }
-  static VRDeviceEvent* Create(const AtomicString& type, VRDevice* device) {
-    return new VRDeviceEvent(type, device);
-  }
-
-  static VRDeviceEvent* Create(const AtomicString& type,
-                               const VRDeviceEventInit& initializer) {
-    return new VRDeviceEvent(type, initializer);
-  }
-
-  ~VRDeviceEvent() override;
-
-  VRDevice* device() const { return device_.Get(); }
-
-  const AtomicString& InterfaceName() const override;
-
-  void Trace(blink::Visitor*) override;
-
- private:
-  VRDeviceEvent();
-  VRDeviceEvent(const AtomicString& type, VRDevice*);
-  VRDeviceEvent(const AtomicString&, const VRDeviceEventInit&);
-
-  Member<VRDevice> device_;
-};
-
-}  // namespace blink
-
-#endif  // VRDisplayEvent_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.idl b/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.idl
deleted file mode 100644
index 2d6b510..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRDeviceEvent.idl
+++ /dev/null

@@ -1,12 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrdeviceevent-interface
-[
-    SecureContext,
-    RuntimeEnabled=WebXR,
-    Constructor(DOMString type, VRDeviceEventInit eventInitDict)
-] interface VRDeviceEvent : Event {
-  readonly attribute VRDevice device;
-};
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDeviceEventInit.idl b/third_party/WebKit/Source/modules/vr/latest/VRDeviceEventInit.idl
deleted file mode 100644
index 9d005753..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRDeviceEventInit.idl
+++ /dev/null

@@ -1,10 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrdeviceevent-interface
-[
-    SecureContext
-] dictionary VRDeviceEventInit : EventInit {
-  required VRDevice device;
-};
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.idl b/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.idl
deleted file mode 100644
index 754044f5..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.idl
+++ /dev/null

@@ -1,19 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrframeofreference-interface
-
-enum VRFrameOfReferenceType {
-  "headModel",
-  "eyeLevel",
-  "stage",
-};
-
-[
-    SecureContext,
-    RuntimeEnabled=WebXR
-] interface VRFrameOfReference : VRCoordinateSystem {
-  readonly attribute VRStageBounds? bounds;
-  readonly attribute double emulatedHeight;
-};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallback.idl b/third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallback.idl
deleted file mode 100644
index c5f799f4..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallback.idl
+++ /dev/null

@@ -1,6 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrframerequestcallback
-callback VRFrameRequestCallback = void (VRPresentationFrame frame);

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallbackCollection.cpp b/third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallbackCollection.cpp
deleted file mode 100644
index e165d846..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallbackCollection.cpp
+++ /dev/null

@@ -1,71 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "modules/vr/latest/VRFrameRequestCallbackCollection.h"
-
-#include "bindings/modules/v8/v8_vr_frame_request_callback.h"
-#include "core/inspector/InspectorTraceEvents.h"
-#include "core/probe/CoreProbes.h"
-#include "modules/vr/latest/VRPresentationFrame.h"
-#include "modules/vr/latest/VRSession.h"
-
-namespace blink {
-
-VRFrameRequestCallbackCollection::VRFrameRequestCallbackCollection(
-    ExecutionContext* context)
-    : context_(context) {}
-
-VRFrameRequestCallbackCollection::CallbackId
-VRFrameRequestCallbackCollection::RegisterCallback(
-    V8VRFrameRequestCallback* callback) {
-  CallbackId id = ++next_callback_id_;
-  callbacks_.Set(id, callback);
-  pending_callbacks_.push_back(id);
-
-  probe::AsyncTaskScheduledBreakable(context_, "VRRequestFrame", callback);
-  return id;
-}
-
-void VRFrameRequestCallbackCollection::CancelCallback(CallbackId id) {
-  if (IsValidCallbackId(id)) {
-    callbacks_.erase(id);
-  }
-}
-
-void VRFrameRequestCallbackCollection::ExecuteCallbacks(
-    VRSession* session,
-    VRPresentationFrame* frame) {
-  // First, generate a list of callbacks to consider.  Callbacks registered from
-  // this point on are considered only for the "next" frame, not this one.
-  DCHECK(callbacks_to_invoke_.IsEmpty());
-  callbacks_to_invoke_.swap(pending_callbacks_);
-
-  for (const auto& id : callbacks_to_invoke_) {
-    V8VRFrameRequestCallback* callback = callbacks_.Take(id);
-
-    // Callback won't be found if it was cancelled.
-    if (!callback)
-      continue;
-
-    probe::AsyncTask async_task(context_, callback);
-    probe::UserCallback probe(context_, "VRRequestFrame", AtomicString(), true);
-    callback->InvokeAndReportException(session, frame);
-  }
-
-  callbacks_to_invoke_.clear();
-}
-
-void VRFrameRequestCallbackCollection::Trace(blink::Visitor* visitor) {
-  visitor->Trace(callbacks_);
-  visitor->Trace(context_);
-}
-
-void VRFrameRequestCallbackCollection::TraceWrappers(
-    const blink::ScriptWrappableVisitor* visitor) const {
-  for (const auto& callback : callbacks_.Values()) {
-    visitor->TraceWrappers(callback);
-  }
-}
-
-}  // namespace blink

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRLayer.cpp b/third_party/WebKit/Source/modules/vr/latest/VRLayer.cpp
deleted file mode 100644
index 081b354..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRLayer.cpp
+++ /dev/null

@@ -1,26 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "modules/vr/latest/VRLayer.h"
-#include "modules/vr/latest/VRSession.h"
-
-namespace blink {
-
-VRLayer::VRLayer(VRSession* session, VRLayerType layer_type)
-    : session_(session), layer_type_(layer_type) {}
-
-VRViewport* VRLayer::GetViewport(VRView::Eye) {
-  return nullptr;
-}
-
-void VRLayer::OnFrameStart() {}
-void VRLayer::OnFrameEnd() {}
-void VRLayer::OnResize() {}
-
-void VRLayer::Trace(blink::Visitor* visitor) {
-  visitor->Trace(session_);
-  ScriptWrappable::Trace(visitor);
-}
-
-}  // namespace blink

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRLayer.h b/third_party/WebKit/Source/modules/vr/latest/VRLayer.h
deleted file mode 100644
index b277c416..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRLayer.h
+++ /dev/null

@@ -1,43 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef VRLayer_h
-#define VRLayer_h
-
-#include "modules/vr/latest/VRView.h"
-#include "platform/bindings/ScriptWrappable.h"
-#include "platform/heap/Handle.h"
-#include "platform/wtf/Forward.h"
-
-namespace blink {
-
-class VRSession;
-class VRViewport;
-
-enum VRLayerType { kVRWebGLLayerType };
-
-class VRLayer : public ScriptWrappable {
-  DEFINE_WRAPPERTYPEINFO();
-
- public:
-  VRLayer(VRSession*, VRLayerType);
-
-  VRSession* session() const { return session_; }
-  VRLayerType layerType() const { return layer_type_; }
-  virtual VRViewport* GetViewport(VRView::Eye);
-
-  virtual void OnFrameStart();
-  virtual void OnFrameEnd();
-  virtual void OnResize();
-
-  virtual void Trace(blink::Visitor*);
-
- private:
-  const Member<VRSession> session_;
-  VRLayerType layer_type_;
-};
-
-}  // namespace blink
-
-#endif  // VRLayer_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.idl b/third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.idl
deleted file mode 100644
index 977aa70..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.idl
+++ /dev/null

@@ -1,14 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrpresentationframe-interface
-[
-    SecureContext,
-    RuntimeEnabled=WebXR
-] interface VRPresentationFrame {
-  readonly attribute VRSession session;
-  readonly attribute FrozenArray<VRView> views;
-
-  VRDevicePose? getDevicePose(VRCoordinateSystem coordinateSystem);
-};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRSession.idl b/third_party/WebKit/Source/modules/vr/latest/VRSession.idl
deleted file mode 100644
index 547571b..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRSession.idl
+++ /dev/null

@@ -1,29 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrsession-interface
-[
-    SecureContext,
-    RuntimeEnabled=WebXR
-] interface VRSession : EventTarget {
-  readonly attribute VRDevice device;
-  readonly attribute boolean exclusive;
-
-  attribute double depthNear;
-  attribute double depthFar;
-
-  attribute VRLayer baseLayer;
-
-  attribute EventHandler onblur;
-  attribute EventHandler onfocus;
-  attribute EventHandler onresetpose;
-  attribute EventHandler onend;
-
-  [CallWith=ScriptState] Promise<VRFrameOfReference> requestFrameOfReference(VRFrameOfReferenceType type, [PermissiveDictionaryConversion] optional VRFrameOfReferenceOptions options);
-
-  long requestFrame(VRFrameRequestCallback callback);
-  void cancelFrame(long handle);
-
-  [CallWith=ScriptState] Promise<void> end();
-};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.cpp b/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.cpp
deleted file mode 100644
index 470c161..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.cpp
+++ /dev/null

@@ -1,32 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#include "modules/vr/latest/VRSessionEvent.h"
-
-namespace blink {
-
-VRSessionEvent::VRSessionEvent() {}
-
-VRSessionEvent::VRSessionEvent(const AtomicString& type, VRSession* session)
-    : Event(type, true, false), session_(session) {}
-
-VRSessionEvent::VRSessionEvent(const AtomicString& type,
-                               const VRSessionEventInit& initializer)
-    : Event(type, initializer) {
-  if (initializer.hasSession())
-    session_ = initializer.session();
-}
-
-VRSessionEvent::~VRSessionEvent() {}
-
-const AtomicString& VRSessionEvent::InterfaceName() const {
-  return EventNames::VRSessionEvent;
-}
-
-void VRSessionEvent::Trace(blink::Visitor* visitor) {
-  visitor->Trace(session_);
-  Event::Trace(visitor);
-}
-
-}  // namespace blink

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.h b/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.h
deleted file mode 100644
index 1445af6..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.h
+++ /dev/null

@@ -1,46 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef VRSessionEvent_h
-#define VRSessionEvent_h
-
-#include "modules/EventModules.h"
-#include "modules/vr/latest/VRSession.h"
-#include "modules/vr/latest/VRSessionEventInit.h"
-
-namespace blink {
-
-class VRSessionEvent final : public Event {
-  DEFINE_WRAPPERTYPEINFO();
-
- public:
-  static VRSessionEvent* Create() { return new VRSessionEvent; }
-  static VRSessionEvent* Create(const AtomicString& type, VRSession* session) {
-    return new VRSessionEvent(type, session);
-  }
-
-  static VRSessionEvent* Create(const AtomicString& type,
-                                const VRSessionEventInit& initializer) {
-    return new VRSessionEvent(type, initializer);
-  }
-
-  ~VRSessionEvent() override;
-
-  VRSession* session() const { return session_.Get(); }
-
-  const AtomicString& InterfaceName() const override;
-
-  void Trace(blink::Visitor*) override;
-
- private:
-  VRSessionEvent();
-  VRSessionEvent(const AtomicString& type, VRSession*);
-  VRSessionEvent(const AtomicString& type, const VRSessionEventInit&);
-
-  Member<VRSession> session_;
-};
-
-}  // namespace blink
-
-#endif  // VRDisplayEvent_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.idl b/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.idl
deleted file mode 100644
index ebc7423..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRSessionEvent.idl
+++ /dev/null

@@ -1,12 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrsessionevent-interface
-[
-    SecureContext,
-    RuntimeEnabled=WebXR,
-    Constructor(DOMString type, VRSessionEventInit eventInitDict)
-] interface VRSessionEvent : Event {
-  readonly attribute VRSession session;
-};
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRSessionEventInit.idl b/third_party/WebKit/Source/modules/vr/latest/VRSessionEventInit.idl
deleted file mode 100644
index fc46fe2..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRSessionEventInit.idl
+++ /dev/null

@@ -1,10 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrsessionevent-interface
-[
-    SecureContext
-] dictionary VRSessionEventInit : EventInit {
-  required VRSession session;
-};
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRStageBounds.h b/third_party/WebKit/Source/modules/vr/latest/VRStageBounds.h
deleted file mode 100644
index d41bb7c..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRStageBounds.h
+++ /dev/null

@@ -1,31 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-#ifndef VRStageBounds_h
-#define VRStageBounds_h
-
-#include "modules/vr/latest/VRStageBoundsPoint.h"
-#include "platform/bindings/ScriptWrappable.h"
-#include "platform/heap/Handle.h"
-#include "platform/wtf/Forward.h"
-
-namespace blink {
-
-class VRStageBounds final : public ScriptWrappable {
-  DEFINE_WRAPPERTYPEINFO();
-
- public:
-  VRStageBounds() = default;
-
-  HeapVector<Member<VRStageBoundsPoint>> geometry() const { return geometry_; }
-
-  virtual void Trace(blink::Visitor*);
-
- private:
-  HeapVector<Member<VRStageBoundsPoint>> geometry_;
-};
-
-}  // namespace blink
-
-#endif  // VRStageBounds_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRStageBounds.idl b/third_party/WebKit/Source/modules/vr/latest/VRStageBounds.idl
deleted file mode 100644
index 974b0c8..0000000
--- a/third_party/WebKit/Source/modules/vr/latest/VRStageBounds.idl
+++ /dev/null

@@ -1,11 +0,0 @@
-// Copyright 2017 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// https://w3c.github.io/webvr/spec/latest/#vrstagebounds-interface
-[
-    SecureContext,
-    RuntimeEnabled=WebXR
-] interface VRStageBounds {
-  readonly attribute FrozenArray<VRStageBoundsPoint> geometry;
-};

diff --git a/third_party/WebKit/Source/modules/xr/BUILD.gn b/third_party/WebKit/Source/modules/xr/BUILD.gn
new file mode 100644
index 0000000..1595b6b
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/BUILD.gn

@@ -0,0 +1,48 @@
+# Copyright 2017 The Chromium Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style license that can be
+# found in the LICENSE file.
+
+import("//third_party/WebKit/Source/modules/modules.gni")
+
+blink_modules_sources("xr") {
+  sources = [
+    "XR.cpp",
+    "XR.h",
+    "XRCoordinateSystem.cpp",
+    "XRCoordinateSystem.h",
+    "XRDevice.cpp",
+    "XRDevice.h",
+    "XRDeviceEvent.cpp",
+    "XRDeviceEvent.h",
+    "XRDevicePose.cpp",
+    "XRDevicePose.h",
+    "XRFrameOfReference.cpp",
+    "XRFrameOfReference.h",
+    "XRFrameProvider.cpp",
+    "XRFrameProvider.h",
+    "XRFrameRequestCallbackCollection.cpp",
+    "XRFrameRequestCallbackCollection.h",
+    "XRLayer.cpp",
+    "XRLayer.h",
+    "XRPresentationFrame.cpp",
+    "XRPresentationFrame.h",
+    "XRSession.cpp",
+    "XRSession.h",
+    "XRSessionEvent.cpp",
+    "XRSessionEvent.h",
+    "XRStageBounds.cpp",
+    "XRStageBounds.h",
+    "XRStageBoundsPoint.h",
+    "XRView.cpp",
+    "XRView.h",
+    "XRViewport.h",
+    "XRWebGLDrawingBuffer.cpp",
+    "XRWebGLDrawingBuffer.h",
+    "XRWebGLLayer.cpp",
+    "XRWebGLLayer.h",
+  ]
+
+  deps = [
+    "//device/vr:mojo_bindings_blink",
+  ]
+}

diff --git a/third_party/WebKit/Source/modules/xr/DEPS b/third_party/WebKit/Source/modules/xr/DEPS
new file mode 100644
index 0000000..a3b0b3b7
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/DEPS

@@ -0,0 +1,8 @@
+include_rules = [
+    "+mojo/public/cpp/bindings/binding.h",
+    "+mojo/public/cpp/system/platform_handle.h",
+    "+device/vr/vr_service.mojom-blink.h",
+    "+gpu/command_buffer/client/gles2_interface.h",
+    "+gpu/command_buffer/common/mailbox_holder.h",
+    "+ui/gfx/geometry",
+]

diff --git a/third_party/WebKit/Source/modules/xr/OWNERS b/third_party/WebKit/Source/modules/xr/OWNERS
new file mode 100644
index 0000000..26c48a2
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/OWNERS

@@ -0,0 +1,4 @@
+bajones@chromium.org
+klausw@chromium.org
+
+# COMPONENT: Blink>WebVR
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/vr/latest/VR.cpp b/third_party/WebKit/Source/modules/xr/XR.cpp
similarity index 76%
rename from third_party/WebKit/Source/modules/vr/latest/VR.cpp
rename to third_party/WebKit/Source/modules/xr/XR.cpp
index bd1bcf5..fca07495 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VR.cpp
+++ b/third_party/WebKit/Source/modules/xr/XR.cpp

@@ -2,15 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VR.h"
+#include "modules/xr/XR.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/EventTargetModules.h"
-#include "modules/vr/latest/VRDevice.h"
-#include "modules/vr/latest/VRDeviceEvent.h"
+#include "modules/xr/XRDevice.h"
+#include "modules/xr/XRDeviceEvent.h"
 #include "platform/feature_policy/FeaturePolicy.h"
 #include "public/platform/InterfaceProvider.h"
 #include "services/service_manager/public/cpp/interface_provider.h"
@@ -20,43 +20,43 @@
 namespace {
 
 const char kNavigatorDetachedError[] =
-    "The navigator.vr object is no longer associated with a document.";
+    "The navigator.xr object is no longer associated with a document.";
 
 const char kFeaturePolicyBlocked[] =
-    "Access to the feature \"vr\" is disallowed by feature policy.";
+    "Access to the feature \"xr\" is disallowed by feature policy.";
 
 const char kCrossOriginSubframeBlocked[] =
-    "Blocked call to navigator.vr.requestDevice inside a cross-origin "
+    "Blocked call to navigator.xr.requestDevice inside a cross-origin "
     "iframe because the frame has never been activated by the user.";
 
 }  // namespace
 
-VR::VR(LocalFrame& frame)
+XR::XR(LocalFrame& frame)
     : ContextLifecycleObserver(frame.GetDocument()),
       devices_synced_(false),
       binding_(this) {
   frame.GetInterfaceProvider().GetInterface(mojo::MakeRequest(&service_));
   service_.set_connection_error_handler(
-      WTF::Bind(&VR::Dispose, WrapWeakPersistent(this)));
+      WTF::Bind(&XR::Dispose, WrapWeakPersistent(this)));
 
   device::mojom::blink::VRServiceClientPtr client;
   binding_.Bind(mojo::MakeRequest(&client));
 
   // Setting the client kicks off a request for the details of any connected
-  // VRDevices.
+  // XRDevices.
   service_->SetClient(std::move(client),
-                      WTF::Bind(&VR::OnDevicesSynced, WrapPersistent(this)));
+                      WTF::Bind(&XR::OnDevicesSynced, WrapPersistent(this)));
 }
 
-ExecutionContext* VR::GetExecutionContext() const {
+ExecutionContext* XR::GetExecutionContext() const {
   return ContextLifecycleObserver::GetExecutionContext();
 }
 
-const AtomicString& VR::InterfaceName() const {
-  return EventTargetNames::VR;
+const AtomicString& XR::InterfaceName() const {
+  return EventTargetNames::XR;
 }
 
-ScriptPromise VR::requestDevice(ScriptState* script_state) {
+ScriptPromise XR::requestDevice(ScriptState* script_state) {
   LocalFrame* frame = GetFrame();
   if (!frame) {
     // Reject if the frame is inaccessible.
@@ -89,7 +89,7 @@
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
-  // If we've previously synced the VRDevices or no longer have a valid service
+  // If we've previously synced the XRDevices or no longer have a valid service
   // connection just use the current list. In the case of the service being
   // disconnected this will be an empty array.
   if (!service_ || devices_synced_) {
@@ -107,33 +107,33 @@
   return promise;
 }
 
-// Each time a new VRDevice is connected we'll recieve a VRDisplayPtr for it
+// Each time a new XRDevice is connected we'll recieve a XRDisplayPtr for it
 // here. Upon calling SetClient in the constructor we should receive one call
-// for each VRDevice that was already connected at the time.
-void VR::OnDisplayConnected(
+// for each XRDevice that was already connected at the time.
+void XR::OnDisplayConnected(
     device::mojom::blink::VRMagicWindowProviderPtr magic_window_provider,
     device::mojom::blink::VRDisplayHostPtr display,
     device::mojom::blink::VRDisplayClientRequest client_request,
     device::mojom::blink::VRDisplayInfoPtr display_info) {
-  VRDevice* vr_device =
-      new VRDevice(this, std::move(magic_window_provider), std::move(display),
+  XRDevice* xr_device =
+      new XRDevice(this, std::move(magic_window_provider), std::move(display),
                    std::move(client_request), std::move(display_info));
 
-  devices_.push_back(vr_device);
+  devices_.push_back(xr_device);
 
   DispatchEvent(
-      VRDeviceEvent::Create(EventTypeNames::deviceconnect, vr_device));
+      XRDeviceEvent::Create(EventTypeNames::deviceconnect, xr_device));
 }
 
-// Called when the VRService has called OnDevicesConnected for all active
-// VRDevices.
-void VR::OnDevicesSynced() {
+// Called when the XRService has called OnDevicesConnected for all active
+// XRDevices.
+void XR::OnDevicesSynced() {
   devices_synced_ = true;
   ResolveRequestDevice();
 }
 
-// Called when details for every connected VRDevice has been received.
-void VR::ResolveRequestDevice() {
+// Called when details for every connected XRDevice has been received.
+void XR::ResolveRequestDevice() {
   if (pending_devices_resolver_) {
     devices_.size() == 0 ? pending_devices_resolver_->Resolve()
                          : pending_devices_resolver_->Resolve(devices_[0]);
@@ -141,11 +141,11 @@
   }
 }
 
-void VR::ContextDestroyed(ExecutionContext*) {
+void XR::ContextDestroyed(ExecutionContext*) {
   Dispose();
 }
 
-void VR::Dispose() {
+void XR::Dispose() {
   // If the document context was destroyed, shut down the client connection
   // and never call the mojo service again.
   service_.reset();
@@ -162,7 +162,7 @@
   ResolveRequestDevice();
 }
 
-void VR::Trace(blink::Visitor* visitor) {
+void XR::Trace(blink::Visitor* visitor) {
   visitor->Trace(devices_);
   visitor->Trace(pending_devices_resolver_);
   ContextLifecycleObserver::Trace(visitor);

diff --git a/third_party/WebKit/Source/modules/vr/latest/VR.h b/third_party/WebKit/Source/modules/xr/XR.h
similarity index 84%
rename from third_party/WebKit/Source/modules/vr/latest/VR.h
rename to third_party/WebKit/Source/modules/xr/XR.h
index 4e4679f7..350404f2 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VR.h
+++ b/third_party/WebKit/Source/modules/xr/XR.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VR_h
-#define VR_h
+#ifndef XR_h
+#define XR_h
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "core/dom/ContextLifecycleObserver.h"
@@ -17,23 +17,23 @@
 namespace blink {
 
 class ScriptPromiseResolver;
-class VRDevice;
+class XRDevice;
 
-class VR final : public EventTargetWithInlineData,
+class XR final : public EventTargetWithInlineData,
                  public ContextLifecycleObserver,
                  public device::mojom::blink::VRServiceClient {
   DEFINE_WRAPPERTYPEINFO();
-  USING_GARBAGE_COLLECTED_MIXIN(VR);
+  USING_GARBAGE_COLLECTED_MIXIN(XR);
 
  public:
-  static VR* Create(LocalFrame& frame) { return new VR(frame); }
+  static XR* Create(LocalFrame& frame) { return new XR(frame); }
 
   DEFINE_ATTRIBUTE_EVENT_LISTENER(deviceconnect);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(devicedisconnect);
 
   ScriptPromise requestDevice(ScriptState*);
 
-  // VRServiceClient overrides.
+  // XRServiceClient overrides.
   void OnDisplayConnected(device::mojom::blink::VRMagicWindowProviderPtr,
                           device::mojom::blink::VRDisplayHostPtr,
                           device::mojom::blink::VRDisplayClientRequest,
@@ -51,14 +51,14 @@
   void Trace(blink::Visitor*) override;
 
  private:
-  explicit VR(LocalFrame& frame);
+  explicit XR(LocalFrame& frame);
 
   void OnDevicesSynced();
   void ResolveRequestDevice();
 
   bool devices_synced_;
 
-  HeapVector<Member<VRDevice>> devices_;
+  HeapVector<Member<XRDevice>> devices_;
   Member<ScriptPromiseResolver> pending_devices_resolver_;
   device::mojom::blink::VRServicePtr service_;
   mojo::Binding<device::mojom::blink::VRServiceClient> binding_;
@@ -66,4 +66,4 @@
 
 }  // namespace blink
 
-#endif  // VR_h
+#endif  // XR_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VR.idl b/third_party/WebKit/Source/modules/xr/XR.idl
similarity index 78%
rename from third_party/WebKit/Source/modules/vr/latest/VR.idl
rename to third_party/WebKit/Source/modules/xr/XR.idl
index 3eb3b7c..a7a9eff3 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VR.idl
+++ b/third_party/WebKit/Source/modules/xr/XR.idl

@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vr-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xr-interface
 [
     SecureContext,
     RuntimeEnabled=WebXR
-] interface VR : EventTarget {
+] interface XR : EventTarget {
   attribute EventHandler ondeviceconnect;
   attribute EventHandler ondevicedisconnect;
 

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.cpp b/third_party/WebKit/Source/modules/xr/XRCoordinateSystem.cpp
similarity index 70%
rename from third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.cpp
rename to third_party/WebKit/Source/modules/xr/XRCoordinateSystem.cpp
index f71e10b7..f39fb5fb 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRCoordinateSystem.cpp

@@ -2,21 +2,21 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRCoordinateSystem.h"
+#include "modules/xr/XRCoordinateSystem.h"
 
-#include "modules/vr/latest/VRSession.h"
+#include "modules/xr/XRSession.h"
 
 namespace blink {
 
-VRCoordinateSystem::VRCoordinateSystem(VRSession* session)
+XRCoordinateSystem::XRCoordinateSystem(XRSession* session)
     : session_(session) {}
 
-VRCoordinateSystem::~VRCoordinateSystem() {}
+XRCoordinateSystem::~XRCoordinateSystem() {}
 
 // If possible, get the matrix required to transform between two coordinate
 // systems.
-DOMFloat32Array* VRCoordinateSystem::getTransformTo(
-    VRCoordinateSystem* other) const {
+DOMFloat32Array* XRCoordinateSystem::getTransformTo(
+    XRCoordinateSystem* other) const {
   if (session_ != other->session()) {
     // Cannot get relationships between coordinate systems that belong to
     // different sessions.
@@ -29,7 +29,7 @@
   return nullptr;
 }
 
-void VRCoordinateSystem::Trace(blink::Visitor* visitor) {
+void XRCoordinateSystem::Trace(blink::Visitor* visitor) {
   visitor->Trace(session_);
   ScriptWrappable::Trace(visitor);
 }

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.h b/third_party/WebKit/Source/modules/xr/XRCoordinateSystem.h
similarity index 62%
rename from third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.h
rename to third_party/WebKit/Source/modules/xr/XRCoordinateSystem.h
index 7e25850..0c3a347 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRCoordinateSystem.h
+++ b/third_party/WebKit/Source/modules/xr/XRCoordinateSystem.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRCoordinateSystem_h
-#define VRCoordinateSystem_h
+#ifndef XRCoordinateSystem_h
+#define XRCoordinateSystem_h
 
 #include "core/typed_arrays/DOMTypedArray.h"
 #include "platform/bindings/ScriptWrappable.h"
@@ -13,18 +13,18 @@
 namespace blink {
 
 class TransformationMatrix;
-class VRSession;
+class XRSession;
 
-class VRCoordinateSystem : public ScriptWrappable {
+class XRCoordinateSystem : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  explicit VRCoordinateSystem(VRSession*);
-  virtual ~VRCoordinateSystem();
+  explicit XRCoordinateSystem(XRSession*);
+  virtual ~XRCoordinateSystem();
 
-  DOMFloat32Array* getTransformTo(VRCoordinateSystem*) const;
+  DOMFloat32Array* getTransformTo(XRCoordinateSystem*) const;
 
-  VRSession* session() { return session_; }
+  XRSession* session() { return session_; }
 
   virtual std::unique_ptr<TransformationMatrix> TransformBasePose(
       const TransformationMatrix& base_pose) = 0;
@@ -32,9 +32,9 @@
   virtual void Trace(blink::Visitor*);
 
  private:
-  const Member<VRSession> session_;
+  const Member<XRSession> session_;
 };
 
 }  // namespace blink
 
-#endif  // VRWebGLLayer_h
+#endif  // XRWebGLLayer_h

diff --git a/third_party/WebKit/Source/modules/xr/XRCoordinateSystem.idl b/third_party/WebKit/Source/modules/xr/XRCoordinateSystem.idl
new file mode 100644
index 0000000..dc32784
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRCoordinateSystem.idl

@@ -0,0 +1,11 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://immersive-web.github.io/webxr/spec/latest/#xrcoordinatesystem-interface
+[
+    SecureContext,
+    RuntimeEnabled=WebXR
+] interface XRCoordinateSystem {
+  Float32Array? getTransformTo(XRCoordinateSystem other);
+};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDevice.cpp b/third_party/WebKit/Source/modules/xr/XRDevice.cpp
similarity index 73%
rename from third_party/WebKit/Source/modules/vr/latest/VRDevice.cpp
rename to third_party/WebKit/Source/modules/xr/XRDevice.cpp
index 1a4bf17..d0cc1be6 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRDevice.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRDevice.cpp

@@ -2,58 +2,58 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRDevice.h"
+#include "modules/xr/XRDevice.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/frame/Frame.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/EventTargetModules.h"
-#include "modules/vr/latest/VR.h"
-#include "modules/vr/latest/VRFrameProvider.h"
-#include "modules/vr/latest/VRSession.h"
+#include "modules/xr/XR.h"
+#include "modules/xr/XRFrameProvider.h"
+#include "modules/xr/XRSession.h"
 
 namespace blink {
 
 namespace {
 
 const char kActiveExclusiveSession[] =
-    "VRDevice already has an active, exclusive session";
+    "XRDevice already has an active, exclusive session";
 
 const char kExclusiveNotSupported[] =
-    "VRDevice does not support the creation of exclusive sessions.";
+    "XRDevice does not support the creation of exclusive sessions.";
 
 const char kNonExclusiveNotSupported[] =
-    "VRDevice does not support the creation of non-exclusive sessions.";
+    "XRDevice does not support the creation of non-exclusive sessions.";
 
 const char kRequestNotInUserGesture[] =
     "Exclusive sessions can only be requested during a user gesture.";
 
 }  // namespace
 
-VRDevice::VRDevice(
-    VR* vr,
+XRDevice::XRDevice(
+    XR* xr,
     device::mojom::blink::VRMagicWindowProviderPtr magic_window_provider,
     device::mojom::blink::VRDisplayHostPtr display,
     device::mojom::blink::VRDisplayClientRequest client_request,
     device::mojom::blink::VRDisplayInfoPtr display_info)
-    : vr_(vr),
+    : xr_(xr),
       magic_window_provider_(std::move(magic_window_provider)),
       display_(std::move(display)),
       display_client_binding_(this, std::move(client_request)) {
-  SetVRDisplayInfo(std::move(display_info));
+  SetXRDisplayInfo(std::move(display_info));
 }
 
-ExecutionContext* VRDevice::GetExecutionContext() const {
-  return vr_->GetExecutionContext();
+ExecutionContext* XRDevice::GetExecutionContext() const {
+  return xr_->GetExecutionContext();
 }
 
-const AtomicString& VRDevice::InterfaceName() const {
-  return EventTargetNames::VRDevice;
+const AtomicString& XRDevice::InterfaceName() const {
+  return EventTargetNames::XRDevice;
 }
 
-const char* VRDevice::checkSessionSupport(
-    const VRSessionCreationOptions& options) const {
+const char* XRDevice::checkSessionSupport(
+    const XRSessionCreationOptions& options) const {
   if (options.exclusive()) {
     // Validation for exclusive sessions.
     if (!supports_exclusive_) {
@@ -68,9 +68,9 @@
   return nullptr;
 }
 
-ScriptPromise VRDevice::supportsSession(
+ScriptPromise XRDevice::supportsSession(
     ScriptState* script_state,
-    const VRSessionCreationOptions& options) const {
+    const XRSessionCreationOptions& options) const {
   // Check to see if the device is capable of supporting the requested session
   // options. Note that reporting support here does not guarantee that creating
   // a session with those options will succeed, as other external and
@@ -90,9 +90,9 @@
   return promise;
 }
 
-ScriptPromise VRDevice::requestSession(
+ScriptPromise XRDevice::requestSession(
     ScriptState* script_state,
-    const VRSessionCreationOptions& options) {
+    const XRSessionCreationOptions& options) {
   // Check first to see if the device is capable of supporting the requested
   // options.
   const char* reject_reason = checkSessionSupport(options);
@@ -121,7 +121,7 @@
   ScriptPromiseResolver* resolver = ScriptPromiseResolver::Create(script_state);
   ScriptPromise promise = resolver->Promise();
 
-  VRSession* session = new VRSession(this, options.exclusive());
+  XRSession* session = new XRSession(this, options.exclusive());
 
   if (options.exclusive()) {
     frameProvider()->BeginExclusiveSession(session, resolver);
@@ -133,28 +133,28 @@
 }
 
 // TODO: Forward these calls on to the sessions once they've been implemented.
-void VRDevice::OnChanged(device::mojom::blink::VRDisplayInfoPtr display_info) {
-  SetVRDisplayInfo(std::move(display_info));
+void XRDevice::OnChanged(device::mojom::blink::VRDisplayInfoPtr display_info) {
+  SetXRDisplayInfo(std::move(display_info));
 }
-void VRDevice::OnExitPresent() {}
-void VRDevice::OnBlur() {}
-void VRDevice::OnFocus() {}
-void VRDevice::OnActivate(device::mojom::blink::VRDisplayEventReason,
+void XRDevice::OnExitPresent() {}
+void XRDevice::OnBlur() {}
+void XRDevice::OnFocus() {}
+void XRDevice::OnActivate(device::mojom::blink::VRDisplayEventReason,
                           OnActivateCallback on_handled) {}
-void VRDevice::OnDeactivate(device::mojom::blink::VRDisplayEventReason) {}
+void XRDevice::OnDeactivate(device::mojom::blink::VRDisplayEventReason) {}
 
-VRFrameProvider* VRDevice::frameProvider() {
+XRFrameProvider* XRDevice::frameProvider() {
   if (!frame_provider_)
-    frame_provider_ = new VRFrameProvider(this);
+    frame_provider_ = new XRFrameProvider(this);
 
   return frame_provider_;
 }
 
-void VRDevice::Dispose() {
+void XRDevice::Dispose() {
   display_client_binding_.Close();
 }
 
-void VRDevice::SetVRDisplayInfo(
+void XRDevice::SetXRDisplayInfo(
     device::mojom::blink::VRDisplayInfoPtr display_info) {
   display_info_ = std::move(display_info);
   device_name_ = display_info_->displayName;
@@ -162,8 +162,8 @@
   supports_exclusive_ = (display_info_->capabilities->canPresent);
 }
 
-void VRDevice::Trace(blink::Visitor* visitor) {
-  visitor->Trace(vr_);
+void XRDevice::Trace(blink::Visitor* visitor) {
+  visitor->Trace(xr_);
   visitor->Trace(frame_provider_);
   EventTargetWithInlineData::Trace(visitor);
 }

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDevice.h b/third_party/WebKit/Source/modules/xr/XRDevice.h
similarity index 72%
rename from third_party/WebKit/Source/modules/vr/latest/VRDevice.h
rename to third_party/WebKit/Source/modules/xr/XRDevice.h
index 2c14f0b..385d1aa 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRDevice.h
+++ b/third_party/WebKit/Source/modules/xr/XRDevice.h

@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRDevice_h
-#define VRDevice_h
+#ifndef XRDevice_h
+#define XRDevice_h
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "core/dom/events/EventTarget.h"
 #include "device/vr/vr_service.mojom-blink.h"
-#include "modules/vr/latest/VRSessionCreationOptions.h"
+#include "modules/xr/XRSessionCreationOptions.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "platform/heap/Handle.h"
 #include "platform/wtf/Forward.h"
@@ -16,33 +16,33 @@
 
 namespace blink {
 
-class VR;
-class VRFrameProvider;
+class XR;
+class XRFrameProvider;
 
-class VRDevice final : public EventTargetWithInlineData,
+class XRDevice final : public EventTargetWithInlineData,
                        public device::mojom::blink::VRDisplayClient {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  VRDevice(VR*,
+  XRDevice(XR*,
            device::mojom::blink::VRMagicWindowProviderPtr,
            device::mojom::blink::VRDisplayHostPtr,
            device::mojom::blink::VRDisplayClientRequest,
            device::mojom::blink::VRDisplayInfoPtr);
-  VR* vr() const { return vr_; }
+  XR* xr() const { return xr_; }
 
   const String& deviceName() const { return device_name_; }
   bool isExternal() const { return is_external_; }
 
   ScriptPromise supportsSession(ScriptState*,
-                                const VRSessionCreationOptions&) const;
-  ScriptPromise requestSession(ScriptState*, const VRSessionCreationOptions&);
+                                const XRSessionCreationOptions&) const;
+  ScriptPromise requestSession(ScriptState*, const XRSessionCreationOptions&);
 
   // EventTarget overrides.
   ExecutionContext* GetExecutionContext() const override;
   const AtomicString& InterfaceName() const override;
 
-  // VRDisplayClient
+  // XRDisplayClient
   void OnChanged(device::mojom::blink::VRDisplayInfoPtr) override;
   void OnExitPresent() override;
   void OnBlur() override;
@@ -51,30 +51,30 @@
                   OnActivateCallback on_handled) override;
   void OnDeactivate(device::mojom::blink::VRDisplayEventReason) override;
 
-  VRFrameProvider* frameProvider();
+  XRFrameProvider* frameProvider();
 
   void Dispose();
 
-  const device::mojom::blink::VRDisplayHostPtr& vrDisplayHostPtr() const {
+  const device::mojom::blink::VRDisplayHostPtr& xrDisplayHostPtr() const {
     return display_;
   }
   const device::mojom::blink::VRMagicWindowProviderPtr&
-  vrMagicWindowProviderPtr() const {
+  xrMagicWindowProviderPtr() const {
     return magic_window_provider_;
   }
-  const device::mojom::blink::VRDisplayInfoPtr& vrDisplayInfoPtr() const {
+  const device::mojom::blink::VRDisplayInfoPtr& xrDisplayInfoPtr() const {
     return display_info_;
   }
 
   void Trace(blink::Visitor*) override;
 
  private:
-  void SetVRDisplayInfo(device::mojom::blink::VRDisplayInfoPtr);
+  void SetXRDisplayInfo(device::mojom::blink::VRDisplayInfoPtr);
 
-  const char* checkSessionSupport(const VRSessionCreationOptions&) const;
+  const char* checkSessionSupport(const XRSessionCreationOptions&) const;
 
-  Member<VR> vr_;
-  Member<VRFrameProvider> frame_provider_;
+  Member<XR> xr_;
+  Member<XRFrameProvider> frame_provider_;
   String device_name_;
   bool is_external_;
   bool supports_exclusive_;
@@ -88,4 +88,4 @@
 
 }  // namespace blink
 
-#endif  // VRDevice_h
+#endif  // XRDevice_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDevice.idl b/third_party/WebKit/Source/modules/xr/XRDevice.idl
similarity index 64%
rename from third_party/WebKit/Source/modules/vr/latest/VRDevice.idl
rename to third_party/WebKit/Source/modules/xr/XRDevice.idl
index ae72864..72830f9 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRDevice.idl
+++ b/third_party/WebKit/Source/modules/xr/XRDevice.idl

@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrdevice-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrdevice-interface
 [
     SecureContext,
     RuntimeEnabled=WebXR
-] interface VRDevice : EventTarget {
+] interface XRDevice : EventTarget {
   readonly attribute DOMString deviceName;
   readonly attribute boolean isExternal;
 
-  [CallWith=ScriptState] Promise supportsSession([PermissiveDictionaryConversion] optional VRSessionCreationOptions options);
-  [CallWith=ScriptState] Promise requestSession([PermissiveDictionaryConversion] optional VRSessionCreationOptions options);
+  [CallWith=ScriptState] Promise supportsSession([PermissiveDictionaryConversion] optional XRSessionCreationOptions options);
+  [CallWith=ScriptState] Promise requestSession([PermissiveDictionaryConversion] optional XRSessionCreationOptions options);
 };

diff --git a/third_party/WebKit/Source/modules/xr/XRDeviceEvent.cpp b/third_party/WebKit/Source/modules/xr/XRDeviceEvent.cpp
new file mode 100644
index 0000000..7473a97
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRDeviceEvent.cpp

@@ -0,0 +1,32 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "modules/xr/XRDeviceEvent.h"
+
+namespace blink {
+
+XRDeviceEvent::XRDeviceEvent() {}
+
+XRDeviceEvent::XRDeviceEvent(const AtomicString& type, XRDevice* device)
+    : Event(type, true, false), device_(device) {}
+
+XRDeviceEvent::XRDeviceEvent(const AtomicString& type,
+                             const XRDeviceEventInit& initializer)
+    : Event(type, initializer) {
+  if (initializer.hasDevice())
+    device_ = initializer.device();
+}
+
+XRDeviceEvent::~XRDeviceEvent() {}
+
+const AtomicString& XRDeviceEvent::InterfaceName() const {
+  return EventNames::XRDeviceEvent;
+}
+
+void XRDeviceEvent::Trace(blink::Visitor* visitor) {
+  visitor->Trace(device_);
+  Event::Trace(visitor);
+}
+
+}  // namespace blink

diff --git a/third_party/WebKit/Source/modules/xr/XRDeviceEvent.h b/third_party/WebKit/Source/modules/xr/XRDeviceEvent.h
new file mode 100644
index 0000000..ddf4ac8
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRDeviceEvent.h

@@ -0,0 +1,46 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef XRDeviceEvent_h
+#define XRDeviceEvent_h
+
+#include "modules/EventModules.h"
+#include "modules/xr/XRDevice.h"
+#include "modules/xr/XRDeviceEventInit.h"
+
+namespace blink {
+
+class XRDeviceEvent final : public Event {
+  DEFINE_WRAPPERTYPEINFO();
+
+ public:
+  static XRDeviceEvent* Create() { return new XRDeviceEvent; }
+  static XRDeviceEvent* Create(const AtomicString& type, XRDevice* device) {
+    return new XRDeviceEvent(type, device);
+  }
+
+  static XRDeviceEvent* Create(const AtomicString& type,
+                               const XRDeviceEventInit& initializer) {
+    return new XRDeviceEvent(type, initializer);
+  }
+
+  ~XRDeviceEvent() override;
+
+  XRDevice* device() const { return device_.Get(); }
+
+  const AtomicString& InterfaceName() const override;
+
+  void Trace(blink::Visitor*) override;
+
+ private:
+  XRDeviceEvent();
+  XRDeviceEvent(const AtomicString& type, XRDevice*);
+  XRDeviceEvent(const AtomicString&, const XRDeviceEventInit&);
+
+  Member<XRDevice> device_;
+};
+
+}  // namespace blink
+
+#endif  // XRDisplayEvent_h

diff --git a/third_party/WebKit/Source/modules/xr/XRDeviceEvent.idl b/third_party/WebKit/Source/modules/xr/XRDeviceEvent.idl
new file mode 100644
index 0000000..cab15ad
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRDeviceEvent.idl

@@ -0,0 +1,12 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://w3c.github.io/webxr/spec/latest/#xrdeviceevent-interface
+[
+    SecureContext,
+    RuntimeEnabled=WebXR,
+    Constructor(DOMString type, XRDeviceEventInit eventInitDict)
+] interface XRDeviceEvent : Event {
+  readonly attribute XRDevice device;
+};
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/xr/XRDeviceEventInit.idl b/third_party/WebKit/Source/modules/xr/XRDeviceEventInit.idl
new file mode 100644
index 0000000..7ba5a0f
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRDeviceEventInit.idl

@@ -0,0 +1,10 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// TODO(offenwanger) Remove this interface.
+[
+    SecureContext
+] dictionary XRDeviceEventInit : EventInit {
+  required XRDevice device;
+};
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDevicePose.cpp b/third_party/WebKit/Source/modules/xr/XRDevicePose.cpp
similarity index 83%
rename from third_party/WebKit/Source/modules/vr/latest/VRDevicePose.cpp
rename to third_party/WebKit/Source/modules/xr/XRDevicePose.cpp
index 0816b69..9139590d 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRDevicePose.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRDevicePose.cpp

@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRDevicePose.h"
+#include "modules/xr/XRDevicePose.h"
 
-#include "modules/vr/latest/VRSession.h"
-#include "modules/vr/latest/VRView.h"
+#include "modules/xr/XRSession.h"
+#include "modules/xr/XRView.h"
 
 namespace blink {
 
@@ -28,18 +28,18 @@
 
 }  // namespace
 
-VRDevicePose::VRDevicePose(
-    VRSession* session,
+XRDevicePose::XRDevicePose(
+    XRSession* session,
     std::unique_ptr<TransformationMatrix> pose_model_matrix)
     : session_(session), pose_model_matrix_(std::move(pose_model_matrix)) {}
 
-DOMFloat32Array* VRDevicePose::poseModelMatrix() const {
+DOMFloat32Array* XRDevicePose::poseModelMatrix() const {
   if (!pose_model_matrix_)
     return nullptr;
   return transformationMatrixToFloat32Array(*pose_model_matrix_);
 }
 
-DOMFloat32Array* VRDevicePose::getViewMatrix(VRView* view) {
+DOMFloat32Array* XRDevicePose::getViewMatrix(XRView* view) {
   if (view->session() != session_)
     return nullptr;
 
@@ -57,7 +57,7 @@
   return transformationMatrixToFloat32Array(view_matrix);
 }
 
-void VRDevicePose::Trace(blink::Visitor* visitor) {
+void XRDevicePose::Trace(blink::Visitor* visitor) {
   visitor->Trace(session_);
   ScriptWrappable::Trace(visitor);
 }

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDevicePose.h b/third_party/WebKit/Source/modules/xr/XRDevicePose.h
similarity index 66%
rename from third_party/WebKit/Source/modules/vr/latest/VRDevicePose.h
rename to third_party/WebKit/Source/modules/xr/XRDevicePose.h
index 0661a1d6..9d3d80aa9 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRDevicePose.h
+++ b/third_party/WebKit/Source/modules/xr/XRDevicePose.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRDevicePose_h
-#define VRDevicePose_h
+#ifndef XRDevicePose_h
+#define XRDevicePose_h
 
 #include "core/typed_arrays/DOMTypedArray.h"
 #include "platform/bindings/ScriptWrappable.h"
@@ -12,25 +12,25 @@
 
 namespace blink {
 
-class VRSession;
-class VRView;
+class XRSession;
+class XRView;
 
-class VRDevicePose final : public ScriptWrappable {
+class XRDevicePose final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  VRDevicePose(VRSession*, std::unique_ptr<TransformationMatrix>);
+  XRDevicePose(XRSession*, std::unique_ptr<TransformationMatrix>);
 
   DOMFloat32Array* poseModelMatrix() const;
-  DOMFloat32Array* getViewMatrix(VRView*);
+  DOMFloat32Array* getViewMatrix(XRView*);
 
   virtual void Trace(blink::Visitor*);
 
  private:
-  const Member<VRSession> session_;
+  const Member<XRSession> session_;
   std::unique_ptr<TransformationMatrix> pose_model_matrix_;
 };
 
 }  // namespace blink
 
-#endif  // VRWebGLLayer_h
+#endif  // XRWebGLLayer_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRDevicePose.idl b/third_party/WebKit/Source/modules/xr/XRDevicePose.idl
similarity index 64%
rename from third_party/WebKit/Source/modules/vr/latest/VRDevicePose.idl
rename to third_party/WebKit/Source/modules/xr/XRDevicePose.idl
index 4ca5374..0958125 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRDevicePose.idl
+++ b/third_party/WebKit/Source/modules/xr/XRDevicePose.idl

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrdevicepose-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrdevicepose-interface
 [
     SecureContext,
     RuntimeEnabled=WebXR
-] interface VRDevicePose {
+] interface XRDevicePose {
   readonly attribute Float32Array poseModelMatrix;
 
-  Float32Array getViewMatrix(VRView view);
+  Float32Array getViewMatrix(XRView view);
 };

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.cpp b/third_party/WebKit/Source/modules/xr/XRFrameOfReference.cpp
similarity index 79%
rename from third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.cpp
rename to third_party/WebKit/Source/modules/xr/XRFrameOfReference.cpp
index 6f17b558..1410069 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRFrameOfReference.cpp

@@ -2,37 +2,37 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRFrameOfReference.h"
+#include "modules/xr/XRFrameOfReference.h"
 
-#include "modules/vr/latest/VRStageBounds.h"
+#include "modules/xr/XRStageBounds.h"
 
 namespace blink {
 
 // Rough estimate of avg human eye height in meters.
 const double kDefaultEmulationHeight = 1.6;
 
-VRFrameOfReference::VRFrameOfReference(VRSession* session, Type type)
-    : VRCoordinateSystem(session), type_(type) {}
+XRFrameOfReference::XRFrameOfReference(XRSession* session, Type type)
+    : XRCoordinateSystem(session), type_(type) {}
 
-VRFrameOfReference::~VRFrameOfReference() {}
+XRFrameOfReference::~XRFrameOfReference() {}
 
-void VRFrameOfReference::UpdatePoseTransform(
+void XRFrameOfReference::UpdatePoseTransform(
     std::unique_ptr<TransformationMatrix> transform) {
   pose_transform_ = std::move(transform);
 }
 
-void VRFrameOfReference::UpdateStageBounds(VRStageBounds* bounds) {
+void XRFrameOfReference::UpdateStageBounds(XRStageBounds* bounds) {
   bounds_ = bounds;
   // TODO(bajones): Fire a boundschange event
 }
 
 // Enables emulated height when using a stage frame of reference, which should
 // only be used if the sytem does not have a native concept of how far above the
-// floor the VRDevice is at any given moment. This applies a static vertical
+// floor the XRDevice is at any given moment. This applies a static vertical
 // offset to the coordinate system so that the user feels approximately like
 // they are standing on a floor plane located at Y = 0. An explicit offset in
 // meters can be given if the page has specific needs.
-void VRFrameOfReference::UseEmulatedHeight(double value) {
+void XRFrameOfReference::UseEmulatedHeight(double value) {
   if (value == 0.0) {
     value = kDefaultEmulationHeight;
   }
@@ -41,11 +41,11 @@
   pose_transform_->Translate3d(0, emulatedHeight_, 0);
 }
 
-// Transforms a given pose from a "base" coordinate system used by the VR
+// Transforms a given pose from a "base" coordinate system used by the XR
 // service to the frame of reference's coordinate system. This model is a bit
 // over-simplified and will need to be made more robust when we start dealing
 // with world-scale 6DoF tracking.
-std::unique_ptr<TransformationMatrix> VRFrameOfReference::TransformBasePose(
+std::unique_ptr<TransformationMatrix> XRFrameOfReference::TransformBasePose(
     const TransformationMatrix& base_pose) {
   switch (type_) {
     case kTypeHeadModel: {
@@ -81,9 +81,9 @@
   return nullptr;
 }
 
-void VRFrameOfReference::Trace(blink::Visitor* visitor) {
+void XRFrameOfReference::Trace(blink::Visitor* visitor) {
   visitor->Trace(bounds_);
-  VRCoordinateSystem::Trace(visitor);
+  XRCoordinateSystem::Trace(visitor);
 }
 
 }  // namespace blink

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.h b/third_party/WebKit/Source/modules/xr/XRFrameOfReference.h
similarity index 66%
rename from third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.h
rename to third_party/WebKit/Source/modules/xr/XRFrameOfReference.h
index f02490ff..67a9edb3 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReference.h
+++ b/third_party/WebKit/Source/modules/xr/XRFrameOfReference.h

@@ -2,33 +2,33 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRFrameOfReference_h
-#define VRFrameOfReference_h
+#ifndef XRFrameOfReference_h
+#define XRFrameOfReference_h
 
-#include "modules/vr/latest/VRCoordinateSystem.h"
+#include "modules/xr/XRCoordinateSystem.h"
 #include "platform/transforms/TransformationMatrix.h"
 
 namespace blink {
 
-class VRStageBounds;
+class XRStageBounds;
 
-class VRFrameOfReference final : public VRCoordinateSystem {
+class XRFrameOfReference final : public XRCoordinateSystem {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
   enum Type { kTypeHeadModel, kTypeEyeLevel, kTypeStage };
 
-  VRFrameOfReference(VRSession*, Type);
-  ~VRFrameOfReference() override;
+  XRFrameOfReference(XRSession*, Type);
+  ~XRFrameOfReference() override;
 
   void UpdatePoseTransform(std::unique_ptr<TransformationMatrix>);
-  void UpdateStageBounds(VRStageBounds*);
+  void UpdateStageBounds(XRStageBounds*);
   void UseEmulatedHeight(double value);
 
   std::unique_ptr<TransformationMatrix> TransformBasePose(
       const TransformationMatrix& base_pose) override;
 
-  VRStageBounds* bounds() const { return bounds_; }
+  XRStageBounds* bounds() const { return bounds_; }
   double emulatedHeight() const { return emulatedHeight_; }
 
   Type type() const { return type_; }
@@ -36,7 +36,7 @@
   void Trace(blink::Visitor*) override;
 
  private:
-  Member<VRStageBounds> bounds_;
+  Member<XRStageBounds> bounds_;
   double emulatedHeight_ = 0.0;
   Type type_;
   std::unique_ptr<TransformationMatrix> pose_transform_;
@@ -44,4 +44,4 @@
 
 }  // namespace blink
 
-#endif  // VRWebGLLayer_h
+#endif  // XRWebGLLayer_h

diff --git a/third_party/WebKit/Source/modules/xr/XRFrameOfReference.idl b/third_party/WebKit/Source/modules/xr/XRFrameOfReference.idl
new file mode 100644
index 0000000..2a751c1
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRFrameOfReference.idl

@@ -0,0 +1,19 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://immersive-web.github.io/webxr/spec/latest/#xrframeofreference-interface
+
+enum XRFrameOfReferenceType {
+  "headModel",
+  "eyeLevel",
+  "stage",
+};
+
+[
+    SecureContext,
+    RuntimeEnabled=WebXR
+] interface XRFrameOfReference : XRCoordinateSystem {
+  readonly attribute XRStageBounds? bounds;
+  readonly attribute double emulatedHeight;
+};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReferenceOptions.idl b/third_party/WebKit/Source/modules/xr/XRFrameOfReferenceOptions.idl
similarity index 68%
rename from third_party/WebKit/Source/modules/vr/latest/VRFrameOfReferenceOptions.idl
rename to third_party/WebKit/Source/modules/xr/XRFrameOfReferenceOptions.idl
index 7939bd85..e1bf41d7 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameOfReferenceOptions.idl
+++ b/third_party/WebKit/Source/modules/xr/XRFrameOfReferenceOptions.idl

@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrframeofreference-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrframeofreference-interface
 [
     SecureContext
-] dictionary VRFrameOfReferenceOptions {
+] dictionary XRFrameOfReferenceOptions {
   boolean disableStageEmulation = false;
   double stageEmulationHeight = 0.0;
 };

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameProvider.cpp b/third_party/WebKit/Source/modules/xr/XRFrameProvider.cpp
similarity index 75%
rename from third_party/WebKit/Source/modules/vr/latest/VRFrameProvider.cpp
rename to third_party/WebKit/Source/modules/xr/XRFrameProvider.cpp
index c7ae964..53ac15dd 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameProvider.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRFrameProvider.cpp

@@ -2,16 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRFrameProvider.h"
+#include "modules/xr/XRFrameProvider.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
 #include "core/dom/DOMException.h"
 #include "core/dom/Document.h"
 #include "core/dom/FrameRequestCallbackCollection.h"
 #include "core/frame/LocalFrame.h"
-#include "modules/vr/latest/VR.h"
-#include "modules/vr/latest/VRDevice.h"
-#include "modules/vr/latest/VRSession.h"
+#include "modules/xr/XR.h"
+#include "modules/xr/XRDevice.h"
+#include "modules/xr/XRSession.h"
 #include "platform/WebTaskRunner.h"
 #include "platform/instrumentation/tracing/TraceEvent.h"
 #include "platform/transforms/TransformationMatrix.h"
@@ -22,12 +22,12 @@
 
 namespace {
 
-class VRFrameProviderRequestCallback
+class XRFrameProviderRequestCallback
     : public FrameRequestCallbackCollection::FrameCallback {
  public:
-  explicit VRFrameProviderRequestCallback(VRFrameProvider* frame_provider)
+  explicit XRFrameProviderRequestCallback(XRFrameProvider* frame_provider)
       : frame_provider_(frame_provider) {}
-  ~VRFrameProviderRequestCallback() override {}
+  ~XRFrameProviderRequestCallback() override {}
   void Invoke(double high_res_time_ms) override {
     // TODO(bajones): Eventually exclusive vsyncs won't be handled here.
     if (frame_provider_->exclusive_session()) {
@@ -43,7 +43,7 @@
     FrameRequestCallbackCollection::FrameCallback::Trace(visitor);
   }
 
-  Member<VRFrameProvider> frame_provider_;
+  Member<XRFrameProvider> frame_provider_;
 };
 
 std::unique_ptr<TransformationMatrix> getPoseMatrix(
@@ -84,9 +84,9 @@
 
 }  // namespace
 
-VRFrameProvider::VRFrameProvider(VRDevice* device) : device_(device) {}
+XRFrameProvider::XRFrameProvider(XRDevice* device) : device_(device) {}
 
-void VRFrameProvider::BeginExclusiveSession(VRSession* session,
+void XRFrameProvider::BeginExclusiveSession(XRSession* session,
                                             ScriptPromiseResolver* resolver) {
   // Make sure the session is indeed an exclusive one.
   DCHECK(session && session->exclusive());
@@ -98,12 +98,12 @@
 
   pending_exclusive_session_resolver_ = resolver;
 
-  // TODO(bajones): Request a VRPresentationProviderPtr to use for presenting
+  // TODO(bajones): Request a XRPresentationProviderPtr to use for presenting
   // frames, delay call to OnPresentComplete till the connection is established.
   OnPresentComplete(true);
 }
 
-void VRFrameProvider::OnPresentComplete(bool success) {
+void XRFrameProvider::OnPresentComplete(bool success) {
   if (success) {
     pending_exclusive_session_resolver_->Resolve(exclusive_session_);
   } else {
@@ -111,7 +111,7 @@
 
     if (pending_exclusive_session_resolver_) {
       DOMException* exception = DOMException::Create(
-          kNotAllowedError, "Request for exclusive VRSession was denied.");
+          kNotAllowedError, "Request for exclusive XRSession was denied.");
       pending_exclusive_session_resolver_->Reject(exception);
     }
   }
@@ -120,11 +120,11 @@
 }
 
 // Called by the exclusive session when it is ended.
-void VRFrameProvider::OnExclusiveSessionEnded() {
+void XRFrameProvider::OnExclusiveSessionEnded() {
   if (!exclusive_session_)
     return;
 
-  // TODO(bajones): Call device_->vrDisplayHostPtr()->ExitPresent();
+  // TODO(bajones): Call device_->xrDisplayHostPtr()->ExitPresent();
 
   exclusive_session_ = nullptr;
   pending_exclusive_vsync_ = false;
@@ -137,8 +137,8 @@
     ScheduleNonExclusiveFrame();
 }
 
-// Schedule a session to be notified when the next VR frame is available.
-void VRFrameProvider::RequestFrame(VRSession* session) {
+// Schedule a session to be notified when the next XR frame is available.
+void XRFrameProvider::RequestFrame(XRSession* session) {
   DVLOG(2) << __FUNCTION__;
 
   // If a previous session has already requested a frame don't fire off another
@@ -157,13 +157,13 @@
   }
 }
 
-void VRFrameProvider::ScheduleExclusiveFrame() {
+void XRFrameProvider::ScheduleExclusiveFrame() {
   if (pending_exclusive_vsync_)
     return;
 
-  // TODO(bajones): This should acquire frames through a VRPresentationProvider
+  // TODO(bajones): This should acquire frames through a XRPresentationProvider
   // instead of duplicating the non-exclusive path.
-  LocalFrame* frame = device_->vr()->GetFrame();
+  LocalFrame* frame = device_->xr()->GetFrame();
   if (!frame)
     return;
 
@@ -173,16 +173,16 @@
 
   pending_exclusive_vsync_ = true;
 
-  device_->vrMagicWindowProviderPtr()->GetPose(WTF::Bind(
-      &VRFrameProvider::OnNonExclusivePose, WrapWeakPersistent(this)));
-  doc->RequestAnimationFrame(new VRFrameProviderRequestCallback(this));
+  device_->xrMagicWindowProviderPtr()->GetPose(WTF::Bind(
+      &XRFrameProvider::OnNonExclusivePose, WrapWeakPersistent(this)));
+  doc->RequestAnimationFrame(new XRFrameProviderRequestCallback(this));
 }
 
-void VRFrameProvider::ScheduleNonExclusiveFrame() {
+void XRFrameProvider::ScheduleNonExclusiveFrame() {
   if (pending_non_exclusive_vsync_)
     return;
 
-  LocalFrame* frame = device_->vr()->GetFrame();
+  LocalFrame* frame = device_->xr()->GetFrame();
   if (!frame)
     return;
 
@@ -192,12 +192,12 @@
 
   pending_non_exclusive_vsync_ = true;
 
-  device_->vrMagicWindowProviderPtr()->GetPose(WTF::Bind(
-      &VRFrameProvider::OnNonExclusivePose, WrapWeakPersistent(this)));
-  doc->RequestAnimationFrame(new VRFrameProviderRequestCallback(this));
+  device_->xrMagicWindowProviderPtr()->GetPose(WTF::Bind(
+      &XRFrameProvider::OnNonExclusivePose, WrapWeakPersistent(this)));
+  doc->RequestAnimationFrame(new XRFrameProviderRequestCallback(this));
 }
 
-void VRFrameProvider::OnExclusiveVSync(double timestamp) {
+void XRFrameProvider::OnExclusiveVSync(double timestamp) {
   DVLOG(2) << __FUNCTION__;
 
   pending_exclusive_vsync_ = false;
@@ -212,11 +212,11 @@
   // execution context caused extreme input delay due to processing
   // multiple frames without yielding, see crbug.com/701444.
   Platform::Current()->CurrentThread()->GetWebTaskRunner()->PostTask(
-      BLINK_FROM_HERE, WTF::Bind(&VRFrameProvider::ProcessScheduledFrame,
+      BLINK_FROM_HERE, WTF::Bind(&XRFrameProvider::ProcessScheduledFrame,
                                  WrapWeakPersistent(this), timestamp));
 }
 
-void VRFrameProvider::OnNonExclusiveVSync(double timestamp) {
+void XRFrameProvider::OnNonExclusiveVSync(double timestamp) {
   DVLOG(2) << __FUNCTION__;
 
   pending_non_exclusive_vsync_ = false;
@@ -226,18 +226,18 @@
     return;
 
   Platform::Current()->CurrentThread()->GetWebTaskRunner()->PostTask(
-      BLINK_FROM_HERE, WTF::Bind(&VRFrameProvider::ProcessScheduledFrame,
+      BLINK_FROM_HERE, WTF::Bind(&XRFrameProvider::ProcessScheduledFrame,
                                  WrapWeakPersistent(this), timestamp));
 }
 
-void VRFrameProvider::OnNonExclusivePose(device::mojom::blink::VRPosePtr pose) {
+void XRFrameProvider::OnNonExclusivePose(device::mojom::blink::VRPosePtr pose) {
   frame_pose_ = std::move(pose);
 }
 
-void VRFrameProvider::ProcessScheduledFrame(double timestamp) {
+void XRFrameProvider::ProcessScheduledFrame(double timestamp) {
   DVLOG(2) << __FUNCTION__;
 
-  TRACE_EVENT1("gpu", "VRFrameProvider::ProcessScheduledFrame", "frame",
+  TRACE_EVENT1("gpu", "XRFrameProvider::ProcessScheduledFrame", "frame",
                frame_id_);
 
   if (exclusive_session_) {
@@ -249,12 +249,12 @@
     // In the process of fulfilling the frame requests for each session they are
     // extremely likely to request another frame. Work off of a separate list
     // from the requests to prevent infinite loops.
-    HeapVector<Member<VRSession>> processing_sessions;
+    HeapVector<Member<XRSession>> processing_sessions;
     swap(requesting_sessions_, processing_sessions);
 
     // Inform sessions with a pending request of the new frame
     for (unsigned i = 0; i < processing_sessions.size(); ++i) {
-      VRSession* session = processing_sessions.at(i).Get();
+      XRSession* session = processing_sessions.at(i).Get();
       std::unique_ptr<TransformationMatrix> pose_matrix =
           getPoseMatrix(frame_pose_);
       session->OnFrame(std::move(pose_matrix));
@@ -262,7 +262,7 @@
   }
 }
 
-void VRFrameProvider::Trace(blink::Visitor* visitor) {
+void XRFrameProvider::Trace(blink::Visitor* visitor) {
   visitor->Trace(device_);
   visitor->Trace(pending_exclusive_session_resolver_);
   visitor->Trace(exclusive_session_);

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameProvider.h b/third_party/WebKit/Source/modules/xr/XRFrameProvider.h
similarity index 68%
rename from third_party/WebKit/Source/modules/vr/latest/VRFrameProvider.h
rename to third_party/WebKit/Source/modules/xr/XRFrameProvider.h
index a9aaef8..3f6b2fe2 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameProvider.h
+++ b/third_party/WebKit/Source/modules/xr/XRFrameProvider.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRFrameProvider_h
-#define VRFrameProvider_h
+#ifndef XRFrameProvider_h
+#define XRFrameProvider_h
 
 #include "device/vr/vr_service.mojom-blink.h"
 #include "mojo/public/cpp/bindings/binding.h"
@@ -14,22 +14,22 @@
 namespace blink {
 
 class ScriptPromiseResolver;
-class VRDevice;
-class VRSession;
+class XRDevice;
+class XRSession;
 
 // This class manages requesting and dispatching frame updates, which includes
-// pose information for a given VRDevice.
-class VRFrameProvider final
-    : public GarbageCollectedFinalized<VRFrameProvider> {
+// pose information for a given XRDevice.
+class XRFrameProvider final
+    : public GarbageCollectedFinalized<XRFrameProvider> {
  public:
-  explicit VRFrameProvider(VRDevice*);
+  explicit XRFrameProvider(XRDevice*);
 
-  VRSession* exclusive_session() const { return exclusive_session_; }
+  XRSession* exclusive_session() const { return exclusive_session_; }
 
-  void BeginExclusiveSession(VRSession*, ScriptPromiseResolver*);
+  void BeginExclusiveSession(XRSession*, ScriptPromiseResolver*);
   void OnExclusiveSessionEnded();
 
-  void RequestFrame(VRSession*);
+  void RequestFrame(XRSession*);
 
   void OnExclusiveVSync(double timestamp);
   void OnNonExclusiveVSync(double timestamp);
@@ -47,18 +47,18 @@
   void OnPresentComplete(bool success);
   void ProcessScheduledFrame(double timestamp);
 
-  const Member<VRDevice> device_;
-  Member<VRSession> exclusive_session_;
+  const Member<XRDevice> device_;
+  Member<XRSession> exclusive_session_;
   Member<ScriptPromiseResolver> pending_exclusive_session_resolver_;
 
   // Non-exclusive Sessions which have requested a frame update.
-  HeapVector<Member<VRSession>> requesting_sessions_;
+  HeapVector<Member<XRSession>> requesting_sessions_;
 
   device::mojom::blink::VRMagicWindowProviderPtr magic_window_provider_;
   device::mojom::blink::VRPosePtr frame_pose_;
 
-  // This frame ID is VR-specific and is used to track when frames arrive at the
-  // VR compositor so that it knows which poses to use, when to apply bounds
+  // This frame ID is XR-specific and is used to track when frames arrive at the
+  // XR compositor so that it knows which poses to use, when to apply bounds
   // updates, etc.
   int16_t frame_id_ = -1;
   bool pending_exclusive_vsync_ = false;
@@ -72,4 +72,4 @@
 
 }  // namespace blink
 
-#endif  // VRFrameProvider_h
+#endif  // XRFrameProvider_h

diff --git a/third_party/WebKit/Source/modules/xr/XRFrameRequestCallback.idl b/third_party/WebKit/Source/modules/xr/XRFrameRequestCallback.idl
new file mode 100644
index 0000000..66dc93f
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRFrameRequestCallback.idl

@@ -0,0 +1,6 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://immersive-web.github.io/webxr/spec/latest/#callbackdef-xrframerequestcallback
+callback XRFrameRequestCallback = void (XRPresentationFrame frame);

diff --git a/third_party/WebKit/Source/modules/xr/XRFrameRequestCallbackCollection.cpp b/third_party/WebKit/Source/modules/xr/XRFrameRequestCallbackCollection.cpp
new file mode 100644
index 0000000..63fe34a
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRFrameRequestCallbackCollection.cpp

@@ -0,0 +1,71 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "modules/xr/XRFrameRequestCallbackCollection.h"
+
+#include "bindings/modules/v8/v8_xr_frame_request_callback.h"
+#include "core/inspector/InspectorTraceEvents.h"
+#include "core/probe/CoreProbes.h"
+#include "modules/xr/XRPresentationFrame.h"
+#include "modules/xr/XRSession.h"
+
+namespace blink {
+
+XRFrameRequestCallbackCollection::XRFrameRequestCallbackCollection(
+    ExecutionContext* context)
+    : context_(context) {}
+
+XRFrameRequestCallbackCollection::CallbackId
+XRFrameRequestCallbackCollection::RegisterCallback(
+    V8XRFrameRequestCallback* callback) {
+  CallbackId id = ++next_callback_id_;
+  callbacks_.Set(id, callback);
+  pending_callbacks_.push_back(id);
+
+  probe::AsyncTaskScheduledBreakable(context_, "XRRequestFrame", callback);
+  return id;
+}
+
+void XRFrameRequestCallbackCollection::CancelCallback(CallbackId id) {
+  if (IsValidCallbackId(id)) {
+    callbacks_.erase(id);
+  }
+}
+
+void XRFrameRequestCallbackCollection::ExecuteCallbacks(
+    XRSession* session,
+    XRPresentationFrame* frame) {
+  // First, generate a list of callbacks to consider.  Callbacks registered from
+  // this point on are considered only for the "next" frame, not this one.
+  DCHECK(callbacks_to_invoke_.IsEmpty());
+  callbacks_to_invoke_.swap(pending_callbacks_);
+
+  for (const auto& id : callbacks_to_invoke_) {
+    V8XRFrameRequestCallback* callback = callbacks_.Take(id);
+
+    // Callback won't be found if it was cancelled.
+    if (!callback)
+      continue;
+
+    probe::AsyncTask async_task(context_, callback);
+    probe::UserCallback probe(context_, "XRRequestFrame", AtomicString(), true);
+    callback->InvokeAndReportException(session, frame);
+  }
+
+  callbacks_to_invoke_.clear();
+}
+
+void XRFrameRequestCallbackCollection::Trace(blink::Visitor* visitor) {
+  visitor->Trace(callbacks_);
+  visitor->Trace(context_);
+}
+
+void XRFrameRequestCallbackCollection::TraceWrappers(
+    const blink::ScriptWrappableVisitor* visitor) const {
+  for (const auto& callback : callbacks_.Values()) {
+    visitor->TraceWrappers(callback);
+  }
+}
+
+}  // namespace blink

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallbackCollection.h b/third_party/WebKit/Source/modules/xr/XRFrameRequestCallbackCollection.h
similarity index 69%
rename from third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallbackCollection.h
rename to third_party/WebKit/Source/modules/xr/XRFrameRequestCallbackCollection.h
index 0b6f5a6..94970aa9 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRFrameRequestCallbackCollection.h
+++ b/third_party/WebKit/Source/modules/xr/XRFrameRequestCallbackCollection.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRFrameRequestCallbackCollection_h
-#define VRFrameRequestCallbackCollection_h
+#ifndef XRFrameRequestCallbackCollection_h
+#define XRFrameRequestCallbackCollection_h
 
 #include "platform/bindings/TraceWrapperMember.h"
 #include "platform/heap/Handle.h"
@@ -11,20 +11,20 @@
 namespace blink {
 
 class ExecutionContext;
-class V8VRFrameRequestCallback;
-class VRPresentationFrame;
-class VRSession;
+class V8XRFrameRequestCallback;
+class XRPresentationFrame;
+class XRSession;
 
-class VRFrameRequestCallbackCollection final : public TraceWrapperBase {
+class XRFrameRequestCallbackCollection final : public TraceWrapperBase {
   DISALLOW_NEW();
 
  public:
-  explicit VRFrameRequestCallbackCollection(ExecutionContext*);
+  explicit XRFrameRequestCallbackCollection(ExecutionContext*);
 
   using CallbackId = int;
-  CallbackId RegisterCallback(V8VRFrameRequestCallback*);
+  CallbackId RegisterCallback(V8XRFrameRequestCallback*);
   void CancelCallback(CallbackId);
-  void ExecuteCallbacks(VRSession*, VRPresentationFrame*);
+  void ExecuteCallbacks(XRSession*, XRPresentationFrame*);
 
   bool IsEmpty() const { return !callbacks_.size(); }
 
@@ -39,7 +39,7 @@
   }
 
   using CallbackMap =
-      HeapHashMap<CallbackId, TraceWrapperMember<V8VRFrameRequestCallback>>;
+      HeapHashMap<CallbackId, TraceWrapperMember<V8XRFrameRequestCallback>>;
   CallbackMap callbacks_;
   Vector<CallbackId> pending_callbacks_;
   // Only non-empty while inside executeCallbacks.

diff --git a/third_party/WebKit/Source/modules/xr/XRLayer.cpp b/third_party/WebKit/Source/modules/xr/XRLayer.cpp
new file mode 100644
index 0000000..24b6050
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRLayer.cpp

@@ -0,0 +1,26 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "modules/xr/XRLayer.h"
+#include "modules/xr/XRSession.h"
+
+namespace blink {
+
+XRLayer::XRLayer(XRSession* session, XRLayerType layer_type)
+    : session_(session), layer_type_(layer_type) {}
+
+XRViewport* XRLayer::GetViewport(XRView::Eye) {
+  return nullptr;
+}
+
+void XRLayer::OnFrameStart() {}
+void XRLayer::OnFrameEnd() {}
+void XRLayer::OnResize() {}
+
+void XRLayer::Trace(blink::Visitor* visitor) {
+  visitor->Trace(session_);
+  ScriptWrappable::Trace(visitor);
+}
+
+}  // namespace blink

diff --git a/third_party/WebKit/Source/modules/xr/XRLayer.h b/third_party/WebKit/Source/modules/xr/XRLayer.h
new file mode 100644
index 0000000..29587a3
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRLayer.h

@@ -0,0 +1,43 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef XRLayer_h
+#define XRLayer_h
+
+#include "modules/xr/XRView.h"
+#include "platform/bindings/ScriptWrappable.h"
+#include "platform/heap/Handle.h"
+#include "platform/wtf/Forward.h"
+
+namespace blink {
+
+class XRSession;
+class XRViewport;
+
+enum XRLayerType { kXRWebGLLayerType };
+
+class XRLayer : public ScriptWrappable {
+  DEFINE_WRAPPERTYPEINFO();
+
+ public:
+  XRLayer(XRSession*, XRLayerType);
+
+  XRSession* session() const { return session_; }
+  XRLayerType layerType() const { return layer_type_; }
+  virtual XRViewport* GetViewport(XRView::Eye);
+
+  virtual void OnFrameStart();
+  virtual void OnFrameEnd();
+  virtual void OnResize();
+
+  virtual void Trace(blink::Visitor*);
+
+ private:
+  const Member<XRSession> session_;
+  XRLayerType layer_type_;
+};
+
+}  // namespace blink
+
+#endif  // XRLayer_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRLayer.idl b/third_party/WebKit/Source/modules/xr/XRLayer.idl
similarity index 68%
rename from third_party/WebKit/Source/modules/vr/latest/VRLayer.idl
rename to third_party/WebKit/Source/modules/xr/XRLayer.idl
index 9119307e..76da959 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRLayer.idl
+++ b/third_party/WebKit/Source/modules/xr/XRLayer.idl

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrlayer-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrlayer-interface
 [
     SecureContext,
     RuntimeEnabled=WebXR
-] interface VRLayer {};
+] interface XRLayer {};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.cpp b/third_party/WebKit/Source/modules/xr/XRPresentationFrame.cpp
similarity index 60%
rename from third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.cpp
rename to third_party/WebKit/Source/modules/xr/XRPresentationFrame.cpp
index ad7b2ed..27fa3879c 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRPresentationFrame.cpp

@@ -2,24 +2,24 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRPresentationFrame.h"
+#include "modules/xr/XRPresentationFrame.h"
 
-#include "modules/vr/latest/VRCoordinateSystem.h"
-#include "modules/vr/latest/VRDevicePose.h"
-#include "modules/vr/latest/VRSession.h"
-#include "modules/vr/latest/VRView.h"
+#include "modules/xr/XRCoordinateSystem.h"
+#include "modules/xr/XRDevicePose.h"
+#include "modules/xr/XRSession.h"
+#include "modules/xr/XRView.h"
 
 namespace blink {
 
-VRPresentationFrame::VRPresentationFrame(VRSession* session)
+XRPresentationFrame::XRPresentationFrame(XRSession* session)
     : session_(session) {}
 
-const HeapVector<Member<VRView>>& VRPresentationFrame::views() const {
+const HeapVector<Member<XRView>>& XRPresentationFrame::views() const {
   return session_->views();
 }
 
-VRDevicePose* VRPresentationFrame::getDevicePose(
-    VRCoordinateSystem* coordinate_system) const {
+XRDevicePose* XRPresentationFrame::getDevicePose(
+    XRCoordinateSystem* coordinate_system) const {
   // If we don't have a valid base pose return null. Most common when tracking
   // is lost.
   if (!base_pose_matrix_ || !coordinate_system) {
@@ -38,15 +38,15 @@
     return nullptr;
   }
 
-  return new VRDevicePose(session(), std::move(pose));
+  return new XRDevicePose(session(), std::move(pose));
 }
 
-void VRPresentationFrame::UpdateBasePose(
+void XRPresentationFrame::UpdateBasePose(
     std::unique_ptr<TransformationMatrix> base_pose_matrix) {
   base_pose_matrix_ = std::move(base_pose_matrix);
 }
 
-void VRPresentationFrame::Trace(blink::Visitor* visitor) {
+void XRPresentationFrame::Trace(blink::Visitor* visitor) {
   visitor->Trace(session_);
   ScriptWrappable::Trace(visitor);
 }

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.h b/third_party/WebKit/Source/modules/xr/XRPresentationFrame.h
similarity index 60%
rename from third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.h
rename to third_party/WebKit/Source/modules/xr/XRPresentationFrame.h
index fff9501..99dc2e97 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRPresentationFrame.h
+++ b/third_party/WebKit/Source/modules/xr/XRPresentationFrame.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRPresentationFrame_h
-#define VRPresentationFrame_h
+#ifndef XRPresentationFrame_h
+#define XRPresentationFrame_h
 
 #include "device/vr/vr_service.mojom-blink.h"
 #include "platform/bindings/ScriptWrappable.h"
@@ -14,31 +14,31 @@
 
 namespace blink {
 
-class VRCoordinateSystem;
-class VRDevicePose;
-class VRSession;
-class VRView;
+class XRCoordinateSystem;
+class XRDevicePose;
+class XRSession;
+class XRView;
 
-class VRPresentationFrame final : public ScriptWrappable {
+class XRPresentationFrame final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  explicit VRPresentationFrame(VRSession*);
+  explicit XRPresentationFrame(XRSession*);
 
-  VRSession* session() const { return session_; }
+  XRSession* session() const { return session_; }
 
-  const HeapVector<Member<VRView>>& views() const;
-  VRDevicePose* getDevicePose(VRCoordinateSystem*) const;
+  const HeapVector<Member<XRView>>& views() const;
+  XRDevicePose* getDevicePose(XRCoordinateSystem*) const;
 
   void UpdateBasePose(std::unique_ptr<TransformationMatrix>);
 
   virtual void Trace(blink::Visitor*);
 
  private:
-  const Member<VRSession> session_;
+  const Member<XRSession> session_;
   std::unique_ptr<TransformationMatrix> base_pose_matrix_;
 };
 
 }  // namespace blink
 
-#endif  // VRWebGLLayer_h
+#endif  // XRWebGLLayer_h

diff --git a/third_party/WebKit/Source/modules/xr/XRPresentationFrame.idl b/third_party/WebKit/Source/modules/xr/XRPresentationFrame.idl
new file mode 100644
index 0000000..3a64182
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRPresentationFrame.idl

@@ -0,0 +1,14 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://immersive-web.github.io/webxr/spec/latest/#xrpresentationframe-interface
+[
+    SecureContext,
+    RuntimeEnabled=WebXR
+] interface XRPresentationFrame {
+  readonly attribute XRSession session;
+  readonly attribute FrozenArray<XRView> views;
+
+  XRDevicePose? getDevicePose(XRCoordinateSystem coordinateSystem);
+};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRSession.cpp b/third_party/WebKit/Source/modules/xr/XRSession.cpp
similarity index 67%
rename from third_party/WebKit/Source/modules/vr/latest/VRSession.cpp
rename to third_party/WebKit/Source/modules/xr/XRSession.cpp
index 3d1ecb166..e4b3961 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRSession.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRSession.cpp

@@ -2,29 +2,29 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRSession.h"
+#include "modules/xr/XRSession.h"
 
 #include "bindings/core/v8/ScriptPromiseResolver.h"
-#include "bindings/modules/v8/v8_vr_frame_request_callback.h"
+#include "bindings/modules/v8/v8_xr_frame_request_callback.h"
 #include "core/dom/DOMException.h"
 #include "core/frame/LocalFrame.h"
 #include "modules/EventTargetModules.h"
-#include "modules/vr/latest/VR.h"
-#include "modules/vr/latest/VRDevice.h"
-#include "modules/vr/latest/VRFrameOfReference.h"
-#include "modules/vr/latest/VRFrameOfReferenceOptions.h"
-#include "modules/vr/latest/VRFrameProvider.h"
-#include "modules/vr/latest/VRLayer.h"
-#include "modules/vr/latest/VRPresentationFrame.h"
-#include "modules/vr/latest/VRSessionEvent.h"
-#include "modules/vr/latest/VRView.h"
+#include "modules/xr/XR.h"
+#include "modules/xr/XRDevice.h"
+#include "modules/xr/XRFrameOfReference.h"
+#include "modules/xr/XRFrameOfReferenceOptions.h"
+#include "modules/xr/XRFrameProvider.h"
+#include "modules/xr/XRLayer.h"
+#include "modules/xr/XRPresentationFrame.h"
+#include "modules/xr/XRSessionEvent.h"
+#include "modules/xr/XRView.h"
 #include "platform/wtf/AutoReset.h"
 
 namespace blink {
 
 namespace {
 
-const char kSessionEnded[] = "VRSession has already ended.";
+const char kSessionEnded[] = "XRSession has already ended.";
 
 const char kUnknownFrameOfReference[] = "Unknown frame of reference type";
 
@@ -34,7 +34,7 @@
 const double kDegToRad = M_PI / 180.0;
 
 void UpdateViewFromEyeParameters(
-    VRView* view,
+    XRView* view,
     const device::mojom::blink::VREyeParametersPtr& eye,
     double depth_near,
     double depth_far) {
@@ -50,56 +50,56 @@
 
 }  // namespace
 
-VRSession::VRSession(VRDevice* device, bool exclusive)
+XRSession::XRSession(XRDevice* device, bool exclusive)
     : device_(device),
       exclusive_(exclusive),
       callback_collection_(device->GetExecutionContext()) {}
 
-void VRSession::setDepthNear(double value) {
+void XRSession::setDepthNear(double value) {
   if (depth_near_ != value) {
     views_dirty_ = true;
     depth_near_ = value;
   }
 }
 
-void VRSession::setDepthFar(double value) {
+void XRSession::setDepthFar(double value) {
   if (depth_far_ != value) {
     views_dirty_ = true;
     depth_far_ = value;
   }
 }
 
-void VRSession::setBaseLayer(VRLayer* value) {
+void XRSession::setBaseLayer(XRLayer* value) {
   base_layer_ = value;
 }
 
-ExecutionContext* VRSession::GetExecutionContext() const {
+ExecutionContext* XRSession::GetExecutionContext() const {
   return device_->GetExecutionContext();
 }
 
-const AtomicString& VRSession::InterfaceName() const {
-  return EventTargetNames::VRSession;
+const AtomicString& XRSession::InterfaceName() const {
+  return EventTargetNames::XRSession;
 }
 
-ScriptPromise VRSession::requestFrameOfReference(
+ScriptPromise XRSession::requestFrameOfReference(
     ScriptState* script_state,
     const String& type,
-    const VRFrameOfReferenceOptions& options) {
+    const XRFrameOfReferenceOptions& options) {
   if (detached_) {
     return ScriptPromise::RejectWithDOMException(
         script_state, DOMException::Create(kInvalidStateError, kSessionEnded));
   }
 
-  VRFrameOfReference* frameOfRef = nullptr;
+  XRFrameOfReference* frameOfRef = nullptr;
   if (type == "headModel") {
     frameOfRef =
-        new VRFrameOfReference(this, VRFrameOfReference::kTypeHeadModel);
+        new XRFrameOfReference(this, XRFrameOfReference::kTypeHeadModel);
   } else if (type == "eyeLevel") {
     frameOfRef =
-        new VRFrameOfReference(this, VRFrameOfReference::kTypeEyeLevel);
+        new XRFrameOfReference(this, XRFrameOfReference::kTypeEyeLevel);
   } else if (type == "stage") {
     if (!options.disableStageEmulation()) {
-      frameOfRef = new VRFrameOfReference(this, VRFrameOfReference::kTypeStage);
+      frameOfRef = new XRFrameOfReference(this, XRFrameOfReference::kTypeStage);
       frameOfRef->UseEmulatedHeight(options.stageEmulationHeight());
     } else {
       // TODO(bajones): Support native stages using the standing transform.
@@ -122,7 +122,7 @@
   return promise;
 }
 
-int VRSession::requestFrame(V8VRFrameRequestCallback* callback) {
+int XRSession::requestFrame(V8XRFrameRequestCallback* callback) {
   // Don't allow any new frame requests once the session is ended.
   if (detached_)
     return 0;
@@ -134,18 +134,18 @@
 
   int id = callback_collection_.RegisterCallback(callback);
   if (!pending_frame_) {
-    // Kick off a request for a new VR frame.
+    // Kick off a request for a new XR frame.
     device_->frameProvider()->RequestFrame(this);
     pending_frame_ = true;
   }
   return id;
 }
 
-void VRSession::cancelFrame(int id) {
+void XRSession::cancelFrame(int id) {
   callback_collection_.CancelCallback(id);
 }
 
-ScriptPromise VRSession::end(ScriptState* script_state) {
+ScriptPromise XRSession::end(ScriptState* script_state) {
   // Don't allow a session to end twice.
   if (detached_) {
     return ScriptPromise::RejectWithDOMException(
@@ -164,7 +164,7 @@
   return promise;
 }
 
-void VRSession::ForceEnd() {
+void XRSession::ForceEnd() {
   // Detach this session from the device.
   detached_ = true;
 
@@ -174,34 +174,34 @@
     device_->frameProvider()->OnExclusiveSessionEnded();
   }
 
-  DispatchEvent(VRSessionEvent::Create(EventTypeNames::end, this));
+  DispatchEvent(XRSessionEvent::Create(EventTypeNames::end, this));
 }
 
-DoubleSize VRSession::IdealFramebufferSize() const {
-  double width = device_->vrDisplayInfoPtr()->leftEye->renderWidth +
-                 device_->vrDisplayInfoPtr()->rightEye->renderWidth;
-  double height = std::max(device_->vrDisplayInfoPtr()->leftEye->renderHeight,
-                           device_->vrDisplayInfoPtr()->rightEye->renderHeight);
+DoubleSize XRSession::IdealFramebufferSize() const {
+  double width = device_->xrDisplayInfoPtr()->leftEye->renderWidth +
+                 device_->xrDisplayInfoPtr()->rightEye->renderWidth;
+  double height = std::max(device_->xrDisplayInfoPtr()->leftEye->renderHeight,
+                           device_->xrDisplayInfoPtr()->rightEye->renderHeight);
   return DoubleSize(width, height);
 }
 
-void VRSession::OnFocus() {
+void XRSession::OnFocus() {
   if (!blurred_)
     return;
 
   blurred_ = false;
-  DispatchEvent(VRSessionEvent::Create(EventTypeNames::focus, this));
+  DispatchEvent(XRSessionEvent::Create(EventTypeNames::focus, this));
 }
 
-void VRSession::OnBlur() {
+void XRSession::OnBlur() {
   if (blurred_)
     return;
 
   blurred_ = true;
-  DispatchEvent(VRSessionEvent::Create(EventTypeNames::blur, this));
+  DispatchEvent(XRSessionEvent::Create(EventTypeNames::blur, this));
 }
 
-void VRSession::OnFrame(
+void XRSession::OnFrame(
     std::unique_ptr<TransformationMatrix> base_pose_matrix) {
   DVLOG(2) << __FUNCTION__;
   // Don't process any outstanding frames once the session is ended.
@@ -213,17 +213,17 @@
   if (!base_layer_)
     return;
 
-  VRPresentationFrame* presentation_frame = new VRPresentationFrame(this);
+  XRPresentationFrame* presentation_frame = new XRPresentationFrame(this);
   presentation_frame->UpdateBasePose(std::move(base_pose_matrix));
 
   if (pending_frame_) {
     pending_frame_ = false;
 
     // Cache the base layer, since it could change during the frame callback.
-    VRLayer* frame_base_layer = base_layer_;
+    XRLayer* frame_base_layer = base_layer_;
     frame_base_layer->OnFrameStart();
 
-    // Resolve the queued requestFrame callbacks. All VR rendering will happen
+    // Resolve the queued requestFrame callbacks. All XR rendering will happen
     // within these calls. resolving_frame_ will be true for the duration of the
     // callbacks.
     AutoReset<bool> resolving(&resolving_frame_, true);
@@ -233,22 +233,22 @@
   }
 }
 
-const HeapVector<Member<VRView>>& VRSession::views() {
+const HeapVector<Member<XRView>>& XRSession::views() {
   if (views_dirty_) {
     if (exclusive_) {
       // If we don't already have the views allocated, do so now.
       if (views_.IsEmpty()) {
-        views_.push_back(new VRView(this, VRView::kEyeLeft));
-        views_.push_back(new VRView(this, VRView::kEyeRight));
+        views_.push_back(new XRView(this, XRView::kEyeLeft));
+        views_.push_back(new XRView(this, XRView::kEyeRight));
       }
 
       // In exclusive mode the projection and view matrices must be aligned with
       // the device's physical optics.
-      UpdateViewFromEyeParameters(views_[VRView::kEyeLeft],
-                                  device_->vrDisplayInfoPtr()->leftEye,
+      UpdateViewFromEyeParameters(views_[XRView::kEyeLeft],
+                                  device_->xrDisplayInfoPtr()->leftEye,
                                   depth_near_, depth_far_);
-      UpdateViewFromEyeParameters(views_[VRView::kEyeRight],
-                                  device_->vrDisplayInfoPtr()->rightEye,
+      UpdateViewFromEyeParameters(views_[XRView::kEyeRight],
+                                  device_->xrDisplayInfoPtr()->rightEye,
                                   depth_near_, depth_far_);
     }
 
@@ -258,7 +258,7 @@
   return views_;
 }
 
-void VRSession::Trace(blink::Visitor* visitor) {
+void XRSession::Trace(blink::Visitor* visitor) {
   visitor->Trace(device_);
   visitor->Trace(base_layer_);
   visitor->Trace(views_);
@@ -266,7 +266,7 @@
   EventTargetWithInlineData::Trace(visitor);
 }
 
-void VRSession::TraceWrappers(
+void XRSession::TraceWrappers(
     const blink::ScriptWrappableVisitor* visitor) const {
   visitor->TraceWrappers(callback_collection_);
 }

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRSession.h b/third_party/WebKit/Source/modules/xr/XRSession.h
similarity index 76%
rename from third_party/WebKit/Source/modules/vr/latest/VRSession.h
rename to third_party/WebKit/Source/modules/xr/XRSession.h
index 7dfafb1..ad61822 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRSession.h
+++ b/third_party/WebKit/Source/modules/xr/XRSession.h

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRSession_h
-#define VRSession_h
+#ifndef XRSession_h
+#define XRSession_h
 
 #include "bindings/core/v8/ScriptPromise.h"
 #include "core/dom/events/EventTarget.h"
-#include "modules/vr/latest/VRFrameRequestCallbackCollection.h"
+#include "modules/xr/XRFrameRequestCallbackCollection.h"
 #include "platform/bindings/TraceWrapperMember.h"
 #include "platform/geometry/DoubleSize.h"
 #include "platform/heap/Handle.h"
@@ -16,19 +16,19 @@
 
 namespace blink {
 
-class V8VRFrameRequestCallback;
-class VRDevice;
-class VRFrameOfReferenceOptions;
-class VRLayer;
-class VRView;
+class V8XRFrameRequestCallback;
+class XRDevice;
+class XRFrameOfReferenceOptions;
+class XRLayer;
+class XRView;
 
-class VRSession final : public EventTargetWithInlineData {
+class XRSession final : public EventTargetWithInlineData {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  VRSession(VRDevice*, bool exclusive);
+  XRSession(XRDevice*, bool exclusive);
 
-  VRDevice* device() const { return device_; }
+  XRDevice* device() const { return device_; }
   bool exclusive() const { return exclusive_; }
 
   // Near and far depths are used when computing projection matrices for this
@@ -39,8 +39,8 @@
   double depthFar() const { return depth_far_; }
   void setDepthFar(double value);
 
-  VRLayer* baseLayer() const { return base_layer_; }
-  void setBaseLayer(VRLayer* value);
+  XRLayer* baseLayer() const { return base_layer_; }
+  void setBaseLayer(XRLayer* value);
 
   DEFINE_ATTRIBUTE_EVENT_LISTENER(blur);
   DEFINE_ATTRIBUTE_EVENT_LISTENER(focus);
@@ -49,9 +49,9 @@
 
   ScriptPromise requestFrameOfReference(ScriptState*,
                                         const String& type,
-                                        const VRFrameOfReferenceOptions&);
+                                        const XRFrameOfReferenceOptions&);
 
-  int requestFrame(V8VRFrameRequestCallback*);
+  int requestFrame(V8XRFrameRequestCallback*);
   void cancelFrame(int id);
 
   // Called by JavaScript to manually end the session.
@@ -78,18 +78,18 @@
   void OnBlur();
   void OnFrame(std::unique_ptr<TransformationMatrix>);
 
-  const HeapVector<Member<VRView>>& views();
+  const HeapVector<Member<XRView>>& views();
 
   void Trace(blink::Visitor*) override;
   virtual void TraceWrappers(const blink::ScriptWrappableVisitor*) const;
 
  private:
-  const Member<VRDevice> device_;
+  const Member<XRDevice> device_;
   const bool exclusive_;
-  Member<VRLayer> base_layer_;
-  HeapVector<Member<VRView>> views_;
+  Member<XRLayer> base_layer_;
+  HeapVector<Member<XRView>> views_;
 
-  VRFrameRequestCallbackCollection callback_collection_;
+  XRFrameRequestCallbackCollection callback_collection_;
 
   double depth_near_ = 0.1;
   double depth_far_ = 1000.0;
@@ -102,4 +102,4 @@
 
 }  // namespace blink
 
-#endif  // VRWebGLLayer_h
+#endif  // XRWebGLLayer_h

diff --git a/third_party/WebKit/Source/modules/xr/XRSession.idl b/third_party/WebKit/Source/modules/xr/XRSession.idl
new file mode 100644
index 0000000..5918c8f29
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRSession.idl

@@ -0,0 +1,29 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://immersive-web.github.io/webxr/spec/latest/#xrsession-interface
+[
+    SecureContext,
+    RuntimeEnabled=WebXR
+] interface XRSession : EventTarget {
+  readonly attribute XRDevice device;
+  readonly attribute boolean exclusive;
+
+  attribute double depthNear;
+  attribute double depthFar;
+
+  attribute XRLayer baseLayer;
+
+  attribute EventHandler onblur;
+  attribute EventHandler onfocus;
+  attribute EventHandler onresetpose;
+  attribute EventHandler onend;
+
+  [CallWith=ScriptState] Promise<XRFrameOfReference> requestFrameOfReference(XRFrameOfReferenceType type, [PermissiveDictionaryConversion] optional XRFrameOfReferenceOptions options);
+
+  long requestFrame(XRFrameRequestCallback callback);
+  void cancelFrame(long handle);
+
+  [CallWith=ScriptState] Promise<void> end();
+};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRSessionCreationOptions.idl b/third_party/WebKit/Source/modules/xr/XRSessionCreationOptions.idl
similarity index 62%
rename from third_party/WebKit/Source/modules/vr/latest/VRSessionCreationOptions.idl
rename to third_party/WebKit/Source/modules/xr/XRSessionCreationOptions.idl
index 786d630b..382052f 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRSessionCreationOptions.idl
+++ b/third_party/WebKit/Source/modules/xr/XRSessionCreationOptions.idl

@@ -2,9 +2,9 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrsessioncreationoptions-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrsessioncreationoptions-interface
 [
     SecureContext
-] dictionary VRSessionCreationOptions {
+] dictionary XRSessionCreationOptions {
   boolean exclusive = false;
 };

diff --git a/third_party/WebKit/Source/modules/xr/XRSessionEvent.cpp b/third_party/WebKit/Source/modules/xr/XRSessionEvent.cpp
new file mode 100644
index 0000000..f1ca59c4
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRSessionEvent.cpp

@@ -0,0 +1,32 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "modules/xr/XRSessionEvent.h"
+
+namespace blink {
+
+XRSessionEvent::XRSessionEvent() {}
+
+XRSessionEvent::XRSessionEvent(const AtomicString& type, XRSession* session)
+    : Event(type, true, false), session_(session) {}
+
+XRSessionEvent::XRSessionEvent(const AtomicString& type,
+                               const XRSessionEventInit& initializer)
+    : Event(type, initializer) {
+  if (initializer.hasSession())
+    session_ = initializer.session();
+}
+
+XRSessionEvent::~XRSessionEvent() {}
+
+const AtomicString& XRSessionEvent::InterfaceName() const {
+  return EventNames::XRSessionEvent;
+}
+
+void XRSessionEvent::Trace(blink::Visitor* visitor) {
+  visitor->Trace(session_);
+  Event::Trace(visitor);
+}
+
+}  // namespace blink

diff --git a/third_party/WebKit/Source/modules/xr/XRSessionEvent.h b/third_party/WebKit/Source/modules/xr/XRSessionEvent.h
new file mode 100644
index 0000000..5885ca0
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRSessionEvent.h

@@ -0,0 +1,46 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef XRSessionEvent_h
+#define XRSessionEvent_h
+
+#include "modules/EventModules.h"
+#include "modules/xr/XRSession.h"
+#include "modules/xr/XRSessionEventInit.h"
+
+namespace blink {
+
+class XRSessionEvent final : public Event {
+  DEFINE_WRAPPERTYPEINFO();
+
+ public:
+  static XRSessionEvent* Create() { return new XRSessionEvent; }
+  static XRSessionEvent* Create(const AtomicString& type, XRSession* session) {
+    return new XRSessionEvent(type, session);
+  }
+
+  static XRSessionEvent* Create(const AtomicString& type,
+                                const XRSessionEventInit& initializer) {
+    return new XRSessionEvent(type, initializer);
+  }
+
+  ~XRSessionEvent() override;
+
+  XRSession* session() const { return session_.Get(); }
+
+  const AtomicString& InterfaceName() const override;
+
+  void Trace(blink::Visitor*) override;
+
+ private:
+  XRSessionEvent();
+  XRSessionEvent(const AtomicString& type, XRSession*);
+  XRSessionEvent(const AtomicString& type, const XRSessionEventInit&);
+
+  Member<XRSession> session_;
+};
+
+}  // namespace blink
+
+#endif  // XRDisplayEvent_h

diff --git a/third_party/WebKit/Source/modules/xr/XRSessionEvent.idl b/third_party/WebKit/Source/modules/xr/XRSessionEvent.idl
new file mode 100644
index 0000000..8c2570b
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRSessionEvent.idl

@@ -0,0 +1,12 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://immersive-web.github.io/webxr/spec/latest/#xrsessionevent-interface
+[
+    SecureContext,
+    RuntimeEnabled=WebXR,
+    Constructor(DOMString type, XRSessionEventInit eventInitDict)
+] interface XRSessionEvent : Event {
+  readonly attribute XRSession session;
+};
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/xr/XRSessionEventInit.idl b/third_party/WebKit/Source/modules/xr/XRSessionEventInit.idl
new file mode 100644
index 0000000..cb2d268
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRSessionEventInit.idl

@@ -0,0 +1,10 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://immersive-web.github.io/webxr/spec/latest/#xrsessionevent-interface
+[
+    SecureContext
+] dictionary XRSessionEventInit : EventInit {
+  required XRSession session;
+};
\ No newline at end of file

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRStageBounds.cpp b/third_party/WebKit/Source/modules/xr/XRStageBounds.cpp
similarity index 73%
rename from third_party/WebKit/Source/modules/vr/latest/VRStageBounds.cpp
rename to third_party/WebKit/Source/modules/xr/XRStageBounds.cpp
index 108d1656..00d8342 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRStageBounds.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRStageBounds.cpp

@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRStageBounds.h"
+#include "modules/xr/XRStageBounds.h"
 
 namespace blink {
 
-void VRStageBounds::Trace(blink::Visitor* visitor) {
+void XRStageBounds::Trace(blink::Visitor* visitor) {
   visitor->Trace(geometry_);
   ScriptWrappable::Trace(visitor);
 }

diff --git a/third_party/WebKit/Source/modules/xr/XRStageBounds.h b/third_party/WebKit/Source/modules/xr/XRStageBounds.h
new file mode 100644
index 0000000..97750cb1
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRStageBounds.h

@@ -0,0 +1,31 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef XRStageBounds_h
+#define XRStageBounds_h
+
+#include "modules/xr/XRStageBoundsPoint.h"
+#include "platform/bindings/ScriptWrappable.h"
+#include "platform/heap/Handle.h"
+#include "platform/wtf/Forward.h"
+
+namespace blink {
+
+class XRStageBounds final : public ScriptWrappable {
+  DEFINE_WRAPPERTYPEINFO();
+
+ public:
+  XRStageBounds() = default;
+
+  HeapVector<Member<XRStageBoundsPoint>> geometry() const { return geometry_; }
+
+  virtual void Trace(blink::Visitor*);
+
+ private:
+  HeapVector<Member<XRStageBoundsPoint>> geometry_;
+};
+
+}  // namespace blink
+
+#endif  // XRStageBounds_h

diff --git a/third_party/WebKit/Source/modules/xr/XRStageBounds.idl b/third_party/WebKit/Source/modules/xr/XRStageBounds.idl
new file mode 100644
index 0000000..049e95b
--- /dev/null
+++ b/third_party/WebKit/Source/modules/xr/XRStageBounds.idl

@@ -0,0 +1,11 @@
+// Copyright 2017 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// https://immersive-web.github.io/webxr/spec/latest/#xrstagebounds-interface
+[
+    SecureContext,
+    RuntimeEnabled=WebXR
+] interface XRStageBounds {
+  readonly attribute FrozenArray<XRStageBoundsPoint> geometry;
+};

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRStageBoundsPoint.h b/third_party/WebKit/Source/modules/xr/XRStageBoundsPoint.h
similarity index 69%
rename from third_party/WebKit/Source/modules/vr/latest/VRStageBoundsPoint.h
rename to third_party/WebKit/Source/modules/xr/XRStageBoundsPoint.h
index 003aa92f..7291fa8 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRStageBoundsPoint.h
+++ b/third_party/WebKit/Source/modules/xr/XRStageBoundsPoint.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRStageBoundsPoint_h
-#define VRStageBoundsPoint_h
+#ifndef XRStageBoundsPoint_h
+#define XRStageBoundsPoint_h
 
 #include "platform/bindings/ScriptWrappable.h"
 #include "platform/heap/Handle.h"
@@ -11,11 +11,11 @@
 
 namespace blink {
 
-class VRStageBoundsPoint final : public ScriptWrappable {
+class XRStageBoundsPoint final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  VRStageBoundsPoint(double x, double z) : x_(x), z_(z) {}
+  XRStageBoundsPoint(double x, double z) : x_(x), z_(z) {}
 
   double x() const { return x_; }
   double z() const { return z_; }
@@ -27,4 +27,4 @@
 
 }  // namespace blink
 
-#endif  // VRStageBoundsPoint_h
+#endif  // XRStageBoundsPoint_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRStageBoundsPoint.idl b/third_party/WebKit/Source/modules/xr/XRStageBoundsPoint.idl
similarity index 70%
rename from third_party/WebKit/Source/modules/vr/latest/VRStageBoundsPoint.idl
rename to third_party/WebKit/Source/modules/xr/XRStageBoundsPoint.idl
index b6a2f89..99a4acd 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRStageBoundsPoint.idl
+++ b/third_party/WebKit/Source/modules/xr/XRStageBoundsPoint.idl

@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrstageboundspoint-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrstageboundspoint-interface
 [
     SecureContext,
     RuntimeEnabled=WebXR
-] interface VRStageBoundsPoint {
+] interface XRStageBoundsPoint {
   readonly attribute double x;
   readonly attribute double z;
 };

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRView.cpp b/third_party/WebKit/Source/modules/xr/XRView.cpp
similarity index 77%
rename from third_party/WebKit/Source/modules/vr/latest/VRView.cpp
rename to third_party/WebKit/Source/modules/xr/XRView.cpp
index 3b8c6d0..208b9a9 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRView.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRView.cpp

@@ -2,35 +2,35 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRView.h"
+#include "modules/xr/XRView.h"
 
-#include "modules/vr/latest/VRLayer.h"
-#include "modules/vr/latest/VRPresentationFrame.h"
-#include "modules/vr/latest/VRSession.h"
-#include "modules/vr/latest/VRViewport.h"
+#include "modules/xr/XRLayer.h"
+#include "modules/xr/XRPresentationFrame.h"
+#include "modules/xr/XRSession.h"
+#include "modules/xr/XRViewport.h"
 #include "platform/geometry/FloatPoint3D.h"
 
 namespace blink {
 
-VRView::VRView(VRSession* session, Eye eye)
+XRView::XRView(XRSession* session, Eye eye)
     : eye_(eye),
       session_(session),
       projection_matrix_(DOMFloat32Array::Create(16)) {
   eye_string_ = (eye_ == kEyeLeft ? "left" : "right");
 }
 
-VRSession* VRView::session() const {
+XRSession* XRView::session() const {
   return session_;
 }
 
-VRViewport* VRView::getViewport(VRLayer* layer) const {
+XRViewport* XRView::getViewport(XRLayer* layer) const {
   if (!layer || layer->session() != session_)
     return nullptr;
 
   return layer->GetViewport(eye_);
 }
 
-void VRView::UpdateProjectionMatrixFromFoV(float up_rad,
+void XRView::UpdateProjectionMatrixFromFoV(float up_rad,
                                            float down_rad,
                                            float left_rad,
                                            float right_rad,
@@ -63,11 +63,11 @@
   out[15] = 0.0f;
 }
 
-void VRView::UpdateOffset(float x, float y, float z) {
+void XRView::UpdateOffset(float x, float y, float z) {
   offset_.Set(x, y, z);
 }
 
-void VRView::Trace(blink::Visitor* visitor) {
+void XRView::Trace(blink::Visitor* visitor) {
   visitor->Trace(session_);
   visitor->Trace(projection_matrix_);
   ScriptWrappable::Trace(visitor);

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRView.h b/third_party/WebKit/Source/modules/xr/XRView.h
similarity index 83%
rename from third_party/WebKit/Source/modules/vr/latest/VRView.h
rename to third_party/WebKit/Source/modules/xr/XRView.h
index acc5b9b..84e4fa4 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRView.h
+++ b/third_party/WebKit/Source/modules/xr/XRView.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRView_h
-#define VRView_h
+#ifndef XRView_h
+#define XRView_h
 
 #include "core/typed_arrays/DOMTypedArray.h"
 #include "platform/bindings/ScriptWrappable.h"
@@ -15,22 +15,22 @@
 
 namespace blink {
 
-class VRLayer;
-class VRSession;
-class VRViewport;
+class XRLayer;
+class XRSession;
+class XRViewport;
 
-class VRView final : public ScriptWrappable {
+class XRView final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
   enum Eye { kEyeLeft = 0, kEyeRight = 1 };
 
-  VRView(VRSession*, Eye);
+  XRView(XRSession*, Eye);
 
   const String& eye() const { return eye_string_; }
-  VRSession* session() const;
+  XRSession* session() const;
   DOMFloat32Array* projectionMatrix() const { return projection_matrix_; }
-  VRViewport* getViewport(VRLayer*) const;
+  XRViewport* getViewport(XRLayer*) const;
 
   void UpdateProjectionMatrixFromFoV(float up_rad,
                                      float down_rad,
@@ -48,11 +48,11 @@
  private:
   const Eye eye_;
   String eye_string_;
-  Member<VRSession> session_;
+  Member<XRSession> session_;
   Member<DOMFloat32Array> projection_matrix_;
   FloatPoint3D offset_;
 };
 
 }  // namespace blink
 
-#endif  // VRView_h
+#endif  // XRView_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRView.idl b/third_party/WebKit/Source/modules/xr/XRView.idl
similarity index 69%
rename from third_party/WebKit/Source/modules/vr/latest/VRView.idl
rename to third_party/WebKit/Source/modules/xr/XRView.idl
index 61b26aa3..3b0d5e2 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRView.idl
+++ b/third_party/WebKit/Source/modules/xr/XRView.idl

@@ -2,12 +2,12 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrview-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrview-interface
 [
     SecureContext,
     RuntimeEnabled=WebXR
-] interface VRView {
+] interface XRView {
   readonly attribute VREye? eye;
   readonly attribute Float32Array projectionMatrix;
-  VRViewport? getViewport(VRLayer layer);
+  XRViewport? getViewport(XRLayer layer);
 };

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRViewport.h b/third_party/WebKit/Source/modules/xr/XRViewport.h
similarity index 78%
rename from third_party/WebKit/Source/modules/vr/latest/VRViewport.h
rename to third_party/WebKit/Source/modules/xr/XRViewport.h
index 80829b5..1a60b2ad 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRViewport.h
+++ b/third_party/WebKit/Source/modules/xr/XRViewport.h

@@ -2,8 +2,8 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRViewport_h
-#define VRViewport_h
+#ifndef XRViewport_h
+#define XRViewport_h
 
 #include "platform/bindings/ScriptWrappable.h"
 #include "platform/heap/Handle.h"
@@ -11,11 +11,11 @@
 
 namespace blink {
 
-class VRViewport final : public ScriptWrappable {
+class XRViewport final : public ScriptWrappable {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  VRViewport(int x, int y, int width, int height)
+  XRViewport(int x, int y, int width, int height)
       : x_(x), y_(y), width_(width), height_(height) {}
 
   int x() const { return x_; }
@@ -32,4 +32,4 @@
 
 }  // namespace blink
 
-#endif  // VRViewport_h
+#endif  // XRViewport_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRViewport.idl b/third_party/WebKit/Source/modules/xr/XRViewport.idl
similarity index 77%
rename from third_party/WebKit/Source/modules/vr/latest/VRViewport.idl
rename to third_party/WebKit/Source/modules/xr/XRViewport.idl
index c259573..17a8b74 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRViewport.idl
+++ b/third_party/WebKit/Source/modules/xr/XRViewport.idl

@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrviewport-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrviewport-interface
 [
     SecureContext,
     RuntimeEnabled=WebXR
-] interface VRViewport {
+] interface XRViewport {
   readonly attribute long x;
   readonly attribute long y;
   readonly attribute long width;

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRWebGLDrawingBuffer.cpp b/third_party/WebKit/Source/modules/xr/XRWebGLDrawingBuffer.cpp
similarity index 93%
rename from third_party/WebKit/Source/modules/vr/latest/VRWebGLDrawingBuffer.cpp
rename to third_party/WebKit/Source/modules/xr/XRWebGLDrawingBuffer.cpp
index 2b0e00b..62b6caf 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRWebGLDrawingBuffer.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRWebGLDrawingBuffer.cpp

@@ -2,13 +2,13 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRWebGLDrawingBuffer.h"
+#include "modules/xr/XRWebGLDrawingBuffer.h"
 
 #include "gpu/command_buffer/client/gles2_interface.h"
-#include "modules/vr/latest/VRSession.h"
-#include "modules/vr/latest/VRView.h"
-#include "modules/vr/latest/VRViewport.h"
 #include "modules/webgl/WebGLFramebuffer.h"
+#include "modules/xr/XRSession.h"
+#include "modules/xr/XRView.h"
+#include "modules/xr/XRViewport.h"
 #include "platform/graphics/AcceleratedStaticBitmapImage.h"
 #include "platform/graphics/gpu/DrawingBuffer.h"
 #include "platform/graphics/gpu/Extensions3DUtil.h"
@@ -21,7 +21,7 @@
 // to the more narrow use case. It may make sense in the future to abstract out
 // some of the common bits into a base class?
 
-VRWebGLDrawingBuffer* VRWebGLDrawingBuffer::Create(
+XRWebGLDrawingBuffer* XRWebGLDrawingBuffer::Create(
     WebGLRenderingContextBase* webgl_context,
     const IntSize& size,
     bool want_alpha_channel,
@@ -66,19 +66,19 @@
   // TODO(bajones): Support multiview.
   bool multiview_supported = false;
 
-  VRWebGLDrawingBuffer* drawing_buffer = new VRWebGLDrawingBuffer(
+  XRWebGLDrawingBuffer* drawing_buffer = new XRWebGLDrawingBuffer(
       webgl_context, discard_framebuffer_supported, want_alpha_channel,
       want_depth_buffer, want_stencil_buffer, multiview_supported);
   if (!drawing_buffer->Initialize(size, multisample_supported,
                                   multiview_supported)) {
-    DLOG(ERROR) << "VRWebGLDrawingBuffer Initialization Failed";
+    DLOG(ERROR) << "XRWebGLDrawingBuffer Initialization Failed";
     return nullptr;
   }
 
   return drawing_buffer;
 }
 
-VRWebGLDrawingBuffer::VRWebGLDrawingBuffer(
+XRWebGLDrawingBuffer::XRWebGLDrawingBuffer(
     WebGLRenderingContextBase* webgl_context,
     bool discard_framebuffer_supported,
     bool want_alpha_channel,
@@ -96,7 +96,7 @@
 
 // TODO(bajones): The GL resources allocated in this function are leaking. Add
 // a way to clean up the buffers when the layer is GCed or the session ends.
-bool VRWebGLDrawingBuffer::Initialize(const IntSize& size,
+bool XRWebGLDrawingBuffer::Initialize(const IntSize& size,
                                       bool use_multisampling,
                                       bool use_multiview) {
   gpu::gles2::GLES2Interface* gl = gl_context();
@@ -152,7 +152,7 @@
   return true;
 }
 
-void VRWebGLDrawingBuffer::Resize(const IntSize& new_size) {
+void XRWebGLDrawingBuffer::Resize(const IntSize& new_size) {
   if (webgl_context_->isContextLost())
     return;
 
@@ -252,11 +252,11 @@
   client->DrawingBufferClientRestoreFramebufferBinding();
 }
 
-void VRWebGLDrawingBuffer::MarkFramebufferComplete(bool complete) {
+void XRWebGLDrawingBuffer::MarkFramebufferComplete(bool complete) {
   framebuffer_->MarkOpaqueBufferComplete(complete);
 }
 
-GLuint VRWebGLDrawingBuffer::CreateColorBuffer() {
+GLuint XRWebGLDrawingBuffer::CreateColorBuffer() {
   gpu::gles2::GLES2Interface* gl = gl_context();
 
   GLuint texture_id = 0;
@@ -284,14 +284,14 @@
   return texture_id;
 }
 
-bool VRWebGLDrawingBuffer::WantExplicitResolve() const {
+bool XRWebGLDrawingBuffer::WantExplicitResolve() const {
   return anti_aliasing_mode_ == kMSAAExplicitResolve;
 }
 
 // Swap the front and back buffers. After this call the front buffer should
 // contain the previously rendered content, resolved from the multisample
 // renderbuffer if needed.
-void VRWebGLDrawingBuffer::SwapColorBuffers() {
+void XRWebGLDrawingBuffer::SwapColorBuffers() {
   if (webgl_context_->isContextLost())
     return;
 
@@ -338,12 +338,12 @@
   client->DrawingBufferClientRestoreFramebufferBinding();
 }
 
-void VRWebGLDrawingBuffer::Trace(blink::Visitor* visitor) {
+void XRWebGLDrawingBuffer::Trace(blink::Visitor* visitor) {
   visitor->Trace(webgl_context_);
   visitor->Trace(framebuffer_);
 }
 
-void VRWebGLDrawingBuffer::TraceWrappers(
+void XRWebGLDrawingBuffer::TraceWrappers(
     const ScriptWrappableVisitor* visitor) const {
   visitor->TraceWrappers(webgl_context_);
 }

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRWebGLDrawingBuffer.h b/third_party/WebKit/Source/modules/xr/XRWebGLDrawingBuffer.h
similarity index 87%
rename from third_party/WebKit/Source/modules/vr/latest/VRWebGLDrawingBuffer.h
rename to third_party/WebKit/Source/modules/xr/XRWebGLDrawingBuffer.h
index 4f6cc93..df2e6ac 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRWebGLDrawingBuffer.h
+++ b/third_party/WebKit/Source/modules/xr/XRWebGLDrawingBuffer.h

@@ -2,14 +2,14 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRWebGLDrawingBuffer_h
-#define VRWebGLDrawingBuffer_h
+#ifndef XRWebGLDrawingBuffer_h
+#define XRWebGLDrawingBuffer_h
 
 #include "gpu/command_buffer/common/mailbox_holder.h"
-#include "modules/vr/latest/VRLayer.h"
-#include "modules/vr/latest/VRWebGLLayerInit.h"
 #include "modules/webgl/WebGL2RenderingContext.h"
 #include "modules/webgl/WebGLRenderingContext.h"
+#include "modules/xr/XRLayer.h"
+#include "modules/xr/XRWebGLLayerInit.h"
 #include "platform/geometry/IntSize.h"
 #include "platform/heap/Handle.h"
 
@@ -17,11 +17,11 @@
 
 class WebGLFramebuffer;
 
-class VRWebGLDrawingBuffer final
-    : public GarbageCollected<VRWebGLDrawingBuffer>,
+class XRWebGLDrawingBuffer final
+    : public GarbageCollected<XRWebGLDrawingBuffer>,
       public TraceWrapperBase {
  public:
-  static VRWebGLDrawingBuffer* Create(WebGLRenderingContextBase*,
+  static XRWebGLDrawingBuffer* Create(WebGLRenderingContextBase*,
                                       const IntSize&,
                                       bool want_alpha_channel,
                                       bool want_depth_buffer,
@@ -48,7 +48,7 @@
   virtual void TraceWrappers(const ScriptWrappableVisitor*) const;
 
  private:
-  VRWebGLDrawingBuffer(WebGLRenderingContextBase*,
+  XRWebGLDrawingBuffer(WebGLRenderingContextBase*,
                        bool discard_framebuffer_supported,
                        bool want_alpha_channel,
                        bool want_depth_buffer,
@@ -106,4 +106,4 @@
 
 }  // namespace blink
 
-#endif  // VRWebGLDrawingBuffer_h
+#endif  // XRWebGLDrawingBuffer_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.cpp b/third_party/WebKit/Source/modules/xr/XRWebGLLayer.cpp
similarity index 75%
rename from third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.cpp
rename to third_party/WebKit/Source/modules/xr/XRWebGLLayer.cpp
index 97455169..2bb1f058 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.cpp
+++ b/third_party/WebKit/Source/modules/xr/XRWebGLLayer.cpp

@@ -2,16 +2,16 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "modules/vr/latest/VRWebGLLayer.h"
+#include "modules/xr/XRWebGLLayer.h"
 
-#include "modules/vr/latest/VRDevice.h"
-#include "modules/vr/latest/VRFrameProvider.h"
-#include "modules/vr/latest/VRSession.h"
-#include "modules/vr/latest/VRView.h"
-#include "modules/vr/latest/VRViewport.h"
 #include "modules/webgl/WebGL2RenderingContext.h"
 #include "modules/webgl/WebGLFramebuffer.h"
 #include "modules/webgl/WebGLRenderingContext.h"
+#include "modules/xr/XRDevice.h"
+#include "modules/xr/XRFrameProvider.h"
+#include "modules/xr/XRSession.h"
+#include "modules/xr/XRView.h"
+#include "modules/xr/XRViewport.h"
 #include "platform/geometry/DoubleSize.h"
 #include "platform/geometry/IntSize.h"
 
@@ -32,10 +32,10 @@
 
 }  // namespace
 
-VRWebGLLayer* VRWebGLLayer::Create(
-    VRSession* session,
+XRWebGLLayer* XRWebGLLayer::Create(
+    XRSession* session,
     const WebGLRenderingContextOrWebGL2RenderingContext& context,
-    const VRWebGLLayerInit& initializer) {
+    const XRWebGLLayerInit& initializer) {
   WebGLRenderingContextBase* webgl_context;
   if (context.IsWebGL2RenderingContext()) {
     webgl_context = context.GetAsWebGL2RenderingContext();
@@ -65,7 +65,7 @@
   IntSize desired_size(framebuffers_size.Width() * framebuffer_scale,
                        framebuffers_size.Height() * framebuffer_scale);
 
-  VRWebGLDrawingBuffer* drawing_buffer = VRWebGLDrawingBuffer::Create(
+  XRWebGLDrawingBuffer* drawing_buffer = XRWebGLDrawingBuffer::Create(
       webgl_context, desired_size, want_alpha_channel, want_depth_buffer,
       want_stencil_buffer, want_antialiasing, want_multiview);
 
@@ -73,16 +73,16 @@
     return nullptr;
   }
 
-  return new VRWebGLLayer(session, drawing_buffer);
+  return new XRWebGLLayer(session, drawing_buffer);
 }
 
-VRWebGLLayer::VRWebGLLayer(VRSession* session,
-                           VRWebGLDrawingBuffer* drawing_buffer)
-    : VRLayer(session, kVRWebGLLayerType), drawing_buffer_(drawing_buffer) {
+XRWebGLLayer::XRWebGLLayer(XRSession* session,
+                           XRWebGLDrawingBuffer* drawing_buffer)
+    : XRLayer(session, kXRWebGLLayerType), drawing_buffer_(drawing_buffer) {
   DCHECK(drawing_buffer);
 }
 
-void VRWebGLLayer::getVRWebGLRenderingContext(
+void XRWebGLLayer::getXRWebGLRenderingContext(
     WebGLRenderingContextOrWebGL2RenderingContext& result) const {
   WebGLRenderingContextBase* webgl_context = drawing_buffer_->webgl_context();
   if (webgl_context->Version() == 2) {
@@ -94,7 +94,7 @@
   }
 }
 
-void VRWebGLLayer::requestViewportScaling(double scale_factor) {
+void XRWebGLLayer::requestViewportScaling(double scale_factor) {
   // Clamp the developer-requested viewport size to ensure it's not too
   // small to see or larger than the framebuffer.
   scale_factor =
@@ -106,49 +106,49 @@
   }
 }
 
-VRViewport* VRWebGLLayer::GetViewport(VRView::Eye eye) {
+XRViewport* XRWebGLLayer::GetViewport(XRView::Eye eye) {
   if (viewports_dirty_)
     UpdateViewports();
 
-  if (eye == VRView::kEyeLeft)
+  if (eye == XRView::kEyeLeft)
     return left_viewport_;
 
   return right_viewport_;
 }
 
-void VRWebGLLayer::UpdateViewports() {
+void XRWebGLLayer::UpdateViewports() {
   long framebuffer_width = framebufferWidth();
   long framebuffer_height = framebufferHeight();
 
   if (session()->exclusive()) {
     left_viewport_ =
-        new VRViewport(0, 0, framebuffer_width * 0.5 * viewport_scale_,
+        new XRViewport(0, 0, framebuffer_width * 0.5 * viewport_scale_,
                        framebuffer_height * viewport_scale_);
     right_viewport_ =
-        new VRViewport(framebuffer_width * 0.5 * viewport_scale_, 0,
+        new XRViewport(framebuffer_width * 0.5 * viewport_scale_, 0,
                        framebuffer_width * 0.5 * viewport_scale_,
                        framebuffer_height * viewport_scale_);
   } else {
-    left_viewport_ = new VRViewport(0, 0, framebuffer_width * viewport_scale_,
+    left_viewport_ = new XRViewport(0, 0, framebuffer_width * viewport_scale_,
                                     framebuffer_height * viewport_scale_);
   }
 
   viewports_dirty_ = false;
 }
 
-void VRWebGLLayer::OnFrameStart() {
+void XRWebGLLayer::OnFrameStart() {
   drawing_buffer_->MarkFramebufferComplete(true);
 }
 
-void VRWebGLLayer::OnFrameEnd() {
+void XRWebGLLayer::OnFrameEnd() {
   drawing_buffer_->MarkFramebufferComplete(false);
 }
 
-void VRWebGLLayer::Trace(blink::Visitor* visitor) {
+void XRWebGLLayer::Trace(blink::Visitor* visitor) {
   visitor->Trace(left_viewport_);
   visitor->Trace(right_viewport_);
   visitor->Trace(drawing_buffer_);
-  VRLayer::Trace(visitor);
+  XRLayer::Trace(visitor);
 }
 
 }  // namespace blink

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.h b/third_party/WebKit/Source/modules/xr/XRWebGLLayer.h
similarity index 70%
rename from third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.h
rename to third_party/WebKit/Source/modules/xr/XRWebGLLayer.h
index a6f4ca5..759365a4 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.h
+++ b/third_party/WebKit/Source/modules/xr/XRWebGLLayer.h

@@ -2,33 +2,33 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#ifndef VRWebGLLayer_h
-#define VRWebGLLayer_h
+#ifndef XRWebGLLayer_h
+#define XRWebGLLayer_h
 
 #include "bindings/modules/v8/webgl_rendering_context_or_webgl2_rendering_context.h"
-#include "modules/vr/latest/VRLayer.h"
-#include "modules/vr/latest/VRWebGLDrawingBuffer.h"
-#include "modules/vr/latest/VRWebGLLayerInit.h"
+#include "modules/xr/XRLayer.h"
+#include "modules/xr/XRWebGLDrawingBuffer.h"
+#include "modules/xr/XRWebGLLayerInit.h"
 
 namespace blink {
 
 class WebGLFramebuffer;
 class WebGLRenderingContextBase;
-class VRSession;
+class XRSession;
 
-class VRWebGLLayer final : public VRLayer {
+class XRWebGLLayer final : public XRLayer {
   DEFINE_WRAPPERTYPEINFO();
 
  public:
-  static VRWebGLLayer* Create(
-      VRSession*,
+  static XRWebGLLayer* Create(
+      XRSession*,
       const WebGLRenderingContextOrWebGL2RenderingContext&,
-      const VRWebGLLayerInit&);
+      const XRWebGLLayerInit&);
 
   WebGLRenderingContextBase* context() const {
     return drawing_buffer_->webgl_context();
   }
-  void getVRWebGLRenderingContext(
+  void getXRWebGLRenderingContext(
       WebGLRenderingContextOrWebGL2RenderingContext&) const;
 
   WebGLFramebuffer* framebuffer() const {
@@ -49,7 +49,7 @@
 
   void requestViewportScaling(double scale_factor);
 
-  VRViewport* GetViewport(VRView::Eye) override;
+  XRViewport* GetViewport(XRView::Eye) override;
 
   void UpdateViewports();
 
@@ -59,11 +59,11 @@
   virtual void Trace(blink::Visitor*);
 
  private:
-  VRWebGLLayer(VRSession*, VRWebGLDrawingBuffer*);
+  XRWebGLLayer(XRSession*, XRWebGLDrawingBuffer*);
 
-  Member<VRViewport> left_viewport_;
-  Member<VRViewport> right_viewport_;
-  Member<VRWebGLDrawingBuffer> drawing_buffer_;
+  Member<XRViewport> left_viewport_;
+  Member<XRViewport> right_viewport_;
+  Member<XRWebGLDrawingBuffer> drawing_buffer_;
 
   double viewport_scale_ = 1.0;
   bool viewports_dirty_ = true;
@@ -71,4 +71,4 @@
 
 }  // namespace blink
 
-#endif  // VRWebGLLayer_h
+#endif  // XRWebGLLayer_h

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.idl b/third_party/WebKit/Source/modules/xr/XRWebGLLayer.idl
similarity index 62%
rename from third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.idl
rename to third_party/WebKit/Source/modules/xr/XRWebGLLayer.idl
index 5732556..359185f 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRWebGLLayer.idl
+++ b/third_party/WebKit/Source/modules/xr/XRWebGLLayer.idl

@@ -2,15 +2,15 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-typedef (WebGLRenderingContext or WebGL2RenderingContext) VRWebGLRenderingContext;
+typedef (WebGLRenderingContext or WebGL2RenderingContext) XRWebGLRenderingContext;
 
-// https://w3c.github.io/webvr/spec/latest/#vrwebgllayer-interface
+// https://immersive-web.github.io/webxr/spec/latest/#xrwebgllayer-interface
 [
     SecureContext,
     RuntimeEnabled=WebXR,
-    Constructor(VRSession session, VRWebGLRenderingContext context, optional VRWebGLLayerInit layerInit)
-] interface VRWebGLLayer : VRLayer {
-  [ImplementedAs=getVRWebGLRenderingContext] readonly attribute VRWebGLRenderingContext context;
+    Constructor(XRSession session, XRWebGLRenderingContext context, optional XRWebGLLayerInit layerInit)
+] interface XRWebGLLayer : XRLayer {
+  [ImplementedAs=getXRWebGLRenderingContext] readonly attribute XRWebGLRenderingContext context;
   readonly attribute boolean antialias;
   readonly attribute boolean depth;
   readonly attribute boolean stencil;

diff --git a/third_party/WebKit/Source/modules/vr/latest/VRWebGLLayerInit.idl b/third_party/WebKit/Source/modules/xr/XRWebGLLayerInit.idl
similarity index 75%
rename from third_party/WebKit/Source/modules/vr/latest/VRWebGLLayerInit.idl
rename to third_party/WebKit/Source/modules/xr/XRWebGLLayerInit.idl
index 46aacb5..0071cc5 100644
--- a/third_party/WebKit/Source/modules/vr/latest/VRWebGLLayerInit.idl
+++ b/third_party/WebKit/Source/modules/xr/XRWebGLLayerInit.idl

@@ -2,10 +2,10 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// https://w3c.github.io/webvr/spec/latest/#vrwebgllayerinit-dictionary
+// https://immersive-web.github.io/webxr/spec/latest/#xrwebgllayerinit-dictionary
 [
     SecureContext
-] dictionary VRWebGLLayerInit {
+] dictionary XRWebGLLayerInit {
   boolean antialias = true;
   boolean depth = true;
   boolean stencil = false;

diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
index 8ee06d5..36288686 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_impl.cc

@@ -410,7 +410,7 @@
   while (!main_thread_only().delayed_incoming_queue.empty()) {
     Task& task =
         const_cast<Task&>(main_thread_only().delayed_incoming_queue.top());
-    if (task.task.IsCancelled()) {
+    if (!task.task || task.task.IsCancelled()) {
       main_thread_only().delayed_incoming_queue.pop();
       continue;
     }

diff --git a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
index 5a371b5..d91fd17 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/task_queue_manager.cc

@@ -477,7 +477,10 @@
       work_queue->TakeTaskFromWorkQueue();
 
   // It's possible the task was canceled, if so bail out.
-  if (pending_task.task.IsCancelled())
+  // The task should be non-null, but it seems to be possible to due
+  // a hard-to-track bug. The first check is a defence against this bug,
+  // and this check isn't expected to be true in practice.
+  if (!pending_task.task || pending_task.task.IsCancelled())
     return ProcessTaskResult::kExecuted;
 
   internal::TaskQueueImpl* queue = work_queue->task_queue();

diff --git a/third_party/WebKit/Source/platform/scheduler/base/work_queue.cc b/third_party/WebKit/Source/platform/scheduler/base/work_queue.cc
index e28f4814c..3d7d757 100644
--- a/third_party/WebKit/Source/platform/scheduler/base/work_queue.cc
+++ b/third_party/WebKit/Source/platform/scheduler/base/work_queue.cc

@@ -97,7 +97,7 @@
   // Skip over canceled tasks, except for the last one since we always return
   // something.
   while (work_queue_.size() > 1u) {
-    if (work_queue_.front().task.IsCancelled()) {
+    if (!work_queue_.front().task || work_queue_.front().task.IsCancelled()) {
       work_queue_.pop_front();
     } else {
       break;

diff --git a/third_party/WebKit/Tools/Scripts/audit-non-blink-usage.py b/third_party/WebKit/Tools/Scripts/audit-non-blink-usage.py
index 0de8fe2..c2c240a 100755
--- a/third_party/WebKit/Tools/Scripts/audit-non-blink-usage.py
+++ b/third_party/WebKit/Tools/Scripts/audit-non-blink-usage.py

@@ -127,6 +127,7 @@
             'third_party/WebKit/Source/core/html/media/',
             'third_party/WebKit/Source/modules/vr/',
             'third_party/WebKit/Source/modules/webgl/',
+            'third_party/WebKit/Source/modules/xr/',
         ],
         # These modules need access to GL drawing, cross-process image
         # transport, and related interfaces.

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py b/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py
index e16e852..de7c506 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/controllers/single_test_runner.py

@@ -357,9 +357,10 @@
             processed = actual.replace('LayoutNGBlockFlow', 'LayoutBlockFlow').replace('LayoutNGListItem', 'LayoutListItem')
             return not self._port.do_text_results_differ(expected, processed)
 
-        # LayoutNG name mismatch
+        # LayoutNG name mismatch (e.g., LayoutBlockFlow vs. LayoutNGBlockFlow)
+        # is treated as pass
         if is_ng_name_mismatch(expected_text, normalized_actual_text):
-            return [test_failures.FailureLayoutNGNameMismatch()]
+            return []
 
         # General text mismatch
         if self._port.do_text_results_differ(

diff --git a/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/models/test_failures.py b/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/models/test_failures.py
index 77aea8ae..210a118 100644
--- a/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/models/test_failures.py
+++ b/third_party/WebKit/Tools/Scripts/webkitpy/layout_tests/models/test_failures.py

@@ -216,15 +216,6 @@
         return 'spaces, tabs and newlines only'
 
 
-class FailureLayoutNGNameMismatch(FailureTextMismatch):
-
-    def message(self):
-        return 'text diff due to LayoutNG name mismatch'
-
-    def text_mismatch_category(self):
-        return 'LayoutNG name mismatch'
-
-
 class FailureMissingImageHash(TestFailure):
 
     def message(self):
@@ -313,7 +304,7 @@
                        FailureTestHarnessAssertion,
                        FailureTextMismatch, FailureSpacesAndTabsTextMismatch,
                        FailureLineBreaksTextMismatch, FailureSpaceTabLineBreakTextMismatch,
-                       FailureLayoutNGNameMismatch, FailureMissingImageHash,
+                       FailureMissingImageHash,
                        FailureMissingImage, FailureImageHashMismatch,
                        FailureImageHashIncorrect, FailureReftestMismatch,
                        FailureReftestMismatchDidNotOccur,

diff --git a/tools/cfi/blacklist.txt b/tools/cfi/blacklist.txt
index 8e86ab00..80704203 100644
--- a/tools/cfi/blacklist.txt
+++ b/tools/cfi/blacklist.txt

@@ -154,6 +154,9 @@
 src:*device/udev_linux/udev1_loader.cc
 src:*net/proxy/proxy_config_service_linux.cc
 
+# Calls to auto-generated stubs by ui/gl/generate_bindings.py
+src:*ui/gl/gl_bindings_autogen_*
+
 src:*components/os_crypt/*
 src:*chrome/browser/password_manager/native_backend_libsecret*
 

diff --git a/ui/gl/egl_api_unittest.cc b/ui/gl/egl_api_unittest.cc
index b535fdb..1d8babc 100644
--- a/ui/gl/egl_api_unittest.cc
+++ b/ui/gl/egl_api_unittest.cc

@@ -18,14 +18,13 @@
     fake_extension_string_ = "";
 
     // TODO(dyen): Add a way to bind mock drivers for testing.
-    auto writer = base::AutoWritableMemory::Create(g_driver_egl);
-    g_driver_egl->ClearBindings();
-    g_driver_egl->fn.eglInitializeFn = &FakeInitialize;
-    g_driver_egl->fn.eglQueryStringFn = &FakeQueryString;
-    g_driver_egl->fn.eglGetCurrentDisplayFn = &FakeGetCurrentDisplay;
-    g_driver_egl->fn.eglGetDisplayFn = &FakeGetDisplay;
-    g_driver_egl->fn.eglGetErrorFn = &FakeGetError;
-    g_driver_egl->fn.eglGetProcAddressFn = &FakeGetProcAddress;
+    g_driver_egl.ClearBindings();
+    g_driver_egl.fn.eglInitializeFn = &FakeInitialize;
+    g_driver_egl.fn.eglQueryStringFn = &FakeQueryString;
+    g_driver_egl.fn.eglGetCurrentDisplayFn = &FakeGetCurrentDisplay;
+    g_driver_egl.fn.eglGetDisplayFn = &FakeGetDisplay;
+    g_driver_egl.fn.eglGetErrorFn = &FakeGetError;
+    g_driver_egl.fn.eglGetProcAddressFn = &FakeGetProcAddress;
 
     SetGLImplementation(kGLImplementationEGLGLES2);
   }
@@ -33,8 +32,7 @@
   void TearDown() override {
     g_current_egl_context = nullptr;
     api_.reset(nullptr);
-    auto writer = base::AutoWritableMemory::Create(g_driver_egl);
-    g_driver_egl->ClearBindings();
+    g_driver_egl.ClearBindings();
 
     fake_client_extension_string_ = "";
     fake_extension_string_ = "";
@@ -43,14 +41,13 @@
   void InitializeAPI(const char* disabled_extensions) {
     api_.reset(new RealEGLApi());
     g_current_egl_context = api_.get();
-    api_->Initialize(&*g_driver_egl);
+    api_->Initialize(&g_driver_egl);
     if (disabled_extensions) {
       SetDisabledExtensionsEGL(disabled_extensions);
     }
-    auto writer = base::AutoWritableMemory::Create(g_driver_egl);
-    g_driver_egl->InitializeClientExtensionBindings();
+    g_driver_egl.InitializeClientExtensionBindings();
     GLSurfaceEGL::InitializeDisplay(EGL_DEFAULT_DISPLAY);
-    g_driver_egl->InitializeExtensionBindings();
+    g_driver_egl.InitializeExtensionBindings();
   }
 
   void SetFakeExtensionString(const char* fake_string,
@@ -116,11 +113,11 @@
   SetFakeExtensionString(kFakeExtensions, kFakeClientExtensions);
   InitializeAPI(nullptr);
 
-  EXPECT_TRUE(g_driver_egl->ext.b_EGL_KHR_fence_sync);
+  EXPECT_TRUE(g_driver_egl.ext.b_EGL_KHR_fence_sync);
 
   InitializeAPI(kFakeDisabledExtensions);
 
-  EXPECT_FALSE(g_driver_egl->ext.b_EGL_KHR_fence_sync);
+  EXPECT_FALSE(g_driver_egl.ext.b_EGL_KHR_fence_sync);
 }
 
 TEST_F(EGLApiTest, DisabledExtensionStringTest) {

diff --git a/ui/gl/generate_bindings.py b/ui/gl/generate_bindings.py
index a559a5d..f5c2c990 100755
--- a/ui/gl/generate_bindings.py
+++ b/ui/gl/generate_bindings.py

@@ -2661,9 +2661,7 @@
   """Generates gl_bindings_autogen_x.cc"""
 
   set_header_name = "ui/gl/gl_" + set_name.lower() + "_api_implementation.h"
-  include_list = [ 'base/compiler_specific.h',
-                   'base/memory/protected_memory.h',
-                   'base/trace_event/trace_event.h',
+  include_list = [ 'base/trace_event/trace_event.h',
                    'ui/gl/gl_enums.h',
                    'ui/gl/gl_bindings.h',
                    'ui/gl/gl_context.h',
@@ -2687,12 +2685,8 @@
 
   file.write('\n')
   if set_name != 'gl':
-    file.write('// Place the driver in protected memory so that it is set\n')
-    file.write('// read-only after it is initialized, preventing it from\n')
-    file.write('// being tampered with. See http://crbug.com/771365.\n')
-    file.write('PROTECTED_MEMORY_SECTION base::ProtectedMemory<Driver%s>\n' %
-        set_name.upper())
-    file.write('    g_driver_%s;\n' % set_name.lower())
+    file.write('Driver%s g_driver_%s;  // Exists in .bss\n' % (
+        set_name.upper(), set_name.lower()))
   file.write('\n')
 
   # Write stub functions that take the place of some functions before a context
@@ -2864,7 +2858,6 @@
     return_type = func['return_type']
     arguments = func['arguments']
     file.write('\n')
-    file.write('DISABLE_CFI_ICALL\n')
     file.write('%s %sApiBase::%sFn(%s) {\n' %
         (return_type, set_name.upper(), function_name, arguments))
     argument_names = MakeArgNames(arguments)
@@ -2882,7 +2875,6 @@
     return_type = func['return_type']
     arguments = func['arguments']
     file.write('\n')
-    file.write('DISABLE_CFI_ICALL\n')
     file.write('%s Trace%sApi::%sFn(%s) {\n' %
         (return_type, set_name.upper(), function_name, arguments))
     argument_names = MakeArgNames(arguments)
@@ -2901,7 +2893,6 @@
     return_type = func['return_type']
     arguments = func['arguments']
     file.write('\n')
-    file.write('DISABLE_CFI_ICALL\n')
     file.write('%s Debug%sApi::%sFn(%s) {\n' %
         (return_type, set_name.upper(), func['known_as'], arguments))
     argument_names = re.sub(

diff --git a/ui/gl/gl_bindings.h b/ui/gl/gl_bindings.h
index 52ecce7..2fc9661 100644
--- a/ui/gl/gl_bindings.h
+++ b/ui/gl/gl_bindings.h

@@ -37,7 +37,6 @@
 #include <string>
 
 #include "base/logging.h"
-#include "base/memory/protected_memory.h"
 #include "base/threading/thread_local.h"
 #include "build/build_config.h"
 #include "ui/gl/extension_set.h"
@@ -530,21 +529,21 @@
 GL_EXPORT extern base::ThreadLocalPointer<CurrentGL>* g_current_gl_context_tls;
 
 GL_EXPORT extern OSMESAApi* g_current_osmesa_context;
-GL_EXPORT extern base::ProtectedMemory<DriverOSMESA> g_driver_osmesa;
+GL_EXPORT extern DriverOSMESA g_driver_osmesa;
 
 #if defined(USE_EGL)
 GL_EXPORT extern EGLApi* g_current_egl_context;
-GL_EXPORT extern base::ProtectedMemory<DriverEGL> g_driver_egl;
+GL_EXPORT extern DriverEGL g_driver_egl;
 #endif
 
 #if defined(OS_WIN)
 GL_EXPORT extern WGLApi* g_current_wgl_context;
-GL_EXPORT extern base::ProtectedMemory<DriverWGL> g_driver_wgl;
+GL_EXPORT extern DriverWGL g_driver_wgl;
 #endif
 
 #if defined(USE_GLX)
 GL_EXPORT extern GLXApi* g_current_glx_context;
-GL_EXPORT extern base::ProtectedMemory<DriverGLX> g_driver_glx;
+GL_EXPORT extern DriverGLX g_driver_glx;
 #endif
 
 }  // namespace gl

diff --git a/ui/gl/gl_bindings_autogen_egl.cc b/ui/gl/gl_bindings_autogen_egl.cc
index 6007320a..4a1c1ed 100644
--- a/ui/gl/gl_bindings_autogen_egl.cc
+++ b/ui/gl/gl_bindings_autogen_egl.cc

@@ -10,8 +10,6 @@
 
 #include <string>
 
-#include "base/compiler_specific.h"
-#include "base/memory/protected_memory.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
@@ -22,10 +20,7 @@
 
 namespace gl {
 
-// Place the driver in protected memory so that it is set
-// read-only after it is initialized, preventing it from
-// being tampered with. See http://crbug.com/771365.
-PROTECTED_MEMORY_SECTION base::ProtectedMemory<DriverEGL> g_driver_egl;
+DriverEGL g_driver_egl;  // Exists in .bss
 
 void DriverEGL::InitializeStaticBindings() {
   // Ensure struct has been zero-initialized.
@@ -360,19 +355,16 @@
   memset(this, 0, sizeof(*this));
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglBindAPIFn(EGLenum api) {
   return driver_->fn.eglBindAPIFn(api);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglBindTexImageFn(EGLDisplay dpy,
                                          EGLSurface surface,
                                          EGLint buffer) {
   return driver_->fn.eglBindTexImageFn(dpy, surface, buffer);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglChooseConfigFn(EGLDisplay dpy,
                                          const EGLint* attrib_list,
                                          EGLConfig* configs,
@@ -382,7 +374,6 @@
                                        num_config);
 }
 
-DISABLE_CFI_ICALL
 EGLint EGLApiBase::eglClientWaitSyncKHRFn(EGLDisplay dpy,
                                           EGLSyncKHR sync,
                                           EGLint flags,
@@ -390,14 +381,12 @@
   return driver_->fn.eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglCopyBuffersFn(EGLDisplay dpy,
                                         EGLSurface surface,
                                         EGLNativePixmapType target) {
   return driver_->fn.eglCopyBuffersFn(dpy, surface, target);
 }
 
-DISABLE_CFI_ICALL
 EGLContext EGLApiBase::eglCreateContextFn(EGLDisplay dpy,
                                           EGLConfig config,
                                           EGLContext share_context,
@@ -406,7 +395,6 @@
                                         attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLImageKHR EGLApiBase::eglCreateImageKHRFn(EGLDisplay dpy,
                                             EGLContext ctx,
                                             EGLenum target,
@@ -415,7 +403,6 @@
   return driver_->fn.eglCreateImageKHRFn(dpy, ctx, target, buffer, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSurface EGLApiBase::eglCreatePbufferFromClientBufferFn(
     EGLDisplay dpy,
     EGLenum buftype,
@@ -426,14 +413,12 @@
                                                         config, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSurface EGLApiBase::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
                                                  EGLConfig config,
                                                  const EGLint* attrib_list) {
   return driver_->fn.eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSurface EGLApiBase::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
                                                 EGLConfig config,
                                                 EGLNativePixmapType pixmap,
@@ -441,13 +426,11 @@
   return driver_->fn.eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLStreamKHR EGLApiBase::eglCreateStreamKHRFn(EGLDisplay dpy,
                                               const EGLint* attrib_list) {
   return driver_->fn.eglCreateStreamKHRFn(dpy, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglCreateStreamProducerD3DTextureANGLEFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -456,14 +439,12 @@
                                                               attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSyncKHR EGLApiBase::eglCreateSyncKHRFn(EGLDisplay dpy,
                                           EGLenum type,
                                           const EGLint* attrib_list) {
   return driver_->fn.eglCreateSyncKHRFn(dpy, type, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSurface EGLApiBase::eglCreateWindowSurfaceFn(EGLDisplay dpy,
                                                 EGLConfig config,
                                                 EGLNativeWindowType win,
@@ -471,39 +452,32 @@
   return driver_->fn.eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
   return driver_->fn.eglDestroyContextFn(dpy, ctx);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglDestroyImageKHRFn(EGLDisplay dpy, EGLImageKHR image) {
   return driver_->fn.eglDestroyImageKHRFn(dpy, image);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglDestroyStreamKHRFn(EGLDisplay dpy,
                                              EGLStreamKHR stream) {
   return driver_->fn.eglDestroyStreamKHRFn(dpy, stream);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglDestroySurfaceFn(EGLDisplay dpy, EGLSurface surface) {
   return driver_->fn.eglDestroySurfaceFn(dpy, surface);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
   return driver_->fn.eglDestroySyncKHRFn(dpy, sync);
 }
 
-DISABLE_CFI_ICALL
 EGLint EGLApiBase::eglDupNativeFenceFDANDROIDFn(EGLDisplay dpy,
                                                 EGLSyncKHR sync) {
   return driver_->fn.eglDupNativeFenceFDANDROIDFn(dpy, sync);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglExportDMABUFImageMESAFn(EGLDisplay dpy,
                                                   EGLImageKHR image,
                                                   int* fds,
@@ -513,7 +487,6 @@
                                                 offsets);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglExportDMABUFImageQueryMESAFn(
     EGLDisplay dpy,
     EGLImageKHR image,
@@ -524,7 +497,6 @@
                                                      num_planes, modifiers);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetCompositorTimingANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -535,7 +507,6 @@
       dpy, surface, numTimestamps, names, values);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetCompositorTimingSupportedANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -544,7 +515,6 @@
                                                               timestamp);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetConfigAttribFn(EGLDisplay dpy,
                                             EGLConfig config,
                                             EGLint attribute,
@@ -552,7 +522,6 @@
   return driver_->fn.eglGetConfigAttribFn(dpy, config, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetConfigsFn(EGLDisplay dpy,
                                        EGLConfig* configs,
                                        EGLint config_size,
@@ -560,32 +529,26 @@
   return driver_->fn.eglGetConfigsFn(dpy, configs, config_size, num_config);
 }
 
-DISABLE_CFI_ICALL
 EGLContext EGLApiBase::eglGetCurrentContextFn(void) {
   return driver_->fn.eglGetCurrentContextFn();
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay EGLApiBase::eglGetCurrentDisplayFn(void) {
   return driver_->fn.eglGetCurrentDisplayFn();
 }
 
-DISABLE_CFI_ICALL
 EGLSurface EGLApiBase::eglGetCurrentSurfaceFn(EGLint readdraw) {
   return driver_->fn.eglGetCurrentSurfaceFn(readdraw);
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay EGLApiBase::eglGetDisplayFn(EGLNativeDisplayType display_id) {
   return driver_->fn.eglGetDisplayFn(display_id);
 }
 
-DISABLE_CFI_ICALL
 EGLint EGLApiBase::eglGetErrorFn(void) {
   return driver_->fn.eglGetErrorFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetFrameTimestampsANDROIDFn(EGLDisplay dpy,
                                                       EGLSurface surface,
                                                       EGLuint64KHR frameId,
@@ -596,7 +559,6 @@
       dpy, surface, frameId, numTimestamps, timestamps, values);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetFrameTimestampSupportedANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -605,20 +567,17 @@
                                                             timestamp);
 }
 
-DISABLE_CFI_ICALL
 EGLClientBuffer EGLApiBase::eglGetNativeClientBufferANDROIDFn(
     const struct AHardwareBuffer* ahardwarebuffer) {
   return driver_->fn.eglGetNativeClientBufferANDROIDFn(ahardwarebuffer);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetNextFrameIdANDROIDFn(EGLDisplay dpy,
                                                   EGLSurface surface,
                                                   EGLuint64KHR* frameId) {
   return driver_->fn.eglGetNextFrameIdANDROIDFn(dpy, surface, frameId);
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay EGLApiBase::eglGetPlatformDisplayEXTFn(EGLenum platform,
                                                   void* native_display,
                                                   const EGLint* attrib_list) {
@@ -626,13 +585,11 @@
                                                 attrib_list);
 }
 
-DISABLE_CFI_ICALL
 __eglMustCastToProperFunctionPointerType EGLApiBase::eglGetProcAddressFn(
     const char* procname) {
   return driver_->fn.eglGetProcAddressFn(procname);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetSyncAttribKHRFn(EGLDisplay dpy,
                                              EGLSyncKHR sync,
                                              EGLint attribute,
@@ -640,7 +597,6 @@
   return driver_->fn.eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
                                                   EGLSurface surface,
                                                   EGLuint64CHROMIUM* ust,
@@ -649,7 +605,6 @@
   return driver_->fn.eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglImageFlushExternalEXTFn(
     EGLDisplay dpy,
     EGLImageKHR image,
@@ -657,14 +612,12 @@
   return driver_->fn.eglImageFlushExternalEXTFn(dpy, image, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglInitializeFn(EGLDisplay dpy,
                                        EGLint* major,
                                        EGLint* minor) {
   return driver_->fn.eglInitializeFn(dpy, major, minor);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglMakeCurrentFn(EGLDisplay dpy,
                                         EGLSurface draw,
                                         EGLSurface read,
@@ -672,7 +625,6 @@
   return driver_->fn.eglMakeCurrentFn(dpy, draw, read, ctx);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglPostSubBufferNVFn(EGLDisplay dpy,
                                             EGLSurface surface,
                                             EGLint x,
@@ -682,13 +634,11 @@
   return driver_->fn.eglPostSubBufferNVFn(dpy, surface, x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 EGLint EGLApiBase::eglProgramCacheGetAttribANGLEFn(EGLDisplay dpy,
                                                    EGLenum attrib) {
   return driver_->fn.eglProgramCacheGetAttribANGLEFn(dpy, attrib);
 }
 
-DISABLE_CFI_ICALL
 void EGLApiBase::eglProgramCachePopulateANGLEFn(EGLDisplay dpy,
                                                 const void* key,
                                                 EGLint keysize,
@@ -698,7 +648,6 @@
                                              binarysize);
 }
 
-DISABLE_CFI_ICALL
 void EGLApiBase::eglProgramCacheQueryANGLEFn(EGLDisplay dpy,
                                              EGLint index,
                                              void* key,
@@ -709,19 +658,16 @@
                                           binarysize);
 }
 
-DISABLE_CFI_ICALL
 EGLint EGLApiBase::eglProgramCacheResizeANGLEFn(EGLDisplay dpy,
                                                 EGLint limit,
                                                 EGLenum mode) {
   return driver_->fn.eglProgramCacheResizeANGLEFn(dpy, limit, mode);
 }
 
-DISABLE_CFI_ICALL
 EGLenum EGLApiBase::eglQueryAPIFn(void) {
   return driver_->fn.eglQueryAPIFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglQueryContextFn(EGLDisplay dpy,
                                          EGLContext ctx,
                                          EGLint attribute,
@@ -729,7 +675,6 @@
   return driver_->fn.eglQueryContextFn(dpy, ctx, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglQueryStreamKHRFn(EGLDisplay dpy,
                                            EGLStreamKHR stream,
                                            EGLenum attribute,
@@ -737,7 +682,6 @@
   return driver_->fn.eglQueryStreamKHRFn(dpy, stream, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglQueryStreamu64KHRFn(EGLDisplay dpy,
                                               EGLStreamKHR stream,
                                               EGLenum attribute,
@@ -745,12 +689,10 @@
   return driver_->fn.eglQueryStreamu64KHRFn(dpy, stream, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 const char* EGLApiBase::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
   return driver_->fn.eglQueryStringFn(dpy, name);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglQuerySurfaceFn(EGLDisplay dpy,
                                          EGLSurface surface,
                                          EGLint attribute,
@@ -758,7 +700,6 @@
   return driver_->fn.eglQuerySurfaceFn(dpy, surface, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
                                                      EGLSurface surface,
                                                      EGLint attribute,
@@ -767,19 +708,16 @@
                                                    value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglReleaseTexImageFn(EGLDisplay dpy,
                                             EGLSurface surface,
                                             EGLint buffer) {
   return driver_->fn.eglReleaseTexImageFn(dpy, surface, buffer);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglReleaseThreadFn(void) {
   return driver_->fn.eglReleaseThreadFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglStreamAttribKHRFn(EGLDisplay dpy,
                                             EGLStreamKHR stream,
                                             EGLenum attribute,
@@ -787,13 +725,11 @@
   return driver_->fn.eglStreamAttribKHRFn(dpy, stream, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
                                                      EGLStreamKHR stream) {
   return driver_->fn.eglStreamConsumerAcquireKHRFn(dpy, stream);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglStreamConsumerGLTextureExternalAttribsNVFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -802,20 +738,17 @@
                                                                    attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglStreamConsumerGLTextureExternalKHRFn(
     EGLDisplay dpy,
     EGLStreamKHR stream) {
   return driver_->fn.eglStreamConsumerGLTextureExternalKHRFn(dpy, stream);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
                                                      EGLStreamKHR stream) {
   return driver_->fn.eglStreamConsumerReleaseKHRFn(dpy, stream);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglStreamPostD3DTextureANGLEFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -825,7 +758,6 @@
                                                     attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglSurfaceAttribFn(EGLDisplay dpy,
                                           EGLSurface surface,
                                           EGLint attribute,
@@ -833,12 +765,10 @@
   return driver_->fn.eglSurfaceAttribFn(dpy, surface, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
   return driver_->fn.eglSwapBuffersFn(dpy, surface);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
                                                      EGLSurface surface,
                                                      EGLint* rects,
@@ -847,45 +777,37 @@
                                                    n_rects);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
   return driver_->fn.eglSwapIntervalFn(dpy, interval);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglTerminateFn(EGLDisplay dpy) {
   return driver_->fn.eglTerminateFn(dpy);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglWaitClientFn(void) {
   return driver_->fn.eglWaitClientFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglWaitGLFn(void) {
   return driver_->fn.eglWaitGLFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean EGLApiBase::eglWaitNativeFn(EGLint engine) {
   return driver_->fn.eglWaitNativeFn(engine);
 }
 
-DISABLE_CFI_ICALL
 EGLint EGLApiBase::eglWaitSyncKHRFn(EGLDisplay dpy,
                                     EGLSyncKHR sync,
                                     EGLint flags) {
   return driver_->fn.eglWaitSyncKHRFn(dpy, sync, flags);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglBindAPIFn(EGLenum api) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglBindAPI")
   return egl_api_->eglBindAPIFn(api);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglBindTexImageFn(EGLDisplay dpy,
                                           EGLSurface surface,
                                           EGLint buffer) {
@@ -893,7 +815,6 @@
   return egl_api_->eglBindTexImageFn(dpy, surface, buffer);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglChooseConfigFn(EGLDisplay dpy,
                                           const EGLint* attrib_list,
                                           EGLConfig* configs,
@@ -904,7 +825,6 @@
                                      num_config);
 }
 
-DISABLE_CFI_ICALL
 EGLint TraceEGLApi::eglClientWaitSyncKHRFn(EGLDisplay dpy,
                                            EGLSyncKHR sync,
                                            EGLint flags,
@@ -913,7 +833,6 @@
   return egl_api_->eglClientWaitSyncKHRFn(dpy, sync, flags, timeout);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglCopyBuffersFn(EGLDisplay dpy,
                                          EGLSurface surface,
                                          EGLNativePixmapType target) {
@@ -921,7 +840,6 @@
   return egl_api_->eglCopyBuffersFn(dpy, surface, target);
 }
 
-DISABLE_CFI_ICALL
 EGLContext TraceEGLApi::eglCreateContextFn(EGLDisplay dpy,
                                            EGLConfig config,
                                            EGLContext share_context,
@@ -930,7 +848,6 @@
   return egl_api_->eglCreateContextFn(dpy, config, share_context, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLImageKHR TraceEGLApi::eglCreateImageKHRFn(EGLDisplay dpy,
                                              EGLContext ctx,
                                              EGLenum target,
@@ -940,7 +857,6 @@
   return egl_api_->eglCreateImageKHRFn(dpy, ctx, target, buffer, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSurface TraceEGLApi::eglCreatePbufferFromClientBufferFn(
     EGLDisplay dpy,
     EGLenum buftype,
@@ -953,7 +869,6 @@
                                                       config, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSurface TraceEGLApi::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
                                                   EGLConfig config,
                                                   const EGLint* attrib_list) {
@@ -961,7 +876,6 @@
   return egl_api_->eglCreatePbufferSurfaceFn(dpy, config, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSurface TraceEGLApi::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
                                                  EGLConfig config,
                                                  EGLNativePixmapType pixmap,
@@ -970,14 +884,12 @@
   return egl_api_->eglCreatePixmapSurfaceFn(dpy, config, pixmap, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLStreamKHR TraceEGLApi::eglCreateStreamKHRFn(EGLDisplay dpy,
                                                const EGLint* attrib_list) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglCreateStreamKHR")
   return egl_api_->eglCreateStreamKHRFn(dpy, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglCreateStreamProducerD3DTextureANGLEFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -988,7 +900,6 @@
                                                             attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSyncKHR TraceEGLApi::eglCreateSyncKHRFn(EGLDisplay dpy,
                                            EGLenum type,
                                            const EGLint* attrib_list) {
@@ -996,7 +907,6 @@
   return egl_api_->eglCreateSyncKHRFn(dpy, type, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLSurface TraceEGLApi::eglCreateWindowSurfaceFn(EGLDisplay dpy,
                                                  EGLConfig config,
                                                  EGLNativeWindowType win,
@@ -1005,47 +915,40 @@
   return egl_api_->eglCreateWindowSurfaceFn(dpy, config, win, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroyContext")
   return egl_api_->eglDestroyContextFn(dpy, ctx);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglDestroyImageKHRFn(EGLDisplay dpy,
                                              EGLImageKHR image) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroyImageKHR")
   return egl_api_->eglDestroyImageKHRFn(dpy, image);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglDestroyStreamKHRFn(EGLDisplay dpy,
                                               EGLStreamKHR stream) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroyStreamKHR")
   return egl_api_->eglDestroyStreamKHRFn(dpy, stream);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglDestroySurfaceFn(EGLDisplay dpy,
                                             EGLSurface surface) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroySurface")
   return egl_api_->eglDestroySurfaceFn(dpy, surface);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDestroySyncKHR")
   return egl_api_->eglDestroySyncKHRFn(dpy, sync);
 }
 
-DISABLE_CFI_ICALL
 EGLint TraceEGLApi::eglDupNativeFenceFDANDROIDFn(EGLDisplay dpy,
                                                  EGLSyncKHR sync) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglDupNativeFenceFDANDROID")
   return egl_api_->eglDupNativeFenceFDANDROIDFn(dpy, sync);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglExportDMABUFImageMESAFn(EGLDisplay dpy,
                                                    EGLImageKHR image,
                                                    int* fds,
@@ -1056,7 +959,6 @@
                                               offsets);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglExportDMABUFImageQueryMESAFn(
     EGLDisplay dpy,
     EGLImageKHR image,
@@ -1069,7 +971,6 @@
                                                    num_planes, modifiers);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetCompositorTimingANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -1082,7 +983,6 @@
                                                    names, values);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetCompositorTimingSupportedANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -1093,7 +993,6 @@
                                                             timestamp);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetConfigAttribFn(EGLDisplay dpy,
                                              EGLConfig config,
                                              EGLint attribute,
@@ -1102,7 +1001,6 @@
   return egl_api_->eglGetConfigAttribFn(dpy, config, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetConfigsFn(EGLDisplay dpy,
                                         EGLConfig* configs,
                                         EGLint config_size,
@@ -1111,37 +1009,31 @@
   return egl_api_->eglGetConfigsFn(dpy, configs, config_size, num_config);
 }
 
-DISABLE_CFI_ICALL
 EGLContext TraceEGLApi::eglGetCurrentContextFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetCurrentContext")
   return egl_api_->eglGetCurrentContextFn();
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay TraceEGLApi::eglGetCurrentDisplayFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetCurrentDisplay")
   return egl_api_->eglGetCurrentDisplayFn();
 }
 
-DISABLE_CFI_ICALL
 EGLSurface TraceEGLApi::eglGetCurrentSurfaceFn(EGLint readdraw) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetCurrentSurface")
   return egl_api_->eglGetCurrentSurfaceFn(readdraw);
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay TraceEGLApi::eglGetDisplayFn(EGLNativeDisplayType display_id) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetDisplay")
   return egl_api_->eglGetDisplayFn(display_id);
 }
 
-DISABLE_CFI_ICALL
 EGLint TraceEGLApi::eglGetErrorFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetError")
   return egl_api_->eglGetErrorFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetFrameTimestampsANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -1155,7 +1047,6 @@
       dpy, surface, frameId, numTimestamps, timestamps, values);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetFrameTimestampSupportedANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -1166,7 +1057,6 @@
                                                           timestamp);
 }
 
-DISABLE_CFI_ICALL
 EGLClientBuffer TraceEGLApi::eglGetNativeClientBufferANDROIDFn(
     const struct AHardwareBuffer* ahardwarebuffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
@@ -1174,7 +1064,6 @@
   return egl_api_->eglGetNativeClientBufferANDROIDFn(ahardwarebuffer);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetNextFrameIdANDROIDFn(EGLDisplay dpy,
                                                    EGLSurface surface,
                                                    EGLuint64KHR* frameId) {
@@ -1182,7 +1071,6 @@
   return egl_api_->eglGetNextFrameIdANDROIDFn(dpy, surface, frameId);
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay TraceEGLApi::eglGetPlatformDisplayEXTFn(EGLenum platform,
                                                    void* native_display,
                                                    const EGLint* attrib_list) {
@@ -1191,14 +1079,12 @@
                                               attrib_list);
 }
 
-DISABLE_CFI_ICALL
 __eglMustCastToProperFunctionPointerType TraceEGLApi::eglGetProcAddressFn(
     const char* procname) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglGetProcAddress")
   return egl_api_->eglGetProcAddressFn(procname);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetSyncAttribKHRFn(EGLDisplay dpy,
                                               EGLSyncKHR sync,
                                               EGLint attribute,
@@ -1207,7 +1093,6 @@
   return egl_api_->eglGetSyncAttribKHRFn(dpy, sync, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
                                                    EGLSurface surface,
                                                    EGLuint64CHROMIUM* ust,
@@ -1217,7 +1102,6 @@
   return egl_api_->eglGetSyncValuesCHROMIUMFn(dpy, surface, ust, msc, sbc);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglImageFlushExternalEXTFn(
     EGLDisplay dpy,
     EGLImageKHR image,
@@ -1226,7 +1110,6 @@
   return egl_api_->eglImageFlushExternalEXTFn(dpy, image, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglInitializeFn(EGLDisplay dpy,
                                         EGLint* major,
                                         EGLint* minor) {
@@ -1234,7 +1117,6 @@
   return egl_api_->eglInitializeFn(dpy, major, minor);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglMakeCurrentFn(EGLDisplay dpy,
                                          EGLSurface draw,
                                          EGLSurface read,
@@ -1243,7 +1125,6 @@
   return egl_api_->eglMakeCurrentFn(dpy, draw, read, ctx);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglPostSubBufferNVFn(EGLDisplay dpy,
                                              EGLSurface surface,
                                              EGLint x,
@@ -1254,7 +1135,6 @@
   return egl_api_->eglPostSubBufferNVFn(dpy, surface, x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 EGLint TraceEGLApi::eglProgramCacheGetAttribANGLEFn(EGLDisplay dpy,
                                                     EGLenum attrib) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
@@ -1262,7 +1142,6 @@
   return egl_api_->eglProgramCacheGetAttribANGLEFn(dpy, attrib);
 }
 
-DISABLE_CFI_ICALL
 void TraceEGLApi::eglProgramCachePopulateANGLEFn(EGLDisplay dpy,
                                                  const void* key,
                                                  EGLint keysize,
@@ -1274,7 +1153,6 @@
                                            binarysize);
 }
 
-DISABLE_CFI_ICALL
 void TraceEGLApi::eglProgramCacheQueryANGLEFn(EGLDisplay dpy,
                                               EGLint index,
                                               void* key,
@@ -1286,7 +1164,6 @@
                                         binarysize);
 }
 
-DISABLE_CFI_ICALL
 EGLint TraceEGLApi::eglProgramCacheResizeANGLEFn(EGLDisplay dpy,
                                                  EGLint limit,
                                                  EGLenum mode) {
@@ -1294,13 +1171,11 @@
   return egl_api_->eglProgramCacheResizeANGLEFn(dpy, limit, mode);
 }
 
-DISABLE_CFI_ICALL
 EGLenum TraceEGLApi::eglQueryAPIFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryAPI")
   return egl_api_->eglQueryAPIFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglQueryContextFn(EGLDisplay dpy,
                                           EGLContext ctx,
                                           EGLint attribute,
@@ -1309,7 +1184,6 @@
   return egl_api_->eglQueryContextFn(dpy, ctx, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglQueryStreamKHRFn(EGLDisplay dpy,
                                             EGLStreamKHR stream,
                                             EGLenum attribute,
@@ -1318,7 +1192,6 @@
   return egl_api_->eglQueryStreamKHRFn(dpy, stream, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglQueryStreamu64KHRFn(EGLDisplay dpy,
                                                EGLStreamKHR stream,
                                                EGLenum attribute,
@@ -1327,13 +1200,11 @@
   return egl_api_->eglQueryStreamu64KHRFn(dpy, stream, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 const char* TraceEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglQueryString")
   return egl_api_->eglQueryStringFn(dpy, name);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglQuerySurfaceFn(EGLDisplay dpy,
                                           EGLSurface surface,
                                           EGLint attribute,
@@ -1342,7 +1213,6 @@
   return egl_api_->eglQuerySurfaceFn(dpy, surface, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
                                                       EGLSurface surface,
                                                       EGLint attribute,
@@ -1353,7 +1223,6 @@
                                                  value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglReleaseTexImageFn(EGLDisplay dpy,
                                              EGLSurface surface,
                                              EGLint buffer) {
@@ -1361,13 +1230,11 @@
   return egl_api_->eglReleaseTexImageFn(dpy, surface, buffer);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglReleaseThreadFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglReleaseThread")
   return egl_api_->eglReleaseThreadFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglStreamAttribKHRFn(EGLDisplay dpy,
                                              EGLStreamKHR stream,
                                              EGLenum attribute,
@@ -1376,7 +1243,6 @@
   return egl_api_->eglStreamAttribKHRFn(dpy, stream, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
                                                       EGLStreamKHR stream) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
@@ -1384,7 +1250,6 @@
   return egl_api_->eglStreamConsumerAcquireKHRFn(dpy, stream);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglStreamConsumerGLTextureExternalAttribsNVFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -1395,7 +1260,6 @@
                                                                  attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglStreamConsumerGLTextureExternalKHRFn(
     EGLDisplay dpy,
     EGLStreamKHR stream) {
@@ -1404,7 +1268,6 @@
   return egl_api_->eglStreamConsumerGLTextureExternalKHRFn(dpy, stream);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
                                                       EGLStreamKHR stream) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
@@ -1412,7 +1275,6 @@
   return egl_api_->eglStreamConsumerReleaseKHRFn(dpy, stream);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglStreamPostD3DTextureANGLEFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -1424,7 +1286,6 @@
                                                   attrib_list);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglSurfaceAttribFn(EGLDisplay dpy,
                                            EGLSurface surface,
                                            EGLint attribute,
@@ -1433,13 +1294,11 @@
   return egl_api_->eglSurfaceAttribFn(dpy, surface, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglSwapBuffers")
   return egl_api_->eglSwapBuffersFn(dpy, surface);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
                                                       EGLSurface surface,
                                                       EGLint* rects,
@@ -1449,37 +1308,31 @@
   return egl_api_->eglSwapBuffersWithDamageKHRFn(dpy, surface, rects, n_rects);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglSwapInterval")
   return egl_api_->eglSwapIntervalFn(dpy, interval);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglTerminateFn(EGLDisplay dpy) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglTerminate")
   return egl_api_->eglTerminateFn(dpy);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglWaitClientFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitClient")
   return egl_api_->eglWaitClientFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglWaitGLFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitGL")
   return egl_api_->eglWaitGLFn();
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean TraceEGLApi::eglWaitNativeFn(EGLint engine) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::eglWaitNative")
   return egl_api_->eglWaitNativeFn(engine);
 }
 
-DISABLE_CFI_ICALL
 EGLint TraceEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
                                      EGLSyncKHR sync,
                                      EGLint flags) {
@@ -1487,7 +1340,6 @@
   return egl_api_->eglWaitSyncKHRFn(dpy, sync, flags);
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglBindAPIFn(EGLenum api) {
   GL_SERVICE_LOG("eglBindAPI"
                  << "(" << api << ")");
@@ -1496,7 +1348,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglBindTexImageFn(EGLDisplay dpy,
                                           EGLSurface surface,
                                           EGLint buffer) {
@@ -1507,7 +1358,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglChooseConfigFn(EGLDisplay dpy,
                                           const EGLint* attrib_list,
                                           EGLConfig* configs,
@@ -1524,7 +1374,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLint DebugEGLApi::eglClientWaitSyncKHRFn(EGLDisplay dpy,
                                            EGLSyncKHR sync,
                                            EGLint flags,
@@ -1537,7 +1386,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglCopyBuffersFn(EGLDisplay dpy,
                                          EGLSurface surface,
                                          EGLNativePixmapType target) {
@@ -1548,7 +1396,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLContext DebugEGLApi::eglCreateContextFn(EGLDisplay dpy,
                                            EGLConfig config,
                                            EGLContext share_context,
@@ -1562,7 +1409,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLImageKHR DebugEGLApi::eglCreateImageKHRFn(EGLDisplay dpy,
                                              EGLContext ctx,
                                              EGLenum target,
@@ -1578,7 +1424,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLSurface DebugEGLApi::eglCreatePbufferFromClientBufferFn(
     EGLDisplay dpy,
     EGLenum buftype,
@@ -1595,7 +1440,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLSurface DebugEGLApi::eglCreatePbufferSurfaceFn(EGLDisplay dpy,
                                                   EGLConfig config,
                                                   const EGLint* attrib_list) {
@@ -1608,7 +1452,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLSurface DebugEGLApi::eglCreatePixmapSurfaceFn(EGLDisplay dpy,
                                                  EGLConfig config,
                                                  EGLNativePixmapType pixmap,
@@ -1622,7 +1465,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLStreamKHR DebugEGLApi::eglCreateStreamKHRFn(EGLDisplay dpy,
                                                const EGLint* attrib_list) {
   GL_SERVICE_LOG("eglCreateStreamKHR"
@@ -1633,7 +1475,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglCreateStreamProducerD3DTextureANGLEFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -1647,7 +1488,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLSyncKHR DebugEGLApi::eglCreateSyncKHRFn(EGLDisplay dpy,
                                            EGLenum type,
                                            const EGLint* attrib_list) {
@@ -1659,7 +1499,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLSurface DebugEGLApi::eglCreateWindowSurfaceFn(EGLDisplay dpy,
                                                  EGLConfig config,
                                                  EGLNativeWindowType win,
@@ -1673,7 +1512,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglDestroyContextFn(EGLDisplay dpy, EGLContext ctx) {
   GL_SERVICE_LOG("eglDestroyContext"
                  << "(" << dpy << ", " << ctx << ")");
@@ -1682,7 +1520,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglDestroyImageKHRFn(EGLDisplay dpy,
                                              EGLImageKHR image) {
   GL_SERVICE_LOG("eglDestroyImageKHR"
@@ -1692,7 +1529,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglDestroyStreamKHRFn(EGLDisplay dpy,
                                               EGLStreamKHR stream) {
   GL_SERVICE_LOG("eglDestroyStreamKHR"
@@ -1702,7 +1538,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglDestroySurfaceFn(EGLDisplay dpy,
                                             EGLSurface surface) {
   GL_SERVICE_LOG("eglDestroySurface"
@@ -1712,7 +1547,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglDestroySyncKHRFn(EGLDisplay dpy, EGLSyncKHR sync) {
   GL_SERVICE_LOG("eglDestroySyncKHR"
                  << "(" << dpy << ", " << sync << ")");
@@ -1721,7 +1555,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLint DebugEGLApi::eglDupNativeFenceFDANDROIDFn(EGLDisplay dpy,
                                                  EGLSyncKHR sync) {
   GL_SERVICE_LOG("eglDupNativeFenceFDANDROID"
@@ -1731,7 +1564,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglExportDMABUFImageMESAFn(EGLDisplay dpy,
                                                    EGLImageKHR image,
                                                    int* fds,
@@ -1748,7 +1580,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglExportDMABUFImageQueryMESAFn(
     EGLDisplay dpy,
     EGLImageKHR image,
@@ -1766,7 +1597,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetCompositorTimingANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -1783,7 +1613,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetCompositorTimingSupportedANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -1796,7 +1625,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetConfigAttribFn(EGLDisplay dpy,
                                              EGLConfig config,
                                              EGLint attribute,
@@ -1810,7 +1638,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetConfigsFn(EGLDisplay dpy,
                                         EGLConfig* configs,
                                         EGLint config_size,
@@ -1825,7 +1652,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLContext DebugEGLApi::eglGetCurrentContextFn(void) {
   GL_SERVICE_LOG("eglGetCurrentContext"
                  << "("
@@ -1835,7 +1661,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay DebugEGLApi::eglGetCurrentDisplayFn(void) {
   GL_SERVICE_LOG("eglGetCurrentDisplay"
                  << "("
@@ -1845,7 +1670,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLSurface DebugEGLApi::eglGetCurrentSurfaceFn(EGLint readdraw) {
   GL_SERVICE_LOG("eglGetCurrentSurface"
                  << "(" << readdraw << ")");
@@ -1854,7 +1678,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay DebugEGLApi::eglGetDisplayFn(EGLNativeDisplayType display_id) {
   GL_SERVICE_LOG("eglGetDisplay"
                  << "(" << display_id << ")");
@@ -1863,7 +1686,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLint DebugEGLApi::eglGetErrorFn(void) {
   GL_SERVICE_LOG("eglGetError"
                  << "("
@@ -1873,7 +1695,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetFrameTimestampsANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -1892,7 +1713,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetFrameTimestampSupportedANDROIDFn(
     EGLDisplay dpy,
     EGLSurface surface,
@@ -1905,7 +1725,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLClientBuffer DebugEGLApi::eglGetNativeClientBufferANDROIDFn(
     const struct AHardwareBuffer* ahardwarebuffer) {
   GL_SERVICE_LOG("eglGetNativeClientBufferANDROID"
@@ -1916,7 +1735,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetNextFrameIdANDROIDFn(EGLDisplay dpy,
                                                    EGLSurface surface,
                                                    EGLuint64KHR* frameId) {
@@ -1929,7 +1747,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLDisplay DebugEGLApi::eglGetPlatformDisplayEXTFn(EGLenum platform,
                                                    void* native_display,
                                                    const EGLint* attrib_list) {
@@ -1943,7 +1760,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 __eglMustCastToProperFunctionPointerType DebugEGLApi::eglGetProcAddressFn(
     const char* procname) {
   GL_SERVICE_LOG("eglGetProcAddress"
@@ -1954,7 +1770,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetSyncAttribKHRFn(EGLDisplay dpy,
                                               EGLSyncKHR sync,
                                               EGLint attribute,
@@ -1968,7 +1783,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglGetSyncValuesCHROMIUMFn(EGLDisplay dpy,
                                                    EGLSurface surface,
                                                    EGLuint64CHROMIUM* ust,
@@ -1985,7 +1799,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglImageFlushExternalEXTFn(
     EGLDisplay dpy,
     EGLImageKHR image,
@@ -1999,7 +1812,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglInitializeFn(EGLDisplay dpy,
                                         EGLint* major,
                                         EGLint* minor) {
@@ -2011,7 +1823,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglMakeCurrentFn(EGLDisplay dpy,
                                          EGLSurface draw,
                                          EGLSurface read,
@@ -2024,7 +1835,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglPostSubBufferNVFn(EGLDisplay dpy,
                                              EGLSurface surface,
                                              EGLint x,
@@ -2040,7 +1850,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLint DebugEGLApi::eglProgramCacheGetAttribANGLEFn(EGLDisplay dpy,
                                                     EGLenum attrib) {
   GL_SERVICE_LOG("eglProgramCacheGetAttribANGLE"
@@ -2050,7 +1859,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugEGLApi::eglProgramCachePopulateANGLEFn(EGLDisplay dpy,
                                                  const void* key,
                                                  EGLint keysize,
@@ -2064,7 +1872,6 @@
                                            binarysize);
 }
 
-DISABLE_CFI_ICALL
 void DebugEGLApi::eglProgramCacheQueryANGLEFn(EGLDisplay dpy,
                                               EGLint index,
                                               void* key,
@@ -2081,7 +1888,6 @@
                                         binarysize);
 }
 
-DISABLE_CFI_ICALL
 EGLint DebugEGLApi::eglProgramCacheResizeANGLEFn(EGLDisplay dpy,
                                                  EGLint limit,
                                                  EGLenum mode) {
@@ -2092,7 +1898,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLenum DebugEGLApi::eglQueryAPIFn(void) {
   GL_SERVICE_LOG("eglQueryAPI"
                  << "("
@@ -2102,7 +1907,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglQueryContextFn(EGLDisplay dpy,
                                           EGLContext ctx,
                                           EGLint attribute,
@@ -2115,7 +1919,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglQueryStreamKHRFn(EGLDisplay dpy,
                                             EGLStreamKHR stream,
                                             EGLenum attribute,
@@ -2129,7 +1932,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglQueryStreamu64KHRFn(EGLDisplay dpy,
                                                EGLStreamKHR stream,
                                                EGLenum attribute,
@@ -2143,7 +1945,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 const char* DebugEGLApi::eglQueryStringFn(EGLDisplay dpy, EGLint name) {
   GL_SERVICE_LOG("eglQueryString"
                  << "(" << dpy << ", " << name << ")");
@@ -2152,7 +1953,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglQuerySurfaceFn(EGLDisplay dpy,
                                           EGLSurface surface,
                                           EGLint attribute,
@@ -2166,7 +1966,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglQuerySurfacePointerANGLEFn(EGLDisplay dpy,
                                                       EGLSurface surface,
                                                       EGLint attribute,
@@ -2180,7 +1979,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglReleaseTexImageFn(EGLDisplay dpy,
                                              EGLSurface surface,
                                              EGLint buffer) {
@@ -2191,7 +1989,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglReleaseThreadFn(void) {
   GL_SERVICE_LOG("eglReleaseThread"
                  << "("
@@ -2201,7 +1998,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglStreamAttribKHRFn(EGLDisplay dpy,
                                              EGLStreamKHR stream,
                                              EGLenum attribute,
@@ -2215,7 +2011,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglStreamConsumerAcquireKHRFn(EGLDisplay dpy,
                                                       EGLStreamKHR stream) {
   GL_SERVICE_LOG("eglStreamConsumerAcquireKHR"
@@ -2225,7 +2020,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglStreamConsumerGLTextureExternalAttribsNVFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -2239,7 +2033,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglStreamConsumerGLTextureExternalKHRFn(
     EGLDisplay dpy,
     EGLStreamKHR stream) {
@@ -2251,7 +2044,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglStreamConsumerReleaseKHRFn(EGLDisplay dpy,
                                                       EGLStreamKHR stream) {
   GL_SERVICE_LOG("eglStreamConsumerReleaseKHR"
@@ -2261,7 +2053,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglStreamPostD3DTextureANGLEFn(
     EGLDisplay dpy,
     EGLStreamKHR stream,
@@ -2277,7 +2068,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglSurfaceAttribFn(EGLDisplay dpy,
                                            EGLSurface surface,
                                            EGLint attribute,
@@ -2291,7 +2081,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglSwapBuffersFn(EGLDisplay dpy, EGLSurface surface) {
   GL_SERVICE_LOG("eglSwapBuffers"
                  << "(" << dpy << ", " << surface << ")");
@@ -2300,7 +2089,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglSwapBuffersWithDamageKHRFn(EGLDisplay dpy,
                                                       EGLSurface surface,
                                                       EGLint* rects,
@@ -2314,7 +2102,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglSwapIntervalFn(EGLDisplay dpy, EGLint interval) {
   GL_SERVICE_LOG("eglSwapInterval"
                  << "(" << dpy << ", " << interval << ")");
@@ -2323,7 +2110,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglTerminateFn(EGLDisplay dpy) {
   GL_SERVICE_LOG("eglTerminate"
                  << "(" << dpy << ")");
@@ -2332,7 +2118,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglWaitClientFn(void) {
   GL_SERVICE_LOG("eglWaitClient"
                  << "("
@@ -2342,7 +2127,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglWaitGLFn(void) {
   GL_SERVICE_LOG("eglWaitGL"
                  << "("
@@ -2352,7 +2136,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLBoolean DebugEGLApi::eglWaitNativeFn(EGLint engine) {
   GL_SERVICE_LOG("eglWaitNative"
                  << "(" << engine << ")");
@@ -2361,7 +2144,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 EGLint DebugEGLApi::eglWaitSyncKHRFn(EGLDisplay dpy,
                                      EGLSyncKHR sync,
                                      EGLint flags) {

diff --git a/ui/gl/gl_bindings_autogen_gl.cc b/ui/gl/gl_bindings_autogen_gl.cc
index 40bc9c65..5897a33 100644
--- a/ui/gl/gl_bindings_autogen_gl.cc
+++ b/ui/gl/gl_bindings_autogen_gl.cc

@@ -10,8 +10,6 @@
 
 #include <string>
 
-#include "base/compiler_specific.h"
-#include "base/memory/protected_memory.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
@@ -2253,49 +2251,40 @@
   memset(this, 0, sizeof(*this));
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glActiveTextureFn(GLenum texture) {
   driver_->fn.glActiveTextureFn(texture);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glApplyFramebufferAttachmentCMAAINTELFn(void) {
   driver_->fn.glApplyFramebufferAttachmentCMAAINTELFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glAttachShaderFn(GLuint program, GLuint shader) {
   driver_->fn.glAttachShaderFn(program, shader);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBeginQueryFn(GLenum target, GLuint id) {
   driver_->fn.glBeginQueryFn(target, id);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBeginTransformFeedbackFn(GLenum primitiveMode) {
   driver_->fn.glBeginTransformFeedbackFn(primitiveMode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindAttribLocationFn(GLuint program,
                                        GLuint index,
                                        const char* name) {
   driver_->fn.glBindAttribLocationFn(program, index, name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindBufferFn(GLenum target, GLuint buffer) {
   driver_->fn.glBindBufferFn(target, buffer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindBufferBaseFn(GLenum target, GLuint index, GLuint buffer) {
   driver_->fn.glBindBufferBaseFn(target, index, buffer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindBufferRangeFn(GLenum target,
                                     GLuint index,
                                     GLuint buffer,
@@ -2304,14 +2293,12 @@
   driver_->fn.glBindBufferRangeFn(target, index, buffer, offset, size);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindFragDataLocationFn(GLuint program,
                                          GLuint colorNumber,
                                          const char* name) {
   driver_->fn.glBindFragDataLocationFn(program, colorNumber, name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindFragDataLocationIndexedFn(GLuint program,
                                                 GLuint colorNumber,
                                                 GLuint index,
@@ -2320,12 +2307,10 @@
                                               name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindFramebufferEXTFn(GLenum target, GLuint framebuffer) {
   driver_->fn.glBindFramebufferEXTFn(target, framebuffer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindImageTextureEXTFn(GLuint index,
                                         GLuint texture,
                                         GLint level,
@@ -2337,44 +2322,36 @@
                                       access, format);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindRenderbufferEXTFn(GLenum target, GLuint renderbuffer) {
   driver_->fn.glBindRenderbufferEXTFn(target, renderbuffer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindSamplerFn(GLuint unit, GLuint sampler) {
   driver_->fn.glBindSamplerFn(unit, sampler);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindTextureFn(GLenum target, GLuint texture) {
   driver_->fn.glBindTextureFn(target, texture);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindTransformFeedbackFn(GLenum target, GLuint id) {
   driver_->fn.glBindTransformFeedbackFn(target, id);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindUniformLocationCHROMIUMFn(GLuint program,
                                                 GLint location,
                                                 const char* name) {
   driver_->fn.glBindUniformLocationCHROMIUMFn(program, location, name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBindVertexArrayOESFn(GLuint array) {
   driver_->fn.glBindVertexArrayOESFn(array);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBlendBarrierKHRFn(void) {
   driver_->fn.glBlendBarrierKHRFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBlendColorFn(GLclampf red,
                                GLclampf green,
                                GLclampf blue,
@@ -2382,22 +2359,18 @@
   driver_->fn.glBlendColorFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBlendEquationFn(GLenum mode) {
   driver_->fn.glBlendEquationFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) {
   driver_->fn.glBlendEquationSeparateFn(modeRGB, modeAlpha);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBlendFuncFn(GLenum sfactor, GLenum dfactor) {
   driver_->fn.glBlendFuncFn(sfactor, dfactor);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBlendFuncSeparateFn(GLenum srcRGB,
                                       GLenum dstRGB,
                                       GLenum srcAlpha,
@@ -2405,7 +2378,6 @@
   driver_->fn.glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBlitFramebufferFn(GLint srcX0,
                                     GLint srcY0,
                                     GLint srcX1,
@@ -2420,7 +2392,6 @@
                                   dstX1, dstY1, mask, filter);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBufferDataFn(GLenum target,
                                GLsizeiptr size,
                                const void* data,
@@ -2428,7 +2399,6 @@
   driver_->fn.glBufferDataFn(target, size, data, usage);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glBufferSubDataFn(GLenum target,
                                   GLintptr offset,
                                   GLsizeiptr size,
@@ -2436,17 +2406,14 @@
   driver_->fn.glBufferSubDataFn(target, offset, size, data);
 }
 
-DISABLE_CFI_ICALL
 GLenum GLApiBase::glCheckFramebufferStatusEXTFn(GLenum target) {
   return driver_->fn.glCheckFramebufferStatusEXTFn(target);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearFn(GLbitfield mask) {
   driver_->fn.glClearFn(mask);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearBufferfiFn(GLenum buffer,
                                   GLint drawbuffer,
                                   const GLfloat depth,
@@ -2454,28 +2421,24 @@
   driver_->fn.glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearBufferfvFn(GLenum buffer,
                                   GLint drawbuffer,
                                   const GLfloat* value) {
   driver_->fn.glClearBufferfvFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearBufferivFn(GLenum buffer,
                                   GLint drawbuffer,
                                   const GLint* value) {
   driver_->fn.glClearBufferivFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearBufferuivFn(GLenum buffer,
                                    GLint drawbuffer,
                                    const GLuint* value) {
   driver_->fn.glClearBufferuivFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearColorFn(GLclampf red,
                                GLclampf green,
                                GLclampf blue,
@@ -2483,29 +2446,24 @@
   driver_->fn.glClearColorFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearDepthFn(GLclampd depth) {
   driver_->fn.glClearDepthFn(depth);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearDepthfFn(GLclampf depth) {
   driver_->fn.glClearDepthfFn(depth);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glClearStencilFn(GLint s) {
   driver_->fn.glClearStencilFn(s);
 }
 
-DISABLE_CFI_ICALL
 GLenum GLApiBase::glClientWaitSyncFn(GLsync sync,
                                      GLbitfield flags,
                                      GLuint64 timeout) {
   return driver_->fn.glClientWaitSyncFn(sync, flags, timeout);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glColorMaskFn(GLboolean red,
                               GLboolean green,
                               GLboolean blue,
@@ -2513,18 +2471,15 @@
   driver_->fn.glColorMaskFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompileShaderFn(GLuint shader) {
   driver_->fn.glCompileShaderFn(shader);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedCopyTextureCHROMIUMFn(GLuint sourceId,
                                                   GLuint destId) {
   driver_->fn.glCompressedCopyTextureCHROMIUMFn(sourceId, destId);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedTexImage2DFn(GLenum target,
                                          GLint level,
                                          GLenum internalformat,
@@ -2537,7 +2492,6 @@
                                        height, border, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedTexImage2DRobustANGLEFn(GLenum target,
                                                     GLint level,
                                                     GLenum internalformat,
@@ -2552,7 +2506,6 @@
                                                   imageSize, dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedTexImage3DFn(GLenum target,
                                          GLint level,
                                          GLenum internalformat,
@@ -2566,7 +2519,6 @@
                                        height, depth, border, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedTexImage3DRobustANGLEFn(GLenum target,
                                                     GLint level,
                                                     GLenum internalformat,
@@ -2582,7 +2534,6 @@
                                                   imageSize, dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedTexSubImage2DFn(GLenum target,
                                             GLint level,
                                             GLint xoffset,
@@ -2596,7 +2547,6 @@
       target, level, xoffset, yoffset, width, height, format, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedTexSubImage2DRobustANGLEFn(GLenum target,
                                                        GLint level,
                                                        GLint xoffset,
@@ -2612,7 +2562,6 @@
       dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedTexSubImage3DFn(GLenum target,
                                             GLint level,
                                             GLint xoffset,
@@ -2629,7 +2578,6 @@
                                           imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCompressedTexSubImage3DRobustANGLEFn(GLenum target,
                                                        GLint level,
                                                        GLint xoffset,
@@ -2647,7 +2595,6 @@
       imageSize, dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCopyBufferSubDataFn(GLenum readTarget,
                                       GLenum writeTarget,
                                       GLintptr readOffset,
@@ -2657,7 +2604,6 @@
                                     writeOffset, size);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCopySubTextureCHROMIUMFn(GLuint sourceId,
                                            GLint sourceLevel,
                                            GLenum destTarget,
@@ -2678,7 +2624,6 @@
       unpackUnmultiplyAlpha);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCopyTexImage2DFn(GLenum target,
                                    GLint level,
                                    GLenum internalformat,
@@ -2691,7 +2636,6 @@
                                  height, border);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCopyTexSubImage2DFn(GLenum target,
                                       GLint level,
                                       GLint xoffset,
@@ -2704,7 +2648,6 @@
                                     width, height);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCopyTexSubImage3DFn(GLenum target,
                                       GLint level,
                                       GLint xoffset,
@@ -2718,7 +2661,6 @@
                                     y, width, height);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCopyTextureCHROMIUMFn(GLuint sourceId,
                                         GLint sourceLevel,
                                         GLenum destTarget,
@@ -2734,12 +2676,10 @@
       destType, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCoverageModulationNVFn(GLenum components) {
   driver_->fn.glCoverageModulationNVFn(components);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCoverFillPathInstancedNVFn(GLsizei numPaths,
                                              GLenum pathNameType,
                                              const void* paths,
@@ -2752,12 +2692,10 @@
                                            transformValues);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
   driver_->fn.glCoverFillPathNVFn(path, coverMode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCoverStrokePathInstancedNVFn(GLsizei numPaths,
                                                GLenum pathNameType,
                                                const void* paths,
@@ -2770,33 +2708,27 @@
                                              transformValues);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
   driver_->fn.glCoverStrokePathNVFn(name, coverMode);
 }
 
-DISABLE_CFI_ICALL
 GLuint GLApiBase::glCreateProgramFn(void) {
   return driver_->fn.glCreateProgramFn();
 }
 
-DISABLE_CFI_ICALL
 GLuint GLApiBase::glCreateShaderFn(GLenum type) {
   return driver_->fn.glCreateShaderFn(type);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glCullFaceFn(GLenum mode) {
   driver_->fn.glCullFaceFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDebugMessageCallbackFn(GLDEBUGPROC callback,
                                          const void* userParam) {
   driver_->fn.glDebugMessageCallbackFn(callback, userParam);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDebugMessageControlFn(GLenum source,
                                         GLenum type,
                                         GLenum severity,
@@ -2807,7 +2739,6 @@
                                       enabled);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDebugMessageInsertFn(GLenum source,
                                        GLenum type,
                                        GLuint id,
@@ -2817,126 +2748,102 @@
   driver_->fn.glDebugMessageInsertFn(source, type, id, severity, length, buf);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
   driver_->fn.glDeleteBuffersARBFn(n, buffers);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) {
   driver_->fn.glDeleteFencesAPPLEFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
   driver_->fn.glDeleteFencesNVFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteFramebuffersEXTFn(GLsizei n,
                                           const GLuint* framebuffers) {
   driver_->fn.glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeletePathsNVFn(GLuint path, GLsizei range) {
   driver_->fn.glDeletePathsNVFn(path, range);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteProgramFn(GLuint program) {
   driver_->fn.glDeleteProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
   driver_->fn.glDeleteQueriesFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteRenderbuffersEXTFn(GLsizei n,
                                            const GLuint* renderbuffers) {
   driver_->fn.glDeleteRenderbuffersEXTFn(n, renderbuffers);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteSamplersFn(GLsizei n, const GLuint* samplers) {
   driver_->fn.glDeleteSamplersFn(n, samplers);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteShaderFn(GLuint shader) {
   driver_->fn.glDeleteShaderFn(shader);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteSyncFn(GLsync sync) {
   driver_->fn.glDeleteSyncFn(sync);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteTexturesFn(GLsizei n, const GLuint* textures) {
   driver_->fn.glDeleteTexturesFn(n, textures);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteTransformFeedbacksFn(GLsizei n, const GLuint* ids) {
   driver_->fn.glDeleteTransformFeedbacksFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDeleteVertexArraysOESFn(GLsizei n, const GLuint* arrays) {
   driver_->fn.glDeleteVertexArraysOESFn(n, arrays);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDepthFuncFn(GLenum func) {
   driver_->fn.glDepthFuncFn(func);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDepthMaskFn(GLboolean flag) {
   driver_->fn.glDepthMaskFn(flag);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDepthRangeFn(GLclampd zNear, GLclampd zFar) {
   driver_->fn.glDepthRangeFn(zNear, zFar);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDepthRangefFn(GLclampf zNear, GLclampf zFar) {
   driver_->fn.glDepthRangefFn(zNear, zFar);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDetachShaderFn(GLuint program, GLuint shader) {
   driver_->fn.glDetachShaderFn(program, shader);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDisableFn(GLenum cap) {
   driver_->fn.glDisableFn(cap);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDisableVertexAttribArrayFn(GLuint index) {
   driver_->fn.glDisableVertexAttribArrayFn(index);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDiscardFramebufferEXTFn(GLenum target,
                                           GLsizei numAttachments,
                                           const GLenum* attachments) {
   driver_->fn.glDiscardFramebufferEXTFn(target, numAttachments, attachments);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
   driver_->fn.glDrawArraysFn(mode, first, count);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDrawArraysInstancedANGLEFn(GLenum mode,
                                              GLint first,
                                              GLsizei count,
@@ -2944,17 +2851,14 @@
   driver_->fn.glDrawArraysInstancedANGLEFn(mode, first, count, primcount);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDrawBufferFn(GLenum mode) {
   driver_->fn.glDrawBufferFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDrawBuffersARBFn(GLsizei n, const GLenum* bufs) {
   driver_->fn.glDrawBuffersARBFn(n, bufs);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDrawElementsFn(GLenum mode,
                                  GLsizei count,
                                  GLenum type,
@@ -2962,7 +2866,6 @@
   driver_->fn.glDrawElementsFn(mode, count, type, indices);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDrawElementsInstancedANGLEFn(GLenum mode,
                                                GLsizei count,
                                                GLenum type,
@@ -2972,7 +2875,6 @@
                                              primcount);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glDrawRangeElementsFn(GLenum mode,
                                       GLuint start,
                                       GLuint end,
@@ -2982,71 +2884,58 @@
   driver_->fn.glDrawRangeElementsFn(mode, start, end, count, type, indices);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glEGLImageTargetRenderbufferStorageOESFn(GLenum target,
                                                          GLeglImageOES image) {
   driver_->fn.glEGLImageTargetRenderbufferStorageOESFn(target, image);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glEGLImageTargetTexture2DOESFn(GLenum target,
                                                GLeglImageOES image) {
   driver_->fn.glEGLImageTargetTexture2DOESFn(target, image);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glEnableFn(GLenum cap) {
   driver_->fn.glEnableFn(cap);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glEnableVertexAttribArrayFn(GLuint index) {
   driver_->fn.glEnableVertexAttribArrayFn(index);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glEndQueryFn(GLenum target) {
   driver_->fn.glEndQueryFn(target);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glEndTransformFeedbackFn(void) {
   driver_->fn.glEndTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 GLsync GLApiBase::glFenceSyncFn(GLenum condition, GLbitfield flags) {
   return driver_->fn.glFenceSyncFn(condition, flags);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFinishFn(void) {
   driver_->fn.glFinishFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFinishFenceAPPLEFn(GLuint fence) {
   driver_->fn.glFinishFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFinishFenceNVFn(GLuint fence) {
   driver_->fn.glFinishFenceNVFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFlushFn(void) {
   driver_->fn.glFlushFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFlushMappedBufferRangeFn(GLenum target,
                                            GLintptr offset,
                                            GLsizeiptr length) {
   driver_->fn.glFlushMappedBufferRangeFn(target, offset, length);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFramebufferRenderbufferEXTFn(GLenum target,
                                                GLenum attachment,
                                                GLenum renderbuffertarget,
@@ -3055,7 +2944,6 @@
                                              renderbuffertarget, renderbuffer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFramebufferTexture2DEXTFn(GLenum target,
                                             GLenum attachment,
                                             GLenum textarget,
@@ -3065,7 +2953,6 @@
                                           texture, level);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFramebufferTexture2DMultisampleEXTFn(GLenum target,
                                                        GLenum attachment,
                                                        GLenum textarget,
@@ -3076,7 +2963,6 @@
       target, attachment, textarget, texture, level, samples);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFramebufferTextureLayerFn(GLenum target,
                                             GLenum attachment,
                                             GLuint texture,
@@ -3086,72 +2972,58 @@
                                           layer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glFrontFaceFn(GLenum mode) {
   driver_->fn.glFrontFaceFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenBuffersARBFn(GLsizei n, GLuint* buffers) {
   driver_->fn.glGenBuffersARBFn(n, buffers);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenerateMipmapEXTFn(GLenum target) {
   driver_->fn.glGenerateMipmapEXTFn(target);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenFencesAPPLEFn(GLsizei n, GLuint* fences) {
   driver_->fn.glGenFencesAPPLEFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenFencesNVFn(GLsizei n, GLuint* fences) {
   driver_->fn.glGenFencesNVFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
   driver_->fn.glGenFramebuffersEXTFn(n, framebuffers);
 }
 
-DISABLE_CFI_ICALL
 GLuint GLApiBase::glGenPathsNVFn(GLsizei range) {
   return driver_->fn.glGenPathsNVFn(range);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenQueriesFn(GLsizei n, GLuint* ids) {
   driver_->fn.glGenQueriesFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
   driver_->fn.glGenRenderbuffersEXTFn(n, renderbuffers);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenSamplersFn(GLsizei n, GLuint* samplers) {
   driver_->fn.glGenSamplersFn(n, samplers);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenTexturesFn(GLsizei n, GLuint* textures) {
   driver_->fn.glGenTexturesFn(n, textures);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenTransformFeedbacksFn(GLsizei n, GLuint* ids) {
   driver_->fn.glGenTransformFeedbacksFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGenVertexArraysOESFn(GLsizei n, GLuint* arrays) {
   driver_->fn.glGenVertexArraysOESFn(n, arrays);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetActiveAttribFn(GLuint program,
                                     GLuint index,
                                     GLsizei bufsize,
@@ -3163,7 +3035,6 @@
                                   name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetActiveUniformFn(GLuint program,
                                      GLuint index,
                                      GLsizei bufsize,
@@ -3175,7 +3046,6 @@
                                    name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetActiveUniformBlockivFn(GLuint program,
                                             GLuint uniformBlockIndex,
                                             GLenum pname,
@@ -3184,7 +3054,6 @@
                                           params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetActiveUniformBlockivRobustANGLEFn(GLuint program,
                                                        GLuint uniformBlockIndex,
                                                        GLenum pname,
@@ -3195,7 +3064,6 @@
       program, uniformBlockIndex, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetActiveUniformBlockNameFn(GLuint program,
                                               GLuint uniformBlockIndex,
                                               GLsizei bufSize,
@@ -3205,7 +3073,6 @@
                                             length, uniformBlockName);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetActiveUniformsivFn(GLuint program,
                                         GLsizei uniformCount,
                                         const GLuint* uniformIndices,
@@ -3215,7 +3082,6 @@
                                       pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetAttachedShadersFn(GLuint program,
                                        GLsizei maxcount,
                                        GLsizei* count,
@@ -3223,12 +3089,10 @@
   driver_->fn.glGetAttachedShadersFn(program, maxcount, count, shaders);
 }
 
-DISABLE_CFI_ICALL
 GLint GLApiBase::glGetAttribLocationFn(GLuint program, const char* name) {
   return driver_->fn.glGetAttribLocationFn(program, name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetBooleani_vRobustANGLEFn(GLenum target,
                                              GLuint index,
                                              GLsizei bufSize,
@@ -3238,12 +3102,10 @@
                                            data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetBooleanvFn(GLenum pname, GLboolean* params) {
   driver_->fn.glGetBooleanvFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetBooleanvRobustANGLEFn(GLenum pname,
                                            GLsizei bufSize,
                                            GLsizei* length,
@@ -3251,7 +3113,6 @@
   driver_->fn.glGetBooleanvRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetBufferParameteri64vRobustANGLEFn(GLenum target,
                                                       GLenum pname,
                                                       GLsizei bufSize,
@@ -3261,14 +3122,12 @@
                                                     length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetBufferParameterivFn(GLenum target,
                                          GLenum pname,
                                          GLint* params) {
   driver_->fn.glGetBufferParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetBufferParameterivRobustANGLEFn(GLenum target,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -3278,7 +3137,6 @@
                                                   length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetBufferPointervRobustANGLEFn(GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -3288,7 +3146,6 @@
                                                params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetDebugMessageLogFn(GLuint count,
                                        GLsizei bufSize,
                                        GLenum* sources,
@@ -3301,22 +3158,18 @@
                                      severities, lengths, messageLog);
 }
 
-DISABLE_CFI_ICALL
 GLenum GLApiBase::glGetErrorFn(void) {
   return driver_->fn.glGetErrorFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) {
   driver_->fn.glGetFenceivNVFn(fence, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetFloatvFn(GLenum pname, GLfloat* params) {
   driver_->fn.glGetFloatvFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetFloatvRobustANGLEFn(GLenum pname,
                                          GLsizei bufSize,
                                          GLsizei* length,
@@ -3324,17 +3177,14 @@
   driver_->fn.glGetFloatvRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 GLint GLApiBase::glGetFragDataIndexFn(GLuint program, const char* name) {
   return driver_->fn.glGetFragDataIndexFn(program, name);
 }
 
-DISABLE_CFI_ICALL
 GLint GLApiBase::glGetFragDataLocationFn(GLuint program, const char* name) {
   return driver_->fn.glGetFragDataLocationFn(program, name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetFramebufferAttachmentParameterivEXTFn(GLenum target,
                                                            GLenum attachment,
                                                            GLenum pname,
@@ -3343,7 +3193,6 @@
                                                          pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetFramebufferAttachmentParameterivRobustANGLEFn(
     GLenum target,
     GLenum attachment,
@@ -3355,7 +3204,6 @@
       target, attachment, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetFramebufferParameterivRobustANGLEFn(GLenum target,
                                                          GLenum pname,
                                                          GLsizei bufSize,
@@ -3365,19 +3213,16 @@
                                                        length, params);
 }
 
-DISABLE_CFI_ICALL
 GLenum GLApiBase::glGetGraphicsResetStatusARBFn(void) {
   return driver_->fn.glGetGraphicsResetStatusARBFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetInteger64i_vFn(GLenum target,
                                     GLuint index,
                                     GLint64* data) {
   driver_->fn.glGetInteger64i_vFn(target, index, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetInteger64i_vRobustANGLEFn(GLenum target,
                                                GLuint index,
                                                GLsizei bufSize,
@@ -3387,12 +3232,10 @@
                                              data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetInteger64vFn(GLenum pname, GLint64* params) {
   driver_->fn.glGetInteger64vFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetInteger64vRobustANGLEFn(GLenum pname,
                                              GLsizei bufSize,
                                              GLsizei* length,
@@ -3400,12 +3243,10 @@
   driver_->fn.glGetInteger64vRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetIntegeri_vFn(GLenum target, GLuint index, GLint* data) {
   driver_->fn.glGetIntegeri_vFn(target, index, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetIntegeri_vRobustANGLEFn(GLenum target,
                                              GLuint index,
                                              GLsizei bufSize,
@@ -3415,12 +3256,10 @@
                                            data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetIntegervFn(GLenum pname, GLint* params) {
   driver_->fn.glGetIntegervFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetIntegervRobustANGLEFn(GLenum pname,
                                            GLsizei bufSize,
                                            GLsizei* length,
@@ -3428,7 +3267,6 @@
   driver_->fn.glGetIntegervRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetInternalformativFn(GLenum target,
                                         GLenum internalformat,
                                         GLenum pname,
@@ -3438,7 +3276,6 @@
                                       params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetInternalformativRobustANGLEFn(GLenum target,
                                                    GLenum internalformat,
                                                    GLenum pname,
@@ -3449,12 +3286,10 @@
                                                  bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetMultisamplefvFn(GLenum pname, GLuint index, GLfloat* val) {
   driver_->fn.glGetMultisamplefvFn(pname, index, val);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetMultisamplefvRobustANGLEFn(GLenum pname,
                                                 GLuint index,
                                                 GLsizei bufSize,
@@ -3464,7 +3299,6 @@
                                               val);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetnUniformfvRobustANGLEFn(GLuint program,
                                              GLint location,
                                              GLsizei bufSize,
@@ -3474,7 +3308,6 @@
                                            params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetnUniformivRobustANGLEFn(GLuint program,
                                              GLint location,
                                              GLsizei bufSize,
@@ -3484,7 +3317,6 @@
                                            params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetnUniformuivRobustANGLEFn(GLuint program,
                                               GLint location,
                                               GLsizei bufSize,
@@ -3494,7 +3326,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetObjectLabelFn(GLenum identifier,
                                    GLuint name,
                                    GLsizei bufSize,
@@ -3503,7 +3334,6 @@
   driver_->fn.glGetObjectLabelFn(identifier, name, bufSize, length, label);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetObjectPtrLabelFn(void* ptr,
                                       GLsizei bufSize,
                                       GLsizei* length,
@@ -3511,12 +3341,10 @@
   driver_->fn.glGetObjectPtrLabelFn(ptr, bufSize, length, label);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetPointervFn(GLenum pname, void** params) {
   driver_->fn.glGetPointervFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetPointervRobustANGLERobustANGLEFn(GLenum pname,
                                                       GLsizei bufSize,
                                                       GLsizei* length,
@@ -3525,7 +3353,6 @@
                                                     params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetProgramBinaryFn(GLuint program,
                                      GLsizei bufSize,
                                      GLsizei* length,
@@ -3535,7 +3362,6 @@
                                    binary);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetProgramInfoLogFn(GLuint program,
                                       GLsizei bufsize,
                                       GLsizei* length,
@@ -3543,7 +3369,6 @@
   driver_->fn.glGetProgramInfoLogFn(program, bufsize, length, infolog);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetProgramInterfaceivFn(GLuint program,
                                           GLenum programInterface,
                                           GLenum pname,
@@ -3552,7 +3377,6 @@
                                         params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetProgramInterfaceivRobustANGLEFn(GLuint program,
                                                      GLenum programInterface,
                                                      GLenum pname,
@@ -3563,12 +3387,10 @@
       program, programInterface, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetProgramivFn(GLuint program, GLenum pname, GLint* params) {
   driver_->fn.glGetProgramivFn(program, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetProgramivRobustANGLEFn(GLuint program,
                                             GLenum pname,
                                             GLsizei bufSize,
@@ -3578,7 +3400,6 @@
                                           params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetProgramResourceivFn(GLuint program,
                                          GLenum programInterface,
                                          GLuint index,
@@ -3592,7 +3413,6 @@
                                        params);
 }
 
-DISABLE_CFI_ICALL
 GLint GLApiBase::glGetProgramResourceLocationFn(GLuint program,
                                                 GLenum programInterface,
                                                 const char* name) {
@@ -3600,7 +3420,6 @@
                                                     name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetProgramResourceNameFn(GLuint program,
                                            GLenum programInterface,
                                            GLuint index,
@@ -3611,12 +3430,10 @@
                                          bufSize, length, name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryivFn(GLenum target, GLenum pname, GLint* params) {
   driver_->fn.glGetQueryivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryivRobustANGLEFn(GLenum target,
                                           GLenum pname,
                                           GLsizei bufSize,
@@ -3625,14 +3442,12 @@
   driver_->fn.glGetQueryivRobustANGLEFn(target, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryObjecti64vFn(GLuint id,
                                        GLenum pname,
                                        GLint64* params) {
   driver_->fn.glGetQueryObjecti64vFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryObjecti64vRobustANGLEFn(GLuint id,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -3642,12 +3457,10 @@
                                                 params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryObjectivFn(GLuint id, GLenum pname, GLint* params) {
   driver_->fn.glGetQueryObjectivFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryObjectivRobustANGLEFn(GLuint id,
                                                 GLenum pname,
                                                 GLsizei bufSize,
@@ -3657,14 +3470,12 @@
                                               params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryObjectui64vFn(GLuint id,
                                         GLenum pname,
                                         GLuint64* params) {
   driver_->fn.glGetQueryObjectui64vFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryObjectui64vRobustANGLEFn(GLuint id,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -3674,12 +3485,10 @@
                                                  params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryObjectuivFn(GLuint id, GLenum pname, GLuint* params) {
   driver_->fn.glGetQueryObjectuivFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetQueryObjectuivRobustANGLEFn(GLuint id,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -3689,14 +3498,12 @@
                                                params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetRenderbufferParameterivEXTFn(GLenum target,
                                                   GLenum pname,
                                                   GLint* params) {
   driver_->fn.glGetRenderbufferParameterivEXTFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetRenderbufferParameterivRobustANGLEFn(GLenum target,
                                                           GLenum pname,
                                                           GLsizei bufSize,
@@ -3706,14 +3513,12 @@
                                                         length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetSamplerParameterfvFn(GLuint sampler,
                                           GLenum pname,
                                           GLfloat* params) {
   driver_->fn.glGetSamplerParameterfvFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetSamplerParameterfvRobustANGLEFn(GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
@@ -3723,7 +3528,6 @@
                                                    length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetSamplerParameterIivRobustANGLEFn(GLuint sampler,
                                                       GLenum pname,
                                                       GLsizei bufSize,
@@ -3733,7 +3537,6 @@
                                                     length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetSamplerParameterIuivRobustANGLEFn(GLuint sampler,
                                                        GLenum pname,
                                                        GLsizei bufSize,
@@ -3743,14 +3546,12 @@
                                                      length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetSamplerParameterivFn(GLuint sampler,
                                           GLenum pname,
                                           GLint* params) {
   driver_->fn.glGetSamplerParameterivFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetSamplerParameterivRobustANGLEFn(GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
@@ -3760,7 +3561,6 @@
                                                    length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetShaderInfoLogFn(GLuint shader,
                                      GLsizei bufsize,
                                      GLsizei* length,
@@ -3768,12 +3568,10 @@
   driver_->fn.glGetShaderInfoLogFn(shader, bufsize, length, infolog);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetShaderivFn(GLuint shader, GLenum pname, GLint* params) {
   driver_->fn.glGetShaderivFn(shader, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetShaderivRobustANGLEFn(GLuint shader,
                                            GLenum pname,
                                            GLsizei bufSize,
@@ -3783,7 +3581,6 @@
                                          params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetShaderPrecisionFormatFn(GLenum shadertype,
                                              GLenum precisiontype,
                                              GLint* range,
@@ -3792,7 +3589,6 @@
                                            precision);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetShaderSourceFn(GLuint shader,
                                     GLsizei bufsize,
                                     GLsizei* length,
@@ -3800,17 +3596,14 @@
   driver_->fn.glGetShaderSourceFn(shader, bufsize, length, source);
 }
 
-DISABLE_CFI_ICALL
 const GLubyte* GLApiBase::glGetStringFn(GLenum name) {
   return driver_->fn.glGetStringFn(name);
 }
 
-DISABLE_CFI_ICALL
 const GLubyte* GLApiBase::glGetStringiFn(GLenum name, GLuint index) {
   return driver_->fn.glGetStringiFn(name, index);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetSyncivFn(GLsync sync,
                               GLenum pname,
                               GLsizei bufSize,
@@ -3819,7 +3612,6 @@
   driver_->fn.glGetSyncivFn(sync, pname, bufSize, length, values);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexLevelParameterfvFn(GLenum target,
                                            GLint level,
                                            GLenum pname,
@@ -3827,7 +3619,6 @@
   driver_->fn.glGetTexLevelParameterfvFn(target, level, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexLevelParameterfvRobustANGLEFn(GLenum target,
                                                       GLint level,
                                                       GLenum pname,
@@ -3838,7 +3629,6 @@
                                                     bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexLevelParameterivFn(GLenum target,
                                            GLint level,
                                            GLenum pname,
@@ -3846,7 +3636,6 @@
   driver_->fn.glGetTexLevelParameterivFn(target, level, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexLevelParameterivRobustANGLEFn(GLenum target,
                                                       GLint level,
                                                       GLenum pname,
@@ -3857,14 +3646,12 @@
                                                     bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexParameterfvFn(GLenum target,
                                       GLenum pname,
                                       GLfloat* params) {
   driver_->fn.glGetTexParameterfvFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexParameterfvRobustANGLEFn(GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -3874,7 +3661,6 @@
                                                params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexParameterIivRobustANGLEFn(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -3884,7 +3670,6 @@
                                                 params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexParameterIuivRobustANGLEFn(GLenum target,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -3894,14 +3679,12 @@
                                                  params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexParameterivFn(GLenum target,
                                       GLenum pname,
                                       GLint* params) {
   driver_->fn.glGetTexParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTexParameterivRobustANGLEFn(GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -3911,7 +3694,6 @@
                                                params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTransformFeedbackVaryingFn(GLuint program,
                                                 GLuint index,
                                                 GLsizei bufSize,
@@ -3923,7 +3705,6 @@
                                               size, type, name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetTranslatedShaderSourceANGLEFn(GLuint shader,
                                                    GLsizei bufsize,
                                                    GLsizei* length,
@@ -3932,20 +3713,17 @@
                                                  source);
 }
 
-DISABLE_CFI_ICALL
 GLuint GLApiBase::glGetUniformBlockIndexFn(GLuint program,
                                            const char* uniformBlockName) {
   return driver_->fn.glGetUniformBlockIndexFn(program, uniformBlockName);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetUniformfvFn(GLuint program,
                                  GLint location,
                                  GLfloat* params) {
   driver_->fn.glGetUniformfvFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetUniformfvRobustANGLEFn(GLuint program,
                                             GLint location,
                                             GLsizei bufSize,
@@ -3955,7 +3733,6 @@
                                           params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetUniformIndicesFn(GLuint program,
                                       GLsizei uniformCount,
                                       const char* const* uniformNames,
@@ -3964,14 +3741,12 @@
                                     uniformIndices);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetUniformivFn(GLuint program,
                                  GLint location,
                                  GLint* params) {
   driver_->fn.glGetUniformivFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetUniformivRobustANGLEFn(GLuint program,
                                             GLint location,
                                             GLsizei bufSize,
@@ -3981,19 +3756,16 @@
                                           params);
 }
 
-DISABLE_CFI_ICALL
 GLint GLApiBase::glGetUniformLocationFn(GLuint program, const char* name) {
   return driver_->fn.glGetUniformLocationFn(program, name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetUniformuivFn(GLuint program,
                                   GLint location,
                                   GLuint* params) {
   driver_->fn.glGetUniformuivFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetUniformuivRobustANGLEFn(GLuint program,
                                              GLint location,
                                              GLsizei bufSize,
@@ -4003,14 +3775,12 @@
                                            params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetVertexAttribfvFn(GLuint index,
                                       GLenum pname,
                                       GLfloat* params) {
   driver_->fn.glGetVertexAttribfvFn(index, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetVertexAttribfvRobustANGLEFn(GLuint index,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -4020,7 +3790,6 @@
                                                params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetVertexAttribIivRobustANGLEFn(GLuint index,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -4030,7 +3799,6 @@
                                                 params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetVertexAttribIuivRobustANGLEFn(GLuint index,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -4040,14 +3808,12 @@
                                                  params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetVertexAttribivFn(GLuint index,
                                       GLenum pname,
                                       GLint* params) {
   driver_->fn.glGetVertexAttribivFn(index, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetVertexAttribivRobustANGLEFn(GLuint index,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -4057,14 +3823,12 @@
                                                params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetVertexAttribPointervFn(GLuint index,
                                             GLenum pname,
                                             void** pointer) {
   driver_->fn.glGetVertexAttribPointervFn(index, pname, pointer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glGetVertexAttribPointervRobustANGLEFn(GLuint index,
                                                        GLenum pname,
                                                        GLsizei bufSize,
@@ -4074,24 +3838,20 @@
                                                      length, pointer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glHintFn(GLenum target, GLenum mode) {
   driver_->fn.glHintFn(target, mode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glInsertEventMarkerEXTFn(GLsizei length, const char* marker) {
   driver_->fn.glInsertEventMarkerEXTFn(length, marker);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glInvalidateFramebufferFn(GLenum target,
                                           GLsizei numAttachments,
                                           const GLenum* attachments) {
   driver_->fn.glInvalidateFramebufferFn(target, numAttachments, attachments);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glInvalidateSubFramebufferFn(GLenum target,
                                              GLsizei numAttachments,
                                              const GLenum* attachments,
@@ -4103,97 +3863,78 @@
                                            x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsBufferFn(GLuint buffer) {
   return driver_->fn.glIsBufferFn(buffer);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsEnabledFn(GLenum cap) {
   return driver_->fn.glIsEnabledFn(cap);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsFenceAPPLEFn(GLuint fence) {
   return driver_->fn.glIsFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsFenceNVFn(GLuint fence) {
   return driver_->fn.glIsFenceNVFn(fence);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsFramebufferEXTFn(GLuint framebuffer) {
   return driver_->fn.glIsFramebufferEXTFn(framebuffer);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsPathNVFn(GLuint path) {
   return driver_->fn.glIsPathNVFn(path);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsProgramFn(GLuint program) {
   return driver_->fn.glIsProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsQueryFn(GLuint query) {
   return driver_->fn.glIsQueryFn(query);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsRenderbufferEXTFn(GLuint renderbuffer) {
   return driver_->fn.glIsRenderbufferEXTFn(renderbuffer);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsSamplerFn(GLuint sampler) {
   return driver_->fn.glIsSamplerFn(sampler);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsShaderFn(GLuint shader) {
   return driver_->fn.glIsShaderFn(shader);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsSyncFn(GLsync sync) {
   return driver_->fn.glIsSyncFn(sync);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsTextureFn(GLuint texture) {
   return driver_->fn.glIsTextureFn(texture);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsTransformFeedbackFn(GLuint id) {
   return driver_->fn.glIsTransformFeedbackFn(id);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glIsVertexArrayOESFn(GLuint array) {
   return driver_->fn.glIsVertexArrayOESFn(array);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glLineWidthFn(GLfloat width) {
   driver_->fn.glLineWidthFn(width);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glLinkProgramFn(GLuint program) {
   driver_->fn.glLinkProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void* GLApiBase::glMapBufferFn(GLenum target, GLenum access) {
   return driver_->fn.glMapBufferFn(target, access);
 }
 
-DISABLE_CFI_ICALL
 void* GLApiBase::glMapBufferRangeFn(GLenum target,
                                     GLintptr offset,
                                     GLsizeiptr length,
@@ -4201,22 +3942,18 @@
   return driver_->fn.glMapBufferRangeFn(target, offset, length, access);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
   driver_->fn.glMatrixLoadfEXTFn(matrixMode, m);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
   driver_->fn.glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glMemoryBarrierEXTFn(GLbitfield barriers) {
   driver_->fn.glMemoryBarrierEXTFn(barriers);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glObjectLabelFn(GLenum identifier,
                                 GLuint name,
                                 GLsizei length,
@@ -4224,14 +3961,12 @@
   driver_->fn.glObjectLabelFn(identifier, name, length, label);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glObjectPtrLabelFn(void* ptr,
                                    GLsizei length,
                                    const char* label) {
   driver_->fn.glObjectPtrLabelFn(ptr, length, label);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPathCommandsNVFn(GLuint path,
                                    GLsizei numCommands,
                                    const GLubyte* commands,
@@ -4242,62 +3977,50 @@
                                  coordType, coords);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPathParameterfNVFn(GLuint path, GLenum pname, GLfloat value) {
   driver_->fn.glPathParameterfNVFn(path, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
   driver_->fn.glPathParameteriNVFn(path, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
   driver_->fn.glPathStencilFuncNVFn(func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPauseTransformFeedbackFn(void) {
   driver_->fn.glPauseTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPixelStoreiFn(GLenum pname, GLint param) {
   driver_->fn.glPixelStoreiFn(pname, param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPointParameteriFn(GLenum pname, GLint param) {
   driver_->fn.glPointParameteriFn(pname, param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPolygonModeFn(GLenum face, GLenum mode) {
   driver_->fn.glPolygonModeFn(face, mode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPolygonOffsetFn(GLfloat factor, GLfloat units) {
   driver_->fn.glPolygonOffsetFn(factor, units);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPopDebugGroupFn() {
   driver_->fn.glPopDebugGroupFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPopGroupMarkerEXTFn(void) {
   driver_->fn.glPopGroupMarkerEXTFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPrimitiveRestartIndexFn(GLuint index) {
   driver_->fn.glPrimitiveRestartIndexFn(index);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glProgramBinaryFn(GLuint program,
                                   GLenum binaryFormat,
                                   const GLvoid* binary,
@@ -4305,14 +4028,12 @@
   driver_->fn.glProgramBinaryFn(program, binaryFormat, binary, length);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glProgramParameteriFn(GLuint program,
                                       GLenum pname,
                                       GLint value) {
   driver_->fn.glProgramParameteriFn(program, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glProgramPathFragmentInputGenNVFn(GLuint program,
                                                   GLint location,
                                                   GLenum genMode,
@@ -4322,7 +4043,6 @@
                                                 components, coeffs);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPushDebugGroupFn(GLenum source,
                                    GLuint id,
                                    GLsizei length,
@@ -4330,22 +4050,18 @@
   driver_->fn.glPushDebugGroupFn(source, id, length, message);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) {
   driver_->fn.glPushGroupMarkerEXTFn(length, marker);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glQueryCounterFn(GLuint id, GLenum target) {
   driver_->fn.glQueryCounterFn(id, target);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glReadBufferFn(GLenum src) {
   driver_->fn.glReadBufferFn(src);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glReadnPixelsRobustANGLEFn(GLint x,
                                            GLint y,
                                            GLsizei width,
@@ -4361,7 +4077,6 @@
                                          bufSize, length, columns, rows, data);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glReadPixelsFn(GLint x,
                                GLint y,
                                GLsizei width,
@@ -4372,7 +4087,6 @@
   driver_->fn.glReadPixelsFn(x, y, width, height, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glReadPixelsRobustANGLEFn(GLint x,
                                           GLint y,
                                           GLsizei width,
@@ -4388,12 +4102,10 @@
                                         bufSize, length, columns, rows, pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glReleaseShaderCompilerFn(void) {
   driver_->fn.glReleaseShaderCompilerFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glRenderbufferStorageEXTFn(GLenum target,
                                            GLenum internalformat,
                                            GLsizei width,
@@ -4401,7 +4113,6 @@
   driver_->fn.glRenderbufferStorageEXTFn(target, internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glRenderbufferStorageMultisampleFn(GLenum target,
                                                    GLsizei samples,
                                                    GLenum internalformat,
@@ -4411,7 +4122,6 @@
                                                  internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glRenderbufferStorageMultisampleEXTFn(GLenum target,
                                                       GLsizei samples,
                                                       GLenum internalformat,
@@ -4421,36 +4131,30 @@
       target, samples, internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glRequestExtensionANGLEFn(const char* name) {
   driver_->fn.glRequestExtensionANGLEFn(name);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glResumeTransformFeedbackFn(void) {
   driver_->fn.glResumeTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSampleCoverageFn(GLclampf value, GLboolean invert) {
   driver_->fn.glSampleCoverageFn(value, invert);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSamplerParameterfFn(GLuint sampler,
                                       GLenum pname,
                                       GLfloat param) {
   driver_->fn.glSamplerParameterfFn(sampler, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSamplerParameterfvFn(GLuint sampler,
                                        GLenum pname,
                                        const GLfloat* params) {
   driver_->fn.glSamplerParameterfvFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSamplerParameterfvRobustANGLEFn(GLuint sampler,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -4458,14 +4162,12 @@
   driver_->fn.glSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSamplerParameteriFn(GLuint sampler,
                                       GLenum pname,
                                       GLint param) {
   driver_->fn.glSamplerParameteriFn(sampler, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSamplerParameterIivRobustANGLEFn(GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -4474,7 +4176,6 @@
                                                  param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSamplerParameterIuivRobustANGLEFn(GLuint sampler,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -4483,14 +4184,12 @@
                                                   param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSamplerParameterivFn(GLuint sampler,
                                        GLenum pname,
                                        const GLint* params) {
   driver_->fn.glSamplerParameterivFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSamplerParameterivRobustANGLEFn(GLuint sampler,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -4498,22 +4197,18 @@
   driver_->fn.glSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glScissorFn(GLint x, GLint y, GLsizei width, GLsizei height) {
   driver_->fn.glScissorFn(x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSetFenceAPPLEFn(GLuint fence) {
   driver_->fn.glSetFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glSetFenceNVFn(GLuint fence, GLenum condition) {
   driver_->fn.glSetFenceNVFn(fence, condition);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glShaderBinaryFn(GLsizei n,
                                  const GLuint* shaders,
                                  GLenum binaryformat,
@@ -4522,7 +4217,6 @@
   driver_->fn.glShaderBinaryFn(n, shaders, binaryformat, binary, length);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glShaderSourceFn(GLuint shader,
                                  GLsizei count,
                                  const char* const* str,
@@ -4530,7 +4224,6 @@
   driver_->fn.glShaderSourceFn(shader, count, str, length);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilFillPathInstancedNVFn(GLsizei numPaths,
                                                GLenum pathNameType,
                                                const void* paths,
@@ -4544,19 +4237,16 @@
                                              transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilFillPathNVFn(GLuint path,
                                       GLenum fillMode,
                                       GLuint mask) {
   driver_->fn.glStencilFillPathNVFn(path, fillMode, mask);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   driver_->fn.glStencilFuncFn(func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilFuncSeparateFn(GLenum face,
                                         GLenum func,
                                         GLint ref,
@@ -4564,22 +4254,18 @@
   driver_->fn.glStencilFuncSeparateFn(face, func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilMaskFn(GLuint mask) {
   driver_->fn.glStencilMaskFn(mask);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilMaskSeparateFn(GLenum face, GLuint mask) {
   driver_->fn.glStencilMaskSeparateFn(face, mask);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilOpFn(GLenum fail, GLenum zfail, GLenum zpass) {
   driver_->fn.glStencilOpFn(fail, zfail, zpass);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilOpSeparateFn(GLenum face,
                                       GLenum fail,
                                       GLenum zfail,
@@ -4587,7 +4273,6 @@
   driver_->fn.glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilStrokePathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -4602,14 +4287,12 @@
                                                transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilStrokePathNVFn(GLuint path,
                                         GLint reference,
                                         GLuint mask) {
   driver_->fn.glStencilStrokePathNVFn(path, reference, mask);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilThenCoverFillPathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -4625,7 +4308,6 @@
       transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilThenCoverFillPathNVFn(GLuint path,
                                                GLenum fillMode,
                                                GLuint mask,
@@ -4633,7 +4315,6 @@
   driver_->fn.glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilThenCoverStrokePathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -4649,7 +4330,6 @@
       transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glStencilThenCoverStrokePathNVFn(GLuint path,
                                                  GLint reference,
                                                  GLuint mask,
@@ -4658,24 +4338,20 @@
                                                coverMode);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glTestFenceAPPLEFn(GLuint fence) {
   return driver_->fn.glTestFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glTestFenceNVFn(GLuint fence) {
   return driver_->fn.glTestFenceNVFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexBufferFn(GLenum target,
                               GLenum internalformat,
                               GLuint buffer) {
   driver_->fn.glTexBufferFn(target, internalformat, buffer);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexBufferRangeFn(GLenum target,
                                    GLenum internalformat,
                                    GLuint buffer,
@@ -4684,7 +4360,6 @@
   driver_->fn.glTexBufferRangeFn(target, internalformat, buffer, offset, size);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexImage2DFn(GLenum target,
                                GLint level,
                                GLint internalformat,
@@ -4698,7 +4373,6 @@
                              border, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexImage2DRobustANGLEFn(GLenum target,
                                           GLint level,
                                           GLint internalformat,
@@ -4714,7 +4388,6 @@
                                         pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexImage3DFn(GLenum target,
                                GLint level,
                                GLint internalformat,
@@ -4729,7 +4402,6 @@
                              depth, border, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexImage3DRobustANGLEFn(GLenum target,
                                           GLint level,
                                           GLint internalformat,
@@ -4746,19 +4418,16 @@
                                         bufSize, pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexParameterfFn(GLenum target, GLenum pname, GLfloat param) {
   driver_->fn.glTexParameterfFn(target, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexParameterfvFn(GLenum target,
                                    GLenum pname,
                                    const GLfloat* params) {
   driver_->fn.glTexParameterfvFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexParameterfvRobustANGLEFn(GLenum target,
                                               GLenum pname,
                                               GLsizei bufSize,
@@ -4766,12 +4435,10 @@
   driver_->fn.glTexParameterfvRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexParameteriFn(GLenum target, GLenum pname, GLint param) {
   driver_->fn.glTexParameteriFn(target, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexParameterIivRobustANGLEFn(GLenum target,
                                                GLenum pname,
                                                GLsizei bufSize,
@@ -4779,7 +4446,6 @@
   driver_->fn.glTexParameterIivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexParameterIuivRobustANGLEFn(GLenum target,
                                                 GLenum pname,
                                                 GLsizei bufSize,
@@ -4787,14 +4453,12 @@
   driver_->fn.glTexParameterIuivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexParameterivFn(GLenum target,
                                    GLenum pname,
                                    const GLint* params) {
   driver_->fn.glTexParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexParameterivRobustANGLEFn(GLenum target,
                                               GLenum pname,
                                               GLsizei bufSize,
@@ -4802,7 +4466,6 @@
   driver_->fn.glTexParameterivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexStorage2DEXTFn(GLenum target,
                                     GLsizei levels,
                                     GLenum internalformat,
@@ -4812,7 +4475,6 @@
                                   height);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexStorage3DFn(GLenum target,
                                  GLsizei levels,
                                  GLenum internalformat,
@@ -4823,7 +4485,6 @@
                                depth);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexSubImage2DFn(GLenum target,
                                   GLint level,
                                   GLint xoffset,
@@ -4837,7 +4498,6 @@
                                 format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexSubImage2DRobustANGLEFn(GLenum target,
                                              GLint level,
                                              GLint xoffset,
@@ -4853,7 +4513,6 @@
                                            pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexSubImage3DFn(GLenum target,
                                   GLint level,
                                   GLint xoffset,
@@ -4869,7 +4528,6 @@
                                 height, depth, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTexSubImage3DRobustANGLEFn(GLenum target,
                                              GLint level,
                                              GLint xoffset,
@@ -4887,7 +4545,6 @@
                                            format, type, bufSize, pixels);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glTransformFeedbackVaryingsFn(GLuint program,
                                               GLsizei count,
                                               const char* const* varyings,
@@ -4896,97 +4553,80 @@
                                             bufferMode);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform1fFn(GLint location, GLfloat x) {
   driver_->fn.glUniform1fFn(location, x);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform1fvFn(GLint location,
                                GLsizei count,
                                const GLfloat* v) {
   driver_->fn.glUniform1fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform1iFn(GLint location, GLint x) {
   driver_->fn.glUniform1iFn(location, x);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform1ivFn(GLint location, GLsizei count, const GLint* v) {
   driver_->fn.glUniform1ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform1uiFn(GLint location, GLuint v0) {
   driver_->fn.glUniform1uiFn(location, v0);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform1uivFn(GLint location,
                                 GLsizei count,
                                 const GLuint* v) {
   driver_->fn.glUniform1uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform2fFn(GLint location, GLfloat x, GLfloat y) {
   driver_->fn.glUniform2fFn(location, x, y);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform2fvFn(GLint location,
                                GLsizei count,
                                const GLfloat* v) {
   driver_->fn.glUniform2fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform2iFn(GLint location, GLint x, GLint y) {
   driver_->fn.glUniform2iFn(location, x, y);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform2ivFn(GLint location, GLsizei count, const GLint* v) {
   driver_->fn.glUniform2ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform2uiFn(GLint location, GLuint v0, GLuint v1) {
   driver_->fn.glUniform2uiFn(location, v0, v1);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform2uivFn(GLint location,
                                 GLsizei count,
                                 const GLuint* v) {
   driver_->fn.glUniform2uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform3fFn(GLint location, GLfloat x, GLfloat y, GLfloat z) {
   driver_->fn.glUniform3fFn(location, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform3fvFn(GLint location,
                                GLsizei count,
                                const GLfloat* v) {
   driver_->fn.glUniform3fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform3iFn(GLint location, GLint x, GLint y, GLint z) {
   driver_->fn.glUniform3iFn(location, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform3ivFn(GLint location, GLsizei count, const GLint* v) {
   driver_->fn.glUniform3ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform3uiFn(GLint location,
                                GLuint v0,
                                GLuint v1,
@@ -4994,14 +4634,12 @@
   driver_->fn.glUniform3uiFn(location, v0, v1, v2);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform3uivFn(GLint location,
                                 GLsizei count,
                                 const GLuint* v) {
   driver_->fn.glUniform3uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform4fFn(GLint location,
                               GLfloat x,
                               GLfloat y,
@@ -5010,14 +4648,12 @@
   driver_->fn.glUniform4fFn(location, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform4fvFn(GLint location,
                                GLsizei count,
                                const GLfloat* v) {
   driver_->fn.glUniform4fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform4iFn(GLint location,
                               GLint x,
                               GLint y,
@@ -5026,12 +4662,10 @@
   driver_->fn.glUniform4iFn(location, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform4ivFn(GLint location, GLsizei count, const GLint* v) {
   driver_->fn.glUniform4ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform4uiFn(GLint location,
                                GLuint v0,
                                GLuint v1,
@@ -5040,14 +4674,12 @@
   driver_->fn.glUniform4uiFn(location, v0, v1, v2, v3);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniform4uivFn(GLint location,
                                 GLsizei count,
                                 const GLuint* v) {
   driver_->fn.glUniform4uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformBlockBindingFn(GLuint program,
                                         GLuint uniformBlockIndex,
                                         GLuint uniformBlockBinding) {
@@ -5055,7 +4687,6 @@
                                       uniformBlockBinding);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix2fvFn(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
@@ -5063,7 +4694,6 @@
   driver_->fn.glUniformMatrix2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix2x3fvFn(GLint location,
                                        GLsizei count,
                                        GLboolean transpose,
@@ -5071,7 +4701,6 @@
   driver_->fn.glUniformMatrix2x3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix2x4fvFn(GLint location,
                                        GLsizei count,
                                        GLboolean transpose,
@@ -5079,7 +4708,6 @@
   driver_->fn.glUniformMatrix2x4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix3fvFn(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
@@ -5087,7 +4715,6 @@
   driver_->fn.glUniformMatrix3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix3x2fvFn(GLint location,
                                        GLsizei count,
                                        GLboolean transpose,
@@ -5095,7 +4722,6 @@
   driver_->fn.glUniformMatrix3x2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix3x4fvFn(GLint location,
                                        GLsizei count,
                                        GLboolean transpose,
@@ -5103,7 +4729,6 @@
   driver_->fn.glUniformMatrix3x4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix4fvFn(GLint location,
                                      GLsizei count,
                                      GLboolean transpose,
@@ -5111,7 +4736,6 @@
   driver_->fn.glUniformMatrix4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix4x2fvFn(GLint location,
                                        GLsizei count,
                                        GLboolean transpose,
@@ -5119,7 +4743,6 @@
   driver_->fn.glUniformMatrix4x2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUniformMatrix4x3fvFn(GLint location,
                                        GLsizei count,
                                        GLboolean transpose,
@@ -5127,42 +4750,34 @@
   driver_->fn.glUniformMatrix4x3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 GLboolean GLApiBase::glUnmapBufferFn(GLenum target) {
   return driver_->fn.glUnmapBufferFn(target);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glUseProgramFn(GLuint program) {
   driver_->fn.glUseProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glValidateProgramFn(GLuint program) {
   driver_->fn.glValidateProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttrib1fFn(GLuint indx, GLfloat x) {
   driver_->fn.glVertexAttrib1fFn(indx, x);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttrib1fvFn(GLuint indx, const GLfloat* values) {
   driver_->fn.glVertexAttrib1fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttrib2fFn(GLuint indx, GLfloat x, GLfloat y) {
   driver_->fn.glVertexAttrib2fFn(indx, x, y);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttrib2fvFn(GLuint indx, const GLfloat* values) {
   driver_->fn.glVertexAttrib2fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttrib3fFn(GLuint indx,
                                    GLfloat x,
                                    GLfloat y,
@@ -5170,12 +4785,10 @@
   driver_->fn.glVertexAttrib3fFn(indx, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttrib3fvFn(GLuint indx, const GLfloat* values) {
   driver_->fn.glVertexAttrib3fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttrib4fFn(GLuint indx,
                                    GLfloat x,
                                    GLfloat y,
@@ -5184,17 +4797,14 @@
   driver_->fn.glVertexAttrib4fFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttrib4fvFn(GLuint indx, const GLfloat* values) {
   driver_->fn.glVertexAttrib4fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttribDivisorANGLEFn(GLuint index, GLuint divisor) {
   driver_->fn.glVertexAttribDivisorANGLEFn(index, divisor);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttribI4iFn(GLuint indx,
                                     GLint x,
                                     GLint y,
@@ -5203,12 +4813,10 @@
   driver_->fn.glVertexAttribI4iFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttribI4ivFn(GLuint indx, const GLint* values) {
   driver_->fn.glVertexAttribI4ivFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttribI4uiFn(GLuint indx,
                                      GLuint x,
                                      GLuint y,
@@ -5217,12 +4825,10 @@
   driver_->fn.glVertexAttribI4uiFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttribI4uivFn(GLuint indx, const GLuint* values) {
   driver_->fn.glVertexAttribI4uivFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttribIPointerFn(GLuint indx,
                                          GLint size,
                                          GLenum type,
@@ -5231,7 +4837,6 @@
   driver_->fn.glVertexAttribIPointerFn(indx, size, type, stride, ptr);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glVertexAttribPointerFn(GLuint indx,
                                         GLint size,
                                         GLenum type,
@@ -5242,55 +4847,46 @@
                                       ptr);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glViewportFn(GLint x, GLint y, GLsizei width, GLsizei height) {
   driver_->fn.glViewportFn(x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glWaitSyncFn(GLsync sync, GLbitfield flags, GLuint64 timeout) {
   driver_->fn.glWaitSyncFn(sync, flags, timeout);
 }
 
-DISABLE_CFI_ICALL
 void GLApiBase::glWindowRectanglesEXTFn(GLenum mode,
                                         GLsizei n,
                                         const GLint* box) {
   driver_->fn.glWindowRectanglesEXTFn(mode, n, box);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glActiveTextureFn(GLenum texture) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glActiveTexture")
   gl_api_->glActiveTextureFn(texture);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glApplyFramebufferAttachmentCMAAINTELFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0(
       "gpu", "TraceGLAPI::glApplyFramebufferAttachmentCMAAINTEL")
   gl_api_->glApplyFramebufferAttachmentCMAAINTELFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glAttachShaderFn(GLuint program, GLuint shader) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glAttachShader")
   gl_api_->glAttachShaderFn(program, shader);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBeginQueryFn(GLenum target, GLuint id) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBeginQuery")
   gl_api_->glBeginQueryFn(target, id);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBeginTransformFeedbackFn(GLenum primitiveMode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBeginTransformFeedback")
   gl_api_->glBeginTransformFeedbackFn(primitiveMode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindAttribLocationFn(GLuint program,
                                         GLuint index,
                                         const char* name) {
@@ -5298,13 +4894,11 @@
   gl_api_->glBindAttribLocationFn(program, index, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindBufferFn(GLenum target, GLuint buffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindBuffer")
   gl_api_->glBindBufferFn(target, buffer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindBufferBaseFn(GLenum target,
                                     GLuint index,
                                     GLuint buffer) {
@@ -5312,7 +4906,6 @@
   gl_api_->glBindBufferBaseFn(target, index, buffer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindBufferRangeFn(GLenum target,
                                      GLuint index,
                                      GLuint buffer,
@@ -5322,7 +4915,6 @@
   gl_api_->glBindBufferRangeFn(target, index, buffer, offset, size);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindFragDataLocationFn(GLuint program,
                                           GLuint colorNumber,
                                           const char* name) {
@@ -5330,7 +4922,6 @@
   gl_api_->glBindFragDataLocationFn(program, colorNumber, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindFragDataLocationIndexedFn(GLuint program,
                                                  GLuint colorNumber,
                                                  GLuint index,
@@ -5340,13 +4931,11 @@
   gl_api_->glBindFragDataLocationIndexedFn(program, colorNumber, index, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindFramebufferEXTFn(GLenum target, GLuint framebuffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindFramebufferEXT")
   gl_api_->glBindFramebufferEXTFn(target, framebuffer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindImageTextureEXTFn(GLuint index,
                                          GLuint texture,
                                          GLint level,
@@ -5359,31 +4948,26 @@
                                    access, format);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindRenderbufferEXTFn(GLenum target, GLuint renderbuffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindRenderbufferEXT")
   gl_api_->glBindRenderbufferEXTFn(target, renderbuffer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindSamplerFn(GLuint unit, GLuint sampler) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindSampler")
   gl_api_->glBindSamplerFn(unit, sampler);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindTextureFn(GLenum target, GLuint texture) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindTexture")
   gl_api_->glBindTextureFn(target, texture);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindTransformFeedbackFn(GLenum target, GLuint id) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindTransformFeedback")
   gl_api_->glBindTransformFeedbackFn(target, id);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindUniformLocationCHROMIUMFn(GLuint program,
                                                  GLint location,
                                                  const char* name) {
@@ -5392,19 +4976,16 @@
   gl_api_->glBindUniformLocationCHROMIUMFn(program, location, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBindVertexArrayOESFn(GLuint array) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBindVertexArrayOES")
   gl_api_->glBindVertexArrayOESFn(array);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBlendBarrierKHRFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendBarrierKHR")
   gl_api_->glBlendBarrierKHRFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBlendColorFn(GLclampf red,
                                 GLclampf green,
                                 GLclampf blue,
@@ -5413,25 +4994,21 @@
   gl_api_->glBlendColorFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBlendEquationFn(GLenum mode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendEquation")
   gl_api_->glBlendEquationFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendEquationSeparate")
   gl_api_->glBlendEquationSeparateFn(modeRGB, modeAlpha);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glBlendFunc")
   gl_api_->glBlendFuncFn(sfactor, dfactor);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBlendFuncSeparateFn(GLenum srcRGB,
                                        GLenum dstRGB,
                                        GLenum srcAlpha,
@@ -5440,7 +5017,6 @@
   gl_api_->glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBlitFramebufferFn(GLint srcX0,
                                      GLint srcY0,
                                      GLint srcX1,
@@ -5456,7 +5032,6 @@
                                dstY1, mask, filter);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBufferDataFn(GLenum target,
                                 GLsizeiptr size,
                                 const void* data,
@@ -5465,7 +5040,6 @@
   gl_api_->glBufferDataFn(target, size, data, usage);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glBufferSubDataFn(GLenum target,
                                    GLintptr offset,
                                    GLsizeiptr size,
@@ -5474,20 +5048,17 @@
   gl_api_->glBufferSubDataFn(target, offset, size, data);
 }
 
-DISABLE_CFI_ICALL
 GLenum TraceGLApi::glCheckFramebufferStatusEXTFn(GLenum target) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
                                 "TraceGLAPI::glCheckFramebufferStatusEXT")
   return gl_api_->glCheckFramebufferStatusEXTFn(target);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearFn(GLbitfield mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClear")
   gl_api_->glClearFn(mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearBufferfiFn(GLenum buffer,
                                    GLint drawbuffer,
                                    const GLfloat depth,
@@ -5496,7 +5067,6 @@
   gl_api_->glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearBufferfvFn(GLenum buffer,
                                    GLint drawbuffer,
                                    const GLfloat* value) {
@@ -5504,7 +5074,6 @@
   gl_api_->glClearBufferfvFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearBufferivFn(GLenum buffer,
                                    GLint drawbuffer,
                                    const GLint* value) {
@@ -5512,7 +5081,6 @@
   gl_api_->glClearBufferivFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearBufferuivFn(GLenum buffer,
                                     GLint drawbuffer,
                                     const GLuint* value) {
@@ -5520,7 +5088,6 @@
   gl_api_->glClearBufferuivFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearColorFn(GLclampf red,
                                 GLclampf green,
                                 GLclampf blue,
@@ -5529,25 +5096,21 @@
   gl_api_->glClearColorFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearDepthFn(GLclampd depth) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearDepth")
   gl_api_->glClearDepthFn(depth);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearDepthfFn(GLclampf depth) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearDepthf")
   gl_api_->glClearDepthfFn(depth);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glClearStencilFn(GLint s) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glClearStencil")
   gl_api_->glClearStencilFn(s);
 }
 
-DISABLE_CFI_ICALL
 GLenum TraceGLApi::glClientWaitSyncFn(GLsync sync,
                                       GLbitfield flags,
                                       GLuint64 timeout) {
@@ -5555,7 +5118,6 @@
   return gl_api_->glClientWaitSyncFn(sync, flags, timeout);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glColorMaskFn(GLboolean red,
                                GLboolean green,
                                GLboolean blue,
@@ -5564,13 +5126,11 @@
   gl_api_->glColorMaskFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompileShaderFn(GLuint shader) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCompileShader")
   gl_api_->glCompileShaderFn(shader);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedCopyTextureCHROMIUMFn(GLuint sourceId,
                                                    GLuint destId) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
@@ -5578,7 +5138,6 @@
   gl_api_->glCompressedCopyTextureCHROMIUMFn(sourceId, destId);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedTexImage2DFn(GLenum target,
                                           GLint level,
                                           GLenum internalformat,
@@ -5592,7 +5151,6 @@
                                     height, border, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedTexImage2DRobustANGLEFn(GLenum target,
                                                      GLint level,
                                                      GLenum internalformat,
@@ -5609,7 +5167,6 @@
                                                dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedTexImage3DFn(GLenum target,
                                           GLint level,
                                           GLenum internalformat,
@@ -5624,7 +5181,6 @@
                                     height, depth, border, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedTexImage3DRobustANGLEFn(GLenum target,
                                                      GLint level,
                                                      GLenum internalformat,
@@ -5642,7 +5198,6 @@
                                                imageSize, dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedTexSubImage2DFn(GLenum target,
                                              GLint level,
                                              GLint xoffset,
@@ -5657,7 +5212,6 @@
                                        height, format, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedTexSubImage2DRobustANGLEFn(GLenum target,
                                                         GLint level,
                                                         GLint xoffset,
@@ -5675,7 +5229,6 @@
       dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedTexSubImage3DFn(GLenum target,
                                              GLint level,
                                              GLint xoffset,
@@ -5693,7 +5246,6 @@
                                        data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCompressedTexSubImage3DRobustANGLEFn(GLenum target,
                                                         GLint level,
                                                         GLint xoffset,
@@ -5713,7 +5265,6 @@
       imageSize, dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCopyBufferSubDataFn(GLenum readTarget,
                                        GLenum writeTarget,
                                        GLintptr readOffset,
@@ -5724,7 +5275,6 @@
                                  writeOffset, size);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCopySubTextureCHROMIUMFn(GLuint sourceId,
                                             GLint sourceLevel,
                                             GLenum destTarget,
@@ -5746,7 +5296,6 @@
       unpackUnmultiplyAlpha);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCopyTexImage2DFn(GLenum target,
                                     GLint level,
                                     GLenum internalformat,
@@ -5760,7 +5309,6 @@
                               height, border);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCopyTexSubImage2DFn(GLenum target,
                                        GLint level,
                                        GLint xoffset,
@@ -5774,7 +5322,6 @@
                                  height);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCopyTexSubImage3DFn(GLenum target,
                                        GLint level,
                                        GLint xoffset,
@@ -5789,7 +5336,6 @@
                                  width, height);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCopyTextureCHROMIUMFn(GLuint sourceId,
                                          GLint sourceLevel,
                                          GLenum destTarget,
@@ -5806,13 +5352,11 @@
       destType, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCoverageModulationNVFn(GLenum components) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverageModulationNV")
   gl_api_->glCoverageModulationNVFn(components);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCoverFillPathInstancedNVFn(GLsizei numPaths,
                                               GLenum pathNameType,
                                               const void* paths,
@@ -5826,13 +5370,11 @@
                                         transformValues);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverFillPathNV")
   gl_api_->glCoverFillPathNVFn(path, coverMode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCoverStrokePathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -5848,38 +5390,32 @@
                                           transformValues);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCoverStrokePathNV")
   gl_api_->glCoverStrokePathNVFn(name, coverMode);
 }
 
-DISABLE_CFI_ICALL
 GLuint TraceGLApi::glCreateProgramFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCreateProgram")
   return gl_api_->glCreateProgramFn();
 }
 
-DISABLE_CFI_ICALL
 GLuint TraceGLApi::glCreateShaderFn(GLenum type) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCreateShader")
   return gl_api_->glCreateShaderFn(type);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glCullFaceFn(GLenum mode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glCullFace")
   gl_api_->glCullFaceFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDebugMessageCallbackFn(GLDEBUGPROC callback,
                                           const void* userParam) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDebugMessageCallback")
   gl_api_->glDebugMessageCallbackFn(callback, userParam);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDebugMessageControlFn(GLenum source,
                                          GLenum type,
                                          GLenum severity,
@@ -5890,7 +5426,6 @@
   gl_api_->glDebugMessageControlFn(source, type, severity, count, ids, enabled);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDebugMessageInsertFn(GLenum source,
                                         GLenum type,
                                         GLuint id,
@@ -5901,135 +5436,113 @@
   gl_api_->glDebugMessageInsertFn(source, type, id, severity, length, buf);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteBuffersARB")
   gl_api_->glDeleteBuffersARBFn(n, buffers);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteFencesAPPLE")
   gl_api_->glDeleteFencesAPPLEFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteFencesNV")
   gl_api_->glDeleteFencesNVFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteFramebuffersEXTFn(GLsizei n,
                                            const GLuint* framebuffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteFramebuffersEXT")
   gl_api_->glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeletePathsNVFn(GLuint path, GLsizei range) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeletePathsNV")
   gl_api_->glDeletePathsNVFn(path, range);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteProgram")
   gl_api_->glDeleteProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteQueries")
   gl_api_->glDeleteQueriesFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteRenderbuffersEXTFn(GLsizei n,
                                             const GLuint* renderbuffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteRenderbuffersEXT")
   gl_api_->glDeleteRenderbuffersEXTFn(n, renderbuffers);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteSamplersFn(GLsizei n, const GLuint* samplers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteSamplers")
   gl_api_->glDeleteSamplersFn(n, samplers);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteShaderFn(GLuint shader) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteShader")
   gl_api_->glDeleteShaderFn(shader);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteSyncFn(GLsync sync) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteSync")
   gl_api_->glDeleteSyncFn(sync);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteTexturesFn(GLsizei n, const GLuint* textures) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteTextures")
   gl_api_->glDeleteTexturesFn(n, textures);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteTransformFeedbacksFn(GLsizei n, const GLuint* ids) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteTransformFeedbacks")
   gl_api_->glDeleteTransformFeedbacksFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDeleteVertexArraysOESFn(GLsizei n, const GLuint* arrays) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDeleteVertexArraysOES")
   gl_api_->glDeleteVertexArraysOESFn(n, arrays);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDepthFuncFn(GLenum func) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDepthFunc")
   gl_api_->glDepthFuncFn(func);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDepthMaskFn(GLboolean flag) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDepthMask")
   gl_api_->glDepthMaskFn(flag);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDepthRangeFn(GLclampd zNear, GLclampd zFar) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDepthRange")
   gl_api_->glDepthRangeFn(zNear, zFar);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDepthRangefFn(GLclampf zNear, GLclampf zFar) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDepthRangef")
   gl_api_->glDepthRangefFn(zNear, zFar);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDetachShaderFn(GLuint program, GLuint shader) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDetachShader")
   gl_api_->glDetachShaderFn(program, shader);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDisableFn(GLenum cap) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDisable")
   gl_api_->glDisableFn(cap);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDisableVertexAttribArrayFn(GLuint index) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDisableVertexAttribArray")
   gl_api_->glDisableVertexAttribArrayFn(index);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDiscardFramebufferEXTFn(GLenum target,
                                            GLsizei numAttachments,
                                            const GLenum* attachments) {
@@ -6037,13 +5550,11 @@
   gl_api_->glDiscardFramebufferEXTFn(target, numAttachments, attachments);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawArrays")
   gl_api_->glDrawArraysFn(mode, first, count);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDrawArraysInstancedANGLEFn(GLenum mode,
                                               GLint first,
                                               GLsizei count,
@@ -6052,19 +5563,16 @@
   gl_api_->glDrawArraysInstancedANGLEFn(mode, first, count, primcount);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDrawBufferFn(GLenum mode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawBuffer")
   gl_api_->glDrawBufferFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDrawBuffersARBFn(GLsizei n, const GLenum* bufs) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glDrawBuffersARB")
   gl_api_->glDrawBuffersARBFn(n, bufs);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDrawElementsFn(GLenum mode,
                                   GLsizei count,
                                   GLenum type,
@@ -6073,7 +5581,6 @@
   gl_api_->glDrawElementsFn(mode, count, type, indices);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDrawElementsInstancedANGLEFn(GLenum mode,
                                                 GLsizei count,
                                                 GLenum type,
@@ -6085,7 +5592,6 @@
                                           primcount);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glDrawRangeElementsFn(GLenum mode,
                                        GLuint start,
                                        GLuint end,
@@ -6096,7 +5602,6 @@
   gl_api_->glDrawRangeElementsFn(mode, start, end, count, type, indices);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glEGLImageTargetRenderbufferStorageOESFn(GLenum target,
                                                           GLeglImageOES image) {
   TRACE_EVENT_BINARY_EFFICIENT0(
@@ -6104,7 +5609,6 @@
   gl_api_->glEGLImageTargetRenderbufferStorageOESFn(target, image);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glEGLImageTargetTexture2DOESFn(GLenum target,
                                                 GLeglImageOES image) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
@@ -6112,61 +5616,51 @@
   gl_api_->glEGLImageTargetTexture2DOESFn(target, image);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glEnableFn(GLenum cap) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEnable")
   gl_api_->glEnableFn(cap);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glEnableVertexAttribArrayFn(GLuint index) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEnableVertexAttribArray")
   gl_api_->glEnableVertexAttribArrayFn(index);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glEndQueryFn(GLenum target) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEndQuery")
   gl_api_->glEndQueryFn(target);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glEndTransformFeedbackFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glEndTransformFeedback")
   gl_api_->glEndTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 GLsync TraceGLApi::glFenceSyncFn(GLenum condition, GLbitfield flags) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFenceSync")
   return gl_api_->glFenceSyncFn(condition, flags);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFinishFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFinish")
   gl_api_->glFinishFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFinishFenceAPPLEFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFinishFenceAPPLE")
   gl_api_->glFinishFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFinishFenceNVFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFinishFenceNV")
   gl_api_->glFinishFenceNVFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFlushFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFlush")
   gl_api_->glFlushFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFlushMappedBufferRangeFn(GLenum target,
                                             GLintptr offset,
                                             GLsizeiptr length) {
@@ -6174,7 +5668,6 @@
   gl_api_->glFlushMappedBufferRangeFn(target, offset, length);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFramebufferRenderbufferEXTFn(GLenum target,
                                                 GLenum attachment,
                                                 GLenum renderbuffertarget,
@@ -6185,7 +5678,6 @@
                                           renderbuffertarget, renderbuffer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFramebufferTexture2DEXTFn(GLenum target,
                                              GLenum attachment,
                                              GLenum textarget,
@@ -6196,7 +5688,6 @@
                                        level);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFramebufferTexture2DMultisampleEXTFn(GLenum target,
                                                         GLenum attachment,
                                                         GLenum textarget,
@@ -6209,7 +5700,6 @@
                                                   texture, level, samples);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFramebufferTextureLayerFn(GLenum target,
                                              GLenum attachment,
                                              GLuint texture,
@@ -6220,85 +5710,71 @@
                                        layer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glFrontFaceFn(GLenum mode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glFrontFace")
   gl_api_->glFrontFaceFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenBuffersARBFn(GLsizei n, GLuint* buffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenBuffersARB")
   gl_api_->glGenBuffersARBFn(n, buffers);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenerateMipmapEXTFn(GLenum target) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenerateMipmapEXT")
   gl_api_->glGenerateMipmapEXTFn(target);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenFencesAPPLEFn(GLsizei n, GLuint* fences) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenFencesAPPLE")
   gl_api_->glGenFencesAPPLEFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenFencesNVFn(GLsizei n, GLuint* fences) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenFencesNV")
   gl_api_->glGenFencesNVFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenFramebuffersEXT")
   gl_api_->glGenFramebuffersEXTFn(n, framebuffers);
 }
 
-DISABLE_CFI_ICALL
 GLuint TraceGLApi::glGenPathsNVFn(GLsizei range) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenPathsNV")
   return gl_api_->glGenPathsNVFn(range);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenQueries")
   gl_api_->glGenQueriesFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenRenderbuffersEXT")
   gl_api_->glGenRenderbuffersEXTFn(n, renderbuffers);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenSamplersFn(GLsizei n, GLuint* samplers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenSamplers")
   gl_api_->glGenSamplersFn(n, samplers);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenTexturesFn(GLsizei n, GLuint* textures) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenTextures")
   gl_api_->glGenTexturesFn(n, textures);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenTransformFeedbacksFn(GLsizei n, GLuint* ids) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenTransformFeedbacks")
   gl_api_->glGenTransformFeedbacksFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGenVertexArraysOESFn(GLsizei n, GLuint* arrays) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGenVertexArraysOES")
   gl_api_->glGenVertexArraysOESFn(n, arrays);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetActiveAttribFn(GLuint program,
                                      GLuint index,
                                      GLsizei bufsize,
@@ -6311,7 +5787,6 @@
                                name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetActiveUniformFn(GLuint program,
                                       GLuint index,
                                       GLsizei bufsize,
@@ -6324,7 +5799,6 @@
                                 name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetActiveUniformBlockivFn(GLuint program,
                                              GLuint uniformBlockIndex,
                                              GLenum pname,
@@ -6334,7 +5808,6 @@
                                        params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetActiveUniformBlockivRobustANGLEFn(
     GLuint program,
     GLuint uniformBlockIndex,
@@ -6348,7 +5821,6 @@
       program, uniformBlockIndex, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetActiveUniformBlockNameFn(GLuint program,
                                                GLuint uniformBlockIndex,
                                                GLsizei bufSize,
@@ -6360,7 +5832,6 @@
                                          length, uniformBlockName);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetActiveUniformsivFn(GLuint program,
                                          GLsizei uniformCount,
                                          const GLuint* uniformIndices,
@@ -6371,7 +5842,6 @@
                                    params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetAttachedShadersFn(GLuint program,
                                         GLsizei maxcount,
                                         GLsizei* count,
@@ -6380,13 +5850,11 @@
   gl_api_->glGetAttachedShadersFn(program, maxcount, count, shaders);
 }
 
-DISABLE_CFI_ICALL
 GLint TraceGLApi::glGetAttribLocationFn(GLuint program, const char* name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetAttribLocation")
   return gl_api_->glGetAttribLocationFn(program, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetBooleani_vRobustANGLEFn(GLenum target,
                                               GLuint index,
                                               GLsizei bufSize,
@@ -6396,13 +5864,11 @@
   gl_api_->glGetBooleani_vRobustANGLEFn(target, index, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetBooleanvFn(GLenum pname, GLboolean* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetBooleanv")
   gl_api_->glGetBooleanvFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetBooleanvRobustANGLEFn(GLenum pname,
                                             GLsizei bufSize,
                                             GLsizei* length,
@@ -6411,7 +5877,6 @@
   gl_api_->glGetBooleanvRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetBufferParameteri64vRobustANGLEFn(GLenum target,
                                                        GLenum pname,
                                                        GLsizei bufSize,
@@ -6423,7 +5888,6 @@
                                                  params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetBufferParameterivFn(GLenum target,
                                           GLenum pname,
                                           GLint* params) {
@@ -6431,7 +5895,6 @@
   gl_api_->glGetBufferParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetBufferParameterivRobustANGLEFn(GLenum target,
                                                      GLenum pname,
                                                      GLsizei bufSize,
@@ -6443,7 +5906,6 @@
                                                params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetBufferPointervRobustANGLEFn(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -6455,7 +5917,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetDebugMessageLogFn(GLuint count,
                                         GLsizei bufSize,
                                         GLenum* sources,
@@ -6469,25 +5930,21 @@
                                   severities, lengths, messageLog);
 }
 
-DISABLE_CFI_ICALL
 GLenum TraceGLApi::glGetErrorFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetError")
   return gl_api_->glGetErrorFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFenceivNV")
   gl_api_->glGetFenceivNVFn(fence, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetFloatvFn(GLenum pname, GLfloat* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFloatv")
   gl_api_->glGetFloatvFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetFloatvRobustANGLEFn(GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei* length,
@@ -6496,19 +5953,16 @@
   gl_api_->glGetFloatvRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 GLint TraceGLApi::glGetFragDataIndexFn(GLuint program, const char* name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFragDataIndex")
   return gl_api_->glGetFragDataIndexFn(program, name);
 }
 
-DISABLE_CFI_ICALL
 GLint TraceGLApi::glGetFragDataLocationFn(GLuint program, const char* name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetFragDataLocation")
   return gl_api_->glGetFragDataLocationFn(program, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetFramebufferAttachmentParameterivEXTFn(GLenum target,
                                                             GLenum attachment,
                                                             GLenum pname,
@@ -6519,7 +5973,6 @@
                                                       params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetFramebufferAttachmentParameterivRobustANGLEFn(
     GLenum target,
     GLenum attachment,
@@ -6533,7 +5986,6 @@
       target, attachment, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetFramebufferParameterivRobustANGLEFn(GLenum target,
                                                           GLenum pname,
                                                           GLsizei bufSize,
@@ -6545,14 +5997,12 @@
                                                     length, params);
 }
 
-DISABLE_CFI_ICALL
 GLenum TraceGLApi::glGetGraphicsResetStatusARBFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu",
                                 "TraceGLAPI::glGetGraphicsResetStatusARB")
   return gl_api_->glGetGraphicsResetStatusARBFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetInteger64i_vFn(GLenum target,
                                      GLuint index,
                                      GLint64* data) {
@@ -6560,7 +6010,6 @@
   gl_api_->glGetInteger64i_vFn(target, index, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetInteger64i_vRobustANGLEFn(GLenum target,
                                                 GLuint index,
                                                 GLsizei bufSize,
@@ -6571,13 +6020,11 @@
   gl_api_->glGetInteger64i_vRobustANGLEFn(target, index, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetInteger64vFn(GLenum pname, GLint64* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetInteger64v")
   gl_api_->glGetInteger64vFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetInteger64vRobustANGLEFn(GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei* length,
@@ -6586,13 +6033,11 @@
   gl_api_->glGetInteger64vRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetIntegeri_vFn(GLenum target, GLuint index, GLint* data) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetIntegeri_v")
   gl_api_->glGetIntegeri_vFn(target, index, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetIntegeri_vRobustANGLEFn(GLenum target,
                                               GLuint index,
                                               GLsizei bufSize,
@@ -6602,13 +6047,11 @@
   gl_api_->glGetIntegeri_vRobustANGLEFn(target, index, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetIntegervFn(GLenum pname, GLint* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetIntegerv")
   gl_api_->glGetIntegervFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetIntegervRobustANGLEFn(GLenum pname,
                                             GLsizei bufSize,
                                             GLsizei* length,
@@ -6617,7 +6060,6 @@
   gl_api_->glGetIntegervRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetInternalformativFn(GLenum target,
                                          GLenum internalformat,
                                          GLenum pname,
@@ -6628,7 +6070,6 @@
                                    params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetInternalformativRobustANGLEFn(GLenum target,
                                                     GLenum internalformat,
                                                     GLenum pname,
@@ -6641,7 +6082,6 @@
                                               bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetMultisamplefvFn(GLenum pname,
                                       GLuint index,
                                       GLfloat* val) {
@@ -6649,7 +6089,6 @@
   gl_api_->glGetMultisamplefvFn(pname, index, val);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetMultisamplefvRobustANGLEFn(GLenum pname,
                                                  GLuint index,
                                                  GLsizei bufSize,
@@ -6660,7 +6099,6 @@
   gl_api_->glGetMultisamplefvRobustANGLEFn(pname, index, bufSize, length, val);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetnUniformfvRobustANGLEFn(GLuint program,
                                               GLint location,
                                               GLsizei bufSize,
@@ -6671,7 +6109,6 @@
                                         params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetnUniformivRobustANGLEFn(GLuint program,
                                               GLint location,
                                               GLsizei bufSize,
@@ -6682,7 +6119,6 @@
                                         params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetnUniformuivRobustANGLEFn(GLuint program,
                                                GLint location,
                                                GLsizei bufSize,
@@ -6694,7 +6130,6 @@
                                          params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetObjectLabelFn(GLenum identifier,
                                     GLuint name,
                                     GLsizei bufSize,
@@ -6704,7 +6139,6 @@
   gl_api_->glGetObjectLabelFn(identifier, name, bufSize, length, label);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetObjectPtrLabelFn(void* ptr,
                                        GLsizei bufSize,
                                        GLsizei* length,
@@ -6713,13 +6147,11 @@
   gl_api_->glGetObjectPtrLabelFn(ptr, bufSize, length, label);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetPointervFn(GLenum pname, void** params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetPointerv")
   gl_api_->glGetPointervFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetPointervRobustANGLERobustANGLEFn(GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei* length,
@@ -6730,7 +6162,6 @@
                                                  params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetProgramBinaryFn(GLuint program,
                                       GLsizei bufSize,
                                       GLsizei* length,
@@ -6740,7 +6171,6 @@
   gl_api_->glGetProgramBinaryFn(program, bufSize, length, binaryFormat, binary);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetProgramInfoLogFn(GLuint program,
                                        GLsizei bufsize,
                                        GLsizei* length,
@@ -6749,7 +6179,6 @@
   gl_api_->glGetProgramInfoLogFn(program, bufsize, length, infolog);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetProgramInterfaceivFn(GLuint program,
                                            GLenum programInterface,
                                            GLenum pname,
@@ -6758,7 +6187,6 @@
   gl_api_->glGetProgramInterfaceivFn(program, programInterface, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetProgramInterfaceivRobustANGLEFn(GLuint program,
                                                       GLenum programInterface,
                                                       GLenum pname,
@@ -6771,13 +6199,11 @@
                                                 pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetProgramivFn(GLuint program, GLenum pname, GLint* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetProgramiv")
   gl_api_->glGetProgramivFn(program, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetProgramivRobustANGLEFn(GLuint program,
                                              GLenum pname,
                                              GLsizei bufSize,
@@ -6787,7 +6213,6 @@
   gl_api_->glGetProgramivRobustANGLEFn(program, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetProgramResourceivFn(GLuint program,
                                           GLenum programInterface,
                                           GLuint index,
@@ -6801,7 +6226,6 @@
                                     props, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 GLint TraceGLApi::glGetProgramResourceLocationFn(GLuint program,
                                                  GLenum programInterface,
                                                  const char* name) {
@@ -6811,7 +6235,6 @@
                                                  name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetProgramResourceNameFn(GLuint program,
                                             GLenum programInterface,
                                             GLuint index,
@@ -6823,13 +6246,11 @@
                                       length, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryivFn(GLenum target, GLenum pname, GLint* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetQueryiv")
   gl_api_->glGetQueryivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryivRobustANGLEFn(GLenum target,
                                            GLenum pname,
                                            GLsizei bufSize,
@@ -6839,7 +6260,6 @@
   gl_api_->glGetQueryivRobustANGLEFn(target, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryObjecti64vFn(GLuint id,
                                         GLenum pname,
                                         GLint64* params) {
@@ -6847,7 +6267,6 @@
   gl_api_->glGetQueryObjecti64vFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryObjecti64vRobustANGLEFn(GLuint id,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -6859,13 +6278,11 @@
                                              params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryObjectivFn(GLuint id, GLenum pname, GLint* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetQueryObjectiv")
   gl_api_->glGetQueryObjectivFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryObjectivRobustANGLEFn(GLuint id,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -6876,7 +6293,6 @@
   gl_api_->glGetQueryObjectivRobustANGLEFn(id, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryObjectui64vFn(GLuint id,
                                          GLenum pname,
                                          GLuint64* params) {
@@ -6884,7 +6300,6 @@
   gl_api_->glGetQueryObjectui64vFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryObjectui64vRobustANGLEFn(GLuint id,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -6896,7 +6311,6 @@
                                               params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryObjectuivFn(GLuint id,
                                        GLenum pname,
                                        GLuint* params) {
@@ -6904,7 +6318,6 @@
   gl_api_->glGetQueryObjectuivFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetQueryObjectuivRobustANGLEFn(GLuint id,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -6915,7 +6328,6 @@
   gl_api_->glGetQueryObjectuivRobustANGLEFn(id, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetRenderbufferParameterivEXTFn(GLenum target,
                                                    GLenum pname,
                                                    GLint* params) {
@@ -6924,7 +6336,6 @@
   gl_api_->glGetRenderbufferParameterivEXTFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetRenderbufferParameterivRobustANGLEFn(GLenum target,
                                                            GLenum pname,
                                                            GLsizei bufSize,
@@ -6936,7 +6347,6 @@
                                                      length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetSamplerParameterfvFn(GLuint sampler,
                                            GLenum pname,
                                            GLfloat* params) {
@@ -6944,7 +6354,6 @@
   gl_api_->glGetSamplerParameterfvFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetSamplerParameterfvRobustANGLEFn(GLuint sampler,
                                                       GLenum pname,
                                                       GLsizei bufSize,
@@ -6956,7 +6365,6 @@
                                                 params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetSamplerParameterIivRobustANGLEFn(GLuint sampler,
                                                        GLenum pname,
                                                        GLsizei bufSize,
@@ -6968,7 +6376,6 @@
                                                  length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetSamplerParameterIuivRobustANGLEFn(GLuint sampler,
                                                         GLenum pname,
                                                         GLsizei bufSize,
@@ -6980,7 +6387,6 @@
                                                   length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetSamplerParameterivFn(GLuint sampler,
                                            GLenum pname,
                                            GLint* params) {
@@ -6988,7 +6394,6 @@
   gl_api_->glGetSamplerParameterivFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetSamplerParameterivRobustANGLEFn(GLuint sampler,
                                                       GLenum pname,
                                                       GLsizei bufSize,
@@ -7000,7 +6405,6 @@
                                                 params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetShaderInfoLogFn(GLuint shader,
                                       GLsizei bufsize,
                                       GLsizei* length,
@@ -7009,13 +6413,11 @@
   gl_api_->glGetShaderInfoLogFn(shader, bufsize, length, infolog);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetShaderivFn(GLuint shader, GLenum pname, GLint* params) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetShaderiv")
   gl_api_->glGetShaderivFn(shader, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetShaderivRobustANGLEFn(GLuint shader,
                                             GLenum pname,
                                             GLsizei bufSize,
@@ -7025,7 +6427,6 @@
   gl_api_->glGetShaderivRobustANGLEFn(shader, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetShaderPrecisionFormatFn(GLenum shadertype,
                                               GLenum precisiontype,
                                               GLint* range,
@@ -7035,7 +6436,6 @@
                                         precision);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetShaderSourceFn(GLuint shader,
                                      GLsizei bufsize,
                                      GLsizei* length,
@@ -7044,19 +6444,16 @@
   gl_api_->glGetShaderSourceFn(shader, bufsize, length, source);
 }
 
-DISABLE_CFI_ICALL
 const GLubyte* TraceGLApi::glGetStringFn(GLenum name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetString")
   return gl_api_->glGetStringFn(name);
 }
 
-DISABLE_CFI_ICALL
 const GLubyte* TraceGLApi::glGetStringiFn(GLenum name, GLuint index) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetStringi")
   return gl_api_->glGetStringiFn(name, index);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetSyncivFn(GLsync sync,
                                GLenum pname,
                                GLsizei bufSize,
@@ -7066,7 +6463,6 @@
   gl_api_->glGetSyncivFn(sync, pname, bufSize, length, values);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexLevelParameterfvFn(GLenum target,
                                             GLint level,
                                             GLenum pname,
@@ -7075,7 +6471,6 @@
   gl_api_->glGetTexLevelParameterfvFn(target, level, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexLevelParameterfvRobustANGLEFn(GLenum target,
                                                        GLint level,
                                                        GLenum pname,
@@ -7088,7 +6483,6 @@
                                                  length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexLevelParameterivFn(GLenum target,
                                             GLint level,
                                             GLenum pname,
@@ -7097,7 +6491,6 @@
   gl_api_->glGetTexLevelParameterivFn(target, level, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexLevelParameterivRobustANGLEFn(GLenum target,
                                                        GLint level,
                                                        GLenum pname,
@@ -7110,7 +6503,6 @@
                                                  length, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexParameterfvFn(GLenum target,
                                        GLenum pname,
                                        GLfloat* params) {
@@ -7118,7 +6510,6 @@
   gl_api_->glGetTexParameterfvFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexParameterfvRobustANGLEFn(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -7130,7 +6521,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexParameterIivRobustANGLEFn(GLenum target,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -7142,7 +6532,6 @@
                                              params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexParameterIuivRobustANGLEFn(GLenum target,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -7154,7 +6543,6 @@
                                               params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexParameterivFn(GLenum target,
                                        GLenum pname,
                                        GLint* params) {
@@ -7162,7 +6550,6 @@
   gl_api_->glGetTexParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTexParameterivRobustANGLEFn(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -7174,7 +6561,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTransformFeedbackVaryingFn(GLuint program,
                                                  GLuint index,
                                                  GLsizei bufSize,
@@ -7188,7 +6574,6 @@
                                            size, type, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetTranslatedShaderSourceANGLEFn(GLuint shader,
                                                     GLsizei bufsize,
                                                     GLsizei* length,
@@ -7198,14 +6583,12 @@
   gl_api_->glGetTranslatedShaderSourceANGLEFn(shader, bufsize, length, source);
 }
 
-DISABLE_CFI_ICALL
 GLuint TraceGLApi::glGetUniformBlockIndexFn(GLuint program,
                                             const char* uniformBlockName) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformBlockIndex")
   return gl_api_->glGetUniformBlockIndexFn(program, uniformBlockName);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetUniformfvFn(GLuint program,
                                   GLint location,
                                   GLfloat* params) {
@@ -7213,7 +6596,6 @@
   gl_api_->glGetUniformfvFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetUniformfvRobustANGLEFn(GLuint program,
                                              GLint location,
                                              GLsizei bufSize,
@@ -7224,7 +6606,6 @@
                                        params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetUniformIndicesFn(GLuint program,
                                        GLsizei uniformCount,
                                        const char* const* uniformNames,
@@ -7234,7 +6615,6 @@
                                  uniformIndices);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetUniformivFn(GLuint program,
                                   GLint location,
                                   GLint* params) {
@@ -7242,7 +6622,6 @@
   gl_api_->glGetUniformivFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetUniformivRobustANGLEFn(GLuint program,
                                              GLint location,
                                              GLsizei bufSize,
@@ -7253,13 +6632,11 @@
                                        params);
 }
 
-DISABLE_CFI_ICALL
 GLint TraceGLApi::glGetUniformLocationFn(GLuint program, const char* name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glGetUniformLocation")
   return gl_api_->glGetUniformLocationFn(program, name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetUniformuivFn(GLuint program,
                                    GLint location,
                                    GLuint* params) {
@@ -7267,7 +6644,6 @@
   gl_api_->glGetUniformuivFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetUniformuivRobustANGLEFn(GLuint program,
                                               GLint location,
                                               GLsizei bufSize,
@@ -7278,7 +6654,6 @@
                                         params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetVertexAttribfvFn(GLuint index,
                                        GLenum pname,
                                        GLfloat* params) {
@@ -7286,7 +6661,6 @@
   gl_api_->glGetVertexAttribfvFn(index, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetVertexAttribfvRobustANGLEFn(GLuint index,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -7298,7 +6672,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetVertexAttribIivRobustANGLEFn(GLuint index,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -7310,7 +6683,6 @@
                                              params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetVertexAttribIuivRobustANGLEFn(GLuint index,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -7322,7 +6694,6 @@
                                               params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetVertexAttribivFn(GLuint index,
                                        GLenum pname,
                                        GLint* params) {
@@ -7330,7 +6701,6 @@
   gl_api_->glGetVertexAttribivFn(index, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetVertexAttribivRobustANGLEFn(GLuint index,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -7342,7 +6712,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetVertexAttribPointervFn(GLuint index,
                                              GLenum pname,
                                              void** pointer) {
@@ -7350,7 +6719,6 @@
   gl_api_->glGetVertexAttribPointervFn(index, pname, pointer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glGetVertexAttribPointervRobustANGLEFn(GLuint index,
                                                         GLenum pname,
                                                         GLsizei bufSize,
@@ -7362,19 +6730,16 @@
                                                   pointer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glHintFn(GLenum target, GLenum mode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glHint")
   gl_api_->glHintFn(target, mode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glInsertEventMarkerEXTFn(GLsizei length, const char* marker) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glInsertEventMarkerEXT")
   gl_api_->glInsertEventMarkerEXTFn(length, marker);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glInvalidateFramebufferFn(GLenum target,
                                            GLsizei numAttachments,
                                            const GLenum* attachments) {
@@ -7382,7 +6747,6 @@
   gl_api_->glInvalidateFramebufferFn(target, numAttachments, attachments);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glInvalidateSubFramebufferFn(GLenum target,
                                               GLsizei numAttachments,
                                               const GLenum* attachments,
@@ -7395,115 +6759,96 @@
                                         y, width, height);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsBufferFn(GLuint buffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsBuffer")
   return gl_api_->glIsBufferFn(buffer);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsEnabledFn(GLenum cap) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsEnabled")
   return gl_api_->glIsEnabledFn(cap);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsFenceAPPLEFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFenceAPPLE")
   return gl_api_->glIsFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsFenceNVFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFenceNV")
   return gl_api_->glIsFenceNVFn(fence);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsFramebufferEXT")
   return gl_api_->glIsFramebufferEXTFn(framebuffer);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsPathNVFn(GLuint path) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsPathNV")
   return gl_api_->glIsPathNVFn(path);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsProgram")
   return gl_api_->glIsProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsQueryFn(GLuint query) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsQuery")
   return gl_api_->glIsQueryFn(query);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsRenderbufferEXTFn(GLuint renderbuffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsRenderbufferEXT")
   return gl_api_->glIsRenderbufferEXTFn(renderbuffer);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsSamplerFn(GLuint sampler) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsSampler")
   return gl_api_->glIsSamplerFn(sampler);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsShaderFn(GLuint shader) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsShader")
   return gl_api_->glIsShaderFn(shader);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsSyncFn(GLsync sync) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsSync")
   return gl_api_->glIsSyncFn(sync);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsTextureFn(GLuint texture) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsTexture")
   return gl_api_->glIsTextureFn(texture);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsTransformFeedbackFn(GLuint id) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsTransformFeedback")
   return gl_api_->glIsTransformFeedbackFn(id);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glIsVertexArrayOESFn(GLuint array) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glIsVertexArrayOES")
   return gl_api_->glIsVertexArrayOESFn(array);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glLineWidthFn(GLfloat width) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glLineWidth")
   gl_api_->glLineWidthFn(width);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glLinkProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glLinkProgram")
   gl_api_->glLinkProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void* TraceGLApi::glMapBufferFn(GLenum target, GLenum access) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMapBuffer")
   return gl_api_->glMapBufferFn(target, access);
 }
 
-DISABLE_CFI_ICALL
 void* TraceGLApi::glMapBufferRangeFn(GLenum target,
                                      GLintptr offset,
                                      GLsizeiptr length,
@@ -7512,25 +6857,21 @@
   return gl_api_->glMapBufferRangeFn(target, offset, length, access);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMatrixLoadfEXT")
   gl_api_->glMatrixLoadfEXTFn(matrixMode, m);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMatrixLoadIdentityEXT")
   gl_api_->glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glMemoryBarrierEXTFn(GLbitfield barriers) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glMemoryBarrierEXT")
   gl_api_->glMemoryBarrierEXTFn(barriers);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glObjectLabelFn(GLenum identifier,
                                  GLuint name,
                                  GLsizei length,
@@ -7539,7 +6880,6 @@
   gl_api_->glObjectLabelFn(identifier, name, length, label);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glObjectPtrLabelFn(void* ptr,
                                     GLsizei length,
                                     const char* label) {
@@ -7547,7 +6887,6 @@
   gl_api_->glObjectPtrLabelFn(ptr, length, label);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPathCommandsNVFn(GLuint path,
                                     GLsizei numCommands,
                                     const GLubyte* commands,
@@ -7559,7 +6898,6 @@
                               coords);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPathParameterfNVFn(GLuint path,
                                       GLenum pname,
                                       GLfloat value) {
@@ -7567,67 +6905,56 @@
   gl_api_->glPathParameterfNVFn(path, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathParameteriNV")
   gl_api_->glPathParameteriNVFn(path, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPathStencilFuncNV")
   gl_api_->glPathStencilFuncNVFn(func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPauseTransformFeedbackFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPauseTransformFeedback")
   gl_api_->glPauseTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPixelStoreiFn(GLenum pname, GLint param) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPixelStorei")
   gl_api_->glPixelStoreiFn(pname, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPointParameteriFn(GLenum pname, GLint param) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPointParameteri")
   gl_api_->glPointParameteriFn(pname, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPolygonModeFn(GLenum face, GLenum mode) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPolygonMode")
   gl_api_->glPolygonModeFn(face, mode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPolygonOffsetFn(GLfloat factor, GLfloat units) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPolygonOffset")
   gl_api_->glPolygonOffsetFn(factor, units);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPopDebugGroupFn() {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPopDebugGroup")
   gl_api_->glPopDebugGroupFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPopGroupMarkerEXTFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPopGroupMarkerEXT")
   gl_api_->glPopGroupMarkerEXTFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPrimitiveRestartIndexFn(GLuint index) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPrimitiveRestartIndex")
   gl_api_->glPrimitiveRestartIndexFn(index);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glProgramBinaryFn(GLuint program,
                                    GLenum binaryFormat,
                                    const GLvoid* binary,
@@ -7636,7 +6963,6 @@
   gl_api_->glProgramBinaryFn(program, binaryFormat, binary, length);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glProgramParameteriFn(GLuint program,
                                        GLenum pname,
                                        GLint value) {
@@ -7644,7 +6970,6 @@
   gl_api_->glProgramParameteriFn(program, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glProgramPathFragmentInputGenNVFn(GLuint program,
                                                    GLint location,
                                                    GLenum genMode,
@@ -7656,7 +6981,6 @@
                                              components, coeffs);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPushDebugGroupFn(GLenum source,
                                     GLuint id,
                                     GLsizei length,
@@ -7665,25 +6989,21 @@
   gl_api_->glPushDebugGroupFn(source, id, length, message);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glPushGroupMarkerEXT")
   gl_api_->glPushGroupMarkerEXTFn(length, marker);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glQueryCounterFn(GLuint id, GLenum target) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glQueryCounter")
   gl_api_->glQueryCounterFn(id, target);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glReadBufferFn(GLenum src) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glReadBuffer")
   gl_api_->glReadBufferFn(src);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glReadnPixelsRobustANGLEFn(GLint x,
                                             GLint y,
                                             GLsizei width,
@@ -7700,7 +7020,6 @@
                                       bufSize, length, columns, rows, data);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glReadPixelsFn(GLint x,
                                 GLint y,
                                 GLsizei width,
@@ -7712,7 +7031,6 @@
   gl_api_->glReadPixelsFn(x, y, width, height, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glReadPixelsRobustANGLEFn(GLint x,
                                            GLint y,
                                            GLsizei width,
@@ -7729,13 +7047,11 @@
                                      length, columns, rows, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glReleaseShaderCompilerFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glReleaseShaderCompiler")
   gl_api_->glReleaseShaderCompilerFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glRenderbufferStorageEXTFn(GLenum target,
                                             GLenum internalformat,
                                             GLsizei width,
@@ -7744,7 +7060,6 @@
   gl_api_->glRenderbufferStorageEXTFn(target, internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glRenderbufferStorageMultisampleFn(GLenum target,
                                                     GLsizei samples,
                                                     GLenum internalformat,
@@ -7756,7 +7071,6 @@
                                               width, height);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glRenderbufferStorageMultisampleEXTFn(GLenum target,
                                                        GLsizei samples,
                                                        GLenum internalformat,
@@ -7768,25 +7082,21 @@
                                                  internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glRequestExtensionANGLEFn(const char* name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glRequestExtensionANGLE")
   gl_api_->glRequestExtensionANGLEFn(name);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glResumeTransformFeedbackFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glResumeTransformFeedback")
   gl_api_->glResumeTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSampleCoverageFn(GLclampf value, GLboolean invert) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSampleCoverage")
   gl_api_->glSampleCoverageFn(value, invert);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSamplerParameterfFn(GLuint sampler,
                                        GLenum pname,
                                        GLfloat param) {
@@ -7794,7 +7104,6 @@
   gl_api_->glSamplerParameterfFn(sampler, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSamplerParameterfvFn(GLuint sampler,
                                         GLenum pname,
                                         const GLfloat* params) {
@@ -7802,7 +7111,6 @@
   gl_api_->glSamplerParameterfvFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSamplerParameterfvRobustANGLEFn(GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -7812,7 +7120,6 @@
   gl_api_->glSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSamplerParameteriFn(GLuint sampler,
                                        GLenum pname,
                                        GLint param) {
@@ -7820,7 +7127,6 @@
   gl_api_->glSamplerParameteriFn(sampler, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSamplerParameterIivRobustANGLEFn(GLuint sampler,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -7830,7 +7136,6 @@
   gl_api_->glSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSamplerParameterIuivRobustANGLEFn(GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
@@ -7840,7 +7145,6 @@
   gl_api_->glSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSamplerParameterivFn(GLuint sampler,
                                         GLenum pname,
                                         const GLint* params) {
@@ -7848,7 +7152,6 @@
   gl_api_->glSamplerParameterivFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSamplerParameterivRobustANGLEFn(GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -7858,25 +7161,21 @@
   gl_api_->glSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glScissorFn(GLint x, GLint y, GLsizei width, GLsizei height) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glScissor")
   gl_api_->glScissorFn(x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSetFenceAPPLEFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSetFenceAPPLE")
   gl_api_->glSetFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glSetFenceNVFn(GLuint fence, GLenum condition) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glSetFenceNV")
   gl_api_->glSetFenceNVFn(fence, condition);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glShaderBinaryFn(GLsizei n,
                                   const GLuint* shaders,
                                   GLenum binaryformat,
@@ -7886,7 +7185,6 @@
   gl_api_->glShaderBinaryFn(n, shaders, binaryformat, binary, length);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glShaderSourceFn(GLuint shader,
                                   GLsizei count,
                                   const char* const* str,
@@ -7895,7 +7193,6 @@
   gl_api_->glShaderSourceFn(shader, count, str, length);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilFillPathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -7912,7 +7209,6 @@
                                           transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilFillPathNVFn(GLuint path,
                                        GLenum fillMode,
                                        GLuint mask) {
@@ -7920,13 +7216,11 @@
   gl_api_->glStencilFillPathNVFn(path, fillMode, mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilFunc")
   gl_api_->glStencilFuncFn(func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilFuncSeparateFn(GLenum face,
                                          GLenum func,
                                          GLint ref,
@@ -7935,25 +7229,21 @@
   gl_api_->glStencilFuncSeparateFn(face, func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilMaskFn(GLuint mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilMask")
   gl_api_->glStencilMaskFn(mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilMaskSeparateFn(GLenum face, GLuint mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilMaskSeparate")
   gl_api_->glStencilMaskSeparateFn(face, mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilOpFn(GLenum fail, GLenum zfail, GLenum zpass) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glStencilOp")
   gl_api_->glStencilOpFn(fail, zfail, zpass);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilOpSeparateFn(GLenum face,
                                        GLenum fail,
                                        GLenum zfail,
@@ -7962,7 +7252,6 @@
   gl_api_->glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilStrokePathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -7979,7 +7268,6 @@
                                             transformValues);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilStrokePathNVFn(GLuint path,
                                          GLint reference,
                                          GLuint mask) {
@@ -7987,7 +7275,6 @@
   gl_api_->glStencilStrokePathNVFn(path, reference, mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilThenCoverFillPathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -8005,7 +7292,6 @@
       transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
                                                 GLenum fillMode,
                                                 GLuint mask,
@@ -8015,7 +7301,6 @@
   gl_api_->glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilThenCoverStrokePathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -8033,7 +7318,6 @@
       transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glStencilThenCoverStrokePathNVFn(GLuint path,
                                                   GLint reference,
                                                   GLuint mask,
@@ -8043,19 +7327,16 @@
   gl_api_->glStencilThenCoverStrokePathNVFn(path, reference, mask, coverMode);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glTestFenceAPPLEFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTestFenceAPPLE")
   return gl_api_->glTestFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glTestFenceNVFn(GLuint fence) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTestFenceNV")
   return gl_api_->glTestFenceNVFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexBufferFn(GLenum target,
                                GLenum internalformat,
                                GLuint buffer) {
@@ -8063,7 +7344,6 @@
   gl_api_->glTexBufferFn(target, internalformat, buffer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexBufferRangeFn(GLenum target,
                                     GLenum internalformat,
                                     GLuint buffer,
@@ -8073,7 +7353,6 @@
   gl_api_->glTexBufferRangeFn(target, internalformat, buffer, offset, size);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexImage2DFn(GLenum target,
                                 GLint level,
                                 GLint internalformat,
@@ -8088,7 +7367,6 @@
                           format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexImage2DRobustANGLEFn(GLenum target,
                                            GLint level,
                                            GLint internalformat,
@@ -8105,7 +7383,6 @@
                                      pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexImage3DFn(GLenum target,
                                 GLint level,
                                 GLint internalformat,
@@ -8121,7 +7398,6 @@
                           border, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexImage3DRobustANGLEFn(GLenum target,
                                            GLint level,
                                            GLint internalformat,
@@ -8139,13 +7415,11 @@
                                      bufSize, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexParameterfFn(GLenum target, GLenum pname, GLfloat param) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexParameterf")
   gl_api_->glTexParameterfFn(target, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexParameterfvFn(GLenum target,
                                     GLenum pname,
                                     const GLfloat* params) {
@@ -8153,7 +7427,6 @@
   gl_api_->glTexParameterfvFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexParameterfvRobustANGLEFn(GLenum target,
                                                GLenum pname,
                                                GLsizei bufSize,
@@ -8163,13 +7436,11 @@
   gl_api_->glTexParameterfvRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexParameteriFn(GLenum target, GLenum pname, GLint param) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glTexParameteri")
   gl_api_->glTexParameteriFn(target, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexParameterIivRobustANGLEFn(GLenum target,
                                                 GLenum pname,
                                                 GLsizei bufSize,
@@ -8179,7 +7450,6 @@
   gl_api_->glTexParameterIivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexParameterIuivRobustANGLEFn(GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -8189,7 +7459,6 @@
   gl_api_->glTexParameterIuivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexParameterivFn(GLenum target,
                                     GLenum pname,
                                     const GLint* params) {
@@ -8197,7 +7466,6 @@
   gl_api_->glTexParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexParameterivRobustANGLEFn(GLenum target,
                                                GLenum pname,
                                                GLsizei bufSize,
@@ -8207,7 +7475,6 @@
   gl_api_->glTexParameterivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexStorage2DEXTFn(GLenum target,
                                      GLsizei levels,
                                      GLenum internalformat,
@@ -8217,7 +7484,6 @@
   gl_api_->glTexStorage2DEXTFn(target, levels, internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexStorage3DFn(GLenum target,
                                   GLsizei levels,
                                   GLenum internalformat,
@@ -8229,7 +7495,6 @@
                             depth);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexSubImage2DFn(GLenum target,
                                    GLint level,
                                    GLint xoffset,
@@ -8244,7 +7509,6 @@
                              format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexSubImage2DRobustANGLEFn(GLenum target,
                                               GLint level,
                                               GLint xoffset,
@@ -8260,7 +7524,6 @@
                                         height, format, type, bufSize, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexSubImage3DFn(GLenum target,
                                    GLint level,
                                    GLint xoffset,
@@ -8277,7 +7540,6 @@
                              height, depth, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTexSubImage3DRobustANGLEFn(GLenum target,
                                               GLint level,
                                               GLint xoffset,
@@ -8296,7 +7558,6 @@
                                         type, bufSize, pixels);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glTransformFeedbackVaryingsFn(GLuint program,
                                                GLsizei count,
                                                const char* const* varyings,
@@ -8306,13 +7567,11 @@
   gl_api_->glTransformFeedbackVaryingsFn(program, count, varyings, bufferMode);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform1fFn(GLint location, GLfloat x) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1f")
   gl_api_->glUniform1fFn(location, x);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform1fvFn(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
@@ -8320,25 +7579,21 @@
   gl_api_->glUniform1fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform1iFn(GLint location, GLint x) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1i")
   gl_api_->glUniform1iFn(location, x);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform1ivFn(GLint location, GLsizei count, const GLint* v) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1iv")
   gl_api_->glUniform1ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform1uiFn(GLint location, GLuint v0) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform1ui")
   gl_api_->glUniform1uiFn(location, v0);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform1uivFn(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
@@ -8346,13 +7601,11 @@
   gl_api_->glUniform1uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform2fFn(GLint location, GLfloat x, GLfloat y) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2f")
   gl_api_->glUniform2fFn(location, x, y);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform2fvFn(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
@@ -8360,25 +7613,21 @@
   gl_api_->glUniform2fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform2iFn(GLint location, GLint x, GLint y) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2i")
   gl_api_->glUniform2iFn(location, x, y);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform2ivFn(GLint location, GLsizei count, const GLint* v) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2iv")
   gl_api_->glUniform2ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform2uiFn(GLint location, GLuint v0, GLuint v1) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform2ui")
   gl_api_->glUniform2uiFn(location, v0, v1);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform2uivFn(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
@@ -8386,7 +7635,6 @@
   gl_api_->glUniform2uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform3fFn(GLint location,
                                GLfloat x,
                                GLfloat y,
@@ -8395,7 +7643,6 @@
   gl_api_->glUniform3fFn(location, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform3fvFn(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
@@ -8403,19 +7650,16 @@
   gl_api_->glUniform3fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform3iFn(GLint location, GLint x, GLint y, GLint z) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform3i")
   gl_api_->glUniform3iFn(location, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform3ivFn(GLint location, GLsizei count, const GLint* v) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform3iv")
   gl_api_->glUniform3ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform3uiFn(GLint location,
                                 GLuint v0,
                                 GLuint v1,
@@ -8424,7 +7668,6 @@
   gl_api_->glUniform3uiFn(location, v0, v1, v2);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform3uivFn(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
@@ -8432,7 +7675,6 @@
   gl_api_->glUniform3uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform4fFn(GLint location,
                                GLfloat x,
                                GLfloat y,
@@ -8442,7 +7684,6 @@
   gl_api_->glUniform4fFn(location, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform4fvFn(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
@@ -8450,7 +7691,6 @@
   gl_api_->glUniform4fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform4iFn(GLint location,
                                GLint x,
                                GLint y,
@@ -8460,13 +7700,11 @@
   gl_api_->glUniform4iFn(location, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform4ivFn(GLint location, GLsizei count, const GLint* v) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUniform4iv")
   gl_api_->glUniform4ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform4uiFn(GLint location,
                                 GLuint v0,
                                 GLuint v1,
@@ -8476,7 +7714,6 @@
   gl_api_->glUniform4uiFn(location, v0, v1, v2, v3);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniform4uivFn(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
@@ -8484,7 +7721,6 @@
   gl_api_->glUniform4uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformBlockBindingFn(GLuint program,
                                          GLuint uniformBlockIndex,
                                          GLuint uniformBlockBinding) {
@@ -8493,7 +7729,6 @@
                                    uniformBlockBinding);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix2fvFn(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
@@ -8502,7 +7737,6 @@
   gl_api_->glUniformMatrix2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix2x3fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -8511,7 +7745,6 @@
   gl_api_->glUniformMatrix2x3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix2x4fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -8520,7 +7753,6 @@
   gl_api_->glUniformMatrix2x4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix3fvFn(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
@@ -8529,7 +7761,6 @@
   gl_api_->glUniformMatrix3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix3x2fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -8538,7 +7769,6 @@
   gl_api_->glUniformMatrix3x2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix3x4fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -8547,7 +7777,6 @@
   gl_api_->glUniformMatrix3x4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix4fvFn(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
@@ -8556,7 +7785,6 @@
   gl_api_->glUniformMatrix4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix4x2fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -8565,7 +7793,6 @@
   gl_api_->glUniformMatrix4x2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUniformMatrix4x3fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -8574,49 +7801,41 @@
   gl_api_->glUniformMatrix4x3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceGLApi::glUnmapBufferFn(GLenum target) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUnmapBuffer")
   return gl_api_->glUnmapBufferFn(target);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glUseProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glUseProgram")
   gl_api_->glUseProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glValidateProgramFn(GLuint program) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glValidateProgram")
   gl_api_->glValidateProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttrib1fFn(GLuint indx, GLfloat x) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib1f")
   gl_api_->glVertexAttrib1fFn(indx, x);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttrib1fvFn(GLuint indx, const GLfloat* values) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib1fv")
   gl_api_->glVertexAttrib1fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttrib2fFn(GLuint indx, GLfloat x, GLfloat y) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib2f")
   gl_api_->glVertexAttrib2fFn(indx, x, y);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttrib2fvFn(GLuint indx, const GLfloat* values) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib2fv")
   gl_api_->glVertexAttrib2fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttrib3fFn(GLuint indx,
                                     GLfloat x,
                                     GLfloat y,
@@ -8625,13 +7844,11 @@
   gl_api_->glVertexAttrib3fFn(indx, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttrib3fvFn(GLuint indx, const GLfloat* values) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib3fv")
   gl_api_->glVertexAttrib3fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttrib4fFn(GLuint indx,
                                     GLfloat x,
                                     GLfloat y,
@@ -8641,19 +7858,16 @@
   gl_api_->glVertexAttrib4fFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttrib4fvFn(GLuint indx, const GLfloat* values) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttrib4fv")
   gl_api_->glVertexAttrib4fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttribDivisorANGLEFn(GLuint index, GLuint divisor) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribDivisorANGLE")
   gl_api_->glVertexAttribDivisorANGLEFn(index, divisor);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttribI4iFn(GLuint indx,
                                      GLint x,
                                      GLint y,
@@ -8663,13 +7877,11 @@
   gl_api_->glVertexAttribI4iFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttribI4ivFn(GLuint indx, const GLint* values) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribI4iv")
   gl_api_->glVertexAttribI4ivFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttribI4uiFn(GLuint indx,
                                       GLuint x,
                                       GLuint y,
@@ -8679,13 +7891,11 @@
   gl_api_->glVertexAttribI4uiFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttribI4uivFn(GLuint indx, const GLuint* values) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glVertexAttribI4uiv")
   gl_api_->glVertexAttribI4uivFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttribIPointerFn(GLuint indx,
                                           GLint size,
                                           GLenum type,
@@ -8695,7 +7905,6 @@
   gl_api_->glVertexAttribIPointerFn(indx, size, type, stride, ptr);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glVertexAttribPointerFn(GLuint indx,
                                          GLint size,
                                          GLenum type,
@@ -8706,19 +7915,16 @@
   gl_api_->glVertexAttribPointerFn(indx, size, type, normalized, stride, ptr);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glViewportFn(GLint x, GLint y, GLsizei width, GLsizei height) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glViewport")
   gl_api_->glViewportFn(x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glWaitSyncFn(GLsync sync, GLbitfield flags, GLuint64 timeout) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glWaitSync")
   gl_api_->glWaitSyncFn(sync, flags, timeout);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLApi::glWindowRectanglesEXTFn(GLenum mode,
                                          GLsizei n,
                                          const GLint* box) {
@@ -8726,14 +7932,12 @@
   gl_api_->glWindowRectanglesEXTFn(mode, n, box);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glActiveTextureFn(GLenum texture) {
   GL_SERVICE_LOG("glActiveTexture"
                  << "(" << GLEnums::GetStringEnum(texture) << ")");
   gl_api_->glActiveTextureFn(texture);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glApplyFramebufferAttachmentCMAAINTELFn(void) {
   GL_SERVICE_LOG("glApplyFramebufferAttachmentCMAAINTEL"
                  << "("
@@ -8741,28 +7945,24 @@
   gl_api_->glApplyFramebufferAttachmentCMAAINTELFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glAttachShaderFn(GLuint program, GLuint shader) {
   GL_SERVICE_LOG("glAttachShader"
                  << "(" << program << ", " << shader << ")");
   gl_api_->glAttachShaderFn(program, shader);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBeginQueryFn(GLenum target, GLuint id) {
   GL_SERVICE_LOG("glBeginQuery"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
   gl_api_->glBeginQueryFn(target, id);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBeginTransformFeedbackFn(GLenum primitiveMode) {
   GL_SERVICE_LOG("glBeginTransformFeedback"
                  << "(" << GLEnums::GetStringEnum(primitiveMode) << ")");
   gl_api_->glBeginTransformFeedbackFn(primitiveMode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindAttribLocationFn(GLuint program,
                                         GLuint index,
                                         const char* name) {
@@ -8771,7 +7971,6 @@
   gl_api_->glBindAttribLocationFn(program, index, name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindBufferFn(GLenum target, GLuint buffer) {
   GL_SERVICE_LOG("glBindBuffer"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << buffer
@@ -8779,7 +7978,6 @@
   gl_api_->glBindBufferFn(target, buffer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindBufferBaseFn(GLenum target,
                                     GLuint index,
                                     GLuint buffer) {
@@ -8789,7 +7987,6 @@
   gl_api_->glBindBufferBaseFn(target, index, buffer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindBufferRangeFn(GLenum target,
                                      GLuint index,
                                      GLuint buffer,
@@ -8801,7 +7998,6 @@
   gl_api_->glBindBufferRangeFn(target, index, buffer, offset, size);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindFragDataLocationFn(GLuint program,
                                           GLuint colorNumber,
                                           const char* name) {
@@ -8811,7 +8007,6 @@
   gl_api_->glBindFragDataLocationFn(program, colorNumber, name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindFragDataLocationIndexedFn(GLuint program,
                                                  GLuint colorNumber,
                                                  GLuint index,
@@ -8822,7 +8017,6 @@
   gl_api_->glBindFragDataLocationIndexedFn(program, colorNumber, index, name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindFramebufferEXTFn(GLenum target, GLuint framebuffer) {
   GL_SERVICE_LOG("glBindFramebufferEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << framebuffer
@@ -8830,7 +8024,6 @@
   gl_api_->glBindFramebufferEXTFn(target, framebuffer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindImageTextureEXTFn(GLuint index,
                                          GLuint texture,
                                          GLint level,
@@ -8846,7 +8039,6 @@
                                    access, format);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindRenderbufferEXTFn(GLenum target, GLuint renderbuffer) {
   GL_SERVICE_LOG("glBindRenderbufferEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
@@ -8854,14 +8046,12 @@
   gl_api_->glBindRenderbufferEXTFn(target, renderbuffer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindSamplerFn(GLuint unit, GLuint sampler) {
   GL_SERVICE_LOG("glBindSampler"
                  << "(" << unit << ", " << sampler << ")");
   gl_api_->glBindSamplerFn(unit, sampler);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindTextureFn(GLenum target, GLuint texture) {
   GL_SERVICE_LOG("glBindTexture"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << texture
@@ -8869,14 +8059,12 @@
   gl_api_->glBindTextureFn(target, texture);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindTransformFeedbackFn(GLenum target, GLuint id) {
   GL_SERVICE_LOG("glBindTransformFeedback"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << id << ")");
   gl_api_->glBindTransformFeedbackFn(target, id);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindUniformLocationCHROMIUMFn(GLuint program,
                                                  GLint location,
                                                  const char* name) {
@@ -8885,14 +8073,12 @@
   gl_api_->glBindUniformLocationCHROMIUMFn(program, location, name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBindVertexArrayOESFn(GLuint array) {
   GL_SERVICE_LOG("glBindVertexArrayOES"
                  << "(" << array << ")");
   gl_api_->glBindVertexArrayOESFn(array);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBlendBarrierKHRFn(void) {
   GL_SERVICE_LOG("glBlendBarrierKHR"
                  << "("
@@ -8900,7 +8086,6 @@
   gl_api_->glBlendBarrierKHRFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBlendColorFn(GLclampf red,
                                 GLclampf green,
                                 GLclampf blue,
@@ -8911,14 +8096,12 @@
   gl_api_->glBlendColorFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBlendEquationFn(GLenum mode) {
   GL_SERVICE_LOG("glBlendEquation"
                  << "(" << GLEnums::GetStringEnum(mode) << ")");
   gl_api_->glBlendEquationFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBlendEquationSeparateFn(GLenum modeRGB, GLenum modeAlpha) {
   GL_SERVICE_LOG("glBlendEquationSeparate"
                  << "(" << GLEnums::GetStringEnum(modeRGB) << ", "
@@ -8926,7 +8109,6 @@
   gl_api_->glBlendEquationSeparateFn(modeRGB, modeAlpha);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBlendFuncFn(GLenum sfactor, GLenum dfactor) {
   GL_SERVICE_LOG("glBlendFunc"
                  << "(" << GLEnums::GetStringEnum(sfactor) << ", "
@@ -8934,7 +8116,6 @@
   gl_api_->glBlendFuncFn(sfactor, dfactor);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBlendFuncSeparateFn(GLenum srcRGB,
                                        GLenum dstRGB,
                                        GLenum srcAlpha,
@@ -8947,7 +8128,6 @@
   gl_api_->glBlendFuncSeparateFn(srcRGB, dstRGB, srcAlpha, dstAlpha);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBlitFramebufferFn(GLint srcX0,
                                      GLint srcY0,
                                      GLint srcX1,
@@ -8967,7 +8147,6 @@
                                dstY1, mask, filter);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBufferDataFn(GLenum target,
                                 GLsizeiptr size,
                                 const void* data,
@@ -8979,7 +8158,6 @@
   gl_api_->glBufferDataFn(target, size, data, usage);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glBufferSubDataFn(GLenum target,
                                    GLintptr offset,
                                    GLsizeiptr size,
@@ -8991,7 +8169,6 @@
   gl_api_->glBufferSubDataFn(target, offset, size, data);
 }
 
-DISABLE_CFI_ICALL
 GLenum DebugGLApi::glCheckFramebufferStatusEXTFn(GLenum target) {
   GL_SERVICE_LOG("glCheckFramebufferStatusEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ")");
@@ -9002,14 +8179,12 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearFn(GLbitfield mask) {
   GL_SERVICE_LOG("glClear"
                  << "(" << mask << ")");
   gl_api_->glClearFn(mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearBufferfiFn(GLenum buffer,
                                    GLint drawbuffer,
                                    const GLfloat depth,
@@ -9020,7 +8195,6 @@
   gl_api_->glClearBufferfiFn(buffer, drawbuffer, depth, stencil);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearBufferfvFn(GLenum buffer,
                                    GLint drawbuffer,
                                    const GLfloat* value) {
@@ -9030,7 +8204,6 @@
   gl_api_->glClearBufferfvFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearBufferivFn(GLenum buffer,
                                    GLint drawbuffer,
                                    const GLint* value) {
@@ -9040,7 +8213,6 @@
   gl_api_->glClearBufferivFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearBufferuivFn(GLenum buffer,
                                     GLint drawbuffer,
                                     const GLuint* value) {
@@ -9050,7 +8222,6 @@
   gl_api_->glClearBufferuivFn(buffer, drawbuffer, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearColorFn(GLclampf red,
                                 GLclampf green,
                                 GLclampf blue,
@@ -9061,28 +8232,24 @@
   gl_api_->glClearColorFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearDepthFn(GLclampd depth) {
   GL_SERVICE_LOG("glClearDepth"
                  << "(" << depth << ")");
   gl_api_->glClearDepthFn(depth);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearDepthfFn(GLclampf depth) {
   GL_SERVICE_LOG("glClearDepthf"
                  << "(" << depth << ")");
   gl_api_->glClearDepthfFn(depth);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glClearStencilFn(GLint s) {
   GL_SERVICE_LOG("glClearStencil"
                  << "(" << s << ")");
   gl_api_->glClearStencilFn(s);
 }
 
-DISABLE_CFI_ICALL
 GLenum DebugGLApi::glClientWaitSyncFn(GLsync sync,
                                       GLbitfield flags,
                                       GLuint64 timeout) {
@@ -9093,7 +8260,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glColorMaskFn(GLboolean red,
                                GLboolean green,
                                GLboolean blue,
@@ -9106,14 +8272,12 @@
   gl_api_->glColorMaskFn(red, green, blue, alpha);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompileShaderFn(GLuint shader) {
   GL_SERVICE_LOG("glCompileShader"
                  << "(" << shader << ")");
   gl_api_->glCompileShaderFn(shader);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedCopyTextureCHROMIUMFn(GLuint sourceId,
                                                    GLuint destId) {
   GL_SERVICE_LOG("glCompressedCopyTextureCHROMIUM"
@@ -9121,7 +8285,6 @@
   gl_api_->glCompressedCopyTextureCHROMIUMFn(sourceId, destId);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedTexImage2DFn(GLenum target,
                                           GLint level,
                                           GLenum internalformat,
@@ -9139,7 +8302,6 @@
                                     height, border, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedTexImage2DRobustANGLEFn(GLenum target,
                                                      GLint level,
                                                      GLenum internalformat,
@@ -9160,7 +8322,6 @@
                                                dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedTexImage3DFn(GLenum target,
                                           GLint level,
                                           GLenum internalformat,
@@ -9180,7 +8341,6 @@
                                     height, depth, border, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedTexImage3DRobustANGLEFn(GLenum target,
                                                      GLint level,
                                                      GLenum internalformat,
@@ -9202,7 +8362,6 @@
                                                imageSize, dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedTexSubImage2DFn(GLenum target,
                                              GLint level,
                                              GLint xoffset,
@@ -9221,7 +8380,6 @@
                                        height, format, imageSize, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedTexSubImage2DRobustANGLEFn(GLenum target,
                                                         GLint level,
                                                         GLint xoffset,
@@ -9243,7 +8401,6 @@
       dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedTexSubImage3DFn(GLenum target,
                                              GLint level,
                                              GLint xoffset,
@@ -9266,7 +8423,6 @@
                                        data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCompressedTexSubImage3DRobustANGLEFn(GLenum target,
                                                         GLint level,
                                                         GLint xoffset,
@@ -9290,7 +8446,6 @@
       imageSize, dataSize, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCopyBufferSubDataFn(GLenum readTarget,
                                        GLenum writeTarget,
                                        GLintptr readOffset,
@@ -9304,7 +8459,6 @@
                                  writeOffset, size);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCopySubTextureCHROMIUMFn(GLuint sourceId,
                                             GLint sourceLevel,
                                             GLenum destTarget,
@@ -9333,7 +8487,6 @@
       unpackUnmultiplyAlpha);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCopyTexImage2DFn(GLenum target,
                                     GLint level,
                                     GLenum internalformat,
@@ -9351,7 +8504,6 @@
                               height, border);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCopyTexSubImage2DFn(GLenum target,
                                        GLint level,
                                        GLint xoffset,
@@ -9368,7 +8520,6 @@
                                  height);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCopyTexSubImage3DFn(GLenum target,
                                        GLint level,
                                        GLint xoffset,
@@ -9387,7 +8538,6 @@
                                  width, height);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCopyTextureCHROMIUMFn(GLuint sourceId,
                                          GLint sourceLevel,
                                          GLenum destTarget,
@@ -9411,14 +8561,12 @@
       destType, unpackFlipY, unpackPremultiplyAlpha, unpackUnmultiplyAlpha);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCoverageModulationNVFn(GLenum components) {
   GL_SERVICE_LOG("glCoverageModulationNV"
                  << "(" << GLEnums::GetStringEnum(components) << ")");
   gl_api_->glCoverageModulationNVFn(components);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCoverFillPathInstancedNVFn(GLsizei numPaths,
                                               GLenum pathNameType,
                                               const void* paths,
@@ -9438,7 +8586,6 @@
                                         transformValues);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCoverFillPathNVFn(GLuint path, GLenum coverMode) {
   GL_SERVICE_LOG("glCoverFillPathNV"
                  << "(" << path << ", " << GLEnums::GetStringEnum(coverMode)
@@ -9446,7 +8593,6 @@
   gl_api_->glCoverFillPathNVFn(path, coverMode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCoverStrokePathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -9467,7 +8613,6 @@
                                           transformValues);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCoverStrokePathNVFn(GLuint name, GLenum coverMode) {
   GL_SERVICE_LOG("glCoverStrokePathNV"
                  << "(" << name << ", " << GLEnums::GetStringEnum(coverMode)
@@ -9475,7 +8620,6 @@
   gl_api_->glCoverStrokePathNVFn(name, coverMode);
 }
 
-DISABLE_CFI_ICALL
 GLuint DebugGLApi::glCreateProgramFn(void) {
   GL_SERVICE_LOG("glCreateProgram"
                  << "("
@@ -9485,7 +8629,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLuint DebugGLApi::glCreateShaderFn(GLenum type) {
   GL_SERVICE_LOG("glCreateShader"
                  << "(" << GLEnums::GetStringEnum(type) << ")");
@@ -9494,14 +8637,12 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glCullFaceFn(GLenum mode) {
   GL_SERVICE_LOG("glCullFace"
                  << "(" << GLEnums::GetStringEnum(mode) << ")");
   gl_api_->glCullFaceFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDebugMessageCallbackFn(GLDEBUGPROC callback,
                                           const void* userParam) {
   GL_SERVICE_LOG("glDebugMessageCallback"
@@ -9510,7 +8651,6 @@
   gl_api_->glDebugMessageCallbackFn(callback, userParam);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDebugMessageControlFn(GLenum source,
                                          GLenum type,
                                          GLenum severity,
@@ -9526,7 +8666,6 @@
   gl_api_->glDebugMessageControlFn(source, type, severity, count, ids, enabled);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDebugMessageInsertFn(GLenum source,
                                         GLenum type,
                                         GLuint id,
@@ -9541,7 +8680,6 @@
   gl_api_->glDebugMessageInsertFn(source, type, id, severity, length, buf);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteBuffersARBFn(GLsizei n, const GLuint* buffers) {
   GL_SERVICE_LOG("glDeleteBuffersARB"
                  << "(" << n << ", " << static_cast<const void*>(buffers)
@@ -9549,7 +8687,6 @@
   gl_api_->glDeleteBuffersARBFn(n, buffers);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteFencesAPPLEFn(GLsizei n, const GLuint* fences) {
   GL_SERVICE_LOG("glDeleteFencesAPPLE"
                  << "(" << n << ", " << static_cast<const void*>(fences)
@@ -9557,7 +8694,6 @@
   gl_api_->glDeleteFencesAPPLEFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteFencesNVFn(GLsizei n, const GLuint* fences) {
   GL_SERVICE_LOG("glDeleteFencesNV"
                  << "(" << n << ", " << static_cast<const void*>(fences)
@@ -9565,7 +8701,6 @@
   gl_api_->glDeleteFencesNVFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteFramebuffersEXTFn(GLsizei n,
                                            const GLuint* framebuffers) {
   GL_SERVICE_LOG("glDeleteFramebuffersEXT"
@@ -9574,28 +8709,24 @@
   gl_api_->glDeleteFramebuffersEXTFn(n, framebuffers);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeletePathsNVFn(GLuint path, GLsizei range) {
   GL_SERVICE_LOG("glDeletePathsNV"
                  << "(" << path << ", " << range << ")");
   gl_api_->glDeletePathsNVFn(path, range);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteProgramFn(GLuint program) {
   GL_SERVICE_LOG("glDeleteProgram"
                  << "(" << program << ")");
   gl_api_->glDeleteProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteQueriesFn(GLsizei n, const GLuint* ids) {
   GL_SERVICE_LOG("glDeleteQueries"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
   gl_api_->glDeleteQueriesFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteRenderbuffersEXTFn(GLsizei n,
                                             const GLuint* renderbuffers) {
   GL_SERVICE_LOG("glDeleteRenderbuffersEXT"
@@ -9604,7 +8735,6 @@
   gl_api_->glDeleteRenderbuffersEXTFn(n, renderbuffers);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteSamplersFn(GLsizei n, const GLuint* samplers) {
   GL_SERVICE_LOG("glDeleteSamplers"
                  << "(" << n << ", " << static_cast<const void*>(samplers)
@@ -9612,21 +8742,18 @@
   gl_api_->glDeleteSamplersFn(n, samplers);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteShaderFn(GLuint shader) {
   GL_SERVICE_LOG("glDeleteShader"
                  << "(" << shader << ")");
   gl_api_->glDeleteShaderFn(shader);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteSyncFn(GLsync sync) {
   GL_SERVICE_LOG("glDeleteSync"
                  << "(" << sync << ")");
   gl_api_->glDeleteSyncFn(sync);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteTexturesFn(GLsizei n, const GLuint* textures) {
   GL_SERVICE_LOG("glDeleteTextures"
                  << "(" << n << ", " << static_cast<const void*>(textures)
@@ -9634,14 +8761,12 @@
   gl_api_->glDeleteTexturesFn(n, textures);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteTransformFeedbacksFn(GLsizei n, const GLuint* ids) {
   GL_SERVICE_LOG("glDeleteTransformFeedbacks"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
   gl_api_->glDeleteTransformFeedbacksFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDeleteVertexArraysOESFn(GLsizei n, const GLuint* arrays) {
   GL_SERVICE_LOG("glDeleteVertexArraysOES"
                  << "(" << n << ", " << static_cast<const void*>(arrays)
@@ -9649,56 +8774,48 @@
   gl_api_->glDeleteVertexArraysOESFn(n, arrays);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDepthFuncFn(GLenum func) {
   GL_SERVICE_LOG("glDepthFunc"
                  << "(" << GLEnums::GetStringEnum(func) << ")");
   gl_api_->glDepthFuncFn(func);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDepthMaskFn(GLboolean flag) {
   GL_SERVICE_LOG("glDepthMask"
                  << "(" << GLEnums::GetStringBool(flag) << ")");
   gl_api_->glDepthMaskFn(flag);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDepthRangeFn(GLclampd zNear, GLclampd zFar) {
   GL_SERVICE_LOG("glDepthRange"
                  << "(" << zNear << ", " << zFar << ")");
   gl_api_->glDepthRangeFn(zNear, zFar);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDepthRangefFn(GLclampf zNear, GLclampf zFar) {
   GL_SERVICE_LOG("glDepthRangef"
                  << "(" << zNear << ", " << zFar << ")");
   gl_api_->glDepthRangefFn(zNear, zFar);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDetachShaderFn(GLuint program, GLuint shader) {
   GL_SERVICE_LOG("glDetachShader"
                  << "(" << program << ", " << shader << ")");
   gl_api_->glDetachShaderFn(program, shader);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDisableFn(GLenum cap) {
   GL_SERVICE_LOG("glDisable"
                  << "(" << GLEnums::GetStringEnum(cap) << ")");
   gl_api_->glDisableFn(cap);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDisableVertexAttribArrayFn(GLuint index) {
   GL_SERVICE_LOG("glDisableVertexAttribArray"
                  << "(" << index << ")");
   gl_api_->glDisableVertexAttribArrayFn(index);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDiscardFramebufferEXTFn(GLenum target,
                                            GLsizei numAttachments,
                                            const GLenum* attachments) {
@@ -9709,7 +8826,6 @@
   gl_api_->glDiscardFramebufferEXTFn(target, numAttachments, attachments);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDrawArraysFn(GLenum mode, GLint first, GLsizei count) {
   GL_SERVICE_LOG("glDrawArrays"
                  << "(" << GLEnums::GetStringEnum(mode) << ", " << first << ", "
@@ -9717,7 +8833,6 @@
   gl_api_->glDrawArraysFn(mode, first, count);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDrawArraysInstancedANGLEFn(GLenum mode,
                                               GLint first,
                                               GLsizei count,
@@ -9728,21 +8843,18 @@
   gl_api_->glDrawArraysInstancedANGLEFn(mode, first, count, primcount);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDrawBufferFn(GLenum mode) {
   GL_SERVICE_LOG("glDrawBuffer"
                  << "(" << GLEnums::GetStringEnum(mode) << ")");
   gl_api_->glDrawBufferFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDrawBuffersARBFn(GLsizei n, const GLenum* bufs) {
   GL_SERVICE_LOG("glDrawBuffersARB"
                  << "(" << n << ", " << static_cast<const void*>(bufs) << ")");
   gl_api_->glDrawBuffersARBFn(n, bufs);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDrawElementsFn(GLenum mode,
                                   GLsizei count,
                                   GLenum type,
@@ -9754,7 +8866,6 @@
   gl_api_->glDrawElementsFn(mode, count, type, indices);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDrawElementsInstancedANGLEFn(GLenum mode,
                                                 GLsizei count,
                                                 GLenum type,
@@ -9769,7 +8880,6 @@
                                           primcount);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glDrawRangeElementsFn(GLenum mode,
                                        GLuint start,
                                        GLuint end,
@@ -9783,7 +8893,6 @@
   gl_api_->glDrawRangeElementsFn(mode, start, end, count, type, indices);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glEGLImageTargetRenderbufferStorageOESFn(GLenum target,
                                                           GLeglImageOES image) {
   GL_SERVICE_LOG("glEGLImageTargetRenderbufferStorageOES"
@@ -9792,7 +8901,6 @@
   gl_api_->glEGLImageTargetRenderbufferStorageOESFn(target, image);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glEGLImageTargetTexture2DOESFn(GLenum target,
                                                 GLeglImageOES image) {
   GL_SERVICE_LOG("glEGLImageTargetTexture2DOES"
@@ -9801,28 +8909,24 @@
   gl_api_->glEGLImageTargetTexture2DOESFn(target, image);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glEnableFn(GLenum cap) {
   GL_SERVICE_LOG("glEnable"
                  << "(" << GLEnums::GetStringEnum(cap) << ")");
   gl_api_->glEnableFn(cap);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glEnableVertexAttribArrayFn(GLuint index) {
   GL_SERVICE_LOG("glEnableVertexAttribArray"
                  << "(" << index << ")");
   gl_api_->glEnableVertexAttribArrayFn(index);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glEndQueryFn(GLenum target) {
   GL_SERVICE_LOG("glEndQuery"
                  << "(" << GLEnums::GetStringEnum(target) << ")");
   gl_api_->glEndQueryFn(target);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glEndTransformFeedbackFn(void) {
   GL_SERVICE_LOG("glEndTransformFeedback"
                  << "("
@@ -9830,7 +8934,6 @@
   gl_api_->glEndTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 GLsync DebugGLApi::glFenceSyncFn(GLenum condition, GLbitfield flags) {
   GL_SERVICE_LOG("glFenceSync"
                  << "(" << GLEnums::GetStringEnum(condition) << ", " << flags
@@ -9840,7 +8943,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFinishFn(void) {
   GL_SERVICE_LOG("glFinish"
                  << "("
@@ -9848,21 +8950,18 @@
   gl_api_->glFinishFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFinishFenceAPPLEFn(GLuint fence) {
   GL_SERVICE_LOG("glFinishFenceAPPLE"
                  << "(" << fence << ")");
   gl_api_->glFinishFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFinishFenceNVFn(GLuint fence) {
   GL_SERVICE_LOG("glFinishFenceNV"
                  << "(" << fence << ")");
   gl_api_->glFinishFenceNVFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFlushFn(void) {
   GL_SERVICE_LOG("glFlush"
                  << "("
@@ -9870,7 +8969,6 @@
   gl_api_->glFlushFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFlushMappedBufferRangeFn(GLenum target,
                                             GLintptr offset,
                                             GLsizeiptr length) {
@@ -9880,7 +8978,6 @@
   gl_api_->glFlushMappedBufferRangeFn(target, offset, length);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFramebufferRenderbufferEXTFn(GLenum target,
                                                 GLenum attachment,
                                                 GLenum renderbuffertarget,
@@ -9894,7 +8991,6 @@
                                           renderbuffertarget, renderbuffer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFramebufferTexture2DEXTFn(GLenum target,
                                              GLenum attachment,
                                              GLenum textarget,
@@ -9909,7 +9005,6 @@
                                        level);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFramebufferTexture2DMultisampleEXTFn(GLenum target,
                                                         GLenum attachment,
                                                         GLenum textarget,
@@ -9925,7 +9020,6 @@
                                                   texture, level, samples);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFramebufferTextureLayerFn(GLenum target,
                                              GLenum attachment,
                                              GLuint texture,
@@ -9939,14 +9033,12 @@
                                        layer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glFrontFaceFn(GLenum mode) {
   GL_SERVICE_LOG("glFrontFace"
                  << "(" << GLEnums::GetStringEnum(mode) << ")");
   gl_api_->glFrontFaceFn(mode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenBuffersARBFn(GLsizei n, GLuint* buffers) {
   GL_SERVICE_LOG("glGenBuffersARB"
                  << "(" << n << ", " << static_cast<const void*>(buffers)
@@ -9954,14 +9046,12 @@
   gl_api_->glGenBuffersARBFn(n, buffers);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenerateMipmapEXTFn(GLenum target) {
   GL_SERVICE_LOG("glGenerateMipmapEXT"
                  << "(" << GLEnums::GetStringEnum(target) << ")");
   gl_api_->glGenerateMipmapEXTFn(target);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenFencesAPPLEFn(GLsizei n, GLuint* fences) {
   GL_SERVICE_LOG("glGenFencesAPPLE"
                  << "(" << n << ", " << static_cast<const void*>(fences)
@@ -9969,7 +9059,6 @@
   gl_api_->glGenFencesAPPLEFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenFencesNVFn(GLsizei n, GLuint* fences) {
   GL_SERVICE_LOG("glGenFencesNV"
                  << "(" << n << ", " << static_cast<const void*>(fences)
@@ -9977,7 +9066,6 @@
   gl_api_->glGenFencesNVFn(n, fences);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenFramebuffersEXTFn(GLsizei n, GLuint* framebuffers) {
   GL_SERVICE_LOG("glGenFramebuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(framebuffers)
@@ -9985,7 +9073,6 @@
   gl_api_->glGenFramebuffersEXTFn(n, framebuffers);
 }
 
-DISABLE_CFI_ICALL
 GLuint DebugGLApi::glGenPathsNVFn(GLsizei range) {
   GL_SERVICE_LOG("glGenPathsNV"
                  << "(" << range << ")");
@@ -9994,14 +9081,12 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenQueriesFn(GLsizei n, GLuint* ids) {
   GL_SERVICE_LOG("glGenQueries"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
   gl_api_->glGenQueriesFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenRenderbuffersEXTFn(GLsizei n, GLuint* renderbuffers) {
   GL_SERVICE_LOG("glGenRenderbuffersEXT"
                  << "(" << n << ", " << static_cast<const void*>(renderbuffers)
@@ -10009,7 +9094,6 @@
   gl_api_->glGenRenderbuffersEXTFn(n, renderbuffers);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenSamplersFn(GLsizei n, GLuint* samplers) {
   GL_SERVICE_LOG("glGenSamplers"
                  << "(" << n << ", " << static_cast<const void*>(samplers)
@@ -10017,7 +9101,6 @@
   gl_api_->glGenSamplersFn(n, samplers);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenTexturesFn(GLsizei n, GLuint* textures) {
   GL_SERVICE_LOG("glGenTextures"
                  << "(" << n << ", " << static_cast<const void*>(textures)
@@ -10025,14 +9108,12 @@
   gl_api_->glGenTexturesFn(n, textures);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenTransformFeedbacksFn(GLsizei n, GLuint* ids) {
   GL_SERVICE_LOG("glGenTransformFeedbacks"
                  << "(" << n << ", " << static_cast<const void*>(ids) << ")");
   gl_api_->glGenTransformFeedbacksFn(n, ids);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGenVertexArraysOESFn(GLsizei n, GLuint* arrays) {
   GL_SERVICE_LOG("glGenVertexArraysOES"
                  << "(" << n << ", " << static_cast<const void*>(arrays)
@@ -10040,7 +9121,6 @@
   gl_api_->glGenVertexArraysOESFn(n, arrays);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetActiveAttribFn(GLuint program,
                                      GLuint index,
                                      GLsizei bufsize,
@@ -10058,7 +9138,6 @@
                                name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetActiveUniformFn(GLuint program,
                                       GLuint index,
                                       GLsizei bufsize,
@@ -10076,7 +9155,6 @@
                                 name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetActiveUniformBlockivFn(GLuint program,
                                              GLuint uniformBlockIndex,
                                              GLenum pname,
@@ -10089,7 +9167,6 @@
                                        params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetActiveUniformBlockivRobustANGLEFn(
     GLuint program,
     GLuint uniformBlockIndex,
@@ -10106,7 +9183,6 @@
       program, uniformBlockIndex, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetActiveUniformBlockNameFn(GLuint program,
                                                GLuint uniformBlockIndex,
                                                GLsizei bufSize,
@@ -10120,7 +9196,6 @@
                                          length, uniformBlockName);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetActiveUniformsivFn(GLuint program,
                                          GLsizei uniformCount,
                                          const GLuint* uniformIndices,
@@ -10135,7 +9210,6 @@
                                    params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetAttachedShadersFn(GLuint program,
                                         GLsizei maxcount,
                                         GLsizei* count,
@@ -10147,7 +9221,6 @@
   gl_api_->glGetAttachedShadersFn(program, maxcount, count, shaders);
 }
 
-DISABLE_CFI_ICALL
 GLint DebugGLApi::glGetAttribLocationFn(GLuint program, const char* name) {
   GL_SERVICE_LOG("glGetAttribLocation"
                  << "(" << program << ", " << name << ")");
@@ -10156,7 +9229,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetBooleani_vRobustANGLEFn(GLenum target,
                                               GLuint index,
                                               GLsizei bufSize,
@@ -10169,7 +9241,6 @@
   gl_api_->glGetBooleani_vRobustANGLEFn(target, index, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetBooleanvFn(GLenum pname, GLboolean* params) {
   GL_SERVICE_LOG("glGetBooleanv"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
@@ -10177,7 +9248,6 @@
   gl_api_->glGetBooleanvFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetBooleanvRobustANGLEFn(GLenum pname,
                                             GLsizei bufSize,
                                             GLsizei* length,
@@ -10189,7 +9259,6 @@
   gl_api_->glGetBooleanvRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetBufferParameteri64vRobustANGLEFn(GLenum target,
                                                        GLenum pname,
                                                        GLsizei bufSize,
@@ -10204,7 +9273,6 @@
                                                  params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetBufferParameterivFn(GLenum target,
                                           GLenum pname,
                                           GLint* params) {
@@ -10215,7 +9283,6 @@
   gl_api_->glGetBufferParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetBufferParameterivRobustANGLEFn(GLenum target,
                                                      GLenum pname,
                                                      GLsizei bufSize,
@@ -10230,7 +9297,6 @@
                                                params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetBufferPointervRobustANGLEFn(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -10244,7 +9310,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetDebugMessageLogFn(GLuint count,
                                         GLsizei bufSize,
                                         GLenum* sources,
@@ -10265,7 +9330,6 @@
                                   severities, lengths, messageLog);
 }
 
-DISABLE_CFI_ICALL
 GLenum DebugGLApi::glGetErrorFn(void) {
   GL_SERVICE_LOG("glGetError"
                  << "("
@@ -10277,7 +9341,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetFenceivNVFn(GLuint fence, GLenum pname, GLint* params) {
   GL_SERVICE_LOG("glGetFenceivNV"
                  << "(" << fence << ", " << GLEnums::GetStringEnum(pname)
@@ -10285,7 +9348,6 @@
   gl_api_->glGetFenceivNVFn(fence, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetFloatvFn(GLenum pname, GLfloat* params) {
   GL_SERVICE_LOG("glGetFloatv"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
@@ -10293,7 +9355,6 @@
   gl_api_->glGetFloatvFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetFloatvRobustANGLEFn(GLenum pname,
                                           GLsizei bufSize,
                                           GLsizei* length,
@@ -10305,7 +9366,6 @@
   gl_api_->glGetFloatvRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 GLint DebugGLApi::glGetFragDataIndexFn(GLuint program, const char* name) {
   GL_SERVICE_LOG("glGetFragDataIndex"
                  << "(" << program << ", " << name << ")");
@@ -10314,7 +9374,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLint DebugGLApi::glGetFragDataLocationFn(GLuint program, const char* name) {
   GL_SERVICE_LOG("glGetFragDataLocation"
                  << "(" << program << ", " << name << ")");
@@ -10323,7 +9382,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetFramebufferAttachmentParameterivEXTFn(GLenum target,
                                                             GLenum attachment,
                                                             GLenum pname,
@@ -10337,7 +9395,6 @@
                                                       params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetFramebufferAttachmentParameterivRobustANGLEFn(
     GLenum target,
     GLenum attachment,
@@ -10355,7 +9412,6 @@
       target, attachment, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetFramebufferParameterivRobustANGLEFn(GLenum target,
                                                           GLenum pname,
                                                           GLsizei bufSize,
@@ -10370,7 +9426,6 @@
                                                     length, params);
 }
 
-DISABLE_CFI_ICALL
 GLenum DebugGLApi::glGetGraphicsResetStatusARBFn(void) {
   GL_SERVICE_LOG("glGetGraphicsResetStatusARB"
                  << "("
@@ -10380,7 +9435,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetInteger64i_vFn(GLenum target,
                                      GLuint index,
                                      GLint64* data) {
@@ -10390,7 +9444,6 @@
   gl_api_->glGetInteger64i_vFn(target, index, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetInteger64i_vRobustANGLEFn(GLenum target,
                                                 GLuint index,
                                                 GLsizei bufSize,
@@ -10403,7 +9456,6 @@
   gl_api_->glGetInteger64i_vRobustANGLEFn(target, index, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetInteger64vFn(GLenum pname, GLint64* params) {
   GL_SERVICE_LOG("glGetInteger64v"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
@@ -10411,7 +9463,6 @@
   gl_api_->glGetInteger64vFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetInteger64vRobustANGLEFn(GLenum pname,
                                               GLsizei bufSize,
                                               GLsizei* length,
@@ -10423,7 +9474,6 @@
   gl_api_->glGetInteger64vRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetIntegeri_vFn(GLenum target, GLuint index, GLint* data) {
   GL_SERVICE_LOG("glGetIntegeri_v"
                  << "(" << GLEnums::GetStringEnum(target) << ", " << index
@@ -10431,7 +9481,6 @@
   gl_api_->glGetIntegeri_vFn(target, index, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetIntegeri_vRobustANGLEFn(GLenum target,
                                               GLuint index,
                                               GLsizei bufSize,
@@ -10444,7 +9493,6 @@
   gl_api_->glGetIntegeri_vRobustANGLEFn(target, index, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetIntegervFn(GLenum pname, GLint* params) {
   GL_SERVICE_LOG("glGetIntegerv"
                  << "(" << GLEnums::GetStringEnum(pname) << ", "
@@ -10452,7 +9500,6 @@
   gl_api_->glGetIntegervFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetIntegervRobustANGLEFn(GLenum pname,
                                             GLsizei bufSize,
                                             GLsizei* length,
@@ -10464,7 +9511,6 @@
   gl_api_->glGetIntegervRobustANGLEFn(pname, bufSize, length, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetInternalformativFn(GLenum target,
                                          GLenum internalformat,
                                          GLenum pname,
@@ -10479,7 +9525,6 @@
                                    params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetInternalformativRobustANGLEFn(GLenum target,
                                                     GLenum internalformat,
                                                     GLenum pname,
@@ -10496,7 +9541,6 @@
                                               bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetMultisamplefvFn(GLenum pname,
                                       GLuint index,
                                       GLfloat* val) {
@@ -10506,7 +9550,6 @@
   gl_api_->glGetMultisamplefvFn(pname, index, val);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetMultisamplefvRobustANGLEFn(GLenum pname,
                                                  GLuint index,
                                                  GLsizei bufSize,
@@ -10519,7 +9562,6 @@
   gl_api_->glGetMultisamplefvRobustANGLEFn(pname, index, bufSize, length, val);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetnUniformfvRobustANGLEFn(GLuint program,
                                               GLint location,
                                               GLsizei bufSize,
@@ -10533,7 +9575,6 @@
                                         params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetnUniformivRobustANGLEFn(GLuint program,
                                               GLint location,
                                               GLsizei bufSize,
@@ -10547,7 +9588,6 @@
                                         params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetnUniformuivRobustANGLEFn(GLuint program,
                                                GLint location,
                                                GLsizei bufSize,
@@ -10561,7 +9601,6 @@
                                          params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetObjectLabelFn(GLenum identifier,
                                     GLuint name,
                                     GLsizei bufSize,
@@ -10574,7 +9613,6 @@
   gl_api_->glGetObjectLabelFn(identifier, name, bufSize, length, label);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetObjectPtrLabelFn(void* ptr,
                                        GLsizei bufSize,
                                        GLsizei* length,
@@ -10586,7 +9624,6 @@
   gl_api_->glGetObjectPtrLabelFn(ptr, bufSize, length, label);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetPointervFn(GLenum pname, void** params) {
   GL_SERVICE_LOG("glGetPointerv"
                  << "(" << GLEnums::GetStringEnum(pname) << ", " << params
@@ -10594,7 +9631,6 @@
   gl_api_->glGetPointervFn(pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetPointervRobustANGLERobustANGLEFn(GLenum pname,
                                                        GLsizei bufSize,
                                                        GLsizei* length,
@@ -10607,7 +9643,6 @@
                                                  params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetProgramBinaryFn(GLuint program,
                                       GLsizei bufSize,
                                       GLsizei* length,
@@ -10621,7 +9656,6 @@
   gl_api_->glGetProgramBinaryFn(program, bufSize, length, binaryFormat, binary);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetProgramInfoLogFn(GLuint program,
                                        GLsizei bufsize,
                                        GLsizei* length,
@@ -10633,7 +9667,6 @@
   gl_api_->glGetProgramInfoLogFn(program, bufsize, length, infolog);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetProgramInterfaceivFn(GLuint program,
                                            GLenum programInterface,
                                            GLenum pname,
@@ -10646,7 +9679,6 @@
   gl_api_->glGetProgramInterfaceivFn(program, programInterface, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetProgramInterfaceivRobustANGLEFn(GLuint program,
                                                       GLenum programInterface,
                                                       GLenum pname,
@@ -10663,7 +9695,6 @@
                                                 pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetProgramivFn(GLuint program, GLenum pname, GLint* params) {
   GL_SERVICE_LOG("glGetProgramiv"
                  << "(" << program << ", " << GLEnums::GetStringEnum(pname)
@@ -10671,7 +9702,6 @@
   gl_api_->glGetProgramivFn(program, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetProgramivRobustANGLEFn(GLuint program,
                                              GLenum pname,
                                              GLsizei bufSize,
@@ -10684,7 +9714,6 @@
   gl_api_->glGetProgramivRobustANGLEFn(program, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetProgramResourceivFn(GLuint program,
                                           GLenum programInterface,
                                           GLuint index,
@@ -10703,7 +9732,6 @@
                                     props, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 GLint DebugGLApi::glGetProgramResourceLocationFn(GLuint program,
                                                  GLenum programInterface,
                                                  const char* name) {
@@ -10717,7 +9745,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetProgramResourceNameFn(GLuint program,
                                             GLenum programInterface,
                                             GLuint index,
@@ -10733,7 +9760,6 @@
                                       length, name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryivFn(GLenum target, GLenum pname, GLint* params) {
   GL_SERVICE_LOG("glGetQueryiv"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
@@ -10742,7 +9768,6 @@
   gl_api_->glGetQueryivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryivRobustANGLEFn(GLenum target,
                                            GLenum pname,
                                            GLsizei bufSize,
@@ -10756,7 +9781,6 @@
   gl_api_->glGetQueryivRobustANGLEFn(target, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryObjecti64vFn(GLuint id,
                                         GLenum pname,
                                         GLint64* params) {
@@ -10766,7 +9790,6 @@
   gl_api_->glGetQueryObjecti64vFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryObjecti64vRobustANGLEFn(GLuint id,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -10780,7 +9803,6 @@
                                              params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryObjectivFn(GLuint id, GLenum pname, GLint* params) {
   GL_SERVICE_LOG("glGetQueryObjectiv"
                  << "(" << id << ", " << GLEnums::GetStringEnum(pname) << ", "
@@ -10788,7 +9810,6 @@
   gl_api_->glGetQueryObjectivFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryObjectivRobustANGLEFn(GLuint id,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -10801,7 +9822,6 @@
   gl_api_->glGetQueryObjectivRobustANGLEFn(id, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryObjectui64vFn(GLuint id,
                                          GLenum pname,
                                          GLuint64* params) {
@@ -10811,7 +9831,6 @@
   gl_api_->glGetQueryObjectui64vFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryObjectui64vRobustANGLEFn(GLuint id,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -10825,7 +9844,6 @@
                                               params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryObjectuivFn(GLuint id,
                                        GLenum pname,
                                        GLuint* params) {
@@ -10835,7 +9853,6 @@
   gl_api_->glGetQueryObjectuivFn(id, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetQueryObjectuivRobustANGLEFn(GLuint id,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -10848,7 +9865,6 @@
   gl_api_->glGetQueryObjectuivRobustANGLEFn(id, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetRenderbufferParameterivEXTFn(GLenum target,
                                                    GLenum pname,
                                                    GLint* params) {
@@ -10859,7 +9875,6 @@
   gl_api_->glGetRenderbufferParameterivEXTFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetRenderbufferParameterivRobustANGLEFn(GLenum target,
                                                            GLenum pname,
                                                            GLsizei bufSize,
@@ -10874,7 +9889,6 @@
                                                      length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetSamplerParameterfvFn(GLuint sampler,
                                            GLenum pname,
                                            GLfloat* params) {
@@ -10884,7 +9898,6 @@
   gl_api_->glGetSamplerParameterfvFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetSamplerParameterfvRobustANGLEFn(GLuint sampler,
                                                       GLenum pname,
                                                       GLsizei bufSize,
@@ -10898,7 +9911,6 @@
                                                 params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetSamplerParameterIivRobustANGLEFn(GLuint sampler,
                                                        GLenum pname,
                                                        GLsizei bufSize,
@@ -10912,7 +9924,6 @@
                                                  length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetSamplerParameterIuivRobustANGLEFn(GLuint sampler,
                                                         GLenum pname,
                                                         GLsizei bufSize,
@@ -10926,7 +9937,6 @@
                                                   length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetSamplerParameterivFn(GLuint sampler,
                                            GLenum pname,
                                            GLint* params) {
@@ -10936,7 +9946,6 @@
   gl_api_->glGetSamplerParameterivFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetSamplerParameterivRobustANGLEFn(GLuint sampler,
                                                       GLenum pname,
                                                       GLsizei bufSize,
@@ -10950,7 +9959,6 @@
                                                 params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetShaderInfoLogFn(GLuint shader,
                                       GLsizei bufsize,
                                       GLsizei* length,
@@ -10962,7 +9970,6 @@
   gl_api_->glGetShaderInfoLogFn(shader, bufsize, length, infolog);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetShaderivFn(GLuint shader, GLenum pname, GLint* params) {
   GL_SERVICE_LOG("glGetShaderiv"
                  << "(" << shader << ", " << GLEnums::GetStringEnum(pname)
@@ -10970,7 +9977,6 @@
   gl_api_->glGetShaderivFn(shader, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetShaderivRobustANGLEFn(GLuint shader,
                                             GLenum pname,
                                             GLsizei bufSize,
@@ -10983,7 +9989,6 @@
   gl_api_->glGetShaderivRobustANGLEFn(shader, pname, bufSize, length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetShaderPrecisionFormatFn(GLenum shadertype,
                                               GLenum precisiontype,
                                               GLint* range,
@@ -10997,7 +10002,6 @@
                                         precision);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetShaderSourceFn(GLuint shader,
                                      GLsizei bufsize,
                                      GLsizei* length,
@@ -11009,7 +10013,6 @@
   gl_api_->glGetShaderSourceFn(shader, bufsize, length, source);
 }
 
-DISABLE_CFI_ICALL
 const GLubyte* DebugGLApi::glGetStringFn(GLenum name) {
   GL_SERVICE_LOG("glGetString"
                  << "(" << GLEnums::GetStringEnum(name) << ")");
@@ -11018,7 +10021,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 const GLubyte* DebugGLApi::glGetStringiFn(GLenum name, GLuint index) {
   GL_SERVICE_LOG("glGetStringi"
                  << "(" << GLEnums::GetStringEnum(name) << ", " << index
@@ -11028,7 +10030,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetSyncivFn(GLsync sync,
                                GLenum pname,
                                GLsizei bufSize,
@@ -11041,7 +10042,6 @@
   gl_api_->glGetSyncivFn(sync, pname, bufSize, length, values);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexLevelParameterfvFn(GLenum target,
                                             GLint level,
                                             GLenum pname,
@@ -11053,7 +10053,6 @@
   gl_api_->glGetTexLevelParameterfvFn(target, level, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexLevelParameterfvRobustANGLEFn(GLenum target,
                                                        GLint level,
                                                        GLenum pname,
@@ -11069,7 +10068,6 @@
                                                  length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexLevelParameterivFn(GLenum target,
                                             GLint level,
                                             GLenum pname,
@@ -11081,7 +10079,6 @@
   gl_api_->glGetTexLevelParameterivFn(target, level, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexLevelParameterivRobustANGLEFn(GLenum target,
                                                        GLint level,
                                                        GLenum pname,
@@ -11097,7 +10094,6 @@
                                                  length, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexParameterfvFn(GLenum target,
                                        GLenum pname,
                                        GLfloat* params) {
@@ -11108,7 +10104,6 @@
   gl_api_->glGetTexParameterfvFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexParameterfvRobustANGLEFn(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -11123,7 +10118,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexParameterIivRobustANGLEFn(GLenum target,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -11138,7 +10132,6 @@
                                              params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexParameterIuivRobustANGLEFn(GLenum target,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -11153,7 +10146,6 @@
                                               params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexParameterivFn(GLenum target,
                                        GLenum pname,
                                        GLint* params) {
@@ -11164,7 +10156,6 @@
   gl_api_->glGetTexParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTexParameterivRobustANGLEFn(GLenum target,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -11179,7 +10170,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTransformFeedbackVaryingFn(GLuint program,
                                                  GLuint index,
                                                  GLsizei bufSize,
@@ -11197,7 +10187,6 @@
                                            size, type, name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetTranslatedShaderSourceANGLEFn(GLuint shader,
                                                     GLsizei bufsize,
                                                     GLsizei* length,
@@ -11209,7 +10198,6 @@
   gl_api_->glGetTranslatedShaderSourceANGLEFn(shader, bufsize, length, source);
 }
 
-DISABLE_CFI_ICALL
 GLuint DebugGLApi::glGetUniformBlockIndexFn(GLuint program,
                                             const char* uniformBlockName) {
   GL_SERVICE_LOG("glGetUniformBlockIndex"
@@ -11219,7 +10207,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetUniformfvFn(GLuint program,
                                   GLint location,
                                   GLfloat* params) {
@@ -11229,7 +10216,6 @@
   gl_api_->glGetUniformfvFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetUniformfvRobustANGLEFn(GLuint program,
                                              GLint location,
                                              GLsizei bufSize,
@@ -11243,7 +10229,6 @@
                                        params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetUniformIndicesFn(GLuint program,
                                        GLsizei uniformCount,
                                        const char* const* uniformNames,
@@ -11256,7 +10241,6 @@
                                  uniformIndices);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetUniformivFn(GLuint program,
                                   GLint location,
                                   GLint* params) {
@@ -11266,7 +10250,6 @@
   gl_api_->glGetUniformivFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetUniformivRobustANGLEFn(GLuint program,
                                              GLint location,
                                              GLsizei bufSize,
@@ -11280,7 +10263,6 @@
                                        params);
 }
 
-DISABLE_CFI_ICALL
 GLint DebugGLApi::glGetUniformLocationFn(GLuint program, const char* name) {
   GL_SERVICE_LOG("glGetUniformLocation"
                  << "(" << program << ", " << name << ")");
@@ -11289,7 +10271,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetUniformuivFn(GLuint program,
                                    GLint location,
                                    GLuint* params) {
@@ -11299,7 +10280,6 @@
   gl_api_->glGetUniformuivFn(program, location, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetUniformuivRobustANGLEFn(GLuint program,
                                               GLint location,
                                               GLsizei bufSize,
@@ -11313,7 +10293,6 @@
                                         params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetVertexAttribfvFn(GLuint index,
                                        GLenum pname,
                                        GLfloat* params) {
@@ -11323,7 +10302,6 @@
   gl_api_->glGetVertexAttribfvFn(index, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetVertexAttribfvRobustANGLEFn(GLuint index,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -11337,7 +10315,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetVertexAttribIivRobustANGLEFn(GLuint index,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -11351,7 +10328,6 @@
                                              params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetVertexAttribIuivRobustANGLEFn(GLuint index,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -11365,7 +10341,6 @@
                                               params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetVertexAttribivFn(GLuint index,
                                        GLenum pname,
                                        GLint* params) {
@@ -11375,7 +10350,6 @@
   gl_api_->glGetVertexAttribivFn(index, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetVertexAttribivRobustANGLEFn(GLuint index,
                                                   GLenum pname,
                                                   GLsizei bufSize,
@@ -11389,7 +10363,6 @@
                                             params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetVertexAttribPointervFn(GLuint index,
                                              GLenum pname,
                                              void** pointer) {
@@ -11399,7 +10372,6 @@
   gl_api_->glGetVertexAttribPointervFn(index, pname, pointer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glGetVertexAttribPointervRobustANGLEFn(GLuint index,
                                                         GLenum pname,
                                                         GLsizei bufSize,
@@ -11413,7 +10385,6 @@
                                                   pointer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glHintFn(GLenum target, GLenum mode) {
   GL_SERVICE_LOG("glHint"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
@@ -11421,14 +10392,12 @@
   gl_api_->glHintFn(target, mode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glInsertEventMarkerEXTFn(GLsizei length, const char* marker) {
   GL_SERVICE_LOG("glInsertEventMarkerEXT"
                  << "(" << length << ", " << marker << ")");
   gl_api_->glInsertEventMarkerEXTFn(length, marker);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glInvalidateFramebufferFn(GLenum target,
                                            GLsizei numAttachments,
                                            const GLenum* attachments) {
@@ -11439,7 +10408,6 @@
   gl_api_->glInvalidateFramebufferFn(target, numAttachments, attachments);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glInvalidateSubFramebufferFn(GLenum target,
                                               GLsizei numAttachments,
                                               const GLenum* attachments,
@@ -11456,7 +10424,6 @@
                                         y, width, height);
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsBufferFn(GLuint buffer) {
   GL_SERVICE_LOG("glIsBuffer"
                  << "(" << buffer << ")");
@@ -11465,7 +10432,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsEnabledFn(GLenum cap) {
   GL_SERVICE_LOG("glIsEnabled"
                  << "(" << GLEnums::GetStringEnum(cap) << ")");
@@ -11474,7 +10440,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsFenceAPPLEFn(GLuint fence) {
   GL_SERVICE_LOG("glIsFenceAPPLE"
                  << "(" << fence << ")");
@@ -11483,7 +10448,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsFenceNVFn(GLuint fence) {
   GL_SERVICE_LOG("glIsFenceNV"
                  << "(" << fence << ")");
@@ -11492,7 +10456,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsFramebufferEXTFn(GLuint framebuffer) {
   GL_SERVICE_LOG("glIsFramebufferEXT"
                  << "(" << framebuffer << ")");
@@ -11501,7 +10464,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsPathNVFn(GLuint path) {
   GL_SERVICE_LOG("glIsPathNV"
                  << "(" << path << ")");
@@ -11510,7 +10472,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsProgramFn(GLuint program) {
   GL_SERVICE_LOG("glIsProgram"
                  << "(" << program << ")");
@@ -11519,7 +10480,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsQueryFn(GLuint query) {
   GL_SERVICE_LOG("glIsQuery"
                  << "(" << query << ")");
@@ -11528,7 +10488,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsRenderbufferEXTFn(GLuint renderbuffer) {
   GL_SERVICE_LOG("glIsRenderbufferEXT"
                  << "(" << renderbuffer << ")");
@@ -11537,7 +10496,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsSamplerFn(GLuint sampler) {
   GL_SERVICE_LOG("glIsSampler"
                  << "(" << sampler << ")");
@@ -11546,7 +10504,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsShaderFn(GLuint shader) {
   GL_SERVICE_LOG("glIsShader"
                  << "(" << shader << ")");
@@ -11555,7 +10512,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsSyncFn(GLsync sync) {
   GL_SERVICE_LOG("glIsSync"
                  << "(" << sync << ")");
@@ -11564,7 +10520,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsTextureFn(GLuint texture) {
   GL_SERVICE_LOG("glIsTexture"
                  << "(" << texture << ")");
@@ -11573,7 +10528,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsTransformFeedbackFn(GLuint id) {
   GL_SERVICE_LOG("glIsTransformFeedback"
                  << "(" << id << ")");
@@ -11582,7 +10536,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glIsVertexArrayOESFn(GLuint array) {
   GL_SERVICE_LOG("glIsVertexArrayOES"
                  << "(" << array << ")");
@@ -11591,21 +10544,18 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glLineWidthFn(GLfloat width) {
   GL_SERVICE_LOG("glLineWidth"
                  << "(" << width << ")");
   gl_api_->glLineWidthFn(width);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glLinkProgramFn(GLuint program) {
   GL_SERVICE_LOG("glLinkProgram"
                  << "(" << program << ")");
   gl_api_->glLinkProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void* DebugGLApi::glMapBufferFn(GLenum target, GLenum access) {
   GL_SERVICE_LOG("glMapBuffer"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
@@ -11615,7 +10565,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void* DebugGLApi::glMapBufferRangeFn(GLenum target,
                                      GLintptr offset,
                                      GLsizeiptr length,
@@ -11628,7 +10577,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glMatrixLoadfEXTFn(GLenum matrixMode, const GLfloat* m) {
   GL_SERVICE_LOG("glMatrixLoadfEXT"
                  << "(" << GLEnums::GetStringEnum(matrixMode) << ", "
@@ -11636,21 +10584,18 @@
   gl_api_->glMatrixLoadfEXTFn(matrixMode, m);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glMatrixLoadIdentityEXTFn(GLenum matrixMode) {
   GL_SERVICE_LOG("glMatrixLoadIdentityEXT"
                  << "(" << GLEnums::GetStringEnum(matrixMode) << ")");
   gl_api_->glMatrixLoadIdentityEXTFn(matrixMode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glMemoryBarrierEXTFn(GLbitfield barriers) {
   GL_SERVICE_LOG("glMemoryBarrierEXT"
                  << "(" << barriers << ")");
   gl_api_->glMemoryBarrierEXTFn(barriers);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glObjectLabelFn(GLenum identifier,
                                  GLuint name,
                                  GLsizei length,
@@ -11661,7 +10606,6 @@
   gl_api_->glObjectLabelFn(identifier, name, length, label);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glObjectPtrLabelFn(void* ptr,
                                     GLsizei length,
                                     const char* label) {
@@ -11671,7 +10615,6 @@
   gl_api_->glObjectPtrLabelFn(ptr, length, label);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPathCommandsNVFn(GLuint path,
                                     GLsizei numCommands,
                                     const GLubyte* commands,
@@ -11687,7 +10630,6 @@
                               coords);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPathParameterfNVFn(GLuint path,
                                       GLenum pname,
                                       GLfloat value) {
@@ -11697,7 +10639,6 @@
   gl_api_->glPathParameterfNVFn(path, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPathParameteriNVFn(GLuint path, GLenum pname, GLint value) {
   GL_SERVICE_LOG("glPathParameteriNV"
                  << "(" << path << ", " << GLEnums::GetStringEnum(pname) << ", "
@@ -11705,7 +10646,6 @@
   gl_api_->glPathParameteriNVFn(path, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPathStencilFuncNVFn(GLenum func, GLint ref, GLuint mask) {
   GL_SERVICE_LOG("glPathStencilFuncNV"
                  << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
@@ -11713,7 +10653,6 @@
   gl_api_->glPathStencilFuncNVFn(func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPauseTransformFeedbackFn(void) {
   GL_SERVICE_LOG("glPauseTransformFeedback"
                  << "("
@@ -11721,7 +10660,6 @@
   gl_api_->glPauseTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPixelStoreiFn(GLenum pname, GLint param) {
   GL_SERVICE_LOG("glPixelStorei"
                  << "(" << GLEnums::GetStringEnum(pname) << ", " << param
@@ -11729,7 +10667,6 @@
   gl_api_->glPixelStoreiFn(pname, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPointParameteriFn(GLenum pname, GLint param) {
   GL_SERVICE_LOG("glPointParameteri"
                  << "(" << GLEnums::GetStringEnum(pname) << ", " << param
@@ -11737,7 +10674,6 @@
   gl_api_->glPointParameteriFn(pname, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPolygonModeFn(GLenum face, GLenum mode) {
   GL_SERVICE_LOG("glPolygonMode"
                  << "(" << GLEnums::GetStringEnum(face) << ", "
@@ -11745,14 +10681,12 @@
   gl_api_->glPolygonModeFn(face, mode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPolygonOffsetFn(GLfloat factor, GLfloat units) {
   GL_SERVICE_LOG("glPolygonOffset"
                  << "(" << factor << ", " << units << ")");
   gl_api_->glPolygonOffsetFn(factor, units);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPopDebugGroupFn() {
   GL_SERVICE_LOG("glPopDebugGroup"
                  << "("
@@ -11760,7 +10694,6 @@
   gl_api_->glPopDebugGroupFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPopGroupMarkerEXTFn(void) {
   GL_SERVICE_LOG("glPopGroupMarkerEXT"
                  << "("
@@ -11768,14 +10701,12 @@
   gl_api_->glPopGroupMarkerEXTFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPrimitiveRestartIndexFn(GLuint index) {
   GL_SERVICE_LOG("glPrimitiveRestartIndex"
                  << "(" << index << ")");
   gl_api_->glPrimitiveRestartIndexFn(index);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glProgramBinaryFn(GLuint program,
                                    GLenum binaryFormat,
                                    const GLvoid* binary,
@@ -11787,7 +10718,6 @@
   gl_api_->glProgramBinaryFn(program, binaryFormat, binary, length);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glProgramParameteriFn(GLuint program,
                                        GLenum pname,
                                        GLint value) {
@@ -11797,7 +10727,6 @@
   gl_api_->glProgramParameteriFn(program, pname, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glProgramPathFragmentInputGenNVFn(GLuint program,
                                                    GLint location,
                                                    GLenum genMode,
@@ -11811,7 +10740,6 @@
                                              components, coeffs);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPushDebugGroupFn(GLenum source,
                                     GLuint id,
                                     GLsizei length,
@@ -11822,28 +10750,24 @@
   gl_api_->glPushDebugGroupFn(source, id, length, message);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glPushGroupMarkerEXTFn(GLsizei length, const char* marker) {
   GL_SERVICE_LOG("glPushGroupMarkerEXT"
                  << "(" << length << ", " << marker << ")");
   gl_api_->glPushGroupMarkerEXTFn(length, marker);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glQueryCounterFn(GLuint id, GLenum target) {
   GL_SERVICE_LOG("glQueryCounter"
                  << "(" << id << ", " << GLEnums::GetStringEnum(target) << ")");
   gl_api_->glQueryCounterFn(id, target);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glReadBufferFn(GLenum src) {
   GL_SERVICE_LOG("glReadBuffer"
                  << "(" << GLEnums::GetStringEnum(src) << ")");
   gl_api_->glReadBufferFn(src);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glReadnPixelsRobustANGLEFn(GLint x,
                                             GLint y,
                                             GLsizei width,
@@ -11867,7 +10791,6 @@
                                       bufSize, length, columns, rows, data);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glReadPixelsFn(GLint x,
                                 GLint y,
                                 GLsizei width,
@@ -11883,7 +10806,6 @@
   gl_api_->glReadPixelsFn(x, y, width, height, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glReadPixelsRobustANGLEFn(GLint x,
                                            GLint y,
                                            GLsizei width,
@@ -11907,7 +10829,6 @@
                                      length, columns, rows, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glReleaseShaderCompilerFn(void) {
   GL_SERVICE_LOG("glReleaseShaderCompiler"
                  << "("
@@ -11915,7 +10836,6 @@
   gl_api_->glReleaseShaderCompilerFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glRenderbufferStorageEXTFn(GLenum target,
                                             GLenum internalformat,
                                             GLsizei width,
@@ -11927,7 +10847,6 @@
   gl_api_->glRenderbufferStorageEXTFn(target, internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glRenderbufferStorageMultisampleFn(GLenum target,
                                                     GLsizei samples,
                                                     GLenum internalformat,
@@ -11941,7 +10860,6 @@
                                               width, height);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glRenderbufferStorageMultisampleEXTFn(GLenum target,
                                                        GLsizei samples,
                                                        GLenum internalformat,
@@ -11955,14 +10873,12 @@
                                                  internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glRequestExtensionANGLEFn(const char* name) {
   GL_SERVICE_LOG("glRequestExtensionANGLE"
                  << "(" << name << ")");
   gl_api_->glRequestExtensionANGLEFn(name);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glResumeTransformFeedbackFn(void) {
   GL_SERVICE_LOG("glResumeTransformFeedback"
                  << "("
@@ -11970,7 +10886,6 @@
   gl_api_->glResumeTransformFeedbackFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSampleCoverageFn(GLclampf value, GLboolean invert) {
   GL_SERVICE_LOG("glSampleCoverage"
                  << "(" << value << ", " << GLEnums::GetStringBool(invert)
@@ -11978,7 +10893,6 @@
   gl_api_->glSampleCoverageFn(value, invert);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSamplerParameterfFn(GLuint sampler,
                                        GLenum pname,
                                        GLfloat param) {
@@ -11988,7 +10902,6 @@
   gl_api_->glSamplerParameterfFn(sampler, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSamplerParameterfvFn(GLuint sampler,
                                         GLenum pname,
                                         const GLfloat* params) {
@@ -11998,7 +10911,6 @@
   gl_api_->glSamplerParameterfvFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSamplerParameterfvRobustANGLEFn(GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -12010,7 +10922,6 @@
   gl_api_->glSamplerParameterfvRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSamplerParameteriFn(GLuint sampler,
                                        GLenum pname,
                                        GLint param) {
@@ -12020,7 +10931,6 @@
   gl_api_->glSamplerParameteriFn(sampler, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSamplerParameterIivRobustANGLEFn(GLuint sampler,
                                                     GLenum pname,
                                                     GLsizei bufSize,
@@ -12032,7 +10942,6 @@
   gl_api_->glSamplerParameterIivRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSamplerParameterIuivRobustANGLEFn(GLuint sampler,
                                                      GLenum pname,
                                                      GLsizei bufSize,
@@ -12044,7 +10953,6 @@
   gl_api_->glSamplerParameterIuivRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSamplerParameterivFn(GLuint sampler,
                                         GLenum pname,
                                         const GLint* params) {
@@ -12054,7 +10962,6 @@
   gl_api_->glSamplerParameterivFn(sampler, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSamplerParameterivRobustANGLEFn(GLuint sampler,
                                                    GLenum pname,
                                                    GLsizei bufSize,
@@ -12066,7 +10973,6 @@
   gl_api_->glSamplerParameterivRobustANGLEFn(sampler, pname, bufSize, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glScissorFn(GLint x, GLint y, GLsizei width, GLsizei height) {
   GL_SERVICE_LOG("glScissor"
                  << "(" << x << ", " << y << ", " << width << ", " << height
@@ -12074,14 +10980,12 @@
   gl_api_->glScissorFn(x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSetFenceAPPLEFn(GLuint fence) {
   GL_SERVICE_LOG("glSetFenceAPPLE"
                  << "(" << fence << ")");
   gl_api_->glSetFenceAPPLEFn(fence);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glSetFenceNVFn(GLuint fence, GLenum condition) {
   GL_SERVICE_LOG("glSetFenceNV"
                  << "(" << fence << ", " << GLEnums::GetStringEnum(condition)
@@ -12089,7 +10993,6 @@
   gl_api_->glSetFenceNVFn(fence, condition);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glShaderBinaryFn(GLsizei n,
                                   const GLuint* shaders,
                                   GLenum binaryformat,
@@ -12102,7 +11005,6 @@
   gl_api_->glShaderBinaryFn(n, shaders, binaryformat, binary, length);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glShaderSourceFn(GLuint shader,
                                   GLsizei count,
                                   const char* const* str,
@@ -12129,7 +11031,6 @@
   });
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilFillPathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -12151,7 +11052,6 @@
                                           transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilFillPathNVFn(GLuint path,
                                        GLenum fillMode,
                                        GLuint mask) {
@@ -12161,7 +11061,6 @@
   gl_api_->glStencilFillPathNVFn(path, fillMode, mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilFuncFn(GLenum func, GLint ref, GLuint mask) {
   GL_SERVICE_LOG("glStencilFunc"
                  << "(" << GLEnums::GetStringEnum(func) << ", " << ref << ", "
@@ -12169,7 +11068,6 @@
   gl_api_->glStencilFuncFn(func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilFuncSeparateFn(GLenum face,
                                          GLenum func,
                                          GLint ref,
@@ -12181,21 +11079,18 @@
   gl_api_->glStencilFuncSeparateFn(face, func, ref, mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilMaskFn(GLuint mask) {
   GL_SERVICE_LOG("glStencilMask"
                  << "(" << mask << ")");
   gl_api_->glStencilMaskFn(mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilMaskSeparateFn(GLenum face, GLuint mask) {
   GL_SERVICE_LOG("glStencilMaskSeparate"
                  << "(" << GLEnums::GetStringEnum(face) << ", " << mask << ")");
   gl_api_->glStencilMaskSeparateFn(face, mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilOpFn(GLenum fail, GLenum zfail, GLenum zpass) {
   GL_SERVICE_LOG("glStencilOp"
                  << "(" << GLEnums::GetStringEnum(fail) << ", "
@@ -12204,7 +11099,6 @@
   gl_api_->glStencilOpFn(fail, zfail, zpass);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilOpSeparateFn(GLenum face,
                                        GLenum fail,
                                        GLenum zfail,
@@ -12217,7 +11111,6 @@
   gl_api_->glStencilOpSeparateFn(face, fail, zfail, zpass);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilStrokePathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -12238,7 +11131,6 @@
                                             transformValues);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilStrokePathNVFn(GLuint path,
                                          GLint reference,
                                          GLuint mask) {
@@ -12247,7 +11139,6 @@
   gl_api_->glStencilStrokePathNVFn(path, reference, mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilThenCoverFillPathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -12271,7 +11162,6 @@
       transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilThenCoverFillPathNVFn(GLuint path,
                                                 GLenum fillMode,
                                                 GLuint mask,
@@ -12283,7 +11173,6 @@
   gl_api_->glStencilThenCoverFillPathNVFn(path, fillMode, mask, coverMode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilThenCoverStrokePathInstancedNVFn(
     GLsizei numPaths,
     GLenum pathNameType,
@@ -12306,7 +11195,6 @@
       transformType, transformValues);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glStencilThenCoverStrokePathNVFn(GLuint path,
                                                   GLint reference,
                                                   GLuint mask,
@@ -12317,7 +11205,6 @@
   gl_api_->glStencilThenCoverStrokePathNVFn(path, reference, mask, coverMode);
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glTestFenceAPPLEFn(GLuint fence) {
   GL_SERVICE_LOG("glTestFenceAPPLE"
                  << "(" << fence << ")");
@@ -12326,7 +11213,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glTestFenceNVFn(GLuint fence) {
   GL_SERVICE_LOG("glTestFenceNV"
                  << "(" << fence << ")");
@@ -12335,7 +11221,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexBufferFn(GLenum target,
                                GLenum internalformat,
                                GLuint buffer) {
@@ -12346,7 +11231,6 @@
   gl_api_->glTexBufferFn(target, internalformat, buffer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexBufferRangeFn(GLenum target,
                                     GLenum internalformat,
                                     GLuint buffer,
@@ -12359,7 +11243,6 @@
   gl_api_->glTexBufferRangeFn(target, internalformat, buffer, offset, size);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexImage2DFn(GLenum target,
                                 GLint level,
                                 GLint internalformat,
@@ -12379,7 +11262,6 @@
                           format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexImage2DRobustANGLEFn(GLenum target,
                                            GLint level,
                                            GLint internalformat,
@@ -12401,7 +11283,6 @@
                                      pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexImage3DFn(GLenum target,
                                 GLint level,
                                 GLint internalformat,
@@ -12423,7 +11304,6 @@
                           border, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexImage3DRobustANGLEFn(GLenum target,
                                            GLint level,
                                            GLint internalformat,
@@ -12447,7 +11327,6 @@
                                      bufSize, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexParameterfFn(GLenum target, GLenum pname, GLfloat param) {
   GL_SERVICE_LOG("glTexParameterf"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
@@ -12455,7 +11334,6 @@
   gl_api_->glTexParameterfFn(target, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexParameterfvFn(GLenum target,
                                     GLenum pname,
                                     const GLfloat* params) {
@@ -12466,7 +11344,6 @@
   gl_api_->glTexParameterfvFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexParameterfvRobustANGLEFn(GLenum target,
                                                GLenum pname,
                                                GLsizei bufSize,
@@ -12478,7 +11355,6 @@
   gl_api_->glTexParameterfvRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexParameteriFn(GLenum target, GLenum pname, GLint param) {
   GL_SERVICE_LOG("glTexParameteri"
                  << "(" << GLEnums::GetStringEnum(target) << ", "
@@ -12486,7 +11362,6 @@
   gl_api_->glTexParameteriFn(target, pname, param);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexParameterIivRobustANGLEFn(GLenum target,
                                                 GLenum pname,
                                                 GLsizei bufSize,
@@ -12498,7 +11373,6 @@
   gl_api_->glTexParameterIivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexParameterIuivRobustANGLEFn(GLenum target,
                                                  GLenum pname,
                                                  GLsizei bufSize,
@@ -12510,7 +11384,6 @@
   gl_api_->glTexParameterIuivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexParameterivFn(GLenum target,
                                     GLenum pname,
                                     const GLint* params) {
@@ -12521,7 +11394,6 @@
   gl_api_->glTexParameterivFn(target, pname, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexParameterivRobustANGLEFn(GLenum target,
                                                GLenum pname,
                                                GLsizei bufSize,
@@ -12533,7 +11405,6 @@
   gl_api_->glTexParameterivRobustANGLEFn(target, pname, bufSize, params);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexStorage2DEXTFn(GLenum target,
                                      GLsizei levels,
                                      GLenum internalformat,
@@ -12546,7 +11417,6 @@
   gl_api_->glTexStorage2DEXTFn(target, levels, internalformat, width, height);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexStorage3DFn(GLenum target,
                                   GLsizei levels,
                                   GLenum internalformat,
@@ -12561,7 +11431,6 @@
                             depth);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexSubImage2DFn(GLenum target,
                                    GLint level,
                                    GLint xoffset,
@@ -12581,7 +11450,6 @@
                              format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexSubImage2DRobustANGLEFn(GLenum target,
                                               GLint level,
                                               GLint xoffset,
@@ -12602,7 +11470,6 @@
                                         height, format, type, bufSize, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexSubImage3DFn(GLenum target,
                                    GLint level,
                                    GLint xoffset,
@@ -12625,7 +11492,6 @@
                              height, depth, format, type, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTexSubImage3DRobustANGLEFn(GLenum target,
                                               GLint level,
                                               GLint xoffset,
@@ -12650,7 +11516,6 @@
                                         type, bufSize, pixels);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glTransformFeedbackVaryingsFn(GLuint program,
                                                GLsizei count,
                                                const char* const* varyings,
@@ -12662,14 +11527,12 @@
   gl_api_->glTransformFeedbackVaryingsFn(program, count, varyings, bufferMode);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform1fFn(GLint location, GLfloat x) {
   GL_SERVICE_LOG("glUniform1f"
                  << "(" << location << ", " << x << ")");
   gl_api_->glUniform1fFn(location, x);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform1fvFn(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
@@ -12679,14 +11542,12 @@
   gl_api_->glUniform1fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform1iFn(GLint location, GLint x) {
   GL_SERVICE_LOG("glUniform1i"
                  << "(" << location << ", " << x << ")");
   gl_api_->glUniform1iFn(location, x);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform1ivFn(GLint location, GLsizei count, const GLint* v) {
   GL_SERVICE_LOG("glUniform1iv"
                  << "(" << location << ", " << count << ", "
@@ -12694,14 +11555,12 @@
   gl_api_->glUniform1ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform1uiFn(GLint location, GLuint v0) {
   GL_SERVICE_LOG("glUniform1ui"
                  << "(" << location << ", " << v0 << ")");
   gl_api_->glUniform1uiFn(location, v0);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform1uivFn(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
@@ -12711,14 +11570,12 @@
   gl_api_->glUniform1uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform2fFn(GLint location, GLfloat x, GLfloat y) {
   GL_SERVICE_LOG("glUniform2f"
                  << "(" << location << ", " << x << ", " << y << ")");
   gl_api_->glUniform2fFn(location, x, y);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform2fvFn(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
@@ -12728,14 +11585,12 @@
   gl_api_->glUniform2fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform2iFn(GLint location, GLint x, GLint y) {
   GL_SERVICE_LOG("glUniform2i"
                  << "(" << location << ", " << x << ", " << y << ")");
   gl_api_->glUniform2iFn(location, x, y);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform2ivFn(GLint location, GLsizei count, const GLint* v) {
   GL_SERVICE_LOG("glUniform2iv"
                  << "(" << location << ", " << count << ", "
@@ -12743,14 +11598,12 @@
   gl_api_->glUniform2ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform2uiFn(GLint location, GLuint v0, GLuint v1) {
   GL_SERVICE_LOG("glUniform2ui"
                  << "(" << location << ", " << v0 << ", " << v1 << ")");
   gl_api_->glUniform2uiFn(location, v0, v1);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform2uivFn(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
@@ -12760,7 +11613,6 @@
   gl_api_->glUniform2uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform3fFn(GLint location,
                                GLfloat x,
                                GLfloat y,
@@ -12771,7 +11623,6 @@
   gl_api_->glUniform3fFn(location, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform3fvFn(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
@@ -12781,7 +11632,6 @@
   gl_api_->glUniform3fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform3iFn(GLint location, GLint x, GLint y, GLint z) {
   GL_SERVICE_LOG("glUniform3i"
                  << "(" << location << ", " << x << ", " << y << ", " << z
@@ -12789,7 +11639,6 @@
   gl_api_->glUniform3iFn(location, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform3ivFn(GLint location, GLsizei count, const GLint* v) {
   GL_SERVICE_LOG("glUniform3iv"
                  << "(" << location << ", " << count << ", "
@@ -12797,7 +11646,6 @@
   gl_api_->glUniform3ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform3uiFn(GLint location,
                                 GLuint v0,
                                 GLuint v1,
@@ -12808,7 +11656,6 @@
   gl_api_->glUniform3uiFn(location, v0, v1, v2);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform3uivFn(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
@@ -12818,7 +11665,6 @@
   gl_api_->glUniform3uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform4fFn(GLint location,
                                GLfloat x,
                                GLfloat y,
@@ -12830,7 +11676,6 @@
   gl_api_->glUniform4fFn(location, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform4fvFn(GLint location,
                                 GLsizei count,
                                 const GLfloat* v) {
@@ -12840,7 +11685,6 @@
   gl_api_->glUniform4fvFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform4iFn(GLint location,
                                GLint x,
                                GLint y,
@@ -12852,7 +11696,6 @@
   gl_api_->glUniform4iFn(location, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform4ivFn(GLint location, GLsizei count, const GLint* v) {
   GL_SERVICE_LOG("glUniform4iv"
                  << "(" << location << ", " << count << ", "
@@ -12860,7 +11703,6 @@
   gl_api_->glUniform4ivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform4uiFn(GLint location,
                                 GLuint v0,
                                 GLuint v1,
@@ -12872,7 +11714,6 @@
   gl_api_->glUniform4uiFn(location, v0, v1, v2, v3);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniform4uivFn(GLint location,
                                  GLsizei count,
                                  const GLuint* v) {
@@ -12882,7 +11723,6 @@
   gl_api_->glUniform4uivFn(location, count, v);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformBlockBindingFn(GLuint program,
                                          GLuint uniformBlockIndex,
                                          GLuint uniformBlockBinding) {
@@ -12893,7 +11733,6 @@
                                    uniformBlockBinding);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix2fvFn(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
@@ -12905,7 +11744,6 @@
   gl_api_->glUniformMatrix2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix2x3fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -12917,7 +11755,6 @@
   gl_api_->glUniformMatrix2x3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix2x4fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -12929,7 +11766,6 @@
   gl_api_->glUniformMatrix2x4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix3fvFn(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
@@ -12941,7 +11777,6 @@
   gl_api_->glUniformMatrix3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix3x2fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -12953,7 +11788,6 @@
   gl_api_->glUniformMatrix3x2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix3x4fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -12965,7 +11799,6 @@
   gl_api_->glUniformMatrix3x4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix4fvFn(GLint location,
                                       GLsizei count,
                                       GLboolean transpose,
@@ -12977,7 +11810,6 @@
   gl_api_->glUniformMatrix4fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix4x2fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -12989,7 +11821,6 @@
   gl_api_->glUniformMatrix4x2fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUniformMatrix4x3fvFn(GLint location,
                                         GLsizei count,
                                         GLboolean transpose,
@@ -13001,7 +11832,6 @@
   gl_api_->glUniformMatrix4x3fvFn(location, count, transpose, value);
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugGLApi::glUnmapBufferFn(GLenum target) {
   GL_SERVICE_LOG("glUnmapBuffer"
                  << "(" << GLEnums::GetStringEnum(target) << ")");
@@ -13010,28 +11840,24 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glUseProgramFn(GLuint program) {
   GL_SERVICE_LOG("glUseProgram"
                  << "(" << program << ")");
   gl_api_->glUseProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glValidateProgramFn(GLuint program) {
   GL_SERVICE_LOG("glValidateProgram"
                  << "(" << program << ")");
   gl_api_->glValidateProgramFn(program);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttrib1fFn(GLuint indx, GLfloat x) {
   GL_SERVICE_LOG("glVertexAttrib1f"
                  << "(" << indx << ", " << x << ")");
   gl_api_->glVertexAttrib1fFn(indx, x);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttrib1fvFn(GLuint indx, const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib1fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
@@ -13039,14 +11865,12 @@
   gl_api_->glVertexAttrib1fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttrib2fFn(GLuint indx, GLfloat x, GLfloat y) {
   GL_SERVICE_LOG("glVertexAttrib2f"
                  << "(" << indx << ", " << x << ", " << y << ")");
   gl_api_->glVertexAttrib2fFn(indx, x, y);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttrib2fvFn(GLuint indx, const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib2fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
@@ -13054,7 +11878,6 @@
   gl_api_->glVertexAttrib2fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttrib3fFn(GLuint indx,
                                     GLfloat x,
                                     GLfloat y,
@@ -13064,7 +11887,6 @@
   gl_api_->glVertexAttrib3fFn(indx, x, y, z);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttrib3fvFn(GLuint indx, const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib3fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
@@ -13072,7 +11894,6 @@
   gl_api_->glVertexAttrib3fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttrib4fFn(GLuint indx,
                                     GLfloat x,
                                     GLfloat y,
@@ -13084,7 +11905,6 @@
   gl_api_->glVertexAttrib4fFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttrib4fvFn(GLuint indx, const GLfloat* values) {
   GL_SERVICE_LOG("glVertexAttrib4fv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
@@ -13092,14 +11912,12 @@
   gl_api_->glVertexAttrib4fvFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttribDivisorANGLEFn(GLuint index, GLuint divisor) {
   GL_SERVICE_LOG("glVertexAttribDivisorANGLE"
                  << "(" << index << ", " << divisor << ")");
   gl_api_->glVertexAttribDivisorANGLEFn(index, divisor);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttribI4iFn(GLuint indx,
                                      GLint x,
                                      GLint y,
@@ -13111,7 +11929,6 @@
   gl_api_->glVertexAttribI4iFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttribI4ivFn(GLuint indx, const GLint* values) {
   GL_SERVICE_LOG("glVertexAttribI4iv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
@@ -13119,7 +11936,6 @@
   gl_api_->glVertexAttribI4ivFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttribI4uiFn(GLuint indx,
                                       GLuint x,
                                       GLuint y,
@@ -13131,7 +11947,6 @@
   gl_api_->glVertexAttribI4uiFn(indx, x, y, z, w);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttribI4uivFn(GLuint indx, const GLuint* values) {
   GL_SERVICE_LOG("glVertexAttribI4uiv"
                  << "(" << indx << ", " << static_cast<const void*>(values)
@@ -13139,7 +11954,6 @@
   gl_api_->glVertexAttribI4uivFn(indx, values);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttribIPointerFn(GLuint indx,
                                           GLint size,
                                           GLenum type,
@@ -13152,7 +11966,6 @@
   gl_api_->glVertexAttribIPointerFn(indx, size, type, stride, ptr);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glVertexAttribPointerFn(GLuint indx,
                                          GLint size,
                                          GLenum type,
@@ -13167,7 +11980,6 @@
   gl_api_->glVertexAttribPointerFn(indx, size, type, normalized, stride, ptr);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glViewportFn(GLint x, GLint y, GLsizei width, GLsizei height) {
   GL_SERVICE_LOG("glViewport"
                  << "(" << x << ", " << y << ", " << width << ", " << height
@@ -13175,14 +11987,12 @@
   gl_api_->glViewportFn(x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glWaitSyncFn(GLsync sync, GLbitfield flags, GLuint64 timeout) {
   GL_SERVICE_LOG("glWaitSync"
                  << "(" << sync << ", " << flags << ", " << timeout << ")");
   gl_api_->glWaitSyncFn(sync, flags, timeout);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLApi::glWindowRectanglesEXTFn(GLenum mode,
                                          GLsizei n,
                                          const GLint* box) {

diff --git a/ui/gl/gl_bindings_autogen_glx.cc b/ui/gl/gl_bindings_autogen_glx.cc
index 47284d5..44d5391 100644
--- a/ui/gl/gl_bindings_autogen_glx.cc
+++ b/ui/gl/gl_bindings_autogen_glx.cc

@@ -10,8 +10,6 @@
 
 #include <string>
 
-#include "base/compiler_specific.h"
-#include "base/memory/protected_memory.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
@@ -22,10 +20,7 @@
 
 namespace gl {
 
-// Place the driver in protected memory so that it is set
-// read-only after it is initialized, preventing it from
-// being tampered with. See http://crbug.com/771365.
-PROTECTED_MEMORY_SECTION base::ProtectedMemory<DriverGLX> g_driver_glx;
+DriverGLX g_driver_glx;  // Exists in .bss
 
 void DriverGLX::InitializeStaticBindings() {
   // Ensure struct has been zero-initialized.
@@ -188,7 +183,6 @@
   memset(this, 0, sizeof(*this));
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXBindTexImageEXTFn(Display* dpy,
                                       GLXDrawable drawable,
                                       int buffer,
@@ -196,7 +190,6 @@
   driver_->fn.glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig* GLXApiBase::glXChooseFBConfigFn(Display* dpy,
                                              int screen,
                                              const int* attribList,
@@ -204,14 +197,12 @@
   return driver_->fn.glXChooseFBConfigFn(dpy, screen, attribList, nitems);
 }
 
-DISABLE_CFI_ICALL
 XVisualInfo* GLXApiBase::glXChooseVisualFn(Display* dpy,
                                            int screen,
                                            int* attribList) {
   return driver_->fn.glXChooseVisualFn(dpy, screen, attribList);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXCopyContextFn(Display* dpy,
                                   GLXContext src,
                                   GLXContext dst,
@@ -219,7 +210,6 @@
   driver_->fn.glXCopyContextFn(dpy, src, dst, mask);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXCopySubBufferMESAFn(Display* dpy,
                                         GLXDrawable drawable,
                                         int x,
@@ -229,7 +219,6 @@
   driver_->fn.glXCopySubBufferMESAFn(dpy, drawable, x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 GLXContext GLXApiBase::glXCreateContextFn(Display* dpy,
                                           XVisualInfo* vis,
                                           GLXContext shareList,
@@ -237,7 +226,6 @@
   return driver_->fn.glXCreateContextFn(dpy, vis, shareList, direct);
 }
 
-DISABLE_CFI_ICALL
 GLXContext GLXApiBase::glXCreateContextAttribsARBFn(Display* dpy,
                                                     GLXFBConfig config,
                                                     GLXContext share_context,
@@ -247,14 +235,12 @@
                                                   direct, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 GLXPixmap GLXApiBase::glXCreateGLXPixmapFn(Display* dpy,
                                            XVisualInfo* visual,
                                            Pixmap pixmap) {
   return driver_->fn.glXCreateGLXPixmapFn(dpy, visual, pixmap);
 }
 
-DISABLE_CFI_ICALL
 GLXContext GLXApiBase::glXCreateNewContextFn(Display* dpy,
                                              GLXFBConfig config,
                                              int renderType,
@@ -264,14 +250,12 @@
                                            direct);
 }
 
-DISABLE_CFI_ICALL
 GLXPbuffer GLXApiBase::glXCreatePbufferFn(Display* dpy,
                                           GLXFBConfig config,
                                           const int* attribList) {
   return driver_->fn.glXCreatePbufferFn(dpy, config, attribList);
 }
 
-DISABLE_CFI_ICALL
 GLXPixmap GLXApiBase::glXCreatePixmapFn(Display* dpy,
                                         GLXFBConfig config,
                                         Pixmap pixmap,
@@ -279,7 +263,6 @@
   return driver_->fn.glXCreatePixmapFn(dpy, config, pixmap, attribList);
 }
 
-DISABLE_CFI_ICALL
 GLXWindow GLXApiBase::glXCreateWindowFn(Display* dpy,
                                         GLXFBConfig config,
                                         Window win,
@@ -287,37 +270,30 @@
   return driver_->fn.glXCreateWindowFn(dpy, config, win, attribList);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXDestroyContextFn(Display* dpy, GLXContext ctx) {
   driver_->fn.glXDestroyContextFn(dpy, ctx);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXDestroyGLXPixmapFn(Display* dpy, GLXPixmap pixmap) {
   driver_->fn.glXDestroyGLXPixmapFn(dpy, pixmap);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXDestroyPbufferFn(Display* dpy, GLXPbuffer pbuf) {
   driver_->fn.glXDestroyPbufferFn(dpy, pbuf);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXDestroyPixmapFn(Display* dpy, GLXPixmap pixmap) {
   driver_->fn.glXDestroyPixmapFn(dpy, pixmap);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXDestroyWindowFn(Display* dpy, GLXWindow window) {
   driver_->fn.glXDestroyWindowFn(dpy, window);
 }
 
-DISABLE_CFI_ICALL
 const char* GLXApiBase::glXGetClientStringFn(Display* dpy, int name) {
   return driver_->fn.glXGetClientStringFn(dpy, name);
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXGetConfigFn(Display* dpy,
                                XVisualInfo* visual,
                                int attrib,
@@ -325,27 +301,22 @@
   return driver_->fn.glXGetConfigFn(dpy, visual, attrib, value);
 }
 
-DISABLE_CFI_ICALL
 GLXContext GLXApiBase::glXGetCurrentContextFn(void) {
   return driver_->fn.glXGetCurrentContextFn();
 }
 
-DISABLE_CFI_ICALL
 Display* GLXApiBase::glXGetCurrentDisplayFn(void) {
   return driver_->fn.glXGetCurrentDisplayFn();
 }
 
-DISABLE_CFI_ICALL
 GLXDrawable GLXApiBase::glXGetCurrentDrawableFn(void) {
   return driver_->fn.glXGetCurrentDrawableFn();
 }
 
-DISABLE_CFI_ICALL
 GLXDrawable GLXApiBase::glXGetCurrentReadDrawableFn(void) {
   return driver_->fn.glXGetCurrentReadDrawableFn();
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXGetFBConfigAttribFn(Display* dpy,
                                        GLXFBConfig config,
                                        int attribute,
@@ -353,21 +324,18 @@
   return driver_->fn.glXGetFBConfigAttribFn(dpy, config, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig GLXApiBase::glXGetFBConfigFromVisualSGIXFn(
     Display* dpy,
     XVisualInfo* visualInfo) {
   return driver_->fn.glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig* GLXApiBase::glXGetFBConfigsFn(Display* dpy,
                                            int screen,
                                            int* nelements) {
   return driver_->fn.glXGetFBConfigsFn(dpy, screen, nelements);
 }
 
-DISABLE_CFI_ICALL
 bool GLXApiBase::glXGetMscRateOMLFn(Display* dpy,
                                     GLXDrawable drawable,
                                     int32_t* numerator,
@@ -375,14 +343,12 @@
   return driver_->fn.glXGetMscRateOMLFn(dpy, drawable, numerator, denominator);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXGetSelectedEventFn(Display* dpy,
                                        GLXDrawable drawable,
                                        unsigned long* mask) {
   driver_->fn.glXGetSelectedEventFn(dpy, drawable, mask);
 }
 
-DISABLE_CFI_ICALL
 bool GLXApiBase::glXGetSyncValuesOMLFn(Display* dpy,
                                        GLXDrawable drawable,
                                        int64_t* ust,
@@ -391,18 +357,15 @@
   return driver_->fn.glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
 }
 
-DISABLE_CFI_ICALL
 XVisualInfo* GLXApiBase::glXGetVisualFromFBConfigFn(Display* dpy,
                                                     GLXFBConfig config) {
   return driver_->fn.glXGetVisualFromFBConfigFn(dpy, config);
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXIsDirectFn(Display* dpy, GLXContext ctx) {
   return driver_->fn.glXIsDirectFn(dpy, ctx);
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXMakeContextCurrentFn(Display* dpy,
                                         GLXDrawable draw,
                                         GLXDrawable read,
@@ -410,14 +373,12 @@
   return driver_->fn.glXMakeContextCurrentFn(dpy, draw, read, ctx);
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXMakeCurrentFn(Display* dpy,
                                  GLXDrawable drawable,
                                  GLXContext ctx) {
   return driver_->fn.glXMakeCurrentFn(dpy, drawable, ctx);
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXQueryContextFn(Display* dpy,
                                   GLXContext ctx,
                                   int attribute,
@@ -425,7 +386,6 @@
   return driver_->fn.glXQueryContextFn(dpy, ctx, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXQueryDrawableFn(Display* dpy,
                                     GLXDrawable draw,
                                     int attribute,
@@ -433,82 +393,68 @@
   driver_->fn.glXQueryDrawableFn(dpy, draw, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXQueryExtensionFn(Display* dpy, int* errorb, int* event) {
   return driver_->fn.glXQueryExtensionFn(dpy, errorb, event);
 }
 
-DISABLE_CFI_ICALL
 const char* GLXApiBase::glXQueryExtensionsStringFn(Display* dpy, int screen) {
   return driver_->fn.glXQueryExtensionsStringFn(dpy, screen);
 }
 
-DISABLE_CFI_ICALL
 const char* GLXApiBase::glXQueryServerStringFn(Display* dpy,
                                                int screen,
                                                int name) {
   return driver_->fn.glXQueryServerStringFn(dpy, screen, name);
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXQueryVersionFn(Display* dpy, int* maj, int* min) {
   return driver_->fn.glXQueryVersionFn(dpy, maj, min);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXReleaseTexImageEXTFn(Display* dpy,
                                          GLXDrawable drawable,
                                          int buffer) {
   driver_->fn.glXReleaseTexImageEXTFn(dpy, drawable, buffer);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXSelectEventFn(Display* dpy,
                                   GLXDrawable drawable,
                                   unsigned long mask) {
   driver_->fn.glXSelectEventFn(dpy, drawable, mask);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXSwapBuffersFn(Display* dpy, GLXDrawable drawable) {
   driver_->fn.glXSwapBuffersFn(dpy, drawable);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXSwapIntervalEXTFn(Display* dpy,
                                       GLXDrawable drawable,
                                       int interval) {
   driver_->fn.glXSwapIntervalEXTFn(dpy, drawable, interval);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXSwapIntervalMESAFn(unsigned int interval) {
   driver_->fn.glXSwapIntervalMESAFn(interval);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXUseXFontFn(Font font, int first, int count, int list) {
   driver_->fn.glXUseXFontFn(font, first, count, list);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXWaitGLFn(void) {
   driver_->fn.glXWaitGLFn();
 }
 
-DISABLE_CFI_ICALL
 int GLXApiBase::glXWaitVideoSyncSGIFn(int divisor,
                                       int remainder,
                                       unsigned int* count) {
   return driver_->fn.glXWaitVideoSyncSGIFn(divisor, remainder, count);
 }
 
-DISABLE_CFI_ICALL
 void GLXApiBase::glXWaitXFn(void) {
   driver_->fn.glXWaitXFn();
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXBindTexImageEXTFn(Display* dpy,
                                        GLXDrawable drawable,
                                        int buffer,
@@ -517,7 +463,6 @@
   glx_api_->glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig* TraceGLXApi::glXChooseFBConfigFn(Display* dpy,
                                               int screen,
                                               const int* attribList,
@@ -526,7 +471,6 @@
   return glx_api_->glXChooseFBConfigFn(dpy, screen, attribList, nitems);
 }
 
-DISABLE_CFI_ICALL
 XVisualInfo* TraceGLXApi::glXChooseVisualFn(Display* dpy,
                                             int screen,
                                             int* attribList) {
@@ -534,7 +478,6 @@
   return glx_api_->glXChooseVisualFn(dpy, screen, attribList);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXCopyContextFn(Display* dpy,
                                    GLXContext src,
                                    GLXContext dst,
@@ -543,7 +486,6 @@
   glx_api_->glXCopyContextFn(dpy, src, dst, mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXCopySubBufferMESAFn(Display* dpy,
                                          GLXDrawable drawable,
                                          int x,
@@ -554,7 +496,6 @@
   glx_api_->glXCopySubBufferMESAFn(dpy, drawable, x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 GLXContext TraceGLXApi::glXCreateContextFn(Display* dpy,
                                            XVisualInfo* vis,
                                            GLXContext shareList,
@@ -563,7 +504,6 @@
   return glx_api_->glXCreateContextFn(dpy, vis, shareList, direct);
 }
 
-DISABLE_CFI_ICALL
 GLXContext TraceGLXApi::glXCreateContextAttribsARBFn(Display* dpy,
                                                      GLXFBConfig config,
                                                      GLXContext share_context,
@@ -574,7 +514,6 @@
                                                 direct, attrib_list);
 }
 
-DISABLE_CFI_ICALL
 GLXPixmap TraceGLXApi::glXCreateGLXPixmapFn(Display* dpy,
                                             XVisualInfo* visual,
                                             Pixmap pixmap) {
@@ -582,7 +521,6 @@
   return glx_api_->glXCreateGLXPixmapFn(dpy, visual, pixmap);
 }
 
-DISABLE_CFI_ICALL
 GLXContext TraceGLXApi::glXCreateNewContextFn(Display* dpy,
                                               GLXFBConfig config,
                                               int renderType,
@@ -593,7 +531,6 @@
                                          direct);
 }
 
-DISABLE_CFI_ICALL
 GLXPbuffer TraceGLXApi::glXCreatePbufferFn(Display* dpy,
                                            GLXFBConfig config,
                                            const int* attribList) {
@@ -601,7 +538,6 @@
   return glx_api_->glXCreatePbufferFn(dpy, config, attribList);
 }
 
-DISABLE_CFI_ICALL
 GLXPixmap TraceGLXApi::glXCreatePixmapFn(Display* dpy,
                                          GLXFBConfig config,
                                          Pixmap pixmap,
@@ -610,7 +546,6 @@
   return glx_api_->glXCreatePixmapFn(dpy, config, pixmap, attribList);
 }
 
-DISABLE_CFI_ICALL
 GLXWindow TraceGLXApi::glXCreateWindowFn(Display* dpy,
                                          GLXFBConfig config,
                                          Window win,
@@ -619,43 +554,36 @@
   return glx_api_->glXCreateWindowFn(dpy, config, win, attribList);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXDestroyContextFn(Display* dpy, GLXContext ctx) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyContext")
   glx_api_->glXDestroyContextFn(dpy, ctx);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXDestroyGLXPixmapFn(Display* dpy, GLXPixmap pixmap) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyGLXPixmap")
   glx_api_->glXDestroyGLXPixmapFn(dpy, pixmap);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXDestroyPbufferFn(Display* dpy, GLXPbuffer pbuf) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyPbuffer")
   glx_api_->glXDestroyPbufferFn(dpy, pbuf);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXDestroyPixmapFn(Display* dpy, GLXPixmap pixmap) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyPixmap")
   glx_api_->glXDestroyPixmapFn(dpy, pixmap);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXDestroyWindowFn(Display* dpy, GLXWindow window) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXDestroyWindow")
   glx_api_->glXDestroyWindowFn(dpy, window);
 }
 
-DISABLE_CFI_ICALL
 const char* TraceGLXApi::glXGetClientStringFn(Display* dpy, int name) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetClientString")
   return glx_api_->glXGetClientStringFn(dpy, name);
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXGetConfigFn(Display* dpy,
                                 XVisualInfo* visual,
                                 int attrib,
@@ -664,31 +592,26 @@
   return glx_api_->glXGetConfigFn(dpy, visual, attrib, value);
 }
 
-DISABLE_CFI_ICALL
 GLXContext TraceGLXApi::glXGetCurrentContextFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentContext")
   return glx_api_->glXGetCurrentContextFn();
 }
 
-DISABLE_CFI_ICALL
 Display* TraceGLXApi::glXGetCurrentDisplayFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentDisplay")
   return glx_api_->glXGetCurrentDisplayFn();
 }
 
-DISABLE_CFI_ICALL
 GLXDrawable TraceGLXApi::glXGetCurrentDrawableFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentDrawable")
   return glx_api_->glXGetCurrentDrawableFn();
 }
 
-DISABLE_CFI_ICALL
 GLXDrawable TraceGLXApi::glXGetCurrentReadDrawableFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetCurrentReadDrawable")
   return glx_api_->glXGetCurrentReadDrawableFn();
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXGetFBConfigAttribFn(Display* dpy,
                                         GLXFBConfig config,
                                         int attribute,
@@ -697,7 +620,6 @@
   return glx_api_->glXGetFBConfigAttribFn(dpy, config, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig TraceGLXApi::glXGetFBConfigFromVisualSGIXFn(
     Display* dpy,
     XVisualInfo* visualInfo) {
@@ -706,7 +628,6 @@
   return glx_api_->glXGetFBConfigFromVisualSGIXFn(dpy, visualInfo);
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig* TraceGLXApi::glXGetFBConfigsFn(Display* dpy,
                                             int screen,
                                             int* nelements) {
@@ -714,7 +635,6 @@
   return glx_api_->glXGetFBConfigsFn(dpy, screen, nelements);
 }
 
-DISABLE_CFI_ICALL
 bool TraceGLXApi::glXGetMscRateOMLFn(Display* dpy,
                                      GLXDrawable drawable,
                                      int32_t* numerator,
@@ -723,7 +643,6 @@
   return glx_api_->glXGetMscRateOMLFn(dpy, drawable, numerator, denominator);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXGetSelectedEventFn(Display* dpy,
                                         GLXDrawable drawable,
                                         unsigned long* mask) {
@@ -731,7 +650,6 @@
   glx_api_->glXGetSelectedEventFn(dpy, drawable, mask);
 }
 
-DISABLE_CFI_ICALL
 bool TraceGLXApi::glXGetSyncValuesOMLFn(Display* dpy,
                                         GLXDrawable drawable,
                                         int64_t* ust,
@@ -741,20 +659,17 @@
   return glx_api_->glXGetSyncValuesOMLFn(dpy, drawable, ust, msc, sbc);
 }
 
-DISABLE_CFI_ICALL
 XVisualInfo* TraceGLXApi::glXGetVisualFromFBConfigFn(Display* dpy,
                                                      GLXFBConfig config) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXGetVisualFromFBConfig")
   return glx_api_->glXGetVisualFromFBConfigFn(dpy, config);
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXIsDirectFn(Display* dpy, GLXContext ctx) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXIsDirect")
   return glx_api_->glXIsDirectFn(dpy, ctx);
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXMakeContextCurrentFn(Display* dpy,
                                          GLXDrawable draw,
                                          GLXDrawable read,
@@ -763,7 +678,6 @@
   return glx_api_->glXMakeContextCurrentFn(dpy, draw, read, ctx);
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXMakeCurrentFn(Display* dpy,
                                   GLXDrawable drawable,
                                   GLXContext ctx) {
@@ -771,7 +685,6 @@
   return glx_api_->glXMakeCurrentFn(dpy, drawable, ctx);
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXQueryContextFn(Display* dpy,
                                    GLXContext ctx,
                                    int attribute,
@@ -780,7 +693,6 @@
   return glx_api_->glXQueryContextFn(dpy, ctx, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXQueryDrawableFn(Display* dpy,
                                      GLXDrawable draw,
                                      int attribute,
@@ -789,19 +701,16 @@
   glx_api_->glXQueryDrawableFn(dpy, draw, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXQueryExtensionFn(Display* dpy, int* errorb, int* event) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryExtension")
   return glx_api_->glXQueryExtensionFn(dpy, errorb, event);
 }
 
-DISABLE_CFI_ICALL
 const char* TraceGLXApi::glXQueryExtensionsStringFn(Display* dpy, int screen) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryExtensionsString")
   return glx_api_->glXQueryExtensionsStringFn(dpy, screen);
 }
 
-DISABLE_CFI_ICALL
 const char* TraceGLXApi::glXQueryServerStringFn(Display* dpy,
                                                 int screen,
                                                 int name) {
@@ -809,13 +718,11 @@
   return glx_api_->glXQueryServerStringFn(dpy, screen, name);
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXQueryVersionFn(Display* dpy, int* maj, int* min) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXQueryVersion")
   return glx_api_->glXQueryVersionFn(dpy, maj, min);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXReleaseTexImageEXTFn(Display* dpy,
                                           GLXDrawable drawable,
                                           int buffer) {
@@ -823,7 +730,6 @@
   glx_api_->glXReleaseTexImageEXTFn(dpy, drawable, buffer);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXSelectEventFn(Display* dpy,
                                    GLXDrawable drawable,
                                    unsigned long mask) {
@@ -831,13 +737,11 @@
   glx_api_->glXSelectEventFn(dpy, drawable, mask);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXSwapBuffersFn(Display* dpy, GLXDrawable drawable) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSwapBuffers")
   glx_api_->glXSwapBuffersFn(dpy, drawable);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXSwapIntervalEXTFn(Display* dpy,
                                        GLXDrawable drawable,
                                        int interval) {
@@ -845,25 +749,21 @@
   glx_api_->glXSwapIntervalEXTFn(dpy, drawable, interval);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXSwapIntervalMESAFn(unsigned int interval) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXSwapIntervalMESA")
   glx_api_->glXSwapIntervalMESAFn(interval);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXUseXFontFn(Font font, int first, int count, int list) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXUseXFont")
   glx_api_->glXUseXFontFn(font, first, count, list);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXWaitGLFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitGL")
   glx_api_->glXWaitGLFn();
 }
 
-DISABLE_CFI_ICALL
 int TraceGLXApi::glXWaitVideoSyncSGIFn(int divisor,
                                        int remainder,
                                        unsigned int* count) {
@@ -871,13 +771,11 @@
   return glx_api_->glXWaitVideoSyncSGIFn(divisor, remainder, count);
 }
 
-DISABLE_CFI_ICALL
 void TraceGLXApi::glXWaitXFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::glXWaitX")
   glx_api_->glXWaitXFn();
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXBindTexImageEXTFn(Display* dpy,
                                        GLXDrawable drawable,
                                        int buffer,
@@ -889,7 +787,6 @@
   glx_api_->glXBindTexImageEXTFn(dpy, drawable, buffer, attribList);
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig* DebugGLXApi::glXChooseFBConfigFn(Display* dpy,
                                               int screen,
                                               const int* attribList,
@@ -904,7 +801,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 XVisualInfo* DebugGLXApi::glXChooseVisualFn(Display* dpy,
                                             int screen,
                                             int* attribList) {
@@ -916,7 +812,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXCopyContextFn(Display* dpy,
                                    GLXContext src,
                                    GLXContext dst,
@@ -927,7 +822,6 @@
   glx_api_->glXCopyContextFn(dpy, src, dst, mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXCopySubBufferMESAFn(Display* dpy,
                                          GLXDrawable drawable,
                                          int x,
@@ -941,7 +835,6 @@
   glx_api_->glXCopySubBufferMESAFn(dpy, drawable, x, y, width, height);
 }
 
-DISABLE_CFI_ICALL
 GLXContext DebugGLXApi::glXCreateContextFn(Display* dpy,
                                            XVisualInfo* vis,
                                            GLXContext shareList,
@@ -955,7 +848,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXContext DebugGLXApi::glXCreateContextAttribsARBFn(Display* dpy,
                                                      GLXFBConfig config,
                                                      GLXContext share_context,
@@ -971,7 +863,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXPixmap DebugGLXApi::glXCreateGLXPixmapFn(Display* dpy,
                                             XVisualInfo* visual,
                                             Pixmap pixmap) {
@@ -983,7 +874,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXContext DebugGLXApi::glXCreateNewContextFn(Display* dpy,
                                               GLXFBConfig config,
                                               int renderType,
@@ -999,7 +889,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXPbuffer DebugGLXApi::glXCreatePbufferFn(Display* dpy,
                                            GLXFBConfig config,
                                            const int* attribList) {
@@ -1011,7 +900,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXPixmap DebugGLXApi::glXCreatePixmapFn(Display* dpy,
                                          GLXFBConfig config,
                                          Pixmap pixmap,
@@ -1026,7 +914,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXWindow DebugGLXApi::glXCreateWindowFn(Display* dpy,
                                          GLXFBConfig config,
                                          Window win,
@@ -1040,14 +927,12 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXDestroyContextFn(Display* dpy, GLXContext ctx) {
   GL_SERVICE_LOG("glXDestroyContext"
                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
   glx_api_->glXDestroyContextFn(dpy, ctx);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXDestroyGLXPixmapFn(Display* dpy, GLXPixmap pixmap) {
   GL_SERVICE_LOG("glXDestroyGLXPixmap"
                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
@@ -1055,7 +940,6 @@
   glx_api_->glXDestroyGLXPixmapFn(dpy, pixmap);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXDestroyPbufferFn(Display* dpy, GLXPbuffer pbuf) {
   GL_SERVICE_LOG("glXDestroyPbuffer"
                  << "(" << static_cast<const void*>(dpy) << ", " << pbuf
@@ -1063,7 +947,6 @@
   glx_api_->glXDestroyPbufferFn(dpy, pbuf);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXDestroyPixmapFn(Display* dpy, GLXPixmap pixmap) {
   GL_SERVICE_LOG("glXDestroyPixmap"
                  << "(" << static_cast<const void*>(dpy) << ", " << pixmap
@@ -1071,7 +954,6 @@
   glx_api_->glXDestroyPixmapFn(dpy, pixmap);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXDestroyWindowFn(Display* dpy, GLXWindow window) {
   GL_SERVICE_LOG("glXDestroyWindow"
                  << "(" << static_cast<const void*>(dpy) << ", " << window
@@ -1079,7 +961,6 @@
   glx_api_->glXDestroyWindowFn(dpy, window);
 }
 
-DISABLE_CFI_ICALL
 const char* DebugGLXApi::glXGetClientStringFn(Display* dpy, int name) {
   GL_SERVICE_LOG("glXGetClientString"
                  << "(" << static_cast<const void*>(dpy) << ", " << name
@@ -1089,7 +970,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXGetConfigFn(Display* dpy,
                                 XVisualInfo* visual,
                                 int attrib,
@@ -1103,7 +983,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXContext DebugGLXApi::glXGetCurrentContextFn(void) {
   GL_SERVICE_LOG("glXGetCurrentContext"
                  << "("
@@ -1113,7 +992,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 Display* DebugGLXApi::glXGetCurrentDisplayFn(void) {
   GL_SERVICE_LOG("glXGetCurrentDisplay"
                  << "("
@@ -1123,7 +1001,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXDrawable DebugGLXApi::glXGetCurrentDrawableFn(void) {
   GL_SERVICE_LOG("glXGetCurrentDrawable"
                  << "("
@@ -1133,7 +1010,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXDrawable DebugGLXApi::glXGetCurrentReadDrawableFn(void) {
   GL_SERVICE_LOG("glXGetCurrentReadDrawable"
                  << "("
@@ -1143,7 +1019,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXGetFBConfigAttribFn(Display* dpy,
                                         GLXFBConfig config,
                                         int attribute,
@@ -1157,7 +1032,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig DebugGLXApi::glXGetFBConfigFromVisualSGIXFn(
     Display* dpy,
     XVisualInfo* visualInfo) {
@@ -1170,7 +1044,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLXFBConfig* DebugGLXApi::glXGetFBConfigsFn(Display* dpy,
                                             int screen,
                                             int* nelements) {
@@ -1182,7 +1055,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 bool DebugGLXApi::glXGetMscRateOMLFn(Display* dpy,
                                      GLXDrawable drawable,
                                      int32_t* numerator,
@@ -1197,7 +1069,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXGetSelectedEventFn(Display* dpy,
                                         GLXDrawable drawable,
                                         unsigned long* mask) {
@@ -1207,7 +1078,6 @@
   glx_api_->glXGetSelectedEventFn(dpy, drawable, mask);
 }
 
-DISABLE_CFI_ICALL
 bool DebugGLXApi::glXGetSyncValuesOMLFn(Display* dpy,
                                         GLXDrawable drawable,
                                         int64_t* ust,
@@ -1223,7 +1093,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 XVisualInfo* DebugGLXApi::glXGetVisualFromFBConfigFn(Display* dpy,
                                                      GLXFBConfig config) {
   GL_SERVICE_LOG("glXGetVisualFromFBConfig"
@@ -1234,7 +1103,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXIsDirectFn(Display* dpy, GLXContext ctx) {
   GL_SERVICE_LOG("glXIsDirect"
                  << "(" << static_cast<const void*>(dpy) << ", " << ctx << ")");
@@ -1243,7 +1111,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXMakeContextCurrentFn(Display* dpy,
                                          GLXDrawable draw,
                                          GLXDrawable read,
@@ -1256,7 +1123,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXMakeCurrentFn(Display* dpy,
                                   GLXDrawable drawable,
                                   GLXContext ctx) {
@@ -1268,7 +1134,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXQueryContextFn(Display* dpy,
                                    GLXContext ctx,
                                    int attribute,
@@ -1282,7 +1147,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXQueryDrawableFn(Display* dpy,
                                      GLXDrawable draw,
                                      int attribute,
@@ -1294,7 +1158,6 @@
   glx_api_->glXQueryDrawableFn(dpy, draw, attribute, value);
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXQueryExtensionFn(Display* dpy, int* errorb, int* event) {
   GL_SERVICE_LOG("glXQueryExtension"
                  << "(" << static_cast<const void*>(dpy) << ", "
@@ -1305,7 +1168,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 const char* DebugGLXApi::glXQueryExtensionsStringFn(Display* dpy, int screen) {
   GL_SERVICE_LOG("glXQueryExtensionsString"
                  << "(" << static_cast<const void*>(dpy) << ", " << screen
@@ -1315,7 +1177,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 const char* DebugGLXApi::glXQueryServerStringFn(Display* dpy,
                                                 int screen,
                                                 int name) {
@@ -1327,7 +1188,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXQueryVersionFn(Display* dpy, int* maj, int* min) {
   GL_SERVICE_LOG("glXQueryVersion"
                  << "(" << static_cast<const void*>(dpy) << ", "
@@ -1338,7 +1198,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXReleaseTexImageEXTFn(Display* dpy,
                                           GLXDrawable drawable,
                                           int buffer) {
@@ -1348,7 +1207,6 @@
   glx_api_->glXReleaseTexImageEXTFn(dpy, drawable, buffer);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXSelectEventFn(Display* dpy,
                                    GLXDrawable drawable,
                                    unsigned long mask) {
@@ -1358,7 +1216,6 @@
   glx_api_->glXSelectEventFn(dpy, drawable, mask);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXSwapBuffersFn(Display* dpy, GLXDrawable drawable) {
   GL_SERVICE_LOG("glXSwapBuffers"
                  << "(" << static_cast<const void*>(dpy) << ", " << drawable
@@ -1366,7 +1223,6 @@
   glx_api_->glXSwapBuffersFn(dpy, drawable);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXSwapIntervalEXTFn(Display* dpy,
                                        GLXDrawable drawable,
                                        int interval) {
@@ -1376,14 +1232,12 @@
   glx_api_->glXSwapIntervalEXTFn(dpy, drawable, interval);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXSwapIntervalMESAFn(unsigned int interval) {
   GL_SERVICE_LOG("glXSwapIntervalMESA"
                  << "(" << interval << ")");
   glx_api_->glXSwapIntervalMESAFn(interval);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXUseXFontFn(Font font, int first, int count, int list) {
   GL_SERVICE_LOG("glXUseXFont"
                  << "(" << font << ", " << first << ", " << count << ", "
@@ -1391,7 +1245,6 @@
   glx_api_->glXUseXFontFn(font, first, count, list);
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXWaitGLFn(void) {
   GL_SERVICE_LOG("glXWaitGL"
                  << "("
@@ -1399,7 +1252,6 @@
   glx_api_->glXWaitGLFn();
 }
 
-DISABLE_CFI_ICALL
 int DebugGLXApi::glXWaitVideoSyncSGIFn(int divisor,
                                        int remainder,
                                        unsigned int* count) {
@@ -1411,7 +1263,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugGLXApi::glXWaitXFn(void) {
   GL_SERVICE_LOG("glXWaitX"
                  << "("

diff --git a/ui/gl/gl_bindings_autogen_osmesa.cc b/ui/gl/gl_bindings_autogen_osmesa.cc
index 22bbbd2..75bd1e9 100644
--- a/ui/gl/gl_bindings_autogen_osmesa.cc
+++ b/ui/gl/gl_bindings_autogen_osmesa.cc

@@ -10,8 +10,6 @@
 
 #include <string>
 
-#include "base/compiler_specific.h"
-#include "base/memory/protected_memory.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
@@ -22,10 +20,7 @@
 
 namespace gl {
 
-// Place the driver in protected memory so that it is set
-// read-only after it is initialized, preventing it from
-// being tampered with. See http://crbug.com/771365.
-PROTECTED_MEMORY_SECTION base::ProtectedMemory<DriverOSMESA> g_driver_osmesa;
+DriverOSMESA g_driver_osmesa;  // Exists in .bss
 
 void DriverOSMESA::InitializeStaticBindings() {
   // Ensure struct has been zero-initialized.
@@ -67,18 +62,15 @@
   memset(this, 0, sizeof(*this));
 }
 
-DISABLE_CFI_ICALL
 void OSMESAApiBase::OSMesaColorClampFn(GLboolean enable) {
   driver_->fn.OSMesaColorClampFn(enable);
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext OSMESAApiBase::OSMesaCreateContextFn(GLenum format,
                                                    OSMesaContext sharelist) {
   return driver_->fn.OSMesaCreateContextFn(format, sharelist);
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext OSMESAApiBase::OSMesaCreateContextExtFn(GLenum format,
                                                       GLint depthBits,
                                                       GLint stencilBits,
@@ -88,12 +80,10 @@
                                               accumBits, sharelist);
 }
 
-DISABLE_CFI_ICALL
 void OSMESAApiBase::OSMesaDestroyContextFn(OSMesaContext ctx) {
   driver_->fn.OSMesaDestroyContextFn(ctx);
 }
 
-DISABLE_CFI_ICALL
 GLboolean OSMESAApiBase::OSMesaGetColorBufferFn(OSMesaContext c,
                                                 GLint* width,
                                                 GLint* height,
@@ -102,12 +92,10 @@
   return driver_->fn.OSMesaGetColorBufferFn(c, width, height, format, buffer);
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext OSMESAApiBase::OSMesaGetCurrentContextFn(void) {
   return driver_->fn.OSMesaGetCurrentContextFn();
 }
 
-DISABLE_CFI_ICALL
 GLboolean OSMESAApiBase::OSMesaGetDepthBufferFn(OSMesaContext c,
                                                 GLint* width,
                                                 GLint* height,
@@ -117,17 +105,14 @@
                                             buffer);
 }
 
-DISABLE_CFI_ICALL
 void OSMESAApiBase::OSMesaGetIntegervFn(GLint pname, GLint* value) {
   driver_->fn.OSMesaGetIntegervFn(pname, value);
 }
 
-DISABLE_CFI_ICALL
 OSMESAproc OSMESAApiBase::OSMesaGetProcAddressFn(const char* funcName) {
   return driver_->fn.OSMesaGetProcAddressFn(funcName);
 }
 
-DISABLE_CFI_ICALL
 GLboolean OSMESAApiBase::OSMesaMakeCurrentFn(OSMesaContext ctx,
                                              void* buffer,
                                              GLenum type,
@@ -136,25 +121,21 @@
   return driver_->fn.OSMesaMakeCurrentFn(ctx, buffer, type, width, height);
 }
 
-DISABLE_CFI_ICALL
 void OSMESAApiBase::OSMesaPixelStoreFn(GLint pname, GLint value) {
   driver_->fn.OSMesaPixelStoreFn(pname, value);
 }
 
-DISABLE_CFI_ICALL
 void TraceOSMESAApi::OSMesaColorClampFn(GLboolean enable) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::OSMesaColorClamp")
   osmesa_api_->OSMesaColorClampFn(enable);
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext TraceOSMESAApi::OSMesaCreateContextFn(GLenum format,
                                                     OSMesaContext sharelist) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::OSMesaCreateContext")
   return osmesa_api_->OSMesaCreateContextFn(format, sharelist);
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext TraceOSMESAApi::OSMesaCreateContextExtFn(
     GLenum format,
     GLint depthBits,
@@ -166,13 +147,11 @@
                                                accumBits, sharelist);
 }
 
-DISABLE_CFI_ICALL
 void TraceOSMESAApi::OSMesaDestroyContextFn(OSMesaContext ctx) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::OSMesaDestroyContext")
   osmesa_api_->OSMesaDestroyContextFn(ctx);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceOSMESAApi::OSMesaGetColorBufferFn(OSMesaContext c,
                                                  GLint* width,
                                                  GLint* height,
@@ -182,13 +161,11 @@
   return osmesa_api_->OSMesaGetColorBufferFn(c, width, height, format, buffer);
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext TraceOSMESAApi::OSMesaGetCurrentContextFn(void) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::OSMesaGetCurrentContext")
   return osmesa_api_->OSMesaGetCurrentContextFn();
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceOSMESAApi::OSMesaGetDepthBufferFn(OSMesaContext c,
                                                  GLint* width,
                                                  GLint* height,
@@ -199,19 +176,16 @@
                                              buffer);
 }
 
-DISABLE_CFI_ICALL
 void TraceOSMESAApi::OSMesaGetIntegervFn(GLint pname, GLint* value) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::OSMesaGetIntegerv")
   osmesa_api_->OSMesaGetIntegervFn(pname, value);
 }
 
-DISABLE_CFI_ICALL
 OSMESAproc TraceOSMESAApi::OSMesaGetProcAddressFn(const char* funcName) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::OSMesaGetProcAddress")
   return osmesa_api_->OSMesaGetProcAddressFn(funcName);
 }
 
-DISABLE_CFI_ICALL
 GLboolean TraceOSMESAApi::OSMesaMakeCurrentFn(OSMesaContext ctx,
                                               void* buffer,
                                               GLenum type,
@@ -221,20 +195,17 @@
   return osmesa_api_->OSMesaMakeCurrentFn(ctx, buffer, type, width, height);
 }
 
-DISABLE_CFI_ICALL
 void TraceOSMESAApi::OSMesaPixelStoreFn(GLint pname, GLint value) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::OSMesaPixelStore")
   osmesa_api_->OSMesaPixelStoreFn(pname, value);
 }
 
-DISABLE_CFI_ICALL
 void DebugOSMESAApi::OSMesaColorClampFn(GLboolean enable) {
   GL_SERVICE_LOG("OSMesaColorClamp"
                  << "(" << GLEnums::GetStringBool(enable) << ")");
   osmesa_api_->OSMesaColorClampFn(enable);
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext DebugOSMESAApi::OSMesaCreateContextFn(GLenum format,
                                                     OSMesaContext sharelist) {
   GL_SERVICE_LOG("OSMesaCreateContext"
@@ -245,7 +216,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext DebugOSMESAApi::OSMesaCreateContextExtFn(
     GLenum format,
     GLint depthBits,
@@ -262,14 +232,12 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugOSMESAApi::OSMesaDestroyContextFn(OSMesaContext ctx) {
   GL_SERVICE_LOG("OSMesaDestroyContext"
                  << "(" << ctx << ")");
   osmesa_api_->OSMesaDestroyContextFn(ctx);
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugOSMESAApi::OSMesaGetColorBufferFn(OSMesaContext c,
                                                  GLint* width,
                                                  GLint* height,
@@ -285,7 +253,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 OSMesaContext DebugOSMESAApi::OSMesaGetCurrentContextFn(void) {
   GL_SERVICE_LOG("OSMesaGetCurrentContext"
                  << "("
@@ -295,7 +262,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugOSMESAApi::OSMesaGetDepthBufferFn(OSMesaContext c,
                                                  GLint* width,
                                                  GLint* height,
@@ -312,7 +278,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugOSMESAApi::OSMesaGetIntegervFn(GLint pname, GLint* value) {
   GL_SERVICE_LOG("OSMesaGetIntegerv"
                  << "(" << pname << ", " << static_cast<const void*>(value)
@@ -320,7 +285,6 @@
   osmesa_api_->OSMesaGetIntegervFn(pname, value);
 }
 
-DISABLE_CFI_ICALL
 OSMESAproc DebugOSMESAApi::OSMesaGetProcAddressFn(const char* funcName) {
   GL_SERVICE_LOG("OSMesaGetProcAddress"
                  << "(" << funcName << ")");
@@ -329,7 +293,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 GLboolean DebugOSMESAApi::OSMesaMakeCurrentFn(OSMesaContext ctx,
                                               void* buffer,
                                               GLenum type,
@@ -345,7 +308,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 void DebugOSMESAApi::OSMesaPixelStoreFn(GLint pname, GLint value) {
   GL_SERVICE_LOG("OSMesaPixelStore"
                  << "(" << pname << ", " << value << ")");

diff --git a/ui/gl/gl_bindings_autogen_wgl.cc b/ui/gl/gl_bindings_autogen_wgl.cc
index 3c40f10e..547cf73 100644
--- a/ui/gl/gl_bindings_autogen_wgl.cc
+++ b/ui/gl/gl_bindings_autogen_wgl.cc

@@ -10,8 +10,6 @@
 
 #include <string>
 
-#include "base/compiler_specific.h"
-#include "base/memory/protected_memory.h"
 #include "base/trace_event/trace_event.h"
 #include "ui/gl/gl_bindings.h"
 #include "ui/gl/gl_context.h"
@@ -22,10 +20,7 @@
 
 namespace gl {
 
-// Place the driver in protected memory so that it is set
-// read-only after it is initialized, preventing it from
-// being tampered with. See http://crbug.com/771365.
-PROTECTED_MEMORY_SECTION base::ProtectedMemory<DriverWGL> g_driver_wgl;
+DriverWGL g_driver_wgl;  // Exists in .bss
 
 void DriverWGL::InitializeStaticBindings() {
   // Ensure struct has been zero-initialized.
@@ -121,7 +116,6 @@
   memset(this, 0, sizeof(*this));
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglChoosePixelFormatARBFn(HDC dc,
                                            const int* int_attrib_list,
                                            const float* float_attrib_list,
@@ -133,17 +127,14 @@
                                                formats, num_formats);
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglCopyContextFn(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask) {
   return driver_->fn.wglCopyContextFn(hglrcSrc, hglrcDst, mask);
 }
 
-DISABLE_CFI_ICALL
 HGLRC WGLApiBase::wglCreateContextFn(HDC hdc) {
   return driver_->fn.wglCreateContextFn(hdc);
 }
 
-DISABLE_CFI_ICALL
 HGLRC WGLApiBase::wglCreateContextAttribsARBFn(HDC hDC,
                                                HGLRC hShareContext,
                                                const int* attribList) {
@@ -151,12 +142,10 @@
                                                   attribList);
 }
 
-DISABLE_CFI_ICALL
 HGLRC WGLApiBase::wglCreateLayerContextFn(HDC hdc, int iLayerPlane) {
   return driver_->fn.wglCreateLayerContextFn(hdc, iLayerPlane);
 }
 
-DISABLE_CFI_ICALL
 HPBUFFERARB WGLApiBase::wglCreatePbufferARBFn(HDC hDC,
                                               int iPixelFormat,
                                               int iWidth,
@@ -166,74 +155,60 @@
                                            piAttribList);
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglDeleteContextFn(HGLRC hglrc) {
   return driver_->fn.wglDeleteContextFn(hglrc);
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglDestroyPbufferARBFn(HPBUFFERARB hPbuffer) {
   return driver_->fn.wglDestroyPbufferARBFn(hPbuffer);
 }
 
-DISABLE_CFI_ICALL
 HGLRC WGLApiBase::wglGetCurrentContextFn() {
   return driver_->fn.wglGetCurrentContextFn();
 }
 
-DISABLE_CFI_ICALL
 HDC WGLApiBase::wglGetCurrentDCFn() {
   return driver_->fn.wglGetCurrentDCFn();
 }
 
-DISABLE_CFI_ICALL
 const char* WGLApiBase::wglGetExtensionsStringARBFn(HDC hDC) {
   return driver_->fn.wglGetExtensionsStringARBFn(hDC);
 }
 
-DISABLE_CFI_ICALL
 const char* WGLApiBase::wglGetExtensionsStringEXTFn() {
   return driver_->fn.wglGetExtensionsStringEXTFn();
 }
 
-DISABLE_CFI_ICALL
 HDC WGLApiBase::wglGetPbufferDCARBFn(HPBUFFERARB hPbuffer) {
   return driver_->fn.wglGetPbufferDCARBFn(hPbuffer);
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglMakeCurrentFn(HDC hdc, HGLRC hglrc) {
   return driver_->fn.wglMakeCurrentFn(hdc, hglrc);
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglQueryPbufferARBFn(HPBUFFERARB hPbuffer,
                                       int iAttribute,
                                       int* piValue) {
   return driver_->fn.wglQueryPbufferARBFn(hPbuffer, iAttribute, piValue);
 }
 
-DISABLE_CFI_ICALL
 int WGLApiBase::wglReleasePbufferDCARBFn(HPBUFFERARB hPbuffer, HDC hDC) {
   return driver_->fn.wglReleasePbufferDCARBFn(hPbuffer, hDC);
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglShareListsFn(HGLRC hglrc1, HGLRC hglrc2) {
   return driver_->fn.wglShareListsFn(hglrc1, hglrc2);
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglSwapIntervalEXTFn(int interval) {
   return driver_->fn.wglSwapIntervalEXTFn(interval);
 }
 
-DISABLE_CFI_ICALL
 BOOL WGLApiBase::wglSwapLayerBuffersFn(HDC hdc, UINT fuPlanes) {
   return driver_->fn.wglSwapLayerBuffersFn(hdc, fuPlanes);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglChoosePixelFormatARBFn(HDC dc,
                                             const int* int_attrib_list,
                                             const float* float_attrib_list,
@@ -246,19 +221,16 @@
                                              formats, num_formats);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglCopyContextFn(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglCopyContext")
   return wgl_api_->wglCopyContextFn(hglrcSrc, hglrcDst, mask);
 }
 
-DISABLE_CFI_ICALL
 HGLRC TraceWGLApi::wglCreateContextFn(HDC hdc) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglCreateContext")
   return wgl_api_->wglCreateContextFn(hdc);
 }
 
-DISABLE_CFI_ICALL
 HGLRC TraceWGLApi::wglCreateContextAttribsARBFn(HDC hDC,
                                                 HGLRC hShareContext,
                                                 const int* attribList) {
@@ -266,13 +238,11 @@
   return wgl_api_->wglCreateContextAttribsARBFn(hDC, hShareContext, attribList);
 }
 
-DISABLE_CFI_ICALL
 HGLRC TraceWGLApi::wglCreateLayerContextFn(HDC hdc, int iLayerPlane) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglCreateLayerContext")
   return wgl_api_->wglCreateLayerContextFn(hdc, iLayerPlane);
 }
 
-DISABLE_CFI_ICALL
 HPBUFFERARB TraceWGLApi::wglCreatePbufferARBFn(HDC hDC,
                                                int iPixelFormat,
                                                int iWidth,
@@ -283,55 +253,46 @@
                                          piAttribList);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglDeleteContextFn(HGLRC hglrc) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglDeleteContext")
   return wgl_api_->wglDeleteContextFn(hglrc);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglDestroyPbufferARBFn(HPBUFFERARB hPbuffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglDestroyPbufferARB")
   return wgl_api_->wglDestroyPbufferARBFn(hPbuffer);
 }
 
-DISABLE_CFI_ICALL
 HGLRC TraceWGLApi::wglGetCurrentContextFn() {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglGetCurrentContext")
   return wgl_api_->wglGetCurrentContextFn();
 }
 
-DISABLE_CFI_ICALL
 HDC TraceWGLApi::wglGetCurrentDCFn() {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglGetCurrentDC")
   return wgl_api_->wglGetCurrentDCFn();
 }
 
-DISABLE_CFI_ICALL
 const char* TraceWGLApi::wglGetExtensionsStringARBFn(HDC hDC) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglGetExtensionsStringARB")
   return wgl_api_->wglGetExtensionsStringARBFn(hDC);
 }
 
-DISABLE_CFI_ICALL
 const char* TraceWGLApi::wglGetExtensionsStringEXTFn() {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglGetExtensionsStringEXT")
   return wgl_api_->wglGetExtensionsStringEXTFn();
 }
 
-DISABLE_CFI_ICALL
 HDC TraceWGLApi::wglGetPbufferDCARBFn(HPBUFFERARB hPbuffer) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglGetPbufferDCARB")
   return wgl_api_->wglGetPbufferDCARBFn(hPbuffer);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglMakeCurrentFn(HDC hdc, HGLRC hglrc) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglMakeCurrent")
   return wgl_api_->wglMakeCurrentFn(hdc, hglrc);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglQueryPbufferARBFn(HPBUFFERARB hPbuffer,
                                        int iAttribute,
                                        int* piValue) {
@@ -339,31 +300,26 @@
   return wgl_api_->wglQueryPbufferARBFn(hPbuffer, iAttribute, piValue);
 }
 
-DISABLE_CFI_ICALL
 int TraceWGLApi::wglReleasePbufferDCARBFn(HPBUFFERARB hPbuffer, HDC hDC) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglReleasePbufferDCARB")
   return wgl_api_->wglReleasePbufferDCARBFn(hPbuffer, hDC);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglShareListsFn(HGLRC hglrc1, HGLRC hglrc2) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglShareLists")
   return wgl_api_->wglShareListsFn(hglrc1, hglrc2);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglSwapIntervalEXTFn(int interval) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglSwapIntervalEXT")
   return wgl_api_->wglSwapIntervalEXTFn(interval);
 }
 
-DISABLE_CFI_ICALL
 BOOL TraceWGLApi::wglSwapLayerBuffersFn(HDC hdc, UINT fuPlanes) {
   TRACE_EVENT_BINARY_EFFICIENT0("gpu", "TraceGLAPI::wglSwapLayerBuffers")
   return wgl_api_->wglSwapLayerBuffersFn(hdc, fuPlanes);
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglChoosePixelFormatARBFn(HDC dc,
                                             const int* int_attrib_list,
                                             const float* float_attrib_list,
@@ -383,7 +339,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglCopyContextFn(HGLRC hglrcSrc, HGLRC hglrcDst, UINT mask) {
   GL_SERVICE_LOG("wglCopyContext"
                  << "(" << hglrcSrc << ", " << hglrcDst << ", " << mask << ")");
@@ -392,7 +347,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 HGLRC DebugWGLApi::wglCreateContextFn(HDC hdc) {
   GL_SERVICE_LOG("wglCreateContext"
                  << "(" << hdc << ")");
@@ -401,7 +355,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 HGLRC DebugWGLApi::wglCreateContextAttribsARBFn(HDC hDC,
                                                 HGLRC hShareContext,
                                                 const int* attribList) {
@@ -414,7 +367,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 HGLRC DebugWGLApi::wglCreateLayerContextFn(HDC hdc, int iLayerPlane) {
   GL_SERVICE_LOG("wglCreateLayerContext"
                  << "(" << hdc << ", " << iLayerPlane << ")");
@@ -423,7 +375,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 HPBUFFERARB DebugWGLApi::wglCreatePbufferARBFn(HDC hDC,
                                                int iPixelFormat,
                                                int iWidth,
@@ -439,7 +390,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglDeleteContextFn(HGLRC hglrc) {
   GL_SERVICE_LOG("wglDeleteContext"
                  << "(" << hglrc << ")");
@@ -448,7 +398,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglDestroyPbufferARBFn(HPBUFFERARB hPbuffer) {
   GL_SERVICE_LOG("wglDestroyPbufferARB"
                  << "(" << hPbuffer << ")");
@@ -457,7 +406,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 HGLRC DebugWGLApi::wglGetCurrentContextFn() {
   GL_SERVICE_LOG("wglGetCurrentContext"
                  << "("
@@ -467,7 +415,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 HDC DebugWGLApi::wglGetCurrentDCFn() {
   GL_SERVICE_LOG("wglGetCurrentDC"
                  << "("
@@ -477,7 +424,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 const char* DebugWGLApi::wglGetExtensionsStringARBFn(HDC hDC) {
   GL_SERVICE_LOG("wglGetExtensionsStringARB"
                  << "(" << hDC << ")");
@@ -486,7 +432,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 const char* DebugWGLApi::wglGetExtensionsStringEXTFn() {
   GL_SERVICE_LOG("wglGetExtensionsStringEXT"
                  << "("
@@ -496,7 +441,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 HDC DebugWGLApi::wglGetPbufferDCARBFn(HPBUFFERARB hPbuffer) {
   GL_SERVICE_LOG("wglGetPbufferDCARB"
                  << "(" << hPbuffer << ")");
@@ -505,7 +449,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglMakeCurrentFn(HDC hdc, HGLRC hglrc) {
   GL_SERVICE_LOG("wglMakeCurrent"
                  << "(" << hdc << ", " << hglrc << ")");
@@ -514,7 +457,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglQueryPbufferARBFn(HPBUFFERARB hPbuffer,
                                        int iAttribute,
                                        int* piValue) {
@@ -526,7 +468,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 int DebugWGLApi::wglReleasePbufferDCARBFn(HPBUFFERARB hPbuffer, HDC hDC) {
   GL_SERVICE_LOG("wglReleasePbufferDCARB"
                  << "(" << hPbuffer << ", " << hDC << ")");
@@ -535,7 +476,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglShareListsFn(HGLRC hglrc1, HGLRC hglrc2) {
   GL_SERVICE_LOG("wglShareLists"
                  << "(" << hglrc1 << ", " << hglrc2 << ")");
@@ -544,7 +484,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglSwapIntervalEXTFn(int interval) {
   GL_SERVICE_LOG("wglSwapIntervalEXT"
                  << "(" << interval << ")");
@@ -553,7 +492,6 @@
   return result;
 }
 
-DISABLE_CFI_ICALL
 BOOL DebugWGLApi::wglSwapLayerBuffersFn(HDC hdc, UINT fuPlanes) {
   GL_SERVICE_LOG("wglSwapLayerBuffers"
                  << "(" << hdc << ", " << fuPlanes << ")");

diff --git a/ui/gl/gl_context_glx_unittest.cc b/ui/gl/gl_context_glx_unittest.cc
index da01392..25478c7 100644
--- a/ui/gl/gl_context_glx_unittest.cc
+++ b/ui/gl/gl_context_glx_unittest.cc

@@ -65,12 +65,12 @@
     // window. In those cases, override the glx api to force MakeCurrent() to
     // fail.
     context->ReleaseCurrent(surface.get());
-    auto real_fn = g_driver_glx->fn.glXMakeContextCurrentFn;
-    g_driver_glx->fn.glXMakeContextCurrentFn =
+    auto real_fn = g_driver_glx.fn.glXMakeContextCurrentFn;
+    g_driver_glx.fn.glXMakeContextCurrentFn =
         [](Display* display, GLXDrawable drawable, GLXDrawable read,
            GLXContext context) -> int { return 0; };
     EXPECT_FALSE(context->MakeCurrent(surface.get()));
-    g_driver_glx->fn.glXMakeContextCurrentFn = real_fn;
+    g_driver_glx.fn.glXMakeContextCurrentFn = real_fn;
   }
   // At this point, MakeCurrent() failed. Make sure the GLContextGLX still was
   // not destroyed.

diff --git a/ui/gl/gl_context_wgl.cc b/ui/gl/gl_context_wgl.cc
index 01b6252c..520b4ca 100644
--- a/ui/gl/gl_context_wgl.cc
+++ b/ui/gl/gl_context_wgl.cc

@@ -153,7 +153,7 @@
 
 void GLContextWGL::OnSetSwapInterval(int interval) {
   DCHECK(IsCurrent(nullptr));
-  if (g_driver_wgl->ext.b_WGL_EXT_swap_control) {
+  if (g_driver_wgl.ext.b_WGL_EXT_swap_control) {
     wglSwapIntervalEXT(interval);
   } else {
       LOG(WARNING) <<

diff --git a/ui/gl/gl_egl_api_implementation.cc b/ui/gl/gl_egl_api_implementation.cc
index 5bc79cb..f3bcf75 100644
--- a/ui/gl/gl_egl_api_implementation.cc
+++ b/ui/gl/gl_egl_api_implementation.cc

@@ -17,12 +17,11 @@
 DebugEGLApi* g_debug_egl = nullptr;
 
 void InitializeStaticGLBindingsEGL() {
-  auto writer = base::AutoWritableMemory::Create(g_driver_egl);
-  g_driver_egl->InitializeStaticBindings();
+  g_driver_egl.InitializeStaticBindings();
   if (!g_real_egl) {
     g_real_egl = new RealEGLApi();
   }
-  g_real_egl->Initialize(&*g_driver_egl);
+  g_real_egl->Initialize(&g_driver_egl);
   g_current_egl_context = g_real_egl;
 }
 
@@ -43,8 +42,7 @@
     g_real_egl = NULL;
   }
   g_current_egl_context = NULL;
-  auto writer = base::AutoWritableMemory::Create(g_driver_egl);
-  g_driver_egl->ClearBindings();
+  g_driver_egl.ClearBindings();
 }
 
 EGLApi::EGLApi() {

diff --git a/ui/gl/gl_fence.cc b/ui/gl/gl_fence.cc
index c41b658..39cb8dc 100644
--- a/ui/gl/gl_fence.cc
+++ b/ui/gl/gl_fence.cc

@@ -39,7 +39,7 @@
 #if defined(OS_MACOSX)
          g_current_gl_driver->ext.b_GL_APPLE_fence ||
 #else
-         g_driver_egl->ext.b_EGL_KHR_fence_sync ||
+         g_driver_egl.ext.b_EGL_KHR_fence_sync ||
 #endif
          g_current_gl_driver->ext.b_GL_NV_fence;
 }
@@ -50,8 +50,8 @@
 
   std::unique_ptr<GLFence> fence;
 #if !defined(OS_MACOSX)
-  if (g_driver_egl->ext.b_EGL_KHR_fence_sync &&
-      g_driver_egl->ext.b_EGL_KHR_wait_sync) {
+  if (g_driver_egl.ext.b_EGL_KHR_fence_sync &&
+      g_driver_egl.ext.b_EGL_KHR_wait_sync) {
     // Prefer GLFenceEGL which doesn't require GL context switching.
     fence = GLFenceEGL::Create();
     DCHECK(fence);
@@ -66,7 +66,7 @@
   } else if (g_current_gl_driver->ext.b_GL_APPLE_fence) {
     fence.reset(new GLFenceAPPLE);
 #else
-  } else if (g_driver_egl->ext.b_EGL_KHR_fence_sync) {
+  } else if (g_driver_egl.ext.b_EGL_KHR_fence_sync) {
     fence = GLFenceEGL::Create();
     DCHECK(fence);
 #endif

diff --git a/ui/gl/gl_fence_egl.cc b/ui/gl/gl_fence_egl.cc
index 2b58e43..536346f 100644
--- a/ui/gl/gl_fence_egl.cc
+++ b/ui/gl/gl_fence_egl.cc

@@ -77,7 +77,7 @@
 }
 
 void GLFenceEGL::ServerWait() {
-  if (!g_driver_egl->ext.b_EGL_KHR_wait_sync) {
+  if (!g_driver_egl.ext.b_EGL_KHR_wait_sync) {
     ClientWait();
     return;
   }

diff --git a/ui/gl/gl_glx_api_implementation.cc b/ui/gl/gl_glx_api_implementation.cc
index c50ec2e..d7903a2 100644
--- a/ui/gl/gl_glx_api_implementation.cc
+++ b/ui/gl/gl_glx_api_implementation.cc

@@ -17,12 +17,11 @@
 DebugGLXApi* g_debug_glx;
 
 void InitializeStaticGLBindingsGLX() {
-  auto writer = base::AutoWritableMemory::Create(g_driver_glx);
-  g_driver_glx->InitializeStaticBindings();
+  g_driver_glx.InitializeStaticBindings();
   if (!g_real_glx) {
     g_real_glx = new RealGLXApi();
   }
-  g_real_glx->Initialize(&*g_driver_glx);
+  g_real_glx->Initialize(&g_driver_glx);
   g_current_glx_context = g_real_glx;
 }
 
@@ -43,8 +42,7 @@
     g_real_glx = NULL;
   }
   g_current_glx_context = NULL;
-  auto writer = base::AutoWritableMemory::Create(g_driver_glx);
-  g_driver_glx->ClearBindings();
+  g_driver_glx.ClearBindings();
 }
 
 GLXApi::GLXApi() {

diff --git a/ui/gl/gl_osmesa_api_implementation.cc b/ui/gl/gl_osmesa_api_implementation.cc
index e2f64696..081fc32 100644
--- a/ui/gl/gl_osmesa_api_implementation.cc
+++ b/ui/gl/gl_osmesa_api_implementation.cc

@@ -10,14 +10,13 @@
 DebugOSMESAApi* g_debug_osmesa = nullptr;
 
 void InitializeStaticGLBindingsOSMESA() {
-  auto writer = base::AutoWritableMemory::Create(g_driver_osmesa);
-  g_driver_osmesa->InitializeStaticBindings();
+  g_driver_osmesa.InitializeStaticBindings();
   if (!g_real_osmesa) {
     g_real_osmesa = new RealOSMESAApi();
   }
-  g_real_osmesa->Initialize(&*g_driver_osmesa);
+  g_real_osmesa->Initialize(&g_driver_osmesa);
   g_current_osmesa_context = g_real_osmesa;
-  g_driver_osmesa->InitializeExtensionBindings();
+  g_driver_osmesa.InitializeExtensionBindings();
 }
 
 void InitializeDebugGLBindingsOSMESA() {
@@ -37,8 +36,7 @@
     g_real_osmesa = NULL;
   }
   g_current_osmesa_context = NULL;
-  auto writer = base::AutoWritableMemory::Create(g_driver_osmesa);
-  g_driver_osmesa->ClearBindings();
+  g_driver_osmesa.ClearBindings();
 }
 
 OSMESAApi::OSMESAApi() {

diff --git a/ui/gl/gl_surface_egl.cc b/ui/gl/gl_surface_egl.cc
index fff52c4..556c566 100644
--- a/ui/gl/gl_surface_egl.cc
+++ b/ui/gl/gl_surface_egl.cc

@@ -557,25 +557,23 @@
     return true;
 
   // Must be called before InitializeDisplay().
-  auto writer = base::AutoWritableMemory::Create(g_driver_egl);
-  g_driver_egl->InitializeClientExtensionBindings();
+  g_driver_egl.InitializeClientExtensionBindings();
 
   InitializeDisplay(native_display);
   if (g_display == EGL_NO_DISPLAY)
     return false;
 
   // Must be called after InitializeDisplay().
-  g_driver_egl->InitializeExtensionBindings();
+  g_driver_egl.InitializeExtensionBindings();
 
   return InitializeOneOffCommon();
 }
 
 // static
 bool GLSurfaceEGL::InitializeOneOffForTesting() {
-  auto writer = base::AutoWritableMemory::Create(g_driver_egl);
-  g_driver_egl->InitializeClientExtensionBindings();
+  g_driver_egl.InitializeClientExtensionBindings();
   g_display = eglGetCurrentDisplay();
-  g_driver_egl->InitializeExtensionBindings();
+  g_driver_egl.InitializeExtensionBindings();
   return InitializeOneOffCommon();
 }
 
@@ -670,7 +668,7 @@
 #if defined(OS_ANDROID)
   if (base::android::BuildInfo::GetInstance()->sdk_int() >=
           base::android::SDK_VERSION_NOUGAT &&
-      g_driver_egl->fn.eglDupNativeFenceFDANDROIDFn) {
+      g_driver_egl.fn.eglDupNativeFenceFDANDROIDFn) {
     g_egl_android_native_fence_sync_supported = true;
   }
 #endif
@@ -683,8 +681,7 @@
 bool GLSurfaceEGL::InitializeExtensionSettingsOneOff() {
   if (!initialized_)
     return false;
-  auto writer = base::AutoWritableMemory::Create(g_driver_egl);
-  g_driver_egl->UpdateConditionalExtensionBindings();
+  g_driver_egl.UpdateConditionalExtensionBindings();
   g_egl_extensions = eglQueryString(g_display, EGL_EXTENSIONS);
 
   return true;
@@ -898,7 +895,7 @@
     egl_window_attributes.push_back(size_.height());
   }
 
-  if (g_driver_egl->ext.b_EGL_NV_post_sub_buffer) {
+  if (g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
     egl_window_attributes.push_back(EGL_POST_SUB_BUFFER_SUPPORTED_NV);
     egl_window_attributes.push_back(EGL_TRUE);
   }
@@ -963,7 +960,7 @@
     return false;
   }
 
-  if (g_driver_egl->ext.b_EGL_NV_post_sub_buffer) {
+  if (g_driver_egl.ext.b_EGL_NV_post_sub_buffer) {
     EGLint surfaceVal;
     EGLBoolean retVal = eglQuerySurface(
         GetDisplay(), surface_, EGL_POST_SUB_BUFFER_SUPPORTED_NV, &surfaceVal);
@@ -971,7 +968,7 @@
   }
 
   supports_swap_buffer_with_damage_ =
-      g_driver_egl->ext.b_EGL_KHR_swap_buffers_with_damage;
+      g_driver_egl.ext.b_EGL_KHR_swap_buffers_with_damage;
 
   if (!vsync_provider_external_ && EGLSyncControlVSyncProvider::IsSupported()) {
     vsync_provider_internal_ =
@@ -982,11 +979,11 @@
 }
 
 bool NativeViewGLSurfaceEGL::SupportsSwapTimestamps() const {
-  return g_driver_egl->ext.b_EGL_ANDROID_get_frame_timestamps;
+  return g_driver_egl.ext.b_EGL_ANDROID_get_frame_timestamps;
 }
 
 void NativeViewGLSurfaceEGL::SetEnableSwapTimestamps() {
-  DCHECK(g_driver_egl->ext.b_EGL_ANDROID_get_frame_timestamps);
+  DCHECK(g_driver_egl.ext.b_EGL_ANDROID_get_frame_timestamps);
 
   // If frame timestamps are supported, set the proper attribute to enable the
   // feature and then cache the timestamps supported by the underlying
@@ -1490,10 +1487,10 @@
   NOTREACHED();
   return NULL;
 #else
-  if (!g_driver_egl->ext.b_EGL_ANGLE_query_surface_pointer)
+  if (!g_driver_egl.ext.b_EGL_ANGLE_query_surface_pointer)
     return NULL;
 
-  if (!g_driver_egl->ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle)
+  if (!g_driver_egl.ext.b_EGL_ANGLE_surface_d3d_texture_2d_share_handle)
     return NULL;
 
   void* handle;

diff --git a/ui/gl/gl_surface_glx.cc b/ui/gl/gl_surface_glx.cc
index a80f544b..5b0794c 100644
--- a/ui/gl/gl_surface_glx.cc
+++ b/ui/gl/gl_surface_glx.cc

@@ -456,8 +456,7 @@
   if (!initialized_)
     return false;
 
-  auto writer = base::AutoWritableMemory::Create(g_driver_glx);
-  g_driver_glx->InitializeExtensionBindings();
+  g_driver_glx.InitializeExtensionBindings();
 
   g_glx_context_create = HasGLXExtension("GLX_ARB_create_context");
   g_glx_create_context_robustness_supported =
@@ -694,7 +693,7 @@
 }
 
 bool NativeViewGLSurfaceGLX::SupportsPostSubBuffer() {
-  return g_driver_glx->ext.b_GLX_MESA_copy_sub_buffer;
+  return g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer;
 }
 
 void* NativeViewGLSurfaceGLX::GetConfig() {
@@ -717,7 +716,7 @@
     int width,
     int height,
     const PresentationCallback& callback) {
-  DCHECK(g_driver_glx->ext.b_GLX_MESA_copy_sub_buffer);
+  DCHECK(g_driver_glx.ext.b_GLX_MESA_copy_sub_buffer);
   PreSwapBuffers(callback);
   glXCopySubBufferMESA(g_display, GetDrawableHandle(), x, y, width, height);
   PostSwapBuffers();

diff --git a/ui/gl/gl_surface_wgl.cc b/ui/gl/gl_surface_wgl.cc
index d77dce5..d3a91b9 100644
--- a/ui/gl/gl_surface_wgl.cc
+++ b/ui/gl/gl_surface_wgl.cc

@@ -180,7 +180,7 @@
 bool GLSurfaceWGL::InitializeExtensionSettingsOneOff() {
   if (!initialized_)
     return false;
-  g_driver_wgl->InitializeExtensionBindings();
+  g_driver_wgl.InitializeExtensionBindings();
   return true;
 }
 
@@ -355,7 +355,7 @@
 bool PbufferGLSurfaceWGL::Initialize(GLSurfaceFormat format) {
   DCHECK(!device_context_);
 
-  if (!g_driver_wgl->fn.wglCreatePbufferARBFn) {
+  if (!g_driver_wgl.fn.wglCreatePbufferARBFn) {
     LOG(ERROR) << "wglCreatePbufferARB not available.";
     Destroy();
     return false;

diff --git a/ui/gl/gl_wgl_api_implementation.cc b/ui/gl/gl_wgl_api_implementation.cc
index 488f64eef..7cda14e 100644
--- a/ui/gl/gl_wgl_api_implementation.cc
+++ b/ui/gl/gl_wgl_api_implementation.cc

@@ -17,12 +17,11 @@
 DebugWGLApi* g_debug_wgl = nullptr;
 
 void InitializeStaticGLBindingsWGL() {
-  auto writer = base::AutoWritableMemory::Create(g_driver_wgl);
-  g_driver_wgl->InitializeStaticBindings();
+  g_driver_wgl.InitializeStaticBindings();
   if (!g_real_wgl) {
     g_real_wgl = new RealWGLApi();
   }
-  g_real_wgl->Initialize(&*g_driver_wgl);
+  g_real_wgl->Initialize(&g_driver_wgl);
   g_current_wgl_context = g_real_wgl;
 }
 
@@ -43,8 +42,7 @@
     g_real_wgl = NULL;
   }
   g_current_wgl_context = NULL;
-  auto writer = base::AutoWritableMemory::Create(g_driver_wgl);
-  g_driver_wgl->ClearBindings();
+  g_driver_wgl.ClearBindings();
 }
 
 WGLApi::WGLApi() {

diff --git a/ui/gl/glx_api_unittest.cc b/ui/gl/glx_api_unittest.cc
index 2e28d72..1b2dfc9 100644
--- a/ui/gl/glx_api_unittest.cc
+++ b/ui/gl/glx_api_unittest.cc

@@ -15,9 +15,8 @@
   void SetUp() override {
     fake_extension_string_ = "";
 
-    auto writer = base::AutoWritableMemory::Create(g_driver_glx);
-    g_driver_glx->ClearBindings();
-    g_driver_glx->fn.glXQueryExtensionsStringFn = &FakeQueryExtensionsString;
+    g_driver_glx.ClearBindings();
+    g_driver_glx.fn.glXQueryExtensionsStringFn = &FakeQueryExtensionsString;
     SetGLImplementation(kGLImplementationMockGL);
     SetGLGetProcAddressProc(
         static_cast<GLGetProcAddressProc>(&FakeGLGetProcAddress));
@@ -26,8 +25,7 @@
   void TearDown() override {
     g_current_glx_context = nullptr;
     api_.reset(nullptr);
-    auto writer = base::AutoWritableMemory::Create(g_driver_glx);
-    g_driver_glx->ClearBindings();
+    g_driver_glx.ClearBindings();
 
     fake_extension_string_ = "";
   }
@@ -35,12 +33,11 @@
   void InitializeAPI(const char* disabled_extensions) {
     api_.reset(new RealGLXApi());
     g_current_glx_context = api_.get();
-    api_->Initialize(&*g_driver_glx);
+    api_->Initialize(&g_driver_glx);
     if (disabled_extensions) {
       SetDisabledExtensionsGLX(disabled_extensions);
     }
-    auto writer = base::AutoWritableMemory::Create(g_driver_glx);
-    g_driver_glx->InitializeExtensionBindings();
+    g_driver_glx.InitializeExtensionBindings();
   }
 
   void SetFakeExtensionString(const char* fake_string) {
@@ -88,11 +85,11 @@
   SetFakeExtensionString(kFakeExtensions);
   InitializeAPI(nullptr);
 
-  EXPECT_TRUE(g_driver_glx->ext.b_GLX_ARB_create_context);
+  EXPECT_TRUE(g_driver_glx.ext.b_GLX_ARB_create_context);
 
   InitializeAPI(kFakeDisabledExtensions);
 
-  EXPECT_FALSE(g_driver_glx->ext.b_GLX_ARB_create_context);
+  EXPECT_FALSE(g_driver_glx.ext.b_GLX_ARB_create_context);
 }
 
 TEST_F(GLXApiTest, DisabledExtensionStringTest) {

diff --git a/ui/gl/wgl_api_unittest.cc b/ui/gl/wgl_api_unittest.cc
index 958f30f..a0fe216 100644
--- a/ui/gl/wgl_api_unittest.cc
+++ b/ui/gl/wgl_api_unittest.cc

@@ -21,10 +21,9 @@
     fake_arb_extension_string_ = "";
     fake_ext_extension_string_ = "";
 
-    auto writer = base::AutoWritableMemory::Create(g_driver_wgl);
-    g_driver_wgl->ClearBindings();
-    g_driver_wgl->fn.wglGetExtensionsStringARBFn = &FakeGetExtensionsStringARB;
-    g_driver_wgl->fn.wglGetExtensionsStringEXTFn = &FakeGetExtensionsStringEXT;
+    g_driver_wgl.ClearBindings();
+    g_driver_wgl.fn.wglGetExtensionsStringARBFn = &FakeGetExtensionsStringARB;
+    g_driver_wgl.fn.wglGetExtensionsStringEXTFn = &FakeGetExtensionsStringEXT;
     SetGLImplementation(kGLImplementationDesktopGL);
     SetGLGetProcAddressProc(&FakeGLGetProcAddress);
   }
@@ -32,7 +31,7 @@
   void TearDown() override {
     g_current_wgl_context = nullptr;
     api_.reset(nullptr);
-    g_driver_wgl->ClearBindings();
+    g_driver_wgl.ClearBindings();
 
     fake_ext_extension_string_ = "";
     fake_arb_extension_string_ = "";
@@ -41,12 +40,11 @@
   void InitializeAPI(const char* disabled_extensions) {
     api_.reset(new RealWGLApi());
     g_current_wgl_context = api_.get();
-    api_->Initialize(&*g_driver_wgl);
+    api_->Initialize(&g_driver_wgl);
     if (disabled_extensions) {
       SetDisabledExtensionsWGL(disabled_extensions);
     }
-    auto writer = base::AutoWritableMemory::Create(g_driver_wgl);
-    g_driver_wgl->InitializeExtensionBindings();
+    g_driver_wgl.InitializeExtensionBindings();
   }
 
   void SetFakeEXTExtensionString(const char* fake_string) {
@@ -94,17 +92,17 @@
 
   InitializeAPI(nullptr);
 
-  EXPECT_FALSE(g_driver_wgl->ext.b_WGL_ARB_extensions_string);
+  EXPECT_FALSE(g_driver_wgl.ext.b_WGL_ARB_extensions_string);
 
   // NULL simulates not being able to resolve wglGetExtensionsStringARB
   SetFakeARBExtensionString(nullptr);
   SetFakeEXTExtensionString(kFakeExtensions);
 
   InitializeAPI(nullptr);
-  EXPECT_TRUE(g_driver_wgl->ext.b_WGL_ARB_extensions_string);
+  EXPECT_TRUE(g_driver_wgl.ext.b_WGL_ARB_extensions_string);
 
   InitializeAPI(kFakeExtensions);
-  EXPECT_FALSE(g_driver_wgl->ext.b_WGL_ARB_extensions_string);
+  EXPECT_FALSE(g_driver_wgl.ext.b_WGL_ARB_extensions_string);
 
   SetFakeARBExtensionString("");
   SetFakeEXTExtensionString(kFakeExtensions);
@@ -113,16 +111,16 @@
   // We expect false here, because wglGetExtensionsStringARB
   // always takes precedence over wglGetExtensionsStringEXT
   // if it is available.
-  EXPECT_FALSE(g_driver_wgl->ext.b_WGL_ARB_extensions_string);
+  EXPECT_FALSE(g_driver_wgl.ext.b_WGL_ARB_extensions_string);
 
   SetFakeARBExtensionString(kFakeExtensions);
   SetFakeEXTExtensionString("");
 
   InitializeAPI(nullptr);
-  EXPECT_TRUE(g_driver_wgl->ext.b_WGL_ARB_extensions_string);
+  EXPECT_TRUE(g_driver_wgl.ext.b_WGL_ARB_extensions_string);
 
   InitializeAPI(kFakeDisabledExtensions);
-  EXPECT_FALSE(g_driver_wgl->ext.b_WGL_ARB_extensions_string);
+  EXPECT_FALSE(g_driver_wgl.ext.b_WGL_ARB_extensions_string);
 }
 
 TEST_F(WGLApiTest, DisabledExtensionStringTest) {