Add initial support for API versioning (see #3836)

- Generated files are now created when running cef_create_projects or
  the new version_manager.py tool. These files are still created in the
  cef/ source tree (same location as before) but Git ignores them due to
  the generated .gitignore file.
- API hashes are committed to Git as a new cef_api_versions.json file.
  This file is used for both code generation and CEF version calculation
  (replacing the previous usage of cef_api_hash.h for this purpose).
  It will be updated by the CEF admin before merging breaking API
  changes upstream.
- As an added benefit to the above, contributor PRs will no longer
  contain generated code that is susceptible to frequent merge conflicts.
- From a code generation perspective, the main difference is that we now
  use versioned structs (e.g. cef_browser_0_t instead of cef_browser_t)
  on the libcef (dll/framework) side. Most of the make_*.py tool changes
  are related to supporting this.
- From the client perspective, you can now define CEF_API_VERSION in the
  project configuration (or get CEF_EXPERIMENTAL by default). This
  define will change the API exposed in CEF’s include/ and include/capi
  header files. All client-side targets including libcef_dll_wrapper
  will need be recompiled when changing this define.
- Examples of the new API-related define usage are provided in
  cef_api_version_test.h, api_version_test_impl.cc and
  api_version_unittest.cc.

To test:
- Run `ceftests --gtest_filter=ApiVersionTest.*`
- Add `cef_api_version=13300` to GN_DEFINES. Re-run configure, build and
  ceftests steps.
- Repeat with 13301, 13302, 13303 (all supported test versions).

libcef_dll/cpptoc/base_ref_counted_cpptoc.h

@@ -23,4 +23,7 @@ class CefBaseRefCountedCppToC
   CefBaseRefCountedCppToC();
 };
 
+constexpr auto CefBaseRefCountedCppToC_Wrap = CefBaseRefCountedCppToC::Wrap;
+constexpr auto CefBaseRefCountedCppToC_Unwrap = CefBaseRefCountedCppToC::Unwrap;
+
 #endif  // CEF_LIBCEF_DLL_CPPTOC_BASE_REF_COUNTED_CPPTOC_H_

libcef_dll/cpptoc/base_scoped_cpptoc.h

@@ -22,4 +22,17 @@ class CefBaseScopedCppToC : public CefCppToCScoped<CefBaseScopedCppToC,
   CefBaseScopedCppToC();
 };
 
+constexpr auto CefBaseScopedCppToC_WrapOwn = CefBaseScopedCppToC::WrapOwn;
+constexpr auto CefBaseScopedCppToC_WrapRaw = CefBaseScopedCppToC::WrapRaw;
+constexpr auto CefBaseScopedCppToC_UnwrapOwn = CefBaseScopedCppToC::UnwrapOwn;
+constexpr auto CefBaseScopedCppToC_UnwrapRaw = CefBaseScopedCppToC::UnwrapRaw;
+constexpr auto CefBaseScopedCppToC_GetWrapper = CefBaseScopedCppToC::GetWrapper;
+
+inline cef_base_scoped_t* CefBaseScopedCppToC_WrapRawAndRelease(
+    CefRawPtr<CefBaseScoped> c) {
+  auto [ownerPtr, structPtr] = CefBaseScopedCppToC_WrapRaw(c);
+  ownerPtr.release();
+  return structPtr;
+}
+
 #endif  // CEF_LIBCEF_DLL_CPPTOC_BASE_CPPTOC_H_

libcef_dll/cpptoc/cpptoc_ref_counted.h

@@ -45,7 +45,8 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
     }
 
     // Cast our structure to the wrapper structure type.
-    WrapperStruct* wrapperStruct = GetWrapperStruct(s);
+    WrapperStruct* wrapperStruct =
+        GetWrapperStruct(s, /*require_exact_type=*/false);
 
     // If the type does not match this object then we need to unwrap as the
     // derived type.
@@ -68,8 +69,6 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
   static CefRefPtr<BaseName> Get(StructName* s) {
     DCHECK(s);
     WrapperStruct* wrapperStruct = GetWrapperStruct(s);
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
     return wrapperStruct->object_;
   }
 
