diff --git a/cobalt/browser/on_screen_keyboard_starboard_bridge.cc b/cobalt/browser/on_screen_keyboard_starboard_bridge.cc
index 39b998c..969f822 100644
--- a/cobalt/browser/on_screen_keyboard_starboard_bridge.cc
+++ b/cobalt/browser/on_screen_keyboard_starboard_bridge.cc
@@ -96,5 +96,34 @@
   return SbWindowSetOnScreenKeyboardKeepFocus(sb_window_provider_.Run(),
                                               keep_focus);
 }
+
+void OnScreenKeyboardStarboardBridge::SetBackgroundColor(
+    const char* background_color) {
+  const CobaltExtensionOnScreenKeyboardApi* on_screen_keyboard_extension =
+      static_cast<const CobaltExtensionOnScreenKeyboardApi*>(
+          SbSystemGetExtension(kCobaltExtensionOnScreenKeyboardName));
+
+  if (on_screen_keyboard_extension &&
+      strcmp(on_screen_keyboard_extension->name,
+             kCobaltExtensionOnScreenKeyboardName) == 0 &&
+      on_screen_keyboard_extension->version >= 1) {
+    on_screen_keyboard_extension->SetBackgroundColor(sb_window_provider_.Run(),
+                                                     background_color);
+  }
+}
+
+void OnScreenKeyboardStarboardBridge::SetDarkTheme(bool dark_theme) {
+  const CobaltExtensionOnScreenKeyboardApi* on_screen_keyboard_extension =
+      static_cast<const CobaltExtensionOnScreenKeyboardApi*>(
+          SbSystemGetExtension(kCobaltExtensionOnScreenKeyboardName));
+
+  if (on_screen_keyboard_extension &&
+      strcmp(on_screen_keyboard_extension->name,
+             kCobaltExtensionOnScreenKeyboardName) == 0 &&
+      on_screen_keyboard_extension->version >= 1) {
+    on_screen_keyboard_extension->SetDarkTheme(sb_window_provider_.Run(),
+                                               dark_theme);
+  }
+}
 }  // namespace browser
 }  // namespace cobalt
diff --git a/cobalt/browser/on_screen_keyboard_starboard_bridge.h b/cobalt/browser/on_screen_keyboard_starboard_bridge.h
index f73cc11..6ee9a70 100644
--- a/cobalt/browser/on_screen_keyboard_starboard_bridge.h
+++ b/cobalt/browser/on_screen_keyboard_starboard_bridge.h
@@ -19,6 +19,7 @@
 
 #include "base/callback.h"
 #include "cobalt/dom/on_screen_keyboard_bridge.h"
+#include "cobalt/extension/on_screen_keyboard.h"
 #include "starboard/window.h"
 
 namespace cobalt {
@@ -58,6 +59,10 @@
 
   void SetKeepFocus(bool keep_focus) override;
 
+  void SetBackgroundColor(const char* background_color) override;
+
+  void SetDarkTheme(bool dark_theme) override;
+
  private:
   base::Callback<SbWindow()> sb_window_provider_;
 };
diff --git a/cobalt/demos/content/BUILD.gn b/cobalt/demos/content/BUILD.gn
index 9e6b742..e9f5d09 100644
--- a/cobalt/demos/content/BUILD.gn
+++ b/cobalt/demos/content/BUILD.gn
@@ -111,8 +111,6 @@
 
   if (is_internal_build) {
     sources += [
-      "internal/runtime-dump.html",
-      "javascript-fuzzer/index.html",
       "media-element-demo/public/assets/ac3.mp4",
       "media-element-demo/public/assets/dash-audio.mp4",
       "media-element-demo/public/assets/dash-video-1080p.mp4",
@@ -125,86 +123,6 @@
       "media-element-demo/public/assets/progressive.mp4",
       "mtm-demo/README.txt",
       "mtm-demo/progressive.mp4",
-      "performance-spike/assets/Roboto-Regular.ttf",
-      "performance-spike/assets/banner.jpg",
-      "performance-spike/assets/banner1080.jpg",
-      "performance-spike/assets/banner1080baked.jpg",
-      "performance-spike/assets/banner1080withLinearGradient.jpg",
-      "performance-spike/assets/banner720.jpg",
-      "performance-spike/assets/banner720baked.jpg",
-      "performance-spike/assets/icons.ttf",
-      "performance-spike/css/default.css",
-      "performance-spike/css/icons-content.css",
-      "performance-spike/css/icons.css",
-      "performance-spike/di/injector.js",
-      "performance-spike/di/mapping.js",
-      "performance-spike/di/resolver.js",
-      "performance-spike/index.html",
-      "performance-spike/namespace.js",
-      "performance-spike/runtime-dump.html",
-      "performance-spike/spike/anim/_config.js",
-      "performance-spike/spike/anim/alignment.js",
-      "performance-spike/spike/anim/centering.js",
-      "performance-spike/spike/anim/cssanimations/_config.js",
-      "performance-spike/spike/anim/cssanimations/animationbuilder.js",
-      "performance-spike/spike/anim/cssanimations/centering.js",
-      "performance-spike/spike/anim/cssanimations/rows.js",
-      "performance-spike/spike/anim/csstransitions/_config.js",
-      "performance-spike/spike/anim/csstransitions/centering.js",
-      "performance-spike/spike/anim/csstransitions/rows.js",
-      "performance-spike/spike/anim/csstransitions/transitionbuilder.js",
-      "performance-spike/spike/anim/rows.js",
-      "performance-spike/spike/anim/transformer/_config.js",
-      "performance-spike/spike/anim/transformer/centering.js",
-      "performance-spike/spike/anim/transformer/ease.js",
-      "performance-spike/spike/anim/transformer/rows.js",
-      "performance-spike/spike/anim/transformer/transformer.js",
-      "performance-spike/spike/anim/tweens/_config.js",
-      "performance-spike/spike/anim/tweens/centering.js",
-      "performance-spike/spike/anim/tweens/rows.js",
-      "performance-spike/spike/anim/tweens/tweens.js",
-      "performance-spike/spike/behavior/_config.js",
-      "performance-spike/spike/behavior/body.js",
-      "performance-spike/spike/behavior/buttons.js",
-      "performance-spike/spike/behavior/column.js",
-      "performance-spike/spike/behavior/content.js",
-      "performance-spike/spike/behavior/cssfocused.js",
-      "performance-spike/spike/behavior/factory.js",
-      "performance-spike/spike/behavior/header.js",
-      "performance-spike/spike/behavior/headerbuttons.js",
-      "performance-spike/spike/behavior/item.js",
-      "performance-spike/spike/behavior/main.js",
-      "performance-spike/spike/behavior/menu.js",
-      "performance-spike/spike/behavior/navigate.js",
-      "performance-spike/spike/behavior/row.js",
-      "performance-spike/spike/core/_config.js",
-      "performance-spike/spike/core/environment.js",
-      "performance-spike/spike/core/experiments.js",
-      "performance-spike/spike/core/fps.js",
-      "performance-spike/spike/core/location.js",
-      "performance-spike/spike/core/math.js",
-      "performance-spike/spike/core/rollingmean.js",
-      "performance-spike/spike/core/styles.js",
-      "performance-spike/spike/core/throttlefactory.js",
-      "performance-spike/spike/core/ticker.js",
-      "performance-spike/spike/ctrl/_config.js",
-      "performance-spike/spike/ctrl/behaviors.js",
-      "performance-spike/spike/ctrl/factory.js",
-      "performance-spike/spike/ctrl/focuser.js",
-      "performance-spike/spike/ctrl/hbox.js",
-      "performance-spike/spike/ctrl/keyhandler.js",
-      "performance-spike/spike/ctrl/leaf.js",
-      "performance-spike/spike/ctrl/vbox.js",
-      "performance-spike/spike/data/_config.js",
-      "performance-spike/spike/data/channel_crash_course.js",
-      "performance-spike/spike/data/menu.js",
-      "performance-spike/spike/data/menu_content.js",
-      "performance-spike/spike/data/update.js",
-      "performance-spike/spike/factory/_config.js",
-      "performance-spike/spike/factory/itemfactory.js",
-      "performance-spike/spike/factory/menufactory.js",
-      "performance-spike/spike/factory/rowfactory.js",
-      "performance-spike/spike/main.js",
       "text-encoding-workaround/text-encoding-workaround.html",
     ]
   }
