@@ -181,27 +181,8 @@ class V8_EXPORT Context : public Data {
      * also be considered for freezing should be added to the children_out
      * parameter. Returns true if the operation completed successfully.
      */
-    V8_DEPRECATED("Please use the version that takes a LocalVector&")
     virtual bool FreezeEmbedderObjectAndGetChildren(
-        Local<Object> obj, std::vector<Local<Object>>& children_out) {
-      // TODO(chromium:1454114): This method is temporarily defined in order to
-      // smoothen the transition to the version that follows.
-      return true;
-    }
-    virtual bool FreezeEmbedderObjectAndGetChildren(
-        Local<Object> obj, LocalVector<Object>& children_out) {
-      // TODO(chromium:1454114): This method is temporarily defined and
-      // calls the previous version, soon to be deprecated, in order to
-      // smoothen the transition. When deprecation is completed, this
-      // will become an abstract method.
-      std::vector<Local<Object>> children;
-      START_ALLOW_USE_DEPRECATED()
-      // Temporarily use the old callback.
-      bool result = FreezeEmbedderObjectAndGetChildren(obj, children);
-      END_ALLOW_USE_DEPRECATED()
-      children_out.insert(children_out.end(), children.begin(), children.end());
-      return result;
-    }
+        Local<Object> obj, LocalVector<Object>& children_out) = 0;
   };
 
   /**
 
@@ -291,11 +291,6 @@ class V8_EXPORT Module : public Data {
    * module_name is used solely for logging/debugging and doesn't affect module
    * behavior.
    */
