diff --git a/cobalt/base/c_val.cc b/cobalt/base/c_val.cc
index c1f7684..c020671 100644
--- a/cobalt/base/c_val.cc
+++ b/cobalt/base/c_val.cc
@@ -56,7 +56,8 @@
   // CVals cannot share name.  If this assert is triggered, we are trying to
   // register more than one CVal with the same name, which this system is
   // not designed to handle.
-  DCHECK(registered_vars_->find(cval->GetName()) == registered_vars_->end());
+  DCHECK(registered_vars_->find(cval->GetName()) == registered_vars_->end())
+      << " CVal " << cval->GetName() << " Already registered.";
 
   (*registered_vars_)[cval->GetName()] = cval;
   *value_lock = value_lock_refptr_;
diff --git a/cobalt/bindings/v8c/idl_compiler_v8c.py b/cobalt/bindings/v8c/idl_compiler_v8c.py
index 4b0c8bc..09ca3f4 100644
--- a/cobalt/bindings/v8c/idl_compiler_v8c.py
+++ b/cobalt/bindings/v8c/idl_compiler_v8c.py
@@ -17,21 +17,29 @@
 CodeGenerator class.
 """
 
+import logging
 import sys
 
-import _env  # pylint: disable=unused-import
+import _env  #pylint: disable=import-error,unused-import
 from cobalt.bindings.idl_compiler_cobalt import generate_bindings
 from cobalt.bindings.v8c.code_generator_v8c import CodeGeneratorV8c
 
-if __name__ == '__main__':
-  # TODO(b/225964218): The flakiness here should be resolved and retries
-  # removed.
-  # Retry up to 5 times as this can be flaky
+
+def main():
+  # TODO(b/225964218, b/229148609): The flakiness here should be resolved and
+  # retries removed. Retry up to 5 times as this can be flaky.
   latest_error = None
   for i in range(5):
     try:
+      if i > 0:
+        logging.warning('Failed IDL v8 compilation. Retry Attempt #%d', i)
       sys.exit(generate_bindings(CodeGeneratorV8c))
-    except EOFError as e:
+    except Exception as e:  #pylint: disable=broad-except
+      logging.warning('Failed IDL v8 compilation. Cause: %s', str(e))
       latest_error = e
   if latest_error:
     raise latest_error
+
+
+if __name__ == '__main__':
+  main()
diff --git a/cobalt/browser/browser_module.cc b/cobalt/browser/browser_module.cc
index 79dd071..d95d150 100644
--- a/cobalt/browser/browser_module.cc
+++ b/cobalt/browser/browser_module.cc
@@ -684,6 +684,7 @@
   web_module_loaded_.Signal();
 
   options_.persistent_settings->ValidatePersistentSettings();
+  ValidateCacheBackendSettings();
 }
 
 bool BrowserModule::WaitForLoad(const base::TimeDelta& timeout) {
@@ -2087,5 +2088,17 @@
   web_module_->SetDeepLinkTimestamp(timestamp);
 }
 
+void BrowserModule::ValidateCacheBackendSettings() {
+  DCHECK(network_module_);
+  auto url_request_context = network_module_->url_request_context();
+  auto http_cache = url_request_context->http_transaction_factory()->GetCache();
+  if (!http_cache) return;
+  auto cache_backend = static_cast<disk_cache::CobaltBackendImpl*>(
+      http_cache->GetCurrentBackend());
+  if (cache_backend) {
+    cache_backend->ValidatePersistentSettings();
+  }
+}
+
 }  // namespace browser
 }  // namespace cobalt
diff --git a/cobalt/browser/browser_module.h b/cobalt/browser/browser_module.h
index a12551e..b618caa 100644
--- a/cobalt/browser/browser_module.h
+++ b/cobalt/browser/browser_module.h
@@ -473,6 +473,9 @@
   scoped_refptr<script::Wrappable> CreateH5vcc(
       script::EnvironmentSettings* settings);
 
+  // Validates the PersistentSettings for cache backend, if in use.
+  void ValidateCacheBackendSettings();
+
   // TODO:
   //     WeakPtr usage here can be avoided if BrowserModule has a thread to
   //     own where it can ensure that its tasks are all resolved when it is
diff --git a/cobalt/browser/web_module.cc b/cobalt/browser/web_module.cc
index 330de1e..8311b31 100644
--- a/cobalt/browser/web_module.cc
+++ b/cobalt/browser/web_module.cc
@@ -583,7 +583,10 @@
       data.can_play_type_handler, memory_info, &mutation_observer_task_manager_,
       data.options.dom_settings_options));
   DCHECK(web_context_->environment_settings());
-  web_context_->environment_settings()->set_base_url(data.initial_url);
+  // From algorithm to setup up a window environment settings object:
+  //   https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#set-up-a-window-environment-settings-object
+  // 6. Set settings object's creation URL to creationURL.
+  web_context_->environment_settings()->set_creation_url(data.initial_url);
 
   system_caption_settings_ = new cobalt::dom::captions::SystemCaptionSettings(
       web_context_->environment_settings());
@@ -658,11 +661,6 @@
   window_weak_ = base::AsWeakPtr(window_.get());
   DCHECK(window_weak_);
 
-  dom::DOMSettings* dom_settings =
-      base::polymorphic_downcast<dom::DOMSettings*>(
-          web_context_->environment_settings());
-  dom_settings->set_window(window_);
-
   web_context_->global_environment()->CreateGlobalObject(
       window_, web_context_->environment_settings());
   DCHECK(web_context_->GetWindowOrWorkerGlobalScope()->IsWindow());
diff --git a/cobalt/cache/cache.cc b/cobalt/cache/cache.cc
index e2c568d..867db60 100644
--- a/cobalt/cache/cache.cc
+++ b/cobalt/cache/cache.cc
@@ -22,6 +22,7 @@
 #include "base/files/file_util.h"
 #include "base/memory/singleton.h"
 #include "base/optional.h"
+#include "base/values.h"
 #include "cobalt/configuration/configuration.h"
 #include "cobalt/extension/javascript_cache.h"
 #include "cobalt/persistent_storage/persistent_settings.h"
@@ -31,16 +32,6 @@
 
 namespace {
 
-base::Optional<uint32_t> GetMaxCacheStorageInBytes(
-    disk_cache::ResourceType resource_type) {
-  switch (resource_type) {
-    case disk_cache::ResourceType::kCompiledScript:
-      return 5u << 20;  // 5MiB
-    default:
-      return base::nullopt;
-  }
-}
-
 base::Optional<uint32_t> GetMinSizeToCacheInBytes(
     disk_cache::ResourceType resource_type) {
   switch (resource_type) {
@@ -105,6 +96,14 @@
   }
 }
 
+void Cache::DeleteAll() {
+  auto* memory_capped_directory =
+      GetMemoryCappedDirectory(disk_cache::ResourceType::kCompiledScript);
+  if (memory_capped_directory) {
+    memory_capped_directory->DeleteAll();
+  }
+}
+
 std::unique_ptr<std::vector<uint8_t>> Cache::Retrieve(
     disk_cache::ResourceType resource_type, uint32_t key,
     std::function<std::unique_ptr<std::vector<uint8_t>>()> generate) {
@@ -173,6 +172,16 @@
     return it->second.get();
   }
 
+  // Read in size from persistent storage.
+  auto metadata = disk_cache::kTypeMetadata[resource_type];
+  if (persistent_settings_) {
+    uint32_t bucket_size = static_cast<uint32_t>(
+        persistent_settings_->GetPersistentSettingAsDouble(
+            metadata.directory, metadata.max_size_bytes));
+    disk_cache::kTypeMetadata[resource_type] = {metadata.directory,
+                                                bucket_size};
+  }
+
   auto cache_directory = GetCacheDirectory(resource_type);
   auto max_size = GetMaxCacheStorageInBytes(resource_type);
   if (!cache_directory || !max_size) {
@@ -186,6 +195,32 @@
   return memory_capped_directories_[resource_type].get();
 }
 
+void Cache::Resize(disk_cache::ResourceType resource_type, uint32_t bytes) {
+  if (resource_type != disk_cache::ResourceType::kCompiledScript) return;
+  if (bytes == disk_cache::kTypeMetadata[resource_type].max_size_bytes) return;
+
+  if (persistent_settings_) {
+    persistent_settings_->SetPersistentSetting(
+        disk_cache::kTypeMetadata[resource_type].directory,
+        std::make_unique<base::Value>(static_cast<double>(bytes)));
+  }
+  disk_cache::kTypeMetadata[resource_type].max_size_bytes = bytes;
+  auto* memory_capped_directory = GetMemoryCappedDirectory(resource_type);
+  if (memory_capped_directory) {
+    memory_capped_directory->Resize(bytes);
+  }
+}
+
+base::Optional<uint32_t> Cache::GetMaxCacheStorageInBytes(
+    disk_cache::ResourceType resource_type) {
+  switch (resource_type) {
+    case disk_cache::ResourceType::kCompiledScript:
+      return disk_cache::kTypeMetadata[resource_type].max_size_bytes;
+    default:
+      return base::nullopt;
+  }
+}
+
 base::WaitableEvent* Cache::GetWaitableEvent(
     disk_cache::ResourceType resource_type, uint32_t key) {
   base::AutoLock auto_lock(lock_);
diff --git a/cobalt/cache/cache.h b/cobalt/cache/cache.h
index 4f9e4fe..fd106f1 100644
--- a/cobalt/cache/cache.h
+++ b/cobalt/cache/cache.h
@@ -42,9 +42,13 @@
  public:
   static Cache* GetInstance();
   void Delete(disk_cache::ResourceType resource_type, uint32_t key);
+  void DeleteAll();
   std::unique_ptr<std::vector<uint8_t>> Retrieve(
       disk_cache::ResourceType resource_type, uint32_t key,
       std::function<std::unique_ptr<std::vector<uint8_t>>()> generate);
+  void Resize(disk_cache::ResourceType resource_type, uint32_t bytes);
+  base::Optional<uint32_t> GetMaxCacheStorageInBytes(
+      disk_cache::ResourceType resource_type);
 
   void set_enabled(bool enabled);
 
@@ -74,7 +78,7 @@
       pending_;
   bool enabled_;
 
-  persistent_storage::PersistentSettings* persistent_settings_;
+  persistent_storage::PersistentSettings* persistent_settings_ = nullptr;
 
   DISALLOW_COPY_AND_ASSIGN(Cache);
 };  // class Cache
diff --git a/cobalt/cache/memory_capped_directory.cc b/cobalt/cache/memory_capped_directory.cc
index 2ac9cb1..3dc064c 100644
--- a/cobalt/cache/memory_capped_directory.cc
+++ b/cobalt/cache/memory_capped_directory.cc
@@ -91,6 +91,17 @@
   }
 }
 
+void MemoryCappedDirectory::DeleteAll() {
+  base::AutoLock auto_lock(lock_);
+  // Recursively delete the contents of the directory_path_.
+  base::DeleteFile(directory_path_, true);
+  // Re-create the directory_path_ which will now be empty.
+  SbDirectoryCreate(directory_path_.value().c_str());
+  file_info_heap_.clear();
+  file_sizes_.clear();
+  size_ = 0;
+}
+
 std::unique_ptr<std::vector<uint8_t>> MemoryCappedDirectory::Retrieve(
     uint32_t key) {
   auto file_path = GetFilePath(key);
@@ -131,6 +142,14 @@
   file_sizes_[file_path] = new_entry_size;
 }
 
+void MemoryCappedDirectory::Resize(uint32_t size) {
+  if (max_size_ > size) {
+    uint32_t space_to_be_freed = max_size_ - size;
+    EnsureEnoughSpace(space_to_be_freed);
+  }
+  max_size_ = size;
+}
+
 MemoryCappedDirectory::MemoryCappedDirectory(
     const base::FilePath& directory_path, uint32_t max_size)
     : directory_path_(directory_path), max_size_(max_size), size_(0u) {}
diff --git a/cobalt/cache/memory_capped_directory.h b/cobalt/cache/memory_capped_directory.h
index d44681e..941ab19 100644
--- a/cobalt/cache/memory_capped_directory.h
+++ b/cobalt/cache/memory_capped_directory.h
@@ -51,8 +51,10 @@
   static std::unique_ptr<MemoryCappedDirectory> Create(
       const base::FilePath& directory_path, uint32_t max_size);
   void Delete(uint32_t key);
+  void DeleteAll();
   std::unique_ptr<std::vector<uint8_t>> Retrieve(uint32_t key);
   void Store(uint32_t key, const std::vector<uint8_t>& data);
+  void Resize(uint32_t size);
 
  private:
   MemoryCappedDirectory(const base::FilePath& directory_path,
diff --git a/cobalt/dom/dom_settings.cc b/cobalt/dom/dom_settings.cc
index 60a123c..6c9e66d 100644
--- a/cobalt/dom/dom_settings.cc
+++ b/cobalt/dom/dom_settings.cc
@@ -14,9 +14,13 @@
 
 #include "cobalt/dom/dom_settings.h"
 
+#include "base/logging.h"
 #include "cobalt/dom/document.h"
+#include "cobalt/dom/location.h"
 #include "cobalt/dom/window.h"
+#include "cobalt/web/context.h"
 #include "cobalt/web/url_utils.h"
+#include "cobalt/web/window_or_worker_global_scope.h"
 
 namespace cobalt {
 namespace dom {
@@ -38,11 +42,20 @@
 
 DOMSettings::~DOMSettings() {}
 
-void DOMSettings::set_window(const scoped_refptr<Window>& window) {
-  window_ = window;
-  set_base_url(window->document()->url_as_gurl());
+const GURL& DOMSettings::base_url() const {
+  // From algorithm for to setup up a window environment settings object:
+  //   https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#set-up-a-window-environment-settings-object
+  // 3. Let settings object be a new environment settings object whose
+  //    algorithms are defined as follows:
+  //    The API base URL
+  //    Return the current base URL of window's associated Document.
+  return window()->document()->url_as_gurl();
 }
-scoped_refptr<Window> DOMSettings::window() const { return window_; }
+
+scoped_refptr<Window> DOMSettings::window() const {
+  DCHECK(context()->GetWindowOrWorkerGlobalScope()->IsWindow());
+  return context()->GetWindowOrWorkerGlobalScope()->AsWindow();
+}
 
 loader::Origin DOMSettings::document_origin() const {
   return window()->document()->location()->GetOriginAsObject();
diff --git a/cobalt/dom/dom_settings.h b/cobalt/dom/dom_settings.h
index 0c81c39..8eb437a 100644
--- a/cobalt/dom/dom_settings.h
+++ b/cobalt/dom/dom_settings.h
@@ -66,7 +66,6 @@
     return microphone_options_;
   }
 
-  void set_window(const scoped_refptr<Window>& window);
   scoped_refptr<Window> window() const;
 
   MediaSourceRegistry* media_source_registry() const {
@@ -89,10 +88,13 @@
   // Return's document's origin.
   loader::Origin document_origin() const;
 
+  // From: script::EnvironmentSettings
+  //
+  const GURL& base_url() const override;
+
  private:
   const int max_dom_element_depth_;
   const speech::Microphone::Options microphone_options_;
-  scoped_refptr<Window> window_;
   MediaSourceRegistry* media_source_registry_;
   media::CanPlayTypeHandler* can_play_type_handler_;
   const media::DecoderBufferMemoryInfo* decoder_buffer_memory_info_;
diff --git a/cobalt/dom/global_stats.cc b/cobalt/dom/global_stats.cc
index eccae4c..66acba6 100644
--- a/cobalt/dom/global_stats.cc
+++ b/cobalt/dom/global_stats.cc
@@ -47,6 +47,13 @@
 GlobalStats::~GlobalStats() {}
 
 bool GlobalStats::CheckNoLeaks() {
+  DCHECK(num_attrs_ == 0);
+  DCHECK(num_dom_string_maps_ == 0);
+  DCHECK(num_dom_token_lists_ == 0);
+  DCHECK(num_html_collections_ == 0);
+  DCHECK(num_named_node_maps_ == 0);
+  DCHECK(num_nodes_ == 0);
+  DCHECK(num_node_lists_ == 0);
   return web::GlobalStats::GetInstance()->CheckNoLeaks() &&
          xhr::GlobalStats::GetInstance()->CheckNoLeaks() && num_attrs_ == 0 &&
          num_dom_string_maps_ == 0 && num_dom_token_lists_ == 0 &&
diff --git a/cobalt/dom/html_media_element.cc b/cobalt/dom/html_media_element.cc
index 91bb221..099559b 100644
--- a/cobalt/dom/html_media_element.cc
+++ b/cobalt/dom/html_media_element.cc
@@ -632,7 +632,8 @@
 }
 
 void HTMLMediaElement::ScheduleEvent(const scoped_refptr<web::Event>& event) {
-  TRACE_EVENT0("cobalt::dom", "HTMLMediaElement::ScheduleEvent()");
+  TRACE_EVENT1("cobalt::dom", "HTMLMediaElement::ScheduleEvent()", "event",
+               TRACE_STR_COPY(event->type().c_str()));
   MLOG() << "Schedule event " << event->type() << ".";
   event_queue_.Enqueue(event);
 }
diff --git a/cobalt/dom/local_storage_database.h b/cobalt/dom/local_storage_database.h
index 4541001..ea8dfd3 100644
--- a/cobalt/dom/local_storage_database.h
+++ b/cobalt/dom/local_storage_database.h
@@ -35,7 +35,7 @@
   typedef base::Callback<void(std::unique_ptr<StorageArea::StorageMap>)>
       ReadCompletionCallback;
 
-  explicit LocalStorageDatabase(storage::StorageManager* storage);
+  explicit LocalStorageDatabase(storage::StorageManager* storage = nullptr);
 
   // Load the LocalStorage from the Storage Manager, and extract
   // all key/values for the given origin. Calls callback and transfers ownership
diff --git a/cobalt/dom/on_screen_keyboard_test.cc b/cobalt/dom/on_screen_keyboard_test.cc
index 8a7131f..4ab1e6f 100644
--- a/cobalt/dom/on_screen_keyboard_test.cc
+++ b/cobalt/dom/on_screen_keyboard_test.cc
@@ -172,8 +172,8 @@
  public:
   OnScreenKeyboardTest()
       : on_screen_keyboard_bridge_(new OnScreenKeyboardMockBridge()) {
-    set_stub_window(new testing::StubWindow(DOMSettings::Options(),
-                                            on_screen_keyboard_bridge_.get()));
+    stub_window()->set_on_screen_keyboard_bridge(
+        on_screen_keyboard_bridge_.get());
     on_screen_keyboard_bridge_->window_ = window();
   }
 
diff --git a/cobalt/dom/testing/BUILD.gn b/cobalt/dom/testing/BUILD.gn
index 01add77..49453ae 100644
--- a/cobalt/dom/testing/BUILD.gn
+++ b/cobalt/dom/testing/BUILD.gn
@@ -37,6 +37,7 @@
     "//cobalt/dom",
     "//cobalt/dom_parser",
     "//cobalt/loader",
+    "//cobalt/network",
     "//cobalt/script",
     "//cobalt/web",
     "//cobalt/web:dom_exception",
diff --git a/cobalt/dom/testing/stub_window.h b/cobalt/dom/testing/stub_window.h
index fa17f5c..6651633 100644
--- a/cobalt/dom/testing/stub_window.h
+++ b/cobalt/dom/testing/stub_window.h
@@ -31,8 +31,8 @@
 #include "cobalt/dom/testing/stub_environment_settings.h"
 #include "cobalt/dom/window.h"
 #include "cobalt/dom_parser/parser.h"
-#include "cobalt/loader/fetcher_factory.h"
 #include "cobalt/loader/loader_factory.h"
+#include "cobalt/network/network_module.h"
 #include "cobalt/script/global_environment.h"
 #include "cobalt/script/javascript_engine.h"
 #include "cobalt/web/context.h"
@@ -49,42 +49,85 @@
 // stubbed out.
 class StubWindow {
  public:
-  explicit StubWindow(
-      const DOMSettings::Options& options = DOMSettings::Options(),
-      OnScreenKeyboardBridge* on_screen_keyboard_bridge = nullptr,
-      web::testing::StubWebContext* stub_web_context =
-          new web::testing::StubWebContext())
-      : css_parser_(css_parser::Parser::Create()),
-        dom_parser_(
-            new dom_parser::Parser(base::Bind(&StubLoadCompleteCallback))),
-        local_storage_database_(NULL),
-        dom_stat_tracker_(new dom::DomStatTracker("StubWindow")) {
-    web_context_.reset(stub_web_context);
-    web_context_->setup_environment_settings(
-        new dom::testing::StubEnvironmentSettings(options));
-    web_context_->environment_settings()->set_base_url(GURL("about:blank"));
-    web_context_->set_fetcher_factory(new loader::FetcherFactory(NULL));
+  StubWindow() {}
+  virtual ~StubWindow() {
+    if (window_) {
+      global_environment()->SetReportEvalCallback(base::Closure());
+      global_environment()->SetReportErrorCallback(
+          script::GlobalEnvironment::ReportErrorCallback());
+      window_->DispatchEvent(new web::Event(base::Tokens::unload()));
+      window_->DestroyTimers();
+      window_.reset();
+    }
+  }
+
+  void set_options(const DOMSettings::Options& options) { options_ = options; }
+
+  web::testing::StubWebContext* web_context() {
+    if (!web_context_) InitializeWebContext();
+    return web_context_.get();
+  }
+
+  scoped_refptr<dom::Window> window() {
+    if (!window_) InitializeWindow();
+    return window_;
+  }
+  scoped_refptr<script::GlobalEnvironment> global_environment() {
+    // The Window has to be set as the global object for the global environment
+    // to be valid.
+    if (!window_) InitializeWindow();
+    return web_context()->global_environment();
+  }
+  css_parser::Parser* css_parser() { return css_parser_.get(); }
+  web::EnvironmentSettings* environment_settings() {
+    // The Window has to be set as the global object for the environment
+    // settings object to be valid.
+    if (!window_) InitializeWindow();
+    return web_context()->environment_settings();
+  }
+
+  void set_on_screen_keyboard_bridge(
+      OnScreenKeyboardBridge* on_screen_keyboard_bridge) {
+    on_screen_keyboard_bridge_ = on_screen_keyboard_bridge;
+  }
+
+ private:
+  static void StubLoadCompleteCallback(
+      const base::Optional<std::string>& error) {}
+
+  void InitializeWebContext() {
+    web_context_.reset(new web::testing::StubWebContext());
+    web_context()->setup_environment_settings(
+        new dom::testing::StubEnvironmentSettings(options_));
+    web_context()->environment_settings()->set_creation_url(
+        GURL("about:blank"));
+  }
+
+  void InitializeWindow() {
     loader_factory_.reset(new loader::LoaderFactory(
-        "Test", web_context_->fetcher_factory(), NULL,
-        web_context_->environment_settings()->debugger_hooks(), 0,
+        "Test", web_context()->fetcher_factory(), NULL,
+        web_context()->environment_settings()->debugger_hooks(), 0,
         base::ThreadPriority::DEFAULT));
     system_caption_settings_ = new cobalt::dom::captions::SystemCaptionSettings(
-        web_context_->environment_settings());
-
+        web_context()->environment_settings());
+    css_parser_.reset(css_parser::Parser::Create().release());
+    dom_parser_.reset(
+        new dom_parser::Parser(base::Bind(&StubLoadCompleteCallback)));
+    dom_stat_tracker_.reset(new dom::DomStatTracker("StubWindow"));
     window_ = new dom::Window(
-        web_context_->environment_settings(), cssom::ViewportSize(1920, 1080),
+        web_context()->environment_settings(), cssom::ViewportSize(1920, 1080),
         base::kApplicationStateStarted, css_parser_.get(), dom_parser_.get(),
-        web_context_->fetcher_factory(), loader_factory_.get(), nullptr,
+        web_context()->fetcher_factory(), loader_factory_.get(), nullptr,
         nullptr, nullptr, nullptr, nullptr, nullptr, &local_storage_database_,
         nullptr, nullptr, nullptr, nullptr,
-        global_environment()->script_value_factory(), nullptr,
+        web_context()->global_environment()->script_value_factory(), nullptr,
         dom_stat_tracker_.get(), "en", base::Callback<void(const GURL&)>(),
         base::Bind(&StubLoadCompleteCallback), nullptr,
-        network_bridge::PostSender(), csp::kCSPRequired,
+        network_bridge::PostSender(), csp::kCSPOptional,
         web::kCspEnforcementEnable, base::Closure() /* csp_policy_changed */,
         base::Closure() /* ran_animation_frame_callbacks */,
         dom::Window::CloseCallback() /* window_close */,
-        base::Closure() /* window_minimize */, on_screen_keyboard_bridge,
+        base::Closure() /* window_minimize */, on_screen_keyboard_bridge_,
         nullptr /* camera_3d */, dom::Window::OnStartDispatchEventCallback(),
         dom::Window::OnStopDispatchEventCallback(),
         dom::ScreenshotManager::ProvideScreenshotFunctionCallback(),
@@ -96,28 +139,12 @@
         dom::Window::CacheCallback() /* splash_screen_cache_callback */,
         system_caption_settings_ /* captions */
         );
-    base::polymorphic_downcast<dom::DOMSettings*>(
-        web_context_->environment_settings())
-        ->set_window(window_);
     global_environment()->CreateGlobalObject(
-        window_, web_context_->environment_settings());
-  }
-  virtual ~StubWindow() { window_->DestroyTimers(); }
-
-  web::testing::StubWebContext* web_context() { return web_context_.get(); }
-  scoped_refptr<dom::Window> window() { return window_; }
-  scoped_refptr<script::GlobalEnvironment> global_environment() {
-    return web_context_->global_environment();
-  }
-  css_parser::Parser* css_parser() { return css_parser_.get(); }
-  web::EnvironmentSettings* environment_settings() {
-    return web_context_->environment_settings();
+        window_, web_context()->environment_settings());
   }
 
- private:
-  static void StubLoadCompleteCallback(
-      const base::Optional<std::string>& error) {}
-
+  OnScreenKeyboardBridge* on_screen_keyboard_bridge_ = nullptr;
+  DOMSettings::Options options_;
   std::unique_ptr<css_parser::Parser> css_parser_;
   std::unique_ptr<dom_parser::Parser> dom_parser_;
   std::unique_ptr<loader::LoaderFactory> loader_factory_;
diff --git a/cobalt/dom/testing/test_with_javascript.h b/cobalt/dom/testing/test_with_javascript.h
index f7a281d..58df232 100644
--- a/cobalt/dom/testing/test_with_javascript.h
+++ b/cobalt/dom/testing/test_with_javascript.h
@@ -36,40 +36,28 @@
 // Helper class for running tests in a Window JavaScript context.
 class TestWithJavaScript : public ::testing::Test {
  public:
-  TestWithJavaScript() {}
+  TestWithJavaScript() { stub_window_.reset(new StubWindow()); }
   ~TestWithJavaScript() {
-    if (stub_window_) {
-      stub_window_->global_environment()->SetReportEvalCallback(
-          base::Closure());
-      stub_window_->global_environment()->SetReportErrorCallback(
-          script::GlobalEnvironment::ReportErrorCallback());
-      DCHECK(window());
-      window()->DispatchEvent(new web::Event(base::Tokens::unload()));
-      stub_window_.reset();
-    }
+    stub_window_.reset();
     EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
   }
 
-  void set_stub_window(StubWindow* stub_window) {
-    stub_window_.reset(stub_window);
+  StubWindow* stub_window() { return stub_window_.get(); }
+  web::testing::StubWebContext* stub_web_context() {
+    return stub_window_->web_context();
   }
 
-  Window* window() {
-    if (!stub_window_) stub_window_.reset(new StubWindow());
-    return stub_window_->window().get();
-  }
+  Window* window() { return stub_window_->window().get(); }
 
   bool EvaluateScript(const std::string& js_code, std::string* result) {
-    if (!stub_window_) stub_window_.reset(new StubWindow());
-    DCHECK(stub_window_->global_environment());
+    DCHECK(global_environment());
     scoped_refptr<script::SourceCode> source_code =
         script::SourceCode::CreateSourceCode(
             js_code, base::SourceLocation(__FILE__, __LINE__, 1));
 
-    stub_window_->global_environment()->EnableEval();
-    stub_window_->global_environment()->SetReportEvalCallback(base::Closure());
-    bool succeeded =
-        stub_window_->global_environment()->EvaluateScript(source_code, result);
+    global_environment()->EnableEval();
+    global_environment()->SetReportEvalCallback(base::Closure());
+    bool succeeded = global_environment()->EvaluateScript(source_code, result);
     return succeeded;
   }
 
diff --git a/cobalt/dom/user_agent_data_test.cc b/cobalt/dom/user_agent_data_test.cc
index 2fd56e4..dc3c350 100644
--- a/cobalt/dom/user_agent_data_test.cc
+++ b/cobalt/dom/user_agent_data_test.cc
@@ -36,13 +36,7 @@
   UserAgentDataTest() {
     InitializeEmptyPlatformInfo();
 
-    web::testing::StubWebContext* stub_web_context =
-        new web::testing::StubWebContext();
-    stub_web_context->set_platform_info(platform_info_.get());
-    testing::StubWindow* stub_window = new testing::StubWindow(
-        DOMSettings::Options(), nullptr /* on_screen_keyboard_bridge */,
-        stub_web_context);
-    set_stub_window(stub_window);
+    stub_web_context()->set_platform_info(platform_info_.get());
 
     // Inject H5vcc interface to make it also accessible via Window
     h5vcc::H5vcc::Settings h5vcc_settings;
diff --git a/cobalt/dom_parser/html_decoder_test.cc b/cobalt/dom_parser/html_decoder_test.cc
index 78dd0da..e92f571 100644
--- a/cobalt/dom_parser/html_decoder_test.cc
+++ b/cobalt/dom_parser/html_decoder_test.cc
@@ -71,8 +71,7 @@
 };
 
 HTMLDecoderTest::HTMLDecoderTest()
-    : fetcher_factory_(NULL /* network_module */),
-      loader_factory_("Test" /* name */, &fetcher_factory_,
+    : loader_factory_("Test" /* name */, &fetcher_factory_,
                       NULL /* ResourceProvider */, null_debugger_hooks_,
                       0 /* encoded_image_cache_capacity */,
                       base::ThreadPriority::DEFAULT),
diff --git a/cobalt/h5vcc/h5vcc_crash_log.idl b/cobalt/h5vcc/h5vcc_crash_log.idl
index f551cd7..45f6df3 100644
--- a/cobalt/h5vcc/h5vcc_crash_log.idl
+++ b/cobalt/h5vcc/h5vcc_crash_log.idl
@@ -32,15 +32,15 @@
   // Returns true if Watchdog client was registered.
   //   name, Watchdog client to register.
   //   description, information on the Watchdog client.
-  //   monitor_state, application state to continue monitoring client up to.
+  //   watchdog_state, application state to continue monitoring client up to.
   //     Inclusive.
   //   time_interval, maximum number of microseconds allowed between pings
-  //     before triggering a Watchdog violation.
+  //     before triggering a Watchdog violation. Min value of 1000000.
   //   time_wait, number of microseconds to initially wait before Watchdog
   //     violations can be triggered. Reapplies after client resumes from idle
   //     state due to application state changes.
-  //   replace, behavior with previously registered Watchdog clients of the
-  //     same name.
+  //   watchdog_replace, behavior with previously registered Watchdog clients
+  //     of the same name.
   boolean register(DOMString name, DOMString description,
                    WatchdogState watchdog_state, long long time_interval,
                    long long time_wait, WatchdogReplace watchdog_replace);
@@ -51,7 +51,7 @@
 
   // Returns true if Watchdog client was pinged. Name determines the Watchdog
   // client to ping with ping_info which can either be empty or contain relevant
-  // metadata.
+  // metadata. ping_info has a max length of 1024.
   boolean ping(DOMString name, DOMString ping_info);
 
   // Returns a json string containing the Watchdog violations since the last
diff --git a/cobalt/h5vcc/h5vcc_storage.cc b/cobalt/h5vcc/h5vcc_storage.cc
index dbb6b3b..b5c3af0 100644
--- a/cobalt/h5vcc/h5vcc_storage.cc
+++ b/cobalt/h5vcc/h5vcc_storage.cc
@@ -15,6 +15,7 @@
 #include <algorithm>
 #include <memory>
 #include <string>
+#include <utility>
 #include <vector>
 
 #include "base/files/file_util.h"
@@ -23,6 +24,7 @@
 #include "cobalt/h5vcc/h5vcc_storage.h"
 #include "cobalt/persistent_storage/persistent_settings.h"
 #include "cobalt/storage/storage_manager.h"
+#include "net/base/completion_once_callback.h"
 #include "net/disk_cache/cobalt/cobalt_backend_impl.h"
 #include "net/disk_cache/cobalt/resource_type.h"
 #include "net/http/http_cache.h"
@@ -68,6 +70,10 @@
   return response;
 }
 
+void ClearCacheHelper(disk_cache::Backend* backend) {
+  backend->DoomAllEntries(base::DoNothing());
+}
+
 }  // namespace
 
 H5vccStorage::H5vccStorage(
@@ -76,6 +82,7 @@
     : network_module_(network_module),
       persistent_settings_(persistent_settings) {
   http_cache_ = nullptr;
+  cache_backend_ = nullptr;
   if (network_module == nullptr) {
     return;
   }
@@ -254,87 +261,55 @@
         quota_total, max_quota_size));
   }
 
-  // Write to persistent storage with the new quota values.
-  // Static cast value to double since base::Value cannot be a long.
-  persistent_settings_->SetPersistentSetting(
-      disk_cache::kTypeMetadata[disk_cache::kOther].directory,
-      std::make_unique<base::Value>(static_cast<double>(quota.other())));
-  persistent_settings_->SetPersistentSetting(
-      disk_cache::kTypeMetadata[disk_cache::kHTML].directory,
-      std::make_unique<base::Value>(static_cast<double>(quota.html())));
-  persistent_settings_->SetPersistentSetting(
-      disk_cache::kTypeMetadata[disk_cache::kCSS].directory,
-      std::make_unique<base::Value>(static_cast<double>(quota.css())));
-  persistent_settings_->SetPersistentSetting(
-      disk_cache::kTypeMetadata[disk_cache::kImage].directory,
-      std::make_unique<base::Value>(static_cast<double>(quota.image())));
-  persistent_settings_->SetPersistentSetting(
-      disk_cache::kTypeMetadata[disk_cache::kFont].directory,
-      std::make_unique<base::Value>(static_cast<double>(quota.font())));
-  persistent_settings_->SetPersistentSetting(
-      disk_cache::kTypeMetadata[disk_cache::kSplashScreen].directory,
-      std::make_unique<base::Value>(static_cast<double>(quota.splash())));
-  persistent_settings_->SetPersistentSetting(
-      disk_cache::kTypeMetadata[disk_cache::kUncompiledScript].directory,
-      std::make_unique<base::Value>(
-          static_cast<double>(quota.uncompiled_js())));
-  persistent_settings_->SetPersistentSetting(
-      disk_cache::kTypeMetadata[disk_cache::kCompiledScript].directory,
-      std::make_unique<base::Value>(static_cast<double>(quota.compiled_js())));
+  ValidatedCacheBackend();
 
+  // Write to persistent storage with the new quota values.
+  SetAndSaveQuotaForBackend(disk_cache::kOther,
+                            static_cast<uint32_t>(quota.other()));
+  SetAndSaveQuotaForBackend(disk_cache::kHTML,
+                            static_cast<uint32_t>(quota.html()));
+  SetAndSaveQuotaForBackend(disk_cache::kCSS,
+                            static_cast<uint32_t>(quota.css()));
+  SetAndSaveQuotaForBackend(disk_cache::kImage,
+                            static_cast<uint32_t>(quota.image()));
+  SetAndSaveQuotaForBackend(disk_cache::kFont,
+                            static_cast<uint32_t>(quota.font()));
+  SetAndSaveQuotaForBackend(disk_cache::kSplashScreen,
+                            static_cast<uint32_t>(quota.splash()));
+  SetAndSaveQuotaForBackend(disk_cache::kUncompiledScript,
+                            static_cast<uint32_t>(quota.uncompiled_js()));
+  SetAndSaveQuotaForBackend(disk_cache::kCompiledScript,
+                            static_cast<uint32_t>(quota.compiled_js()));
   return SetQuotaResponse("", true);
 }
 
+void H5vccStorage::SetAndSaveQuotaForBackend(disk_cache::ResourceType type,
+                                             uint32_t bytes) {
+  if (cache_backend_) {
+    cache_backend_->UpdateSizes(type, bytes);
+  }
+  cobalt::cache::Cache::GetInstance()->Resize(type, bytes);
+}
+
 H5vccStorageResourceTypeQuotaBytesDictionary H5vccStorage::GetQuota() {
   // Return persistent storage quota values.
   H5vccStorageResourceTypeQuotaBytesDictionary quota;
+  if (!ValidatedCacheBackend()) {
+    return quota;
+  }
 
-  auto other_meta_data = disk_cache::kTypeMetadata[disk_cache::kOther];
-  quota.set_other(
-      static_cast<uint32>(persistent_settings_->GetPersistentSettingAsDouble(
-          other_meta_data.directory,
-          other_meta_data.max_size_mb * 1024 * 1024)));
-
-  auto html_meta_data = disk_cache::kTypeMetadata[disk_cache::kHTML];
-  quota.set_html(
-      static_cast<uint32>(persistent_settings_->GetPersistentSettingAsDouble(
-          html_meta_data.directory, html_meta_data.max_size_mb * 1024 * 1024)));
-
-  auto css_meta_data = disk_cache::kTypeMetadata[disk_cache::kCSS];
-  quota.set_css(
-      static_cast<uint32>(persistent_settings_->GetPersistentSettingAsDouble(
-          css_meta_data.directory, css_meta_data.max_size_mb * 1024 * 1024)));
-
-  auto image_meta_data = disk_cache::kTypeMetadata[disk_cache::kImage];
-  quota.set_image(
-      static_cast<uint32>(persistent_settings_->GetPersistentSettingAsDouble(
-          image_meta_data.directory,
-          image_meta_data.max_size_mb * 1024 * 1024)));
-
-  auto font_meta_data = disk_cache::kTypeMetadata[disk_cache::kFont];
-  quota.set_font(
-      static_cast<uint32>(persistent_settings_->GetPersistentSettingAsDouble(
-          font_meta_data.directory, font_meta_data.max_size_mb * 1024 * 1024)));
-
-  auto splash_meta_data = disk_cache::kTypeMetadata[disk_cache::kSplashScreen];
-  quota.set_splash(
-      static_cast<uint32>(persistent_settings_->GetPersistentSettingAsDouble(
-          splash_meta_data.directory,
-          splash_meta_data.max_size_mb * 1024 * 1024)));
-
-  auto uncompiled_meta_data =
-      disk_cache::kTypeMetadata[disk_cache::kUncompiledScript];
+  quota.set_other(cache_backend_->GetQuota(disk_cache::kOther));
+  quota.set_html(cache_backend_->GetQuota(disk_cache::kHTML));
+  quota.set_css(cache_backend_->GetQuota(disk_cache::kCSS));
+  quota.set_image(cache_backend_->GetQuota(disk_cache::kImage));
+  quota.set_font(cache_backend_->GetQuota(disk_cache::kFont));
+  quota.set_splash(cache_backend_->GetQuota(disk_cache::kSplashScreen));
   quota.set_uncompiled_js(
-      static_cast<uint32>(persistent_settings_->GetPersistentSettingAsDouble(
-          uncompiled_meta_data.directory,
-          uncompiled_meta_data.max_size_mb * 1024 * 1024)));
-
-  auto compiled_meta_data =
-      disk_cache::kTypeMetadata[disk_cache::kCompiledScript];
+      cache_backend_->GetQuota(disk_cache::kUncompiledScript));
   quota.set_compiled_js(
-      static_cast<uint32>(persistent_settings_->GetPersistentSettingAsDouble(
-          compiled_meta_data.directory,
-          compiled_meta_data.max_size_mb * 1024 * 1024)));
+      cobalt::cache::Cache::GetInstance()
+          ->GetMaxCacheStorageInBytes(disk_cache::kCompiledScript)
+          .value());
 
   // TODO(b/235529738): Calculate correct max_quota_size that subtracts
   // non-cache memory used in the kSbSystemPathCacheDirectory.
@@ -372,5 +347,26 @@
   }
 }
 
+void H5vccStorage::ClearCache() {
+  if (ValidatedCacheBackend()) {
+    network_module_->task_runner()->PostTask(
+        FROM_HERE,
+        base::Bind(&ClearCacheHelper, base::Unretained(cache_backend_)));
+  }
+  cobalt::cache::Cache::GetInstance()->DeleteAll();
+}
+
+bool H5vccStorage::ValidatedCacheBackend() {
+  if (!http_cache_) {
+    return false;
+  }
+  if (cache_backend_) {
+    return true;
+  }
+  cache_backend_ = static_cast<disk_cache::CobaltBackendImpl*>(
+      http_cache_->GetCurrentBackend());
+  return cache_backend_ != nullptr;
+}
+
 }  // namespace h5vcc
 }  // namespace cobalt
diff --git a/cobalt/h5vcc/h5vcc_storage.h b/cobalt/h5vcc/h5vcc_storage.h
index ff96351..54b06c8 100644
--- a/cobalt/h5vcc/h5vcc_storage.h
+++ b/cobalt/h5vcc/h5vcc_storage.h
@@ -26,6 +26,8 @@
 #include "cobalt/network/network_module.h"
 #include "cobalt/persistent_storage/persistent_settings.h"
 #include "cobalt/script/wrappable.h"
+#include "net/disk_cache/cobalt/cobalt_backend_impl.h"
+#include "net/disk_cache/cobalt/resource_type.h"
 #include "net/http/http_cache.h"
 
 namespace cobalt {
@@ -56,11 +58,14 @@
   // Set Quota bytes per disk_cache::ResourceType.
   H5vccStorageSetQuotaResponse SetQuota(
       H5vccStorageResourceTypeQuotaBytesDictionary quota);
+  void SetAndSaveQuotaForBackend(disk_cache::ResourceType type, uint32_t bytes);
 
   void EnableCache();
 
   void DisableCache();
 
+  void ClearCache();
+
   DEFINE_WRAPPABLE_TYPE(H5vccStorage);
 
  private:
@@ -69,6 +74,9 @@
   persistent_storage::PersistentSettings* persistent_settings_;
 
   net::HttpCache* http_cache_;
+  disk_cache::CobaltBackendImpl* cache_backend_;
+
+  bool ValidatedCacheBackend();
 
   DISALLOW_COPY_AND_ASSIGN(H5vccStorage);
 };
diff --git a/cobalt/h5vcc/h5vcc_storage.idl b/cobalt/h5vcc/h5vcc_storage.idl
index 93a6d37..f1a15d2 100644
--- a/cobalt/h5vcc/h5vcc_storage.idl
+++ b/cobalt/h5vcc/h5vcc_storage.idl
@@ -27,4 +27,6 @@
 
   void enableCache();
   void disableCache();
+
+  void clearCache();
 };
diff --git a/cobalt/loader/fetcher_factory.cc b/cobalt/loader/fetcher_factory.cc
index bded32c..ce60177 100644
--- a/cobalt/loader/fetcher_factory.cc
+++ b/cobalt/loader/fetcher_factory.cc
@@ -64,20 +64,12 @@
 }  // namespace
 
 FetcherFactory::FetcherFactory(network::NetworkModule* network_module)
-    : file_thread_("File"),
-      network_module_(network_module),
-      read_cache_callback_() {
-  file_thread_.Start();
-}
+    : network_module_(network_module) {}
 
-FetcherFactory::FetcherFactory(network::NetworkModule* network_module,
-                               const base::FilePath& extra_search_dir)
-    : file_thread_("File"),
-      network_module_(network_module),
-      extra_search_dir_(extra_search_dir),
-      read_cache_callback_() {
-  file_thread_.Start();
-}
+FetcherFactory::FetcherFactory(
+    network::NetworkModule* network_module,
+    const BlobFetcher::ResolverCallback& blob_resolver)
+    : network_module_(network_module), blob_resolver_(blob_resolver) {}
 
 FetcherFactory::FetcherFactory(
     network::NetworkModule* network_module,
@@ -85,13 +77,10 @@
     const BlobFetcher::ResolverCallback& blob_resolver,
     const base::Callback<int(const std::string&, std::unique_ptr<char[]>*)>&
         read_cache_callback)
-    : file_thread_("File"),
-      network_module_(network_module),
+    : network_module_(network_module),
       extra_search_dir_(extra_search_dir),
       blob_resolver_(blob_resolver),
-      read_cache_callback_(read_cache_callback) {
-  file_thread_.Start();
-}
+      read_cache_callback_(read_cache_callback) {}
 
 std::unique_ptr<Fetcher> FetcherFactory::CreateFetcher(
     const GURL& url, const disk_cache::ResourceType type,
@@ -150,6 +139,9 @@
     }
 
     FileFetcher::Options options;
+    if (!file_thread_.IsRunning()) {
+      file_thread_.Start();
+    }
     options.message_loop_proxy = file_thread_.task_runner();
     options.extra_search_dir = extra_search_dir_;
     return std::unique_ptr<Fetcher>(
diff --git a/cobalt/loader/fetcher_factory.h b/cobalt/loader/fetcher_factory.h
index 2630031..4638e10 100644
--- a/cobalt/loader/fetcher_factory.h
+++ b/cobalt/loader/fetcher_factory.h
@@ -36,9 +36,10 @@
 
 class FetcherFactory {
  public:
+  FetcherFactory() {}
   explicit FetcherFactory(network::NetworkModule* network_module);
   FetcherFactory(network::NetworkModule* network_module,
-                 const base::FilePath& extra_search_dir);
+                 const BlobFetcher::ResolverCallback& blob_resolver);
   FetcherFactory(
       network::NetworkModule* network_module,
       const base::FilePath& extra_search_dir,
@@ -60,8 +61,8 @@
   network::NetworkModule* network_module() const { return network_module_; }
 
  private:
-  base::Thread file_thread_;
-  network::NetworkModule* network_module_;
+  base::Thread file_thread_{"File"};
+  network::NetworkModule* network_module_ = nullptr;
   base::FilePath extra_search_dir_;
   BlobFetcher::ResolverCallback blob_resolver_;
   base::Callback<int(const std::string&, std::unique_ptr<char[]>*)>
diff --git a/cobalt/loader/fetcher_factory_test.cc b/cobalt/loader/fetcher_factory_test.cc
index ac16d44..9767e69 100644
--- a/cobalt/loader/fetcher_factory_test.cc
+++ b/cobalt/loader/fetcher_factory_test.cc
@@ -27,8 +27,7 @@
 
 class StubFetcherHandler : public Fetcher::Handler {
  public:
-  explicit StubFetcherHandler(base::RunLoop* run_loop)
-      : run_loop_(run_loop), fetcher_(NULL) {}
+  explicit StubFetcherHandler(base::RunLoop* run_loop) : run_loop_(run_loop) {}
 
   // From Fetcher::Handler.
   void OnReceived(Fetcher* fetcher, const char* data, size_t size) override {
@@ -55,7 +54,7 @@
  private:
   void CheckSameFetcher(Fetcher* fetcher) {
     EXPECT_TRUE(fetcher);
-    if (fetcher_ == NULL) {
+    if (fetcher_ == nullptr) {
       fetcher_ = fetcher;
       return;
     }
@@ -63,7 +62,7 @@
   }
 
   base::RunLoop* run_loop_;
-  Fetcher* fetcher_;
+  Fetcher* fetcher_ = nullptr;
   base::Optional<std::string> error_message_;
 };
 
@@ -71,9 +70,7 @@
 
 class FetcherFactoryTest : public ::testing::Test {
  protected:
-  FetcherFactoryTest()
-      : message_loop_(base::MessageLoop::TYPE_DEFAULT),
-        fetcher_factory_(NULL) {}
+  FetcherFactoryTest() : message_loop_(base::MessageLoop::TYPE_DEFAULT) {}
   ~FetcherFactoryTest() override {}
 
   base::MessageLoop message_loop_;
diff --git a/cobalt/media/base/sbplayer_pipeline.cc b/cobalt/media/base/sbplayer_pipeline.cc
index b9c8f65..d64ce70 100644
--- a/cobalt/media/base/sbplayer_pipeline.cc
+++ b/cobalt/media/base/sbplayer_pipeline.cc
@@ -1484,12 +1484,10 @@
       LOG(INFO) << "SbPlayerPipeline::ResumeTask failed to create a valid "
                    "StarboardPlayer - "
                 << time_information << " \'" << error_message << "\'";
-      // TODO: Determine if CallSeekCB() may be used here, as |seek_cb_| may be
-      // available if the app is suspended before a seek is completed.
-      CallSeekCB(::media::DECODER_ERROR_NOT_SUPPORTED,
-                 "SbPlayerPipeline::ResumeTask failed to create a valid "
-                 "StarboardPlayer - " +
-                     time_information + " \'" + error_message + "\'");
+      CallErrorCB(::media::DECODER_ERROR_NOT_SUPPORTED,
+                  "SbPlayerPipeline::ResumeTask failed to create a valid "
+                  "StarboardPlayer - " +
+                      time_information + " \'" + error_message + "\'");
       done_event->Signal();
       return;
     }
diff --git a/cobalt/media_capture/get_user_media_test.cc b/cobalt/media_capture/get_user_media_test.cc
index fee9ad3..768b26a 100644
--- a/cobalt/media_capture/get_user_media_test.cc
+++ b/cobalt/media_capture/get_user_media_test.cc
@@ -29,12 +29,12 @@
 class GetUserMediaTest : public ::testing::Test {
  protected:
   GetUserMediaTest() {
-    cobalt::dom::DOMSettings::Options options;
+    window_.reset(new dom::testing::StubWindow());
 #if defined(ENABLE_FAKE_MICROPHONE)
+    cobalt::dom::DOMSettings::Options options;
     options.microphone_options.enable_fake_microphone = true;
+    window_->set_options();
 #endif  // defined(ENABLE_FAKE_MICROPHONE)
-
-    window_.reset(new dom::testing::StubWindow(options));
     media_devices_ =
         new MediaDevices(window_->environment_settings(),
                          window_->global_environment()->script_value_factory());
diff --git a/cobalt/renderer/pipeline.cc b/cobalt/renderer/pipeline.cc
index 6198549..98a2eab 100644
--- a/cobalt/renderer/pipeline.cc
+++ b/cobalt/renderer/pipeline.cc
@@ -337,9 +337,9 @@
   // Registers Pipeline as a watchdog client.
   watchdog::Watchdog* watchdog = watchdog::Watchdog::GetInstance();
   if (watchdog)
-    watchdog->Register(kWatchdogName, base::kApplicationStateStarted,
-                       kWatchdogTimeInterval, kWatchdogTimeWait,
-                       watchdog::PING);
+    watchdog->Register(kWatchdogName, kWatchdogName,
+                       base::kApplicationStateStarted, kWatchdogTimeInterval,
+                       kWatchdogTimeWait, watchdog::PING);
 
   // If a time fence is active, save the submission to be queued only after
   // we pass the time fence.  Overwrite any existing waiting submission in this
@@ -405,7 +405,7 @@
   watchdog::Watchdog* watchdog = watchdog::Watchdog::GetInstance();
   if (watchdog) {
 #if defined(_DEBUG)
-    // Injects delay based off of environment variables for watchdog debugging.
+    // Injects delay for watchdog debugging.
     watchdog->MaybeInjectDebugDelay(kWatchdogName);
 #endif  // defined(_DEBUG)
     watchdog->Ping(kWatchdogName);
diff --git a/cobalt/script/environment_settings.h b/cobalt/script/environment_settings.h
index dd615ed..d1761da 100644
--- a/cobalt/script/environment_settings.h
+++ b/cobalt/script/environment_settings.h
@@ -39,12 +39,12 @@
 
   // The API base URL.
   //   https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#api-base-url
-  void set_base_url(const GURL& url) { base_url_ = url; }
-  const GURL& base_url() const { return base_url_; }
+  virtual const GURL& base_url() const { return creation_url(); }
 
   // The API creation URL
   //   https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#concept-environment-creation-url
-  const GURL& creation_url() const { return base_url(); }
+  void set_creation_url(const GURL& url) { creation_url_ = url; }
+  const GURL& creation_url() const { return creation_url_; }
 
   // https://html.spec.whatwg.org/multipage/webappapis.html#concept-settings-object-origin
   const GURL GetOrigin() const { return creation_url().GetOrigin(); }
@@ -60,7 +60,7 @@
   std::string uuid_;
   static const base::NullDebuggerHooks null_debugger_hooks_;
   const base::DebuggerHooks& debugger_hooks_;
-  GURL base_url_;
+  GURL creation_url_;
 };
 
 }  // namespace script
diff --git a/cobalt/site/docs/reference/starboard/gn-configuration.md b/cobalt/site/docs/reference/starboard/gn-configuration.md
index cd877fa..4c72557 100644
--- a/cobalt/site/docs/reference/starboard/gn-configuration.md
+++ b/cobalt/site/docs/reference/starboard/gn-configuration.md
@@ -6,22 +6,22 @@
 | Variables |
 | :--- |
 | **`abort_on_allocation_failure`**<br><br> Halt execution on failure to allocate memory.<br><br>The default value is `true`. |
-| **`asan_symbolizer_path`**<br><br> A symbolizer path for ASAN can be added to allow translation of callstacks.<br><br>The default value is `"$clang_base_path/bin/llvm-symbolizer"`. |
+| **`asan_symbolizer_path`**<br><br> A symbolizer path for ASAN can be added to allow translation of callstacks.<br><br>The default value is `"<clang_base_path>/bin/llvm-symbolizer"`. |
 | **`cobalt_licenses_platform`**<br><br> Sub-directory to copy license file to.<br><br>The default value is `"default"`. |
-| **`cobalt_platform_dependencies`**<br><br> TODO(b/173248397): Migrate to CobaltExtensions or PlatformServices. List of platform-specific targets that get compiled into cobalt.<br><br>The default value is `[]`. |
+| **`cobalt_platform_dependencies`**<br><br> List of platform-specific targets that get compiled into cobalt.<br><br>The default value is `[]`. |
 | **`cobalt_v8_emit_builtins_as_inline_asm`**<br><br> Some compiler can not compile with raw assembly(.S files) and v8 converts asm to inline assembly for these platforms.<br><br>The default value is `false`. |
 | **`default_renderer_options_dependency`**<br><br> Override this value to adjust the default rasterizer setting for your platform.<br><br>The default value is `"//cobalt/renderer:default_options"`. |
 | **`enable_account_manager`**<br><br> Set to true to enable H5vccAccountManager.<br><br>The default value is `false`. |
 | **`enable_in_app_dial`**<br><br> Enables or disables the DIAL server that runs inside Cobalt. Note: Only enable if there's no system-wide DIAL support.<br><br>The default value is `false`. |
 | **`enable_sso`**<br><br> Set to true to enable H5vccSSO (Single Sign On).<br><br>The default value is `false`. |
 | **`enable_xhr_header_filtering`**<br><br> Set to true to enable filtering of HTTP headers before sending.<br><br>The default value is `false`. |
-| **`executable_configs`**<br><br> Target-specific configurations for each platform.<br><br>The default value is `[]`. |
-| **`final_executable_type`**<br><br> The variables allow changing the target type on platforms where the native code may require an additional packaging step (ex. Android).<br><br>The default value is `"executable"`. |
+| **`executable_configs`**<br><br> Target-specific configurations for executable targets.<br><br>The default value is `[]`. |
+| **`final_executable_type`**<br><br> The target type for executable targets. Allows changing the target type on platforms where the native code may require an additional packaging step (ex. Android).<br><br>The default value is `"executable"`. |
 | **`gl_type`**<br><br> The source of EGL and GLES headers and libraries. Valid values (case and everything sensitive!):<ul><li><code>none</code> - No EGL + GLES implementation is available on this platform.<li><code>system_gles2</code> - Use the system implementation of EGL + GLES2. The headers and libraries must be on the system include and link paths.<li><code>glimp</code> - Cobalt's own EGL + GLES2 implementation. This requires a valid Glimp implementation for the platform.<li><code>angle</code> - A DirectX-to-OpenGL adaptation layer. This requires a valid ANGLE implementation for the platform.<br><br>The default value is `"system_gles2"`. |
-| **`gtest_target_type`**<br><br> The variables allow changing the target type on platforms where the native code may require an additional packaging step (ex. Android).<br><br>The default value is `"executable"`. |
+| **`gtest_target_type`**<br><br> The target type for test targets. Allows changing the target type on platforms where the native code may require an additional packaging step (ex. Android).<br><br>The default value is `"executable"`. |
 | **`has_platform_targets`**<br><br> Whether the platform has platform-specific targets to depend on.<br><br>The default value is `false`. |
 | **`install_target_path`**<br><br> The path to the gni file containing the install_target template which defines how the build should produce the install/ directory.<br><br>The default value is `"//starboard/build/install/no_install.gni"`. |
-| **`loadable_module_configs`**<br><br> Target-specific configurations for each platform.<br><br>The default value is `[]`. |
+| **`loadable_module_configs`**<br><br> Target-specific configurations for loadable_module targets.<br><br>The default value is `[]`. |
 | **`path_to_yasm`**<br><br> Where yasm can be found on the host device.<br><br>The default value is `"yasm"`. |
 | **`platform_tests_path`**<br><br> Set to the starboard_platform_tests target if the platform implements them.<br><br>The default value is `""`. |
 | **`sabi_path`**<br><br> Where the Starboard ABI file for this platform can be found.<br><br>The default value is `"starboard/sabi/default/sabi.json"`. |
@@ -36,13 +36,13 @@
 | **`sb_is_evergreen`**<br><br> Whether this is an Evergreen build.<br><br>The default value is `false`. |
 | **`sb_is_evergreen_compatible`**<br><br> Whether this is an Evergreen compatible platform. A compatible platform can run the elf_loader and launch the Evergreen build.<br><br>The default value is `false`. |
 | **`sb_libevent_method`**<br><br> The event polling mechanism available on this platform to support libevent. Platforms may redefine to 'poll' if necessary. Other mechanisms, e.g. devpoll, kqueue, select, are not yet supported.<br><br>The default value is `"epoll"`. |
-| **`sb_static_contents_output_data_dir`**<br><br> Directory path to static contents' data.<br><br>The default value is `"$root_out_dir/content/data"`. |
-| **`sb_use_no_rtti`**<br><br>The default value is `false`. |
+| **`sb_static_contents_output_data_dir`**<br><br> Directory path to static contents' data.<br><br>The default value is `"/project_out_dir/content/data"`. |
+| **`sb_use_no_rtti`**<br><br> Whether or not to disable run-time type information (adding no_rtti flag).<br><br>The default value is `false`. |
 | **`separate_install_targets_for_bundling`**<br><br> Set to true to separate install target directories.<br><br>The default value is `false`. |
-| **`shared_library_configs`**<br><br> Target-specific configurations for each platform.<br><br>The default value is `[]`. |
-| **`source_set_configs`**<br><br> Target-specific configurations for each platform.<br><br>The default value is `[]`. |
-| **`static_library_configs`**<br><br> Target-specific configurations for each platform.<br><br>The default value is `[]`. |
-| **`use_skia_next`**<br><br> Flag to use a future version of Skia, currently not available<br><br>The default value is `false`. |
+| **`shared_library_configs`**<br><br> Target-specific configurations for shared_library targets.<br><br>The default value is `[]`. |
+| **`source_set_configs`**<br><br> Target-specific configurations for source_set targets.<br><br>The default value is `[]`. |
+| **`static_library_configs`**<br><br> Target-specific configurations for static_library targets.<br><br>The default value is `[]`. |
+| **`use_skia_next`**<br><br> Flag to use a future version of Skia, currently not available.<br><br>The default value is `false`. |
 | **`use_thin_archive`**<br><br> Whether or not to link with thin archives.<br><br>The default value is `true`. |
 | **`v8_enable_pointer_compression_override`**<br><br> Set to true to enable pointer compression for v8.<br><br>The default value is `true`. |
 | **`yasm_exists`**<br><br> Enables the yasm compiler to be used to compile .asm files.<br><br>The default value is `false`. |
diff --git a/cobalt/updater/BUILD.gn b/cobalt/updater/BUILD.gn
index 4026027..da5cd31 100644
--- a/cobalt/updater/BUILD.gn
+++ b/cobalt/updater/BUILD.gn
@@ -110,6 +110,7 @@
     ":updater",
     "//base",
     "//components/update_client",
+    "//testing/gmock",
     "//testing/gtest",
   ]
 }
diff --git a/cobalt/updater/utils.cc b/cobalt/updater/utils.cc
index d1678de..5be22e3 100644
--- a/cobalt/updater/utils.cc
+++ b/cobalt/updater/utils.cc
@@ -127,13 +127,14 @@
       .DirName();
 }
 
-const base::FilePath FindInstallationPath() {
+const base::FilePath FindInstallationPath(
+    std::function<const void*(const char*)> get_extension_fn) {
   // TODO(b/233914266): consider using base::NoDestructor to give the
   // installation path static duration once found.
 
   auto installation_manager =
       static_cast<const CobaltExtensionInstallationManagerApi*>(
-          SbSystemGetExtension(kCobaltExtensionInstallationManagerName));
+          get_extension_fn(kCobaltExtensionInstallationManagerName));
   if (!installation_manager) {
     LOG(ERROR) << "Failed to get installation manager extension, getting the "
                   "installation path of the loaded library.";
@@ -171,14 +172,16 @@
   return version.GetString();
 }
 
-const std::string GetCurrentEvergreenVersion() {
-  base::FilePath installation_path = FindInstallationPath();
+const std::string GetCurrentEvergreenVersion(
+    std::function<const void*(const char*)> get_extension_fn) {
+  base::FilePath installation_path = FindInstallationPath(get_extension_fn);
   return GetValidOrDefaultEvergreenVersion(installation_path);
 }
 
-EvergreenLibraryMetadata GetCurrentEvergreenLibraryMetadata() {
+EvergreenLibraryMetadata GetCurrentEvergreenLibraryMetadata(
+    std::function<const void*(const char*)> get_extension_fn) {
   EvergreenLibraryMetadata evergreen_library_metadata;
-  base::FilePath installation_path = FindInstallationPath();
+  base::FilePath installation_path = FindInstallationPath(get_extension_fn);
 
   evergreen_library_metadata.version =
       GetValidOrDefaultEvergreenVersion(installation_path);
diff --git a/cobalt/updater/utils.h b/cobalt/updater/utils.h
index 2b7b1ba..abcabfc 100644
--- a/cobalt/updater/utils.h
+++ b/cobalt/updater/utils.h
@@ -8,6 +8,7 @@
 #include <string>
 
 #include "base/version.h"
+#include "starboard/system.h"
 
 namespace base {
 class FilePath;
@@ -34,10 +35,14 @@
 bool GetProductDirectoryPath(base::FilePath* path);
 
 // Returns the Evergreen library metadata of the current installation.
-EvergreenLibraryMetadata GetCurrentEvergreenLibraryMetadata();
+EvergreenLibraryMetadata GetCurrentEvergreenLibraryMetadata(
+    std::function<const void*(const char*)> get_extension_fn =
+        &SbSystemGetExtension);
 
 // Returns the Evergreen version of the current installation.
-const std::string GetCurrentEvergreenVersion();
+const std::string GetCurrentEvergreenVersion(
+    std::function<const void*(const char*)> get_extension_fn =
+        &SbSystemGetExtension);
 
 // Reads the Evergreen version of the installation dir.
 base::Version ReadEvergreenVersion(base::FilePath installation_dir);
diff --git a/cobalt/updater/utils_test.cc b/cobalt/updater/utils_test.cc
index 91fc329..4a43cde 100644
--- a/cobalt/updater/utils_test.cc
+++ b/cobalt/updater/utils_test.cc
@@ -19,6 +19,8 @@
 #include "base/files/file_path.h"
 #include "base/strings/strcat.h"
 #include "base/values.h"
+#include "cobalt/extension/installation_manager.h"
+#include "gmock/gmock.h"
 #include "starboard/common/file.h"
 #include "starboard/directory.h"
 #include "starboard/file.h"
@@ -31,6 +33,71 @@
 const char kEvergreenManifestFilename[] = "manifest.json";
 const char kEvergreenLibDirname[] = "lib";
 
+// Based on the CobaltExtensionInstallationManagerApi struct typedef.
+class MockInstallationManagerApi {
+ public:
+  MOCK_METHOD0(GetCurrentInstallationIndex, int());
+  MOCK_METHOD3(GetInstallationPath,
+               int(int installation_index, char* path, int path_length));
+};
+
+MockInstallationManagerApi* GetMockInstallationManagerApi() {
+  static auto* const installation_manager_api = []() {
+    auto* inner_installation_manager_api = new MockInstallationManagerApi;
+    // Because the mocked methods are non-state-changing, this mock is really
+    // just used as a stub. It's therefore ok for this mock object to be leaked
+    // and not verified.
+    testing::Mock::AllowLeak(inner_installation_manager_api);
+    return inner_installation_manager_api;
+  }();
+
+  return installation_manager_api;
+}
+
+// Stub definitions that delegate to the mock installation manager API.
+int StubGetCurrentInstallationIndex() {
+  return GetMockInstallationManagerApi()->GetCurrentInstallationIndex();
+}
+
+int StubGetInstallationPath(int installation_index, char* path,
+                            int path_length) {
+  return GetMockInstallationManagerApi()->GetInstallationPath(
+      installation_index, path, path_length);
+}
+
+// No-op stub definitions for functions that aren't exercised.
+int StubMarkInstallationSuccessful(int installation_index) {
+  return IM_EXT_SUCCESS;
+}
+
+int StubRequestRollForwardToInstallation(int installation_index) {
+  return IM_EXT_SUCCESS;
+}
+
+int StubSelectNewInstallationIndex() { return IM_EXT_SUCCESS; }
+
+int StubGetAppKey(char* app_key, int app_key_length) { return IM_EXT_SUCCESS; }
+
+int StubGetMaxNumberInstallations() { return IM_EXT_SUCCESS; }
+
+int StubResetInstallation(int installation_index) { return IM_EXT_SUCCESS; }
+
+int StubReset() { return IM_EXT_SUCCESS; }
+
+const CobaltExtensionInstallationManagerApi kStubInstallationManagerApi = {
+    kCobaltExtensionInstallationManagerName,
+    1,
+    &StubGetCurrentInstallationIndex,
+    &StubMarkInstallationSuccessful,
+    &StubRequestRollForwardToInstallation,
+    &StubGetInstallationPath,
+    &StubSelectNewInstallationIndex,
+    &StubGetAppKey,
+    &StubGetMaxNumberInstallations,
+    &StubResetInstallation,
+    &StubReset,
+};
+
 class UtilsTest : public testing::Test {
  protected:
   void SetUp() override {
@@ -134,8 +201,90 @@
   ASSERT_FALSE(version.IsValid());
 }
 
+TEST_F(UtilsTest, ReturnsEvergreenVersionFromCurrentManagedInstallation) {
+  std::string installation_path = base::StrCat(
+      {temp_dir_path_.data(), kSbFileSepString, "some_installation_path"});
+  int installation_index = 1;
+
+  MockInstallationManagerApi* mock_installation_manager_api =
+      GetMockInstallationManagerApi();
+  EXPECT_CALL(*mock_installation_manager_api, GetCurrentInstallationIndex())
+      .Times(1)
+      .WillOnce(testing::Return(installation_index));
+  EXPECT_CALL(
+      *mock_installation_manager_api,
+      GetInstallationPath(installation_index, testing::_, kSbFileMaxPath))
+      .Times(1)
+      .WillOnce(
+          testing::DoAll(testing::SetArrayArgument<1>(installation_path.begin(),
+                                                      installation_path.end()),
+                         testing::Return(IM_EXT_SUCCESS)));
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return &kStubInstallationManagerApi; };
+
+  ASSERT_TRUE(SbDirectoryCreate(installation_path.c_str()));
+  char manifest_content[] = R"json(
+  {
+    "manifest_version": 2,
+    "name": "Cobalt",
+    "description": "Cobalt",
+    "version": "1.2.0"
+  })json";
+  CreateManifest(manifest_content, installation_path);
+
+  std::string version = GetCurrentEvergreenVersion(stub_get_extension_fn);
+
+  ASSERT_EQ(version, "1.2.0");
+
+  DeleteManifest(installation_path);
+}
+
 TEST_F(UtilsTest,
-       ReturnsValidCurrentEvergreenVersionForManifestInLoadedInstallation) {
+       ReturnsDefaultVersionWhenManifestMissingFromCurrentManagedInstallation) {
+  std::string installation_path = base::StrCat(
+      {temp_dir_path_.data(), kSbFileSepString, "some_installation_path"});
+  int installation_index = 1;
+
+  MockInstallationManagerApi* mock_installation_manager_api =
+      GetMockInstallationManagerApi();
+  EXPECT_CALL(*mock_installation_manager_api, GetCurrentInstallationIndex())
+      .Times(1)
+      .WillOnce(testing::Return(installation_index));
+  EXPECT_CALL(
+      *mock_installation_manager_api,
+      GetInstallationPath(installation_index, testing::_, kSbFileMaxPath))
+      .Times(1)
+      .WillOnce(
+          testing::DoAll(testing::SetArrayArgument<1>(installation_path.begin(),
+                                                      installation_path.end()),
+                         testing::Return(IM_EXT_SUCCESS)));
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return &kStubInstallationManagerApi; };
+
+  ASSERT_TRUE(SbDirectoryCreate(installation_path.c_str()));
+  // No manifest is created in the installation directory.
+
+  std::string version = GetCurrentEvergreenVersion(stub_get_extension_fn);
+
+  ASSERT_EQ(version, kDefaultManifestVersion);
+}
+
+TEST_F(UtilsTest,
+       ReturnsVersionFromLoadedInstallationWhenErrorGettingInstallationPath) {
+  int installation_index = 1;
+  MockInstallationManagerApi* mock_installation_manager_api =
+      GetMockInstallationManagerApi();
+  EXPECT_CALL(*mock_installation_manager_api, GetCurrentInstallationIndex())
+      .Times(1)
+      .WillOnce(testing::Return(installation_index));
+  EXPECT_CALL(
+      *mock_installation_manager_api,
+      GetInstallationPath(installation_index, testing::_, kSbFileMaxPath))
+      .Times(1)
+      .WillOnce(testing::Return(IM_EXT_ERROR));
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return &kStubInstallationManagerApi; };
+
   std::vector<char> system_path_content_dir(kSbFileMaxPath);
   SbSystemGetPath(kSbSystemPathContentDirectory, system_path_content_dir.data(),
                   kSbFileMaxPath);
@@ -156,7 +305,7 @@
   })json";
   CreateManifest(manifest_content, installation_path);
 
-  std::string version = GetCurrentEvergreenVersion();
+  std::string version = GetCurrentEvergreenVersion(stub_get_extension_fn);
 
   ASSERT_EQ(version, "1.2.0");
 
@@ -164,14 +313,15 @@
 }
 
 TEST_F(UtilsTest,
-       ReturnsDefaultEvergreenVersionForManifestMissingFromLoadedInstallation) {
-  std::string version = GetCurrentEvergreenVersion();
+       ReturnsVersionFromLoadedInstallationWhenErrorGettingInstallationIndex) {
+  MockInstallationManagerApi* mock_installation_manager_api =
+      GetMockInstallationManagerApi();
+  EXPECT_CALL(*mock_installation_manager_api, GetCurrentInstallationIndex())
+      .Times(1)
+      .WillOnce(testing::Return(IM_EXT_ERROR));
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return &kStubInstallationManagerApi; };
 
-  ASSERT_EQ(version, kDefaultManifestVersion);
-}
-
-TEST_F(UtilsTest,
-       ReturnsValidCurrentMetadataForValidFilesInLoadedInstallation) {
   std::vector<char> system_path_content_dir(kSbFileMaxPath);
   SbSystemGetPath(kSbSystemPathContentDirectory, system_path_content_dir.data(),
                   kSbFileMaxPath);
@@ -191,9 +341,99 @@
     "version": "1.2.0"
   })json";
   CreateManifest(manifest_content, installation_path);
+
+  std::string version = GetCurrentEvergreenVersion(stub_get_extension_fn);
+
+  ASSERT_EQ(version, "1.2.0");
+
+  DeleteManifest(installation_path);
+}
+
+TEST_F(UtilsTest,
+       ReturnsVersionFromLoadedInstallationWhenErrorGettingIMExtension) {
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return nullptr; };
+
+  std::vector<char> system_path_content_dir(kSbFileMaxPath);
+  SbSystemGetPath(kSbSystemPathContentDirectory, system_path_content_dir.data(),
+                  kSbFileMaxPath);
+  // Since the libupdater_test.so library has already been loaded,
+  // kSbSystemPathContentDirectory points to the content dir of the running
+  // library and the installation dir is therefore its parent.
+  std::string installation_path =
+      base::FilePath(std::string(system_path_content_dir.begin(),
+                                 system_path_content_dir.end()))
+          .DirName()
+          .value();
+  char manifest_content[] = R"json(
+  {
+    "manifest_version": 2,
+    "name": "Cobalt",
+    "description": "Cobalt",
+    "version": "1.2.0"
+  })json";
+  CreateManifest(manifest_content, installation_path);
+
+  std::string version = GetCurrentEvergreenVersion(stub_get_extension_fn);
+
+  ASSERT_EQ(version, "1.2.0");
+
+  DeleteManifest(installation_path);
+}
+
+TEST_F(UtilsTest,
+       ReturnsDefaultVersionWhenManifestMissingFromLoadedInstallation) {
+  // Two levels of resilience are actually tested...
+
+  // First, the loaded installation is used because an error is encountered
+  // while getting the Installation Manager extension. This is similar to
+  // previous test cases.
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return nullptr; };
+
+  // And second, kDefaultManifestVersion should be used because no manifest is
+  // found in the loaded installation.
+
+  std::string version = GetCurrentEvergreenVersion(stub_get_extension_fn);
+
+  ASSERT_EQ(version, kDefaultManifestVersion);
+}
+
+TEST_F(UtilsTest,
+       ReturnsEvergreenLibraryMetadataFromCurrentManagedInstallation) {
+  std::string installation_path = base::StrCat(
+      {temp_dir_path_.data(), kSbFileSepString, "some_installation_path"});
+  int installation_index = 1;
+
+  MockInstallationManagerApi* mock_installation_manager_api =
+      GetMockInstallationManagerApi();
+  EXPECT_CALL(*mock_installation_manager_api, GetCurrentInstallationIndex())
+      .Times(1)
+      .WillOnce(testing::Return(installation_index));
+  EXPECT_CALL(
+      *mock_installation_manager_api,
+      GetInstallationPath(installation_index, testing::_, kSbFileMaxPath))
+      .Times(1)
+      .WillOnce(
+          testing::DoAll(testing::SetArrayArgument<1>(installation_path.begin(),
+                                                      installation_path.end()),
+                         testing::Return(IM_EXT_SUCCESS)));
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return &kStubInstallationManagerApi; };
+
+  ASSERT_TRUE(SbDirectoryCreate(installation_path.c_str()));
+  char manifest_content[] = R"json(
+  {
+    "manifest_version": 2,
+    "name": "Cobalt",
+    "description": "Cobalt",
+    "version": "1.2.0"
+  })json";
+  CreateManifest(manifest_content, installation_path);
   CreateEmptyLibrary("libcobalt.so", installation_path);
 
-  EvergreenLibraryMetadata metadata = GetCurrentEvergreenLibraryMetadata();
+  EvergreenLibraryMetadata metadata =
+      GetCurrentEvergreenLibraryMetadata(stub_get_extension_fn);
 
   ASSERT_EQ(metadata.version, "1.2.0");
   ASSERT_EQ(metadata.file_type, "Uncompressed");
@@ -203,7 +443,43 @@
 }
 
 TEST_F(UtilsTest,
-       ReturnsUnknownFileTypeInMetadataForUnexpectedLibInLoadedInstallation) {
+       ReturnsFileTypeUnknownInMetadataForUnexpectedLibInManagedInstallation) {
+  std::string installation_path = base::StrCat(
+      {temp_dir_path_.data(), kSbFileSepString, "some_installation_path"});
+  int installation_index = 1;
+
+  MockInstallationManagerApi* mock_installation_manager_api =
+      GetMockInstallationManagerApi();
+  EXPECT_CALL(*mock_installation_manager_api, GetCurrentInstallationIndex())
+      .Times(1)
+      .WillOnce(testing::Return(installation_index));
+  EXPECT_CALL(
+      *mock_installation_manager_api,
+      GetInstallationPath(installation_index, testing::_, kSbFileMaxPath))
+      .Times(1)
+      .WillOnce(
+          testing::DoAll(testing::SetArrayArgument<1>(installation_path.begin(),
+                                                      installation_path.end()),
+                         testing::Return(IM_EXT_SUCCESS)));
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return &kStubInstallationManagerApi; };
+
+  ASSERT_TRUE(SbDirectoryCreate(installation_path.c_str()));
+  CreateEmptyLibrary("libcobalt.unexpected", installation_path);
+
+  EvergreenLibraryMetadata metadata =
+      GetCurrentEvergreenLibraryMetadata(stub_get_extension_fn);
+
+  ASSERT_EQ(metadata.file_type, "FileTypeUnknown");
+
+  DeleteLibraryDirRecursively(installation_path);
+}
+
+TEST_F(UtilsTest,
+       ReturnsEvergreenLibMetadataFromLoadedInstallationWhenErrorGettingIM) {
+  std::function<const void*(const char*)> stub_get_extension_fn =
+      [](const char* name) { return nullptr; };
+
   std::vector<char> system_path_content_dir(kSbFileMaxPath);
   SbSystemGetPath(kSbSystemPathContentDirectory, system_path_content_dir.data(),
                   kSbFileMaxPath);
@@ -215,12 +491,23 @@
                                  system_path_content_dir.end()))
           .DirName()
           .value();
-  CreateEmptyLibrary("libcobalt.unexpected", installation_path);
+  char manifest_content[] = R"json(
+  {
+    "manifest_version": 2,
+    "name": "Cobalt",
+    "description": "Cobalt",
+    "version": "1.2.0"
+  })json";
+  CreateManifest(manifest_content, installation_path);
+  CreateEmptyLibrary("libcobalt.lz4", installation_path);
 
-  EvergreenLibraryMetadata metadata = GetCurrentEvergreenLibraryMetadata();
+  EvergreenLibraryMetadata metadata =
+      GetCurrentEvergreenLibraryMetadata(stub_get_extension_fn);
 
-  ASSERT_EQ(metadata.file_type, "FileTypeUnknown");
+  ASSERT_EQ(metadata.version, "1.2.0");
+  ASSERT_EQ(metadata.file_type, "Compressed");
 
+  DeleteManifest(installation_path);
   DeleteLibraryDirRecursively(installation_path);
 }
 
diff --git a/cobalt/watchdog/watchdog.cc b/cobalt/watchdog/watchdog.cc
index 544a47d..a8dd794 100644
--- a/cobalt/watchdog/watchdog.cc
+++ b/cobalt/watchdog/watchdog.cc
@@ -36,12 +36,16 @@
 
 // The Watchdog violations json filename.
 const char kWatchdogViolationsJson[] = "watchdog.json";
-// The default number of microseconds between each monitor loop.
-const int64_t kWatchdogSmallestTimeInterval = 1000000;
+// The frequency in microseconds of monitor loops.
+const int64_t kWatchdogMonitorFrequency = 1000000;
 // The maximum number of most recent repeated Watchdog violations.
 const int64_t kWatchdogMaxViolations = 100;
+// The minimum number of microseconds between writes.
+const int64_t kWatchdogWriteWaitTime = 300000000;
 // The maximum number of most recent ping infos.
-const int64_t kWatchdogMaxPingInfos = 100;
+const int64_t kWatchdogMaxPingInfos = 20;
+// The maximum length of each ping info.
+const int64_t kWatchdogMaxPingInfoLength = 1024;
 
 // Persistent setting name and default setting for the boolean that controls
 // whether or not Watchdog is enabled. When disabled, Watchdog behaves like a
@@ -66,7 +70,8 @@
   if (is_disabled_) return true;
 
   SB_CHECK(SbMutexCreate(&mutex_));
-  smallest_time_interval_ = kWatchdogSmallestTimeInterval;
+  pending_write_ = false;
+  write_wait_time_microseconds_ = kWatchdogWriteWaitTime;
 
 #if defined(_DEBUG)
   // Sets Watchdog delay settings from command line switch.
@@ -111,6 +116,7 @@
   if (is_disabled_) return;
 
   SB_CHECK(SbMutexAcquire(&mutex_) == kSbMutexAcquired);
+  if (pending_write_) WriteWatchdogViolations();
   is_monitoring_ = false;
   SB_CHECK(SbMutexRelease(&mutex_));
   SbThreadJoin(watchdog_thread_, nullptr);
@@ -130,6 +136,19 @@
   return watchdog_file_;
 }
 
+void Watchdog::WriteWatchdogViolations() {
+  // Writes Watchdog violations to persistent storage as a json file.
+  std::string watchdog_json;
+  base::JSONWriter::Write(*violations_map_, &watchdog_json);
+  SB_LOG(INFO) << "[Watchdog] Writing violations to JSON:\n" << watchdog_json;
+  starboard::ScopedFile watchdog_file(GetWatchdogFilePath().c_str(),
+                                      kSbFileCreateAlways | kSbFileWrite);
+  watchdog_file.WriteAll(watchdog_json.c_str(),
+                         static_cast<int>(watchdog_json.size()));
+  pending_write_ = false;
+  time_last_written_microseconds_ = SbTimeGetMonotonicNow();
+}
+
 void Watchdog::UpdateState(base::ApplicationState state) {
   if (is_disabled_) return;
 
@@ -264,19 +283,19 @@
               "violationDurationMicroseconds",
               base::Value(std::to_string(violation_duration + time_delta)));
         }
+        static_cast<Watchdog*>(context)->pending_write_ = true;
 
         // Resets time last updated.
         client->time_last_updated_monotonic_microseconds =
             current_monotonic_time;
       }
     }
-    if (watchdog_violation) {
-      WriteWatchdogViolations(context);
-      MaybeTriggerCrash(context);
-    }
+    if (static_cast<Watchdog*>(context)->pending_write_)
+      MaybeWriteWatchdogViolations(context);
+    if (watchdog_violation) MaybeTriggerCrash(context);
 
     SB_CHECK(SbMutexRelease(&(static_cast<Watchdog*>(context))->mutex_));
-    SbThreadSleep(static_cast<Watchdog*>(context)->smallest_time_interval_);
+    SbThreadSleep(kWatchdogMonitorFrequency);
   }
   return nullptr;
 }
@@ -302,40 +321,41 @@
   }
 }
 
-void Watchdog::WriteWatchdogViolations(void* context) {
-  // Writes Watchdog violations to persistent storage as a json file.
-  std::string watchdog_json;
-  base::JSONWriter::Write(*(static_cast<Watchdog*>(context)->violations_map_),
-                          &watchdog_json);
-
-  SB_LOG(INFO) << "[Watchdog] Writing violations to JSON:\n" << watchdog_json;
-
-  starboard::ScopedFile watchdog_file(
-      (static_cast<Watchdog*>(context)->GetWatchdogFilePath()).c_str(),
-      kSbFileCreateAlways | kSbFileWrite);
-  watchdog_file.WriteAll(watchdog_json.c_str(),
-                         static_cast<int>(watchdog_json.size()));
+void Watchdog::MaybeWriteWatchdogViolations(void* context) {
+  if (SbTimeGetMonotonicNow() >
+      static_cast<Watchdog*>(context)->time_last_written_microseconds_ +
+          static_cast<Watchdog*>(context)->write_wait_time_microseconds_) {
+    static_cast<Watchdog*>(context)->WriteWatchdogViolations();
+  }
 }
 
 void Watchdog::MaybeTriggerCrash(void* context) {
   if (static_cast<Watchdog*>(context)->GetPersistentSettingWatchdogCrash()) {
+    if (static_cast<Watchdog*>(context)->pending_write_)
+      static_cast<Watchdog*>(context)->WriteWatchdogViolations();
     SB_LOG(ERROR) << "[Watchdog] Triggering violation Crash!";
     CHECK(false);
   }
 }
 
-bool Watchdog::Register(std::string name, base::ApplicationState monitor_state,
-                        int64_t time_interval, int64_t time_wait,
-                        Replace replace) {
-  return Register(name, name, monitor_state, time_interval, time_wait, replace);
-}
-
 bool Watchdog::Register(std::string name, std::string description,
                         base::ApplicationState monitor_state,
                         int64_t time_interval, int64_t time_wait,
                         Replace replace) {
   if (is_disabled_) return true;
 
+  // Validates parameters.
+  if (time_interval < 1000000 || time_wait < 0) {
+    SB_DLOG(ERROR) << "[Watchdog] Unable to Register: " << name;
+    if (time_interval < 1000000) {
+      SB_DLOG(ERROR) << "[Watchdog] Time interval less than min: "
+                     << kWatchdogMonitorFrequency;
+    } else {
+      SB_DLOG(ERROR) << "[Watchdog] Time wait is negative.";
+    }
+    return false;
+  }
+
   SB_CHECK(SbMutexAcquire(&mutex_) == kSbMutexAcquired);
 
   int64_t current_time = SbTimeToPosix(SbTimeGetNow());
@@ -373,8 +393,6 @@
 
   // Registers.
   auto result = client_map_.emplace(name, std::move(client));
-  // Sets new smallest_time_interval_.
-  smallest_time_interval_ = std::min(smallest_time_interval_, time_interval);
 
   SB_CHECK(SbMutexRelease(&mutex_));
 
@@ -389,17 +407,9 @@
 bool Watchdog::Unregister(const std::string& name, bool lock) {
   if (is_disabled_) return true;
 
-  if (lock) SB_CHECK(SbMutexAcquire(&mutex_) == kSbMutexAcquired);
   // Unregisters.
+  if (lock) SB_CHECK(SbMutexAcquire(&mutex_) == kSbMutexAcquired);
   auto result = client_map_.erase(name);
-  // Sets new smallest_time_interval_.
-  if (result) {
-    smallest_time_interval_ = kWatchdogSmallestTimeInterval;
-    for (auto& it : client_map_) {
-      smallest_time_interval_ = std::min(smallest_time_interval_,
-                                         it.second->time_interval_microseconds);
-    }
-  }
   if (lock) SB_CHECK(SbMutexRelease(&mutex_));
 
   if (result) {
@@ -415,7 +425,16 @@
 bool Watchdog::Ping(const std::string& name, const std::string& info) {
   if (is_disabled_) return true;
 
+  // Validates parameters.
+  if (info.length() > kWatchdogMaxPingInfoLength) {
+    SB_DLOG(ERROR) << "[Watchdog] Unable to Ping: " << name;
+    SB_DLOG(ERROR) << "[Watchdog] Ping info length exceeds max: "
+                   << kWatchdogMaxPingInfoLength;
+    return false;
+  }
+
   SB_CHECK(SbMutexAcquire(&mutex_) == kSbMutexAcquired);
+
   auto it = client_map_.find(name);
   bool client_exists = it != client_map_.end();
 
@@ -454,7 +473,11 @@
   if (is_disabled_) return "";
 
   std::string watchdog_json = "";
+
   SB_CHECK(SbMutexAcquire(&mutex_) == kSbMutexAcquired);
+
+  if (pending_write_) WriteWatchdogViolations();
+
   starboard::ScopedFile read_file(GetWatchdogFilePath().c_str(),
                                   kSbFileOpenOnly | kSbFileRead);
   if (read_file.IsValid()) {
@@ -517,7 +540,7 @@
 }
 
 #if defined(_DEBUG)
-// Sleeps threads based off of environment variables for Watchdog debugging.
+// Sleeps threads for Watchdog debugging.
 void Watchdog::MaybeInjectDebugDelay(const std::string& name) {
   if (is_disabled_) return;
 
@@ -525,12 +548,7 @@
 
   if (name != delay_name_) return;
 
-  SbTimeMonotonic current_time = SbTimeGetMonotonicNow();
-
-  if (time_last_delayed_microseconds_ == 0)
-    time_last_delayed_microseconds_ = current_time;
-
-  if (current_time >
+  if (SbTimeGetMonotonicNow() >
       time_last_delayed_microseconds_ + delay_wait_time_microseconds_) {
     SbThreadSleep(delay_sleep_time_microseconds_);
     time_last_delayed_microseconds_ = SbTimeGetMonotonicNow();
diff --git a/cobalt/watchdog/watchdog.h b/cobalt/watchdog/watchdog.h
index b4535f1..7ab5d96 100644
--- a/cobalt/watchdog/watchdog.h
+++ b/cobalt/watchdog/watchdog.h
@@ -58,8 +58,8 @@
   // Ping() and Register() when in PING replace mode or set initially by
   // Register(). Also reset by Monitor() when in idle states or when a
   // violation occurs. Prevents excessive violations as they must occur
-  // time_interval_microseconds apart rather than smallest_time_interval_
-  // apart. Used as the start value for time interval calculations.
+  // time_interval_microseconds apart rather than on each monitor loop. Used as
+  // the start value for time interval calculations.
   SbTimeMonotonic time_last_updated_monotonic_microseconds;
 } Client;
 
@@ -76,9 +76,6 @@
   bool InitializeStub();
   void Uninitialize();
   void UpdateState(base::ApplicationState state);
-  bool Register(std::string name, base::ApplicationState monitor_state,
-                int64_t time_interval, int64_t time_wait = 0,
-                Replace replace = NONE);
   bool Register(std::string name, std::string description,
                 base::ApplicationState monitor_state, int64_t time_interval,
                 int64_t time_wait = 0, Replace replace = NONE);
@@ -98,9 +95,10 @@
 
  private:
   std::string GetWatchdogFilePath();
+  void WriteWatchdogViolations();
   static void* Monitor(void* context);
   static void InitializeViolationsMap(void* context);
-  static void WriteWatchdogViolations(void* context);
+  static void MaybeWriteWatchdogViolations(void* context);
   static void MaybeTriggerCrash(void* context);
 
   // Watchdog violations file path.
@@ -111,16 +109,21 @@
   // except that persistent settings can still be get/set.
   bool is_disabled_;
   // Creates a lock which ensures that each loop of monitor is atomic in that
-  // modifications to is_monitoring_, state_, smallest_time_interval_, and most
-  // importantly to the dictionaries containing Watchdog clients, client_map_
-  // and violations_map_, only occur in between loops of monitor. API functions
-  // like Register(), Unregister(), Ping(), and GetWatchdogViolations() will be
-  // called by various threads and interact with these class variables.
+  // modifications to is_monitoring_, state_, and most importantly to the
+  // dictionaries containing Watchdog clients, client_map_ and violations_map_,
+  // only occur in between loops of monitor. API functions like Register(),
+  // Unregister(), Ping(), and GetWatchdogViolations() will be called by
+  // various threads and interact with these class variables.
   SbMutex mutex_;
   // Tracks application state.
   base::ApplicationState state_ = base::kApplicationStateStarted;
-  // Time interval between monitor loops.
-  int64_t smallest_time_interval_;
+  // Flag to trigger Watchdog violations writes to persistent storage.
+  bool pending_write_;
+  // Monotonically increasing timestamp when Watchdog violations were last
+  // written to persistent storage. 0 indicates that it has never been written.
+  SbTimeMonotonic time_last_written_microseconds_ = 0;
+  // Number of microseconds between writes.
+  int64_t write_wait_time_microseconds_;
   // Dictionary of registered Watchdog clients.
   std::unordered_map<std::string, std::unique_ptr<Client>> client_map_;
   // Dictionary of lists of Watchdog violations represented as dictionaries.
@@ -132,13 +135,14 @@
 
 #if defined(_DEBUG)
   starboard::Mutex delay_lock_;
-  // name of the client to inject delay
+  // Name of the client to inject a delay for.
   std::string delay_name_ = "";
-  // since (relative)
+  // Monotonically increasing timestamp when a delay was last injected. 0
+  // indicates that it has never been injected.
   SbTimeMonotonic time_last_delayed_microseconds_ = 0;
-  // time in between delays (periodic)
+  // Number of microseconds between delays.
   int64_t delay_wait_time_microseconds_ = 0;
-  // delay duration
+  // Number of microseconds to delay.
   int64_t delay_sleep_time_microseconds_ = 0;
 #endif
 };
diff --git a/cobalt/web/agent.cc b/cobalt/web/agent.cc
index e936b37..d017e6d 100644
--- a/cobalt/web/agent.cc
+++ b/cobalt/web/agent.cc
@@ -58,9 +58,6 @@
   }
   base::MessageLoop* message_loop() const final { return message_loop_; }
   void ShutDownJavaScriptEngine() final;
-  void set_fetcher_factory(loader::FetcherFactory* factory) final {
-    fetcher_factory_.reset(factory);
-  }
   loader::FetcherFactory* fetcher_factory() const final {
     return fetcher_factory_.get();
   }
@@ -116,7 +113,9 @@
 
   WindowOrWorkerGlobalScope* GetWindowOrWorkerGlobalScope() final;
 
-  UserAgentPlatformInfo* platform_info() const final { return platform_info_; }
+  const UserAgentPlatformInfo* platform_info() const final {
+    return platform_info_;
+  }
   std::string GetUserAgent() const final {
     return network_module()->GetUserAgent();
   }
@@ -201,7 +200,7 @@
       service_worker_object_map_;
 
   worker::ServiceWorkerJobs* service_worker_jobs_;
-  web::UserAgentPlatformInfo* platform_info_;
+  const web::UserAgentPlatformInfo* platform_info_;
 
   // https://html.spec.whatwg.org/multipage/webappapis.html#concept-environment-active-service-worker
   // Note: When a service worker is unregistered from the last client, this will
diff --git a/cobalt/web/agent.h b/cobalt/web/agent.h
index c6cb7e9..956a6f6 100644
--- a/cobalt/web/agent.h
+++ b/cobalt/web/agent.h
@@ -76,7 +76,7 @@
 
     worker::ServiceWorkerJobs* service_worker_jobs = nullptr;
 
-    web::UserAgentPlatformInfo* platform_info = nullptr;
+    const UserAgentPlatformInfo* platform_info = nullptr;
   };
 
   typedef base::Callback<void(const script::HeapStatistics&)>
diff --git a/cobalt/web/blob.idl b/cobalt/web/blob.idl
index 4f6c9a8..8c3f3e7 100644
--- a/cobalt/web/blob.idl
+++ b/cobalt/web/blob.idl
@@ -17,7 +17,8 @@
 [
   Constructor,
   Constructor(sequence<(ArrayBuffer or ArrayBufferView or DataView or Blob or USVString)> blobParts, optional BlobPropertyBag options),
-  ConstructorCallWith=EnvironmentSettings
+  ConstructorCallWith=EnvironmentSettings,
+  Exposed=(Window,Worker)
 ]
 interface Blob {
   readonly attribute unsigned long long size;
diff --git a/cobalt/web/blob_test.cc b/cobalt/web/blob_test.cc
index 32ac89e..f3cb1b3 100644
--- a/cobalt/web/blob_test.cc
+++ b/cobalt/web/blob_test.cc
@@ -20,16 +20,20 @@
 #include "cobalt/script/data_view.h"
 #include "cobalt/script/environment_settings.h"
 #include "cobalt/script/testing/mock_exception_state.h"
+#include "cobalt/web/testing/test_with_javascript.h"
+#include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using cobalt::script::testing::MockExceptionState;
+using ::testing::_;
+using ::testing::SaveArg;
+using ::testing::StrictMock;
+
 namespace cobalt {
 namespace web {
 namespace {
-
-using script::testing::MockExceptionState;
-using ::testing::_;
-using ::testing::SaveArg;
-using ::testing::StrictMock;
+class BlobTestWithJavaScript : public testing::TestWebWithJavaScript {};
+}  // namespace
 
 TEST(BlobTest, Constructors) {
   // Initialize JavaScriptEngine and its environment.
@@ -118,6 +122,93 @@
   EXPECT_EQ(0x7, blob_with_buffer->data()[1]);
 }
 
-}  // namespace
+TEST_P(BlobTestWithJavaScript, ConstructorWithArray) {
+  std::string result;
+  bool success = EvaluateScript(
+      "try {"
+      "  var blob = new Blob([\" TEST \"]);"
+      "} catch (e) {"
+      "  result = e.name;"
+      "}"
+      "if (!blob) result; else blob;",
+      &result);
+  EXPECT_TRUE(success);
+  EXPECT_EQ("[object Blob]", result);
+
+  if (!success) {
+    DLOG(ERROR) << "Failed to evaluate test: "
+                << "\"" << result << "\"";
+  }
+}
+
+
+TEST_P(BlobTestWithJavaScript, ConstructorWithArrayType) {
+  std::string result;
+  bool success = EvaluateScript(
+      "let result = 'unknown';"
+      "try {"
+      "  var blob = new Blob([\" TEST \"]);"
+      "  result = blob.type;"
+      "} catch (e) {"
+      "  result = e.name;"
+      "}"
+      "result;",
+      &result);
+  EXPECT_TRUE(success);
+  EXPECT_EQ("", result);
+
+  if (!success) {
+    DLOG(ERROR) << "Failed to evaluate test: "
+                << "\"" << result << "\"";
+  }
+}
+
+TEST_P(BlobTestWithJavaScript, ConstructorWithBlobPropertyBag) {
+  std::string result;
+  bool success = EvaluateScript(
+      "let result = 'unknown';"
+      "try {"
+      "  var blob = new Blob([\" TEST \"], {type : 'test/foo'});"
+      "  result = blob.type;"
+      "} catch (e) {"
+      "  result = e.name;"
+      "}"
+      "result;",
+      &result);
+  EXPECT_TRUE(success);
+  EXPECT_EQ("test/foo", result);
+
+  if (!success) {
+    DLOG(ERROR) << "Failed to evaluate test: "
+                << "\"" << result << "\"";
+  }
+}
+
+TEST_P(BlobTestWithJavaScript, ConstructorWithArraySize) {
+  std::string result;
+  bool success = EvaluateScript(
+      "try {"
+      "  var blob = new Blob([\" TEST \"]);"
+      "} catch (e) {"
+      "  result = e.name;"
+      "}"
+      "if (!blob) result; else blob.size;",
+      &result);
+  EXPECT_TRUE(success);
+  EXPECT_EQ("6", result);
+
+  if (!success) {
+    DLOG(ERROR) << "Failed to evaluate test: "
+                << "\"" << result << "\"";
+  }
+}
+
+
+INSTANTIATE_TEST_CASE_P(
+    BlobTestsWithJavaScript, BlobTestWithJavaScript,
+    ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWorkerTypes()),
+    testing::TestWebWithJavaScript::GetTypeName);
+
+
 }  // namespace web
 }  // namespace cobalt
diff --git a/cobalt/web/context.h b/cobalt/web/context.h
index e3f9b85..f48182f 100644
--- a/cobalt/web/context.h
+++ b/cobalt/web/context.h
@@ -46,7 +46,6 @@
   virtual ~Context() {}
   virtual base::MessageLoop* message_loop() const = 0;
   virtual void ShutDownJavaScriptEngine() = 0;
-  virtual void set_fetcher_factory(loader::FetcherFactory* factory) = 0;
   virtual loader::FetcherFactory* fetcher_factory() const = 0;
   virtual loader::ScriptLoaderFactory* script_loader_factory() const = 0;
   virtual script::JavaScriptEngine* javascript_engine() const = 0;
@@ -78,7 +77,7 @@
 
   virtual WindowOrWorkerGlobalScope* GetWindowOrWorkerGlobalScope() = 0;
 
-  virtual UserAgentPlatformInfo* platform_info() const = 0;
+  virtual const UserAgentPlatformInfo* platform_info() const = 0;
 
   virtual std::string GetUserAgent() const = 0;
   virtual std::string GetPreferredLanguage() const = 0;
diff --git a/cobalt/web/csp_delegate_test.cc b/cobalt/web/csp_delegate_test.cc
index 837d504..b10dbaf 100644
--- a/cobalt/web/csp_delegate_test.cc
+++ b/cobalt/web/csp_delegate_test.cc
@@ -53,6 +53,13 @@
     {CspDelegate::kWebSocket, "connect-src"},
 };
 
+std::string ResourcePairName(::testing::TestParamInfo<ResourcePair> info) {
+  std::string name(info.param.directive);
+  std::replace(name.begin(), name.end(), '-', '_');
+  base::StringAppendF(&name, "_type_%d", info.param.type);
+  return name;
+}
+
 class MockViolationReporter : public CspViolationReporter {
  public:
   MockViolationReporter()
@@ -132,7 +139,8 @@
   EXPECT_EQ(effective_directive, info.effective_directive);
 }
 
-INSTANTIATE_TEST_CASE_P(CanLoad, CspDelegateTest, ValuesIn(s_params));
+INSTANTIATE_TEST_CASE_P(CanLoad, CspDelegateTest, ValuesIn(s_params),
+                        ResourcePairName);
 
 TEST(CspDelegateFactoryTest, Secure) {
   std::unique_ptr<CspDelegate> delegate =
diff --git a/cobalt/web/custom_event.idl b/cobalt/web/custom_event.idl
index babd097..f327201 100644
--- a/cobalt/web/custom_event.idl
+++ b/cobalt/web/custom_event.idl
@@ -13,8 +13,10 @@
 // limitations under the License.
 
 // https://www.w3.org/TR/2015/REC-dom-20151119/#customevent
-[Constructor(DOMString type, optional CustomEventInit eventInitDict)]
-interface CustomEvent : Event {
+[
+  Constructor(DOMString type, optional CustomEventInit eventInitDict),
+  Exposed = (Window,Worker)
+] interface CustomEvent : Event {
   readonly attribute any detail;
 
   void initCustomEvent(DOMString type,
diff --git a/cobalt/web/custom_event_test.cc b/cobalt/web/custom_event_test.cc
index 2b989e6..9bf87ae 100644
--- a/cobalt/web/custom_event_test.cc
+++ b/cobalt/web/custom_event_test.cc
@@ -19,18 +19,19 @@
 
 #include "base/bind.h"
 #include "base/logging.h"
-#include "cobalt/dom/testing/test_with_javascript.h"
 #include "cobalt/web/custom_event_init.h"
 #include "cobalt/web/testing/gtest_workarounds.h"
+#include "cobalt/web/testing/test_with_javascript.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::testing::_;
+
 namespace cobalt {
 namespace web {
 
 namespace {
-class CustomEventTestWithJavaScript : public dom::testing::TestWithJavaScript {
-};
+class CustomEventTestWithJavaScript : public testing::TestWebWithJavaScript {};
 }  // namespace
 
 TEST(CustomEventTest, ConstructorWithEventTypeString) {
@@ -66,7 +67,7 @@
   EXPECT_EQ(NULL, event->detail());
 }
 
-TEST_F(CustomEventTestWithJavaScript,
+TEST_P(CustomEventTestWithJavaScript,
        ConstructorWithEventTypeAndCustomInitDict) {
   std::string result;
   bool success = EvaluateScript(
@@ -84,13 +85,10 @@
   if (!success) {
     DLOG(ERROR) << "Failed to evaluate test: "
                 << "\"" << result << "\"";
-  } else {
-    LOG(INFO) << "Test result : "
-              << "\"" << result << "\"";
   }
 }
 
-TEST_F(CustomEventTestWithJavaScript, InitCustomEvent) {
+TEST_P(CustomEventTestWithJavaScript, InitCustomEvent) {
   std::string result;
   bool success = EvaluateScript(
       "var event = new CustomEvent('cat');\n"
@@ -106,11 +104,13 @@
   if (!success) {
     DLOG(ERROR) << "Failed to evaluate test: "
                 << "\"" << result << "\"";
-  } else {
-    LOG(INFO) << "Test result : "
-              << "\"" << result << "\"";
   }
 }
 
+INSTANTIATE_TEST_CASE_P(
+    CustomEventTestsWithJavaScript, CustomEventTestWithJavaScript,
+    ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWorkerTypes()),
+    testing::TestWebWithJavaScript::GetTypeName);
+
 }  // namespace web
 }  // namespace cobalt
diff --git a/cobalt/web/event_target.cc b/cobalt/web/event_target.cc
index 5d20131..eaea80d 100644
--- a/cobalt/web/event_target.cc
+++ b/cobalt/web/event_target.cc
@@ -105,8 +105,8 @@
   DCHECK(event);
   DCHECK(!event->IsBeingDispatched());
   DCHECK(event->initialized_flag());
-  TRACE_EVENT1("cobalt::dom", "EventTarget::DispatchEvent", "event",
-               TRACE_STR_COPY(event->type().c_str()));
+  TRACE_EVENT2("cobalt::dom", "EventTarget::DispatchEvent", "name",
+               GetDebugName(), "event", TRACE_STR_COPY(event->type().c_str()));
   if (!event || event->IsBeingDispatched() || !event->initialized_flag()) {
     return false;
   }
diff --git a/cobalt/web/global_stats.cc b/cobalt/web/global_stats.cc
index 97980c4..e4fd2a6 100644
--- a/cobalt/web/global_stats.cc
+++ b/cobalt/web/global_stats.cc
@@ -35,6 +35,8 @@
 GlobalStats::~GlobalStats() {}
 
 bool GlobalStats::CheckNoLeaks() {
+  DCHECK(num_event_listeners_ == 0);
+  DCHECK(num_active_java_script_events_ == 0);
   return num_event_listeners_ == 0 && num_active_java_script_events_ == 0;
 }
 
diff --git a/cobalt/web/navigator_ua_data.cc b/cobalt/web/navigator_ua_data.cc
index b2bae8b..52ac278 100644
--- a/cobalt/web/navigator_ua_data.cc
+++ b/cobalt/web/navigator_ua_data.cc
@@ -20,7 +20,7 @@
 namespace web {
 
 NavigatorUAData::NavigatorUAData(
-    UserAgentPlatformInfo* platform_info,
+    const UserAgentPlatformInfo* platform_info,
     script::ScriptValueFactory* script_value_factory)
     : script_value_factory_(script_value_factory) {
   if (platform_info == nullptr) {
diff --git a/cobalt/web/navigator_ua_data.h b/cobalt/web/navigator_ua_data.h
index 1dfd873..1284bb2 100644
--- a/cobalt/web/navigator_ua_data.h
+++ b/cobalt/web/navigator_ua_data.h
@@ -36,7 +36,7 @@
  public:
   using InterfacePromise = script::Promise<scoped_refptr<script::Wrappable>>;
 
-  NavigatorUAData(UserAgentPlatformInfo* platform_info,
+  NavigatorUAData(const UserAgentPlatformInfo* platform_info,
                   script::ScriptValueFactory* script_value_factory);
 
   script::Sequence<NavigatorUABrandVersion> brands() const { return brands_; }
diff --git a/cobalt/web/testing/BUILD.gn b/cobalt/web/testing/BUILD.gn
index 3b785ca..17f0326 100644
--- a/cobalt/web/testing/BUILD.gn
+++ b/cobalt/web/testing/BUILD.gn
@@ -19,6 +19,7 @@
   sources = [
     "gtest_workarounds.h",
     "mock_event_listener.h",
+    "mock_user_agent_platform_info.h",
     "stub_environment_settings.h",
     "stub_web_context.h",
   ]
@@ -27,6 +28,7 @@
     "//base",
     "//base/test:test_support",
     "//cobalt/base",
+    "//cobalt/loader",
     "//cobalt/network",
     "//cobalt/script",
     "//cobalt/script/testing:script_testing",
diff --git a/cobalt/web/testing/mock_user_agent_platform_info.h b/cobalt/web/testing/mock_user_agent_platform_info.h
new file mode 100644
index 0000000..4f87cfd
--- /dev/null
+++ b/cobalt/web/testing/mock_user_agent_platform_info.h
@@ -0,0 +1,93 @@
+// Copyright 2022 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef COBALT_WEB_TESTING_MOCK_USER_AGENT_PLATFORM_INFO_H_
+#define COBALT_WEB_TESTING_MOCK_USER_AGENT_PLATFORM_INFO_H_
+
+#include <string>
+
+#include "cobalt/web/user_agent_platform_info.h"
+
+namespace cobalt {
+namespace web {
+namespace testing {
+
+// Mock class implementing UserAgentPlatformInfo returning empty strings.
+class MockUserAgentPlatformInfo : public web::UserAgentPlatformInfo {
+ public:
+  MockUserAgentPlatformInfo() {}
+  ~MockUserAgentPlatformInfo() override{};
+
+  // From: dom:UserAgentPlatformInfo
+  //
+  const std::string& starboard_version() const override {
+    return empty_string_;
+  }
+  const std::string& os_name_and_version() const override {
+    return empty_string_;
+  }
+  base::Optional<std::string> original_design_manufacturer() const override {
+    return optional_empty_string_;
+  }
+  SbSystemDeviceType device_type() const override {
+    return kSbSystemDeviceTypeUnknown;
+  }
+  const std::string& device_type_string() const override {
+    return empty_string_;
+  }
+  base::Optional<std::string> chipset_model_number() const override {
+    return optional_empty_string_;
+  }
+  base::Optional<std::string> model_year() const override {
+    return optional_empty_string_;
+  }
+  base::Optional<std::string> firmware_version() const override {
+    return optional_empty_string_;
+  }
+  base::Optional<std::string> brand() const override {
+    return optional_empty_string_;
+  }
+  base::Optional<std::string> model() const override {
+    return optional_empty_string_;
+  }
+  const std::string& aux_field() const override { return empty_string_; }
+  const std::string& javascript_engine_version() const override {
+    return empty_string_;
+  }
+  const std::string& rasterizer_type() const override { return empty_string_; }
+  const std::string& evergreen_type() const override { return empty_string_; }
+  const std::string& evergreen_file_type() const override {
+    return empty_string_;
+  }
+  const std::string& evergreen_version() const override {
+    return empty_string_;
+  }
+  const std::string& cobalt_version() const override { return empty_string_; }
+  const std::string& cobalt_build_version_number() const override {
+    return empty_string_;
+  }
+  const std::string& build_configuration() const override {
+    return empty_string_;
+  }
+
+ private:
+  const std::string empty_string_;
+  base::Optional<std::string> optional_empty_string_;
+};  // namespace cobalt
+
+}  // namespace testing
+}  // namespace web
+}  // namespace cobalt
+
+#endif  // COBALT_WEB_TESTING_MOCK_USER_AGENT_PLATFORM_INFO_H_
diff --git a/cobalt/web/testing/stub_web_context.h b/cobalt/web/testing/stub_web_context.h
index 9442674..f709d0e 100644
--- a/cobalt/web/testing/stub_web_context.h
+++ b/cobalt/web/testing/stub_web_context.h
@@ -20,13 +20,18 @@
 
 #include "base/message_loop/message_loop.h"
 #include "base/test/scoped_task_environment.h"
+#include "cobalt/loader/fetcher_factory.h"
 #include "cobalt/network/network_module.h"
 #include "cobalt/script/global_environment.h"
 #include "cobalt/script/javascript_engine.h"
 #include "cobalt/script/wrappable.h"
+#include "cobalt/web/blob.h"
 #include "cobalt/web/context.h"
 #include "cobalt/web/environment_settings.h"
+#include "cobalt/web/testing/mock_user_agent_platform_info.h"
 #include "cobalt/web/testing/stub_environment_settings.h"
+#include "cobalt/web/url.h"
+#include "cobalt/web/user_agent_platform_info.h"
 #include "cobalt/worker/service_worker.h"
 #include "cobalt/worker/service_worker_object.h"
 #include "cobalt/worker/service_worker_registration.h"
@@ -40,20 +45,18 @@
 namespace web {
 namespace testing {
 
-class StubSettings : public EnvironmentSettings {
- public:
-  explicit StubSettings(const GURL& base) { set_base_url(base); }
-
- private:
-};
-
 class StubWebContext final : public Context {
  public:
   StubWebContext() : Context(), name_("StubWebInstance") {
     javascript_engine_ = script::JavaScriptEngine::CreateEngine();
     global_environment_ = javascript_engine_->CreateGlobalEnvironment();
+    blob_registry_.reset(new Blob::Registry);
+    network_module_.reset(new network::NetworkModule());
+    fetcher_factory_.reset(new loader::FetcherFactory(
+        network_module_.get(),
+        URL::MakeBlobResolverCallback(blob_registry_.get())));
   }
-  ~StubWebContext() final {}
+  ~StubWebContext() final { blob_registry_.reset(); }
 
   // WebInstance
   //
@@ -62,9 +65,6 @@
     return nullptr;
   }
   void ShutDownJavaScriptEngine() final { NOTREACHED(); }
-  void set_fetcher_factory(loader::FetcherFactory* factory) final {
-    fetcher_factory_.reset(factory);
-  }
   loader::FetcherFactory* fetcher_factory() const final {
     DCHECK(fetcher_factory_);
     return fetcher_factory_.get();
@@ -92,11 +92,8 @@
     return nullptr;
   }
   Blob::Registry* blob_registry() const final {
-    NOTREACHED();
-    return nullptr;
-  }
-  void set_network_module(network::NetworkModule* module) {
-    network_module_.reset(module);
+    DCHECK(blob_registry_);
+    return blob_registry_.get();
   }
   network::NetworkModule* network_module() const final {
     DCHECK(network_module_);
@@ -149,14 +146,25 @@
   }
 
   WindowOrWorkerGlobalScope* GetWindowOrWorkerGlobalScope() final {
-    NOTIMPLEMENTED();
-    return nullptr;
+    script::Wrappable* global_wrappable =
+        global_environment()->global_wrappable();
+    if (!global_wrappable) {
+      return nullptr;
+    }
+    DCHECK(global_wrappable->IsWrappable());
+    DCHECK_EQ(script::Wrappable::JSObjectType::kObject,
+              global_wrappable->GetJSObjectType());
+
+    return base::polymorphic_downcast<WindowOrWorkerGlobalScope*>(
+        global_wrappable);
   }
 
   void set_platform_info(UserAgentPlatformInfo* platform_info) {
     platform_info_ = platform_info;
   }
-  UserAgentPlatformInfo* platform_info() const final { return platform_info_; }
+  const UserAgentPlatformInfo* platform_info() const final {
+    return (platform_info_ ? platform_info_ : &mock_platform_info_);
+  }
 
   std::string GetUserAgent() const final {
     return std::string("StubUserAgentString");
@@ -190,6 +198,7 @@
   base::test::ScopedTaskEnvironment env_;
 
   std::unique_ptr<loader::FetcherFactory> fetcher_factory_;
+  std::unique_ptr<Blob::Registry> blob_registry_;
   std::unique_ptr<loader::ScriptLoaderFactory> script_loader_factory_;
   std::unique_ptr<script::JavaScriptEngine> javascript_engine_;
   scoped_refptr<script::GlobalEnvironment> global_environment_;
@@ -199,6 +208,7 @@
   std::unique_ptr<EnvironmentSettings> environment_settings_;
   UserAgentPlatformInfo* platform_info_ = nullptr;
   scoped_refptr<worker::ServiceWorkerObject> service_worker_object_;
+  MockUserAgentPlatformInfo mock_platform_info_;
 };
 
 }  // namespace testing
diff --git a/cobalt/web/testing/test_with_javascript.h b/cobalt/web/testing/test_with_javascript.h
new file mode 100644
index 0000000..f37276b
--- /dev/null
+++ b/cobalt/web/testing/test_with_javascript.h
@@ -0,0 +1,87 @@
+// Copyright 2022 The Cobalt Authors. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef COBALT_WEB_TESTING_TEST_WITH_JAVASCRIPT_H_
+#define COBALT_WEB_TESTING_TEST_WITH_JAVASCRIPT_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "cobalt/dom/dom_settings.h"
+#include "cobalt/dom/testing/stub_window.h"
+#include "cobalt/dom/window.h"
+#include "cobalt/script/wrappable.h"
+#include "cobalt/web/window_or_worker_global_scope.h"
+#include "cobalt/worker/testing/test_with_javascript.h"
+
+namespace cobalt {
+namespace web {
+namespace testing {
+
+// Helper class for extending the worker tests with JavaScript to include
+// testing in Window global scope.
+template <class TypeIdProvider>
+class TestWithJavaScriptBase
+    : public worker::testing::TestWithJavaScriptBase<TypeIdProvider> {
+ public:
+  TestWithJavaScriptBase() {
+    if (TypeIdProvider::GetGlobalScopeTypeId() ==
+        base::GetTypeId<dom::Window>()) {
+      DCHECK(!this->worker_global_scope());
+      this->ClearWebContext();
+      window_.reset(new dom::testing::StubWindow());
+    }
+  }
+
+  WindowOrWorkerGlobalScope* window_or_worker_global_scope() {
+    return window_ ? window_->window().get() : this->worker_global_scope();
+  }
+
+  scoped_refptr<script::GlobalEnvironment> global_environment() override {
+    if (window_) return window_->global_environment();
+    return worker::testing::TestWithJavaScriptBase<
+        TypeIdProvider>::global_environment();
+  }
+
+ private:
+  std::unique_ptr<dom::testing::StubWindow> window_;
+};
+
+// Helper class for running TEST_P() tests on all known worker types.
+class TestWebWithJavaScript
+    : public TestWithJavaScriptBase<
+          worker::testing::GetGlobalScopeTypeIdWithParam> {
+ public:
+  // Return a vector of values for all known worker types, to be used in the
+  // INSTANTIATE_TEST_CASE_P() declaration.
+  static std::vector<base::TypeId> GetWorkerTypes() {
+    std::vector<base::TypeId> worker_types =
+        worker::testing::TestWorkersWithJavaScript::GetWorkerTypes();
+    worker_types.push_back(base::GetTypeId<dom::Window>());
+    return worker_types;
+  }
+  static std::string GetTypeName(::testing::TestParamInfo<base::TypeId> info) {
+    if (info.param == base::GetTypeId<dom::Window>()) {
+      return "Window";
+    }
+    return worker::testing::TestWorkersWithJavaScript::GetTypeName(info);
+  }
+};
+
+}  // namespace testing
+}  // namespace web
+}  // namespace cobalt
+
+#endif  // COBALT_WEB_TESTING_TEST_WITH_JAVASCRIPT_H_
diff --git a/cobalt/web/url.idl b/cobalt/web/url.idl
index eed2f23..fe75fd3 100644
--- a/cobalt/web/url.idl
+++ b/cobalt/web/url.idl
@@ -14,7 +14,8 @@
 
 // https://www.w3.org/TR/2014/WD-url-1-20141209/#dom-url
 [RaisesException=Constructor, Constructor(
-     USVString url, optional USVString base = "about:blank")] interface URL {
+     USVString url, optional USVString base = "about:blank"),
+     Exposed=(Window,Worker)] interface URL {
   [CallWith=EnvironmentSettings] static DOMString
       createObjectURL(Blob blob);
   [CallWith=EnvironmentSettings] static void revokeObjectURL(DOMString url);
diff --git a/cobalt/web/url_test.cc b/cobalt/web/url_test.cc
index 3521dc5..ee6f405 100644
--- a/cobalt/web/url_test.cc
+++ b/cobalt/web/url_test.cc
@@ -18,8 +18,8 @@
 #include <string>
 
 #include "base/logging.h"
-#include "cobalt/dom/testing/test_with_javascript.h"
 #include "cobalt/web/testing/gtest_workarounds.h"
+#include "cobalt/web/testing/test_with_javascript.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -30,7 +30,6 @@
 
 namespace cobalt {
 namespace web {
-
 namespace {
 class URLTest : public ::testing::Test {
  public:
@@ -44,7 +43,7 @@
   StrictMock<MockExceptionState> exception_state_;
 };
 
-class URLTestWithJavaScript : public dom::testing::TestWithJavaScript {};
+class URLTestWithJavaScript : public testing::TestWebWithJavaScript {};
 }  // namespace
 
 TEST_F(URLTest, ConstructorWithValidURL) {
@@ -99,7 +98,7 @@
   EXPECT_EQ("", url->search());
 }
 
-TEST_F(URLTestWithJavaScript, ConstructorWithValidURL) {
+TEST_P(URLTestWithJavaScript, ConstructorWithValidURL) {
   std::string result;
   bool success = EvaluateScript(
       "var url = new "
@@ -119,16 +118,13 @@
   EXPECT_EQ("https://user:password@www.example.com:1234/foo/bar?baz#qux",
             result);
 
-  if (success) {
-    LOG(INFO) << "Test result : "
-              << "\"" << result << "\"";
-  } else {
+  if (!success) {
     DLOG(ERROR) << "Failed to evaluate test: "
                 << "\"" << result << "\"";
   }
 }
 
-TEST_F(URLTestWithJavaScript, ConstructorWithInvalidBase) {
+TEST_P(URLTestWithJavaScript, ConstructorWithInvalidBase) {
   std::string result;
   bool success = EvaluateScript(
       "let result = 'unknown';"
@@ -142,16 +138,13 @@
   EXPECT_TRUE(success);
   EXPECT_EQ("TypeError", result);
 
-  if (success) {
-    LOG(INFO) << "Test result : "
-              << "\"" << result << "\"";
-  } else {
+  if (!success) {
     DLOG(ERROR) << "Failed to evaluate test: "
                 << "\"" << result << "\"";
   }
 }
 
-TEST_F(URLTestWithJavaScript, ConstructorWithInvalidURL) {
+TEST_P(URLTestWithJavaScript, ConstructorWithInvalidURL) {
   std::string result;
   bool success = EvaluateScript(
       "let result = 'unknown';"
@@ -165,14 +158,46 @@
   EXPECT_TRUE(success);
   EXPECT_EQ("TypeError", result);
 
-  if (success) {
-    LOG(INFO) << "Test result : "
-              << "\"" << result << "\"";
-  } else {
+  if (!success) {
     DLOG(ERROR) << "Failed to evaluate test: "
                 << "\"" << result << "\"";
   }
 }
 
+TEST_P(URLTestWithJavaScript, CreateObjectURL) {
+  std::string result;
+  bool success = EvaluateScript(
+      "let result = 'unknown';"
+      "function assert(condition, message) {"
+      "  if (!condition) {"
+      "    throw new Error(message || \"Assertion failed\");"
+      "  }"
+      "}"
+      "try {"
+      "  var blob = new Blob([\" TEST \"]);"
+      "  assert(blob.size == 6, \'Blob has wrong size\');"
+      "  var url = URL.createObjectURL(blob);"
+      "  result = url;"
+      "} catch (e) {"
+      "  result = e;"
+      "}"
+      "result;",
+      &result);
+  EXPECT_TRUE(success);
+  EXPECT_GT(result.length(), 5U);
+  EXPECT_TRUE(Value(result, ::testing::StartsWith("blob:")));
+
+  if (!success) {
+    DLOG(ERROR) << "Failed to evaluate test: "
+                << "\"" << result << "\"";
+  }
+}
+
+INSTANTIATE_TEST_CASE_P(
+    URLTestsWithJavaScript, URLTestWithJavaScript,
+    ::testing::ValuesIn(testing::TestWebWithJavaScript::GetWorkerTypes()),
+    testing::TestWebWithJavaScript::GetTypeName);
+
+
 }  // namespace web
 }  // namespace cobalt
diff --git a/cobalt/web/window_or_worker_global_scope.cc b/cobalt/web/window_or_worker_global_scope.cc
index baa40ac..26cfeff 100644
--- a/cobalt/web/window_or_worker_global_scope.cc
+++ b/cobalt/web/window_or_worker_global_scope.cc
@@ -39,6 +39,10 @@
   return GetWrappableType() == base::GetTypeId<dom::Window>();
 }
 
+bool WindowOrWorkerGlobalScope::IsWorker() {
+  return IsDedicatedWorker() || IsServiceWorker();
+}
+
 bool WindowOrWorkerGlobalScope::IsDedicatedWorker() {
   return GetWrappableType() ==
          base::GetTypeId<worker::DedicatedWorkerGlobalScope>();
diff --git a/cobalt/web/window_or_worker_global_scope.h b/cobalt/web/window_or_worker_global_scope.h
index 2fd0294..6f079ca 100644
--- a/cobalt/web/window_or_worker_global_scope.h
+++ b/cobalt/web/window_or_worker_global_scope.h
@@ -32,6 +32,7 @@
 class Window;
 }  // namespace dom
 namespace worker {
+class WorkerGlobalScope;
 class DedicatedWorkerGlobalScope;
 class ServiceWorkerGlobalScope;
 }  // namespace worker
@@ -54,10 +55,12 @@
   NavigatorBase* navigator_base() { return navigator_base_; }
 
   bool IsWindow();
+  bool IsWorker();
   bool IsDedicatedWorker();
   bool IsServiceWorker();
 
   virtual dom::Window* AsWindow() { return nullptr; }
+  virtual worker::WorkerGlobalScope* AsWorker() { return nullptr; }
   virtual worker::DedicatedWorkerGlobalScope* AsDedicatedWorker() {
     return nullptr;
   }
diff --git a/cobalt/web/window_timers_test.cc b/cobalt/web/window_timers_test.cc
index d4a4ee7..f389997 100644
--- a/cobalt/web/window_timers_test.cc
+++ b/cobalt/web/window_timers_test.cc
@@ -43,9 +43,13 @@
  public:
   MOCK_CONST_METHOD0(Run, script::CallbackResult<void>());
   void ExpectRunCall(int times) {
-    EXPECT_CALL(*this, Run())
-        .Times(times)
-        .WillRepeatedly(Return(script::CallbackResult<void>()));
+    if (!times) {
+      EXPECT_CALL(*this, Run()).Times(times);
+    } else {
+      EXPECT_CALL(*this, Run())
+          .Times(times)
+          .WillRepeatedly(Return(script::CallbackResult<void>()));
+    }
   }
 };
 
diff --git a/cobalt/websocket/web_socket_impl_test.cc b/cobalt/websocket/web_socket_impl_test.cc
index ebbe3fc..66da04c 100644
--- a/cobalt/websocket/web_socket_impl_test.cc
+++ b/cobalt/websocket/web_socket_impl_test.cc
@@ -63,10 +63,9 @@
 
  protected:
   WebSocketImplTest() : web_context_(new web::testing::StubWebContext()) {
-    web_context_->set_network_module(new network::NetworkModule());
     web_context_->setup_environment_settings(
         new dom::testing::StubEnvironmentSettings());
-    web_context_->environment_settings()->set_base_url(
+    web_context_->environment_settings()->set_creation_url(
         GURL("https://127.0.0.1:1234"));
     std::vector<std::string> sub_protocols;
     sub_protocols.push_back("chat");
diff --git a/cobalt/websocket/web_socket_test.cc b/cobalt/websocket/web_socket_test.cc
index 18c47b3..0547e88 100644
--- a/cobalt/websocket/web_socket_test.cc
+++ b/cobalt/websocket/web_socket_test.cc
@@ -19,13 +19,12 @@
 
 #include "base/memory/ref_counted.h"
 #include "cobalt/base/polymorphic_downcast.h"
-#include "cobalt/dom/testing/stub_environment_settings.h"
+#include "cobalt/dom/testing/test_with_javascript.h"
 #include "cobalt/dom/window.h"
 #include "cobalt/script/script_exception.h"
 #include "cobalt/script/testing/mock_exception_state.h"
 #include "cobalt/web/context.h"
 #include "cobalt/web/dom_exception.h"
-#include "cobalt/web/testing/stub_web_context.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using cobalt::script::testing::MockExceptionState;
@@ -36,35 +35,29 @@
 namespace cobalt {
 namespace websocket {
 
-class WebSocketTest : public ::testing::Test {
+class WebSocketTest : public dom::testing::TestWithJavaScript {
  public:
-  web::EnvironmentSettings* settings() const {
-    return web_context_->environment_settings();
+  web::EnvironmentSettings* settings() {
+    return window()->environment_settings();
   }
 
  protected:
-  WebSocketTest() : web_context_(new web::testing::StubWebContext()) {
-    web_context_->set_network_module(new network::NetworkModule());
-    web_context_->setup_environment_settings(
-        new dom::testing::StubEnvironmentSettings());
-    web_context_->environment_settings()->set_base_url(
-        GURL("https://example.com"));
+  WebSocketTest() {
+    settings()->set_creation_url(GURL("https://example.com"));
+    window()->location()->set_url(settings()->creation_url());
   }
-
-  std::unique_ptr<web::testing::StubWebContext> web_context_;
-  StrictMock<MockExceptionState> exception_state_;
 };
 
 TEST_F(WebSocketTest, BadOrigin) {
   scoped_refptr<script::ScriptException> exception;
 
-  settings()->set_base_url(GURL());
+  window()->location()->set_url(GURL());
 
-  EXPECT_CALL(exception_state_, SetException(_))
+  EXPECT_CALL(*exception_state(), SetException(_))
       .WillOnce(SaveArg<0>(&exception));
 
   scoped_refptr<WebSocket> ws(
-      new WebSocket(settings(), "ws://example.com", &exception_state_, false));
+      new WebSocket(settings(), "ws://example.com", exception_state(), false));
 
   ASSERT_TRUE(exception.get());
   web::DOMException& dom_exception(
@@ -83,35 +76,35 @@
       {"https://example.com/", "https://example.com/"},
       {"https://exAMPle.com/", "https://example.com/"},
   };
-  scoped_refptr<script::ScriptException> exception;
+
+  EXPECT_CALL(*exception_state(), SetException(_)).Times(0);
 
   for (std::size_t i(0); i != ARRAYSIZE_UNSAFE(origin_test_cases); ++i) {
     const OriginTestCase& test_case(origin_test_cases[i]);
     std::string new_base = test_case.input_base_url;
-    settings()->set_base_url(GURL(new_base));
+    window()->location()->set_url(GURL(new_base));
 
     scoped_refptr<WebSocket> ws(new WebSocket(settings(), "ws://example.com",
-                                              &exception_state_, false));
+                                              exception_state(), false));
 
-    ASSERT_FALSE(exception.get());
     EXPECT_EQ(ws->entry_script_origin_, test_case.expected_output);
   }
 }
 
 TEST_F(WebSocketTest, TestInitialReadyState) {
   scoped_refptr<WebSocket> ws(
-      new WebSocket(settings(), "ws://example.com", &exception_state_, false));
+      new WebSocket(settings(), "ws://example.com", exception_state(), false));
   EXPECT_EQ(ws->ready_state(), WebSocket::kConnecting);
 }
 
 TEST_F(WebSocketTest, SyntaxErrorWhenBadScheme) {
   scoped_refptr<script::ScriptException> exception;
 
-  EXPECT_CALL(exception_state_, SetException(_))
+  EXPECT_CALL(*exception_state(), SetException(_))
       .WillOnce(SaveArg<0>(&exception));
 
   scoped_refptr<WebSocket> ws(new WebSocket(
-      settings(), "badscheme://example.com", &exception_state_, false));
+      settings(), "badscheme://example.com", exception_state(), false));
 
   web::DOMException& dom_exception(
       *base::polymorphic_downcast<web::DOMException*>(exception.get()));
@@ -124,24 +117,24 @@
 }
 
 TEST_F(WebSocketTest, ParseWsAndWssCorrectly) {
-  EXPECT_CALL(exception_state_, SetException(_)).Times(0);
+  EXPECT_CALL(*exception_state(), SetException(_)).Times(0);
   scoped_refptr<WebSocket> ws(
-      new WebSocket(settings(), "ws://example.com/", &exception_state_, false));
+      new WebSocket(settings(), "ws://example.com/", exception_state(), false));
 
-  EXPECT_CALL(exception_state_, SetException(_)).Times(0);
+  EXPECT_CALL(*exception_state(), SetException(_)).Times(0);
   scoped_refptr<WebSocket> wss(
-      new WebSocket(settings(), "wss://example.com", &exception_state_, false));
+      new WebSocket(settings(), "wss://example.com", exception_state(), false));
 }
 
 TEST_F(WebSocketTest, CheckSecure) {
-  EXPECT_CALL(exception_state_, SetException(_)).Times(0);
+  EXPECT_CALL(*exception_state(), SetException(_)).Times(0);
   scoped_refptr<WebSocket> ws(
-      new WebSocket(settings(), "ws://example.com/", &exception_state_, false));
+      new WebSocket(settings(), "ws://example.com/", exception_state(), false));
   EXPECT_FALSE(ws->IsSecure());
 
-  EXPECT_CALL(exception_state_, SetException(_)).Times(0);
+  EXPECT_CALL(*exception_state(), SetException(_)).Times(0);
   scoped_refptr<WebSocket> wss(
-      new WebSocket(settings(), "wss://example.com", &exception_state_, false));
+      new WebSocket(settings(), "wss://example.com", exception_state(), false));
 
   EXPECT_TRUE(wss->IsSecure());
 }
@@ -150,11 +143,11 @@
 TEST_F(WebSocketTest, SyntaxErrorWhenRelativeUrl) {
   scoped_refptr<script::ScriptException> exception;
 
-  EXPECT_CALL(exception_state_, SetException(_))
+  EXPECT_CALL(*exception_state(), SetException(_))
       .WillOnce(SaveArg<0>(&exception));
 
   scoped_refptr<WebSocket> ws(
-      new WebSocket(settings(), "relative_url", &exception_state_, false));
+      new WebSocket(settings(), "relative_url", exception_state(), false));
 
   web::DOMException& dom_exception(
       *base::polymorphic_downcast<web::DOMException*>(exception.get()));
@@ -168,11 +161,11 @@
 TEST_F(WebSocketTest, URLHasFragments) {
   scoped_refptr<script::ScriptException> exception;
 
-  EXPECT_CALL(exception_state_, SetException(_))
+  EXPECT_CALL(*exception_state(), SetException(_))
       .WillOnce(SaveArg<0>(&exception));
 
   scoped_refptr<WebSocket> ws(new WebSocket(
-      settings(), "wss://example.com/#fragment", &exception_state_, false));
+      settings(), "wss://example.com/#fragment", exception_state(), false));
 
   web::DOMException& dom_exception(
       *base::polymorphic_downcast<web::DOMException*>(exception.get()));
@@ -185,7 +178,7 @@
 
 TEST_F(WebSocketTest, URLHasPort) {
   scoped_refptr<WebSocket> ws(new WebSocket(settings(), "wss://example.com:789",
-                                            &exception_state_, false));
+                                            exception_state(), false));
 
   EXPECT_EQ(ws->GetPort(), 789);
   EXPECT_EQ(ws->GetPortAsString(), "789");
@@ -197,13 +190,13 @@
   // otherwise let port be 443.
 
   scoped_refptr<WebSocket> ws(
-      new WebSocket(settings(), "ws://example.com", &exception_state_, false));
+      new WebSocket(settings(), "ws://example.com", exception_state(), false));
 
   EXPECT_EQ(ws->GetPort(), 80);
   EXPECT_EQ(ws->GetPortAsString(), "80");
 
   scoped_refptr<WebSocket> wss(
-      new WebSocket(settings(), "wss://example.com", &exception_state_, false));
+      new WebSocket(settings(), "wss://example.com", exception_state(), false));
 
   EXPECT_EQ(wss->GetPort(), 443);
   EXPECT_EQ(wss->GetPortAsString(), "443");
@@ -214,7 +207,7 @@
   // Let host be the value of the <host> component of url, converted to ASCII
   // lowercase.
   scoped_refptr<WebSocket> ws(
-      new WebSocket(settings(), "wss://eXAmpLe.com", &exception_state_, false));
+      new WebSocket(settings(), "wss://eXAmpLe.com", exception_state(), false));
 
   std::string host(ws->GetHost());
   EXPECT_EQ(host, "example.com");
@@ -226,7 +219,7 @@
   // empty) of
   // url.
   scoped_refptr<WebSocket> ws(new WebSocket(
-      settings(), "ws://eXAmpLe.com/resource_name", &exception_state_, false));
+      settings(), "ws://eXAmpLe.com/resource_name", exception_state(), false));
 
   std::string resource_name(ws->GetResourceName());
   EXPECT_EQ(resource_name, "/resource_name");
@@ -237,7 +230,7 @@
   // If resource name is the empty string, set it to a single character U+002F
   // SOLIDUS (/).
   scoped_refptr<WebSocket> ws(
-      new WebSocket(settings(), "ws://example.com", &exception_state_, false));
+      new WebSocket(settings(), "ws://example.com", exception_state(), false));
 
   std::string resource_name(ws->GetResourceName());
   EXPECT_EQ(resource_name, "/");
@@ -250,7 +243,7 @@
   // component.
   scoped_refptr<WebSocket> ws(
       new WebSocket(settings(), "ws://example.com/resource_name?abc=xyz&j=3",
-                    &exception_state_, false));
+                    exception_state(), false));
 
   std::string resource_name(ws->GetResourceName());
   EXPECT_EQ(resource_name, "/resource_name?abc=xyz&j=3");
@@ -259,11 +252,11 @@
 TEST_F(WebSocketTest, FailInsecurePort) {
   scoped_refptr<script::ScriptException> exception;
 
-  EXPECT_CALL(exception_state_, SetException(_))
+  EXPECT_CALL(*exception_state(), SetException(_))
       .WillOnce(SaveArg<0>(&exception));
 
   scoped_refptr<WebSocket> ws(new WebSocket(settings(), "ws://example.com:22",
-                                            &exception_state_, false));
+                                            exception_state(), false));
 
   web::DOMException& dom_exception(
       *base::polymorphic_downcast<web::DOMException*>(exception.get()));
@@ -300,13 +293,13 @@
 
     scoped_refptr<script::ScriptException> exception;
     if (test_case.exception_thrown) {
-      EXPECT_CALL(exception_state_, SetException(_))
+      EXPECT_CALL(*exception_state(), SetException(_))
           .WillOnce(SaveArg<0>(&exception));
     }
 
     scoped_refptr<WebSocket> ws(new WebSocket(settings(), "ws://example.com",
                                               test_case.sub_protocol,
-                                              &exception_state_, false));
+                                              exception_state(), false));
 
     if (test_case.exception_thrown) {
       web::DOMException& dom_exception(
@@ -325,7 +318,7 @@
     sub_protocols.push_back("chat.example.com");
     sub_protocols.push_back("bicker.example.com");
     scoped_refptr<WebSocket> ws(new WebSocket(settings(), "ws://example.com",
-                                              sub_protocols, &exception_state_,
+                                              sub_protocols, exception_state(),
                                               false));
 
     ASSERT_FALSE(exception.get());
@@ -334,7 +327,7 @@
     scoped_refptr<script::ScriptException> exception;
     std::string sub_protocol("chat");
     scoped_refptr<WebSocket> ws(new WebSocket(settings(), "ws://example.com",
-                                              sub_protocol, &exception_state_,
+                                              sub_protocol, exception_state(),
                                               false));
 
     ASSERT_FALSE(exception.get());
@@ -344,13 +337,13 @@
 TEST_F(WebSocketTest, DuplicatedSubProtocols) {
   scoped_refptr<script::ScriptException> exception;
 
-  EXPECT_CALL(exception_state_, SetException(_))
+  EXPECT_CALL(*exception_state(), SetException(_))
       .WillOnce(SaveArg<0>(&exception));
   std::vector<std::string> sub_protocols;
   sub_protocols.push_back("chat");
   sub_protocols.push_back("chat");
   scoped_refptr<WebSocket> ws(new WebSocket(
-      settings(), "ws://example.com", sub_protocols, &exception_state_, false));
+      settings(), "ws://example.com", sub_protocols, exception_state(), false));
 
   ASSERT_TRUE(exception.get());
 
diff --git a/cobalt/worker/service_worker_object.cc b/cobalt/worker/service_worker_object.cc
index d442ff1..193638b 100644
--- a/cobalt/worker/service_worker_object.cc
+++ b/cobalt/worker/service_worker_object.cc
@@ -163,7 +163,7 @@
   //      origin to an implementation-defined value, target browsing context to
   //      null, and active service worker to null.
   web_context_->setup_environment_settings(new WorkerSettings());
-  web_context_->environment_settings()->set_base_url(script_url_);
+  web_context_->environment_settings()->set_creation_url(script_url_);
   scoped_refptr<ServiceWorkerGlobalScope> service_worker_global_scope =
       new ServiceWorkerGlobalScope(web_context_->environment_settings(), this);
   worker_global_scope_ = service_worker_global_scope;
@@ -186,8 +186,7 @@
 #endif  // ENABLE_DEBUGGER
 
   // 8.5. Set workerGlobalScope’s url to serviceWorker’s script url.
-  worker_global_scope_->set_url(
-      web_context_->environment_settings()->base_url());
+  worker_global_scope_->set_url(script_url_);
   // 8.6. Set workerGlobalScope’s policy container to serviceWorker’s script
   //      resource’s policy container.
   // 8.7. Set workerGlobalScope’s type to serviceWorker’s type.
diff --git a/cobalt/worker/testing/BUILD.gn b/cobalt/worker/testing/BUILD.gn
index fbce0cf..e91994b 100644
--- a/cobalt/worker/testing/BUILD.gn
+++ b/cobalt/worker/testing/BUILD.gn
@@ -24,6 +24,7 @@
     "//cobalt/base",
     "//cobalt/browser:bindings",
     "//cobalt/loader",
+    "//cobalt/network",
     "//cobalt/script",
     "//cobalt/web",
     "//cobalt/web:dom_exception",
diff --git a/cobalt/worker/testing/test_with_javascript.h b/cobalt/worker/testing/test_with_javascript.h
index be37e56..f6499d5 100644
--- a/cobalt/worker/testing/test_with_javascript.h
+++ b/cobalt/worker/testing/test_with_javascript.h
@@ -21,6 +21,7 @@
 
 #include "base/logging.h"
 #include "cobalt/base/type_id.h"
+#include "cobalt/network/network_module.h"
 #include "cobalt/script/exception_message.h"
 #include "cobalt/script/exception_state.h"
 #include "cobalt/script/global_environment.h"
@@ -43,10 +44,8 @@
  public:
   TestWithJavaScriptBase() {
     web_context_.reset(new web::testing::StubWebContext());
-    web_context_->set_network_module(new network::NetworkModule());
     web_context_->setup_environment_settings(new WorkerSettings());
-    web_context_->environment_settings()->set_base_url(GURL("about:blank"));
-    web_context_->set_fetcher_factory(new loader::FetcherFactory(NULL));
+    web_context_->environment_settings()->set_creation_url(GURL("about:blank"));
 
     if (TypeIdProvider::GetGlobalScopeTypeId() ==
         base::GetTypeId<DedicatedWorkerGlobalScope>()) {
@@ -73,18 +72,33 @@
     }
   }
 
+  ~TestWithJavaScriptBase() { ClearWebContext(); }
+
+  void ClearWebContext() {
+    dedicated_worker_global_scope_ = nullptr;
+    service_worker_object_ = nullptr;
+    containing_service_worker_registration_ = nullptr;
+    service_worker_global_scope_ = nullptr;
+    worker_global_scope_ = nullptr;
+    web_context_.reset();
+  }
+
   WorkerGlobalScope* worker_global_scope() { return worker_global_scope_; }
 
+  virtual scoped_refptr<script::GlobalEnvironment> global_environment() {
+    return web_context_->global_environment();
+  }
+
   bool EvaluateScript(const std::string& js_code, std::string* result) {
-    DCHECK(web_context_->global_environment());
+    DCHECK(this->global_environment());
     scoped_refptr<script::SourceCode> source_code =
         script::SourceCode::CreateSourceCode(
             js_code, base::SourceLocation(__FILE__, __LINE__, 1));
 
-    web_context_->global_environment()->EnableEval();
-    web_context_->global_environment()->SetReportEvalCallback(base::Closure());
+    this->global_environment()->EnableEval();
+    this->global_environment()->SetReportEvalCallback(base::Closure());
     bool succeeded =
-        web_context_->global_environment()->EvaluateScript(source_code, result);
+        this->global_environment()->EvaluateScript(source_code, result);
     return succeeded;
   }
 
@@ -132,6 +146,15 @@
         base::GetTypeId<ServiceWorkerGlobalScope>()};
     return worker_types;
   }
+  static std::string GetTypeName(::testing::TestParamInfo<base::TypeId> info) {
+    if (info.param == base::GetTypeId<DedicatedWorkerGlobalScope>()) {
+      return "DedicatedWorkerGlobalScope";
+    }
+    if (info.param == base::GetTypeId<ServiceWorkerGlobalScope>()) {
+      return "ServiceWorkerGlobalScope";
+    }
+    return "Unknown";
+  }
 };
 
 // Helper classes for running TEST_F() tests on only one type of worker.
diff --git a/cobalt/worker/worker.cc b/cobalt/worker/worker.cc
index 3414b2e..495a95d 100644
--- a/cobalt/worker/worker.cc
+++ b/cobalt/worker/worker.cc
@@ -72,7 +72,7 @@
 Worker::~Worker() { Abort(); }
 
 void Worker::Initialize(web::Context* context) {
-  // Algorithm for 'run a worker'
+  // Algorithm for 'run a worker':
   //   https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#run-a-worker
   // 7. Let realm execution context be the result of creating a new
   //    JavaScript realm given agent and the following customizations:
@@ -80,11 +80,13 @@
   //    . For the global object, if is shared is true, create a new
   //      SharedWorkerGlobalScope object. Otherwise, create a new
   //      DedicatedWorkerGlobalScope object.
-  // TODO: Actual type here should depend on derived class (e.g. dedicated,
-  // shared, service)
   web_context_->setup_environment_settings(
       new WorkerSettings(options_.outside_port));
-  web_context_->environment_settings()->set_base_url(options_.url);
+  // From algorithm for to setup up a worker environment settings object:
+  //   https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#set-up-a-worker-environment-settings-object
+  // 5. Set settings object's creation URL to worker global scope's url.
+  web_context_->environment_settings()->set_creation_url(options_.url);
+  // Continue algorithm for 'run a worker'.
   // 8. Let worker global scope be the global object of realm execution
   //    context's Realm component.
   scoped_refptr<DedicatedWorkerGlobalScope> dedicated_worker_global_scope =
@@ -148,7 +150,7 @@
   //     1. Set request's reserved client to inside settings.
   //     2. Fetch request, and asynchronously wait to run the remaining steps as
   //        part of fetch's process response for the response response.
-  const GURL& url = web_context_->environment_settings()->base_url();
+  const GURL& url = web_context_->environment_settings()->creation_url();
   loader::Origin origin = loader::Origin(url.GetOrigin());
 
   // Todo: implement csp check (b/225037465)
@@ -167,7 +169,7 @@
   DCHECK(content);
   // 14.3. "Set worker global scope's url to response's url."
   worker_global_scope_->set_url(
-      web_context_->environment_settings()->base_url());
+      web_context_->environment_settings()->creation_url());
   // 14.4 - 14.10 initialize worker global scope
   worker_global_scope_->Initialize();
   // 14.11. Asynchronously complete the perform the fetch steps with response.
diff --git a/cobalt/worker/worker_global_scope.h b/cobalt/worker/worker_global_scope.h
index 72e1bab..f4e2291 100644
--- a/cobalt/worker/worker_global_scope.h
+++ b/cobalt/worker/worker_global_scope.h
@@ -74,7 +74,7 @@
 
   void set_url(const GURL& url) { url_ = url; }
 
-  const GURL Url() const { return url_; }
+  const GURL& Url() const { return url_; }
 
   const web::EventTargetListenerInfo::EventListenerScriptValue*
   onlanguagechange() {
@@ -106,6 +106,10 @@
                               event_listener);
   }
 
+  // From web::WindowOrWorkerGlobalScope
+  //
+  WorkerGlobalScope* AsWorker() override { return this; }
+
   // Custom, not in any spec.
   //
   bool LoadImportsAndReturnIfUpdated(
diff --git a/cobalt/worker/worker_global_scope_test.cc b/cobalt/worker/worker_global_scope_test.cc
index efa6207..67ee3ed 100644
--- a/cobalt/worker/worker_global_scope_test.cc
+++ b/cobalt/worker/worker_global_scope_test.cc
@@ -312,7 +312,8 @@
 
 INSTANTIATE_TEST_CASE_P(
     WorkerGlobalScopeTests, WorkerGlobalScopeTest,
-    ::testing::ValuesIn(testing::TestWorkersWithJavaScript::GetWorkerTypes()));
+    ::testing::ValuesIn(testing::TestWorkersWithJavaScript::GetWorkerTypes()),
+    testing::TestWorkersWithJavaScript::GetTypeName);
 
 }  // namespace worker
 }  // namespace cobalt
diff --git a/cobalt/worker/worker_navigator_test.cc b/cobalt/worker/worker_navigator_test.cc
index 49e4b47..31b6340 100644
--- a/cobalt/worker/worker_navigator_test.cc
+++ b/cobalt/worker/worker_navigator_test.cc
@@ -93,7 +93,8 @@
 
 INSTANTIATE_TEST_CASE_P(
     WorkerNavigatorTests, WorkerNavigatorTest,
-    ::testing::ValuesIn(testing::TestWorkersWithJavaScript::GetWorkerTypes()));
+    ::testing::ValuesIn(testing::TestWorkersWithJavaScript::GetWorkerTypes()),
+    testing::TestWorkersWithJavaScript::GetTypeName);
 
 }  // namespace worker
 }  // namespace cobalt
diff --git a/cobalt/worker/worker_settings.cc b/cobalt/worker/worker_settings.cc
index 3c730e3..8e53e10 100644
--- a/cobalt/worker/worker_settings.cc
+++ b/cobalt/worker/worker_settings.cc
@@ -14,10 +14,15 @@
 
 #include "cobalt/worker/worker_settings.h"
 
+#include "base/logging.h"
 #include "cobalt/base/debugger_hooks.h"
 #include "cobalt/script/environment_settings.h"
 #include "cobalt/script/global_environment.h"
 #include "cobalt/script/javascript_engine.h"
+#include "cobalt/web/context.h"
+#include "cobalt/web/environment_settings.h"
+#include "cobalt/web/window_or_worker_global_scope.h"
+#include "cobalt/worker/worker_global_scope.h"
 #include "url/gurl.h"
 
 namespace cobalt {
@@ -26,5 +31,18 @@
 
 WorkerSettings::WorkerSettings(web::MessagePort* message_port)
     : web::EnvironmentSettings(), message_port_(message_port) {}
+
+const GURL& WorkerSettings::base_url() const {
+  // From algorithm for to setup up a worker environment settings object:
+  //   https://html.spec.whatwg.org/commit-snapshots/465a6b672c703054de278b0f8133eb3ad33d93f4/#set-up-a-worker-environment-settings-object
+  // 3. Let settings object be a new environment settings object whose
+  //    algorithms are defined as follows:
+  //    The API base URL
+  //    Return worker global scope's url.
+  DCHECK(context()->GetWindowOrWorkerGlobalScope()->IsWorker());
+  return context()->GetWindowOrWorkerGlobalScope()->AsWorker()->Url();
+}
+
+
 }  // namespace worker
 }  // namespace cobalt
diff --git a/cobalt/worker/worker_settings.h b/cobalt/worker/worker_settings.h
index 99fae7f..b2d7097 100644
--- a/cobalt/worker/worker_settings.h
+++ b/cobalt/worker/worker_settings.h
@@ -33,6 +33,10 @@
 
   web::MessagePort* message_port() const { return message_port_; }
 
+  // From: script::EnvironmentSettings
+  //
+  const GURL& base_url() const override;
+
  private:
   // Outer message port.
   web::MessagePort* message_port_ = nullptr;
diff --git a/cobalt/xhr/global_stats.cc b/cobalt/xhr/global_stats.cc
index d6dd0f7..fbbb9b6 100644
--- a/cobalt/xhr/global_stats.cc
+++ b/cobalt/xhr/global_stats.cc
@@ -31,7 +31,11 @@
 
 GlobalStats::~GlobalStats() {}
 
-bool GlobalStats::CheckNoLeaks() { return num_xhrs_ == 0 && xhr_memory_ == 0; }
+bool GlobalStats::CheckNoLeaks() {
+  DCHECK(num_xhrs_ == 0);
+  DCHECK(xhr_memory_ == 0);
+  return num_xhrs_ == 0 && xhr_memory_ == 0;
+}
 
 void GlobalStats::Add(xhr::XMLHttpRequest* object) { ++num_xhrs_; }
 
diff --git a/cobalt/xhr/xml_http_request.cc b/cobalt/xhr/xml_http_request.cc
index 831b5cb..6f16335 100644
--- a/cobalt/xhr/xml_http_request.cc
+++ b/cobalt/xhr/xml_http_request.cc
@@ -161,73 +161,236 @@
       new dom::ProgressEvent(event_name, loaded, total, length_computable));
 }
 
+#if !defined(COBALT_BUILD_TYPE_GOLD)
 int s_xhr_sequence_num_ = 0;
+#endif  // !defined(COBALT_BUILD_TYPE_GOLD)
 // https://fetch.spec.whatwg.org/#concept-http-redirect-fetch
 // 5. If request's redirect count is twenty, return a network error.
 const int kRedirectLimit = 20;
 
 }  // namespace
 
-bool XMLHttpRequest::verbose_ = false;
+bool XMLHttpRequestImpl::verbose_ = false;
 
 XMLHttpRequest::XMLHttpRequest(script::EnvironmentSettings* settings)
-    : XMLHttpRequestEventTarget(settings),
-      response_body_(new URLFetcherResponseWriter::Buffer(
-          URLFetcherResponseWriter::Buffer::kString)),
-      settings_(base::polymorphic_downcast<dom::DOMSettings*>(settings)),
-      state_(kUnsent),
-      response_type_(kDefault),
-      timeout_ms_(0),
-      method_(net::URLFetcher::GET),
-      http_status_(0),
-      with_credentials_(false),
-      error_(false),
-      sent_(false),
-      stop_timeout_(false),
-      upload_complete_(false),
-      active_requests_count_(0),
-      upload_listener_(false),
-      is_cross_origin_(false),
-      is_redirect_(false),
-      redirect_times_(0),
-      is_data_url_(false) {
-  DCHECK(settings_);
+    : XMLHttpRequestEventTarget(settings) {
+  // Determine which implementation of XHR to use based on being in a window or
+  // worker.
+  if (environment_settings()
+          ->context()
+          ->GetWindowOrWorkerGlobalScope()
+          ->IsWindow()) {
+    xhr_impl_ = std::make_unique<DOMXMLHttpRequestImpl>(this);
+  } else if (environment_settings()
+                 ->context()
+                 ->GetWindowOrWorkerGlobalScope()
+                 ->IsDedicatedWorker() ||
+             environment_settings()
+                 ->context()
+                 ->GetWindowOrWorkerGlobalScope()
+                 ->IsServiceWorker()) {
+    xhr_impl_ = std::make_unique<XMLHttpRequestImpl>(this);
+  }
   xhr::GlobalStats::GetInstance()->Add(this);
+#if !defined(COBALT_BUILD_TYPE_GOLD)
   xhr_id_ = ++s_xhr_sequence_num_;
+#endif  // !defined(COBALT_BUILD_TYPE_GOLD)
 }
 
-void XMLHttpRequest::Abort() {
+XMLHttpRequest::~XMLHttpRequest() {
+  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
+  xhr::GlobalStats::GetInstance()->Remove(this);
+}
+
+void XMLHttpRequest::Abort() { xhr_impl_->Abort(); }
+void XMLHttpRequest::Open(const std::string& method, const std::string& url,
+                          bool async,
+                          const base::Optional<std::string>& username,
+                          const base::Optional<std::string>& password,
+                          script::ExceptionState* exception_state) {
+  xhr_impl_->Open(method, url, async, username, password, exception_state);
+}
+
+// Must be called after open(), but before send().
+void XMLHttpRequest::SetRequestHeader(const std::string& header,
+                                      const std::string& value,
+                                      script::ExceptionState* exception_state) {
+  xhr_impl_->SetRequestHeader(header, value, exception_state);
+}
+
+// Override the MIME type returned by the server.
+// Call before Send(), otherwise throws InvalidStateError.
+void XMLHttpRequest::OverrideMimeType(const std::string& mime_type,
+                                      script::ExceptionState* exception_state) {
+  xhr_impl_->OverrideMimeType(mime_type, exception_state);
+}
+
+void XMLHttpRequest::Send(const base::Optional<RequestBodyType>& request_body,
+                          script::ExceptionState* exception_state) {
+  xhr_impl_->Send(request_body, exception_state);
+}
+
+void XMLHttpRequest::Fetch(const FetchUpdateCallbackArg& fetch_callback,
+                           const FetchModeCallbackArg& fetch_mode_callback,
+                           const base::Optional<RequestBodyType>& request_body,
+                           script::ExceptionState* exception_state) {
+  xhr_impl_->Fetch(fetch_callback, fetch_mode_callback, request_body,
+                   exception_state);
+}
+
+base::Optional<std::string> XMLHttpRequest::GetResponseHeader(
+    const std::string& header) {
+  return xhr_impl_->GetResponseHeader(header);
+}
+std::string XMLHttpRequest::GetAllResponseHeaders() {
+  return xhr_impl_->GetAllResponseHeaders();
+}
+
+const std::string& XMLHttpRequest::response_text(
+    script::ExceptionState* exception_state) {
+  return xhr_impl_->response_text(exception_state);
+}
+scoped_refptr<dom::Document> XMLHttpRequest::response_xml(
+    script::ExceptionState* exception_state) {
+  return xhr_impl_->response_xml(exception_state);
+}
+base::Optional<XMLHttpRequest::ResponseType> XMLHttpRequest::response(
+    script::ExceptionState* exception_state) {
+  return xhr_impl_->response(exception_state);
+}
+
+int XMLHttpRequest::ready_state() const { return xhr_impl_->ready_state(); }
+int XMLHttpRequest::status() const { return xhr_impl_->status(); }
+std::string XMLHttpRequest::status_text() { return xhr_impl_->status_text(); }
+void XMLHttpRequest::set_response_type(
+    const std::string& response_type, script::ExceptionState* exception_state) {
+  xhr_impl_->set_response_type(response_type, exception_state);
+}
+std::string XMLHttpRequest::response_type(
+    script::ExceptionState* exception_state) const {
+  return xhr_impl_->response_type(exception_state);
+}
+
+uint32 XMLHttpRequest::timeout() const { return xhr_impl_->timeout(); }
+void XMLHttpRequest::set_timeout(uint32 timeout) {
+  xhr_impl_->set_timeout(timeout);
+}
+bool XMLHttpRequest::with_credentials(
+    script::ExceptionState* exception_state) const {
+  return xhr_impl_->with_credentials(exception_state);
+}
+void XMLHttpRequest::set_with_credentials(
+    bool b, script::ExceptionState* exception_state) {
+  xhr_impl_->set_with_credentials(b, exception_state);
+}
+
+scoped_refptr<XMLHttpRequestUpload> XMLHttpRequest::upload() {
+  return xhr_impl_->upload();
+}
+
+void XMLHttpRequest::set_verbose(bool verbose) {
+  XMLHttpRequestImpl::set_verbose(verbose);
+}
+bool XMLHttpRequest::verbose() { return XMLHttpRequestImpl::verbose(); }
+
+// net::URLFetcherDelegate interface
+void XMLHttpRequest::OnURLFetchResponseStarted(const net::URLFetcher* source) {
+  xhr_impl_->OnURLFetchResponseStarted(source);
+}
+void XMLHttpRequest::OnURLFetchDownloadProgress(const net::URLFetcher* source,
+                                                int64_t current, int64_t total,
+                                                int64_t current_network_bytes) {
+  xhr_impl_->OnURLFetchDownloadProgress(source, current, total,
+                                        current_network_bytes);
+}
+void XMLHttpRequest::OnURLFetchComplete(const net::URLFetcher* source) {
+  xhr_impl_->OnURLFetchComplete(source);
+}
+
+void XMLHttpRequest::OnURLFetchUploadProgress(const net::URLFetcher* source,
+                                              int64 current, int64 total) {
+  xhr_impl_->OnURLFetchUploadProgress(source, current, total);
+}
+void XMLHttpRequest::OnRedirect(const net::HttpResponseHeaders& headers) {
+  xhr_impl_->OnRedirect(headers);
+}
+
+// Called from bindings layer to tie objects' lifetimes to this XHR instance.
+XMLHttpRequestUpload* XMLHttpRequest::upload_or_null() {
+  return xhr_impl_->upload_or_null();
+}
+
+void XMLHttpRequest::ReportLoadTimingInfo(
+    const net::LoadTimingInfo& timing_info) {
+  xhr_impl_->ReportLoadTimingInfo(timing_info);
+}
+// Create Performance Resource Timing entry for XMLHttpRequest.
+void XMLHttpRequest::GetLoadTimingInfoAndCreateResourceTiming() {
+  xhr_impl_->GetLoadTimingInfoAndCreateResourceTiming();
+}
+
+void XMLHttpRequest::TraceMembers(script::Tracer* tracer) {
+  XMLHttpRequestEventTarget::TraceMembers(tracer);
+  xhr_impl_->TraceMembers(tracer);
+}
+
+XMLHttpRequestImpl::XMLHttpRequestImpl(XMLHttpRequest* xhr)
+    : error_(false),
+      is_cross_origin_(false),
+      is_data_url_(false),
+      is_redirect_(false),
+      method_(net::URLFetcher::GET),
+      response_body_(new URLFetcherResponseWriter::Buffer(
+          URLFetcherResponseWriter::Buffer::kString)),
+      response_type_(XMLHttpRequest::kDefault),
+      state_(XMLHttpRequest::kUnsent),
+      upload_listener_(false),
+      with_credentials_(false),
+      xhr_(xhr),
+      active_requests_count_(0),
+      http_status_(0),
+      redirect_times_(0),
+      sent_(false),
+      settings_(xhr->environment_settings()),
+      stop_timeout_(false),
+      timeout_ms_(0),
+      upload_complete_(false) {
+  DCHECK(settings_);
+}
+
+void XMLHttpRequestImpl::Abort() {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-abort()-method
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   // Cancel any in-flight request and set error flag.
   TerminateRequest();
-  bool abort_is_no_op =
-      state_ == kUnsent || state_ == kDone || (state_ == kOpened && !sent_);
+  bool abort_is_no_op = state_ == XMLHttpRequest::kUnsent ||
+                        state_ == XMLHttpRequest::kDone ||
+                        (state_ == XMLHttpRequest::kOpened && !sent_);
   if (!abort_is_no_op) {
     sent_ = false;
-    HandleRequestError(kAbortError);
+    HandleRequestError(XMLHttpRequest::kAbortError);
   }
-  ChangeState(kUnsent);
+  ChangeState(XMLHttpRequest::kUnsent);
 
   response_body_->Clear();
   response_array_buffer_reference_.reset();
 }
 
 // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-open()-method
-void XMLHttpRequest::Open(const std::string& method, const std::string& url,
-                          bool async,
-                          const base::Optional<std::string>& username,
-                          const base::Optional<std::string>& password,
-                          script::ExceptionState* exception_state) {
+void XMLHttpRequestImpl::Open(const std::string& method, const std::string& url,
+                              bool async,
+                              const base::Optional<std::string>& username,
+                              const base::Optional<std::string>& password,
+                              script::ExceptionState* exception_state) {
   TRACK_MEMORY_SCOPE("XHR");
 
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
-  State previous_state = state_;
+  XMLHttpRequest::State previous_state = state_;
 
   // Cancel any outstanding request.
   TerminateRequest();
-  state_ = kUnsent;
+  state_ = XMLHttpRequest::kUnsent;
 
   if (!async) {
     DLOG(ERROR) << "synchronous XHR is not supported";
@@ -254,7 +417,7 @@
     return;
   }
 
-  web::CspDelegate* csp = csp_delegate();
+  web::CspDelegate* csp = this->csp_delegate();
   if (csp && !csp->CanLoad(web::CspDelegate::kXhr, request_url_, false)) {
     web::DOMException::Raise(web::DOMException::kSecurityErr, exception_state);
     return;
@@ -267,19 +430,19 @@
 
   // Check previous state to avoid dispatching readyState event when calling
   // open several times in a row.
-  if (previous_state != kOpened) {
-    ChangeState(kOpened);
+  if (previous_state != XMLHttpRequest::kOpened) {
+    ChangeState(XMLHttpRequest::kOpened);
   } else {
-    state_ = kOpened;
+    state_ = XMLHttpRequest::kOpened;
   }
 }
 
-void XMLHttpRequest::SetRequestHeader(const std::string& header,
-                                      const std::string& value,
-                                      script::ExceptionState* exception_state) {
+void XMLHttpRequestImpl::SetRequestHeader(
+    const std::string& header, const std::string& value,
+    script::ExceptionState* exception_state) {
   TRACK_MEMORY_SCOPE("XHR");
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#dom-xmlhttprequest-setrequestheader
-  if (state_ != kOpened || sent_) {
+  if (state_ != XMLHttpRequest::kOpened || sent_) {
     web::DOMException::Raise(web::DOMException::kInvalidStateErr,
                              exception_state);
     return;
@@ -307,11 +470,11 @@
   }
 }
 
-void XMLHttpRequest::OverrideMimeType(const std::string& override_mime,
-                                      script::ExceptionState* exception_state) {
+void XMLHttpRequestImpl::OverrideMimeType(
+    const std::string& override_mime, script::ExceptionState* exception_state) {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#dom-xmlhttprequest-overridemimetype
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  if (state_ == kLoading || state_ == kDone) {
+  if (state_ == XMLHttpRequest::kLoading || state_ == XMLHttpRequest::kDone) {
     web::DOMException::Raise(web::DOMException::kInvalidStateErr,
                              exception_state);
     return;
@@ -332,17 +495,14 @@
   mime_type_override_ = mime_type;
 }
 
-void XMLHttpRequest::Send(script::ExceptionState* exception_state) {
-  Send(base::nullopt, exception_state);
-}
-
-void XMLHttpRequest::Send(const base::Optional<RequestBodyType>& request_body,
-                          script::ExceptionState* exception_state) {
+void XMLHttpRequestImpl::Send(
+    const base::Optional<XMLHttpRequest::RequestBodyType>& request_body,
+    script::ExceptionState* exception_state) {
   TRACK_MEMORY_SCOPE("XHR");
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-send()-method
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   // Step 1
-  if (state_ != kOpened) {
+  if (state_ != XMLHttpRequest::kOpened) {
     web::DOMException::Raise(web::DOMException::kInvalidStateErr,
                              exception_state);
     return;
@@ -398,22 +558,22 @@
   if (upload_) {
     upload_listener_ = upload_->HasOneOrMoreAttributeEventListener();
   }
-  origin_ = settings_->document_origin();
+  origin_ = loader::Origin(settings_->GetOrigin());
   // Step 9
   sent_ = true;
   // Now that a send is happening, prevent this object
   // from being collected until it's complete or aborted
   // if no currently active request has called it before.
   IncrementActiveRequests();
-  FireProgressEvent(this, base::Tokens::loadstart());
+  FireProgressEvent(xhr_, base::Tokens::loadstart());
   if (!upload_complete_) {
     FireProgressEvent(upload_, base::Tokens::loadstart());
   }
 
   // The loadstart callback may abort or modify the XHR request in some way.
   // 11.3. If state is not opened or the send() flag is unset, then return.
-  if (state_ == kOpened && sent_) {
-    StartRequest(request_body_text_);
+  if (state_ == XMLHttpRequest::kOpened && sent_) {
+    this->StartRequest(request_body_text_);
 
     // Start the timeout timer running, if applicable.
     send_start_time_ = base::TimeTicks::Now();
@@ -426,23 +586,25 @@
   }
 }
 
-void XMLHttpRequest::Fetch(const FetchUpdateCallbackArg& fetch_callback,
-                           const FetchModeCallbackArg& fetch_mode_callback,
-                           const base::Optional<RequestBodyType>& request_body,
-                           script::ExceptionState* exception_state) {
+void XMLHttpRequestImpl::Fetch(
+    const FetchUpdateCallbackArg& fetch_callback,
+    const FetchModeCallbackArg& fetch_mode_callback,
+    const base::Optional<XMLHttpRequest::RequestBodyType>& request_body,
+    script::ExceptionState* exception_state) {
   fetch_callback_.reset(
-      new FetchUpdateCallbackArg::Reference(this, fetch_callback));
+      new FetchUpdateCallbackArg::Reference(xhr_, fetch_callback));
   fetch_mode_callback_.reset(
-      new FetchModeCallbackArg::Reference(this, fetch_mode_callback));
+      new FetchModeCallbackArg::Reference(xhr_, fetch_mode_callback));
   Send(request_body, exception_state);
 }
 
-base::Optional<std::string> XMLHttpRequest::GetResponseHeader(
+base::Optional<std::string> XMLHttpRequestImpl::GetResponseHeader(
     const std::string& header) {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-getresponseheader()-method
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
-  if (state_ == kUnsent || state_ == kOpened || error_) {
+  if (state_ == XMLHttpRequest::kUnsent || state_ == XMLHttpRequest::kOpened ||
+      error_) {
     return base::nullopt;
   }
 
@@ -463,12 +625,13 @@
   return found ? base::make_optional(value) : base::nullopt;
 }
 
-std::string XMLHttpRequest::GetAllResponseHeaders() {
+std::string XMLHttpRequestImpl::GetAllResponseHeaders() {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-getallresponseheaders()-method
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   std::string output;
 
-  if (state_ == kUnsent || state_ == kOpened || error_) {
+  if (state_ == XMLHttpRequest::kUnsent || state_ == XMLHttpRequest::kOpened ||
+      error_) {
     return output;
   }
 
@@ -485,21 +648,23 @@
   return output;
 }
 
-const std::string& XMLHttpRequest::response_text(
+const std::string& XMLHttpRequestImpl::response_text(
     script::ExceptionState* exception_state) {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-responsetext-attribute
-  if (response_type_ != kDefault && response_type_ != kText) {
+  if (response_type_ != XMLHttpRequest::kDefault &&
+      response_type_ != XMLHttpRequest::kText) {
     web::DOMException::Raise(web::DOMException::kInvalidStateErr,
                              exception_state);
   }
-  if (error_ || (state_ != kLoading && state_ != kDone)) {
+  if (error_ ||
+      (state_ != XMLHttpRequest::kLoading && state_ != XMLHttpRequest::kDone)) {
     return base::EmptyString();
   }
 
   // Note that the conversion from |response_body_| to std::string when |state_|
   // isn't kDone isn't efficient for large responses.  Fortunately this feature
   // is rarely used.
-  if (state_ == kLoading) {
+  if (state_ == XMLHttpRequest::kLoading) {
     LOG_ONCE(WARNING)
         << "Retrieving responseText while loading can be inefficient.";
     return response_body_->GetTemporaryReferenceOfString();
@@ -508,84 +673,70 @@
 }
 
 // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-responsexml-attribute
-scoped_refptr<dom::Document> XMLHttpRequest::response_xml(
+scoped_refptr<dom::Document> XMLHttpRequestImpl::response_xml(
     script::ExceptionState* exception_state) {
-  // 1. If responseType is not the empty string or "document", throw an
-  // "InvalidStateError" exception.
-  if (response_type_ != kDefault && response_type_ != kDocument) {
-    web::DOMException::Raise(web::DOMException::kInvalidStateErr,
-                             exception_state);
-    return NULL;
-  }
-
-  // 2. If the state is not DONE, return null.
-  if (state_ != kDone) {
-    return NULL;
-  }
-
-  // 3. If the error flag is set, return null.
-  if (error_) {
-    return NULL;
-  }
-
-  // 4. Return the document response entity body.
-  return GetDocumentResponseEntityBody();
+  // Workers don't have access to DOM APIs, including Document objects. Nothing
+  // to do.
+  // https://www.w3.org/TR/2012/CR-workers-20120501/#apis-available-to-workers
+  return NULL;
 }
 
-base::Optional<XMLHttpRequest::ResponseType> XMLHttpRequest::response(
+base::Optional<XMLHttpRequest::ResponseType> XMLHttpRequestImpl::response(
     script::ExceptionState* exception_state) {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#response
   switch (response_type_) {
-    case kDefault:
-    case kText:
-      return ResponseType(response_text(exception_state));
-    case kArrayBuffer: {
+    case XMLHttpRequest::kDefault:
+    case XMLHttpRequest::kText:
+      return XMLHttpRequest::ResponseType(response_text(exception_state));
+    case XMLHttpRequest::kArrayBuffer: {
       script::Handle<script::ArrayBuffer> maybe_array_buffer_response =
           response_array_buffer();
       if (maybe_array_buffer_response.IsEmpty()) {
         return base::nullopt;
       }
-      return ResponseType(maybe_array_buffer_response);
+      return XMLHttpRequest::ResponseType(maybe_array_buffer_response);
     }
-    case kJson:
-    case kDocument:
-    case kBlob:
-    case kResponseTypeCodeMax:
+    case XMLHttpRequest::kJson:
+    case XMLHttpRequest::kDocument:
+    case XMLHttpRequest::kBlob:
+    case XMLHttpRequest::kResponseTypeCodeMax:
       NOTIMPLEMENTED() << "Unsupported response_type_ "
                        << response_type(exception_state);
   }
   return base::nullopt;
 }
 
-int XMLHttpRequest::status() const {
+int XMLHttpRequestImpl::status() const {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-status-attribute
-  if (state_ == kUnsent || state_ == kOpened || error_) {
+  if (state_ == XMLHttpRequest::kUnsent || state_ == XMLHttpRequest::kOpened ||
+      error_) {
     return 0;
   } else {
     return http_status_;
   }
 }
 
-std::string XMLHttpRequest::status_text() {
+std::string XMLHttpRequestImpl::status_text() {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-statustext-attribute
-  if (state_ == kUnsent || state_ == kOpened || error_) {
+  if (state_ == XMLHttpRequest::kUnsent || state_ == XMLHttpRequest::kOpened ||
+      error_) {
     return std::string();
   }
 
   return http_response_headers_->GetStatusText();
 }
 
-void XMLHttpRequest::set_response_type(
+void XMLHttpRequestImpl::set_response_type(
     const std::string& response_type, script::ExceptionState* exception_state) {
-  if (state_ == kLoading || state_ == kDone) {
+  if (state_ == XMLHttpRequest::kLoading || state_ == XMLHttpRequest::kDone) {
     web::DOMException::Raise(web::DOMException::kInvalidStateErr,
                              exception_state);
     return;
   }
   for (size_t i = 0; i < arraysize(kResponseTypes); ++i) {
     if (response_type == kResponseTypes[i]) {
-      DCHECK_LT(i, kResponseTypeCodeMax);
-      response_type_ = static_cast<ResponseTypeCode>(i);
+      DCHECK_LT(i, XMLHttpRequest::kResponseTypeCodeMax);
+      response_type_ = static_cast<XMLHttpRequest::ResponseTypeCode>(i);
       return;
     }
   }
@@ -593,14 +744,14 @@
   DLOG(WARNING) << "Unexpected response type " << response_type;
 }
 
-std::string XMLHttpRequest::response_type(
+std::string XMLHttpRequestImpl::response_type(
     script::ExceptionState* unused) const {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-responsetype-attribute
   DCHECK_LT(response_type_, arraysize(kResponseTypes));
   return kResponseTypes[response_type_];
 }
 
-void XMLHttpRequest::set_timeout(uint32 timeout) {
+void XMLHttpRequestImpl::set_timeout(uint32 timeout) {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-timeout-attribute
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
@@ -615,14 +766,17 @@
   }
 }
 
-bool XMLHttpRequest::with_credentials(script::ExceptionState* unused) const {
+bool XMLHttpRequestImpl::with_credentials(
+    script::ExceptionState* unused) const {
   return with_credentials_;
 }
 
-void XMLHttpRequest::set_with_credentials(
+void XMLHttpRequestImpl::set_with_credentials(
     bool with_credentials, script::ExceptionState* exception_state) {
   // https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-withcredentials-attribute
-  if ((state_ != kUnsent && state_ != kOpened) || sent_) {
+  if ((state_ != XMLHttpRequest::kUnsent &&
+       state_ != XMLHttpRequest::kOpened) ||
+      sent_) {
     web::DOMException::Raise(web::DOMException::kInvalidStateErr,
                              exception_state);
     return;
@@ -630,20 +784,21 @@
   with_credentials_ = with_credentials;
 }
 
-scoped_refptr<XMLHttpRequestUpload> XMLHttpRequest::upload() {
+scoped_refptr<XMLHttpRequestUpload> XMLHttpRequestImpl::upload() {
   if (!upload_) {
     upload_ = new XMLHttpRequestUpload(settings_);
   }
   return upload_;
 }
 
-void XMLHttpRequest::OnURLFetchResponseStarted(const net::URLFetcher* source) {
+void XMLHttpRequestImpl::OnURLFetchResponseStarted(
+    const net::URLFetcher* source) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   http_status_ = source->GetResponseCode();
   // Don't handle a response without headers.
   if (!source->GetResponseHeaders()) {
-    HandleRequestError(kNetworkError);
+    HandleRequestError(XMLHttpRequest::kNetworkError);
     return;
   }
   // Copy the response headers from the fetcher. It's not safe for us to
@@ -657,7 +812,7 @@
     if (!loader::CORSPreflight::CORSCheck(*http_response_headers_,
                                           origin_.SerializedOrigin(),
                                           with_credentials_)) {
-      HandleRequestError(kNetworkError);
+      HandleRequestError(XMLHttpRequest::kNetworkError);
       return;
     }
   }
@@ -711,24 +866,24 @@
     }
   }
 
-  ChangeState(kHeadersReceived);
+  ChangeState(XMLHttpRequest::kHeadersReceived);
 
   UpdateProgress(0);
 }
 
-void XMLHttpRequest::OnURLFetchDownloadProgress(const net::URLFetcher* source,
-                                                int64_t current, int64_t total,
-                                                int64_t current_network_bytes) {
+void XMLHttpRequestImpl::OnURLFetchDownloadProgress(
+    const net::URLFetcher* source, int64_t current, int64_t total,
+    int64_t current_network_bytes) {
   TRACK_MEMORY_SCOPE("XHR");
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK_NE(state_, kDone);
+  DCHECK_NE(state_, XMLHttpRequest::kDone);
 
   if (response_body_->HasProgressSinceLastGetAndReset() == 0) {
     return;
   }
 
   // Signal to JavaScript that new data is now available.
-  ChangeState(kLoading);
+  ChangeState(XMLHttpRequest::kLoading);
 
   if (fetch_callback_) {
     std::string downloaded_data;
@@ -754,7 +909,8 @@
   }
 }
 
-void XMLHttpRequest::OnURLFetchComplete(const net::URLFetcher* source) {
+
+void XMLHttpRequestImpl::OnURLFetchComplete(const net::URLFetcher* source) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (source->GetResponseHeaders()) {
     if (source->GetResponseHeaders()->IsRedirect(NULL)) {
@@ -766,7 +922,7 @@
       return;
     }
     // Create Performance Resource Timing entry after fetch complete.
-    GetLoadTimingInfoAndCreateResourceTiming();
+    this->GetLoadTimingInfoAndCreateResourceTiming();
   }
 
   const net::URLRequestStatus& status = source->GetStatus();
@@ -792,33 +948,21 @@
       FireProgressEvent(upload_, base::Tokens::load());
       FireProgressEvent(upload_, base::Tokens::loadend());
     }
-    ChangeState(kDone);
+    ChangeState(XMLHttpRequest::kDone);
     UpdateProgress(response_body_->GetAndResetDownloadProgress());
     // Undo the ref we added in Send()
     DecrementActiveRequests();
   } else {
-    HandleRequestError(kNetworkError);
+    HandleRequestError(XMLHttpRequest::kNetworkError);
   }
 
   fetch_callback_.reset();
   fetch_mode_callback_.reset();
 }
 
-// Reset some variables in case the XHR object is reused.
-void XMLHttpRequest::PrepareForNewRequest() {
-  request_headers_.Clear();
-  // Below are variables used for CORS.
-  request_body_text_.clear();
-  is_cross_origin_ = false;
-  redirect_times_ = 0;
-  is_data_url_ = false;
-  upload_listener_ = false;
-  is_redirect_ = false;
-}
-
-void XMLHttpRequest::OnURLFetchUploadProgress(const net::URLFetcher* source,
-                                              int64 current_val,
-                                              int64 total_val) {
+void XMLHttpRequestImpl::OnURLFetchUploadProgress(const net::URLFetcher* source,
+                                                  int64 current_val,
+                                                  int64 total_val) {
   TRACK_MEMORY_SCOPE("XHR");
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (upload_complete_) {
@@ -863,14 +1007,14 @@
   }
 }
 
-void XMLHttpRequest::OnRedirect(const net::HttpResponseHeaders& headers) {
+void XMLHttpRequestImpl::OnRedirect(const net::HttpResponseHeaders& headers) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   GURL new_url = url_fetcher_->GetURL();
   // Since we moved redirect from url_request to here, we also need to
   // handle redirecting too many times.
   if (redirect_times_ >= kRedirectLimit) {
     DLOG(INFO) << "XHR's redirect times hit limit, aborting request.";
-    HandleRequestError(kNetworkError);
+    HandleRequestError(XMLHttpRequest::kNetworkError);
     return;
   }
 
@@ -886,30 +1030,31 @@
     if (loader::Origin(new_url) != loader::Origin(request_url_)) {
       DLOG(INFO) << "XHR is redirected to cross-origin url with credentials, "
                     "aborting request for security reasons.";
-      HandleRequestError(kNetworkError);
+      HandleRequestError(XMLHttpRequest::kNetworkError);
       return;
     } else if (is_cross_origin_) {
       DLOG(INFO) << "XHR is redirected with credentials and cors_flag set, "
                     "aborting request for security reasons.";
-      HandleRequestError(kNetworkError);
+      HandleRequestError(XMLHttpRequest::kNetworkError);
       return;
     }
   }
   if (!new_url.is_valid()) {
-    HandleRequestError(kNetworkError);
+    HandleRequestError(XMLHttpRequest::kNetworkError);
     return;
   }
   // This is a redirect. Re-check the CSP.
-  if (!csp_delegate()->CanLoad(web::CspDelegate::kXhr, new_url,
-                               true /* is_redirect */)) {
-    HandleRequestError(kNetworkError);
+  web::CspDelegate* csp = this->csp_delegate();
+  if (csp &&
+      !csp->CanLoad(web::CspDelegate::kXhr, new_url, true /* is_redirect */)) {
+    HandleRequestError(XMLHttpRequest::kNetworkError);
     return;
   }
   // CORS check for the received response
   if (is_cross_origin_) {
     if (!loader::CORSPreflight::CORSCheck(headers, origin_.SerializedOrigin(),
                                           with_credentials_)) {
-      HandleRequestError(kNetworkError);
+      HandleRequestError(XMLHttpRequest::kNetworkError);
       return;
     }
   }
@@ -935,42 +1080,45 @@
   }
   request_url_ = new_url;
   redirect_times_++;
-  StartRequest(request_body_text_);
+  this->StartRequest(request_body_text_);
 }
 
-void XMLHttpRequest::TraceMembers(script::Tracer* tracer) {
-  XMLHttpRequestEventTarget::TraceMembers(tracer);
+void XMLHttpRequestImpl::ReportLoadTimingInfo(
+    const net::LoadTimingInfo& timing_info) {
+  load_timing_info_ = timing_info;
+}
 
+void XMLHttpRequestImpl::GetLoadTimingInfoAndCreateResourceTiming() {
+  // Performance info is only available through window currently. Not available
+  // in workers.
+  return;
+}
+
+void XMLHttpRequestImpl::TraceMembers(script::Tracer* tracer) {
   tracer->Trace(upload_);
 }
 
-XMLHttpRequest::~XMLHttpRequest() {
-  DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  xhr::GlobalStats::GetInstance()->Remove(this);
+web::CspDelegate* XMLHttpRequestImpl::csp_delegate() const {
+  // TODO (b/239733363): csp_delegate is currently available through window.
+  // Refactor to make it available outside of window then implement this. At
+  // that point, there should be no more need to override this function in
+  // DOMXMLHttpRequestImpl.
+  return NULL;
 }
 
-web::CspDelegate* XMLHttpRequest::csp_delegate() const {
-  DCHECK(settings_);
-  if (settings_->window() && settings_->window()->document()) {
-    return settings_->window()->document()->csp_delegate();
-  } else {
-    return NULL;
-  }
-}
-
-void XMLHttpRequest::TerminateRequest() {
+void XMLHttpRequestImpl::TerminateRequest() {
   error_ = true;
   corspreflight_.reset(NULL);
   url_fetcher_.reset(NULL);
 }
 
-void XMLHttpRequest::HandleRequestError(
+void XMLHttpRequestImpl::HandleRequestError(
     XMLHttpRequest::RequestErrorType request_error_type) {
   // https://www.w3.org/TR/XMLHttpRequest/#timeout-error
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DLOG_IF(INFO, verbose())
       << __FUNCTION__ << " (" << RequestErrorTypeName(request_error_type)
-      << ") " << *this << std::endl
+      << ") " << *xhr_ << std::endl
       << script::StackTraceToString(
              settings_->context()->global_environment()->GetStackTrace(
                  0 /*max_frames*/));
@@ -979,7 +1127,7 @@
   TerminateRequest();
   // Steps 2-4
   // Change state and fire readystatechange event.
-  ChangeState(kDone);
+  ChangeState(XMLHttpRequest::kDone);
 
   base::Token error_name = RequestErrorTypeName(request_error_type);
   // Step 5
@@ -991,23 +1139,23 @@
   }
 
   // Steps 6-8
-  FireProgressEvent(this, base::Tokens::progress());
-  FireProgressEvent(this, error_name);
-  FireProgressEvent(this, base::Tokens::loadend());
+  FireProgressEvent(xhr_, base::Tokens::progress());
+  FireProgressEvent(xhr_, error_name);
+  FireProgressEvent(xhr_, base::Tokens::loadend());
 
   fetch_callback_.reset();
   fetch_mode_callback_.reset();
   DecrementActiveRequests();
 }
 
-void XMLHttpRequest::OnTimeout() {
+void XMLHttpRequestImpl::OnTimeout() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   if (!stop_timeout_) {
-    HandleRequestError(kTimeoutError);
+    HandleRequestError(XMLHttpRequest::kTimeoutError);
   }
 }
 
-void XMLHttpRequest::StartTimer(base::TimeDelta time_since_send) {
+void XMLHttpRequestImpl::StartTimer(base::TimeDelta time_since_send) {
   // Subtract any time that has already elapsed from the timeout.
   // This is in case the user has set a timeout after send() was already in
   // flight.
@@ -1017,27 +1165,28 @@
 
   // Queue the callback even if delay ends up being zero, to preserve the
   // previous semantics.
-  timer_.Start(FROM_HERE, delay, this, &XMLHttpRequest::OnTimeout);
+  timer_.Start(FROM_HERE, delay, this, &XMLHttpRequestImpl::OnTimeout);
 }
 
-void XMLHttpRequest::ChangeState(XMLHttpRequest::State new_state) {
+void XMLHttpRequestImpl::ChangeState(XMLHttpRequest::State new_state) {
   // Always dispatch state change events for LOADING, also known as
   // INTERACTIVE, so that clients can get partial data (XHR streaming).
   // This is to match the behavior of Chrome (which took it from Firefox).
-  if (state_ == new_state && new_state != kLoading) {
+  if (state_ == new_state && new_state != XMLHttpRequest::kLoading) {
     return;
   }
 
   state_ = new_state;
-  if (state_ != kUnsent) {
-    DispatchEvent(new web::Event(base::Tokens::readystatechange()));
+  if (state_ != XMLHttpRequest::kUnsent) {
+    xhr_->DispatchEvent(new web::Event(base::Tokens::readystatechange()));
   }
 }
 
-script::Handle<script::ArrayBuffer> XMLHttpRequest::response_array_buffer() {
+script::Handle<script::ArrayBuffer>
+XMLHttpRequestImpl::response_array_buffer() {
   TRACK_MEMORY_SCOPE("XHR");
   // https://www.w3.org/TR/XMLHttpRequest/#response-entity-body
-  if (error_ || state_ != kDone) {
+  if (error_ || state_ != XMLHttpRequest::kDone) {
     // Return a handle holding a nullptr.
     return script::Handle<script::ArrayBuffer>();
   }
@@ -1051,7 +1200,7 @@
     auto array_buffer = script::ArrayBuffer::New(
         settings_->context()->global_environment(), std::move(downloaded_data));
     response_array_buffer_reference_.reset(
-        new script::ScriptValue<script::ArrayBuffer>::Reference(this,
+        new script::ScriptValue<script::ArrayBuffer>::Reference(xhr_,
                                                                 array_buffer));
     return array_buffer;
   } else {
@@ -1060,7 +1209,7 @@
   }
 }
 
-void XMLHttpRequest::UpdateProgress(int64_t received_length) {
+void XMLHttpRequestImpl::UpdateProgress(int64_t received_length) {
   DCHECK(http_response_headers_);
   const int64 content_length = http_response_headers_->GetContentLength();
   const bool length_computable =
@@ -1069,62 +1218,30 @@
       length_computable ? static_cast<uint64>(content_length) : 0;
 
   DLOG_IF(INFO, verbose()) << __FUNCTION__ << " (" << received_length << " / "
-                           << total << ") " << *this;
+                           << total << ") " << *xhr_;
 
-  if (state_ == kDone) {
-    FireProgressEvent(this, base::Tokens::load(),
+  if (state_ == XMLHttpRequest::kDone) {
+    FireProgressEvent(xhr_, base::Tokens::load(),
                       static_cast<uint64>(received_length), total,
                       length_computable);
-    FireProgressEvent(this, base::Tokens::loadend(),
+    FireProgressEvent(xhr_, base::Tokens::loadend(),
                       static_cast<uint64>(received_length), total,
                       length_computable);
   } else {
-    FireProgressEvent(this, base::Tokens::progress(),
+    FireProgressEvent(xhr_, base::Tokens::progress(),
                       static_cast<uint64>(received_length), total,
                       length_computable);
   }
 }
 
-void XMLHttpRequest::IncrementActiveRequests() {
-  if (active_requests_count_ == 0) {
-    DCHECK(settings_);
-    DCHECK(settings_->context());
-    prevent_gc_until_send_complete_.reset(
-        new script::GlobalEnvironment::ScopedPreventGarbageCollection(
-            settings_->context()->global_environment(), this));
-  }
-  active_requests_count_++;
-}
-
-void XMLHttpRequest::DecrementActiveRequests() {
-  DCHECK_GT(active_requests_count_, 0);
-  active_requests_count_--;
-  if (active_requests_count_ == 0) {
-    bool is_active = (state_ == kOpened && sent_) ||
-                     state_ == kHeadersReceived || state_ == kLoading;
-    bool has_event_listeners =
-        GetAttributeEventListener(base::Tokens::readystatechange()) ||
-        GetAttributeEventListener(base::Tokens::progress()) ||
-        GetAttributeEventListener(base::Tokens::abort()) ||
-        GetAttributeEventListener(base::Tokens::error()) ||
-        GetAttributeEventListener(base::Tokens::load()) ||
-        GetAttributeEventListener(base::Tokens::timeout()) ||
-        GetAttributeEventListener(base::Tokens::loadend());
-
-    DCHECK_EQ((is_active && has_event_listeners), false);
-
-    prevent_gc_until_send_complete_.reset();
-  }
-}
-
-void XMLHttpRequest::StartRequest(const std::string& request_body) {
+void XMLHttpRequestImpl::StartRequest(const std::string& request_body) {
   TRACK_MEMORY_SCOPE("XHR");
 
   response_array_buffer_reference_.reset();
 
   network::NetworkModule* network_module =
       settings_->context()->fetcher_factory()->network_module();
-  url_fetcher_ = net::URLFetcher::Create(request_url_, method_, this);
+  url_fetcher_ = net::URLFetcher::Create(request_url_, method_, xhr_);
   ++url_fetcher_generation_;
   url_fetcher_->SetRequestContext(network_module->url_request_context_getter());
   if (fetch_callback_) {
@@ -1133,7 +1250,195 @@
     response_body_->DisablePreallocate();
   } else {
     response_body_ = new URLFetcherResponseWriter::Buffer(
-        response_type_ == kArrayBuffer
+        response_type_ == XMLHttpRequest::kArrayBuffer
+            ? URLFetcherResponseWriter::Buffer::kArrayBuffer
+            : URLFetcherResponseWriter::Buffer::kString);
+  }
+  std::unique_ptr<net::URLFetcherResponseWriter> download_data_writer(
+      new URLFetcherResponseWriter(response_body_));
+  url_fetcher_->SaveResponseWithWriter(std::move(download_data_writer));
+  // Don't retry, let the caller deal with it.
+  url_fetcher_->SetAutomaticallyRetryOn5xx(false);
+  url_fetcher_->SetExtraRequestHeaders(request_headers_.ToString());
+
+  // We want to do cors check and preflight during redirects
+  url_fetcher_->SetStopOnRedirect(true);
+
+  if (request_body.size()) {
+    // If applicable, the request body Content-Type is already set in
+    // request_headers.
+    url_fetcher_->SetUploadData("", request_body);
+  }
+
+  // We let data url fetch resources freely but with no response headers.
+  is_data_url_ = is_data_url_ || request_url_.SchemeIs("data");
+  is_cross_origin_ = (is_redirect_ && is_cross_origin_) ||
+                     (origin_ != loader::Origin(request_url_) && !is_data_url_);
+  is_redirect_ = false;
+  // If the CORS flag is set, httpRequest’s method is neither `GET` nor `HEAD`
+  // or httpRequest’s mode is "websocket", then append `Origin`/httpRequest’s
+  // origin, serialized and UTF-8 encoded, to httpRequest’s header list.
+  if (is_cross_origin_ ||
+      (method_ != net::URLFetcher::GET && method_ != net::URLFetcher::HEAD)) {
+    url_fetcher_->AddExtraRequestHeader("Origin:" + origin_.SerializedOrigin());
+  }
+  bool dopreflight = false;
+  // TODO (b/239733363): Include CORS functionality once preflight cache is
+  // accessible outside of window. At that point, there should be no more need
+  // to override this function in DOMXMLHttpRequestImpl.
+  DLOG_IF(INFO, verbose()) << __FUNCTION__ << *xhr_;
+  if (!dopreflight) {
+    DCHECK(settings_->context()->network_module());
+    StartURLFetcher(settings_->context()->network_module()->max_network_delay(),
+                    url_fetcher_generation_);
+  }
+}
+
+void XMLHttpRequestImpl::IncrementActiveRequests() {
+  if (active_requests_count_ == 0) {
+    DCHECK(settings_);
+    DCHECK(settings_->context());
+    prevent_gc_until_send_complete_.reset(
+        new script::GlobalEnvironment::ScopedPreventGarbageCollection(
+            settings_->context()->global_environment(), xhr_));
+  }
+  active_requests_count_++;
+}
+
+void XMLHttpRequestImpl::DecrementActiveRequests() {
+  DCHECK_GT(active_requests_count_, 0);
+  active_requests_count_--;
+  if (active_requests_count_ == 0) {
+    bool is_active = (state_ == XMLHttpRequest::kOpened && sent_) ||
+                     state_ == XMLHttpRequest::kHeadersReceived ||
+                     state_ == XMLHttpRequest::kLoading;
+    bool has_event_listeners =
+        xhr_->GetAttributeEventListener(base::Tokens::readystatechange()) ||
+        xhr_->GetAttributeEventListener(base::Tokens::progress()) ||
+        xhr_->GetAttributeEventListener(base::Tokens::abort()) ||
+        xhr_->GetAttributeEventListener(base::Tokens::error()) ||
+        xhr_->GetAttributeEventListener(base::Tokens::load()) ||
+        xhr_->GetAttributeEventListener(base::Tokens::timeout()) ||
+        xhr_->GetAttributeEventListener(base::Tokens::loadend());
+
+    DCHECK_EQ((is_active && has_event_listeners), false);
+
+    prevent_gc_until_send_complete_.reset();
+  }
+}
+
+// Reset some variables in case the XHR object is reused.
+void XMLHttpRequestImpl::PrepareForNewRequest() {
+  request_headers_.Clear();
+  // Below are variables used for CORS.
+  request_body_text_.clear();
+  is_cross_origin_ = false;
+  redirect_times_ = 0;
+  is_data_url_ = false;
+  upload_listener_ = false;
+  is_redirect_ = false;
+}
+
+void XMLHttpRequestImpl::StartURLFetcher(const SbTime max_artificial_delay,
+                                         const int url_fetcher_generation) {
+  if (max_artificial_delay > 0) {
+    base::MessageLoop::current()->task_runner()->PostDelayedTask(
+        FROM_HERE,
+        base::Bind(&XMLHttpRequestImpl::StartURLFetcher, base::Unretained(this),
+                   0, url_fetcher_generation_),
+        base::TimeDelta::FromMicroseconds(base::RandUint64() %
+                                          max_artificial_delay));
+    return;
+  }
+
+  // Note: Checking that "url_fetcher_generation_" != "url_fetcher_generation"
+  // is to verify the "url_fetcher_" is currently the same one that was present
+  // upon a delayed url fetch. This works because the incoming parameter
+  // "url_fetcher_generation" will hold the value at the time of the initial
+  // call, and if a delayed binding has waited while a new "url_fetcher_" has
+  // changed state, "url_fetcher_generation_" will have incremented.
+  if (nullptr != url_fetcher_ &&
+      url_fetcher_generation == url_fetcher_generation_) {
+    url_fetcher_->Start();
+  }
+}
+
+void XMLHttpRequestImpl::CORSPreflightErrorCallback() {
+  HandleRequestError(XMLHttpRequest::kNetworkError);
+}
+
+void XMLHttpRequestImpl::CORSPreflightSuccessCallback() {
+  DCHECK(settings_->context()->network_module());
+  StartURLFetcher(settings_->context()->network_module()->max_network_delay(),
+                  url_fetcher_generation_);
+}
+
+DOMXMLHttpRequestImpl::DOMXMLHttpRequestImpl(XMLHttpRequest* xhr)
+    : XMLHttpRequestImpl(xhr),
+      settings_(base::polymorphic_downcast<dom::DOMSettings*>(
+          xhr->environment_settings())) {
+  DCHECK(settings_);
+}
+
+// https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#the-responsexml-attribute
+scoped_refptr<dom::Document> DOMXMLHttpRequestImpl::response_xml(
+    script::ExceptionState* exception_state) {
+  // 1. If responseType is not the empty string or "document", throw an
+  // "InvalidStateError" exception.
+  if (response_type_ != XMLHttpRequest::kDefault &&
+      response_type_ != XMLHttpRequest::kDocument) {
+    web::DOMException::Raise(web::DOMException::kInvalidStateErr,
+                             exception_state);
+    return NULL;
+  }
+
+  // 2. If the state is not DONE, return null.
+  if (state_ != XMLHttpRequest::kDone) {
+    return NULL;
+  }
+
+  // 3. If the error flag is set, return null.
+  if (error_) {
+    return NULL;
+  }
+
+  // 4. Return the document response entity body.
+  return GetDocumentResponseEntityBody();
+}
+
+void DOMXMLHttpRequestImpl::GetLoadTimingInfoAndCreateResourceTiming() {
+  if (settings_->window()->performance() == nullptr) return;
+  settings_->window()->performance()->CreatePerformanceResourceTiming(
+      load_timing_info_, kPerformanceResourceTimingInitiatorType,
+      request_url_.spec());
+}
+
+web::CspDelegate* DOMXMLHttpRequestImpl::csp_delegate() const {
+  DCHECK(settings_);
+  if (settings_->window() && settings_->window()->document()) {
+    return settings_->window()->document()->csp_delegate();
+  } else {
+    return NULL;
+  }
+}
+
+void DOMXMLHttpRequestImpl::StartRequest(const std::string& request_body) {
+  TRACK_MEMORY_SCOPE("XHR");
+
+  response_array_buffer_reference_.reset();
+
+  network::NetworkModule* network_module =
+      settings_->context()->fetcher_factory()->network_module();
+  url_fetcher_ = net::URLFetcher::Create(request_url_, method_, xhr_);
+  ++url_fetcher_generation_;
+  url_fetcher_->SetRequestContext(network_module->url_request_context_getter());
+  if (fetch_callback_) {
+    response_body_ = new URLFetcherResponseWriter::Buffer(
+        URLFetcherResponseWriter::Buffer::kString);
+    response_body_->DisablePreallocate();
+  } else {
+    response_body_ = new URLFetcherResponseWriter::Buffer(
+        response_type_ == XMLHttpRequest::kArrayBuffer
             ? URLFetcherResponseWriter::Buffer::kArrayBuffer
             : URLFetcherResponseWriter::Buffer::kString);
   }
@@ -1169,10 +1474,10 @@
   if (is_cross_origin_) {
     corspreflight_.reset(new cobalt::loader::CORSPreflight(
         request_url_, method_, network_module,
-        base::Bind(&XMLHttpRequest::CORSPreflightSuccessCallback,
+        base::Bind(&DOMXMLHttpRequestImpl::CORSPreflightSuccessCallback,
                    base::Unretained(this)),
         origin_.SerializedOrigin(),
-        base::Bind(&XMLHttpRequest::CORSPreflightErrorCallback,
+        base::Bind(&DOMXMLHttpRequestImpl::CORSPreflightErrorCallback,
                    base::Unretained(this)),
         settings_->window()->get_preflight_cache()));
     corspreflight_->set_headers(request_headers_);
@@ -1193,7 +1498,7 @@
     corspreflight_->set_force_preflight(upload_listener_);
     dopreflight = corspreflight_->Send();
   }
-  DLOG_IF(INFO, verbose()) << __FUNCTION__ << *this;
+  DLOG_IF(INFO, verbose()) << __FUNCTION__ << *xhr_;
   if (!dopreflight) {
     DCHECK(settings_->context()->network_module());
     StartURLFetcher(settings_->context()->network_module()->max_network_delay(),
@@ -1201,37 +1506,57 @@
   }
 }
 
-void XMLHttpRequest::CORSPreflightErrorCallback() {
-  HandleRequestError(XMLHttpRequest::kNetworkError);
+// https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#document-response-entity-body
+scoped_refptr<dom::Document>
+DOMXMLHttpRequestImpl::GetDocumentResponseEntityBody() {
+  DCHECK_EQ(state_, XMLHttpRequest::kDone);
+
+  // Step 1..5
+  const std::string final_mime_type =
+      mime_type_override_.empty() ? response_mime_type_ : mime_type_override_;
+  if (final_mime_type != "text/xml" && final_mime_type != "application/xml") {
+    return NULL;
+  }
+
+  // 6. Otherwise, let document be a document that represents the result of
+  // parsing the response entity body following the rules set forth in the XML
+  // specifications. If that fails (unsupported character encoding, namespace
+  // well-formedness error, etc.), return null.
+  scoped_refptr<dom::XMLDocument> xml_document =
+      new dom::XMLDocument(settings_->window()->html_element_context());
+  dom_parser::XMLDecoder xml_decoder(
+      xml_document, xml_document, NULL, settings_->max_dom_element_depth(),
+      base::SourceLocation("[object XMLHttpRequest]", 1, 1),
+      base::Bind(&DOMXMLHttpRequestImpl::XMLDecoderLoadCompleteCallback,
+                 base::Unretained(this)));
+  has_xml_decoder_error_ = false;
+  xml_decoder.DecodeChunk(response_body_->GetReferenceOfStringAndSeal().c_str(),
+                          response_body_->GetReferenceOfStringAndSeal().size());
+  xml_decoder.Finish();
+  if (has_xml_decoder_error_) {
+    return NULL;
+  }
+
+  // Step 7..11 Not needed by Cobalt.
+
+  // 12. Return document.
+  return xml_document;
 }
 
-void XMLHttpRequest::CORSPreflightSuccessCallback() {
-  DCHECK(settings_->context()->network_module());
-  StartURLFetcher(settings_->context()->network_module()->max_network_delay(),
-                  url_fetcher_generation_);
-}
-
-void XMLHttpRequest::ReportLoadTimingInfo(
-    const net::LoadTimingInfo& timing_info) {
-  load_timing_info_ = timing_info;
-}
-
-void XMLHttpRequest::GetLoadTimingInfoAndCreateResourceTiming() {
-  if (settings_->window()->performance() == nullptr) return;
-  settings_->window()->performance()->CreatePerformanceResourceTiming(
-      load_timing_info_, kPerformanceResourceTimingInitiatorType,
-      request_url_.spec());
+void DOMXMLHttpRequestImpl::XMLDecoderLoadCompleteCallback(
+    const base::Optional<std::string>& error) {
+  if (error) has_xml_decoder_error_ = true;
 }
 
 std::ostream& operator<<(std::ostream& out, const XMLHttpRequest& xhr) {
 #if !defined(COBALT_BUILD_TYPE_GOLD)
   base::StringPiece response_text("");
-  if ((xhr.state_ == XMLHttpRequest::kDone) &&
-      (xhr.response_type_ == XMLHttpRequest::kDefault ||
-       xhr.response_type_ == XMLHttpRequest::kText)) {
+  if ((xhr.xhr_impl_->state_ == XMLHttpRequest::kDone) &&
+      (xhr.xhr_impl_->response_type_ == XMLHttpRequest::kDefault ||
+       xhr.xhr_impl_->response_type_ == XMLHttpRequest::kText)) {
     size_t kMaxSize = 4096;
     const auto& response_body =
-        xhr.response_body_->GetTemporaryReferenceOfString();
+        xhr.xhr_impl_->response_body_->GetTemporaryReferenceOfString();
     response_text =
         base::StringPiece(reinterpret_cast<const char*>(response_body.data()),
                           std::min(kMaxSize, response_body.size()));
@@ -1251,11 +1576,15 @@
       "\tsent: %s\n"
       "\tstop_timeout: %s\n"
       "\tresponse_body: %s\n",
-      xhr.xhr_id_, xhr.request_url_.spec().c_str(), StateName(xhr.state_),
-      xhr.response_type(NULL).c_str(), xhr.timeout_ms_,
-      RequestTypeToMethodName(xhr.method_), xhr.http_status_,
-      xhr.with_credentials_ ? "true" : "false", xhr.error_ ? "true" : "false",
-      xhr.sent_ ? "true" : "false", xhr.stop_timeout_ ? "true" : "false",
+      xhr.xhr_id_, xhr.xhr_impl_->request_url_.spec().c_str(),
+      StateName(xhr.xhr_impl_->state_), xhr.response_type(NULL).c_str(),
+      xhr.xhr_impl_->timeout_ms_,
+      RequestTypeToMethodName(xhr.xhr_impl_->method_),
+      xhr.xhr_impl_->http_status_,
+      xhr.xhr_impl_->with_credentials_ ? "true" : "false",
+      xhr.xhr_impl_->error_ ? "true" : "false",
+      xhr.xhr_impl_->sent_ ? "true" : "false",
+      xhr.xhr_impl_->stop_timeout_ ? "true" : "false",
       response_text.as_string().c_str());
   out << xhr_out;
 #else
@@ -1263,70 +1592,5 @@
   return out;
 }
 
-// https://www.w3.org/TR/2014/WD-XMLHttpRequest-20140130/#document-response-entity-body
-scoped_refptr<dom::Document> XMLHttpRequest::GetDocumentResponseEntityBody() {
-  DCHECK_EQ(state_, kDone);
-
-  // Step 1..5
-  const std::string final_mime_type =
-      mime_type_override_.empty() ? response_mime_type_ : mime_type_override_;
-  if (final_mime_type != "text/xml" && final_mime_type != "application/xml") {
-    return NULL;
-  }
-
-  // 6. Otherwise, let document be a document that represents the result of
-  // parsing the response entity body following the rules set forth in the XML
-  // specifications. If that fails (unsupported character encoding, namespace
-  // well-formedness error, etc.), return null.
-  scoped_refptr<dom::XMLDocument> xml_document =
-      new dom::XMLDocument(settings_->window()->html_element_context());
-  dom_parser::XMLDecoder xml_decoder(
-      xml_document, xml_document, NULL, settings_->max_dom_element_depth(),
-      base::SourceLocation("[object XMLHttpRequest]", 1, 1),
-      base::Bind(&XMLHttpRequest::XMLDecoderLoadCompleteCallback,
-                 base::Unretained(this)));
-  has_xml_decoder_error_ = false;
-  xml_decoder.DecodeChunk(response_body_->GetReferenceOfStringAndSeal().c_str(),
-                          response_body_->GetReferenceOfStringAndSeal().size());
-  xml_decoder.Finish();
-  if (has_xml_decoder_error_) {
-    return NULL;
-  }
-
-  // Step 7..11 Not needed by Cobalt.
-
-  // 12. Return document.
-  return xml_document;
-}
-
-void XMLHttpRequest::XMLDecoderLoadCompleteCallback(
-    const base::Optional<std::string>& error) {
-  if (error) has_xml_decoder_error_ = true;
-}
-
-void XMLHttpRequest::StartURLFetcher(const SbTime max_artificial_delay,
-                                     const int url_fetcher_generation) {
-  if (max_artificial_delay > 0) {
-    base::MessageLoop::current()->task_runner()->PostDelayedTask(
-        FROM_HERE,
-        base::Bind(&XMLHttpRequest::StartURLFetcher, this, 0,
-                   url_fetcher_generation_),
-        base::TimeDelta::FromMicroseconds(base::RandUint64() %
-                                          max_artificial_delay));
-    return;
-  }
-
-  // Note: Checking that "url_fetcher_generation_" != "url_fetcher_generation"
-  // is to verify the "url_fetcher_" is currently the same one that was present
-  // upon a delayed url fetch. This works because the incoming parameter
-  // "url_fetcher_generation" will hold the value at the time of the initial
-  // call, and if a delayed binding has waited while a new "url_fetcher_" has
-  // changed state, "url_fetcher_generation_" will have incremented.
-  if (nullptr != url_fetcher_ &&
-      url_fetcher_generation == url_fetcher_generation_) {
-    url_fetcher_->Start();
-  }
-}
-
 }  // namespace xhr
 }  // namespace cobalt
diff --git a/cobalt/xhr/xml_http_request.h b/cobalt/xhr/xml_http_request.h
index 2c26720..e3510f0 100644
--- a/cobalt/xhr/xml_http_request.h
+++ b/cobalt/xhr/xml_http_request.h
@@ -34,6 +34,7 @@
 #include "cobalt/script/union_type.h"
 #include "cobalt/web/csp_delegate.h"
 #include "cobalt/web/dom_exception.h"
+#include "cobalt/web/environment_settings.h"
 #include "cobalt/xhr/url_fetcher_buffer_writer.h"
 #include "cobalt/xhr/xml_http_request_event_target.h"
 #include "cobalt/xhr/xml_http_request_upload.h"
@@ -45,9 +46,6 @@
 #include "url/gurl.h"
 
 namespace cobalt {
-namespace dom {
-class DOMSettings;
-}
 
 namespace script {
 class EnvironmentSettings;
@@ -55,12 +53,14 @@
 
 namespace xhr {
 
+class XMLHttpRequestImpl;
+
 class XMLHttpRequest : public XMLHttpRequestEventTarget,
-                       net::URLFetcherDelegate {
+                       public net::URLFetcherDelegate {
  public:
-  // Note: This is expected to be a DOMSettings object, but we declare it as
-  // EnvironmentSettings so that JSC doesn't need to know about dom.
   explicit XMLHttpRequest(script::EnvironmentSettings* settings);
+  XMLHttpRequest(const XMLHttpRequest&) = delete;
+  XMLHttpRequest& operator=(const XMLHttpRequest&) = delete;
 
   typedef script::UnionType2<std::string, script::Handle<script::ArrayBuffer> >
       ResponseType;
@@ -131,7 +131,9 @@
   void OverrideMimeType(const std::string& mime_type,
                         script::ExceptionState* exception_state);
 
-  void Send(script::ExceptionState* exception_state);
+  void Send(script::ExceptionState* exception_state) {
+    Send(base::nullopt, exception_state);
+  }
   void Send(const base::Optional<RequestBodyType>& request_body,
             script::ExceptionState* exception_state);
 
@@ -153,12 +155,120 @@
   const std::string& response_text(script::ExceptionState* exception_state);
   scoped_refptr<dom::Document> response_xml(
       script::ExceptionState* exception_state);
-  std::string status_text();
   base::Optional<ResponseType> response(
       script::ExceptionState* exception_state);
 
+  int ready_state() const;
+  int status() const;
+  std::string status_text();
+  std::string status_text() const;
+  void set_response_type(const std::string& response_type,
+                         script::ExceptionState* exception_state);
+  std::string response_type(script::ExceptionState* exception_state) const;
+
+  uint32 timeout() const;
+  void set_timeout(uint32 timeout);
+  bool with_credentials(script::ExceptionState* exception_state) const;
+  void set_with_credentials(bool b, script::ExceptionState* exception_state);
+
+  scoped_refptr<XMLHttpRequestUpload> upload();
+
+  static void set_verbose(bool verbose);
+  static bool verbose();
+
+  // net::URLFetcherDelegate interface
+  void OnURLFetchResponseStarted(const net::URLFetcher* source) override;
+  void OnURLFetchDownloadProgress(const net::URLFetcher* source,
+                                  int64_t current, int64_t total,
+                                  int64_t current_network_bytes) override;
+  void OnURLFetchComplete(const net::URLFetcher* source) override;
+
+  void OnURLFetchUploadProgress(const net::URLFetcher* source, int64 current,
+                                int64 total) override;
+  void OnRedirect(const net::HttpResponseHeaders& headers);
+
+  // Called from bindings layer to tie objects' lifetimes to this XHR instance.
+  XMLHttpRequestUpload* upload_or_null();
+
+  void ReportLoadTimingInfo(const net::LoadTimingInfo& timing_info) override;
+  // Create Performance Resource Timing entry for XMLHttpRequest.
+  void GetLoadTimingInfoAndCreateResourceTiming();
+
+  friend std::ostream& operator<<(std::ostream& os, const XMLHttpRequest& xhr);
+  DEFINE_WRAPPABLE_TYPE(XMLHttpRequest);
+  void TraceMembers(script::Tracer* tracer) override;
+
+ protected:
+  ~XMLHttpRequest() override;
+
+ private:
+  FRIEND_TEST_ALL_PREFIXES(XhrTest, GetResponseHeader);
+  FRIEND_TEST_ALL_PREFIXES(XhrTest, InvalidMethod);
+  FRIEND_TEST_ALL_PREFIXES(XhrTest, Open);
+  FRIEND_TEST_ALL_PREFIXES(XhrTest, OpenFailConnectSrc);
+  FRIEND_TEST_ALL_PREFIXES(XhrTest, OverrideMimeType);
+  FRIEND_TEST_ALL_PREFIXES(XhrTest, SetRequestHeader);
+
+  std::unique_ptr<XMLHttpRequestImpl> xhr_impl_;
+#if !defined(COBALT_BUILD_TYPE_GOLD)
+  // Unique ID for debugging.
+  int xhr_id_;
+#endif  // !defined(COBALT_BUILD_TYPE_GOLD)
+
+  THREAD_CHECKER(thread_checker_);
+};
+
+
+class XMLHttpRequestImpl {
+ public:
+  explicit XMLHttpRequestImpl(XMLHttpRequest* xhr);
+  XMLHttpRequestImpl(const XMLHttpRequestImpl&) = delete;
+  XMLHttpRequestImpl& operator=(const XMLHttpRequestImpl&) = delete;
+  virtual ~XMLHttpRequestImpl() {}
+
+  void Abort();
+  void Open(const std::string& method, const std::string& url, bool async,
+            const base::Optional<std::string>& username,
+            const base::Optional<std::string>& password,
+            script::ExceptionState* exception_state);
+
+  // Must be called after open(), but before send().
+  void SetRequestHeader(const std::string& header, const std::string& value,
+                        script::ExceptionState* exception_state);
+
+  // Override the MIME type returned by the server.
+  // Call before Send(), otherwise throws InvalidStateError.
+  void OverrideMimeType(const std::string& mime_type,
+                        script::ExceptionState* exception_state);
+
+  void Send(const base::Optional<XMLHttpRequest::RequestBodyType>& request_body,
+            script::ExceptionState* exception_state);
+
+  // FetchAPI: replacement for Send() when fetch functionality is required.
+  typedef script::CallbackFunction<void(
+      const script::Handle<script::Uint8Array>& data)>
+      FetchUpdateCallback;
+  typedef script::CallbackFunction<void(bool)> FetchModeCallback;
+  typedef script::ScriptValue<FetchUpdateCallback> FetchUpdateCallbackArg;
+  typedef script::ScriptValue<FetchModeCallback> FetchModeCallbackArg;
+  void Fetch(
+      const FetchUpdateCallbackArg& fetch_callback,
+      const FetchModeCallbackArg& fetch_mode_callback,
+      const base::Optional<XMLHttpRequest::RequestBodyType>& request_body,
+      script::ExceptionState* exception_state);
+
+  base::Optional<std::string> GetResponseHeader(const std::string& header);
+  std::string GetAllResponseHeaders();
+
+  const std::string& response_text(script::ExceptionState* exception_state);
+  virtual scoped_refptr<dom::Document> response_xml(
+      script::ExceptionState* exception_state);
+  base::Optional<XMLHttpRequest::ResponseType> response(
+      script::ExceptionState* exception_state);
+
   int ready_state() const { return static_cast<int>(state_); }
   int status() const;
+  std::string status_text();
   std::string status_text() const;
   void set_response_type(const std::string& reponse_type,
                          script::ExceptionState* exception_state);
@@ -173,57 +283,97 @@
 
   static void set_verbose(bool verbose) { verbose_ = verbose; }
   static bool verbose() { return verbose_; }
+
+
   // net::URLFetcherDelegate interface
-  void OnURLFetchResponseStarted(const net::URLFetcher* source) override;
+  void OnURLFetchResponseStarted(const net::URLFetcher* source);
   void OnURLFetchDownloadProgress(const net::URLFetcher* source,
                                   int64_t current, int64_t total,
-                                  int64_t current_network_bytes) override;
-  void OnURLFetchComplete(const net::URLFetcher* source) override;
+                                  int64_t current_network_bytes);
+  void OnURLFetchComplete(const net::URLFetcher* source);
 
   void OnURLFetchUploadProgress(const net::URLFetcher* source, int64 current,
-                                int64 total) override;
+                                int64 total);
   void OnRedirect(const net::HttpResponseHeaders& headers);
 
   // Called from bindings layer to tie objects' lifetimes to this XHR instance.
   XMLHttpRequestUpload* upload_or_null() { return upload_.get(); }
 
-  void ReportLoadTimingInfo(const net::LoadTimingInfo& timing_info) override;
+  void ReportLoadTimingInfo(const net::LoadTimingInfo& timing_info);
   // Create Performance Resource Timing entry for XMLHttpRequest.
-  void GetLoadTimingInfoAndCreateResourceTiming();
+  virtual void GetLoadTimingInfoAndCreateResourceTiming();
 
   friend std::ostream& operator<<(std::ostream& os, const XMLHttpRequest& xhr);
-  DEFINE_WRAPPABLE_TYPE(XMLHttpRequest);
-  void TraceMembers(script::Tracer* tracer) override;
+  void TraceMembers(script::Tracer* tracer);
 
  protected:
-  ~XMLHttpRequest() override;
+  void CORSPreflightErrorCallback();
+  void CORSPreflightSuccessCallback();
 
   // Return the CSP delegate from the Settings object.
   // virtual for use by tests.
   virtual web::CspDelegate* csp_delegate() const;
 
+  // The following method starts "url_fetcher_" with a possible pre-delay.
+  void StartURLFetcher(const SbTime max_artificial_delay,
+                       const int url_fetcher_generation);
+
+  // Protected members for visibility in derived class.
+  // All members requiring initialization are grouped below.
+  bool error_;
+  bool is_cross_origin_;
+  bool is_data_url_;
+  bool is_redirect_;
+  net::URLFetcher::RequestType method_;
+  scoped_refptr<URLFetcherResponseWriter::Buffer> response_body_;
+  XMLHttpRequest::ResponseTypeCode response_type_;
+  XMLHttpRequest::State state_;
+  // https://xhr.spec.whatwg.org/#upload-listener-flag
+  bool upload_listener_;
+  bool with_credentials_;
+  XMLHttpRequest* xhr_;
+
+  // A corspreflight instance for potentially sending preflight
+  // request and performing cors check for all cross origin requests.
+  std::unique_ptr<cobalt::loader::CORSPreflight> corspreflight_;
+  // FetchAPI: transfer progress callback.
+  std::unique_ptr<FetchUpdateCallbackArg::Reference> fetch_callback_;
+  net::LoadTimingInfo load_timing_info_;
+  std::string mime_type_override_;
+  // net::URLRequest does not have origin variable so we can only store it here.
+  // https://fetch.spec.whatwg.org/#concept-request-origin
+  loader::Origin origin_;
+  net::HttpRequestHeaders request_headers_;
+  GURL request_url_;
+  std::unique_ptr<script::ScriptValue<script::ArrayBuffer>::Reference>
+      response_array_buffer_reference_;
+  std::string response_mime_type_;
+  std::unique_ptr<net::URLFetcher> url_fetcher_;
+  int url_fetcher_generation_ = -1;
+
  private:
   FRIEND_TEST_ALL_PREFIXES(XhrTest, GetResponseHeader);
   FRIEND_TEST_ALL_PREFIXES(XhrTest, InvalidMethod);
   FRIEND_TEST_ALL_PREFIXES(XhrTest, Open);
   FRIEND_TEST_ALL_PREFIXES(XhrTest, OverrideMimeType);
   FRIEND_TEST_ALL_PREFIXES(XhrTest, SetRequestHeader);
+
   // Cancel any inflight request and set error flag.
   void TerminateRequest();
   // Dispatch events based on the type of error.
-  void HandleRequestError(RequestErrorType request_error);
+  void HandleRequestError(XMLHttpRequest::RequestErrorType request_error);
   // Callback when timeout fires.
   void OnTimeout();
   // Starts the timeout timer running.
   void StartTimer(base::TimeDelta time_since_send);
   // Update the internal ready state and fire events.
-  void ChangeState(State new_state);
+  void ChangeState(XMLHttpRequest::State new_state);
   // Return array buffer response body as an ArrayBuffer.
   script::Handle<script::ArrayBuffer> response_array_buffer();
 
   void UpdateProgress(int64_t received_length);
 
-  void StartRequest(const std::string& request_body);
+  virtual void StartRequest(const std::string& request_body);
 
   // The following two methods are used to determine if garbage collection is
   // needed. It is legal to reuse XHR and send a new request in last request's
@@ -241,37 +391,19 @@
   const net::HttpRequestHeaders& request_headers() const {
     return request_headers_;
   }
-  void set_state(State state) { state_ = state; }
+  void set_state(XMLHttpRequest::State state) { state_ = state; }
   void set_http_response_headers(
       const scoped_refptr<net::HttpResponseHeaders>& response_headers) {
     http_response_headers_ = response_headers;
   }
   void PrepareForNewRequest();
 
-  scoped_refptr<dom::Document> GetDocumentResponseEntityBody();
-  void XMLDecoderLoadCompleteCallback(
-      const base::Optional<std::string>& status);
-
-  // The following method starts "url_fetcher_" with a possible pre-delay.
-  void StartURLFetcher(const SbTime max_artificial_delay,
-                       const int url_fetcher_generation);
-
-  void CORSPreflightErrorCallback();
-  void CORSPreflightSuccessCallback();
-
   THREAD_CHECKER(thread_checker_);
 
-  std::unique_ptr<net::URLFetcher> url_fetcher_;
   scoped_refptr<net::HttpResponseHeaders> http_response_headers_;
-  scoped_refptr<URLFetcherResponseWriter::Buffer> response_body_;
-  std::unique_ptr<script::ScriptValue<script::ArrayBuffer>::Reference>
-      response_array_buffer_reference_;
   scoped_refptr<XMLHttpRequestUpload> upload_;
 
-  std::string mime_type_override_;
   GURL base_url_;
-  GURL request_url_;
-  net::HttpRequestHeaders request_headers_;
 
   // For handling send() timeout.
   base::OneShotTimer timer_;
@@ -281,53 +413,52 @@
   base::TimeTicks last_progress_time_;
   base::TimeTicks upload_last_progress_time_;
 
-  // FetchAPI: transfer progress callback.
-  std::unique_ptr<FetchUpdateCallbackArg::Reference> fetch_callback_;
   // FetchAPI: tell fetch polyfill if the response mode is cors.
   std::unique_ptr<FetchModeCallbackArg::Reference> fetch_mode_callback_;
 
   // All members requiring initialization are grouped below.
-  dom::DOMSettings* const settings_;
-  State state_;
-  ResponseTypeCode response_type_;
-  uint32 timeout_ms_;
-  net::URLFetcher::RequestType method_;
-  int http_status_;
-  bool with_credentials_;
-  bool error_;
-  bool sent_;
-  bool stop_timeout_;
-  bool upload_complete_;
   int active_requests_count_;
-  // https://xhr.spec.whatwg.org/#upload-listener-flag
-  bool upload_listener_;
+  int http_status_;
+  int redirect_times_;
+  bool sent_;
+  web::EnvironmentSettings* const settings_;
+  bool stop_timeout_;
+  uint32 timeout_ms_;
+  bool upload_complete_;
 
   static bool verbose_;
-  // Unique ID for debugging.
-  int xhr_id_;
-
-  bool has_xml_decoder_error_;
 
   std::unique_ptr<script::GlobalEnvironment::ScopedPreventGarbageCollection>
       prevent_gc_until_send_complete_;
 
-  // A corspreflight instance for potentially sending preflight
-  // request and performing cors check for all cross origin requests.
-  std::unique_ptr<cobalt::loader::CORSPreflight> corspreflight_;
-  bool is_cross_origin_;
-  // net::URLRequest does not have origin variable so we can only store it here.
-  // https://fetch.spec.whatwg.org/#concept-request-origin
-  loader::Origin origin_;
-  bool is_redirect_;
-  std::string response_mime_type_;
   std::string request_body_text_;
-  int redirect_times_;
-  bool is_data_url_;
-  int url_fetcher_generation_ = -1;
+};
 
-  net::LoadTimingInfo load_timing_info_;
+class DOMXMLHttpRequestImpl : public XMLHttpRequestImpl {
+ public:
+  explicit DOMXMLHttpRequestImpl(XMLHttpRequest* xhr);
+  DOMXMLHttpRequestImpl(const DOMXMLHttpRequestImpl&) = delete;
+  DOMXMLHttpRequestImpl& operator=(const DOMXMLHttpRequestImpl&) = delete;
+  ~DOMXMLHttpRequestImpl() override {}
 
-  DISALLOW_COPY_AND_ASSIGN(XMLHttpRequest);
+  scoped_refptr<dom::Document> response_xml(
+      script::ExceptionState* exception_state) override;
+
+  void GetLoadTimingInfoAndCreateResourceTiming() override;
+
+ protected:
+  web::CspDelegate* csp_delegate() const override;
+
+ private:
+  void StartRequest(const std::string& request_body) override;
+
+  scoped_refptr<dom::Document> GetDocumentResponseEntityBody();
+
+  void XMLDecoderLoadCompleteCallback(
+      const base::Optional<std::string>& status);
+
+  dom::DOMSettings* const settings_;
+  bool has_xml_decoder_error_;
 };
 
 std::ostream& operator<<(std::ostream& out, const XMLHttpRequest& xhr);
diff --git a/cobalt/xhr/xml_http_request.idl b/cobalt/xhr/xml_http_request.idl
index 8c72a22..e6fde17 100644
--- a/cobalt/xhr/xml_http_request.idl
+++ b/cobalt/xhr/xml_http_request.idl
@@ -17,6 +17,7 @@
 [
     Constructor,
     ConstructorCallWith=EnvironmentSettings,
+    Exposed=(Window,Worker),
 ] interface XMLHttpRequest : XMLHttpRequestEventTarget {
     // event handler
     attribute EventHandler onreadystatechange;
@@ -60,6 +61,7 @@
     // TODO: Use a union type for all the possible response types.
     [RaisesException] readonly attribute (DOMString or ArrayBuffer) response;
     [RaisesException] readonly attribute DOMString responseText;
+    // TODO: responseXML should only be exposed to Window, not Worker
     [RaisesException] readonly attribute Document? responseXML;
 
     // Not part of the spec. Enable verbose XHR logging.
diff --git a/cobalt/xhr/xml_http_request_test.cc b/cobalt/xhr/xml_http_request_test.cc
index e83e21a..290566a 100644
--- a/cobalt/xhr/xml_http_request_test.cc
+++ b/cobalt/xhr/xml_http_request_test.cc
@@ -17,7 +17,9 @@
 #include <memory>
 
 #include "base/logging.h"
+#include "cobalt/dom/dom_settings.h"
 #include "cobalt/dom/testing/stub_environment_settings.h"
+#include "cobalt/dom/testing/stub_window.h"
 #include "cobalt/dom/window.h"
 #include "cobalt/script/testing/fake_script_value.h"
 #include "cobalt/script/testing/mock_exception_state.h"
@@ -90,11 +92,6 @@
 
 ScopedLogInterceptor* ScopedLogInterceptor::log_interceptor_;
 
-class FakeSettings : public dom::testing::StubEnvironmentSettings {
- public:
-  FakeSettings() { set_base_url(GURL("http://example.com")); }
-};
-
 class MockCspDelegate : public web::CspDelegateInsecure {
  public:
   MockCspDelegate() {}
@@ -102,13 +99,14 @@
                      bool(web::CspDelegate::ResourceType, const GURL&, bool));
 };
 
-// Derive from XMLHttpRequest in order to override its csp_delegate.
+// Derive from XMLHttpRequestImpl in order to override its csp_delegate.
 // Normally this would come from the Document via DOMSettings.
-class FakeXmlHttpRequest : public XMLHttpRequest {
+class FakeXmlHttpRequestImpl : public DOMXMLHttpRequestImpl {
  public:
-  FakeXmlHttpRequest(script::EnvironmentSettings* settings,
-                     web::CspDelegate* csp_delegate)
-      : XMLHttpRequest(settings), csp_delegate_(csp_delegate) {}
+  FakeXmlHttpRequestImpl(xhr::XMLHttpRequest* xhr,
+                         web::EnvironmentSettings* settings,
+                         web::CspDelegate* csp_delegate)
+      : DOMXMLHttpRequestImpl(xhr), csp_delegate_(csp_delegate) {}
   web::CspDelegate* csp_delegate() const override { return csp_delegate_; }
 
  private:
@@ -119,19 +117,23 @@
 
 class XhrTest : public ::testing::Test {
  public:
-  dom::DOMSettings* settings() const { return settings_.get(); }
+  web::EnvironmentSettings* settings() const {
+    return stub_window_->environment_settings();
+  }
 
  protected:
   XhrTest();
   ~XhrTest() override;
 
-  std::unique_ptr<FakeSettings> settings_;
+  std::unique_ptr<dom::testing::StubWindow> stub_window_;
   scoped_refptr<XMLHttpRequest> xhr_;
   StrictMock<MockExceptionState> exception_state_;
 };
 
-XhrTest::XhrTest()
-    : settings_(new FakeSettings()), xhr_(new XMLHttpRequest(settings())) {}
+XhrTest::XhrTest() : stub_window_(new dom::testing::StubWindow()) {
+  settings()->set_creation_url(GURL("http://example.com"));
+  xhr_ = scoped_refptr<XMLHttpRequest>(new XMLHttpRequest(settings()));
+}
 
 XhrTest::~XhrTest() {}
 
@@ -147,6 +149,8 @@
 TEST_F(XhrTest, Open) {
   std::unique_ptr<MockEventListener> listener = MockEventListener::Create();
   FakeScriptValue<web::EventListener> script_object(listener.get());
+  xhr_->xhr_impl_ = std::unique_ptr<FakeXmlHttpRequestImpl>(
+      new FakeXmlHttpRequestImpl(xhr_, settings(), NULL));
   xhr_->set_onreadystatechange(script_object);
   EXPECT_CALL(*listener,
               HandleEvent(Eq(xhr_),
@@ -157,7 +161,7 @@
   xhr_->Open("GET", "https://www.google.com", &exception_state_);
 
   EXPECT_EQ(XMLHttpRequest::kOpened, xhr_->ready_state());
-  EXPECT_EQ(GURL("https://www.google.com"), xhr_->request_url());
+  EXPECT_EQ(GURL("https://www.google.com"), xhr_->xhr_impl_->request_url());
 }
 
 TEST_F(XhrTest, OpenFailConnectSrc) {
@@ -167,8 +171,8 @@
   StrictMock<MockCspDelegate> csp_delegate;
   EXPECT_CALL(exception_state_, SetException(_))
       .WillOnce(SaveArg<0>(&exception));
-
-  xhr_ = new FakeXmlHttpRequest(settings(), &csp_delegate);
+  xhr_->xhr_impl_ = std::unique_ptr<FakeXmlHttpRequestImpl>(
+      new FakeXmlHttpRequestImpl(xhr_, settings(), &csp_delegate));
   EXPECT_CALL(csp_delegate, CanLoad(_, _, _)).WillOnce(Return(false));
   xhr_->Open("GET", "https://www.google.com", &exception_state_);
 
@@ -178,18 +182,18 @@
 }
 
 TEST_F(XhrTest, OverrideMimeType) {
-  EXPECT_EQ("", xhr_->mime_type_override());
+  EXPECT_EQ("", xhr_->xhr_impl_->mime_type_override());
   scoped_refptr<script::ScriptException> exception;
   EXPECT_CALL(exception_state_, SetException(_))
       .WillOnce(SaveArg<0>(&exception));
 
   xhr_->OverrideMimeType("invalidmimetype", &exception_state_);
-  EXPECT_EQ("", xhr_->mime_type_override());
+  EXPECT_EQ("", xhr_->xhr_impl_->mime_type_override());
   EXPECT_EQ(web::DOMException::kSyntaxErr,
             dynamic_cast<web::DOMException*>(exception.get())->code());
 
   xhr_->OverrideMimeType("text/xml", &exception_state_);
-  EXPECT_EQ("text/xml", xhr_->mime_type_override());
+  EXPECT_EQ("text/xml", xhr_->xhr_impl_->mime_type_override());
 }
 
 TEST_F(XhrTest, SetResponseType) {
@@ -214,26 +218,29 @@
 }
 
 TEST_F(XhrTest, SetRequestHeader) {
+  xhr_->xhr_impl_ = std::unique_ptr<FakeXmlHttpRequestImpl>(
+      new FakeXmlHttpRequestImpl(xhr_, settings(), NULL));
   xhr_->Open("GET", "https://www.google.com", &exception_state_);
-  EXPECT_EQ("\r\n", xhr_->request_headers().ToString());
+  EXPECT_EQ("\r\n", xhr_->xhr_impl_->request_headers().ToString());
 
   xhr_->SetRequestHeader("Foo", "bar", &exception_state_);
-  EXPECT_EQ("Foo: bar\r\n\r\n", xhr_->request_headers().ToString());
+  EXPECT_EQ("Foo: bar\r\n\r\n", xhr_->xhr_impl_->request_headers().ToString());
   xhr_->SetRequestHeader("Foo", "baz", &exception_state_);
-  EXPECT_EQ("Foo: bar, baz\r\n\r\n", xhr_->request_headers().ToString());
+  EXPECT_EQ("Foo: bar, baz\r\n\r\n",
+            xhr_->xhr_impl_->request_headers().ToString());
 }
 
 TEST_F(XhrTest, GetResponseHeader) {
-  xhr_->set_state(XMLHttpRequest::kUnsent);
+  xhr_->xhr_impl_->set_state(XMLHttpRequest::kUnsent);
   EXPECT_EQ(base::nullopt, xhr_->GetResponseHeader("Content-Type"));
-  xhr_->set_state(XMLHttpRequest::kOpened);
+  xhr_->xhr_impl_->set_state(XMLHttpRequest::kOpened);
   EXPECT_EQ(base::nullopt, xhr_->GetResponseHeader("Content-Type"));
-  xhr_->set_state(XMLHttpRequest::kHeadersReceived);
+  xhr_->xhr_impl_->set_state(XMLHttpRequest::kHeadersReceived);
   scoped_refptr<net::HttpResponseHeaders> fake_headers(
       new net::HttpResponseHeaders(
           std::string(kFakeHeaders, kFakeHeaders + sizeof(kFakeHeaders))));
 
-  xhr_->set_http_response_headers(fake_headers);
+  xhr_->xhr_impl_->set_http_response_headers(fake_headers);
   EXPECT_EQ(base::nullopt, xhr_->GetResponseHeader("Unknown"));
   EXPECT_EQ("text/plain", xhr_->GetResponseHeader("Content-Type").value_or(""));
   EXPECT_EQ("text/plain", xhr_->GetResponseHeader("CONTENT-TYPE").value_or(""));
diff --git a/docker/docsite/Dockerfile b/docker/docsite/Dockerfile
index 3ed5f9a..fc278cc 100644
--- a/docker/docsite/Dockerfile
+++ b/docker/docsite/Dockerfile
@@ -19,7 +19,15 @@
 ARG GID
 
 RUN apt update -qqy \
-    && apt install -qqy --no-install-recommends bundler doxygen git nodejs python \
+    && apt install -qqy --no-install-recommends \
+        bundler \
+        doxygen \
+        git \
+        nodejs \
+        python \
+        # Required for GN build.
+        python3 \
+        python3-requests \
     && apt-get clean autoclean \
     && apt-get autoremove -y --purge \
     && rm -rf /var/lib/apt/lists/* /tmp/* /var/tmp/* \
@@ -29,11 +37,26 @@
 
 RUN bundle install --gemfile=/app/Gemfile
 
+# === Get GN via CIPD
+ARG GN_SHA256SUM="af7b2dcb3905bca56655e12131b365f1cba8e159db80d2022330c4f522fab2ef  /tmp/gn.zip"
+ARG GN_HASH=r3styzkFvKVmVeEhMbNl8cuo4VnbgNICIzDE9SL6su8C
+
+RUN curl --location --silent --output /tmp/gn.zip \
+    "https://chrome-infra-packages.appspot.com/dl/gn/gn/linux-amd64/+/${GN_HASH}" \
+    && echo ${GN_SHA256SUM} | sha256sum --check \
+    && unzip /tmp/gn.zip -d /usr/local/bin \
+    && rm /tmp/gn.zip
+
 # We create and use a non-root user explicitly so that the generated and
 # modified files maintain the same permissions as the user that launched the
 # Docker container.
 RUN addgroup --group --gid "${GID}" defaultgroup \
-    && adduser --disabled-password --gecos '' --uid "${UID}" --gid "${GID}" defaultuser
+    && adduser --disabled-password --gecos '' --uid "${UID}" --gid "${GID}" ${USER:-defaultuser}
+
+# Allow the new uses to run gn and create a descriptive out directory.
+RUN chmod a+x /usr/local/bin/gn
+RUN mkdir /project_out_dir \
+    && chown ${USER:-defaultuser}:defaultgroup /project_out_dir
 
 USER ${USER:-defaultuser}
 
diff --git a/docker/docsite/docker-compose.yml b/docker/docsite/docker-compose.yml
index bc0b6e0..02e0aa5 100644
--- a/docker/docsite/docker-compose.yml
+++ b/docker/docsite/docker-compose.yml
@@ -20,12 +20,16 @@
       context: .
       dockerfile: Dockerfile
     container_name: docsite
+    environment:
+      - IS_DOCKER=1
+      - PYTHONPATH=/cobalt
     ports:
       - "4000:4000"
     volumes:
       # We use ../../ when the environment variable COBALT_SRC is not set since
       # this file is located two directories under the root of the repository.
       - ${COBALT_SRC:-../../}:/cobalt/
+
   docsite-build-only:
     container_name: docsite-build-only
     environment:
diff --git a/docker/linux/base/build/Dockerfile b/docker/linux/base/build/Dockerfile
index 27050e3..a2d683e 100644
--- a/docker/linux/base/build/Dockerfile
+++ b/docker/linux/base/build/Dockerfile
@@ -15,8 +15,6 @@
 ARG FROM_IMAGE
 FROM ${FROM_IMAGE:-cobalt-base}
 
-ARG gn_hash=vC0rxqiqGTD3ls9KJHrgJoWP2OBiPk_QEO_xbDItKYoC
-
 ARG HOME=/root
 
 # === Install common build tools, required by all platforms
@@ -50,8 +48,12 @@
 ENV PATH $NVM_DIR/versions/node/v$NODE_VERSION/bin:$PATH
 
 # === Get GN via CIPD
+ARG GN_SHA256SUM="af7b2dcb3905bca56655e12131b365f1cba8e159db80d2022330c4f522fab2ef  /tmp/gn.zip"
+ARG GN_HASH=r3styzkFvKVmVeEhMbNl8cuo4VnbgNICIzDE9SL6su8C
+
 RUN curl --location --silent --output /tmp/gn.zip \
-    "https://chrome-infra-packages.appspot.com/dl/gn/gn/linux-amd64/+/${gn_hash}" \
+    "https://chrome-infra-packages.appspot.com/dl/gn/gn/linux-amd64/+/${GN_HASH}" \
+    && echo ${GN_SHA256SUM} | sha256sum --check \
     && unzip /tmp/gn.zip -d /usr/local/bin \
     && rm /tmp/gn.zip
 
diff --git a/docker/precommit_hooks/Dockerfile b/docker/precommit_hooks/Dockerfile
index 19630fb..956c86c 100644
--- a/docker/precommit_hooks/Dockerfile
+++ b/docker/precommit_hooks/Dockerfile
@@ -27,14 +27,14 @@
 RUN pip3 install "pre-commit<3" "cpplint<2" "yapf<1" "pylint<3"
 
 # === Get GN via CIPD
-ARG GN_SHA256SUM="1291d4cf9729b6615c621139be4e9c8bb49b5cc80330e7a9e3e83c583d683f71  /usr/local/bin/gn"
-ARG GN_HASH=vC0rxqiqGTD3ls9KJHrgJoWP2OBiPk_QEO_xbDItKYoC
+ARG GN_SHA256SUM="af7b2dcb3905bca56655e12131b365f1cba8e159db80d2022330c4f522fab2ef  /tmp/gn.zip"
+ARG GN_HASH=r3styzkFvKVmVeEhMbNl8cuo4VnbgNICIzDE9SL6su8C
 
 RUN curl --location --silent --output /tmp/gn.zip \
     "https://chrome-infra-packages.appspot.com/dl/gn/gn/linux-amd64/+/${GN_HASH}" \
+    && echo ${GN_SHA256SUM} | sha256sum --check \
     && unzip /tmp/gn.zip -d /usr/local/bin \
-    && rm /tmp/gn.zip \
-    && echo ${GN_SHA256SUM} | sha256sum --check
+    && rm /tmp/gn.zip
 
 WORKDIR /code
 
diff --git a/net/BUILD.gn b/net/BUILD.gn
index 8c7de67..1044e1d 100644
--- a/net/BUILD.gn
+++ b/net/BUILD.gn
@@ -4218,6 +4218,7 @@
     "//base:i18n",
     "//base/test:test_support",
     "//base/third_party/dynamic_annotations",
+    "//cobalt/persistent_storage:persistent_settings",
     "//crypto",
     "//testing/gmock",
     "//testing/gtest",
diff --git a/net/dial/dial_http_server.cc b/net/dial/dial_http_server.cc
index dc59290..6a0dc72 100644
--- a/net/dial/dial_http_server.cc
+++ b/net/dial/dial_http_server.cc
@@ -4,6 +4,7 @@
 
 #include "net/dial/dial_http_server.h"
 
+#include <memory>
 #include <vector>
 
 #include "base/bind.h"
@@ -20,11 +21,6 @@
 #include "net/socket/stream_socket.h"
 #include "net/socket/tcp_server_socket.h"
 
-#if defined(__LB_SHELL__)
-#include "lb_network_helpers.h"
-#include "starboard/string.h"
-#endif
-
 namespace net {
 
 namespace {
@@ -59,7 +55,7 @@
   memset(&local_ip, 0, sizeof(local_ip));
   bool result = false;
 
-  // Dial Server only supports Ipv4 now.
+  // DIAL Server only supports Ipv4 now.
   SbSocketAddressType address_types = {kSbSocketAddressTypeIpv4};
   SbSocketAddress destination;
   memset(&(destination.address), 0, sizeof(destination.address));
@@ -86,7 +82,7 @@
       new net::TCPServerSocket(NULL /*net_log*/, net::NetLogSource());
   base::Optional<net::IPEndPoint> ip_addr = GetLocalIpAddress();
   if (!ip_addr) {
-    DLOG(ERROR) << "Can not get a local address for Dial HTTP Server";
+    LOG(ERROR) << "Can not get a local address for DIAL HTTP Server";
   } else {
     server_socket->ListenWithAddressAndPort(
         ip_addr.value().address().ToString(), ip_addr.value().port(),
@@ -124,12 +120,14 @@
   SbSocketAddress destination = {0};
   SbSocketAddress netmask = {0};
 
-  // Dial only works with IPv4.
+  // DIAL only works with IPv4.
   destination.type = kSbSocketAddressTypeIpv4;
   if (!SbSocketGetInterfaceAddress(&destination, &local_ip, NULL)) {
     return ERR_FAILED;
   }
   local_ip.port = addr->port();
+  LOG_ONCE(INFO) << "In-App DIAL Address http://" << addr->address().ToString()
+               << ":" << addr->port();
 
   if (addr->FromSbSocketAddress(&local_ip)) {
     return OK;
@@ -148,8 +146,7 @@
     SendDeviceDescriptionManifest(conn_id);
 
   } else if (strstr(info.path.c_str(), kAppsPrefix)) {
-    if (info.method == "GET" &&
-        info.path.length() == strlen(kAppsPrefix)) {
+    if (info.method == "GET" && info.path.length() == strlen(kAppsPrefix)) {
       // If /apps/ request, send 302 to current application.
       http_server_->SendRaw(
           conn_id,
diff --git a/net/dial/dial_udp_server.cc b/net/dial/dial_udp_server.cc
index 2555e03..3ad43c0 100644
--- a/net/dial/dial_udp_server.cc
+++ b/net/dial/dial_udp_server.cc
@@ -9,6 +9,7 @@
 #else
 #include <arpa/inet.h>
 #endif
+#include <memory>
 #include <utility>
 #include <vector>
 
@@ -77,7 +78,7 @@
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   socket_ = factory_->CreateAndBind(GetAddressForAllInterfaces(1900));
   if (!socket_) {
-    DLOG(WARNING) << "Failed to bind socket for Dial UDP Server";
+    LOG(WARNING) << "Failed to bind socket for DIAL UDP Server";
     return;
   }
 
@@ -103,8 +104,7 @@
 void DialUdpServer::Stop() {
   DCHECK(is_running_);
   thread_.message_loop()->task_runner()->PostBlockingTask(
-      FROM_HERE, base::Bind(&DialUdpServer::Shutdown,
-                            base::Unretained(this)));
+      FROM_HERE, base::Bind(&DialUdpServer::Shutdown, base::Unretained(this)));
   thread_.Stop();
 }
 
@@ -251,6 +251,7 @@
                                 DialSystemConfig::GetInstance()->model_uuid(),
                                 kDialStRequest));
   ret.append("\r\n");
+  LOG_ONCE(INFO) << "In-App DIAL Discovery response : " << ret;
   return std::move(ret);
 }
 
diff --git a/net/disk_cache/cobalt/cobalt_backend_impl.cc b/net/disk_cache/cobalt/cobalt_backend_impl.cc
index ec25ce8..76c845a 100644
--- a/net/disk_cache/cobalt/cobalt_backend_impl.cc
+++ b/net/disk_cache/cobalt/cobalt_backend_impl.cc
@@ -19,7 +19,9 @@
 #include <utility>
 
 #include "base/bind.h"
+#include "base/message_loop/message_loop.h"
 #include "base/threading/sequenced_task_runner_handle.h"
+#include "base/values.h"
 #include "net/disk_cache/backend_cleanup_tracker.h"
 
 using base::Time;
@@ -28,6 +30,8 @@
 
 namespace {
 
+const char kPersistentSettingsJson[] = "cache_settings.json";
+
 void CompletionOnceCallbackHandler(
     scoped_refptr<CobaltBackendImpl::RefCountedRunner> runner,
     int result) {
@@ -49,6 +53,17 @@
   return kOther;
 }
 
+void ReadDiskCacheSize(
+    cobalt::persistent_storage::PersistentSettings* settings) {
+  for (int i = 0; i < disk_cache::kTypeCount; i++) {
+    auto metadata = disk_cache::kTypeMetadata[i];
+    uint32_t bucket_size =
+        static_cast<uint32_t>(settings->GetPersistentSettingAsDouble(
+            metadata.directory, metadata.max_size_bytes));
+    disk_cache::kTypeMetadata[i] = {metadata.directory, bucket_size};
+  }
+}
+
 }  // namespace
 
 CobaltBackendImpl::CobaltBackendImpl(
@@ -58,12 +73,17 @@
     net::CacheType cache_type,
     net::NetLog* net_log)
     : weak_factory_(this) {
+  persistent_settings_ =
+      std::make_unique<cobalt::persistent_storage::PersistentSettings>(
+          kPersistentSettingsJson, base::MessageLoop::current()->task_runner());
+  ReadDiskCacheSize(persistent_settings_.get());
+
   // Initialize disk backend for each resource type.
   int64_t total_size = 0;
   for (int i = 0; i < kTypeCount; i++) {
-    base::FilePath dir =
-        path.Append(FILE_PATH_LITERAL(kTypeMetadata[i].directory));
-    int64_t bucket_size = kTypeMetadata[i].max_size_mb * 1024 * 1024;
+    auto metadata = kTypeMetadata[i];
+    base::FilePath dir = path.Append(FILE_PATH_LITERAL(metadata.directory));
+    int64_t bucket_size = metadata.max_size_bytes;
     total_size += bucket_size;
     SimpleBackendImpl* simple_backend = new SimpleBackendImpl(
         dir, cleanup_tracker, /* file_tracker = */ nullptr, bucket_size,
@@ -82,6 +102,28 @@
   simple_backend_map_.clear();
 }
 
+void CobaltBackendImpl::UpdateSizes(ResourceType type, uint32_t bytes) {
+  if (bytes == disk_cache::kTypeMetadata[type].max_size_bytes)
+    return;
+
+  // Static cast value to double since base::Value cannot be a long.
+  persistent_settings_->SetPersistentSetting(
+      disk_cache::kTypeMetadata[type].directory,
+      std::make_unique<base::Value>(static_cast<double>(bytes)));
+
+  disk_cache::kTypeMetadata[type].max_size_bytes = bytes;
+  SimpleBackendImpl* simple_backend = simple_backend_map_[type];
+  simple_backend->SetMaxSize(bytes);
+}
+
+uint32_t CobaltBackendImpl::GetQuota(ResourceType type) {
+  return disk_cache::kTypeMetadata[type].max_size_bytes;
+}
+
+void CobaltBackendImpl::ValidatePersistentSettings() {
+  persistent_settings_->ValidatePersistentSettings();
+}
+
 net::Error CobaltBackendImpl::Init(CompletionOnceCallback completion_callback) {
   auto closure_runner =
       base::MakeRefCounted<RefCountedRunner>(std::move(completion_callback));
diff --git a/net/disk_cache/cobalt/cobalt_backend_impl.h b/net/disk_cache/cobalt/cobalt_backend_impl.h
index 5a4443b..f76d0e9 100644
--- a/net/disk_cache/cobalt/cobalt_backend_impl.h
+++ b/net/disk_cache/cobalt/cobalt_backend_impl.h
@@ -23,6 +23,7 @@
 #include <utility>
 
 #include "base/callback_helpers.h"
+#include "cobalt/persistent_storage/persistent_settings.h"
 #include "net/base/completion_once_callback.h"
 #include "net/disk_cache/cobalt/resource_type.h"
 #include "net/disk_cache/disk_cache.h"
@@ -48,6 +49,9 @@
   ~CobaltBackendImpl() override;
 
   net::Error Init(CompletionOnceCallback completion_callback);
+  void UpdateSizes(ResourceType type, uint32_t bytes);
+  uint32_t GetQuota(ResourceType type);
+  void ValidatePersistentSettings();
 
   // Backend interface.
   net::CacheType GetCacheType() const override;
@@ -111,6 +115,10 @@
   base::WeakPtrFactory<CobaltBackendImpl> weak_factory_;
 
   std::map<ResourceType, SimpleBackendImpl*> simple_backend_map_;
+
+  // Json PrefStore used for persistent settings.
+  std::unique_ptr<cobalt::persistent_storage::PersistentSettings>
+      persistent_settings_;
 };
 
 }  // namespace disk_cache
diff --git a/net/disk_cache/cobalt/resource_type.h b/net/disk_cache/cobalt/resource_type.h
index 72af7d7..b6b5cc7 100644
--- a/net/disk_cache/cobalt/resource_type.h
+++ b/net/disk_cache/cobalt/resource_type.h
@@ -12,8 +12,10 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#ifndef RESOURCE_TYPE_H_
-#define RESOURCE_TYPE_H_
+#ifndef NET_DISK_CACHE_COBALT_RESOURCE_TYPE_H_
+#define NET_DISK_CACHE_COBALT_RESOURCE_TYPE_H_
+
+#include <string>
 
 namespace disk_cache {
 
@@ -32,15 +34,19 @@
 
 struct ResourceTypeMetadata {
   std::string directory;
-  int64_t max_size_mb;
+  uint32_t max_size_bytes;
 };
 
-// TODO: Store sizes on disk.
+static uint32_t kInitialBytes = 3 * 1024 * 1024;
+// These values are updated on start up in application.cc, using the
+// persisted values saved in settings.json.
 static ResourceTypeMetadata kTypeMetadata[] = {
-    {"other", 3}, {"html", 3},   {"css", 3},           {"image", 3},
-    {"font", 3},  {"splash", 3}, {"uncompiled_js", 3}, {"compiled_js", 3},
+    {"other", kInitialBytes},         {"html", kInitialBytes},
+    {"css", kInitialBytes},           {"image", kInitialBytes},
+    {"font", kInitialBytes},          {"splash", kInitialBytes},
+    {"uncompiled_js", kInitialBytes}, {"compiled_js", kInitialBytes},
 };
 
 }  // namespace disk_cache
 
-#endif  // RESOURCE_TYPE_H_
+#endif  // NET_DISK_CACHE_COBALT_RESOURCE_TYPE_H_
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/coat/StarboardBridge.java b/starboard/android/apk/app/src/main/java/dev/cobalt/coat/StarboardBridge.java
index f9ceeee..f956eff 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/coat/StarboardBridge.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/coat/StarboardBridge.java
@@ -42,7 +42,6 @@
 import androidx.annotation.Nullable;
 import androidx.annotation.RequiresApi;
 import dev.cobalt.account.UserAuthorizer;
-import dev.cobalt.libraries.services.clientloginfo.ClientLogInfo;
 import dev.cobalt.media.AudioOutputManager;
 import dev.cobalt.media.CaptionSettings;
 import dev.cobalt.media.CobaltMediaSession;
@@ -146,12 +145,6 @@
     activityHolder.set(activity);
     this.keyboardEditor = keyboardEditor;
     sysConfigChangeReceiver.setForeground(true);
-
-    // TODO: v0_1231sd2 is the default value used for testing,
-    // delete it once we verify it can be queried in QOE system.
-    if (!isReleaseBuild()) {
-      ClientLogInfo.setClientInfo("v0_1231sd2");
-    }
   }
 
   protected void onActivityStop(Activity activity) {
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java b/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
index e2e9b43..c0cee61 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
@@ -365,6 +365,7 @@
   private MediaCodecUtil() {}
 
   /** A wrapper class of codec capability infos. */
+  @UsedByNative
   public static class CodecCapabilityInfo {
     CodecCapabilityInfo(MediaCodecInfo codecInfo, String mimeType) {
       this.codecInfo = codecInfo;
@@ -375,13 +376,14 @@
       this.videoCapabilities = this.codecCapabilities.getVideoCapabilities();
     }
 
-    public MediaCodecInfo codecInfo;
-    public String mimeType;
-    public String decoderName;
-    public CodecCapabilities codecCapabilities;
-    public AudioCapabilities audioCapabilities;
-    public VideoCapabilities videoCapabilities;
+    @UsedByNative public MediaCodecInfo codecInfo;
+    @UsedByNative public String mimeType;
+    @UsedByNative public String decoderName;
+    @UsedByNative public CodecCapabilities codecCapabilities;
+    @UsedByNative public AudioCapabilities audioCapabilities;
+    @UsedByNative public VideoCapabilities videoCapabilities;
 
+    @UsedByNative
     public boolean isSecureRequired() {
       // MediaCodecList is supposed to feed us names of decoders that do NOT end in ".secure".  We
       // are then supposed to check if FEATURE_SecurePlayback is supported, and if it is and we
@@ -397,25 +399,30 @@
           MediaCodecInfo.CodecCapabilities.FEATURE_SecurePlayback);
     }
 
+    @UsedByNative
     public boolean isSecureSupported() {
       return this.codecCapabilities.isFeatureSupported(
           MediaCodecInfo.CodecCapabilities.FEATURE_SecurePlayback);
     }
 
+    @UsedByNative
     public boolean isTunnelModeRequired() {
       return this.codecCapabilities.isFeatureRequired(
           MediaCodecInfo.CodecCapabilities.FEATURE_TunneledPlayback);
     }
 
+    @UsedByNative
     public boolean isTunnelModeSupported() {
       return this.codecCapabilities.isFeatureSupported(
           MediaCodecInfo.CodecCapabilities.FEATURE_TunneledPlayback);
     }
 
+    @UsedByNative
     public boolean isSoftware() {
       return isSoftwareDecoder(this.codecInfo);
     }
 
+    @UsedByNative
     public boolean isHdrCapable() {
       return isHdrCapableVideoDecoder(this.mimeType, this.codecCapabilities);
     }
@@ -523,6 +530,7 @@
    * <p>NOTE: This code path is called repeatedly by the player to determine the decoding
    * capabilities of the device. To ensure speedy playback the code below should be kept performant.
    */
+  @UsedByNative
   public static String findVideoDecoder(
       String mimeType,
       boolean mustSupportSecure,
@@ -743,6 +751,7 @@
    * The same as hasAudioDecoderFor, only return the name of the audio decoder if it is found, and
    * "" otherwise.
    */
+  @UsedByNative
   public static String findAudioDecoder(
       String mimeType, int bitrate, boolean mustSupportTunnelMode) {
     // Note: MediaCodecList is sorted by the framework such that the best decoders come first.
diff --git a/starboard/android/shared/test_filters.py b/starboard/android/shared/test_filters.py
index a57ab71..8d5d0c0 100644
--- a/starboard/android/shared/test_filters.py
+++ b/starboard/android/shared/test_filters.py
@@ -16,6 +16,7 @@
 from starboard.tools.testing import test_filter
 
 # A map of failing or crashing tests per target.
+# pylint: disable=line-too-long
 _FILTERED_TESTS = {
     'player_filter_tests': [
         # GetMaxNumberOfCachedFrames() on Android is device dependent,
@@ -43,7 +44,7 @@
     'nplb': [
         # This test is failing because localhost is not defined for IPv6 in
         # /etc/hosts.
-        'SbSocketAddressTypes/SbSocketResolveTest.Localhost/1',
+        'SbSocketAddressTypes/SbSocketResolveTest.Localhost/filter_ipv6_type_ipv6',
 
         # SbDirectory has problems with empty Asset dirs.
         'SbDirectoryCanOpenTest.SunnyDayStaticContent',
@@ -67,6 +68,7 @@
         'SbDrmSessionTest.InvalidSessionUpdateRequestParams',
     ],
 }
+# pylint: enable=line-too-long
 
 
 class TestFilters(object):
diff --git a/starboard/build/config/base_configuration.gni b/starboard/build/config/base_configuration.gni
index 23b45ac..25d3ba3 100644
--- a/starboard/build/config/base_configuration.gni
+++ b/starboard/build/config/base_configuration.gni
@@ -16,6 +16,10 @@
 import("//cobalt/content/fonts/font_configuration.gni")
 import("//starboard/build/config/enable_vr.gni")
 
+# NOTE:
+# All build arguments in this file must have documentation.
+# Please follow the formatting in this file when adding new ones.
+
 declare_args() {
   # Enables the yasm compiler to be used to compile .asm files.
   yasm_exists = false
@@ -47,9 +51,14 @@
   # Whether to adopt Evergreen Lite on the Evergreen compatible platform.
   sb_evergreen_compatible_enable_lite = false
 
-  # The variables allow changing the target type on platforms where the
-  # native code may require an additional packaging step (ex. Android).
+  # The target type for test targets. Allows changing the target type
+  # on platforms where the native code may require an additional packaging step
+  # (ex. Android).
   gtest_target_type = "executable"
+
+  # The target type for executable targets. Allows changing the target type
+  # on platforms where the native code may require an additional packaging step
+  # (ex. Android).
   final_executable_type = "executable"
 
   # Halt execution on failure to allocate memory.
@@ -57,13 +66,13 @@
 
   # The source of EGL and GLES headers and libraries.
   # Valid values (case and everything sensitive!):
-  #   'none'   - No EGL + GLES implementation is available on this platform.
-  #   'system_gles2' - Use the system implementation of EGL + GLES2. The
+  #   "none"   - No EGL + GLES implementation is available on this platform.
+  #   "system_gles2" - Use the system implementation of EGL + GLES2. The
   #                    headers and libraries must be on the system include and
   #                    link paths.
-  #   'glimp'  - Cobalt's own EGL + GLES2 implementation. This requires a
+  #   "glimp"  - Cobalt's own EGL + GLES2 implementation. This requires a
   #              valid Glimp implementation for the platform.
-  #   'angle'  - A DirectX-to-OpenGL adaptation layer. This requires a valid
+  #   "angle"  - A DirectX-to-OpenGL adaptation layer. This requires a valid
   #              ANGLE implementation for the platform.
   gl_type = "system_gles2"
 
@@ -91,11 +100,19 @@
   # defines how the build should produce the install/ directory.
   install_target_path = "//starboard/build/install/no_install.gni"
 
-  # Target-specific configurations for each platform.
+  # Target-specific configurations for executable targets.
   executable_configs = []
+
+  # Target-specific configurations for shared_library targets.
   shared_library_configs = []
+
+  # Target-specific configurations for static_library targets.
   static_library_configs = []
+
+  # Target-specific configurations for source_set targets.
   source_set_configs = []
+
+  # Target-specific configurations for loadable_module targets.
   loadable_module_configs = []
 
   # Enables optimizations on SSE compatible platforms.
@@ -138,6 +155,7 @@
   # Whether or not to link with thin archives.
   use_thin_archive = true
 
+  # Whether or not to disable run-time type information (adding no_rtti flag).
   sb_use_no_rtti = false
 
   # Set to true to separate install target directories.
@@ -146,6 +164,6 @@
   # Enables an NPLB audit of C++17 support.
   sb_enable_cpp17_audit = true
 
-  # Flag to use a future version of Skia, currently not available
+  # Flag to use a future version of Skia, currently not available.
   use_skia_next = false
 }
diff --git a/starboard/build/copy_install_content.py b/starboard/build/copy_install_content.py
index 1e29cbf..00fa015 100644
--- a/starboard/build/copy_install_content.py
+++ b/starboard/build/copy_install_content.py
@@ -40,13 +40,14 @@
     # if not os.path.isfile(path):
     #   raise InvalidArgumentException(path + ' is not a file.')
 
-    # Get the path of the file relative to the source base_dir.
-    rel_path = os.path.relpath(path, base_dir)
-
     # In certain cases, files would fail to open on windows if relative paths
     # were provided.  Using absolute paths fixes this.
-    filename = os.path.abspath(os.path.join(base_dir, rel_path))
+    filename = os.path.abspath(path)
+
+    # Get the path of the file relative to the source base_dir.
+    rel_path = os.path.relpath(path, base_dir)
     output_dir = os.path.abspath(output_dir)
+    # Use rel_path to preserve the input folder structure in the output.
     output_filename = os.path.abspath(os.path.join(output_dir, rel_path))
 
     # In cases where a directory has turned into a file or vice versa, delete it
diff --git a/starboard/doc/evergreen/evergreen_binary_compression.md b/starboard/doc/evergreen/evergreen_binary_compression.md
new file mode 100644
index 0000000..fd8100d
--- /dev/null
+++ b/starboard/doc/evergreen/evergreen_binary_compression.md
@@ -0,0 +1,110 @@
+# Evergreen Binary Compression
+
+## What is Evergreen Binary Compression?
+
+Evergreen Binary Compression is a feature that reduces the amount of space used
+on-device to store Cobalt Core binaries. The binaries are stored compressed,
+using the
+[LZ4 Frame Format](https://github.com/lz4/lz4/blob/dev/doc/lz4_Frame_format.md),
+and decompressed when they are loaded and run. This optional feature is off by
+default but partners can enable it by following the instructions below.
+
+## Storage Savings
+
+Across all reference devices tested, including Raspberry Pi 2, we have seen
+compression ratios just above 2.0. We therefore expect that partners can halve
+the space used for Cobalt binary storage by enabling the feature for all
+installation slots: the system image slot and the writable slots.
+
+## Caveats
+
+### Performance Costs
+
+Because the Cobalt Core shared library must be decompressed before it's loaded,
+there is necessarily some effect on startup latency and CPU memory usage. Based
+on our analysis across a range of devices these effects are relatively small.
+
+For startup latency, we measured an increase in `libcobalt` load time in the
+hundreds of milliseconds for the low-powered Raspberry Pi 2 and in the tens of
+milliseconds for more representative, higher-powered devices. This increase is
+small in the context of overall app load time.
+
+For CPU memory usage, `libcobalt.lz4` is decompressed to an in-memory ELF file
+before the program is loaded. We therefore expect CPU memory usage to
+temporarily increase by roughly the size of the uncompressed `libcobalt` and
+then to return to a normal level once the library is loaded. And this is exactly
+what we've seen in our analysis.
+
+### Incompatibilities
+
+This feature is incompatible with the Memory Mapped file feature that is
+controlled by the `--loader_use_mmap_file` switch. With compression, we lose the
+required 1:1 mapping between the file and virtual memory. So,
+`--loader_use_mmap_file` should not be set if compression is enabled for any
+installation slots (next section).
+
+## Enabling Binary Compression
+
+Separate steps are required in order for a partner to enable compression for a)
+the system image slot and b) (Evergreen-Full only) the 2+ writable slots on a
+device.
+
+Compression for the system image slot is enabled by installing `libcobalt.lz4`
+instead of `libcobalt.so` in the read-only system image slot (i.e., SLOT_0).
+Starting with a to be determined Cobalt 23 release, the open-source releases on
+[GitHub](https://github.com/youtube/cobalt/releases) include separate CRX
+packages, denoted by a "compressed" suffix, that contain the pre-built and
+LZ4-compressed Cobalt Core binary.
+
+Compression for the writable slots is enabled by configuring Cobalt to launch
+with the `--use_compressed_updates` flag:
+
+```
+$ ./loader_app --use_compressed_updates
+```
+
+This flag instructs the Cobalt Updater to request, download, and install
+packages containing compressed Cobalt Core binaries from Google Update and
+Google Downloads. As a result, the device ends up with `libcobalt.lz4` instead
+of `libcobalt.so` in the relevant slot after its next update.
+
+Note that the system image slot is independent from the writable slots with
+respect to the compression feature: the feature can be enabled for the system
+image slot but disabled for the writable slots, or vice versa. However, we
+expect that partners will typically enable the feature for all slots in order to
+take full advantage of the storage reduction.
+
+## Disabling Binary Compression
+
+The compression feature is turned off by default. Once enabled, though, it can
+be disabled by undoing the steps required for enablement.
+
+Compression for the system image slot is disabled by installing the uncompressed
+`libcobalt.so` instead of `libcobalt.lz4` in the read-only system image slot.
+
+Compression for the writable slots is disabled by configuring Cobalt to launch
+**without** the `--use_compressed_updates` flag. The Cobalt Updater will then be
+instructed to request, download, and install packages containing the
+uncompressed Cobalt Core binaries.
+
+Note that disabling compression for the writable slots is eventual in the sense
+that the compressed Cobalt Core binaries in these slots will remain and continue
+to be used until newer versions of Cobalt Core are available on Google Update
+and Google Downloads.
+
+## FAQ
+
+### Should multiple apps that share binaries also share compression settings?
+
+The [Cobalt Evergreen Overview doc](cobalt_evergreen_overview.md) describes
+multi-app support, where multiple Cobalt-based applications share Cobalt Core
+binaries (i.e., they share the same installation slot(s)). When multi-app
+support is used then, yes, the apps should also share compression settings.
+
+For the system image slot, this means that either `libcobalt.lz4` or
+`libcobalt.so` is installed in the one, shared slot.
+
+For the writable slots, this means that the loader app is either launched with
+`--use_compressed_updates` set for all apps or launched without it for all apps.
+Otherwise, the different apps would compete with respect to whether the writable
+slots are upgraded to compressed or uncompressed binaries.
diff --git a/starboard/evergreen/arm/shared/install_target.gni b/starboard/evergreen/arm/shared/install_target.gni
index 83e7915..eaa6f16 100644
--- a/starboard/evergreen/arm/shared/install_target.gni
+++ b/starboard/evergreen/arm/shared/install_target.gni
@@ -23,7 +23,8 @@
   }
 
   if (invoker.type == "shared_library" &&
-      invoker.installable_target_name == "cobalt") {
+      filter_include([ invoker.installable_target_name ],
+                     lz4_install_targets) != []) {
     lz4_compress_install_target(target_name) {
       forward_variables_from(invoker, "*")
     }
@@ -33,7 +34,8 @@
     forward_variables_from(invoker, [ "testonly" ])
     deps = [ ":${target_name}_run_strip" ]
     if (invoker.type == "shared_library" &&
-        invoker.installable_target_name == "cobalt") {
+        filter_include([ invoker.installable_target_name ],
+                       lz4_install_targets) != []) {
       deps += [ ":${target_name}_run_lz4_compress" ]
     }
   }
diff --git a/starboard/evergreen/arm64/install_target.gni b/starboard/evergreen/arm64/install_target.gni
index bf0f54a..55d3b07 100644
--- a/starboard/evergreen/arm64/install_target.gni
+++ b/starboard/evergreen/arm64/install_target.gni
@@ -23,7 +23,8 @@
   }
 
   if (invoker.type == "shared_library" &&
-      invoker.installable_target_name == "cobalt") {
+      filter_include([ invoker.installable_target_name ],
+                     lz4_install_targets) != []) {
     lz4_compress_install_target(target_name) {
       forward_variables_from(invoker, "*")
     }
@@ -33,7 +34,8 @@
     forward_variables_from(invoker, [ "testonly" ])
     deps = [ ":${target_name}_run_strip" ]
     if (invoker.type == "shared_library" &&
-        invoker.installable_target_name == "cobalt") {
+        filter_include([ invoker.installable_target_name ],
+                       lz4_install_targets) != []) {
       deps += [ ":${target_name}_run_lz4_compress" ]
     }
   }
diff --git a/starboard/evergreen/shared/lz4_compress_install_target.gni b/starboard/evergreen/shared/lz4_compress_install_target.gni
index 69c7603..b9c0b27 100644
--- a/starboard/evergreen/shared/lz4_compress_install_target.gni
+++ b/starboard/evergreen/shared/lz4_compress_install_target.gni
@@ -14,6 +14,13 @@
 
 import("//build/compiled_action.gni")
 
+lz4_install_targets = [
+  "cobalt",
+  "crash_sandbox",
+  "noop_sandbox",
+  "one_app_only_sandbox",
+]
+
 template("lz4_compress_install_target") {
   install_target_name = target_name
   installable_target_name = invoker.installable_target_name
diff --git a/starboard/evergreen/x64/install_target.gni b/starboard/evergreen/x64/install_target.gni
index 389def0..3b5fd48 100644
--- a/starboard/evergreen/x64/install_target.gni
+++ b/starboard/evergreen/x64/install_target.gni
@@ -23,7 +23,8 @@
   }
 
   if (invoker.type == "shared_library" &&
-      invoker.installable_target_name == "cobalt") {
+      filter_include([ invoker.installable_target_name ],
+                     lz4_install_targets) != []) {
     lz4_compress_install_target(target_name) {
       forward_variables_from(invoker, "*")
     }
@@ -33,7 +34,8 @@
     forward_variables_from(invoker, [ "testonly" ])
     deps = [ ":${target_name}_run_strip" ]
     if (invoker.type == "shared_library" &&
-        invoker.installable_target_name == "cobalt") {
+        filter_include([ invoker.installable_target_name ],
+                       lz4_install_targets) != []) {
       deps += [ ":${target_name}_run_lz4_compress" ]
     }
   }
diff --git a/starboard/evergreen/x86/install_target.gni b/starboard/evergreen/x86/install_target.gni
index d0ab661..90a1b77 100644
--- a/starboard/evergreen/x86/install_target.gni
+++ b/starboard/evergreen/x86/install_target.gni
@@ -23,7 +23,8 @@
   }
 
   if (invoker.type == "shared_library" &&
-      invoker.installable_target_name == "cobalt") {
+      filter_include([ invoker.installable_target_name ],
+                     lz4_install_targets) != []) {
     lz4_compress_install_target(target_name) {
       forward_variables_from(invoker, "*")
     }
@@ -33,7 +34,8 @@
     forward_variables_from(invoker, [ "testonly" ])
     deps = [ ":${target_name}_run_strip" ]
     if (invoker.type == "shared_library" &&
-        invoker.installable_target_name == "cobalt") {
+        filter_include([ invoker.installable_target_name ],
+                       lz4_install_targets) != []) {
       deps += [ ":${target_name}_run_lz4_compress" ]
     }
   }
diff --git a/starboard/linux/shared/test_filters.py b/starboard/linux/shared/test_filters.py
index 9592f73..b92b3a9 100644
--- a/starboard/linux/shared/test_filters.py
+++ b/starboard/linux/shared/test_filters.py
@@ -30,27 +30,24 @@
 # Conditionally disables tests that require ipv6
 if os.getenv('IPV6_AVAILABLE', '1') == '0':
   _FILTERED_TESTS['nplb'].extend([
-      'SbSocketAddressTypes/SbSocketGetInterfaceAddressTest.SunnyDayDestination/1',
-      'SbSocketAddressTypes/SbSocketGetInterfaceAddressTest.SunnyDaySourceForDestination/1',
-      'SbSocketAddressTypes/SbSocketGetInterfaceAddressTest.SunnyDaySourceNotLoopback/1',
+      'SbSocketAddressTypes/SbSocketGetInterfaceAddressTest.SunnyDayDestination/type_ipv6',
+      'SbSocketAddressTypes/SbSocketGetInterfaceAddressTest.SunnyDaySourceForDestination/type_ipv6',
+      'SbSocketAddressTypes/SbSocketGetInterfaceAddressTest.SunnyDaySourceNotLoopback/type_ipv6',
+      'SbSocketAddressTypes/SbSocketBindTest.RainyDayBadInterface/type_ipv6_filter_ipv6',
+      'SbSocketAddressTypes/PairSbSocketGetLocalAddressTest.SunnyDayConnected/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketIsConnectedAndIdleTest.SunnyDay/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketIsConnectedTest.SunnyDay/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketReceiveFromTest.SunnyDay/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/SbSocketResolveTest.Localhost/filter_ipv6_type_ipv6',
+      'SbSocketAddressTypes/SbSocketResolveTest.SunnyDayFiltered/filter_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketSendToTest.RainyDaySendToClosedSocket/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketSendToTest.RainyDaySendToSocketUntilBlocking/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketSendToTest.RainyDaySendToSocketConnectionReset/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketWaiterWaitTest.SunnyDay/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketWaiterWaitTest.SunnyDayAlreadyReady/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketWaiterWaitTimedTest.SunnyDay/type_ipv6_type_ipv6',
+      'SbSocketAddressTypes/PairSbSocketWrapperTest.SunnyDay/type_ipv6_type_ipv6',
   ])
-# TODO: Re-enable once tests or infra fixed.
-_FILTERED_TESTS['nplb'].extend([
-    'SbSocketAddressTypes/SbSocketBindTest.RainyDayBadInterface/1',
-    'SbSocketAddressTypes/PairSbSocketGetLocalAddressTest.SunnyDayConnected/1',
-    'SbSocketAddressTypes/PairSbSocketIsConnectedAndIdleTest.SunnyDay/1',
-    'SbSocketAddressTypes/PairSbSocketIsConnectedTest.SunnyDay/1',
-    'SbSocketAddressTypes/PairSbSocketReceiveFromTest.SunnyDay/1',
-    'SbSocketAddressTypes/SbSocketResolveTest.Localhost/1',
-    'SbSocketAddressTypes/SbSocketResolveTest.SunnyDayFiltered/1',
-    'SbSocketAddressTypes/PairSbSocketSendToTest.RainyDaySendToClosedSocket/1',
-    'SbSocketAddressTypes/PairSbSocketSendToTest.RainyDaySendToSocketUntilBlocking/1',
-    'SbSocketAddressTypes/PairSbSocketSendToTest.RainyDaySendToSocketConnectionReset/1',
-    'SbSocketAddressTypes/PairSbSocketWaiterWaitTest.SunnyDay/1',
-    'SbSocketAddressTypes/PairSbSocketWaiterWaitTest.SunnyDayAlreadyReady/1',
-    'SbSocketAddressTypes/PairSbSocketWaiterWaitTimedTest.SunnyDay/1',
-    'SbSocketAddressTypes/PairSbSocketWrapperTest.SunnyDay/1',
-])
 
 # pylint: enable=line-too-long
 
diff --git a/starboard/loader_app/loader_app.cc b/starboard/loader_app/loader_app.cc
index 929c875..8bae605 100644
--- a/starboard/loader_app/loader_app.cc
+++ b/starboard/loader_app/loader_app.cc
@@ -249,7 +249,7 @@
       std::string url =
           command_line.GetSwitchValue(starboard::loader_app::kURL);
       if (url.empty()) {
-        url = "https://www.youtube.com/tv";
+        url = kCobaltDefaultUrl;
       }
       std::string app_key = starboard::loader_app::GetAppKey(url);
       SB_CHECK(!app_key.empty());
diff --git a/starboard/nplb/file_read_write_all_test.cc b/starboard/nplb/file_read_write_all_test.cc
index 9782fde..4871cea 100644
--- a/starboard/nplb/file_read_write_all_test.cc
+++ b/starboard/nplb/file_read_write_all_test.cc
@@ -20,8 +20,7 @@
 namespace nplb {
 namespace {
 
-class SbReadWriteAllTestWithBuffer
-    : public ::testing::TestWithParam<int> {
+class SbReadWriteAllTestWithBuffer : public ::testing::TestWithParam<int> {
  public:
   int GetBufferSize() { return GetParam(); }
 };
@@ -30,8 +29,8 @@
   ScopedRandomFile random_file(0, ScopedRandomFile::kDontCreate);
   const std::string& filename = random_file.filename();
 
-  SbFile file = SbFileOpen(
-      filename.c_str(), kSbFileCreateAlways | kSbFileWrite, NULL, NULL);
+  SbFile file = SbFileOpen(filename.c_str(), kSbFileCreateAlways | kSbFileWrite,
+                           NULL, NULL);
 
   std::vector<char> file_contents;
   file_contents.reserve(GetBufferSize());
@@ -44,8 +43,8 @@
 
   SbFileClose(file);
 
-  file = SbFileOpen(
-      filename.c_str(), kSbFileOpenOnly | kSbFileRead, NULL, NULL);
+  file =
+      SbFileOpen(filename.c_str(), kSbFileOpenOnly | kSbFileRead, NULL, NULL);
   std::vector<char> read_contents(GetBufferSize());
   int bytes_read =
       SbFileReadAll(file, read_contents.data(), read_contents.size());
@@ -58,7 +57,8 @@
 INSTANTIATE_TEST_CASE_P(
     SbReadAllTestSbReadWriteAllTest,
     SbReadWriteAllTestWithBuffer,
-    ::testing::Values(0, 1, 1024, 16 * 1024, 128 * 1024, 1024 * 1024));
+    ::testing::Values(0, 1, 1024, 16 * 1024, 128 * 1024, 1024 * 1024),
+    ::testing::PrintToStringParamName());
 
 }  // namespace
 }  // namespace nplb
diff --git a/starboard/nplb/player_write_sample_test.cc b/starboard/nplb/player_write_sample_test.cc
index f80bb0e..1eca87f 100644
--- a/starboard/nplb/player_write_sample_test.cc
+++ b/starboard/nplb/player_write_sample_test.cc
@@ -192,6 +192,21 @@
                                                          : "Punchout");
 }
 
+std::string GetSbPlayerTestConfigName(
+    ::testing::TestParamInfo<SbPlayerTestConfig> info) {
+  const char* audio_filename = std::get<0>(info.param);
+  const char* video_filename = std::get<1>(info.param);
+  SbPlayerOutputMode output_mode = std::get<2>(info.param);
+  std::string name(FormatString(
+      "audio_%s_video_%s_output_%s", audio_filename, video_filename,
+      output_mode == kSbPlayerOutputModeDecodeToTexture ? "DecodeToTexture"
+                                                        : "Punchout"));
+  std::replace(name.begin(), name.end(), '.', '_');
+  std::replace(name.begin(), name.end(), '(', '_');
+  std::replace(name.begin(), name.end(), ')', '_');
+  return name;
+}
+
 void SbPlayerWriteSampleTest::SetUp() {
   SbMediaVideoCodec video_codec = dmp_reader_->video_codec();
   SbMediaAudioCodec audio_codec = dmp_reader_->audio_codec();
@@ -506,7 +521,8 @@
 
 INSTANTIATE_TEST_CASE_P(SbPlayerWriteSampleTests,
                         SbPlayerWriteSampleTest,
-                        ValuesIn(GetSupportedSbPlayerTestConfigs()));
+                        ValuesIn(GetSupportedSbPlayerTestConfigs()),
+                        GetSbPlayerTestConfigName);
 
 }  // namespace
 }  // namespace nplb
diff --git a/starboard/nplb/socket_accept_test.cc b/starboard/nplb/socket_accept_test.cc
index b3c38a4..35195bf 100644
--- a/starboard/nplb/socket_accept_test.cc
+++ b/starboard/nplb/socket_accept_test.cc
@@ -76,11 +76,13 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketAcceptTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketAcceptTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_bind_test.cc b/starboard/nplb/socket_bind_test.cc
index cf1ca79..f5b3a1a 100644
--- a/starboard/nplb/socket_bind_test.cc
+++ b/starboard/nplb/socket_bind_test.cc
@@ -129,19 +129,22 @@
     SbSocketBindTest,
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketResolveFilterIpv4),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketResolveFilterIpv6)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketResolveFilterIpv6)),
+    GetSbSocketAddressTypeFilterPairName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketBindTest,
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     SbSocketBindTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketResolveFilterIpv4)));
+                                     kSbSocketResolveFilterIpv4)),
+    GetSbSocketAddressTypeFilterPairName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_connect_test.cc b/starboard/nplb/socket_connect_test.cc
index 91063ed..7c545a0 100644
--- a/starboard/nplb/socket_connect_test.cc
+++ b/starboard/nplb/socket_connect_test.cc
@@ -49,11 +49,13 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketConnectTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketConnectTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_create_test.cc b/starboard/nplb/socket_create_test.cc
index b34bdb0..301b12e 100644
--- a/starboard/nplb/socket_create_test.cc
+++ b/starboard/nplb/socket_create_test.cc
@@ -13,6 +13,7 @@
 // limitations under the License.
 
 #include "starboard/common/socket.h"
+#include "starboard/nplb/socket_helpers.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace starboard {
@@ -83,11 +84,13 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketCreateTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketCreateTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 #endif
 
 INSTANTIATE_TEST_CASE_P(
@@ -97,7 +100,8 @@
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketProtocolTcp),
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketProtocolUdp),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketProtocolTcp),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketProtocolUdp)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketProtocolUdp)),
+    GetSbSocketAddressTypeProtocolPairName);
 
 }  // namespace
 }  // namespace nplb
diff --git a/starboard/nplb/socket_get_interface_address_test.cc b/starboard/nplb/socket_get_interface_address_test.cc
index 9a01488..2bfc328 100644
--- a/starboard/nplb/socket_get_interface_address_test.cc
+++ b/starboard/nplb/socket_get_interface_address_test.cc
@@ -177,11 +177,13 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketGetInterfaceAddressTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketGetInterfaceAddressTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 #endif  // SB_HAS(IPV6)
 
 }  // namespace
diff --git a/starboard/nplb/socket_get_local_address_test.cc b/starboard/nplb/socket_get_local_address_test.cc
index 6fd2b72..29d9a6d 100644
--- a/starboard/nplb/socket_get_local_address_test.cc
+++ b/starboard/nplb/socket_get_local_address_test.cc
@@ -125,23 +125,27 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketGetLocalAddressTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketGetLocalAddressTest,
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv4),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketGetLocalAddressTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketGetLocalAddressTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_helpers.cc b/starboard/nplb/socket_helpers.cc
index b9b33fc..6efecd2 100644
--- a/starboard/nplb/socket_helpers.cc
+++ b/starboard/nplb/socket_helpers.cc
@@ -14,8 +14,11 @@
 
 #include "starboard/nplb/socket_helpers.h"
 
+#include <utility>
+
 #include "starboard/common/scoped_ptr.h"
 #include "starboard/common/socket.h"
+#include "starboard/common/string.h"
 #include "starboard/once.h"
 #include "starboard/socket_waiter.h"
 #include "starboard/thread.h"
@@ -550,5 +553,87 @@
   return SbTimeGetMonotonicNow() - start;
 }
 
+#if !defined(COBALT_BUILD_TYPE_GOLD)
+namespace {
+const char* SbSocketAddressTypeName(SbSocketAddressType type) {
+  const char* name = "unknown";
+  switch (type) {
+    case kSbSocketAddressTypeIpv4:
+      name = "ipv4";
+      break;
+    case kSbSocketAddressTypeIpv6:
+      name = "ipv6";
+      break;
+  }
+  return name;
+}
+
+const char* SbSocketAddressFilterName(SbSocketResolveFilter filter) {
+  const char* name = "unknown";
+  switch (filter) {
+    case kSbSocketResolveFilterNone:
+      name = "none";
+      break;
+    case kSbSocketResolveFilterIpv4:
+      name = "ipv4";
+      break;
+    case kSbSocketResolveFilterIpv6:
+      name = "ipv6";
+      break;
+  }
+  return name;
+}
+
+const char* SbSocketProtocolName(SbSocketProtocol protocol) {
+  const char* name = "unknown";
+  switch (protocol) {
+    case kSbSocketProtocolTcp:
+      name = "tcp";
+      break;
+    case kSbSocketProtocolUdp:
+      name = "udp";
+      break;
+  }
+  return name;
+}
+}  // namespace
+
+std::string GetSbSocketAddressTypeName(
+    ::testing::TestParamInfo<SbSocketAddressType> info) {
+  return FormatString("type_%s", SbSocketAddressTypeName(info.param));
+}
+std::string GetSbSocketAddressTypePairName(
+    ::testing::TestParamInfo<
+        std::pair<SbSocketAddressType, SbSocketAddressType>> info) {
+  return FormatString("type_%s_type_%s",
+                      SbSocketAddressTypeName(info.param.first),
+                      SbSocketAddressTypeName(info.param.second));
+}
+
+std::string GetSbSocketAddressTypeFilterPairName(
+    ::testing::TestParamInfo<
+        std::pair<SbSocketAddressType, SbSocketResolveFilter>> info) {
+  return FormatString("type_%s_filter_%s",
+                      SbSocketAddressTypeName(info.param.first),
+                      SbSocketAddressFilterName(info.param.second));
+}
+
+std::string GetSbSocketFilterAddressTypePairName(
+    ::testing::TestParamInfo<
+        std::pair<SbSocketResolveFilter, SbSocketAddressType>> info) {
+  return FormatString("filter_%s_type_%s",
+                      SbSocketAddressFilterName(info.param.first),
+                      SbSocketAddressTypeName(info.param.second));
+}
+
+std::string GetSbSocketAddressTypeProtocolPairName(
+    ::testing::TestParamInfo<std::pair<SbSocketAddressType, SbSocketProtocol>>
+        info) {
+  return FormatString("type_%s_%s", SbSocketAddressTypeName(info.param.first),
+                      SbSocketProtocolName(info.param.second));
+}
+
+#endif  // #if !defined(COBALT_BUILD_TYPE_GOLD)
+
 }  // namespace nplb
 }  // namespace starboard
diff --git a/starboard/nplb/socket_helpers.h b/starboard/nplb/socket_helpers.h
index b9905bb..4d28134 100644
--- a/starboard/nplb/socket_helpers.h
+++ b/starboard/nplb/socket_helpers.h
@@ -15,6 +15,8 @@
 #ifndef STARBOARD_NPLB_SOCKET_HELPERS_H_
 #define STARBOARD_NPLB_SOCKET_HELPERS_H_
 
+#include <string>
+#include <utility>
 #include <vector>
 
 #include "starboard/common/scoped_ptr.h"
@@ -198,6 +200,23 @@
         << "With " #error " = " << error;                               \
   } while (false)
 
+#if !defined(COBALT_BUILD_TYPE_GOLD)
+std::string GetSbSocketAddressTypeName(
+    ::testing::TestParamInfo<SbSocketAddressType> info);
+std::string GetSbSocketAddressTypePairName(
+    ::testing::TestParamInfo<
+        std::pair<SbSocketAddressType, SbSocketAddressType>> info);
+std::string GetSbSocketAddressTypeFilterPairName(
+    ::testing::TestParamInfo<
+        std::pair<SbSocketAddressType, SbSocketResolveFilter>> info);
+std::string GetSbSocketFilterAddressTypePairName(
+    ::testing::TestParamInfo<
+        std::pair<SbSocketResolveFilter, SbSocketAddressType>> info);
+std::string GetSbSocketAddressTypeProtocolPairName(
+    ::testing::TestParamInfo<std::pair<SbSocketAddressType, SbSocketProtocol>>
+        info);
+#endif  // #if !defined(COBALT_BUILD_TYPE_GOLD)
+
 }  // namespace nplb
 }  // namespace starboard
 
diff --git a/starboard/nplb/socket_is_connected_and_idle_test.cc b/starboard/nplb/socket_is_connected_and_idle_test.cc
index 56ded31..3a16795 100644
--- a/starboard/nplb/socket_is_connected_and_idle_test.cc
+++ b/starboard/nplb/socket_is_connected_and_idle_test.cc
@@ -97,23 +97,27 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketIsConnectedAndIdleTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketIsConnectedAndIdleTest,
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv4),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketIsConnectedAndIdleTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketIsConnectedAndIdleTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_is_connected_test.cc b/starboard/nplb/socket_is_connected_test.cc
index f847917..3c2bfdd 100644
--- a/starboard/nplb/socket_is_connected_test.cc
+++ b/starboard/nplb/socket_is_connected_test.cc
@@ -81,23 +81,27 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketIsConnectedTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketIsConnectedTest,
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv4),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketIsConnectedTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketIsConnectedTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_listen_test.cc b/starboard/nplb/socket_listen_test.cc
index 13366e5..9dff540 100644
--- a/starboard/nplb/socket_listen_test.cc
+++ b/starboard/nplb/socket_listen_test.cc
@@ -54,11 +54,13 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketListenTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketListenTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_receive_from_test.cc b/starboard/nplb/socket_receive_from_test.cc
index 2c05228..b9deb06 100644
--- a/starboard/nplb/socket_receive_from_test.cc
+++ b/starboard/nplb/socket_receive_from_test.cc
@@ -132,13 +132,15 @@
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv4),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketReceiveFromTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_resolve_test.cc b/starboard/nplb/socket_resolve_test.cc
index f50f855..ad923c0 100644
--- a/starboard/nplb/socket_resolve_test.cc
+++ b/starboard/nplb/socket_resolve_test.cc
@@ -114,13 +114,15 @@
     SbSocketResolveTest,
     ::testing::Values(
         std::make_pair(kSbSocketResolveFilterIpv4, kSbSocketAddressTypeIpv4),
-        std::make_pair(kSbSocketResolveFilterIpv6, kSbSocketAddressTypeIpv6)));
+        std::make_pair(kSbSocketResolveFilterIpv6, kSbSocketAddressTypeIpv6)),
+    GetSbSocketFilterAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     SbSocketResolveTest,
     ::testing::Values(std::make_pair(kSbSocketResolveFilterIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketFilterAddressTypePairName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_send_to_test.cc b/starboard/nplb/socket_send_to_test.cc
index b20f816..f0be4d5 100644
--- a/starboard/nplb/socket_send_to_test.cc
+++ b/starboard/nplb/socket_send_to_test.cc
@@ -195,13 +195,15 @@
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv4),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketSendToTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #endif
 }  // namespace
 }  // namespace nplb
diff --git a/starboard/nplb/socket_set_options_test.cc b/starboard/nplb/socket_set_options_test.cc
index 6a11414..60e0c17 100644
--- a/starboard/nplb/socket_set_options_test.cc
+++ b/starboard/nplb/socket_set_options_test.cc
@@ -60,11 +60,13 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketSetOptionsTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketSetOptionsTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_waiter_add_test.cc b/starboard/nplb/socket_waiter_add_test.cc
index 1b29ae7..f1d60cc 100644
--- a/starboard/nplb/socket_waiter_add_test.cc
+++ b/starboard/nplb/socket_waiter_add_test.cc
@@ -210,11 +210,13 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketWaiterAddTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketWaiterAddTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_waiter_remove_test.cc b/starboard/nplb/socket_waiter_remove_test.cc
index 7ef883b..12c3627 100644
--- a/starboard/nplb/socket_waiter_remove_test.cc
+++ b/starboard/nplb/socket_waiter_remove_test.cc
@@ -82,11 +82,13 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketWaiterRemoveTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketWaiterRemoveTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_waiter_wait_test.cc b/starboard/nplb/socket_waiter_wait_test.cc
index f49b8ad..53743e2 100644
--- a/starboard/nplb/socket_waiter_wait_test.cc
+++ b/starboard/nplb/socket_waiter_wait_test.cc
@@ -259,23 +259,27 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketWaiterWaitTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketWaiterWaitTest,
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv4),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketWaiterWaitTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketWaiterWaitTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_waiter_wait_timed_test.cc b/starboard/nplb/socket_waiter_wait_timed_test.cc
index a35a17b..7541bef 100644
--- a/starboard/nplb/socket_waiter_wait_timed_test.cc
+++ b/starboard/nplb/socket_waiter_wait_timed_test.cc
@@ -129,23 +129,27 @@
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketWaiterWaitTimedTest,
                         ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
+                                          kSbSocketAddressTypeIpv6),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketWaiterWaitTimedTest,
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv4),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
                         SbSocketWaiterWaitTimedTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
+                        ::testing::Values(kSbSocketAddressTypeIpv4),
+                        GetSbSocketAddressTypeName);
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketWaiterWaitTimedTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #endif
 
 }  // namespace
diff --git a/starboard/nplb/socket_wrapper_test.cc b/starboard/nplb/socket_wrapper_test.cc
index bff5189..9d2c442 100644
--- a/starboard/nplb/socket_wrapper_test.cc
+++ b/starboard/nplb/socket_wrapper_test.cc
@@ -89,13 +89,15 @@
     ::testing::Values(
         std::make_pair(kSbSocketAddressTypeIpv4, kSbSocketAddressTypeIpv4),
         std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv6),
-        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)));
+        std::make_pair(kSbSocketAddressTypeIpv6, kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #else
 INSTANTIATE_TEST_CASE_P(
     SbSocketAddressTypes,
     PairSbSocketWrapperTest,
     ::testing::Values(std::make_pair(kSbSocketAddressTypeIpv4,
-                                     kSbSocketAddressTypeIpv4)));
+                                     kSbSocketAddressTypeIpv4)),
+    GetSbSocketAddressTypePairName);
 #endif
 
 }  // namespace
diff --git a/starboard/shared/ffmpeg/BUILD.gn b/starboard/shared/ffmpeg/BUILD.gn
index 21316bb..2482113 100644
--- a/starboard/shared/ffmpeg/BUILD.gn
+++ b/starboard/shared/ffmpeg/BUILD.gn
@@ -12,15 +12,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-declare_args() {
-  # Whether or not to enable the ffmpeg_demuxer_test target. The target will
-  # only work if ffmpeg 58.35.100 is installed on the build machine.
-  #
-  # TODO(b/239961799): Rework the test to run regardless of the installed
-  # ffmpeg version.
-  enable_ffmpeg_demuxer_test = false
-}
-
 ffmpeg_specialization_sources = [
   "ffmpeg_audio_decoder_impl.cc",
   "ffmpeg_audio_decoder_impl.h",
@@ -106,29 +97,17 @@
   public_configs = [ "//starboard/build/config:starboard_implementation" ]
 }
 
-if (enable_ffmpeg_demuxer_test) {
-  target(gtest_target_type, "ffmpeg_demuxer_test") {
-    testonly = true
-    configs += [ "//starboard/build/config:starboard_implementation" ]
-    sources = ffmpeg_specialization_sources + [
-                "ffmpeg_demuxer.h",
-                "ffmpeg_demuxer.cc",
-                "ffmpeg_demuxer_test.cc",
-              ]
-
-    # Build only against one specified version of the ffmpeg includes. That means
-    # that this binary will only work well when run on a machine with the given
-    # version of ffmpeg installed. This test binary actually should have
-    # specializations for all supported ffmpeg versions, or it should only test
-    # the behavior of the abstraction layer without testing implementation
-    # details.
-    include_dirs = [ "//third_party/ffmpeg_includes/ffmpeg.58.35.100" ]
-    deps = [
-      "//cobalt/test:run_all_unittests",
-      "//starboard",
-      "//starboard/common",
-      "//testing/gmock",
-      "//testing/gtest",
-    ]
-  }
+target(gtest_target_type, "ffmpeg_demuxer_test") {
+  testonly = true
+  sources = [ "ffmpeg_demuxer_test.cc" ]
+  configs += [ "//starboard/build/config:starboard_implementation" ]
+  deps = [
+    ":ffmpeg_dispatch_sources",
+    "//cobalt/test:run_all_unittests",
+    "//starboard",
+    "//starboard/common",
+    "//testing/gmock",
+    "//testing/gtest",
+  ]
+  data_deps = [ "//third_party/chromium/media/test/data:media_testdata" ]
 }
diff --git a/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.cc b/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.cc
index b95d777..0e6cf9a 100644
--- a/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.cc
+++ b/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.cc
@@ -400,10 +400,17 @@
 }
 #endif  // LIBAVUTIL_VERSION_INT >= LIBAVUTIL_VERSION_52_8
 
-void FFmpegDemuxerImpl<FFMPEG>::ScopedPtrAVFree::operator()(void* ptr) const {
+void FFmpegDemuxerImpl<FFMPEG>::ScopedPtrAVFreeAVIOContext::operator()(
+    void* ptr) const {
   if (!ptr) {
     return;
   }
+  // From the documentation of avio_alloc_context, AVIOContext's buffer must be
+  // freed separately from the AVIOContext.
+  unsigned char* buffer = static_cast<AVIOContext*>(ptr)->buffer;
+  if (buffer) {
+    GetDispatch()->av_free(buffer);
+  }
   GetDispatch()->av_free(ptr);
 }
 
diff --git a/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.h b/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.h
index cc609c5..cbe4b09 100644
--- a/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.h
+++ b/starboard/shared/ffmpeg/ffmpeg_demuxer_impl.h
@@ -69,7 +69,7 @@
   };
 #endif  // LIBAVUTIL_VERSION_INT >= LIBAVUTIL_VERSION_52_8
 
-  struct ScopedPtrAVFree {
+  struct ScopedPtrAVFreeAVIOContext {
     void operator()(void* ptr) const;
   };
 
@@ -125,7 +125,7 @@
   int64_t timeline_offset_us_ = 0L;
 
   // FFmpeg-related structs.
-  std::unique_ptr<AVIOContext, ScopedPtrAVFree> avio_context_;
+  std::unique_ptr<AVIOContext, ScopedPtrAVFreeAVIOContext> avio_context_;
   AVFormatContext* format_context_ = nullptr;
 };
 
diff --git a/starboard/shared/ffmpeg/ffmpeg_demuxer_test.cc b/starboard/shared/ffmpeg/ffmpeg_demuxer_test.cc
index 927adcb..49b7f5d 100644
--- a/starboard/shared/ffmpeg/ffmpeg_demuxer_test.cc
+++ b/starboard/shared/ffmpeg/ffmpeg_demuxer_test.cc
@@ -16,12 +16,14 @@
 
 #include <cstdint>
 #include <cstdlib>
+#include <fstream>
 #include <memory>
-#include <tuple>
+#include <string>
 #include <vector>
 
-#include "starboard/shared/ffmpeg/ffmpeg_common.h"
-#include "starboard/shared/ffmpeg/ffmpeg_dispatch.h"
+#include "starboard/configuration_constants.h"
+#include "starboard/log.h"
+#include "starboard/system.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -31,70 +33,32 @@
 namespace {
 
 using ::testing::_;
-using ::testing::AllArgs;
+using ::testing::AtLeast;
 using ::testing::ElementsAreArray;
-using ::testing::Eq;
 using ::testing::ExplainMatchResult;
+using ::testing::Ge;
 using ::testing::Invoke;
 using ::testing::IsNull;
 using ::testing::MockFunction;
 using ::testing::NotNull;
-using ::testing::Pointee;
-using ::testing::Pointwise;
-using ::testing::Return;
-using ::testing::SaveArg;
-using ::testing::WithArg;
-
-// Compares two CobaltExtensionDemuxerSideData structs. Deep equality is
-// checked; in other words, the actual side data is inspected (not just the ptr
-// addresses).
-MATCHER_P(SideDataEq, expected, "") {
-  return arg.type == expected.type && arg.data_size == expected.data_size &&
-         ExplainMatchResult(
-             ElementsAreArray(expected.data,
-                              static_cast<size_t>(expected.data_size)),
-             std::tuple<uint8_t*, size_t>{arg.data, arg.data_size},
-             result_listener);
-}
-
-// Compares two CobaltExtensionDemuxerBuffers. Deep equality is checked; the
-// side data and data are checked element-by-element, rather than simply
-// checking ptr addresses.
-MATCHER_P(BufferMatches, expected_buffer, "") {
-  if (expected_buffer.end_of_stream) {
-    // For EoS buffers, we don't care about the other values.
-    return arg.end_of_stream;
-  }
-
-  if (arg.data_size != expected_buffer.data_size) {
-    return false;
-  }
-  if (!ExplainMatchResult(
-          ElementsAreArray(expected_buffer.data,
-                           static_cast<size_t>(expected_buffer.data_size)),
-          std::tuple<uint8_t*, size_t>{arg.data, arg.data_size},
-          result_listener)) {
-    return false;
-  }
-  if (arg.side_data_elements != expected_buffer.side_data_elements) {
-    return false;
-  }
-  // Note: ::testing::Pointwise doesn't support pointer/count as a
-  // representation of an array, so we manually check each side data element.
-  for (int i = 0; i < expected_buffer.side_data_elements; ++i) {
-    if (!ExplainMatchResult(SideDataEq(expected_buffer.side_data[i]),
-                            arg.side_data[i], result_listener)) {
-      return false;
-    }
-  }
-  return (arg.pts == expected_buffer.pts &&
-          arg.duration == expected_buffer.duration &&
-          arg.is_keyframe == expected_buffer.is_keyframe &&
-          arg.end_of_stream == expected_buffer.end_of_stream);
-}
+using ::testing::SizeIs;
 
 // Streaming is not supported.
 constexpr bool kIsStreaming = false;
+constexpr char kInputWebm[] = "bear-320x240.webm";
+
+std::string ResolveTestFilename(const char* filename) {
+  std::vector<char> content_path(kSbFileMaxPath);
+  SB_CHECK(SbSystemGetPath(kSbSystemPathContentDirectory, content_path.data(),
+                           kSbFileMaxPath));
+  const std::string directory_path =
+      std::string(content_path.data()) + kSbFileSepChar + "third_party" +
+      kSbFileSepChar + "chromium" + kSbFileSepChar + "media" + kSbFileSepChar +
+      "test" + kSbFileSepChar + "data";
+  SB_CHECK(SbDirectoryCanOpen(directory_path.c_str()))
+      << "Cannot open directory " << directory_path;
+  return directory_path + kSbFileSepChar + filename;
+}
 
 // Used to convert a MockFn to a pure C function.
 template <typename T, typename U>
@@ -102,179 +66,6 @@
   static_cast<T*>(user_data)->AsStdFunction()(u);
 }
 
-// A mock class for receiving FFmpeg calls. The API mimics the relevant parts of
-// the real FFmpeg API.
-class MockFFmpegImpl {
- public:
-  MOCK_METHOD1(AVCodecFreeContext, void(AVCodecContext** avctx));
-  MOCK_METHOD1(AVFree, void(void* ptr));
-  MOCK_METHOD4(AVRescaleRnd, int64_t(int64_t a, int64_t b, int64_t c, int rnd));
-  MOCK_METHOD4(AVDictGet,
-               AVDictionaryEntry*(const AVDictionary* m,
-                                  const char* key,
-                                  const AVDictionaryEntry* prev,
-                                  int flags));
-  MOCK_METHOD4(AVFormatOpenInput,
-               int(AVFormatContext** ps,
-                   const char* filename,
-                   AVInputFormat* fmt,
-                   AVDictionary** options));
-  MOCK_METHOD1(AVFormatCloseInput, void(AVFormatContext** s));
-  MOCK_METHOD7(
-      AVIOAllocContext,
-      AVIOContext*(
-          unsigned char* buffer,
-          int buffer_size,
-          int write_flag,
-          void* opaque,
-          int (*read_packet)(void* opaque, uint8_t* buf, int buf_size),
-          int (*write_packet)(void* opaque, uint8_t* buf, int buf_size),
-          int64_t (*seek)(void* opaque, int64_t offset, int whence)));
-  MOCK_METHOD1(AVMalloc, void*(size_t size));
-  MOCK_METHOD0(AVFormatAllocContext, AVFormatContext*());
-  MOCK_METHOD2(AVFormatFindStreamInfo,
-               int(AVFormatContext* ic, AVDictionary** options));
-  MOCK_METHOD4(
-      AVSeekFrame,
-      int(AVFormatContext* s, int stream_index, int64_t timestamp, int flags));
-  MOCK_METHOD0(AVPacketAlloc, AVPacket*());
-  MOCK_METHOD1(AVPacketFree, void(AVPacket** pkt));
-  MOCK_METHOD1(AVPacketUnref, void(AVPacket* pkt));
-  MOCK_METHOD2(AVReadFrame, int(AVFormatContext* s, AVPacket* pkt));
-  MOCK_METHOD1(AVCodecAllocContext3, AVCodecContext*(const AVCodec* codec));
-  MOCK_METHOD2(AVCodecParametersToContext,
-               int(AVCodecContext* codec, const AVCodecParameters* par));
-};
-
-// Returns a MockFFmpegImpl instance. It should not be deleted by the caller.
-MockFFmpegImpl* GetMockFFmpegImpl() {
-  static auto* const ffmpeg_wrapper = []() {
-    auto* wrapper = new MockFFmpegImpl;
-    // This mock won't be destructed.
-    testing::Mock::AllowLeak(wrapper);
-    return wrapper;
-  }();
-  return ffmpeg_wrapper;
-}
-
-// Pure C functions that call the static mock.
-void mock_avcodec_free_context(AVCodecContext** avctx) {
-  GetMockFFmpegImpl()->AVCodecFreeContext(avctx);
-}
-
-void mock_av_free(void* ptr) {
-  GetMockFFmpegImpl()->AVFree(ptr);
-}
-
-int64_t mock_av_rescale_rnd(int64_t a, int64_t b, int64_t c, int rnd) {
-  return GetMockFFmpegImpl()->AVRescaleRnd(a, b, c, rnd);
-}
-
-AVDictionaryEntry* mock_av_dict_get(const AVDictionary* m,
-                                    const char* key,
-                                    const AVDictionaryEntry* prev,
-                                    int flags) {
-  return GetMockFFmpegImpl()->AVDictGet(m, key, prev, flags);
-}
-
-int mock_avformat_open_input(AVFormatContext** ps,
-                             const char* filename,
-                             AVInputFormat* fmt,
-                             AVDictionary** options) {
-  return GetMockFFmpegImpl()->AVFormatOpenInput(ps, filename, fmt, options);
-}
-
-void mock_avformat_close_input(AVFormatContext** s) {
-  GetMockFFmpegImpl()->AVFormatCloseInput(s);
-}
-
-AVIOContext* mock_avio_alloc_context(
-    unsigned char* buffer,
-    int buffer_size,
-    int write_flag,
-    void* opaque,
-    int (*read_packet)(void* opaque, uint8_t* buf, int buf_size),
-    int (*write_packet)(void* opaque, uint8_t* buf, int buf_size),
-    int64_t (*seek)(void* opaque, int64_t offset, int whence)) {
-  return GetMockFFmpegImpl()->AVIOAllocContext(
-      buffer, buffer_size, write_flag, opaque, read_packet, write_packet, seek);
-}
-
-void* mock_av_malloc(size_t size) {
-  return GetMockFFmpegImpl()->AVMalloc(size);
-}
-
-AVFormatContext* mock_avformat_alloc_context() {
-  return GetMockFFmpegImpl()->AVFormatAllocContext();
-}
-
-int mock_avformat_find_stream_info(AVFormatContext* ic,
-                                   AVDictionary** options) {
-  return GetMockFFmpegImpl()->AVFormatFindStreamInfo(ic, options);
-}
-
-int mock_av_seek_frame(AVFormatContext* s,
-                       int stream_index,
-                       int64_t timestamp,
-                       int flags) {
-  return GetMockFFmpegImpl()->AVSeekFrame(s, stream_index, timestamp, flags);
-}
-
-AVPacket* mock_av_packet_alloc() {
-  return GetMockFFmpegImpl()->AVPacketAlloc();
-}
-
-void mock_av_packet_free(AVPacket** pkt) {
-  GetMockFFmpegImpl()->AVPacketFree(pkt);
-}
-
-void mock_av_packet_unref(AVPacket* pkt) {
-  GetMockFFmpegImpl()->AVPacketUnref(pkt);
-}
-
-int mock_av_read_frame(AVFormatContext* s, AVPacket* pkt) {
-  return GetMockFFmpegImpl()->AVReadFrame(s, pkt);
-}
-
-AVCodecContext* mock_avcodec_alloc_context3(const AVCodec* codec) {
-  return GetMockFFmpegImpl()->AVCodecAllocContext3(codec);
-}
-
-int mock_avcodec_parameters_to_context(AVCodecContext* codec,
-                                       const AVCodecParameters* par) {
-  return GetMockFFmpegImpl()->AVCodecParametersToContext(codec, par);
-}
-
-// Returns an FFMPEGDispatch instance that forwards calls to the mock stored in
-// GetMockFFmpegImpl() above. The returned FFMPEGDispatch should not be
-// deleted; it has static storage duration.
-FFMPEGDispatch* GetFFMPEGDispatch() {
-  static auto* const ffmpeg_dispatch = []() -> FFMPEGDispatch* {
-    auto* dispatch = new FFMPEGDispatch;
-    dispatch->avcodec_free_context = &mock_avcodec_free_context;
-    dispatch->av_free = &mock_av_free;
-    dispatch->av_rescale_rnd = &mock_av_rescale_rnd;
-    dispatch->av_dict_get = &mock_av_dict_get;
-    dispatch->avformat_open_input = &mock_avformat_open_input;
-    dispatch->avformat_close_input = &mock_avformat_close_input;
-    dispatch->avio_alloc_context = &mock_avio_alloc_context;
-    dispatch->av_malloc = &mock_av_malloc;
-    dispatch->avformat_alloc_context = &mock_avformat_alloc_context;
-    dispatch->avformat_find_stream_info = &mock_avformat_find_stream_info;
-    dispatch->av_seek_frame = &mock_av_seek_frame;
-    dispatch->av_packet_alloc = &mock_av_packet_alloc;
-    dispatch->av_packet_free = &mock_av_packet_free;
-    dispatch->av_packet_unref = &mock_av_packet_unref;
-    dispatch->av_read_frame = &mock_av_read_frame;
-    dispatch->avcodec_alloc_context3 = &mock_avcodec_alloc_context3;
-    dispatch->avcodec_parameters_to_context =
-        &mock_avcodec_parameters_to_context;
-    return dispatch;
-  }();
-
-  return ffmpeg_dispatch;
-}
-
 // A mock class representing a data source passed to the cobalt extension
 // demuxer.
 class MockDataSource {
@@ -285,104 +76,44 @@
   MOCK_METHOD0(GetSize, int64_t());
 };
 
-// These functions forward calls to a MockDataSource.
-int MockBlockingRead(uint8_t* data, int bytes_requested, void* user_data) {
-  return static_cast<MockDataSource*>(user_data)->BlockingRead(data,
-                                                               bytes_requested);
+// These functions forward calls to a FstreamDataSource.
+int FstreamBlockingRead(uint8_t* data, int bytes_requested, void* user_data) {
+  auto* input = static_cast<std::ifstream*>(user_data);
+  input->read(reinterpret_cast<char*>(data), bytes_requested);
+  return input->gcount();
 }
 
-void MockSeekTo(int position, void* user_data) {
-  static_cast<MockDataSource*>(user_data)->SeekTo(position);
+void FstreamSeekTo(int position, void* user_data) {
+  auto* input = static_cast<std::ifstream*>(user_data);
+  input->seekg(position, input->beg);
 }
 
-int64_t MockGetPosition(void* user_data) {
-  return static_cast<MockDataSource*>(user_data)->GetPosition();
+int64_t FstreamGetPosition(void* user_data) {
+  return static_cast<std::ifstream*>(user_data)->tellg();
 }
 
-int64_t MockGetSize(void* user_data) {
-  return static_cast<MockDataSource*>(user_data)->GetSize();
+int64_t FstreamGetSize(void* user_data) {
+  // Seek to the end of the file to get the size, then seek back to the current
+  // position.
+  auto* input = static_cast<std::ifstream*>(user_data);
+  const auto current_pos = input->tellg();
+  input->seekg(0, input->end);
+  const int64_t filesize = input->tellg();
+  input->seekg(current_pos);
+  return filesize;
 }
 
-// A test fixture is used to ensure that the (static) mock is checked and reset
-// between tests.
-class FFmpegDemuxerTest : public ::testing::Test {
- public:
-  FFmpegDemuxerTest() {
-    FFmpegDemuxer::TestOnlySetFFmpegDispatch(GetFFMPEGDispatch());
-  }
-
-  ~FFmpegDemuxerTest() override {
-    testing::Mock::VerifyAndClearExpectations(GetMockFFmpegImpl());
-  }
-};
-
-TEST_F(FFmpegDemuxerTest, InitializeAllocatesContextAndOpensInput) {
-  auto* const mock_ffmpeg_wrapper = GetMockFFmpegImpl();
-
-  AVFormatContext format_context = {};
-  AVInputFormat iformat = {};
-  iformat.name = "mp4";
-  format_context.iformat = &iformat;
-
-  std::vector<AVStream> streams = {AVStream{}};
-  std::vector<AVStream*> stream_ptrs = {&streams[0]};
-  std::vector<AVCodecParameters> stream_params = {AVCodecParameters{}};
-  stream_params[0].codec_type = AVMEDIA_TYPE_AUDIO;
-  stream_params[0].codec_id = AV_CODEC_ID_AAC;
-
-  AVIOContext avio_context = {};
-  AVCodecContext codec_context = {};
-
-  // Sanity checks; if any of these fail, the test has a bug.
-  SB_CHECK(streams.size() == stream_ptrs.size());
-  SB_CHECK(streams.size() == stream_params.size());
-
-  for (int i = 0; i < streams.size(); ++i) {
-    streams[i].codecpar = &stream_params[i];
-    streams[i].time_base.num = 1;
-    streams[i].time_base.den = 1000000;
-    streams[i].start_time = 0;
-  }
-
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatAllocContext())
-      .WillOnce(Return(&format_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVFormatCloseInput(Pointee(Eq(&format_context))))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVMalloc(_)).Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVIOAllocContext(_, _, _, _, _, _, _))
-      .WillOnce(Return(&avio_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVFormatOpenInput(Pointee(Eq(&format_context)), _, _, _))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatFindStreamInfo(&format_context, _))
-      .WillOnce(WithArg<0>(Invoke([&stream_ptrs](AVFormatContext* context) {
-        context->nb_streams = stream_ptrs.size();
-        context->streams = stream_ptrs.data();
-        context->duration = 120 * AV_TIME_BASE;
-        return 0;
-      })));
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVCodecAllocContext3(_))
-      .WillOnce(Return(&codec_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecFreeContext(Pointee(Eq(&codec_context))))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecParametersToContext(&codec_context, streams[0].codecpar))
-      .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
-        context->codec_id = AV_CODEC_ID_AAC;
-        context->sample_fmt = AV_SAMPLE_FMT_FLT;
-        context->channel_layout = AV_CH_LAYOUT_STEREO;
-        context->channels = 2;
-        context->sample_rate = 44100;
-        return 0;
-      })));
+TEST(FFmpegDemuxerTest, InitializeSucceeds) {
+  const std::string filename = ResolveTestFilename(kInputWebm);
+  std::ifstream input(filename, std::ios_base::binary);
+  SB_CHECK(input.good()) << "Unable to load file " << filename;
 
   const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+  ASSERT_THAT(api, NotNull());
   MockDataSource data_source;
   CobaltExtensionDemuxerDataSource c_data_source{
-      &MockBlockingRead, &MockSeekTo,  &MockGetPosition,
-      &MockGetSize,      kIsStreaming, &data_source};
+      &FstreamBlockingRead, &FstreamSeekTo, &FstreamGetPosition,
+      &FstreamGetSize,      kIsStreaming,   &input};
   std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
   std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
 
@@ -391,114 +122,23 @@
       supported_audio_codecs.size(), supported_video_codecs.data(),
       supported_video_codecs.size());
 
-  ASSERT_THAT(api, NotNull());
+  ASSERT_THAT(demuxer, NotNull());
   EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
 
   api->DestroyDemuxer(demuxer);
 }
 
-TEST_F(FFmpegDemuxerTest, ReadsDataFromDataSource) {
-  auto* const mock_ffmpeg_wrapper = GetMockFFmpegImpl();
-  constexpr size_t kReadSize = 5;
-
-  AVFormatContext format_context = {};
-  AVInputFormat iformat = {};
-  iformat.name = "mp4";
-  format_context.iformat = &iformat;
-
-  std::vector<AVStream> streams = {AVStream{}};
-  std::vector<AVStream*> stream_ptrs = {&streams[0]};
-  std::vector<AVCodecParameters> stream_params = {AVCodecParameters{}};
-  stream_params[0].codec_type = AVMEDIA_TYPE_AUDIO;
-  stream_params[0].codec_id = AV_CODEC_ID_AAC;
-
-  AVIOContext avio_context = {};
-  AVCodecContext codec_context = {};
-
-  // Sanity checks; if any of these fail, the test has a bug.
-  SB_CHECK(streams.size() == stream_ptrs.size());
-  SB_CHECK(streams.size() == stream_params.size());
-
-  for (int i = 0; i < streams.size(); ++i) {
-    streams[i].codecpar = &stream_params[i];
-    streams[i].time_base.num = 1;
-    streams[i].time_base.den = 1000000;
-    streams[i].start_time = 0;
-    streams[i].index = i;
-  }
-
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatAllocContext())
-      .WillOnce(Return(&format_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVFormatCloseInput(Pointee(Eq(&format_context))))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVMalloc(_)).Times(1);
-
-  // We will capture the AVIO read operation passed to FFmpeg, so that we can
-  // simulate FFmpeg reading data from the data source.
-  int (*read_packet)(void*, uint8_t*, int) = nullptr;
-  // Data blob that will be passed to read_packet.
-  void* opaque_read_packet = nullptr;
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVIOAllocContext(_, _, _, _, _, _, _))
-      .WillOnce(DoAll(SaveArg<3>(&opaque_read_packet), SaveArg<4>(&read_packet),
-                      Return(&avio_context)));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVFormatOpenInput(Pointee(Eq(&format_context)), _, _, _))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatFindStreamInfo(&format_context, _))
-      .WillOnce(WithArg<0>(Invoke([&stream_ptrs](AVFormatContext* context) {
-        context->nb_streams = stream_ptrs.size();
-        context->streams = stream_ptrs.data();
-        context->duration = 120 * AV_TIME_BASE;
-        return 0;
-      })));
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVCodecAllocContext3(_))
-      .WillOnce(Return(&codec_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecFreeContext(Pointee(Eq(&codec_context))))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecParametersToContext(&codec_context, streams[0].codecpar))
-      .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
-        context->codec_id = AV_CODEC_ID_AAC;
-        context->sample_fmt = AV_SAMPLE_FMT_FLT;
-        context->channel_layout = AV_CH_LAYOUT_STEREO;
-        context->channels = 2;
-        context->sample_rate = 44100;
-        return 0;
-      })));
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVReadFrame(&format_context, _))
-      .WillOnce(WithArg<1>(Invoke([&opaque_read_packet, &read_packet,
-                                   kReadSize](AVPacket* packet) {
-        SB_CHECK(read_packet != nullptr)
-            << "FFmpeg's read operation should be set via avio_alloc_context "
-               "before av_read_frame is called.";
-        // This will be freed when av_packet_free is called (which eventually
-        // calls AVPacketFree).
-        packet->data =
-            static_cast<uint8_t*>(malloc(kReadSize * sizeof(uint8_t)));
-        packet->size = kReadSize;
-        read_packet(opaque_read_packet, packet->data, kReadSize);
-        return 0;
-      })));
+TEST(FFmpegDemuxerTest, ReadsAudioData) {
+  const std::string filename = ResolveTestFilename(kInputWebm);
+  std::ifstream input(filename, std::ios_base::binary);
+  SB_CHECK(input.good()) << "Unable to load file " << filename;
 
   const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
   ASSERT_THAT(api, NotNull());
-
-  std::vector<uint8_t> expected_data = {0, 1, 2, 3, 4};
-  SB_CHECK(expected_data.size() == kReadSize);
-
   MockDataSource data_source;
-  EXPECT_CALL(data_source, BlockingRead(_, kReadSize))
-      .WillOnce(WithArg<0>(Invoke([expected_data](uint8_t* buffer) {
-        for (int i = 0; i < expected_data.size(); ++i) {
-          buffer[i] = expected_data[i];
-        }
-        return kReadSize;
-      })));
   CobaltExtensionDemuxerDataSource c_data_source{
-      &MockBlockingRead, &MockSeekTo,  &MockGetPosition,
-      &MockGetSize,      kIsStreaming, &data_source};
+      &FstreamBlockingRead, &FstreamSeekTo, &FstreamGetPosition,
+      &FstreamGetSize,      kIsStreaming,   &input};
   std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
   std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
 
@@ -507,103 +147,56 @@
       supported_audio_codecs.size(), supported_video_codecs.data(),
       supported_video_codecs.size());
 
+  ASSERT_THAT(demuxer, NotNull());
   EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
 
-  const CobaltExtensionDemuxerBuffer expected_buffer = {
-      expected_data.data(),
-      static_cast<int64_t>(expected_data.size()),
-      nullptr,
-      0,
-      0,
-      0,
-      false,
-      false};
+  const std::vector<uint8_t> expected_audio = {
+      0xbc, 0xd6, 0xf2, 0xda, 0x7b, 0xad, 0xe5, 0xb5,
+      0x87, 0x29, 0x05, 0x50, 0x6b, 0xfc, 0x6f, 0xd6,
+  };
 
   MockFunction<void(CobaltExtensionDemuxerBuffer*)> read_cb;
-  AVPacket av_packet = {};
+  std::vector<uint8_t> actual_audio;
+  bool read_eos = false;
 
-  // This is the main check: we ensure that the expected buffer is passed to us
-  // via the read callback.
-  EXPECT_CALL(read_cb, Call(Pointee(BufferMatches(expected_buffer)))).Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVPacketAlloc())
-      .WillOnce(Return(&av_packet));
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVPacketFree(Pointee(Eq(&av_packet))))
-      .WillOnce(Invoke([](AVPacket** av_packet) { free((*av_packet)->data); }));
+  EXPECT_CALL(read_cb, Call(_))
+      .Times(AtLeast(1))
+      .WillRepeatedly(Invoke([&](CobaltExtensionDemuxerBuffer* buffer) {
+        SB_CHECK(buffer);
+        if (buffer->end_of_stream || buffer->data_size <= 0) {
+          read_eos = buffer->end_of_stream;
+          return;
+        }
+        actual_audio.insert(actual_audio.end(), buffer->data,
+                            buffer->data + buffer->data_size);
+      }));
 
-  demuxer->Read(kCobaltExtensionDemuxerStreamTypeAudio,
-                &CallMockCB<decltype(read_cb), CobaltExtensionDemuxerBuffer>,
-                &read_cb, demuxer->user_data);
+  // Calling Read may return less -- or more -- data than we need. Keep reading
+  // until we have at least as much data as the amount we're checking.
+  while (!read_eos && actual_audio.size() < expected_audio.size()) {
+    demuxer->Read(kCobaltExtensionDemuxerStreamTypeAudio,
+                  &CallMockCB<decltype(read_cb), CobaltExtensionDemuxerBuffer>,
+                  &read_cb, demuxer->user_data);
+  }
+
+  ASSERT_THAT(actual_audio, SizeIs(Ge(expected_audio.size())));
+  actual_audio.resize(expected_audio.size());
+  EXPECT_THAT(actual_audio, ElementsAreArray(expected_audio));
 
   api->DestroyDemuxer(demuxer);
 }
 
-TEST_F(FFmpegDemuxerTest, ReturnsAudioConfig) {
-  auto* const mock_ffmpeg_wrapper = GetMockFFmpegImpl();
-
-  AVFormatContext format_context = {};
-  AVInputFormat iformat = {};
-  iformat.name = "mp4";
-  format_context.iformat = &iformat;
-
-  std::vector<AVStream> streams = {AVStream{}};
-  std::vector<AVStream*> stream_ptrs = {&streams[0]};
-  std::vector<AVCodecParameters> stream_params = {AVCodecParameters{}};
-  stream_params[0].codec_type = AVMEDIA_TYPE_AUDIO;
-  stream_params[0].codec_id = AV_CODEC_ID_AAC;
-
-  AVIOContext avio_context = {};
-  AVCodecContext codec_context = {};
-
-  // Sanity checks; if any of these fail, the test has a bug.
-  SB_CHECK(streams.size() == stream_ptrs.size());
-  SB_CHECK(streams.size() == stream_params.size());
-
-  for (int i = 0; i < streams.size(); ++i) {
-    streams[i].codecpar = &stream_params[i];
-    streams[i].time_base.num = 1;
-    streams[i].time_base.den = 1000000;
-    streams[i].start_time = 0;
-  }
-
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatAllocContext())
-      .WillOnce(Return(&format_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVFormatCloseInput(Pointee(Eq(&format_context))))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVMalloc(_)).Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVIOAllocContext(_, _, _, _, _, _, _))
-      .WillOnce(Return(&avio_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVFormatOpenInput(Pointee(Eq(&format_context)), _, _, _))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatFindStreamInfo(&format_context, _))
-      .WillOnce(WithArg<0>(Invoke([&stream_ptrs](AVFormatContext* context) {
-        context->nb_streams = stream_ptrs.size();
-        context->streams = stream_ptrs.data();
-        context->duration = 120 * AV_TIME_BASE;
-        return 0;
-      })));
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVCodecAllocContext3(_))
-      .WillOnce(Return(&codec_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecFreeContext(Pointee(Eq(&codec_context))))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecParametersToContext(&codec_context, streams[0].codecpar))
-      .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
-        context->codec_id = AV_CODEC_ID_AAC;
-        context->sample_fmt = AV_SAMPLE_FMT_FLT;
-        context->channel_layout = AV_CH_LAYOUT_STEREO;
-        context->channels = 2;
-        context->sample_rate = 44100;
-        return 0;
-      })));
+TEST(FFmpegDemuxerTest, ReadsVideoData) {
+  const std::string filename = ResolveTestFilename(kInputWebm);
+  std::ifstream input(filename, std::ios_base::binary);
+  SB_CHECK(input.good()) << "Unable to load file " << filename;
 
   const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+  ASSERT_THAT(api, NotNull());
   MockDataSource data_source;
   CobaltExtensionDemuxerDataSource c_data_source{
-      &MockBlockingRead, &MockSeekTo,  &MockGetPosition,
-      &MockGetSize,      kIsStreaming, &data_source};
+      &FstreamBlockingRead, &FstreamSeekTo, &FstreamGetPosition,
+      &FstreamGetSize,      kIsStreaming,   &input};
   std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
   std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
 
@@ -612,119 +205,93 @@
       supported_audio_codecs.size(), supported_video_codecs.data(),
       supported_video_codecs.size());
 
-  ASSERT_THAT(api, NotNull());
+  ASSERT_THAT(demuxer, NotNull());
   EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
 
-  CobaltExtensionDemuxerAudioDecoderConfig actual_audio_config = {};
-  demuxer->GetAudioConfig(&actual_audio_config, demuxer->user_data);
+  const std::vector<uint8_t> expected_video = {
+      0x50, 0x04, 0x01, 0x9d, 0x01, 0x2a, 0x40, 0x01,
+      0xf0, 0x00, 0x00, 0x47, 0x08, 0x85, 0x85, 0x88,
+  };
 
-  // These values are derived from those set via AVCodecParametersToContext.
-  EXPECT_EQ(actual_audio_config.codec, kCobaltExtensionDemuxerCodecAAC);
-  EXPECT_EQ(actual_audio_config.sample_format,
-            kCobaltExtensionDemuxerSampleFormatF32);
-  EXPECT_EQ(actual_audio_config.channel_layout,
+  MockFunction<void(CobaltExtensionDemuxerBuffer*)> read_cb;
+  std::vector<uint8_t> actual_video;
+  bool read_eos = false;
+
+  EXPECT_CALL(read_cb, Call(_))
+      .Times(AtLeast(1))
+      .WillRepeatedly(Invoke([&](CobaltExtensionDemuxerBuffer* buffer) {
+        SB_CHECK(buffer);
+        if (buffer->end_of_stream || buffer->data_size <= 0) {
+          read_eos = buffer->end_of_stream;
+          return;
+        }
+        actual_video.insert(actual_video.end(), buffer->data,
+                            buffer->data + buffer->data_size);
+      }));
+
+  // Calling Read may return less -- or more -- data than we need. Keep reading
+  // until we have at least as much data as the amount we're checking.
+  while (!read_eos && actual_video.size() < expected_video.size()) {
+    demuxer->Read(kCobaltExtensionDemuxerStreamTypeVideo,
+                  &CallMockCB<decltype(read_cb), CobaltExtensionDemuxerBuffer>,
+                  &read_cb, demuxer->user_data);
+  }
+
+  ASSERT_THAT(actual_video, SizeIs(Ge(expected_video.size())));
+  actual_video.resize(expected_video.size());
+  EXPECT_THAT(actual_video, ElementsAreArray(expected_video));
+
+  api->DestroyDemuxer(demuxer);
+}
+
+TEST(FFmpegDemuxerTest, PopulatesAudioConfig) {
+  const std::string filename = ResolveTestFilename(kInputWebm);
+  std::ifstream input(filename, std::ios_base::binary);
+  SB_CHECK(input.good()) << "Unable to load file " << filename;
+
+  const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+  ASSERT_THAT(api, NotNull());
+  MockDataSource data_source;
+  CobaltExtensionDemuxerDataSource c_data_source{
+      &FstreamBlockingRead, &FstreamSeekTo, &FstreamGetPosition,
+      &FstreamGetSize,      kIsStreaming,   &input};
+  std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+  std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+  CobaltExtensionDemuxer* demuxer = api->CreateDemuxer(
+      &c_data_source, supported_audio_codecs.data(),
+      supported_audio_codecs.size(), supported_video_codecs.data(),
+      supported_video_codecs.size());
+
+  ASSERT_THAT(demuxer, NotNull());
+  EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
+
+  CobaltExtensionDemuxerAudioDecoderConfig actual_config = {};
+  demuxer->GetAudioConfig(&actual_config, demuxer->user_data);
+
+  EXPECT_EQ(actual_config.codec, kCobaltExtensionDemuxerCodecVorbis);
+  EXPECT_EQ(actual_config.sample_format,
+            kCobaltExtensionDemuxerSampleFormatPlanarF32);
+  EXPECT_EQ(actual_config.channel_layout,
             kCobaltExtensionDemuxerChannelLayoutStereo);
-  EXPECT_EQ(actual_audio_config.encryption_scheme,
+  EXPECT_EQ(actual_config.encryption_scheme,
             kCobaltExtensionDemuxerEncryptionSchemeUnencrypted);
-  EXPECT_EQ(actual_audio_config.samples_per_second, 44100);
-  EXPECT_THAT(actual_audio_config.extra_data, IsNull());
-  EXPECT_EQ(actual_audio_config.extra_data_size, 0);
+  EXPECT_EQ(actual_config.samples_per_second, 44100);
 
   api->DestroyDemuxer(demuxer);
 }
 
-TEST_F(FFmpegDemuxerTest, ReturnsVideoConfig) {
-  auto* const mock_ffmpeg_wrapper = GetMockFFmpegImpl();
-
-  AVFormatContext format_context = {};
-  AVInputFormat iformat = {};
-  iformat.name = "mp4";
-  format_context.iformat = &iformat;
-
-  // In this test we simulate both an audio stream and a video stream being
-  // present.
-  std::vector<AVStream> streams = {AVStream{}, AVStream{}};
-  std::vector<AVStream*> stream_ptrs = {&streams[0], &streams[1]};
-  std::vector<AVCodecParameters> stream_params = {AVCodecParameters{},
-                                                  AVCodecParameters{}};
-  stream_params[0].codec_type = AVMEDIA_TYPE_AUDIO;
-  stream_params[0].codec_id = AV_CODEC_ID_AAC;
-  stream_params[1].codec_type = AVMEDIA_TYPE_VIDEO;
-  stream_params[1].codec_id = AV_CODEC_ID_H264;
-
-  AVIOContext avio_context = {};
-  AVCodecContext codec_context_1 = {};
-  AVCodecContext codec_context_2 = {};
-
-  // Sanity checks; if any of these fail, the test has a bug.
-  SB_CHECK(streams.size() == stream_ptrs.size());
-  SB_CHECK(streams.size() == stream_params.size());
-
-  for (int i = 0; i < streams.size(); ++i) {
-    streams[i].codecpar = &stream_params[i];
-    streams[i].time_base.num = 1;
-    streams[i].time_base.den = 1000000;
-    streams[i].start_time = 0;
-  }
-
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatAllocContext())
-      .WillOnce(Return(&format_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVFormatCloseInput(Pointee(Eq(&format_context))))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVMalloc(_)).Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVIOAllocContext(_, _, _, _, _, _, _))
-      .WillOnce(Return(&avio_context));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVFormatOpenInput(Pointee(Eq(&format_context)), _, _, _))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVFormatFindStreamInfo(&format_context, _))
-      .WillOnce(WithArg<0>(Invoke([&stream_ptrs](AVFormatContext* context) {
-        context->nb_streams = stream_ptrs.size();
-        context->streams = stream_ptrs.data();
-        context->duration = 120 * AV_TIME_BASE;
-        return 0;
-      })));
-  EXPECT_CALL(*mock_ffmpeg_wrapper, AVCodecAllocContext3(_))
-      .WillOnce(Return(&codec_context_1))
-      .WillOnce(Return(&codec_context_2));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecFreeContext(Pointee(Eq(&codec_context_1))))
-      .Times(1);
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecFreeContext(Pointee(Eq(&codec_context_2))))
-      .Times(1);
-
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecParametersToContext(_, streams[0].codecpar))
-      .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
-        context->codec_id = AV_CODEC_ID_AAC;
-        context->sample_fmt = AV_SAMPLE_FMT_FLT;
-        context->channel_layout = AV_CH_LAYOUT_STEREO;
-        context->channels = 2;
-        context->sample_rate = 44100;
-        return 0;
-      })));
-  EXPECT_CALL(*mock_ffmpeg_wrapper,
-              AVCodecParametersToContext(_, streams[1].codecpar))
-      .WillOnce(WithArg<0>(Invoke([](AVCodecContext* context) {
-        context->codec_id = AV_CODEC_ID_H264;
-        context->width = 1920;
-        context->height = 1080;
-        context->sample_aspect_ratio.num = 1;
-        context->sample_aspect_ratio.den = 1;
-        context->profile = FF_PROFILE_H264_BASELINE;
-        context->pix_fmt = AV_PIX_FMT_YUVJ420P;
-        context->colorspace = AVCOL_SPC_BT709;
-        context->color_range = AVCOL_RANGE_MPEG;
-        return 0;
-      })));
+TEST(FFmpegDemuxerTest, PopulatesVideoConfig) {
+  const std::string filename = ResolveTestFilename(kInputWebm);
+  std::ifstream input(filename, std::ios_base::binary);
+  SB_CHECK(input.good()) << "Unable to load file " << filename;
 
   const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+  ASSERT_THAT(api, NotNull());
   MockDataSource data_source;
   CobaltExtensionDemuxerDataSource c_data_source{
-      &MockBlockingRead, &MockSeekTo,  &MockGetPosition,
-      &MockGetSize,      kIsStreaming, &data_source};
+      &FstreamBlockingRead, &FstreamSeekTo, &FstreamGetPosition,
+      &FstreamGetSize,      kIsStreaming,   &input};
   std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
   std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
 
@@ -733,26 +300,110 @@
       supported_audio_codecs.size(), supported_video_codecs.data(),
       supported_video_codecs.size());
 
-  ASSERT_THAT(api, NotNull());
+  ASSERT_THAT(demuxer, NotNull());
   EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
 
-  CobaltExtensionDemuxerVideoDecoderConfig actual_video_config = {};
-  demuxer->GetVideoConfig(&actual_video_config, demuxer->user_data);
+  CobaltExtensionDemuxerVideoDecoderConfig actual_config = {};
+  demuxer->GetVideoConfig(&actual_config, demuxer->user_data);
 
-  // These values are derived from those set via AVCodecParametersToContext.
-  EXPECT_EQ(actual_video_config.codec, kCobaltExtensionDemuxerCodecH264);
-  EXPECT_EQ(actual_video_config.profile,
-            kCobaltExtensionDemuxerH264ProfileBaseline);
-  EXPECT_EQ(actual_video_config.coded_width, 1920);
-  EXPECT_EQ(actual_video_config.coded_height, 1080);
-  EXPECT_EQ(actual_video_config.visible_rect_x, 0);
-  EXPECT_EQ(actual_video_config.visible_rect_y, 0);
-  EXPECT_EQ(actual_video_config.visible_rect_width, 1920);
-  EXPECT_EQ(actual_video_config.visible_rect_height, 1080);
-  EXPECT_EQ(actual_video_config.natural_width, 1920);
-  EXPECT_EQ(actual_video_config.natural_height, 1080);
-  EXPECT_THAT(actual_video_config.extra_data, IsNull());
-  EXPECT_EQ(actual_video_config.extra_data_size, 0);
+  EXPECT_EQ(actual_config.codec, kCobaltExtensionDemuxerCodecVP8);
+  EXPECT_EQ(actual_config.profile, kCobaltExtensionDemuxerVp8ProfileMin);
+  EXPECT_EQ(actual_config.color_space_primaries, 2);
+  EXPECT_EQ(actual_config.color_space_transfer, 2);
+  EXPECT_EQ(actual_config.color_space_matrix, 2);
+  EXPECT_EQ(actual_config.color_space_range_id,
+            kCobaltExtensionDemuxerColorSpaceRangeIdLimited);
+  EXPECT_EQ(actual_config.alpha_mode, kCobaltExtensionDemuxerHasAlpha);
+  EXPECT_EQ(actual_config.coded_width, 320);
+  EXPECT_EQ(actual_config.coded_height, 240);
+  EXPECT_EQ(actual_config.visible_rect_x, 0);
+  EXPECT_EQ(actual_config.visible_rect_y, 0);
+  EXPECT_EQ(actual_config.visible_rect_width, 320);
+  EXPECT_EQ(actual_config.visible_rect_height, 240);
+  EXPECT_EQ(actual_config.natural_width, 320);
+  EXPECT_EQ(actual_config.natural_height, 240);
+  EXPECT_EQ(actual_config.encryption_scheme,
+            kCobaltExtensionDemuxerEncryptionSchemeUnencrypted);
+  EXPECT_THAT(actual_config.extra_data, IsNull());
+  EXPECT_EQ(actual_config.extra_data_size, 0);
+
+  api->DestroyDemuxer(demuxer);
+}
+
+TEST(FFmpegDemuxerTest, ReturnsVideoDuration) {
+  const std::string filename = ResolveTestFilename(kInputWebm);
+  std::ifstream input(filename, std::ios_base::binary);
+  SB_CHECK(input.good()) << "Unable to load file " << filename;
+
+  const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+  ASSERT_THAT(api, NotNull());
+  MockDataSource data_source;
+  CobaltExtensionDemuxerDataSource c_data_source{
+      &FstreamBlockingRead, &FstreamSeekTo, &FstreamGetPosition,
+      &FstreamGetSize,      kIsStreaming,   &input};
+  std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+  std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+  CobaltExtensionDemuxer* demuxer = api->CreateDemuxer(
+      &c_data_source, supported_audio_codecs.data(),
+      supported_audio_codecs.size(), supported_video_codecs.data(),
+      supported_video_codecs.size());
+
+  ASSERT_THAT(demuxer, NotNull());
+  EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
+  EXPECT_EQ(demuxer->GetDuration(demuxer->user_data), 2744000);
+
+  api->DestroyDemuxer(demuxer);
+}
+
+TEST(FFmpegDemuxerTest, TimelineOffsetReturnsZero) {
+  const std::string filename = ResolveTestFilename(kInputWebm);
+  std::ifstream input(filename, std::ios_base::binary);
+  SB_CHECK(input.good()) << "Unable to load file " << filename;
+
+  const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+  ASSERT_THAT(api, NotNull());
+  MockDataSource data_source;
+  CobaltExtensionDemuxerDataSource c_data_source{
+      &FstreamBlockingRead, &FstreamSeekTo, &FstreamGetPosition,
+      &FstreamGetSize,      kIsStreaming,   &input};
+  std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+  std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+  CobaltExtensionDemuxer* demuxer = api->CreateDemuxer(
+      &c_data_source, supported_audio_codecs.data(),
+      supported_audio_codecs.size(), supported_video_codecs.data(),
+      supported_video_codecs.size());
+
+  ASSERT_THAT(demuxer, NotNull());
+  EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
+  EXPECT_EQ(demuxer->GetTimelineOffset(demuxer->user_data), 0);
+
+  api->DestroyDemuxer(demuxer);
+}
+
+TEST(FFmpegDemuxerTest, StartTimeReturnsZero) {
+  const std::string filename = ResolveTestFilename(kInputWebm);
+  std::ifstream input(filename, std::ios_base::binary);
+  SB_CHECK(input.good()) << "Unable to load file " << filename;
+
+  const CobaltExtensionDemuxerApi* api = GetFFmpegDemuxerApi();
+  ASSERT_THAT(api, NotNull());
+  MockDataSource data_source;
+  CobaltExtensionDemuxerDataSource c_data_source{
+      &FstreamBlockingRead, &FstreamSeekTo, &FstreamGetPosition,
+      &FstreamGetSize,      kIsStreaming,   &input};
+  std::vector<CobaltExtensionDemuxerAudioCodec> supported_audio_codecs;
+  std::vector<CobaltExtensionDemuxerVideoCodec> supported_video_codecs;
+
+  CobaltExtensionDemuxer* demuxer = api->CreateDemuxer(
+      &c_data_source, supported_audio_codecs.data(),
+      supported_audio_codecs.size(), supported_video_codecs.data(),
+      supported_video_codecs.size());
+
+  ASSERT_THAT(demuxer, NotNull());
+  EXPECT_EQ(demuxer->Initialize(demuxer->user_data), kCobaltExtensionDemuxerOk);
+  EXPECT_EQ(demuxer->GetStartTime(demuxer->user_data), 0);
 
   api->DestroyDemuxer(demuxer);
 }
diff --git a/third_party/chromium/media/test/data/BUILD.gn b/third_party/chromium/media/test/data/BUILD.gn
new file mode 100644
index 0000000..582f118
--- /dev/null
+++ b/third_party/chromium/media/test/data/BUILD.gn
@@ -0,0 +1,25 @@
+# Copyright 2022 The Cobalt Authors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+# A target containing test data to be used by Cobalt. Other files can be added
+# as needed.
+copy("media_testdata") {
+  testonly = true
+  install_content = true
+  sources = [ "bear-320x240.webm" ]
+  subdir = "third_party/chromium/media/test/data"
+  outputs = [
+    "$sb_static_contents_output_data_dir/$subdir/{{source_target_relative}}",
+  ]
+}