diff --git a/cobalt/dom/BUILD.gn b/cobalt/dom/BUILD.gn
index 79ed564..ff47acc 100644
--- a/cobalt/dom/BUILD.gn
+++ b/cobalt/dom/BUILD.gn
@@ -261,7 +261,6 @@
     "screenshot.h",
     "screenshot_manager.cc",
     "screenshot_manager.h",
-    "serialized_algorithm_runner.cc",
     "serialized_algorithm_runner.h",
     "serializer.cc",
     "serializer.h",
diff --git a/cobalt/dom/html_script_element.cc b/cobalt/dom/html_script_element.cc
index e003c03..42f7997 100644
--- a/cobalt/dom/html_script_element.cc
+++ b/cobalt/dom/html_script_element.cc
@@ -78,6 +78,18 @@
   DCHECK(document->html_element_context()->script_runner());
 }
 
+std::string HTMLScriptElement::src() const {
+  auto src = GetAttribute("src");
+  if (!src.has_value()) {
+    return "";
+  }
+  if (!node_document()) {
+    return src.value();
+  }
+  const GURL& base_url = node_document()->location()->url();
+  return base_url.Resolve(src.value()).spec();
+}
+
 base::Optional<std::string> HTMLScriptElement::cross_origin() const {
   base::Optional<std::string> cross_origin_attribute =
       GetAttribute("crossOrigin");
@@ -217,7 +229,11 @@
   //   1. Let src be the value of the element's src attribute.
   //   2. If src is the empty string, queue a task to fire a simple event
   // named error at the element, and abort these steps.
-  if (HasAttribute("src") && src() == "") {
+  //
+  // Need to use the "src" attribute. The |src| property is fully resolved. See
+  // header file for details.
+  auto src = GetAttribute("src").value_or("");
+  if (HasAttribute("src") && src == "") {
     LOG(ERROR) << "src attribute of script element is empty.";
 
     PreventGarbageCollectionAndPostToDispatchEvent(
@@ -230,9 +246,9 @@
   //   4. If the previous step failed, queue a task to fire a simple event named
   // error at the element, and abort these steps.
   const GURL& base_url = document_->location()->url();
-  url_ = base_url.Resolve(src());
+  url_ = base_url.Resolve(src);
   if (!url_.is_valid()) {
-    LOG(ERROR) << src() << " cannot be resolved based on " << base_url << ".";
+    LOG(ERROR) << src << " cannot be resolved based on " << base_url << ".";
 
     PreventGarbageCollectionAndPostToDispatchEvent(
         FROM_HERE, base::Tokens::error(),
@@ -267,7 +283,7 @@
              "bugs, it is recommended to use JavaScript to create a "
              "script element and load it async. The <script> reference "
              "appears at: \""
-          << inline_script_location_ << "\" and its src is \"" << src() << "\"";
+          << inline_script_location_ << "\" and its src is \"" << src << "\"";
     }
 
     load_option_ = 2;
diff --git a/cobalt/dom/html_script_element.h b/cobalt/dom/html_script_element.h
index 3c9740e..f5537fd 100644
--- a/cobalt/dom/html_script_element.h
+++ b/cobalt/dom/html_script_element.h
@@ -42,7 +42,13 @@
 
   // Web API: HTMLScriptElement
   //
-  std::string src() const { return GetAttribute("src").value_or(""); }
+  // If the "src" attribute is a relative URL, the |src| property returns a
+  // fully resolved URL used the |document.location.href| as the base URL. This
+  // matches the Chrome implementation of the |src| property.
+  // See:
+  //   https://source.chromium.org/chromium/chromium/src/+/main:out/Debug/gen/third_party/blink/renderer/bindings/core/v8/v8_html_script_element.cc;l=93;drc=4f7206c7352efba617f4561cd8c95844d9e9814f
+  //   https://source.chromium.org/chromium/chromium/src/+/main:third_party/blink/renderer/core/dom/element.cc;l=7360;drc=5f6702f8b8f9da8510d2b3ec809e177e6db09e53
+  std::string src() const;
   void set_src(const std::string& value) { SetAttribute("src", value); }
 
   std::string type() const { return GetAttribute("type").value_or(""); }
diff --git a/cobalt/dom/media_source.cc b/cobalt/dom/media_source.cc
index f9f2c05..1dcc7d3 100644
--- a/cobalt/dom/media_source.cc
+++ b/cobalt/dom/media_source.cc
@@ -83,13 +83,14 @@
 // If the system has more processors than the specified value, SourceBuffer
 // append and remove algorithm will be offloaded to a non-web thread to reduce
 // the load on the web thread.
-// The default value is 2.  Set to a reasonably high value (say 1024) will
-// disable algorithm offloading completely.
+// The default value is 1024, which effectively disable offloading by default.
+// Setting to a reasonably low value (say 0 or 2) will enable algorithm
+// offloading.
 bool IsAlgorithmOffloadEnabled(script::EnvironmentSettings* settings) {
   int min_process_count_to_offload =
       GetMediaSettings(settings)
           ->GetMinimumProcessorCountToOffloadAlgorithm()
-          .value_or(2);
+          .value_or(1024);
   DCHECK_GE(min_process_count_to_offload, 0);
   return SbSystemGetNumberOfProcessors() >= min_process_count_to_offload;
 }
@@ -97,10 +98,10 @@
 // If this function returns true, SourceBuffer will reduce asynchronous
 // behaviors.  For example, queued events will be dispatached immediately when
 // possible.
-// The default value is true.
+// The default value is false.
 bool IsAsynchronousReductionEnabled(script::EnvironmentSettings* settings) {
   return GetMediaSettings(settings)->IsAsynchronousReductionEnabled().value_or(
-      true);
+      false);
 }
 
 // If the size of a job that is part of an algorithm is less than or equal to
@@ -390,9 +391,10 @@
 
   if (algorithm_process_thread_) {
     LOG(INFO) << "Algorithm offloading enabled.";
-    offload_algorithm_runner_.reset(new OffloadAlgorithmRunner(
-        algorithm_process_thread_->message_loop()->task_runner(),
-        base::MessageLoop::current()->task_runner()));
+    offload_algorithm_runner_.reset(
+        new OffloadAlgorithmRunner<SourceBufferAlgorithm>(
+            algorithm_process_thread_->message_loop()->task_runner(),
+            base::MessageLoop::current()->task_runner()));
   } else {
     LOG(INFO) << "Algorithm offloading disabled.";
   }
@@ -574,7 +576,8 @@
   return has_max_video_capabilities_;
 }
 
-SerializedAlgorithmRunner* MediaSource::GetAlgorithmRunner(int job_size) {
+SerializedAlgorithmRunner<SourceBufferAlgorithm>*
+MediaSource::GetAlgorithmRunner(int job_size) {
   if (!offload_algorithm_runner_) {
     return &default_algorithm_runner_;
   }
diff --git a/cobalt/dom/media_source.h b/cobalt/dom/media_source.h
index bfe0774..65ab2a8 100644
--- a/cobalt/dom/media_source.h
+++ b/cobalt/dom/media_source.h
@@ -59,6 +59,7 @@
 #include "cobalt/dom/media_source_ready_state.h"
 #include "cobalt/dom/serialized_algorithm_runner.h"
 #include "cobalt/dom/source_buffer.h"
+#include "cobalt/dom/source_buffer_algorithm.h"
 #include "cobalt/dom/source_buffer_list.h"
 #include "cobalt/dom/time_ranges.h"
 #include "cobalt/dom/video_track.h"
@@ -126,7 +127,8 @@
   void SetSourceBufferActive(SourceBuffer* source_buffer, bool is_active);
   HTMLMediaElement* GetMediaElement() const;
   bool MediaElementHasMaxVideoCapabilities() const;
-  SerializedAlgorithmRunner* GetAlgorithmRunner(int job_size);
+  SerializedAlgorithmRunner<SourceBufferAlgorithm>* GetAlgorithmRunner(
+      int job_size);
 
   DEFINE_WRAPPABLE_TYPE(MediaSource);
   void TraceMembers(script::Tracer* tracer) override;
@@ -148,9 +150,10 @@
   const int min_size_for_immediate_job_;
 
   // The default algorithm runner runs all steps on the web thread.
-  DefaultAlgorithmRunner default_algorithm_runner_;
+  DefaultAlgorithmRunner<SourceBufferAlgorithm> default_algorithm_runner_;
   // The offload algorithm runner offloads some steps to a non-web thread.
-  std::unique_ptr<OffloadAlgorithmRunner> offload_algorithm_runner_;
+  std::unique_ptr<OffloadAlgorithmRunner<SourceBufferAlgorithm>>
+      offload_algorithm_runner_;
   std::unique_ptr<base::Thread> algorithm_process_thread_;
 
   ChunkDemuxer* chunk_demuxer_;
diff --git a/cobalt/dom/on_screen_keyboard.cc b/cobalt/dom/on_screen_keyboard.cc
index 54c2242..188aa1e 100644
--- a/cobalt/dom/on_screen_keyboard.cc
+++ b/cobalt/dom/on_screen_keyboard.cc
@@ -46,6 +46,14 @@
           .second;
   DCHECK(is_emplaced);
   bridge_->Show(data_.c_str(), ticket);
+
+  if (background_color_.has_value()) {
+    bridge_->SetBackgroundColor(background_color_.value().c_str());
+  }
+  if (dark_theme_.has_value()) {
+    bridge_->SetDarkTheme(dark_theme_.value());
+  }
+
   return promise;
 }
 
diff --git a/cobalt/dom/on_screen_keyboard.h b/cobalt/dom/on_screen_keyboard.h
index 8690c95..ce7d0fa 100644
--- a/cobalt/dom/on_screen_keyboard.h
+++ b/cobalt/dom/on_screen_keyboard.h
@@ -99,6 +99,18 @@
   void set_keep_focus(bool keep_focus);
   bool keep_focus() const { return keep_focus_; }
 
+  void set_background_color(base::Optional<std::string>& background_color) {
+    background_color_ = background_color;
+  }
+  base::Optional<std::string> background_color() const {
+    return background_color_;
+  }
+
+  void set_dark_theme(base::Optional<bool> dark_theme) {
+    dark_theme_ = dark_theme;
+  }
+  base::Optional<bool> dark_theme() const { return dark_theme_; }
+
   // Called by the WebModule to dispatch DOM show, hide, focus, blur and
   // suggestions updated events.
   void DispatchHideEvent(int ticket);
@@ -135,6 +147,10 @@
 
   bool suggestions_supported_;
 
+  base::Optional<std::string> background_color_;
+
+  base::Optional<bool> dark_theme_;
+
   DISALLOW_COPY_AND_ASSIGN(OnScreenKeyboard);
 };
 }  // namespace dom
diff --git a/cobalt/dom/on_screen_keyboard.idl b/cobalt/dom/on_screen_keyboard.idl
index ebe632c..fe13887 100644
--- a/cobalt/dom/on_screen_keyboard.idl
+++ b/cobalt/dom/on_screen_keyboard.idl
@@ -43,4 +43,15 @@
   attribute EventHandler onfocus;
   attribute EventHandler onblur;
   attribute EventHandler oninput;
+
+  // This attribute overrides the background color of on-screen keyboard.
+  // The attribute is only fully supported on Apple TV at the moment.
+  // backgroundColor should be a string of below formats:
+  // 1. hex color notation #RRGGBB, e.g. "#0000FF".
+  // 2. rgb color notation rgb(R, G, B), e.g. "rgb(0, 0, 255)".
+  attribute DOMString? backgroundColor;
+
+  // This attribute overrides the dark theme of on-screen keyboard.
+  // The attribute is only fully supported on Apple TV at the moment.
+  attribute boolean? darkTheme;
 };
diff --git a/cobalt/dom/on_screen_keyboard_bridge.h b/cobalt/dom/on_screen_keyboard_bridge.h
index d58c0ad..c5623af 100644
--- a/cobalt/dom/on_screen_keyboard_bridge.h
+++ b/cobalt/dom/on_screen_keyboard_bridge.h
@@ -39,6 +39,8 @@
   virtual scoped_refptr<DOMRect> BoundingRect() const = 0;
   virtual void SetKeepFocus(bool keep_focus) = 0;
   virtual bool IsValidTicket(int ticket) const = 0;
+  virtual void SetBackgroundColor(const char* background_color) = 0;
+  virtual void SetDarkTheme(bool dark_theme) = 0;
 };
 
 }  // namespace dom