@@ -122,13 +121,21 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
     StructName struct_;
   };
 
-  static WrapperStruct* GetWrapperStruct(StructName* s) {
+  static WrapperStruct* GetWrapperStruct(StructName* s,
+                                         bool require_exact_type = true) {
     // Offset using the WrapperStruct size instead of individual member sizes
     // to avoid problems due to platform/compiler differences in structure
     // padding.
-    return reinterpret_cast<WrapperStruct*>(
+    auto* wrapperStruct = reinterpret_cast<WrapperStruct*>(
         reinterpret_cast<char*>(s) -
         (sizeof(WrapperStruct) - sizeof(StructName)));
+
+    if (require_exact_type) {
+      // Verify that the wrapper offset was calculated correctly.
+      CHECK_EQ(kWrapperType, wrapperStruct->type_);
+    }
+
+    return wrapperStruct;
   }
 
   // Unwrap as the derived type.
@@ -152,9 +159,6 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
-
     wrapperStruct->wrapper_->AddRef();
   }
 
@@ -166,9 +170,6 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
-
     return wrapperStruct->wrapper_->Release();
   }
 
@@ -180,9 +181,6 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
-
     return wrapperStruct->wrapper_->HasOneRef();
   }
 
@@ -195,9 +193,6 @@ class CefCppToCRefCounted : public CefBaseRefCounted {
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
-
     return wrapperStruct->wrapper_->HasAtLeastOneRef();
   }
 

libcef_dll/cpptoc/cpptoc_scoped.h

@@ -6,6 +6,8 @@
 #define CEF_LIBCEF_DLL_CPPTOC_CPPTOC_SCOPED_H_
 #pragma once
 
+#include <utility>
+
 #include "include/base/cef_logging.h"
 #include "include/capi/cef_base_capi.h"
 #include "include/cef_base.h"
