--- a/BUILD.gn
+++ b/BUILD.gn
@@ -839,11 +839,6 @@ group("all_rust") {
     "//third_party/cloud_authenticator/processor",
   ]
 
-  # TODO(https://crbug.com/405379314): This fails to build on some iOS ASAN
-  # builders.
-  if (!is_ios || !is_asan) {
-    deps += [ "//testing/rust_gtest_interop:rust_gtest_interop_unittests" ]
-  }
 
   if (!is_cronet_build) {
     deps += [ "//skia" ]
--- a/base/BUILD.gn
+++ b/base/BUILD.gn
@@ -343,6 +343,8 @@ component("base") {
     "hash/legacy_hash.cc",
     "hash/legacy_hash.h",
     "json/json_common.h",
+    "json/json_parser.cc",
+    "json/json_parser.h",
     "json/json_reader.cc",
     "json/json_reader.h",
     "json/json_string_value_serializer.cc",
@@ -1087,10 +1089,6 @@ component("base") {
   # Used by metrics/crc32
   deps += [ "//third_party/zlib" ]
 
-  deps += [
-    ":rust_logger",
-    "//third_party/rust/serde_json_lenient/v0_2/wrapper",
-  ]
 
   if (use_asan_backup_ref_ptr) {
     # Used by raw_ptr_service.cc to override {malloc,free,ignore_free} hooks.
@@ -1141,6 +1139,7 @@ component("base") {
     "//base/third_party/icu",
     "//build:chromecast_buildflags",
     "//third_party/abseil-cpp:absl",
+    "//third_party/abseil-cpp/absl/base:raw_logging_internal",
   ]
 
   if (use_asan_backup_ref_ptr) {
@@ -1151,14 +1150,6 @@ component("base") {
     }
   }
 
-  sources += [
-    "containers/span_rust.h",
-    "strings/string_view_rust.h",
-  ]
-
-  # Base provides conversions between CXX types and base types (e.g.
-  # std::string_view).
-  public_deps += [ "//build/rust:cxx_cppdeps" ]
 
   # Needed for <atomic> if using newer C++ library than sysroot, except if
   # building inside the cros_sdk environment - use host_toolchain as a
@@ -1615,8 +1606,6 @@ component("base") {
     "files/scoped_temp_file.h",
     "json/json_file_value_serializer.cc",
     "json/json_file_value_serializer.h",
-    "logging/rust_log_integration.cc",
-    "logging/rust_log_integration.h",
     "memory/discardable_memory.cc",
     "memory/discardable_memory.h",
     "memory/discardable_memory_allocator.cc",
@@ -3855,11 +3844,6 @@ test("base_unittests") {
     sources += [ "immediate_crash_unittest.cc" ]
   }
 
-  sources += [
-    "containers/span_rust_unittest.cc",
-    "strings/string_piece_rust_unittest.cc",
-  ]
-
   fuzztests = [ "JSONReaderTest.CanParseAnythingWithoutCrashing" ]
 
   defines = []
@@ -3906,8 +3890,6 @@ test("base_unittests") {
     deps += [ "allocator/partition_allocator/src/partition_alloc:unittests" ]
   }
 
-  deps += [ "//build/rust:cxx_cppdeps" ]
-
   data_deps = [
     "//base/test:immediate_crash_test_helper",
     "//base/test:test_child_process",
--- a/base/json/json_reader.cc
+++ b/base/json/json_reader.cc
@@ -12,111 +12,7 @@
 #include "base/strings/strcat.h"
 #include "base/strings/string_number_conversions.h"
 #include "build/build_config.h"
-#include "base/strings/string_view_rust.h"
-#include "third_party/rust/serde_json_lenient/v0_2/wrapper/functions.h"
-#include "third_party/rust/serde_json_lenient/v0_2/wrapper/lib.rs.h"
-
-// This namespace defines FFI-friendly functions that are be called from Rust in
-// //third_party/rust/serde_json_lenient/v0_2/wrapper/.
-namespace serde_json_lenient {
-
-base::ListValue& list_append_list(base::ListValue& ctx) {
-  ctx.Append(base::ListValue());
-  return ctx.back().GetList();
-}
-
-base::DictValue& list_append_dict(base::ListValue& ctx) {
-  ctx.Append(base::DictValue());
-  return ctx.back().GetDict();
-}
-
-void list_append_none(base::ListValue& ctx) {
-  ctx.Append(base::Value());
-}
-
-void list_append_bool(base::ListValue& ctx, bool val) {
-  ctx.Append(val);
-}
-
-void list_append_i32(base::ListValue& ctx, int32_t val) {
-  ctx.Append(val);
-}
-
-void list_append_f64(base::ListValue& ctx, double val) {
-  ctx.Append(val);
-}
-
-void list_append_str(base::ListValue& ctx, rust::Str val) {
-  ctx.Append(std::string(val));
-}
-
-base::ListValue& dict_set_list(base::DictValue& ctx, rust::Str key) {
-  base::Value* value =
-      ctx.Set(base::RustStrToStringView(key), base::ListValue());
-  return value->GetList();
-}
-
-base::DictValue& dict_set_dict(base::DictValue& ctx, rust::Str key) {
-  base::Value* value =
-      ctx.Set(base::RustStrToStringView(key), base::DictValue());
-  return value->GetDict();
-}
-
-void dict_set_none(base::DictValue& ctx, rust::Str key) {
-  ctx.Set(base::RustStrToStringView(key), base::Value());
-}
-
-void dict_set_bool(base::DictValue& ctx, rust::Str key, bool val) {
-  ctx.Set(base::RustStrToStringView(key), val);
-}
-
-void dict_set_i32(base::DictValue& ctx, rust::Str key, int32_t val) {
-  ctx.Set(base::RustStrToStringView(key), val);
-}
-
-void dict_set_f64(base::DictValue& ctx, rust::Str key, double val) {
-  ctx.Set(base::RustStrToStringView(key), val);
-}
-
-void dict_set_str(base::DictValue& ctx, rust::Str key, rust::Str val) {
-  ctx.Set(base::RustStrToStringView(key), std::string(val));
-}
-
-namespace {
-
-base::JSONReader::Result DecodeJSONInRust(std::string_view json,
-                                          int options,
-                                          size_t max_depth) {
-  const JsonOptions rust_options = {
-      .allow_trailing_commas =
-          (options & base::JSON_ALLOW_TRAILING_COMMAS) != 0,
-      .replace_invalid_characters =
-          (options & base::JSON_REPLACE_INVALID_CHARACTERS) != 0,
-      .allow_comments = (options & base::JSON_ALLOW_COMMENTS) != 0,
-      .allow_newlines = (options & base::JSON_ALLOW_NEWLINES_IN_STRINGS) != 0,
-      .allow_vert_tab = (options & base::JSON_ALLOW_VERT_TAB) != 0,
-      .allow_x_escapes = (options & base::JSON_ALLOW_X_ESCAPES) != 0,
-      .max_depth = max_depth,
-  };
-
-  base::ListValue list;
-  DecodeError error;
-  bool ok =
-      decode_json(base::StringViewToRustSlice(json), rust_options, list, error);
-
-  if (!ok) {
-    return base::unexpected(base::JSONReader::Error{
-        .message = std::string(error.message),
-        .line = error.line,
-        .column = error.column,
-    });
-  }
-
-  return std::move(list.back());
-}
-
-}  // namespace
-}  // namespace serde_json_lenient
+#include "base/json/json_parser.h"
 
 namespace base {
 
@@ -129,12 +25,8 @@ std::string JSONReader::Error::ToString(
 std::optional<Value> JSONReader::Read(std::string_view json,
                                       int options,
                                       size_t max_depth) {
-  JSONReader::Result result =
-      serde_json_lenient::DecodeJSONInRust(json, options, max_depth);
-  if (!result.has_value()) {
-    return std::nullopt;
-  }
-  return std::move(*result);
+  internal::JSONParser parser(options, max_depth);
+  return parser.Parse(json);
 }
 
 // static
@@ -163,8 +55,17 @@ std::optional<ListValue> JSONReader::Rea
 JSONReader::Result JSONReader::ReadAndReturnValueWithError(
     std::string_view json,
     int options) {
-  return serde_json_lenient::DecodeJSONInRust(json, options,
-                                              internal::kAbsoluteMaxDepth);
+    internal::JSONParser parser(options);
+  auto value = parser.Parse(json);
+  if (!value) {
+    Error error;
+    error.message = parser.GetErrorMessage();
+    error.line = parser.error_line();
+    error.column = parser.error_column();
+    return base::unexpected(std::move(error));
+  }
+
+  return std::move(*value);
 }
 
 }  // namespace base
--- a/base/logging.cc
+++ b/base/logging.cc
@@ -34,7 +34,6 @@
 #include "base/functional/callback.h"
 #include "base/immediate_crash.h"
 #include "base/logging/logging_settings.h"
-#include "base/logging/rust_logger.rs.h"
 #include "base/no_destructor.h"
 #include "base/path_service.h"
 #include "base/pending_task.h"
@@ -507,7 +506,7 @@ bool BaseInitLoggingImpl(const LoggingSe
 #endif
 
   // Connects Rust logging with the //base logging functionality.
-  internal::init_rust_log_crate();
+  //internal::init_rust_log_crate();
 
   // Ignore file options unless logging to file is set.
   if ((g_logging_destination & LOG_TO_FILE) == 0) {
--- a/components/user_data_importer/content/stable_portability_data_importer.cc
+++ b/components/user_data_importer/content/stable_portability_data_importer.cc
@@ -16,73 +16,11 @@
 #include "components/strings/grit/components_strings.h"
 #include "components/user_data_importer/utility/bookmark_util.h"
 #include "components/user_data_importer/utility/history_callback_from_rust.h"
-#include "components/user_data_importer/utility/parsing_ffi/lib.rs.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 
 namespace user_data_importer {
 
-namespace {
-
-std::string_view RustStringToStringView(const rust::String& rust_string) {
-  return std::string_view(rust_string.data(), rust_string.length());
-}
-
-std::u16string RustStringToUTF16(const rust::String& rust_string) {
-  return base::UTF8ToUTF16(RustStringToStringView(rust_string));
-}
-
-std::optional<history::URLRow> ConvertToURLRow(
-    const user_data_importer::StablePortabilityHistoryEntry& history_entry) {
-  GURL gurl(RustStringToStringView(history_entry.url));
-  if (!gurl.is_valid()) {
-    return std::nullopt;
-  }
-
-  history::URLRow url_row(gurl);
-  url_row.set_title(RustStringToUTF16(history_entry.title));
-  url_row.set_visit_count(history_entry.visit_count);
-
-  url_row.set_last_visit(
-      base::Time::UnixEpoch() +
-      base::Microseconds(history_entry.visit_time_unix_epoch_usec));
-  url_row.set_typed_count(history_entry.typed_count);
-
-  return url_row;
-}
-
-}  // namespace
-
-StablePortabilityDataImporter::RustHistoryCallbackForStablePortabilityFormat::
-    RustHistoryCallbackForStablePortabilityFormat(
-        TransferHistoryCallback transfer_history_callback,
-        user_data_importer::StablePortabilityDataImporter::ImportCallback
-            done_callback)
-    : transfer_history_callback_(std::move(transfer_history_callback)),
-      done_callback_(std::move(done_callback)) {}
-
-StablePortabilityDataImporter::RustHistoryCallbackForStablePortabilityFormat::
-    ~RustHistoryCallbackForStablePortabilityFormat() = default;
-
-void StablePortabilityDataImporter::
-    RustHistoryCallbackForStablePortabilityFormat::ImportHistoryEntries(
-        std::unique_ptr<std::vector<StablePortabilityHistoryEntry>>
-            history_entries,
-        bool completed) {
-  parsed_history_entries_count_ += history_entries->size();
-  transfer_history_callback_.Run(std::move(*history_entries));
-
-  if (completed && done_callback_) {
-    std::move(done_callback_).Run(parsed_history_entries_count_);
-  }
-}
-
-void StablePortabilityDataImporter::
-    RustHistoryCallbackForStablePortabilityFormat::Fail() {
-  if (done_callback_) {
-    std::move(done_callback_).Run(-1);
-  }
-}
 
 StablePortabilityDataImporter::BackgroundWorker::BackgroundWorker(
     std::unique_ptr<ContentBookmarkParser> bookmark_parser)
@@ -96,16 +34,6 @@ void StablePortabilityDataImporter::Back
   bookmark_parser_->Parse(std::move(file), std::move(bookmarks_callback));
 }
 
-#if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
-void StablePortabilityDataImporter::BackgroundWorker::ParseHistory(
-    base::File file,
-    std::unique_ptr<RustHistoryCallbackForStablePortabilityFormat> callback,
-    size_t import_batch_size) {
-  int owned_raw_fd = file.TakePlatformFile();
-  user_data_importer::parse_stable_portability_history(
-      owned_raw_fd, std::move(callback), import_batch_size);
-}
-#endif  // BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
 
 StablePortabilityDataImporter::StablePortabilityDataImporter(
     history::HistoryService* history_service,
@@ -210,51 +138,15 @@ void StablePortabilityDataImporter::Impo
     return;
   }
 
-  auto transfer_history_entries_callback = base::BindPostTask(
-      origin_sequence_task_runner_,
-      base::BindRepeating(
-          &StablePortabilityDataImporter::TransferHistoryEntries,
-          weak_factory_.GetWeakPtr()));
-
   auto done_callback =
       base::BindOnce(&StablePortabilityDataImporter::OnHistoryImportCompleted,
                      weak_factory_.GetWeakPtr(), std::move(history_callback));
   auto done_callback_on_thread = base::BindPostTask(
       origin_sequence_task_runner_, std::move(done_callback));
 
-  auto rust_history_callback =
-      std::make_unique<RustHistoryCallbackForStablePortabilityFormat>(
-          std::move(transfer_history_entries_callback),
-          std::move(done_callback_on_thread));
-
-  background_worker_.AsyncCall(&BackgroundWorker::ParseHistory)
-      .WithArgs(std::move(file), std::move(rust_history_callback),
-                import_batch_size);
 }
 #endif  // BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
 
-void StablePortabilityDataImporter::TransferHistoryEntries(
-    std::vector<StablePortabilityHistoryEntry> history_entries) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
-  CHECK(history_service_);
-
-  history::URLRows url_rows;
-  url_rows.reserve(history_entries.size());
-  for (const auto& history_entry : history_entries) {
-    std::optional<history::URLRow> opt_row = ConvertToURLRow(history_entry);
-    if (opt_row) {
-      url_rows.push_back(std::move(opt_row.value()));
-    }
-  }
-
-  if (!url_rows.empty()) {
-    history_service_->AddPagesWithDetails(
-        url_rows, history::SOURCE_OS_MIGRATION_IMPORTED);
-    imported_history_entries_count_ += url_rows.size();
-  }
-}
-
 void StablePortabilityDataImporter::OnHistoryImportCompleted(
     ImportCallback history_callback,
     int parsed_history_entries_count) {
--- a/components/user_data_importer/content/stable_portability_data_importer.h
+++ b/components/user_data_importer/content/stable_portability_data_importer.h
@@ -31,7 +31,6 @@ class ReadingListModel;
 
 namespace user_data_importer {
 
-struct StablePortabilityHistoryEntry;
 
 // Main model-layer object for extracting the data exported by browsers in the
 // stable portability data format. The data is received through a system API in
@@ -79,35 +78,6 @@ class StablePortabilityDataImporter {
  private:
   // Object used to allow Rust History import pipeline to communicate results
   // back to this importer.
-  class RustHistoryCallbackForStablePortabilityFormat final
-      : public user_data_importer::HistoryCallbackFromRust<
-            StablePortabilityHistoryEntry> {
-   public:
-    using TransferHistoryCallback = base::RepeatingCallback<void(
-        std::vector<StablePortabilityHistoryEntry>)>;
-
-    explicit RustHistoryCallbackForStablePortabilityFormat(
-        TransferHistoryCallback transfer_history_callback,
-        user_data_importer::StablePortabilityDataImporter::ImportCallback
-            done_callback);
-
-    ~RustHistoryCallbackForStablePortabilityFormat() override;
-
-    // Called from Rust when a batch of history entries has been parsed.
-    void ImportHistoryEntries(
-        std::unique_ptr<std::vector<
-            user_data_importer::StablePortabilityHistoryEntry>> history_entries,
-        bool completed) override;
-
-    // Calls `done_callback_` with 0 to signal that parsing has failed.
-    void Fail() override;
-
-   private:
-    TransferHistoryCallback transfer_history_callback_;
-    user_data_importer::StablePortabilityDataImporter::ImportCallback
-        done_callback_;
-    size_t parsed_history_entries_count_ = 0;
-  };
 
   // Encapsulates work which must occur in the background thread.
   class BackgroundWorker {
@@ -121,12 +91,6 @@ class StablePortabilityDataImporter {
         user_data_importer::BookmarkParser::BookmarkParsingCallback
             bookmarks_callback);
 
-#if BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
-    void ParseHistory(
-        base::File file,
-        std::unique_ptr<RustHistoryCallbackForStablePortabilityFormat> callback,
-        size_t import_batch_size);
-#endif  // BUILDFLAG(IS_POSIX) || BUILDFLAG(IS_FUCHSIA)
 
    private:
     std::unique_ptr<ContentBookmarkParser> bookmark_parser_;
@@ -134,10 +98,6 @@ class StablePortabilityDataImporter {
 
   friend class StablePortabilityDataImporterTest;
 
-  // Transfers the history entries to the importer. This is used by the Rust
-  // History import pipeline to communicate results back to this importer.
-  void TransferHistoryEntries(
-      std::vector<StablePortabilityHistoryEntry> history_entries);
 
   // Logs metrics related to history importing and invokes `history_callback`
   // with the number of history entries imported. A negative
--- a/components/user_data_importer/mojom/BUILD.gn
+++ b/components/user_data_importer/mojom/BUILD.gn
@@ -39,7 +39,6 @@ mojom("mojom") {
       traits_sources = [ "bookmark_html_parser_traits.cc" ]
       traits_public_deps = [
         "//components/favicon_base",
-        "//components/user_data_importer/utility:safari_data_importer",
       ]
     },
   ]
--- a/content/browser/child_process_security_policy_impl.cc
+++ b/content/browser/child_process_security_policy_impl.cc
@@ -28,7 +28,6 @@
 #include "base/strings/stringprintf.h"
 #include "build/build_config.h"
 #include "content/browser/bad_message.h"
-#include "content/browser/child_process_security_policy_impl.rs.h"
 #include "content/browser/isolated_origin_util.h"
 #include "content/browser/process_lock.h"
 #include "content/browser/renderer_host/render_process_host_impl.h"
@@ -115,10 +114,7 @@ const base::FeatureParam<RustPolicy> kRu
 // implementation is enabled, and whether both Rust and the legacy C++
 // implementations should run in parallel.
 RustPolicy GetRustPolicy() {
-  if (!base::FeatureList::IsEnabled(kChildProcessSecurityPolicyRust)) {
     return RustPolicy::kCppOnly;
-  }
-  return kRustPolicyParam.Get();
 }
 bool IsRustEnabled() {
   return GetRustPolicy() == RustPolicy::kRustAndCpp ||
@@ -147,9 +143,6 @@ T CheckAndReturnRustAndCppResults(const
 // Macro for gating whether a void function should use its Rust or C++
 // implementation (or both), based on current feature flags.
 #define RUST_CPP_VOID_FUNCTION(rust_function_call, cpp_function_call) \
-  if (IsRustEnabled()) {                                              \
-    rust_function_call;                                               \
-  }                                                                   \
   if (IsCppEnabled()) {                                               \
     cpp_function_call;                                                \
   }
@@ -162,12 +155,6 @@ T CheckAndReturnRustAndCppResults(const
 #define RUST_CPP_RETURN_FUNCTION(rust_function_call, cpp_function_call, \
                                  ReturnType)                            \
   ReturnType rust_result{};                                             \
-  if (IsRustEnabled()) {                                                \
-    rust_result = rust_function_call;                                   \
-    if (GetRustPolicy() == RustPolicy::kRustOnly) {                     \
-      return rust_result;                                               \
-    }                                                                   \
-  }                                                                     \
   ReturnType cpp_result = cpp_function_call;                            \
   return CheckAndReturnRustAndCppResults(rust_result, cpp_result);
 
--- a/media/parsers/BUILD.gn
+++ b/media/parsers/BUILD.gn
@@ -28,8 +28,6 @@ source_set("parsers") {
     "h264_poc.h",
     "jpeg_parser.cc",
     "jpeg_parser.h",
-    "parse_jpeg_wrapper.cc",
-    "parse_jpeg_wrapper.h",
     "temporal_scalability_id_extractor.cc",
     "temporal_scalability_id_extractor.h",
     "vp8_bool_decoder.cc",
--- a/media/parsers/jpeg_parser.cc
+++ b/media/parsers/jpeg_parser.cc
@@ -575,9 +575,6 @@ bool ParseJpegPictureLegacy(base::span<c
 bool ParseJpegPicture(base::span<const uint8_t> buffer,
                       JpegParseResult* result) {
   CHECK(result);
-  if (base::FeatureList::IsEnabled(kUseRustJpegParser)) {
-    return ParseJpegPictureRust(buffer, result);
-  }
   return ParseJpegPictureLegacy(buffer, result);
 }
 
--- a/mojo/BUILD.gn
+++ b/mojo/BUILD.gn
@@ -57,7 +57,6 @@ test("mojo_unittests") {
     "//mojo/public/cpp/platform/tests",
     "//mojo/public/cpp/system/tests",
     "//mojo/public/js/ts/bindings/tests",
-    "//mojo/public/rust:tests",
   ]
 
   if (is_linux && mojo_support_legacy_core) {
--- a/mojo/public/BUILD.gn
+++ b/mojo/public/BUILD.gn
@@ -9,7 +9,6 @@ group("public") {
     ":sdk",
     "cpp/bindings",
     "interfaces/bindings/tests:test_interfaces",
-    "rust:all",
   ]
 
   if (is_android) {
@@ -24,8 +23,6 @@ group("sdk") {
   deps = [
     "c/system",
     "cpp/bindings",
-    "rust/bindings",
-    "rust/system",
   ]
 }
 
--- a/mojo/public/rust/sequences/BUILD.gn
+++ b/mojo/public/rust/sequences/BUILD.gn
@@ -23,8 +23,6 @@ rust_static_library("sequences") {
     "//base",
   ]
 
-  allow_circular_includes_from = [ ":cxx_shim" ]
-
   visibility = [ "../*" ]
 }
 
--- a/services/on_device_model/ml/BUILD.gn
+++ b/services/on_device_model/ml/BUILD.gn
@@ -78,7 +78,6 @@ if (use_blink || (is_ios && build_with_i
 
     if (enable_constraints) {
       defines += [ "ENABLE_ON_DEVICE_CONSTRAINTS" ]
-      deps += [ "//third_party/rust/llguidance/v1:lib" ]
     }
     if (use_blink) {
       deps += [ "//gpu/config" ]
--- a/services/on_device_model/ml/chrome_ml.cc
+++ b/services/on_device_model/ml/chrome_ml.cc
@@ -24,7 +24,6 @@
 #include "third_party/dawn/include/dawn/dawn_proc.h"
 #include "third_party/dawn/include/dawn/native/DawnNative.h"
 #include "third_party/dawn/include/dawn/webgpu_cpp.h"
-#include "third_party/rust/chromium_crates_io/vendor/llguidance-v1/llguidance.h"
 
 #if !BUILDFLAG(IS_IOS)
 #include "gpu/config/gpu_info_collector.h"
--- a/services/on_device_model/ml/constraint_factory.cc
+++ b/services/on_device_model/ml/constraint_factory.cc
@@ -10,7 +10,6 @@
 #include "base/trace_event/trace_event.h"
 #include "services/on_device_model/ml/chrome_ml.h"
 #include "services/on_device_model/public/mojom/on_device_model.mojom.h"
-#include "third_party/rust/chromium_crates_io/vendor/llguidance-v1/llguidance.h"
 
 namespace ml {
 
--- a/third_party/abseil-cpp/absl/base/BUILD.gn
+++ b/third_party/abseil-cpp/absl/base/BUILD.gn
@@ -73,6 +73,7 @@ absl_source_set("raw_logging_internal")
   visibility = [
     "//third_party/abseil-cpp:absl_component_deps",
     "//third_party/abseil-cpp/absl/*",
+    "//base:base",
   ]
 }
 
--- a/third_party/blink/common/BUILD.gn
+++ b/third_party/blink/common/BUILD.gn
@@ -315,7 +315,6 @@ source_set("common") {
     "//services/metrics/public/mojom",
     "//services/network/public/cpp",
     "//services/network/public/mojom:mojom_permissions_policy",
-    "//third_party/blink/common/rust_crash",
     "//third_party/blink/public/common:buildflags",
     "//third_party/re2",
     "//ui/base",
--- a/third_party/blink/common/chrome_debug_urls.cc
+++ b/third_party/blink/common/chrome_debug_urls.cc
@@ -12,7 +12,6 @@
 #include "base/threading/platform_thread.h"
 #include "build/build_config.h"
 #include "third_party/blink/common/crash_helpers.h"
-#include "third_party/blink/common/rust_crash/src/lib.rs.h"
 #include "url/gurl.h"
 
 #if BUILDFLAG(IS_WIN)
@@ -118,7 +117,7 @@ NOINLINE void MaybeTriggerAsanError(cons
     // Ensure that ASAN works even in Rust code.
     LOG(ERROR) << "Intentionally causing ASAN heap overflow in Rust"
                << " because user navigated to " << url.spec();
-    crash_in_rust_with_overflow();
+    //crash_in_rust_with_overflow();
   }
 }
 #endif  // ADDRESS_SANITIZER
@@ -138,7 +137,7 @@ void HandleChromeDebugURL(const GURL& ur
   } else if (url == kChromeUICrashRustURL) {
     // Cause a typical crash in Rust code, so we can test that call stack
     // collection and symbol mangling work across the language boundary.
-    crash_in_rust();
+    //crash_in_rust();
   } else if (url == kChromeUIDumpURL) {
     // This URL will only correctly create a crash dump file if content is
     // hosted in a process that has correctly called
--- a/third_party/blink/renderer/core/BUILD.gn
+++ b/third_party/blink/renderer/core/BUILD.gn
@@ -431,7 +431,6 @@ component("core") {
     "//third_party/blink/public/strings:generate_permission_element_strings_mono_grd",
     "//third_party/blink/public/strings:permission_element_generated_strings",
     "//third_party/blink/public/strings:permission_element_strings_grit",
-    "//third_party/rust/xml/v1:lib",
     "//tools/v8_context_snapshot:buildflags",
     "//ui/base/cursor/mojom:cursor_type_blink",
     "//ui/base/dragdrop/mojom:mojom_blink",
--- a/third_party/blink/renderer/core/dom/document.cc
+++ b/third_party/blink/renderer/core/dom/document.cc
@@ -359,7 +359,6 @@
 #include "third_party/blink/renderer/core/view_transition/view_transition_supplement.h"
 #include "third_party/blink/renderer/core/view_transition/view_transition_utils.h"
 #include "third_party/blink/renderer/core/xml/parser/xml_document_parser.h"
-#include "third_party/blink/renderer/core/xml/parser/xml_document_parser_rs.h"
 #include "third_party/blink/renderer/core/xml_names.h"
 #include "third_party/blink/renderer/core/xmlns_names.h"
 #include "third_party/blink/renderer/platform/bindings/dom_data_store.h"
@@ -3578,28 +3577,7 @@ DocumentParser* Document::CreateParser()
 
   data_->using_rust_xml_parser_ = false;
 
-  // Use the Rust XML parser for situations non-XSLT situations: XMLHttpRequest,
-  // JS DOMParser API, where no dom_window_ is available, or for SVG images.
-  if (!GetFrame() || IsSVGDocument()) {
-    // Measure this for now only in non-frame = non-XSLT situations, so that
-    // when we compare the UMA metrics of Rust vs. non-Rust for
-    // XMLRustForNonXsltEnabled(), we're looking at roughly the same type and
-    // length of documents on average.
-    data_->xml_parser_start_time_ = base::TimeTicks::Now();
-
-    if (RuntimeEnabledFeatures::XMLRustForNonXsltEnabled()) {
-      data_->using_rust_xml_parser_ = true;
-      return MakeGarbageCollected<XMLDocumentParserRs>(*this, View());
-    }
-  }
-
-  // FIXME: this should probably pass the frame instead
-  if (RuntimeEnabledFeatures::XMLParsingRustEnabled()) {
-    data_->using_rust_xml_parser_ = true;
-    return MakeGarbageCollected<XMLDocumentParserRs>(*this, View());
-  } else {
     return MakeGarbageCollected<XMLDocumentParser>(*this, View());
-  }
 }
 
 bool Document::IsFrameSet() const {
--- a/third_party/blink/renderer/core/dom/processing_instruction.cc
+++ b/third_party/blink/renderer/core/dom/processing_instruction.cc
@@ -41,7 +41,6 @@
 #include "third_party/blink/renderer/core/svg/graphics/svg_image_chrome_client.h"
 #include "third_party/blink/renderer/core/xml/document_xslt.h"
 #include "third_party/blink/renderer/core/xml/parser/xml_document_parser.h"  // for parseAttributes()
-#include "third_party/blink/renderer/core/xml/parser/xml_document_parser_rs.h"  // for parseAttributesRust()
 #include "third_party/blink/renderer/core/xml/xsl_style_sheet.h"
 #include "third_party/blink/renderer/core/xml/xslt_processor.h"
 #include "third_party/blink/renderer/platform/heap/garbage_collected.h"
@@ -145,11 +144,7 @@ void ProcessingInstruction::ProcessAttri
     // ### make sure this gets called when adding from javascript
     bool attrs_ok;
     HashMap<String, String> attrs;
-    if (RuntimeEnabledFeatures::XMLParsingRustEnabled()) {
-      attrs = ParseAttributesRust(data_, attrs_ok);
-    } else {
       attrs = ParseAttributes(data_, attrs_ok);
-    }
     if (!attrs_ok) {
       return;
     }
--- a/third_party/blink/renderer/core/xml/build.gni
+++ b/third_party/blink/renderer/core/xml/build.gni
@@ -17,15 +17,11 @@ blink_core_sources_xml = [
   "parser/xhtml_subset.h",
   "parser/xml_document_parser.cc",
   "parser/xml_document_parser.h",
-  "parser/xml_document_parser_rs.cc",
-  "parser/xml_document_parser_rs.h",
   "parser/xml_document_parser_scope.cc",
   "parser/xml_document_parser_scope.h",
   "parser/xml_errors.cc",
   "parser/xml_errors.h",
   "parser/xml_parser_input.h",
-  "parser/xml_ffi_callbacks.cc",
-  "parser/xml_ffi_callbacks.h",
   "xml_serializer.cc",
   "xml_serializer.h",
   "xpath_evaluator.cc",
--- a/third_party/breakpad/BUILD.gn
+++ b/third_party/breakpad/BUILD.gn
@@ -746,12 +746,6 @@ if (is_linux || is_chromeos || is_androi
 
       include_dirs = [ "breakpad/src" ]
 
-      # Rust demangle support.
-      deps = [ "//third_party/rust/rustc_demangle_capi/v0_1:lib" ]
-      defines += [ "HAVE_RUSTC_DEMANGLE" ]
-      include_dirs += [ "//third_party/rust/chromium_crates_io/vendor/rustc-demangle-capi-v0_1/include" ]
-      sources += [ "//third_party/rust/chromium_crates_io/vendor/rustc-demangle-capi-v0_1/include/rustc_demangle.h" ]
-
       libs = [ "z" ]
     }
   } else if (current_toolchain == default_toolchain) {