diff --git a/cobalt/dom/on_screen_keyboard_test.cc b/cobalt/dom/on_screen_keyboard_test.cc
index 4ab1e6f..fd616a3 100644
--- a/cobalt/dom/on_screen_keyboard_test.cc
+++ b/cobalt/dom/on_screen_keyboard_test.cc
@@ -112,6 +112,10 @@
 
   void SetKeepFocus(bool keep_focus) override { SetKeepFocusMock(keep_focus); }
 
+  void SetBackgroundColor(const char* background_color) override {}
+
+  void SetDarkTheme(bool dark_theme) override {}
+
   MOCK_METHOD1(ShowMock, void(std::string));
   MOCK_METHOD0(HideMock, void());
   MOCK_METHOD0(BlurMock, void());
@@ -604,5 +608,49 @@
   EXPECT_TRUE(EvaluateScript(script, NULL));
 }
 
+TEST_F(OnScreenKeyboardTest, SetBackgroundColor) {
+  if (SkipLocale()) return;
+
+  std::string result;
+  EXPECT_TRUE(
+      EvaluateScript("window.onScreenKeyboard.backgroundColor;", &result));
+  EXPECT_EQ("null", result);
+
+  std::string color_str = "#0000FF";
+  EXPECT_TRUE(EvaluateScript("window.onScreenKeyboard.backgroundColor = '" +
+                                 color_str +
+                                 "';"
+                                 "window.onScreenKeyboard.backgroundColor",
+                             &result));
+
+  EXPECT_EQ(color_str, result);
+
+  color_str = "rgb(0, 0, 100)";
+  EXPECT_TRUE(EvaluateScript("window.onScreenKeyboard.backgroundColor = '" +
+                                 color_str +
+                                 "';"
+                                 "window.onScreenKeyboard.backgroundColor",
+                             &result));
+
+  EXPECT_EQ(color_str, result);
+}
+
+TEST_F(OnScreenKeyboardTest, SetDarkTheme) {
+  if (SkipLocale()) return;
+
+  std::string result;
+  EXPECT_TRUE(EvaluateScript("window.onScreenKeyboard.darkTheme;", &result));
+  EXPECT_EQ("null", result);
+
+  std::string dark_theme_str = "false";
+  EXPECT_TRUE(
+      EvaluateScript("window.onScreenKeyboard.darkTheme = " + dark_theme_str +
+                         ";"
+                         "window.onScreenKeyboard.darkTheme",
+                     &result));
+
+  EXPECT_EQ(dark_theme_str, result);
+}
+
 }  // namespace dom
 }  // namespace cobalt