@@ -52,17 +54,18 @@ class CefCppToCScoped : public CefBaseScoped {
   // For example:
   //
   // void MyMethod(MyType* obj) {
-  //   CefOwnPtr<MyTypeCppToC> MyTypeWrapper = MyTypeCppToC::WrapRaw(obj);
-  //   my_method(MyTypeWrapper->GetStruct());
+  //   [MyTypeWrapper, MyTypeStruct] = MyTypeCppToC::WrapRaw(obj);
+  //   my_method(MyTypeStruct);
   //   // MyTypeWrapper is deleted when MyMethod() goes out of scope.
   // }
   //
   // void my_method(my_type_t* struct) {
   //   // Access |struct| here but you can't delete it.
   // }
-  static CefOwnPtr<ClassName> WrapRaw(CefRawPtr<BaseName> c) {
+  static std::pair<CefOwnPtr<CefBaseScoped>, StructName*> WrapRaw(
+      CefRawPtr<BaseName> c) {
     if (!c) {
-      return CefOwnPtr<ClassName>();
+      return std::make_pair(nullptr, nullptr);
     }
 
     // Wrap our object with the CefCppToC class.
@@ -70,7 +73,9 @@ class CefCppToCScoped : public CefBaseScoped {
     wrapper->Initialize(c, false);
 
     // Return the owned wrapper object.
-    return CefOwnPtr<ClassName>(wrapper);
+    CefOwnPtr<ClassName> wrapperPtr(wrapper);
+    auto* wrapperStruct = wrapperPtr->GetStruct();
+    return std::make_pair(std::move(wrapperPtr), wrapperStruct);
   }
 
   // Retrieve the underlying object instance for a structure reference passed
@@ -87,7 +92,8 @@ class CefCppToCScoped : public CefBaseScoped {
     }
 
     // Cast our structure to the wrapper structure type.
-    WrapperStruct* wrapperStruct = GetWrapperStruct(s);
+    WrapperStruct* wrapperStruct =
+        GetWrapperStruct(s, /*require_exact_type=*/false);
 
     // If the type does not match this object then we need to unwrap as the
     // derived type.
@@ -96,8 +102,8 @@ class CefCppToCScoped : public CefBaseScoped {
     }
 
     // We should own the underlying object currently.
-    DCHECK(wrapperStruct->wrapper_->owned_);
-    DCHECK(wrapperStruct->object_);
+    CHECK(wrapperStruct->wrapper_->owned_);
+    CHECK(wrapperStruct->object_);
 
     // We're giving up ownership of the underlying object. Clear the pointer so
     // it doesn't get deleted.
@@ -123,7 +129,8 @@ class CefCppToCScoped : public CefBaseScoped {
     }
 
     // Cast our structure to the wrapper structure type.
-    WrapperStruct* wrapperStruct = GetWrapperStruct(s);
+    WrapperStruct* wrapperStruct =
+        GetWrapperStruct(s, /*require_exact_type=*/false);
 
     // If the type does not match this object then we need to unwrap as the
     // derived type.
@@ -137,12 +144,10 @@ class CefCppToCScoped : public CefBaseScoped {
 
   // Retrieve the same side wrapper associated with the structure. Ownership
   // does not change.
-  static ClassName* GetWrapper(StructName* s) {
+  static CefBaseScoped* GetWrapper(StructName* s) {
     DCHECK(s);
     WrapperStruct* wrapperStruct = GetWrapperStruct(s);
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
-    return static_cast<ClassName*>(wrapperStruct->wrapper_);
+    return wrapperStruct->wrapper_;
   }
 
   // Retrieve the underlying object instance from our own structure reference
@@ -151,8 +156,6 @@ class CefCppToCScoped : public CefBaseScoped {
   static BaseName* Get(StructName* s) {
     DCHECK(s);
     WrapperStruct* wrapperStruct = GetWrapperStruct(s);
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
     return wrapperStruct->object_;
   }
 
@@ -196,13 +199,21 @@ class CefCppToCScoped : public CefBaseScoped {
     }
   }
 
-  static WrapperStruct* GetWrapperStruct(StructName* s) {
+  static WrapperStruct* GetWrapperStruct(StructName* s,
+                                         bool require_exact_type = true) {
     // Offset using the WrapperStruct size instead of individual member sizes
     // to avoid problems due to platform/compiler differences in structure
     // padding.
-    return reinterpret_cast<WrapperStruct*>(
+    auto* wrapperStruct = reinterpret_cast<WrapperStruct*>(
         reinterpret_cast<char*>(s) -
         (sizeof(WrapperStruct) - sizeof(StructName)));
+
+    if (require_exact_type) {
+      // Verify that the wrapper offset was calculated correctly.
+      CHECK_EQ(kWrapperType, wrapperStruct->type_);
+    }
+
+    return wrapperStruct;
   }
 
   // Unwrap as the derived type.
@@ -219,11 +230,9 @@ class CefCppToCScoped : public CefBaseScoped {
 
     WrapperStruct* wrapperStruct =
         GetWrapperStruct(reinterpret_cast<StructName*>(base));
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
 
     // Should only be deleting wrappers that own the underlying object.
-    DCHECK(wrapperStruct->wrapper_->owned_);
+    CHECK(wrapperStruct->wrapper_->owned_);
     delete wrapperStruct->wrapper_;
   }
 

libcef_dll/ctocpp/base_ref_counted_ctocpp.h

@@ -23,4 +23,7 @@ class CefBaseRefCountedCToCpp
   CefBaseRefCountedCToCpp();
 };
 
+constexpr auto CefBaseRefCountedCToCpp_Wrap = CefBaseRefCountedCToCpp::Wrap;
+constexpr auto CefBaseRefCountedCToCpp_Unwrap = CefBaseRefCountedCToCpp::Unwrap;
+
 #endif  // CEF_LIBCEF_DLL_CTOCPP_BASE_REF_COUNTED_CTOCPP_H_

libcef_dll/ctocpp/base_scoped_ctocpp.h

@@ -22,4 +22,8 @@ class CefBaseScopedCToCpp : public CefCToCppScoped<CefBaseScopedCToCpp,
   CefBaseScopedCToCpp();
 };
 
+constexpr auto CefBaseScopedCToCpp_Wrap = CefBaseScopedCToCpp::Wrap;
+constexpr auto CefBaseScopedCToCpp_UnwrapOwn = CefBaseScopedCToCpp::UnwrapOwn;
+constexpr auto CefBaseScopedCToCpp_UnwrapRaw = CefBaseScopedCToCpp::UnwrapRaw;
+
 #endif  // CEF_LIBCEF_DLL_CTOCPP_BASE_SCOPED_CTOCPP_H_

libcef_dll/ctocpp/ctocpp_ref_counted.h

@@ -8,6 +8,7 @@
 
 #include "include/base/cef_logging.h"
 #include "include/capi/cef_base_capi.h"
+#include "include/cef_api_hash.h"
 #include "include/cef_base.h"
 #include "libcef_dll/wrapper_types.h"
 
@@ -45,8 +46,6 @@ class CefCToCppRefCounted : public BaseName {
   // If returning the structure across the DLL boundary use Unwrap() instead.
   StructName* GetStruct() const {
     WrapperStruct* wrapperStruct = GetWrapperStruct(this);
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
     return wrapperStruct->struct_;
   }
 
@@ -55,7 +54,8 @@ class CefCToCppRefCounted : public BaseName {
   // from the other side.
   struct WrapperStruct;
 
-  static WrapperStruct* GetWrapperStruct(const BaseName* obj);
+  static WrapperStruct* GetWrapperStruct(const BaseName* obj,
+                                         bool require_exact_type = true);
 
   // Unwrap as the derived type.
   static StructName* UnwrapDerived(CefWrapperType type, BaseName* c);
@@ -119,6 +119,18 @@ CefRefPtr<BaseName> CefCToCppRefCounted<ClassName, BaseName, StructName>::Wrap(
     return nullptr;
   }
 
+  const auto size = reinterpret_cast<cef_base_ref_counted_t*>(s)->size;
+  if (size != sizeof(StructName)) {
+    LOG(FATAL) << "Cannot wrap struct with invalid base.size value (got "
+               << size << ", expected " << sizeof(StructName)
+               << ") at API version "
+#if defined(WRAPPING_CEF_SHARED)
+               << CEF_API_VERSION;
+#else
+               << cef_api_version();
+#endif
+  }
+
   // Wrap their structure with the CefCToCppRefCounted object.
   WrapperStruct* wrapperStruct = new WrapperStruct;
   wrapperStruct->type_ = kWrapperType;
@@ -140,7 +152,8 @@ StructName* CefCToCppRefCounted<ClassName, BaseName, StructName>::Unwrap(
     return nullptr;
   }
 
-  WrapperStruct* wrapperStruct = GetWrapperStruct(c.get());
+  WrapperStruct* wrapperStruct =
+      GetWrapperStruct(c.get(), /*require_exact_type=*/false);
 
   // If the type does not match this object then we need to unwrap as the
   // derived type.
@@ -160,8 +173,6 @@ bool CefCToCppRefCounted<ClassName, BaseName, StructName>::Release() const {
   UnderlyingRelease();
   if (ref_count_.Release()) {
     WrapperStruct* wrapperStruct = GetWrapperStruct(this);
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
     delete wrapperStruct;
     return true;
   }
@@ -171,12 +182,20 @@ bool CefCToCppRefCounted<ClassName, BaseName, StructName>::Release() const {
 template <class ClassName, class BaseName, class StructName>
 typename CefCToCppRefCounted<ClassName, BaseName, StructName>::WrapperStruct*
 CefCToCppRefCounted<ClassName, BaseName, StructName>::GetWrapperStruct(
-    const BaseName* obj) {
+    const BaseName* obj,
+    bool require_exact_type) {
   // Offset using the WrapperStruct size instead of individual member sizes to
   // avoid problems due to platform/compiler differences in structure padding.
-  return reinterpret_cast<WrapperStruct*>(
+  auto* wrapperStruct = reinterpret_cast<WrapperStruct*>(
       reinterpret_cast<char*>(const_cast<BaseName*>(obj)) -
       (sizeof(WrapperStruct) - sizeof(ClassName)));
+
+  if (require_exact_type) {
+    // Verify that the wrapper offset was calculated correctly.
+    CHECK_EQ(kWrapperType, wrapperStruct->type_);
+  }
+
+  return wrapperStruct;
 }
 
 #endif  // CEF_LIBCEF_DLL_CTOCPP_CTOCPP_REF_COUNTED_H_

libcef_dll/ctocpp/ctocpp_scoped.h

@@ -8,6 +8,7 @@
 
 #include "include/base/cef_logging.h"
 #include "include/capi/cef_base_capi.h"
+#include "include/cef_api_hash.h"
 #include "include/cef_base.h"
 #include "libcef_dll/wrapper_types.h"
 
@@ -75,8 +76,6 @@ class CefCToCppScoped : public BaseName {
   // If returning the structure across the DLL boundary use Unwrap() instead.
   StructName* GetStruct() const {
     WrapperStruct* wrapperStruct = GetWrapperStruct(this);
-    // Verify that the wrapper offset was calculated correctly.
-    DCHECK_EQ(kWrapperType, wrapperStruct->type_);
     return wrapperStruct->struct_;
   }
 
@@ -85,7 +84,8 @@ class CefCToCppScoped : public BaseName {
   // from the other side.
   struct WrapperStruct;
 
-  static WrapperStruct* GetWrapperStruct(const BaseName* obj);
+  static WrapperStruct* GetWrapperStruct(const BaseName* obj,
+                                         bool require_exact_type = true);
 
   // Unwrap as the derived type.
   static StructName* UnwrapDerivedOwn(CefWrapperType type,
@@ -107,7 +107,19 @@ template <class ClassName, class BaseName, class StructName>
 CefOwnPtr<BaseName> CefCToCppScoped<ClassName, BaseName, StructName>::Wrap(
     StructName* s) {
   if (!s) {
-    return CefOwnPtr<BaseName>();
+    return nullptr;
+  }
+
+  const auto size = reinterpret_cast<cef_base_ref_counted_t*>(s)->size;
+  if (size != sizeof(StructName)) {
+    LOG(FATAL) << "Cannot wrap struct with invalid base.size value (got "
+               << size << ", expected " << sizeof(StructName)
+               << ") at API version "
+#if defined(WRAPPING_CEF_SHARED)
+               << CEF_API_VERSION;
+#else
+               << cef_api_version();
+#endif
   }
 
   // Wrap their structure with the CefCToCpp object.
@@ -125,7 +137,8 @@ StructName* CefCToCppScoped<ClassName, BaseName, StructName>::UnwrapOwn(
     return nullptr;
   }
 
-  WrapperStruct* wrapperStruct = GetWrapperStruct(c.get());
+  WrapperStruct* wrapperStruct =
+      GetWrapperStruct(c.get(), /*require_exact_type=*/false);
 
   // If the type does not match this object then we need to unwrap as the
   // derived type.
@@ -156,7 +169,8 @@ StructName* CefCToCppScoped<ClassName, BaseName, StructName>::UnwrapRaw(
     return nullptr;
   }
 
-  WrapperStruct* wrapperStruct = GetWrapperStruct(c);
+  WrapperStruct* wrapperStruct =
+      GetWrapperStruct(c, /*require_exact_type=*/false);
 
   // If the type does not match this object then we need to unwrap as the
   // derived type.
@@ -173,8 +187,6 @@ NO_SANITIZE("cfi-icall")
 void CefCToCppScoped<ClassName, BaseName, StructName>::operator delete(
     void* ptr) {
   WrapperStruct* wrapperStruct = GetWrapperStruct(static_cast<BaseName*>(ptr));
-  // Verify that the wrapper offset was calculated correctly.
-  DCHECK_EQ(kWrapperType, wrapperStruct->type_);
 
   // May be NULL if UnwrapOwn() was called.
   cef_base_scoped_t* base =
@@ -194,12 +206,20 @@ void CefCToCppScoped<ClassName, BaseName, StructName>::operator delete(
 template <class ClassName, class BaseName, class StructName>
 typename CefCToCppScoped<ClassName, BaseName, StructName>::WrapperStruct*
 CefCToCppScoped<ClassName, BaseName, StructName>::GetWrapperStruct(
-    const BaseName* obj) {
+    const BaseName* obj,
+    bool require_exact_type) {
   // Offset using the WrapperStruct size instead of individual member sizes to
   // avoid problems due to platform/compiler differences in structure padding.
-  return reinterpret_cast<WrapperStruct*>(
+  auto* wrapperStruct = reinterpret_cast<WrapperStruct*>(
       reinterpret_cast<char*>(const_cast<BaseName*>(obj)) -
       (sizeof(WrapperStruct) - sizeof(ClassName)));
+
+  if (require_exact_type) {
+    // Verify that the wrapper offset was calculated correctly.
+    CHECK_EQ(kWrapperType, wrapperStruct->type_);
+  }
+
+  return wrapperStruct;
 }
 
 #endif  // CEF_LIBCEF_DLL_CTOCPP_CTOCPP_SCOPED_H_

libcef_dll/libcef_dll2.cc

@@ -4,15 +4,24 @@
 //
 
 #include <cstddef>
+#include <map>
+#include <string_view>
 
-#include "include/base/cef_build.h"
-#include "include/cef_api_hash.h"
-#include "include/cef_version.h"
+#include "base/logging.h"
+#include "base/no_destructor.h"
+#include "cef/include/base/cef_build.h"
+#include "cef/include/cef_api_hash.h"
+#include "cef/include/cef_id_mappers.h"
+#include "cef/include/cef_version_info.h"
 
 #if defined(OS_WIN)
-#include "include/internal/cef_win.h"
+#include "cef/include/internal/cef_win.h"
 #endif
 
+namespace {
+int g_version = -1;
+}
+
 CEF_EXPORT int cef_version_info(int entry) {
   switch (entry) {
     case 0:
@@ -36,19 +45,117 @@ CEF_EXPORT int cef_version_info(int entry) {
   }
 }
 
-CEF_EXPORT const char* cef_api_hash(int entry) {
+#include "cef/libcef_dll/cef_api_versions.inc"
+
+CEF_EXPORT const char* cef_api_hash(int version, int entry) {
+  static const ApiVersionHash* hash = nullptr;
+
+  // Initialize on the first successful lookup.
+  if (!hash) {
+    for (size_t i = 0; i < kApiVersionHashesSize; ++i) {
+      if (version == kApiVersionHashes[i].version) {
+        hash = &kApiVersionHashes[i];
+        break;
+      }
+    }
+
+    if (hash) {
+      g_version = version;
+    }
+  }
+
+  if (!hash) {
+    LOG(ERROR) << "Request for unsupported CEF API version " << version;
+    return nullptr;
+  }
+
+  if (version != g_version) {
+    LOG(ERROR) << "CEF API version cannot be configured multiple times";
+    return nullptr;
+  }
+
   switch (entry) {
     case 0:
-      return CEF_API_HASH_PLATFORM;
+      return hash->platform;
     case 1:
-      return CEF_API_HASH_UNIVERSAL;
+      return hash->universal;
     case 2:
       return CEF_COMMIT_HASH;
     default:
-      return NULL;
+      return nullptr;
   }
 }
 
+CEF_EXPORT int cef_api_version() {
+  return g_version;
+}
+
+#include "cef/libcef_dll/cef_pack_resources.inc"
+
+CEF_EXPORT int cef_id_for_pack_resource_name(const char* name) {
+  static base::NoDestructor<std::map<std::string_view, int>> string_to_id_map;
+
+  // Initialize on the first call.
+  if (string_to_id_map->empty()) {
+    for (size_t i = 0; i < kIdNamesPackResourcesSize; ++i) {
+      (*string_to_id_map)[kIdNamesPackResources[i].name] =
+          kIdNamesPackResources[i].id;
+    }
+  }
+
+  const auto& it = string_to_id_map->find(name);
+  if (it != string_to_id_map->end()) {
+    return it->second;
+  }
+
+  LOG(WARNING) << __func__ << " called with unsupported value " << name;
+  return -1;
+}
+
+#include "cef/libcef_dll/cef_pack_strings.inc"
+
+CEF_EXPORT int cef_id_for_pack_string_name(const char* name) {
+  static base::NoDestructor<std::map<std::string_view, int>> string_to_id_map;
+
+  // Initialize on the first call.
+  if (string_to_id_map->empty()) {
+    for (size_t i = 0; i < kIdNamesPackStringsSize; ++i) {
+      (*string_to_id_map)[kIdNamesPackStrings[i].name] =
+          kIdNamesPackStrings[i].id;
+    }
+  }
+
+  const auto& it = string_to_id_map->find(name);
+  if (it != string_to_id_map->end()) {
+    return it->second;
+  }
+
+  LOG(WARNING) << __func__ << " called with unsupported value " << name;
+  return -1;
+}
+
+#include "cef/libcef_dll/cef_command_ids.inc"
+
+CEF_EXPORT int cef_id_for_command_id_name(const char* name) {
+  static base::NoDestructor<std::map<std::string_view, int>> string_to_id_map;
+
+  // Initialize on the first call.
+  if (string_to_id_map->empty()) {
+    for (size_t i = 0; i < kIdNamesCommandIdsSize; ++i) {
+      (*string_to_id_map)[kIdNamesCommandIds[i].name] =
+          kIdNamesCommandIds[i].id;
+    }
+  }
+
+  const auto& it = string_to_id_map->find(name);
+  if (it != string_to_id_map->end()) {
+    return it->second;
+  }
+
+  LOG(WARNING) << __func__ << " called with unsupported value " << name;
+  return -1;
+}
+
 #if defined(OS_WIN)
 
 #if defined(ARCH_CPU_32_BITS)

libcef_dll/wrapper/libcef_dll_wrapper2.cc

@@ -19,12 +19,9 @@ int CefRunWinMainWithPreferredStackSize(wWinMainPtr wWinMain,
                                         int nCmdShow) {
   CHECK(wWinMain && hInstance);
 
-  const char* api_hash = cef_api_hash(0);
-  if (strcmp(api_hash, CEF_API_HASH_PLATFORM)) {
-    // The libcef API hash does not match the current header API hash.
-    DCHECK(false);
-    return 0;
-  }
+  const char* api_hash = cef_api_hash(CEF_API_VERSION, 0);
+  CHECK(!strcmp(api_hash, CEF_API_HASH_PLATFORM)) <<
+      "API hashes for libcef and libcef_dll_wrapper do not match.";
 
   return cef_run_winmain_with_preferred_stack_size(wWinMain, hInstance,
                                                    lpCmdLine, nCmdShow);
@@ -33,12 +30,9 @@ int CefRunWinMainWithPreferredStackSize(wWinMainPtr wWinMain,
 int CefRunMainWithPreferredStackSize(mainPtr main, int argc, char* argv[]) {
   CHECK(main);
 
-  const char* api_hash = cef_api_hash(0);
-  if (strcmp(api_hash, CEF_API_HASH_PLATFORM)) {
-    // The libcef API hash does not match the current header API hash.
-    DCHECK(false);
-    return 0;
-  }
+  const char* api_hash = cef_api_hash(CEF_API_VERSION, 0);
+  CHECK(!strcmp(api_hash, CEF_API_HASH_PLATFORM)) <<
+      "API hashes for libcef and libcef_dll_wrapper do not match.";
 
   return cef_run_main_with_preferred_stack_size(main, argc, argv);
 }