-  V8_DEPRECATED("Please use the version that takes a MemorySpan")
-  static Local<Module> CreateSyntheticModule(
-      Isolate* isolate, Local<String> module_name,
-      const std::vector<Local<String>>& export_names,
-      SyntheticModuleEvaluationSteps evaluation_steps);
   static Local<Module> CreateSyntheticModule(
       Isolate* isolate, Local<String> module_name,
       const MemorySpan<const Local<String>>& export_names,
@@ -311,17 +306,6 @@ class V8_EXPORT Module : public Data {
   V8_WARN_UNUSED_RESULT Maybe<bool> SetSyntheticModuleExport(
       Isolate* isolate, Local<String> export_name, Local<Value> export_value);
 
-  /**
-   * Search the modules requested directly or indirectly by the module for
-   * any top-level await that has not yet resolved. If there is any, the
-   * returned vector contains a tuple of the unresolved module and a message
-   * with the pending top-level await.
-   * An embedder may call this before exiting to improve error messages.
-   */
-  V8_DEPRECATED("Please use GetStalledTopLevelAwaitMessages")
-  std::vector<std::tuple<Local<Module>, Local<Message>>>
-  GetStalledTopLevelAwaitMessage(Isolate* isolate);
-
   /**
    * Search the modules requested directly or indirectly by the module for
    * any top-level await that has not yet resolved. If there is any, the
 
@@ -61,33 +61,8 @@ class V8_EXPORT MeasureMemoryDelegate {
    */
   virtual bool ShouldMeasure(Local<Context> context) = 0;
 
-  /**
-   * This function is called when memory measurement finishes.
-   *
-   * \param context_sizes_in_bytes a vector of (context, size) pairs that
-   *   includes each context for which ShouldMeasure returned true and that
-   *   was not garbage collected while the memory measurement was in progress.
-   *
-   * \param unattributed_size_in_bytes total size of objects that were not
-   *   attributed to any context (i.e. are likely shared objects).
-   */
-  V8_DEPRECATED("Please use the version that takes a result struct")
-  virtual void MeasurementComplete(
-      const std::vector<std::pair<Local<Context>, size_t>>&
-          context_sizes_in_bytes,
-      size_t unattributed_size_in_bytes) {}
-
   /** Holds the result of a memory measurement request. */
   struct Result {
-    /**
-     * A vector of (context, size) pairs that includes each context for
-     * which ShouldMeasure returned true and that was not garbage collected
-     * while the memory measurement was in progress.
-     */
-    V8_DEPRECATED("Please use contexts and sizes_in_bytes")
-    const std::vector<std::pair<Local<Context>, size_t>>&
-        context_sizes_in_bytes;
-
     /**
      * Two spans of equal length: the first includes each context for which
      * ShouldMeasure returned true and that was not garbage collected while
 
@@ -2451,16 +2451,6 @@ MaybeLocal<Value> Module::Evaluate(Local<Context> context) {
   RETURN_ESCAPED(result);
 }
 
-Local<Module> Module::CreateSyntheticModule(
-    Isolate* v8_isolate, Local<String> module_name,
-    const std::vector<Local<String>>& export_names,
-    v8::Module::SyntheticModuleEvaluationSteps evaluation_steps) {
-  return CreateSyntheticModule(
-      v8_isolate, module_name,
-      MemorySpan<const Local<String>>(export_names.begin(), export_names.end()),
-      evaluation_steps);
-}
-
 Local<Module> Module::CreateSyntheticModule(
     Isolate* v8_isolate, Local<String> module_name,
     const MemorySpan<const Local<String>>& export_names,
@@ -2501,33 +2491,6 @@ Maybe<bool> Module::SetSyntheticModuleExport(Isolate* v8_isolate,
   return Just(true);
 }
 
-std::vector<std::tuple<Local<Module>, Local<Message>>>
-Module::GetStalledTopLevelAwaitMessage(Isolate* isolate) {
-  auto i_isolate = reinterpret_cast<i::Isolate*>(isolate);
-  auto self = Utils::OpenDirectHandle(this);
-  Utils::ApiCheck(i::IsSourceTextModule(*self),
-                  "v8::Module::GetStalledTopLevelAwaitMessage",
-                  "v8::Module::GetStalledTopLevelAwaitMessage must only be "
-                  "called on a SourceTextModule");
-  std::vector<
-      std::tuple<i::Handle<i::SourceTextModule>, i::Handle<i::JSMessageObject>>>
-      stalled_awaits = i::DirectHandle<i::SourceTextModule>::cast(self)
-                           ->GetStalledTopLevelAwaitMessages(i_isolate);
-
-  std::vector<std::tuple<Local<Module>, Local<Message>>> result;
-  size_t stalled_awaits_count = stalled_awaits.size();
-  if (stalled_awaits_count == 0) {
-    return result;
-  }
-  result.reserve(stalled_awaits_count);
-  for (size_t i = 0; i < stalled_awaits_count; ++i) {
-    auto [module, message] = stalled_awaits[i];
-    result.push_back(std::make_tuple(ToApiHandle<Module>(module),
-                                     ToApiHandle<Message>(message)));
-  }
-  return result;
-}
-
 std::pair<LocalVector<Module>, LocalVector<Message>>
 Module::GetStalledTopLevelAwaitMessages(Isolate* isolate) {
   auto i_isolate = reinterpret_cast<i::Isolate*>(isolate);
 
@@ -342,9 +342,6 @@ void MemoryMeasurement::ReportResults() {
     v8::LocalVector<v8::Context> contexts(
         reinterpret_cast<v8::Isolate*>(isolate_));
     std::vector<size_t> size_in_bytes;
-    // TODO(chromium:1454114): The vector of pairs will be removed when
-    // deprecation is complete.
-    std::vector<std::pair<v8::Local<v8::Context>, size_t>> sizes;
     DCHECK_EQ(request.sizes.size(),
               static_cast<size_t>(request.contexts->length()));
     for (int i = 0; i < request.contexts->length(); i++) {
@@ -356,20 +353,13 @@ void MemoryMeasurement::ReportResults() {
           direct_handle(raw_context, isolate_), isolate_);
       contexts.push_back(context);
       size_in_bytes.push_back(request.sizes[i]);
-      sizes.emplace_back(context, request.sizes[i]);
     }
-    // Temporarily call both old and new callbacks.
-    START_ALLOW_USE_DEPRECATED()
-    request.delegate->MeasurementComplete(sizes, request.shared);
     request.delegate->MeasurementComplete(
-        {sizes,  // TODO(chromium:1454114): This will be removed when
-                 // deprecation is complete.
-         {contexts.begin(), contexts.end()},
+        {{contexts.begin(), contexts.end()},
          {size_in_bytes.begin(), size_in_bytes.end()},
          request.shared,
          request.wasm_code,
          request.wasm_metadata});
-    END_ALLOW_USE_DEPRECATED()
     isolate_->counters()->measure_memory_delay_ms()->AddSample(
         static_cast<int>(request.timer.Elapsed().InMilliseconds()));
   }