diff --git a/cobalt/dom/serialized_algorithm_runner.cc b/cobalt/dom/serialized_algorithm_runner.cc
deleted file mode 100644
index 07dece0..0000000
--- a/cobalt/dom/serialized_algorithm_runner.cc
+++ /dev/null
@@ -1,95 +0,0 @@
-// 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.
-
-#include "cobalt/dom/serialized_algorithm_runner.h"
-
-#include "base/message_loop/message_loop.h"
-
-namespace cobalt {
-namespace dom {
-
-void DefaultAlgorithmRunner::Start(const scoped_refptr<HandleBase>& handle) {
-  DCHECK(handle);
-  TRACE_EVENT0("cobalt::dom", "DefaultAlgorithmRunner::Start()");
-
-  if (asynchronous_reduction_enabled_) {
-    Process(handle);
-    return;
-  }
-
-  auto task_runner = base::MessageLoop::current()->task_runner();
-  task_runner->PostTask(FROM_HERE,
-                        base::BindOnce(&DefaultAlgorithmRunner::Process,
-                                       base::Unretained(this), handle));
-}
-
-void DefaultAlgorithmRunner::Process(const scoped_refptr<HandleBase>& handle) {
-  DCHECK(handle);
-  TRACE_EVENT0("cobalt::dom", "DefaultAlgorithmRunner::Process()");
-
-  auto task_runner = base::MessageLoop::current()->task_runner();
-
-  bool finished = false;
-  handle->Process(&finished);
-
-  if (finished) {
-    handle->Finalize();
-    return;
-  }
-  task_runner->PostTask(FROM_HERE,
-                        base::BindOnce(&DefaultAlgorithmRunner::Process,
-                                       base::Unretained(this), handle));
-}
-
-OffloadAlgorithmRunner::OffloadAlgorithmRunner(
-    const scoped_refptr<TaskRunner>& process_task_runner,
-    const scoped_refptr<TaskRunner>& finalize_task_runner)
-    : process_task_runner_(process_task_runner),
-      finalize_task_runner_(finalize_task_runner) {
-  DCHECK(process_task_runner_);
-  DCHECK(finalize_task_runner_);
-  DCHECK_NE(process_task_runner_, finalize_task_runner_);
-}
-
-void OffloadAlgorithmRunner::Start(const scoped_refptr<HandleBase>& handle) {
-  DCHECK(handle);
-
-  TRACE_EVENT0("cobalt::dom", "OffloadAlgorithmRunner::Start()");
-
-  process_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&OffloadAlgorithmRunner::Process,
-                                base::Unretained(this), handle));
-}
-
-void OffloadAlgorithmRunner::Process(const scoped_refptr<HandleBase>& handle) {
-  DCHECK(handle);
-  DCHECK(process_task_runner_->BelongsToCurrentThread());
-
-  TRACE_EVENT0("cobalt::dom", "OffloadAlgorithmRunner::Process()");
-
-  bool finished = false;
-  handle->Process(&finished);
-
-  if (finished) {
-    finalize_task_runner_->PostTask(
-        FROM_HERE, base::BindOnce(&HandleBase::Finalize, handle));
-    return;
-  }
-  process_task_runner_->PostTask(
-      FROM_HERE, base::BindOnce(&OffloadAlgorithmRunner::Process,
-                                base::Unretained(this), handle));
-}
-
-}  // namespace dom
-}  // namespace cobalt
diff --git a/cobalt/dom/serialized_algorithm_runner.h b/cobalt/dom/serialized_algorithm_runner.h
index d4c2b39..db625ad 100644
--- a/cobalt/dom/serialized_algorithm_runner.h
+++ b/cobalt/dom/serialized_algorithm_runner.h
@@ -22,6 +22,7 @@
 #include "base/callback.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
