diff --git a/cobalt/browser/application.cc b/cobalt/browser/application.cc
index ebf95f7ba587..ed0e419adaf7 100644
--- a/cobalt/browser/application.cc
+++ b/cobalt/browser/application.cc
@@ -616,9 +616,8 @@ void AddCrashLogApplicationState(base::ApplicationState state) {
     return;
   }
 
-  // Crash handler is not supported, fallback to crash log dictionary.
-  h5vcc::CrashLogDictionary::GetInstance()->SetString("application_state",
-                                                      application_state);
+  LOG(ERROR) << "Crash handler extension not implemented, at least not at the "
+             << "required version, so not sending application state.";
 }
 
 }  // namespace
diff --git a/cobalt/browser/browser_module.cc b/cobalt/browser/browser_module.cc
index f44b2b2672fc..30d7470b659a 100644
--- a/cobalt/browser/browser_module.cc
+++ b/cobalt/browser/browser_module.cc
@@ -64,11 +64,6 @@
 #include "starboard/time.h"
 #include "third_party/icu/source/i18n/unicode/timezone.h"
 
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-#include "base/memory/ptr_util.h"
-#include STARBOARD_CORE_DUMP_HANDLER_INCLUDE
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-
 using cobalt::cssom::ViewportSize;
 
 namespace cobalt {
@@ -304,15 +299,6 @@ BrowserModule::BrowserModule(const GURL& url,
   service_worker_registry_.reset(new ServiceWorkerRegistry(
       &web_settings_, network_module, platform_info_.get()));
 
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-  SbCoreDumpRegisterHandler(BrowserModule::CoreDumpHandler, this);
-  on_error_triggered_count_ = 0;
-#if defined(COBALT_CHECK_RENDER_TIMEOUT)
-  recovery_mechanism_triggered_count_ = 0;
-  timeout_response_trigger_count_ = 0;
-#endif  // defined(COBALT_CHECK_RENDER_TIMEOUT)
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-
 #if defined(COBALT_CHECK_RENDER_TIMEOUT)
   timeout_polling_thread_.Start();
   timeout_polling_thread_.message_loop()->task_runner()->PostDelayedTask(
@@ -465,9 +451,6 @@ BrowserModule::~BrowserModule() {
   }
 
   on_error_retry_timer_.Stop();
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-  SbCoreDumpUnregisterHandler(BrowserModule::CoreDumpHandler, this);
-#endif
 
 #if defined(ENABLE_DEBUGGER)
   if (debug_console_) {
@@ -753,22 +736,6 @@ void BrowserModule::Reload() {
       base::SourceLocation("[object BrowserModule]", 1, 1));
 }
 
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-// static
-void BrowserModule::CoreDumpHandler(void* browser_module_as_void) {
-  BrowserModule* browser_module =
-      static_cast<BrowserModule*>(browser_module_as_void);
-  SbCoreDumpLogInteger("BrowserModule.on_error_triggered_count_",
-                       browser_module->on_error_triggered_count_);
-#if defined(COBALT_CHECK_RENDER_TIMEOUT)
-  SbCoreDumpLogInteger("BrowserModule.recovery_mechanism_triggered_count_",
-                       browser_module->recovery_mechanism_triggered_count_);
-  SbCoreDumpLogInteger("BrowserModule.timeout_response_trigger_count_",
-                       browser_module->timeout_response_trigger_count_);
-#endif  // defined(COBALT_CHECK_RENDER_TIMEOUT)
-}
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-
 void BrowserModule::OnLoad() {
   TRACE_EVENT0("cobalt::browser", "BrowserModule::OnLoad()");
   // Repost to our own message loop if necessary. This also prevents
@@ -1341,10 +1308,6 @@ void BrowserModule::OnError(const GURL& url, const std::string& error) {
     return;
   }
 
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-  on_error_triggered_count_++;
-#endif
-
   // Set |pending_navigate_url_| to the url where the error occurred. This will
   // cause the OnError callback to Navigate() to this URL if it receives a
   // positive response; otherwise, if Cobalt is currently preloaded or
@@ -1715,18 +1678,12 @@ void BrowserModule::OnPollForRenderTimeout(const GURL& url) {
   }
 
   if (timeout_response_trigger) {
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-    timeout_response_trigger_count_++;
-#endif
     SbAtomicNoBarrier_Exchange64(
         non_trivial_global_variables.Get().last_render_timestamp,
         static_cast<SbAtomic64>(kSbTimeMax));
     if (SbSystemGetRandomUInt64() <
         kRenderTimeoutErrorPercentage * (UINT64_MAX / 100)) {
       OnError(url, std::string("Rendering Timeout"));
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-      recovery_mechanism_triggered_count_++;
-#endif
     } else {
       SB_DLOG(INFO) << "Received OnRenderTimeout, ignoring by random chance.";
     }
diff --git a/cobalt/browser/browser_module.h b/cobalt/browser/browser_module.h
index abf05fd8f5e0..b58f4122ba19 100644
--- a/cobalt/browser/browser_module.h
+++ b/cobalt/browser/browser_module.h
@@ -245,15 +245,6 @@ class BrowserModule {
   void SetDeepLinkTimestamp(SbTimeMonotonic timestamp);
 
  private:
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-  static void CoreDumpHandler(void* browser_module_as_void);
-  int on_error_triggered_count_;
-#if defined(COBALT_CHECK_RENDER_TIMEOUT)
-  int recovery_mechanism_triggered_count_;
-  int timeout_response_trigger_count_;
-#endif  // defined(COBALT_CHECK_RENDER_TIMEOUT)
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-
   // Called when the WebModule's Window.onload event is fired.
   void OnLoad();
 
diff --git a/cobalt/dom/node.cc b/cobalt/dom/node.cc
index ca68573e45a9..dcb2a373f5b7 100644
--- a/cobalt/dom/node.cc
+++ b/cobalt/dom/node.cc
@@ -42,10 +42,6 @@
 #include "cobalt/web/dom_exception.h"
 #if defined(STARBOARD)
 #include "starboard/configuration.h"
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-#define HANDLE_CORE_DUMP
-#include STARBOARD_CORE_DUMP_HANDLER_INCLUDE
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
 #endif  // defined(STARBOARD)
 
 namespace cobalt {
diff --git a/cobalt/dom_parser/libxml_parser_wrapper.cc b/cobalt/dom_parser/libxml_parser_wrapper.cc
index d3bad2d613ae..2dc88b9d264d 100644
--- a/cobalt/dom_parser/libxml_parser_wrapper.cc
+++ b/cobalt/dom_parser/libxml_parser_wrapper.cc
@@ -26,11 +26,6 @@
 #include "cobalt/dom/text.h"
 #if defined(STARBOARD)
 #include "starboard/configuration.h"
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-#define HANDLE_CORE_DUMP
-#include "base/lazy_instance.h"
-#include STARBOARD_CORE_DUMP_HANDLER_INCLUDE
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
 #endif  // defined(STARBOARD)
 #include "third_party/libxml/src/include/libxml/xmlerror.h"
 
@@ -38,68 +33,6 @@ namespace cobalt {
 namespace dom_parser {
 namespace {
 
-#if defined(HANDLE_CORE_DUMP)
-
-class LibxmlParserWrapperLog {
- public:
-  LibxmlParserWrapperLog()
-      : total_parsed_bytes_(0),
-        total_warning_count_(0),
-        total_error_count_(0),
-        total_fatal_count_(0) {
-    SbCoreDumpRegisterHandler(CoreDumpHandler, this);
-  }
-  ~LibxmlParserWrapperLog() {
-    SbCoreDumpUnregisterHandler(CoreDumpHandler, this);
-  }
-
-  static void CoreDumpHandler(void* context) {
-    SbCoreDumpLogInteger(
-        "LibxmlParserWrapper total parsed bytes",
-        static_cast<LibxmlParserWrapperLog*>(context)->total_parsed_bytes_);
-    SbCoreDumpLogInteger(
-        "LibxmlParserWrapper total warning count",
-        static_cast<LibxmlParserWrapperLog*>(context)->total_warning_count_);
-    SbCoreDumpLogInteger(
-        "LibxmlParserWrapper total error count",
-        static_cast<LibxmlParserWrapperLog*>(context)->total_error_count_);
-    SbCoreDumpLogInteger(
-        "LibxmlParserWrapper total fatal error count",
-        static_cast<LibxmlParserWrapperLog*>(context)->total_fatal_count_);
-    SbCoreDumpLogString("LibxmlParserWrapper last fatal error",
-                        static_cast<LibxmlParserWrapperLog*>(context)
-                            ->last_fatal_message_.c_str());
-  }
-
-  void IncrementParsedBytes(int length) { total_parsed_bytes_ += length; }
-  void LogParsingIssue(LibxmlParserWrapper::IssueSeverity severity,
-                       const std::string& message) {
-    if (severity == LibxmlParserWrapper::kWarning) {
-      total_warning_count_++;
-    } else if (severity == LibxmlParserWrapper::kError) {
-      total_error_count_++;
-    } else if (severity == LibxmlParserWrapper::kFatal) {
-      total_fatal_count_++;
-      last_fatal_message_ = message;
-    } else {
-      NOTREACHED();
-    }
-  }
-
- private:
-  int total_parsed_bytes_;
-  int total_warning_count_;
-  int total_error_count_;
-  int total_fatal_count_;
-  std::string last_fatal_message_;
-  DISALLOW_COPY_AND_ASSIGN(LibxmlParserWrapperLog);
-};
-
-base::LazyInstance<LibxmlParserWrapperLog>::DestructorAtExit
-    libxml_parser_wrapper_log = LAZY_INSTANCE_INITIALIZER;
-
-#endif  // defined(HANDLE_CORE_DUMP)
-
 /////////////////////////////////////////////////////////////////////////////
 // Helpers
 /////////////////////////////////////////////////////////////////////////////
@@ -320,10 +253,6 @@ void LibxmlParserWrapper::OnParsingIssue(IssueSeverity severity,
   } else {
     NOTREACHED();
   }
-
-#if defined(HANDLE_CORE_DUMP)
-  libxml_parser_wrapper_log.Get().LogParsingIssue(severity, message);
-#endif
 }
 
 void LibxmlParserWrapper::OnCDATABlock(const std::string& value) {
@@ -352,10 +281,6 @@ void LibxmlParserWrapper::PreprocessChunk(const char* data, size_t size,
     OnParsingIssue(kFatal, kMessageInputNotUTF8);
     return;
   }
-
-#if defined(HANDLE_CORE_DUMP)
-  libxml_parser_wrapper_log.Get().IncrementParsedBytes(static_cast<int>(size));
-#endif
 }
 
 }  // namespace dom_parser
diff --git a/cobalt/h5vcc/h5vcc_crash_log.cc b/cobalt/h5vcc/h5vcc_crash_log.cc
index 39c545c9da23..50c1dbeafd86 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.cc
+++ b/cobalt/h5vcc/h5vcc_crash_log.cc
@@ -23,60 +23,11 @@
 #include "base/memory/singleton.h"
 #include "base/synchronization/lock.h"
 #include "starboard/extension/crash_handler.h"
-
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-#include STARBOARD_CORE_DUMP_HANDLER_INCLUDE
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-
 #include "starboard/system.h"
 
 namespace cobalt {
 namespace h5vcc {
 
-CrashLogDictionary* CrashLogDictionary::GetInstance() {
-  return base::Singleton<CrashLogDictionary, base::DefaultSingletonTraits<
-                                                 CrashLogDictionary>>::get();
-}
-
-void CrashLogDictionary::SetString(const std::string& key,
-                                   const std::string& value) {
-  base::AutoLock lock(mutex_);
-  // While the lock prevents contention between other calls to SetString(),
-  // the atomics guard against OnCrash(), which doesn't acquire |mutex_|, from
-  // accessing the data at the same time.  In the case that OnCrash() is
-  // being called, we give up and skip adding the data.
-  if (base::subtle::Acquire_CompareAndSwap(&accessing_log_data_, 0, 1) == 0) {
-    string_log_map_[key] = value;
-    base::subtle::Release_Store(&accessing_log_data_, 0);
-  }
-}
-
-CrashLogDictionary::CrashLogDictionary() : accessing_log_data_(0) {
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-  SbCoreDumpRegisterHandler(&CoreDumpHandler, this);
-#endif
-}
-
-void CrashLogDictionary::CoreDumpHandler(void* context) {
-  CrashLogDictionary* crash_log_dictionary =
-      static_cast<CrashLogDictionary*>(context);
-  crash_log_dictionary->OnCrash();
-}
-
-void CrashLogDictionary::OnCrash() {
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-  // Check that we're not already updating log data.  If we are, we just
-  // give up and skip recording any crash data, but hopefully this is rare.
-  if (base::subtle::Acquire_CompareAndSwap(&accessing_log_data_, 0, 1) == 0) {
-    for (StringMap::const_iterator iter = string_log_map_.begin();
-         iter != string_log_map_.end(); ++iter) {
-      SbCoreDumpLogString(iter->first.c_str(), iter->second.c_str());
-    }
-    base::subtle::Release_Store(&accessing_log_data_, 0);
-  }
-#endif
-}
-
 bool H5vccCrashLog::SetString(const std::string& key,
                               const std::string& value) {
   auto crash_handler_extension =
@@ -85,14 +36,10 @@ bool H5vccCrashLog::SetString(const std::string& key,
   if (crash_handler_extension && crash_handler_extension->version >= 2) {
     return crash_handler_extension->SetString(key.c_str(), value.c_str());
   }
+
   // The platform has not implemented a version of the CrashHandler Cobalt
   // Extension appropriate for this use case.
-
-  // Forward the call to a global singleton so that we keep a consistent crash
-  // log globally.
-  CrashLogDictionary::GetInstance()->SetString(key, value);
-
-  return true;
+  return false;
 }
 
 void H5vccCrashLog::TriggerCrash(H5vccCrashType intent) {
diff --git a/cobalt/h5vcc/h5vcc_crash_log.h b/cobalt/h5vcc/h5vcc_crash_log.h
index e01d23e44841..1ddcceee37a1 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.h
+++ b/cobalt/h5vcc/h5vcc_crash_log.h
@@ -28,38 +28,6 @@
 namespace cobalt {
 namespace h5vcc {
 
-// We keep a global mapping of all registered logs.  When a crash occurs, we
-// will iterate through the mapping in this dictionary to extract all
-// logged entries and write them to the system's crash logger via Starboard.
-class CrashLogDictionary {
- public:
-  static CrashLogDictionary* GetInstance();
-
-  void SetString(const std::string& key, const std::string& value);
-
- private:
-  CrashLogDictionary();
-
-  static void CoreDumpHandler(void* context);
-
-  void OnCrash();
-
-  friend struct base::DefaultSingletonTraits<CrashLogDictionary>;
-
-  base::subtle::Atomic32 accessing_log_data_;
-
-  // It is possible for multiple threads to call the H5VCC interface at the
-  // same time, and they will all forward to this global singleton, so we
-  // use this mutex to protect against concurrent access.
-  base::Lock mutex_;
-
-  typedef std::map<std::string, std::string> StringMap;
-  // Keeps track of all string values to be logged when a crash occurs.
-  StringMap string_log_map_;
-
-  DISALLOW_COPY_AND_ASSIGN(CrashLogDictionary);
-};
-
 class H5vccCrashLog : public script::Wrappable {
  public:
   H5vccCrashLog() {}
diff --git a/cobalt/loader/net_fetcher.cc b/cobalt/loader/net_fetcher.cc
index 5ce5e2997ac6..aee6a5d5466e 100644
--- a/cobalt/loader/net_fetcher.cc
+++ b/cobalt/loader/net_fetcher.cc
@@ -31,11 +31,6 @@
 #include "net/url_request/url_fetcher.h"
 #if defined(STARBOARD)
 #include "starboard/configuration.h"
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-#define HANDLE_CORE_DUMP
-#include "base/lazy_instance.h"
-#include STARBOARD_CORE_DUMP_HANDLER_INCLUDE
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
 #endif  // defined(STARBOARD)
 
 namespace cobalt {
@@ -43,33 +38,6 @@ namespace loader {
 
 namespace {
 
-#if defined(HANDLE_CORE_DUMP)
-
-class NetFetcherLog {
- public:
-  NetFetcherLog() : total_fetched_bytes_(0) {
-    SbCoreDumpRegisterHandler(CoreDumpHandler, this);
-  }
-  ~NetFetcherLog() { SbCoreDumpUnregisterHandler(CoreDumpHandler, this); }
-
-  static void CoreDumpHandler(void* context) {
-    SbCoreDumpLogInteger(
-        "NetFetcher total fetched bytes",
-        static_cast<NetFetcherLog*>(context)->total_fetched_bytes_);
-  }
-
-  void IncrementFetchedBytes(int length) { total_fetched_bytes_ += length; }
-
- private:
-  int total_fetched_bytes_;
-  DISALLOW_COPY_AND_ASSIGN(NetFetcherLog);
-};
-
-base::LazyInstance<NetFetcherLog>::DestructorAtExit net_fetcher_log =
-    LAZY_INSTANCE_INITIALIZER;
-
-#endif  // defined(HANDLE_CORE_DUMP)
-
 bool IsResponseCodeSuccess(int response_code) {
   // NetFetcher only considers success to be if the network request
   // was successful *and* we get a 2xx response back.
@@ -302,10 +270,6 @@ void NetFetcher::OnURLFetchDownloadProgress(const net::URLFetcher* source,
     if (data.empty()) {
       return;
     }
-#if defined(HANDLE_CORE_DUMP)
-    net_fetcher_log.Get().IncrementFetchedBytes(
-        static_cast<int>(data.length()));
-#endif
     handler()->OnReceivedPassed(
         this, std::unique_ptr<std::string>(new std::string(std::move(data))));
   }
diff --git a/cobalt/script/script_runner.cc b/cobalt/script/script_runner.cc
index 8463a489cbca..e06d18404ed1 100644
--- a/cobalt/script/script_runner.cc
+++ b/cobalt/script/script_runner.cc
@@ -21,11 +21,6 @@
 #include "cobalt/script/source_code.h"
 #if defined(STARBOARD)
 #include "starboard/configuration.h"
-#if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
-#define HANDLE_CORE_DUMP
-#include "base/lazy_instance.h"
-#include STARBOARD_CORE_DUMP_HANDLER_INCLUDE
-#endif  // SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
 #endif  // defined(STARBOARD)
 
 namespace cobalt {
@@ -33,37 +28,6 @@ namespace script {
 
 namespace {
 
-#if defined(HANDLE_CORE_DUMP)
-
-class ScriptRunnerLog {
- public:
-  ScriptRunnerLog() : success_count_(0), fail_count_(0) {
-    SbCoreDumpRegisterHandler(CoreDumpHandler, this);
-  }
-  ~ScriptRunnerLog() { SbCoreDumpUnregisterHandler(CoreDumpHandler, this); }
-
-  static void CoreDumpHandler(void* context) {
-    SbCoreDumpLogInteger(
-        "ScriptRunner successful executions",
-        static_cast<ScriptRunnerLog*>(context)->success_count_);
-    SbCoreDumpLogInteger("ScriptRunner failed executions",
-                         static_cast<ScriptRunnerLog*>(context)->fail_count_);
-  }
-
-  void IncrementSuccessCount() { success_count_++; }
-  void IncrementFailCount() { fail_count_++; }
-
- private:
-  int success_count_;
-  int fail_count_;
-  DISALLOW_COPY_AND_ASSIGN(ScriptRunnerLog);
-};
-
-base::LazyInstance<ScriptRunnerLog>::DestructorAtExit script_runner_log =
-    LAZY_INSTANCE_INITIALIZER;
-
-#endif  // defined(HANDLE_CORE_DUMP)
-
 class ScriptRunnerImpl : public ScriptRunner {
  public:
   explicit ScriptRunnerImpl(
@@ -96,14 +60,8 @@ std::string ScriptRunnerImpl::Execute(
   std::string result;
   if (!global_environment_->EvaluateScript(source_code, &result)) {
     LOG(WARNING) << "Failed to execute JavaScript: " << result;
-#if defined(HANDLE_CORE_DUMP)
-    script_runner_log.Get().IncrementFailCount();
-#endif
     return result;
   }
-#if defined(HANDLE_CORE_DUMP)
-  script_runner_log.Get().IncrementSuccessCount();
-#endif
   if (out_succeeded) {
     *out_succeeded = true;
   }