+#include "base/message_loop/message_loop.h"
 #include "base/single_thread_task_runner.h"
 #include "base/trace_event/trace_event.h"
 #include "starboard/common/mutex.h"
@@ -53,37 +54,56 @@
 // This class will keep calling Process() until |finished| becomes false, and
 // then call Finalize().  It guarantees that all calls won't be overlapped and
 // the member functions of the algorithm don't have to synchronize between them.
+template <typename SerializedAlgorithm>
 class SerializedAlgorithmRunner {
  public:
-  // Abstract the non-template part of the Handle class, and shouldn't be used
-  // directly.
-  class HandleBase : public base::RefCountedThreadSafe<HandleBase> {
-   public:
-    virtual ~HandleBase() {}
-
-    virtual void Process(bool* finished) = 0;
-    virtual void Finalize() = 0;
-  };
-
   // A handle object for a running algorithm instance, to allow for aborting and
   // access the algorithm.
-  template <typename SerializedAlgorithm>
-  class Handle : public HandleBase {
+  class Handle : public base::RefCountedThreadSafe<Handle> {
    public:
-    explicit Handle(std::unique_ptr<SerializedAlgorithm> algorithm);
-
     // Abort the algorithm and no more processing will happen on return.  It is
     // possible that Process() has already finished asynchronously, in which
     // case this function will call Finalize() instead (if it hasn't been called
     // yet).
     void Abort();
+    void Process(bool* finished);
+    void FinalizeIfNotAborted();
+
     SerializedAlgorithm* algorithm() const { return algorithm_.get(); }
 
    private:
-    void Process(bool* finished) override;
-    void Finalize() override;
+    friend class SerializedAlgorithmRunner;
 
-    // The |mutex_| is necessary as `Abort()` can be called from any thread.
+    // Provide synchronization only when |synchronization_required| is true.
+    // This allows bypassing of synchronization for algorithm runners that
+    // operate on a single thread, where a mutex could be reentrant if acquired
+    // due to nested calls.
+    class ScopedLockWhenRequired {
+     public:
+      ScopedLockWhenRequired(bool synchronization_required,
+                             const starboard::Mutex& mutex)
+          : synchronization_required_(synchronization_required), mutex_(mutex) {
+        if (synchronization_required_) {
+          mutex_.Acquire();
+        }
+      }
+      ~ScopedLockWhenRequired() {
+        if (synchronization_required_) {
+          mutex_.Release();
+        }
+      }
+
+     private:
+      const bool synchronization_required_;
+      const starboard::Mutex& mutex_;
+    };
+
+    Handle(bool synchronization_required,
+           std::unique_ptr<SerializedAlgorithm> algorithm);
+
+    // The |mutex_| is necessary for algorithm runners operate on multiple
+    // threads as `Abort()` can be called from any thread.
+    const bool synchronization_required_;
     starboard::Mutex mutex_;
     std::unique_ptr<SerializedAlgorithm> algorithm_;
     bool aborted_ = false;
@@ -93,21 +113,32 @@
 
   virtual ~SerializedAlgorithmRunner() {}
 
-  virtual void Start(const scoped_refptr<HandleBase>& handle) = 0;
+  virtual scoped_refptr<Handle> CreateHandle(
+      std::unique_ptr<SerializedAlgorithm> algorithm) = 0;
+  virtual void Start(scoped_refptr<Handle> handle) = 0;
+
+ protected:
+  scoped_refptr<Handle> CreateHandle(
+      bool synchronization_required,
+      std::unique_ptr<SerializedAlgorithm> algorithm) {
+    return new Handle(synchronization_required, std::move(algorithm));
+  }
 };
 
 template <typename SerializedAlgorithm>
-SerializedAlgorithmRunner::Handle<SerializedAlgorithm>::Handle(
+SerializedAlgorithmRunner<SerializedAlgorithm>::Handle::Handle(
+    bool synchronization_required,
     std::unique_ptr<SerializedAlgorithm> algorithm)
-    : algorithm_(std::move(algorithm)) {
+    : synchronization_required_(synchronization_required),
+      algorithm_(std::move(algorithm)) {
   DCHECK(algorithm_);
 }
 
 template <typename SerializedAlgorithm>
-void SerializedAlgorithmRunner::Handle<SerializedAlgorithm>::Abort() {
+void SerializedAlgorithmRunner<SerializedAlgorithm>::Handle::Abort() {
   TRACE_EVENT0("cobalt::dom", "SerializedAlgorithmRunner::Handle::Abort()");
 
-  starboard::ScopedLock scoped_lock(mutex_);
+  ScopedLockWhenRequired scoped_lock(synchronization_required_, mutex_);
 
   DCHECK(!aborted_);  // Abort() cannot be called twice.
 
@@ -126,18 +157,19 @@
 }
 
 template <typename SerializedAlgorithm>
-void SerializedAlgorithmRunner::Handle<SerializedAlgorithm>::Process(
+void SerializedAlgorithmRunner<SerializedAlgorithm>::Handle::Process(
     bool* finished) {
   TRACE_EVENT0("cobalt::dom", "SerializedAlgorithmRunner::Handle::Process()");
 
   DCHECK(finished);
 
-  starboard::ScopedLock scoped_lock(mutex_);
+  ScopedLockWhenRequired scoped_lock(synchronization_required_, mutex_);
 
   DCHECK(!finished_);
   DCHECK(!finalized_);
 
   if (aborted_) {
+    *finished = true;
     return;
   }
 
@@ -147,17 +179,19 @@
 }
 
 template <typename SerializedAlgorithm>
-void SerializedAlgorithmRunner::Handle<SerializedAlgorithm>::Finalize() {
+void SerializedAlgorithmRunner<
+    SerializedAlgorithm>::Handle::FinalizeIfNotAborted() {
   TRACE_EVENT0("cobalt::dom", "SerializedAlgorithmRunner::Handle::Finalize()");
-  starboard::ScopedLock scoped_lock(mutex_);
 
-  DCHECK(finished_);
+  ScopedLockWhenRequired scoped_lock(synchronization_required_, mutex_);
+
   DCHECK(!finalized_);
 
   if (aborted_) {
     return;
   }
 
+  DCHECK(finished_);
   DCHECK(algorithm_);
 
   algorithm_->Finalize();
@@ -167,14 +201,21 @@
 
 // This class runs algorithm on the task runner associated with the thread where
 // Start() is called.
-class DefaultAlgorithmRunner : public SerializedAlgorithmRunner {
+template <typename SerializedAlgorithm>
+class DefaultAlgorithmRunner
+    : public SerializedAlgorithmRunner<SerializedAlgorithm> {
  public:
   explicit DefaultAlgorithmRunner(bool asynchronous_reduction_enabled)
       : asynchronous_reduction_enabled_(asynchronous_reduction_enabled) {}
 
  private:
-  void Start(const scoped_refptr<HandleBase>& handle) override;
-  void Process(const scoped_refptr<HandleBase>& handle);
+  typedef
+      typename SerializedAlgorithmRunner<SerializedAlgorithm>::Handle Handle;
+
+  scoped_refptr<Handle> CreateHandle(
+      std::unique_ptr<SerializedAlgorithm> algorithm) override;
+  void Start(scoped_refptr<Handle> handle) override;
+  void Process(scoped_refptr<Handle> handle);
 
   const bool asynchronous_reduction_enabled_;
 };
@@ -185,7 +226,9 @@
 // This class will keep calling the Process() member function of the algorithm
 // on the process task runner, and then call Finalize() on the finalize task
 // runner when |finished| becomes true.
-class OffloadAlgorithmRunner : public SerializedAlgorithmRunner {
+template <typename SerializedAlgorithm>
+class OffloadAlgorithmRunner
+    : public SerializedAlgorithmRunner<SerializedAlgorithm> {
  public:
   typedef base::SingleThreadTaskRunner TaskRunner;
 
@@ -193,13 +236,121 @@
                          const scoped_refptr<TaskRunner>& finalize_task_runner);
 
  private:
-  void Start(const scoped_refptr<HandleBase>& handle) override;
-  void Process(const scoped_refptr<HandleBase>& handle);
+  typedef
+      typename SerializedAlgorithmRunner<SerializedAlgorithm>::Handle Handle;
+
+  scoped_refptr<Handle> CreateHandle(
+      std::unique_ptr<SerializedAlgorithm> algorithm) override;
+  void Start(scoped_refptr<Handle> handle) override;
+  void Process(scoped_refptr<Handle> handle);
 
   scoped_refptr<TaskRunner> process_task_runner_;
   scoped_refptr<TaskRunner> finalize_task_runner_;
 };
 
+template <typename SerializedAlgorithm>
+scoped_refptr<typename SerializedAlgorithmRunner<SerializedAlgorithm>::Handle>
+DefaultAlgorithmRunner<SerializedAlgorithm>::CreateHandle(
+    std::unique_ptr<SerializedAlgorithm> algorithm) {
+  TRACE_EVENT0("cobalt::dom", "DefaultAlgorithmRunner::CreateHandle()");
+
+  const bool kSynchronizationRequired = false;
+  return SerializedAlgorithmRunner<SerializedAlgorithm>::CreateHandle(
+      kSynchronizationRequired, std::move(algorithm));
+}
+
+template <typename SerializedAlgorithm>
+void DefaultAlgorithmRunner<SerializedAlgorithm>::Start(
+    scoped_refptr<Handle> handle) {
+  DCHECK(handle);
+  TRACE_EVENT0("cobalt::dom", "DefaultAlgorithmRunner::Start()");
+
+  if (asynchronous_reduction_enabled_) {
+    Process(handle);
+    return;
+  }
+
+  auto task_runner = base::MessageLoop::current()->task_runner();
+  task_runner->PostTask(FROM_HERE,
+                        base::BindOnce(&DefaultAlgorithmRunner::Process,
+                                       base::Unretained(this), handle));
+}
+
+template <typename SerializedAlgorithm>
+void DefaultAlgorithmRunner<SerializedAlgorithm>::Process(
+    scoped_refptr<Handle> handle) {
+  DCHECK(handle);
+  TRACE_EVENT0("cobalt::dom", "DefaultAlgorithmRunner::Process()");
+
+  auto task_runner = base::MessageLoop::current()->task_runner();
+
+  bool finished = false;
+  handle->Process(&finished);
+
+  if (finished) {
+    handle->FinalizeIfNotAborted();
+    return;
+  }
+  task_runner->PostTask(FROM_HERE,
+                        base::BindOnce(&DefaultAlgorithmRunner::Process,
+                                       base::Unretained(this), handle));
+}
+
+template <typename SerializedAlgorithm>
+OffloadAlgorithmRunner<SerializedAlgorithm>::OffloadAlgorithmRunner(
+    const scoped_refptr<TaskRunner>& process_task_runner,
+    const scoped_refptr<TaskRunner>& finalize_task_runner)
+    : process_task_runner_(process_task_runner),
+      finalize_task_runner_(finalize_task_runner) {
+  DCHECK(process_task_runner_);
+  DCHECK(finalize_task_runner_);
+  DCHECK_NE(process_task_runner_, finalize_task_runner_);
+}
+
+template <typename SerializedAlgorithm>
+scoped_refptr<typename SerializedAlgorithmRunner<SerializedAlgorithm>::Handle>
+OffloadAlgorithmRunner<SerializedAlgorithm>::CreateHandle(
+    std::unique_ptr<SerializedAlgorithm> algorithm) {
+  TRACE_EVENT0("cobalt::dom", "OffloadAlgorithmRunner::CreateHandle()");
+
+  const bool kSynchronizationRequired = true;
+  return SerializedAlgorithmRunner<SerializedAlgorithm>::CreateHandle(
+      kSynchronizationRequired, std::move(algorithm));
+}
+
+template <typename SerializedAlgorithm>
+void OffloadAlgorithmRunner<SerializedAlgorithm>::Start(
+    scoped_refptr<Handle> handle) {
+  DCHECK(handle);
+
+  TRACE_EVENT0("cobalt::dom", "OffloadAlgorithmRunner::Start()");
+
+  process_task_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&OffloadAlgorithmRunner::Process,
+                                base::Unretained(this), handle));
+}
+
+template <typename SerializedAlgorithm>
+void OffloadAlgorithmRunner<SerializedAlgorithm>::Process(
+    scoped_refptr<Handle> handle) {
+  DCHECK(handle);
+  DCHECK(process_task_runner_->BelongsToCurrentThread());
+
+  TRACE_EVENT0("cobalt::dom", "OffloadAlgorithmRunner::Process()");
+
+  bool finished = false;
+  handle->Process(&finished);
+
+  if (finished) {
+    finalize_task_runner_->PostTask(
+        FROM_HERE, base::BindOnce(&Handle::FinalizeIfNotAborted, handle));
+    return;
+  }
+  process_task_runner_->PostTask(
+      FROM_HERE, base::BindOnce(&OffloadAlgorithmRunner::Process,
+                                base::Unretained(this), handle));
+}
+
 }  // namespace dom
 }  // namespace cobalt
 
diff --git a/cobalt/dom/source_buffer.cc b/cobalt/dom/source_buffer.cc
index ffaee80..1f6278b 100644
--- a/cobalt/dom/source_buffer.cc
+++ b/cobalt/dom/source_buffer.cc
@@ -387,11 +387,11 @@
                      base::Unretained(this)),
           base::Bind(&SourceBuffer::OnAlgorithmFinalized,
                      base::Unretained(this))));
+  auto algorithm_runner =
+      media_source_->GetAlgorithmRunner(std::numeric_limits<int>::max());
   active_algorithm_handle_ =
-      new SerializedAlgorithmRunner::Handle<SourceBufferAlgorithm>(
-          std::move(algorithm));
-  media_source_->GetAlgorithmRunner(std::numeric_limits<int>::max())
-      ->Start(active_algorithm_handle_);
+      algorithm_runner->CreateHandle(std::move(algorithm));
+  algorithm_runner->Start(active_algorithm_handle_);
 }
 
 void SourceBuffer::set_track_defaults(
@@ -482,9 +482,13 @@
 }
 
 void SourceBuffer::ScheduleAndMaybeDispatchImmediately(base::Token event_name) {
+  ScheduleEvent(event_name);
+  // TODO(b/244773734): Re-enable direct event dispatching
+  /*
   scoped_refptr<web::Event> event = new web::Event(event_name);
   event->set_target(this);
   event_queue_->EnqueueAndMaybeDispatchImmediately(event);
+  */
 }
 
 bool SourceBuffer::PrepareAppend(size_t new_data_size,
@@ -509,6 +513,7 @@
     return false;
   }
 
+  metrics_.StartTracking();
   media_source_->OpenIfInEndedState();
 
   double current_time = media_source_->GetMediaElement()->current_time(NULL);
@@ -517,9 +522,11 @@
           new_data_size + evict_extra_in_bytes_)) {
     web::DOMException::Raise(web::DOMException::kQuotaExceededErr,
                              exception_state);
+    metrics_.EndTracking(0);
     return false;
   }
 
+  metrics_.EndTracking(0);
   return true;
 }
 
@@ -528,11 +535,9 @@
     script::ExceptionState* exception_state) {
   TRACE_EVENT1("cobalt::dom", "SourceBuffer::AppendBufferInternal()", "size",
                size);
-  metrics_.StartTracking();
   if (!PrepareAppend(size, exception_state)) {
     return;
   }
-  metrics_.EndTracking(0);
 
   DCHECK(data || size == 0);
 
@@ -562,10 +567,10 @@
           base::Bind(&SourceBuffer::OnAlgorithmFinalized,
                      base::Unretained(this)),
           &metrics_));
+  auto algorithm_runner = media_source_->GetAlgorithmRunner(size);
   active_algorithm_handle_ =
-      new SerializedAlgorithmRunner::Handle<SourceBufferAlgorithm>(
-          std::move(algorithm));
-  media_source_->GetAlgorithmRunner(size)->Start(active_algorithm_handle_);
+      algorithm_runner->CreateHandle(std::move(algorithm));
+  algorithm_runner->Start(active_algorithm_handle_);
 }
 
 void SourceBuffer::OnAlgorithmFinalized() {
diff --git a/cobalt/dom/source_buffer.h b/cobalt/dom/source_buffer.h
index 0cf7f28..c7336e6 100644
--- a/cobalt/dom/source_buffer.h
+++ b/cobalt/dom/source_buffer.h
@@ -204,7 +204,7 @@
   starboard::Mutex timestamp_offset_mutex_;
   double timestamp_offset_ = 0;
 
-  scoped_refptr<SerializedAlgorithmRunner::Handle<SourceBufferAlgorithm>>
+  scoped_refptr<SerializedAlgorithmRunner<SourceBufferAlgorithm>::Handle>
       active_algorithm_handle_;
   double append_window_start_ = 0;
   double append_window_end_ = std::numeric_limits<double>::infinity();
diff --git a/cobalt/extension/on_screen_keyboard.h b/cobalt/extension/on_screen_keyboard.h
new file mode 100644
index 0000000..a1d922d
--- /dev/null
+++ b/cobalt/extension/on_screen_keyboard.h
@@ -0,0 +1,57 @@
+// 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_EXTENSION_ON_SCREEN_KEYBOARD_H_
+#define COBALT_EXTENSION_ON_SCREEN_KEYBOARD_H_
+
+#include <stdint.h>
+
+#include "starboard/system.h"
+#include "starboard/window.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define kCobaltExtensionOnScreenKeyboardName \
+  "dev.cobalt.extension.OnScreenKeyboard"
+
+typedef struct CobaltExtensionOnScreenKeyboardApi {
+  // Name should be the string
+  // |kCobaltExtensionOnScreenKeyboardName|. This helps to validate that
+  // the extension API is correct.
+  const char* name;
+
+  // This specifies the version of the API that is implemented.
+  uint32_t version;
+
+  // The fields below this point were added in version 1 or later.
+
+  // This function overrides the background color of on-screen keyboard.
+  // The function is only enabled for Apple TV at the moment.
+  // background_color should be a string of below formats:
+  // 1. hex color notation #RRGGBB, e.g. "#0000FF".
+  // 2. rgb color notation rgb(R, G, B), e.g. "rgb(0, 0, 255)".
+  void (*SetBackgroundColor)(SbWindow window, const char* background_color);
+
+  // This function overrides the dark theme of on-screen keyboard.
+  // The function is only enabled for Apple TV at the moment.
+  void (*SetDarkTheme)(SbWindow window, bool dark_theme);
+} CobaltExtensionOnScreenKeyboardApi;
+
+#ifdef __cplusplus
+}  // extern "C"
+#endif
+
+#endif  // COBALT_EXTENSION_ON_SCREEN_KEYBOARD_H_
diff --git a/cobalt/media_session/media_session_client.cc b/cobalt/media_session/media_session_client.cc
index e668cae..c8290cf 100644
--- a/cobalt/media_session/media_session_client.cc
+++ b/cobalt/media_session/media_session_client.cc
@@ -331,7 +331,7 @@
           ext_image.src = media_image.src().c_str();
           if (ext_image.src == nullptr) {
             // src() is required, but Cobalt IDL parser doesn't enforce it.
-            // http://cs/cobalt/cobalt/media_session/media_image.idl?l=19
+            // See cobalt/media_session/media_image.idl for more info.
             // https://wicg.github.io/mediasession/#dictdef-mediaimage
             LOG(ERROR) << "Required src string for MediaImage is missing.";
           }
diff --git a/starboard/CHANGELOG.md b/starboard/CHANGELOG.md
index 69ca601..fddc2c3 100644
--- a/starboard/CHANGELOG.md
+++ b/starboard/CHANGELOG.md
@@ -15,6 +15,9 @@
 [configuration.h](configuration.h).
 
 ## Version 14
+### Require kSbSystemPathStorageDirectory on all platforms.
+Path to directory for permanent persistent storage.
+
 ### Add MP3, FLAC, and PCM values to SbMediaAudioCodec.
 This makes it possible to support these codecs in the future.
 
diff --git a/starboard/android/apk/app/src/app/AndroidManifest.xml b/starboard/android/apk/app/src/app/AndroidManifest.xml
index 42d8bc0..9c4e11a 100644
--- a/starboard/android/apk/app/src/app/AndroidManifest.xml
+++ b/starboard/android/apk/app/src/app/AndroidManifest.xml
@@ -32,7 +32,7 @@
   <!-- This is needed when targeting API 28+ to use foreground services -->
   <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
 
-  <!-- Used for go/cobalt-ifa and AdvertisingIdClient.Info.getId() -->
+  <!-- https://iabtechlab.com/OTT-IFA, AdvertisingIdClient.Info.getId() -->
   <uses-permission android:name="com.google.android.gms.permission.AD_ID"/>
 
   <application
diff --git a/starboard/android/apk/app/src/main/java/dev/cobalt/libraries/services/clientloginfo/ClientLogInfo.java b/starboard/android/apk/app/src/main/java/dev/cobalt/libraries/services/clientloginfo/ClientLogInfo.java
index 57c39ad..7628f93 100644
--- a/starboard/android/apk/app/src/main/java/dev/cobalt/libraries/services/clientloginfo/ClientLogInfo.java
+++ b/starboard/android/apk/app/src/main/java/dev/cobalt/libraries/services/clientloginfo/ClientLogInfo.java
@@ -6,10 +6,7 @@
 import dev.cobalt.coat.CobaltService;
 import dev.cobalt.util.Log;
 
-/**
- * ClientLogInfo to report Android API support on android devices, read go/coat-api-support for more
- * info.
- */
+/** ClientLogInfo to report Android API support on android devices. */
 public class ClientLogInfo extends CobaltService {
   public static final String TAG = "ClientLogInfo";
 
diff --git a/starboard/nplb/system_get_path_test.cc b/starboard/nplb/system_get_path_test.cc
index e320737..44f4e00 100644
--- a/starboard/nplb/system_get_path_test.cc
+++ b/starboard/nplb/system_get_path_test.cc
@@ -69,6 +69,9 @@
 TEST(SbSystemGetPathTest, ReturnsRequiredPaths) {
   BasicTest(kSbSystemPathContentDirectory, true, true, __LINE__);
   BasicTest(kSbSystemPathCacheDirectory, true, true, __LINE__);
+#if SB_API_VERSION >= 14
+  BasicTest(kSbSystemPathStorageDirectory, true, true, __LINE__);
+#endif  // SB_API_VERSION >= 14
 }
 
 TEST(SbSystemGetPathTest, FailsGracefullyZeroBufferLength) {
diff --git a/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h b/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h
index 3f6e7c0..8a997a8 100644
--- a/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h
+++ b/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h
@@ -62,9 +62,6 @@
   void Reset() override;
 
  private:
-  void ProcessOneInputBuffer(const scoped_refptr<InputBuffer>& input_buffer,
-                             const ConsumedCB& consumed_cb);
-
   void InitializeAudioDecoder(const SbMediaAudioSampleInfo& audio_sample_info);
   void TeardownAudioDecoder();
   void OnDecoderOutput();