diff --git a/src/base/trace_event/trace_event_memory_overhead.h b/src/base/trace_event/trace_event_memory_overhead.h
index 2687e93..7016f0f 100644
--- a/src/base/trace_event/trace_event_memory_overhead.h
+++ b/src/base/trace_event/trace_event_memory_overhead.h
@@ -6,6 +6,7 @@
 #define BASE_TRACE_EVENT_TRACE_EVENT_MEMORY_OVERHEAD_H_
 
 #include <unordered_map>
+#include <string>
 
 #include "base/base_export.h"
 #include "base/macros.h"
diff --git a/src/cobalt/CHANGELOG.md b/src/cobalt/CHANGELOG.md
index f2872b4..644ecae 100644
--- a/src/cobalt/CHANGELOG.md
+++ b/src/cobalt/CHANGELOG.md
@@ -119,6 +119,12 @@
    the comment of `SbMediaCanPlayMimeAndKeySystem()` in `media.h` for more
    details.
 
+ - **Added support for controlling shutdown behavior of graphics system.**
+
+   Cobalt normally clears the framebuffer to opaque black on suspend or exit.
+   This behavior can now be overridden by implementing the cobalt extension
+   function `CobaltExtensionGraphicsApi::ShouldClearFrameOnShutdown`.
+
 ## Version 20
 
  - **Support for QUIC and SPDY is now enabled.**
diff --git a/src/cobalt/bindings/run_cobalt_bindings_tests.py b/src/cobalt/bindings/run_cobalt_bindings_tests.py
old mode 100644
new mode 100755
index a9e3be7..f852272
--- a/src/cobalt/bindings/run_cobalt_bindings_tests.py
+++ b/src/cobalt/bindings/run_cobalt_bindings_tests.py
@@ -27,6 +27,7 @@
 import sys
 
 import _env  # pylint: disable=unused-import
+
 from cobalt.bindings.idl_compiler_cobalt import IdlCompilerCobalt
 from cobalt.bindings.mozjs45.code_generator_mozjs45 import CodeGeneratorMozjs45
 from cobalt.bindings.v8c.code_generator_v8c import CodeGeneratorV8c
diff --git a/src/cobalt/bindings/testing/date_bindings_test.cc b/src/cobalt/bindings/testing/date_bindings_test.cc
index 602f2ee..bb58362 100644
--- a/src/cobalt/bindings/testing/date_bindings_test.cc
+++ b/src/cobalt/bindings/testing/date_bindings_test.cc
@@ -14,8 +14,11 @@
 
 #include "base/logging.h"
 
+#include "base/time/time.h"
 #include "cobalt/bindings/testing/bindings_test_base.h"
 #include "cobalt/bindings/testing/interface_with_date.h"
+#include "starboard/client_porting/eztime/eztime.h"
+#include "starboard/time_zone.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -79,6 +82,45 @@
   EXPECT_LT(std::abs(posix_now_ms - js_now_ms), 1000);
 }
 
+TEST_F(DateBindingsTest, StarboardTimeZone) {
+  const char* month_table[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
+                               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
+  std::string result;
+
+  EvaluateScript("new Date().toString();", &result);
+  base::Time now = base::Time::Now();
+
+  SB_LOG(INFO) << "JavaScript Date now is : " << result;
+  SB_LOG(INFO) << "and base::Time is: " << now;
+
+  base::Time::Exploded exploded;
+  now.LocalExplode(&exploded);
+  EXPECT_NE(result.find(std::to_string(exploded.year)), std::string::npos);
+  EXPECT_NE(result.find(month_table[exploded.month - 1]), std::string::npos);
+  EXPECT_NE(result.find(std::to_string(exploded.day_of_month)),
+            std::string::npos);
+  EXPECT_NE(result.find(std::to_string(exploded.hour)), std::string::npos);
+  EXPECT_NE(result.find(std::to_string(exploded.minute)), std::string::npos);
+  EXPECT_NE(result.find(std::to_string(exploded.second)), std::string::npos);
+}
+
+TEST_F(DateBindingsTest, TimezoneOffset) {
+  EzTimeExploded ez_exploded;
+
+  auto eztt = EzTimeTFromSbTime(SbTimeGetNow());
+  EzTimeTExplodeLocal(&eztt, &ez_exploded);
+  // ez_exploded is already local time, use UTC method to convert to
+  // EzTimeT.
+  EzTimeT local_time_minutes = EzTimeTImplodeUTC(&ez_exploded) / 60;
+  EzTimeT utc_minutes = EzTimeTFromSbTime(SbTimeGetNow()) / 60;
+  EzTimeT timezone_offset = utc_minutes - local_time_minutes;
+
+  std::string result;
+  EvaluateScript("new Date().getTimezoneOffset();", &result);
+
+  EXPECT_EQ(result, std::to_string(utc_minutes - local_time_minutes));
+}
+
 }  // namespace
 }  // namespace testing
 }  // namespace bindings
diff --git a/src/cobalt/browser/application.cc b/src/cobalt/browser/application.cc
index f5459ed..63e56d4 100644
--- a/src/cobalt/browser/application.cc
+++ b/src/cobalt/browser/application.cc
@@ -18,6 +18,7 @@
 
 #include "cobalt/browser/application.h"
 
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ -255,6 +256,15 @@
   return initial_url;
 }
 
+bool ValidateSplashScreen(const base::Optional<GURL>& url) {
+  if (url->is_valid() &&
+      (url->SchemeIsFile() || url->SchemeIs("h5vcc-embedded"))) {
+    return true;
+  }
+  LOG(FATAL) << "Ignoring invalid fallback splash screen: " << url->spec();
+  return false;
+}
+
 base::Optional<GURL> GetFallbackSplashScreenURL() {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   std::string fallback_splash_screen_string;
@@ -270,15 +280,51 @@
   }
   base::Optional<GURL> fallback_splash_screen_url =
       GURL(fallback_splash_screen_string);
-  if (!fallback_splash_screen_url->is_valid() ||
-      !(fallback_splash_screen_url->SchemeIsFile() ||
-        fallback_splash_screen_url->SchemeIs("h5vcc-embedded"))) {
-    LOG(FATAL) << "Ignoring invalid fallback splash screen: "
-               << fallback_splash_screen_string;
-  }
+  ValidateSplashScreen(fallback_splash_screen_url);
   return fallback_splash_screen_url;
 }
 
+// Parses the fallback_splash_screen_topics command line parameter
+// and maps topics to full file url locations, if valid.
+void ParseFallbackSplashScreenTopics(
+    const base::Optional<GURL>& default_fallback_splash_screen_url,
+    std::map<std::string, GURL>* fallback_splash_screen_topic_map) {
+  base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
+  std::string topics;
+  if (command_line->HasSwitch(switches::kFallbackSplashScreenTopics)) {
+    topics = command_line->GetSwitchValueASCII(
+        switches::kFallbackSplashScreenTopics);
+  } else {
+    topics = configuration::Configuration::GetInstance()
+                 ->CobaltFallbackSplashScreenTopics();
+  }
+
+  // Note: values in topics_map may be either file paths or filenames.
+  std::map<std::string, std::string> topics_map;
+  BrowserModule::GetParamMap(topics, topics_map);
+  for (auto iterator = topics_map.begin(); iterator != topics_map.end();
+       iterator++) {
+    std::string topic = iterator->first;
+    std::string location = iterator->second;
+    base::Optional<GURL> topic_fallback_url = GURL(location);
+
+    // If not a valid url, check whether it is a valid filename in the
+    // same directory as the default fallback url.
+    if (!topic_fallback_url->is_valid()) {
+      if (default_fallback_splash_screen_url) {
+        topic_fallback_url = GURL(
+            default_fallback_splash_screen_url->GetWithoutFilename().spec() +
+            location);
+      } else {
+        break;
+      }
+    }
+    if (ValidateSplashScreen(topic_fallback_url)) {
+      (*fallback_splash_screen_topic_map)[topic] = topic_fallback_url.value();
+    }
+  }
+}
+
 base::TimeDelta GetTimedTraceDuration() {
 #if defined(ENABLE_DEBUG_COMMAND_LINE_SWITCHES)
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
@@ -579,6 +625,9 @@
   options.build_auto_mem_settings = memory_settings::GetDefaultBuildSettings();
   options.fallback_splash_screen_url = fallback_splash_screen_url;
 
+  ParseFallbackSplashScreenTopics(fallback_splash_screen_url,
+                                  &options.fallback_splash_screen_topic_map);
+
   if (command_line->HasSwitch(browser::switches::kFPSPrint)) {
     options.renderer_module_options.enable_fps_stdout = true;
   }
diff --git a/src/cobalt/browser/browser_module.cc b/src/cobalt/browser/browser_module.cc
index 383de3e..e143407 100644
--- a/src/cobalt/browser/browser_module.cc
+++ b/src/cobalt/browser/browser_module.cc
@@ -15,6 +15,7 @@
 #include "cobalt/browser/browser_module.h"
 
 #include <algorithm>
+#include <map>
 #include <memory>
 #include <vector>
 
@@ -31,6 +32,7 @@
 #include "base/time/time.h"
 #include "base/trace_event/trace_event.h"
 #include "cobalt/base/cobalt_paths.h"
+#include "cobalt/base/init_cobalt.h"
 #include "cobalt/base/source_location.h"
 #include "cobalt/base/tokens.h"
 #include "cobalt/browser/on_screen_keyboard_starboard_bridge.h"
@@ -452,6 +454,7 @@
                    base::Unretained(this))));
   }
 
+  // Set the fallback splash screen url to the default fallback url.
   fallback_splash_screen_url_ = options.fallback_splash_screen_url;
 
   // Synchronously construct our WebModule object.
@@ -562,15 +565,17 @@
   DestroySplashScreen(base::TimeDelta());
   if (options_.enable_splash_screen_on_reloads ||
       main_web_module_generation_ == 1) {
-    base::Optional<std::string> key = SplashScreenCache::GetKeyForStartUrl(url);
+    base::Optional<std::string> topic = SetSplashScreenTopicFallback(url);
+    splash_screen_cache_->SetUrl(url, topic);
+
     if (fallback_splash_screen_url_ ||
-        (key && splash_screen_cache_->IsSplashScreenCached(*key))) {
+        splash_screen_cache_->IsSplashScreenCached()) {
       splash_screen_.reset(new SplashScreen(
           application_state_,
           base::Bind(&BrowserModule::QueueOnSplashScreenRenderTreeProduced,
                      base::Unretained(this)),
           network_module_, viewport_size, GetResourceProvider(),
-          kLayoutMaxRefreshFrequencyInHz, fallback_splash_screen_url_, url,
+          kLayoutMaxRefreshFrequencyInHz, fallback_splash_screen_url_,
           splash_screen_cache_.get(),
           base::Bind(&BrowserModule::DestroySplashScreen, weak_this_)));
       lifecycle_observers_.AddObserver(splash_screen_.get());
@@ -1893,5 +1898,64 @@
   return system_window_->GetSbWindow();
 }
 
+base::Optional<std::string> BrowserModule::SetSplashScreenTopicFallback(
+    const GURL& url) {
+  std::map<std::string, std::string> url_param_map;
+  // If this is the initial startup, use topic within deeplink, if specified.
+  if (main_web_module_generation_ == 1) {
+    GetParamMap(GetInitialDeepLink(), url_param_map);
+  }
+  // If this is not the initial startup, there was no deeplink specified, or
+  // the deeplink did not have a topic, check the current url for a topic.
+  if (url_param_map["topic"].empty()) {
+    GetParamMap(url.query(), url_param_map);
+  }
+  std::string splash_topic = url_param_map["topic"];
+  // If a topic was found, check whether a fallback url was specified.
+  if (!splash_topic.empty()) {
+    GURL splash_url = options_.fallback_splash_screen_topic_map[splash_topic];
+    if (!splash_url.spec().empty()) {
+      // Update fallback splash screen url to topic-specific URL.
+      fallback_splash_screen_url_ = splash_url;
+    }
+    return base::Optional<std::string>(splash_topic);
+  }
+  return base::Optional<std::string>();
+}
+
+void BrowserModule::GetParamMap(const std::string& url,
+                                std::map<std::string, std::string>& map) {
+  bool next_is_option = true;
+  bool next_is_value = false;
+  std::string option = "";
+  base::StringTokenizer tokenizer(url, "&=");
+  tokenizer.set_options(base::StringTokenizer::RETURN_DELIMS);
+
+  while (tokenizer.GetNext()) {
+    if (tokenizer.token_is_delim()) {
+      switch (*tokenizer.token_begin()) {
+        case '&':
+          next_is_option = true;
+          break;
+        case '=':
+          next_is_value = true;
+          break;
+      }
+    } else {
+      std::string token = tokenizer.token();
+      if (next_is_value && !option.empty()) {
+        // Overwrite previous value when an option appears more than once.
+        map[option] = token;
+      }
+      option = "";
+      if (next_is_option) {
+        option = token;
+      }
+      next_is_option = false;
+      next_is_value = false;
+    }
+  }
+}
+
 }  // namespace browser
 }  // namespace cobalt
diff --git a/src/cobalt/browser/browser_module.h b/src/cobalt/browser/browser_module.h
index 15e0b94..f5bce8f 100644
--- a/src/cobalt/browser/browser_module.h
+++ b/src/cobalt/browser/browser_module.h
@@ -15,6 +15,7 @@
 #ifndef COBALT_BROWSER_BROWSER_MODULE_H_
 #define COBALT_BROWSER_BROWSER_MODULE_H_
 
+#include <map>
 #include <memory>
 #include <string>
 #include <vector>
@@ -104,6 +105,7 @@
     memory_settings::AutoMemSettings command_line_auto_mem_settings;
     memory_settings::AutoMemSettings build_auto_mem_settings;
     base::Optional<GURL> fallback_splash_screen_url;
+    std::map<std::string, GURL> fallback_splash_screen_topic_map;
     base::Optional<cssom::ViewportSize> requested_viewport_size;
     bool enable_splash_screen_on_reloads;
     bool enable_on_screen_keyboard = true;
@@ -215,6 +217,11 @@
 
   bool IsWebModuleLoaded() { return web_module_loaded_.IsSignaled(); }
 
+  // Parses url and defines a mapping of parameter values of the form
+  // &option=value&foo=bar.
+  static void GetParamMap(const std::string& url,
+                          std::map<std::string, std::string>& map);
+
  private:
 #if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
   static void CoreDumpHandler(void* browser_module_as_void);
@@ -431,6 +438,10 @@
   // applied according to the current time.
   scoped_refptr<render_tree::Node> GetLastSubmissionAnimated();
 
+  // Sets the fallback splash screen url to a topic-specific URL, if applicable.
+  // Returns the topic used, or an empty Optional if a topic isn't found.
+  base::Optional<std::string> SetSplashScreenTopicFallback(const GURL& url);
+
   // 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/src/cobalt/browser/splash_screen.cc b/src/cobalt/browser/splash_screen.cc
index 962142f..5521bec 100644
--- a/src/cobalt/browser/splash_screen.cc
+++ b/src/cobalt/browser/splash_screen.cc
@@ -57,7 +57,6 @@
     const cssom::ViewportSize& window_dimensions,
     render_tree::ResourceProvider* resource_provider, float layout_refresh_rate,
     const base::Optional<GURL>& fallback_splash_screen_url,
-    const GURL& initial_main_web_module_url,
     SplashScreenCache* splash_screen_cache,
     const base::Callback<void(base::TimeDelta)>&
         on_splash_screen_shutdown_complete)
@@ -76,15 +75,10 @@
       base::ThreadPriority::HIGHEST;
 
   base::Optional<GURL> url_to_pass = fallback_splash_screen_url;
-  // Use the cached URL rather than the passed in URL if it exists.
-  base::Optional<std::string> key =
-      SplashScreenCache::GetKeyForStartUrl(initial_main_web_module_url);
   DCHECK(fallback_splash_screen_url ||
-         (key && splash_screen_cache &&
-          splash_screen_cache->IsSplashScreenCached(*key)));
-  if (key && splash_screen_cache &&
-      splash_screen_cache->IsSplashScreenCached(*key)) {
-    url_to_pass = GURL(loader::kCacheScheme + ("://" + *key));
+         (splash_screen_cache && splash_screen_cache->IsSplashScreenCached()));
+  if (splash_screen_cache && splash_screen_cache->IsSplashScreenCached()) {
+    url_to_pass = splash_screen_cache->GetCachedSplashScreenUrl();
     web_module_options.can_fetch_cache = true;
     web_module_options.splash_screen_cache = splash_screen_cache;
   }
diff --git a/src/cobalt/browser/splash_screen.h b/src/cobalt/browser/splash_screen.h
index 853c584..5cce8e8 100644
--- a/src/cobalt/browser/splash_screen.h
+++ b/src/cobalt/browser/splash_screen.h
@@ -42,7 +42,6 @@
                render_tree::ResourceProvider* resource_provider,
                float layout_refresh_rate,
                const base::Optional<GURL>& fallback_splash_screen_url,
-               const GURL& initial_main_web_module_url,
                cobalt::browser::SplashScreenCache* splash_screen_cache,
                const base::Callback<void(base::TimeDelta)>&
                    on_splash_screen_shutdown_complete);
diff --git a/src/cobalt/browser/splash_screen_cache.cc b/src/cobalt/browser/splash_screen_cache.cc
index 43cb6f7..7631ae3 100644
--- a/src/cobalt/browser/splash_screen_cache.cc
+++ b/src/cobalt/browser/splash_screen_cache.cc
@@ -18,6 +18,7 @@
 #include <string>
 #include <vector>
 
+#include "base/base64.h"
 #include "base/hash.h"
 #include "base/optional.h"
 #include "base/strings/string_util.h"
@@ -59,10 +60,15 @@
   base::AutoLock lock(lock_);
 }
 
-bool SplashScreenCache::CacheSplashScreen(const std::string& key,
-                                          const std::string& content) const {
+bool SplashScreenCache::CacheSplashScreen(
+    const std::string& content,
+    const base::Optional<std::string>& topic) const {
   base::AutoLock lock(lock_);
-  if (key.empty()) {
+  // Cache the content so that it's retrievable for the topic specified in the
+  // rel attribute. This topic may or may not match the topic-specified for this
+  // particular startup, tracked with "topic_".
+  base::Optional<std::string> key = GetKeyForStartConfig(url_, topic);
+  if (!key) {
     return false;
   }
 
@@ -76,10 +82,11 @@
                        kSbFileMaxPath)) {
     return false;
   }
-  if (!CreateDirsForKey(key)) {
+  if (!CreateDirsForKey(key.value())) {
     return false;
   }
-  std::string full_path = std::string(path.data()) + kSbFileSepString + key;
+  std::string full_path =
+      std::string(path.data()) + kSbFileSepString + key.value();
   starboard::ScopedFile cache_file(
       full_path.c_str(), kSbFileCreateAlways | kSbFileWrite, NULL, NULL);
 
@@ -87,15 +94,18 @@
                              static_cast<int>(content.size())) > 0;
 }
 
-bool SplashScreenCache::IsSplashScreenCached(const std::string& key) const {
+bool SplashScreenCache::IsSplashScreenCached() const {
   base::AutoLock lock(lock_);
   std::vector<char> path(kSbFileMaxPath, 0);
   if (!SbSystemGetPath(kSbSystemPathCacheDirectory, path.data(),
                        kSbFileMaxPath)) {
     return false;
   }
-  std::string full_path = std::string(path.data()) + kSbFileSepString + key;
-  return !key.empty() && SbFileExists(full_path.c_str());
+  base::Optional<std::string> key = GetKeyForStartConfig(url_, topic_);
+  if (!key) return false;
+  std::string full_path =
+      std::string(path.data()) + kSbFileSepString + key.value();
+  return SbFileExists(full_path.c_str());
 }
 
 int SplashScreenCache::ReadCachedSplashScreen(
@@ -126,9 +136,8 @@
   return result_size;
 }
 
-// static
-base::Optional<std::string> SplashScreenCache::GetKeyForStartUrl(
-    const GURL& url) {
+base::Optional<std::string> SplashScreenCache::GetKeyForStartConfig(
+    const GURL& url, const base::Optional<std::string>& topic) const {
   base::Optional<std::string> encoded_url = base::GetApplicationKey(url);
   if (!encoded_url) {
     return base::nullopt;
@@ -142,26 +151,36 @@
   }
 
   std::string subpath = "";
-  std::string subcomponent = kSbFileSepString + std::string("splash_screen");
-  if (SbStringConcat(path.data(), subcomponent.c_str(), kSbFileMaxPath) >=
-      static_cast<int>(kSbFileMaxPath)) {
+  if (!AddPathDirectory(std::string("splash_screen"), path, subpath)) {
     return base::nullopt;
   }
-  subpath += "splash_screen";
-  subcomponent = kSbFileSepString + *encoded_url;
-  if (SbStringConcat(path.data(), subcomponent.c_str(), kSbFileMaxPath) >=
-      static_cast<int>(kSbFileMaxPath)) {
+  if (!AddPathDirectory(*encoded_url, path, subpath)) {
     return base::nullopt;
   }
-  subpath += subcomponent;
-  subcomponent = kSbFileSepString + std::string("splash.html");
-  if (SbStringConcat(path.data(), subcomponent.c_str(), kSbFileMaxPath) >
-      static_cast<int>(kSbFileMaxPath)) {
+  if (topic && !topic.value().empty()) {
+    std::string encoded_topic;
+    base::Base64Encode(topic.value(), &encoded_topic);
+    if (!AddPathDirectory(encoded_topic, path, subpath)) {
+      return base::nullopt;
+    }
+  }
+  if (!AddPathDirectory(std::string("splash.html"), path, subpath)) {
     return base::nullopt;
   }
-  subpath += subcomponent;
 
-  return subpath;
+  return subpath.erase(0, 1);  // Remove leading separator
+}
+
+bool SplashScreenCache::AddPathDirectory(const std::string& directory,
+                                         std::vector<char>& path,
+                                         std::string& subpath) const {
+  std::string subcomponent = kSbFileSepString + directory;
+  if (SbStringConcat(path.data(), subcomponent.c_str(), kSbFileMaxPath) >=
+      static_cast<int>(kSbFileMaxPath)) {
+    return false;
+  }
+  subpath += subcomponent;
+  return true;
 }
 
 }  // namespace browser
diff --git a/src/cobalt/browser/splash_screen_cache.h b/src/cobalt/browser/splash_screen_cache.h
index deacfc8..b10e8cd 100644
--- a/src/cobalt/browser/splash_screen_cache.h
+++ b/src/cobalt/browser/splash_screen_cache.h
@@ -17,9 +17,11 @@
 
 #include <memory>
 #include <string>
+#include <vector>
 
 #include "base/optional.h"
 #include "base/synchronization/lock.h"
+#include "cobalt/loader/cache_fetcher.h"
 #include "url/gurl.h"
 
 namespace cobalt {
@@ -36,25 +38,46 @@
   SplashScreenCache();
 
   // Cache the splash screen.
-  bool CacheSplashScreen(const std::string& key,
-                         const std::string& content) const;
+  bool CacheSplashScreen(const std::string& content,
+                         const base::Optional<std::string>& topic) const;
 
   // Read the cached the splash screen.
   int ReadCachedSplashScreen(const std::string& key,
                              std::unique_ptr<char[]>* result) const;
 
-  // Determine if a splash screen is cached corresponding to the key.
-  bool IsSplashScreenCached(const std::string& key) const;
+  // Determine if a splash screen is cached corresponding to the current url.
+  bool IsSplashScreenCached() const;
 
-  // Get the key that corresponds to a starting URL. Optionally create
-  // subdirectories along the path.
-  static base::Optional<std::string> GetKeyForStartUrl(const GURL& url);
+  // Set the URL of the currently requested splash screen.
+  void SetUrl(const GURL& url, const base::Optional<std::string>& topic) {
+    url_ = url;
+    topic_ = topic;
+  }
+
+  // Get the cache location of the currently requested splash screen.
+  GURL GetCachedSplashScreenUrl() {
+    base::Optional<std::string> key = GetKeyForStartConfig(url_, topic_);
+    return GURL(loader::kCacheScheme + ("://" + *key));
+  }
 
  private:
+  // Get the key that corresponds to the starting URL and (optional) topic.
+  base::Optional<std::string> GetKeyForStartConfig(
+      const GURL& url, const base::Optional<std::string>& topic) const;
+
+  // Adds the directory to the path and subpath if the new path does not exceed
+  // maximum length. Returns true if successful.
+  bool AddPathDirectory(const std::string& directory, std::vector<char>& path,
+                        std::string& subpath) const;
+
   // Lock to protect access to the cache file.
   mutable base::Lock lock_;
   // Hash of the last read page contents.
   mutable uint32_t last_page_hash_;
+  // Latest url that was navigated to.
+  GURL url_;
+  // Splash topic associated with startup.
+  base::Optional<std::string> topic_;
 };
 
 }  // namespace browser
diff --git a/src/cobalt/browser/switches.cc b/src/cobalt/browser/switches.cc
index 915b762..64653d5 100644
--- a/src/cobalt/browser/switches.cc
+++ b/src/cobalt/browser/switches.cc
@@ -390,6 +390,17 @@
     "no value is set, the URL in gyp_configuration.gypi or base.gypi will be "
     "used.";
 
+const char kFallbackSplashScreenTopics[] = "fallback_splash_screen_topics";
+const char kFallbackSplashScreenTopicsHelp[] =
+    "Setting this switch defines a mapping of URL 'topics' to splash screen "
+    "URLs or filenames that Cobalt will use in the absence of a web cache, "
+    "(for example, music=music_splash_screen.html&foo=file:///bar.html). If a "
+    "URL is given it should match the format of 'fallback_splash_screen_url'. "
+    "A given filename should exist in the same directory as "
+    "'fallback_splash_screen_url'. If no fallback url exists for the topic of "
+    "the URL used to launch Cobalt, then the value of "
+    "'fallback_splash_screen_url' will be used.";
+
 const char kVersion[] = "version";
 const char kVersionHelp[] = "Prints the current version of Cobalt";
 
diff --git a/src/cobalt/browser/switches.h b/src/cobalt/browser/switches.h
index f70c0f8..67c03f7 100644
--- a/src/cobalt/browser/switches.h
+++ b/src/cobalt/browser/switches.h
@@ -151,6 +151,8 @@
 extern const char kSoftwareSurfaceCacheSizeInBytesHelp[];
 extern const char kFallbackSplashScreenURL[];
 extern const char kFallbackSplashScreenURLHelp[];
+extern const char kFallbackSplashScreenTopics[];
+extern const char kFallbackSplashScreenTopicsHelp[];
 extern const char kVersion[];
 extern const char kVersionHelp[];
 extern const char kViewport[];
diff --git a/src/cobalt/browser/web_module.cc b/src/cobalt/browser/web_module.cc
index 1923513..7d0a353 100644
--- a/src/cobalt/browser/web_module.cc
+++ b/src/cobalt/browser/web_module.cc
@@ -86,23 +86,20 @@
 // deeper than this could be discarded, and will not be rendered.
 const int kDOMMaxElementDepth = 32;
 
-bool CacheUrlContent(SplashScreenCache* splash_screen_cache, const GURL& url,
-                     const std::string& content) {
-  base::Optional<std::string> key = SplashScreenCache::GetKeyForStartUrl(url);
-  if (key) {
-    return splash_screen_cache->SplashScreenCache::CacheSplashScreen(*key,
-                                                                     content);
-  }
-  return false;
+void CacheUrlContent(SplashScreenCache* splash_screen_cache,
+                     const std::string& content,
+                     const base::Optional<std::string>& topic) {
+  splash_screen_cache->SplashScreenCache::CacheSplashScreen(content, topic);
 }
 
-base::Callback<bool(const GURL&, const std::string&)> CacheUrlContentCallback(
-    SplashScreenCache* splash_screen_cache) {
+base::Callback<void(const std::string&, const base::Optional<std::string>&)>
+CacheUrlContentCallback(SplashScreenCache* splash_screen_cache) {
   // This callback takes in first the url, then the content string.
   if (splash_screen_cache) {
     return base::Bind(CacheUrlContent, base::Unretained(splash_screen_cache));
   } else {
-    return base::Callback<bool(const GURL&, const std::string&)>();
+    return base::Callback<void(const std::string&,
+                               const base::Optional<std::string>&)>();
   }
 }
 
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index f24700a..e9bfa85 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-283720
\ No newline at end of file
+289852
\ No newline at end of file
diff --git a/src/cobalt/build/cobalt_configuration.py b/src/cobalt/build/cobalt_configuration.py
index 691c283..4815b88 100644
--- a/src/cobalt/build/cobalt_configuration.py
+++ b/src/cobalt/build/cobalt_configuration.py
@@ -38,8 +38,17 @@
                          application_directory)
 
   def GetVariables(self, config_name):
+
+    # Use env var to optimize build speed on CI
+    try:
+      # Force to int, so it's easy to pass in an override.
+      use_fastbuild = int(os.environ.get('IS_CI', 0))
+    except (ValueError, TypeError):
+      use_fastbuild = 0
+
     variables = {
-        'cobalt_fastbuild': os.environ.get('LB_FASTBUILD', 0),
+        # This is used to omit large debuginfo in files on CI environment
+        'cobalt_fastbuild': use_fastbuild,
 
         # This is here rather than cobalt_configuration.gypi so that it's
         # available for browser_bindings_gen.gyp.
@@ -114,7 +123,15 @@
 
         # XMLHttpRequest: send() - Redirects (basics) (307).
         # Disabled because of: Flaky.
-        'xhr/WebPlatformTest.Run/XMLHttpRequest_send_redirect_htm'
+        'xhr/WebPlatformTest.Run/XMLHttpRequest_send_redirect_htm',
+
+        # Disabled because of: Flaky on buildbot across multiple buildconfigs.
+        # Non-reproducible with local runs.
+        ('xhr/WebPlatformTest.Run/'
+         'XMLHttpRequest_send_entity_body_get_head_async_htm'),
+        'xhr/WebPlatformTest.Run/XMLHttpRequest_status_error_htm',
+        'xhr/WebPlatformTest.Run/XMLHttpRequest_response_json_htm',
+        'xhr/WebPlatformTest.Run/XMLHttpRequest_send_redirect_to_non_cors_htm',
     ]
     return filters
 
diff --git a/src/cobalt/build/gyp_utils.py b/src/cobalt/build/gyp_utils.py
index cabcbe1..986d81c 100644
--- a/src/cobalt/build/gyp_utils.py
+++ b/src/cobalt/build/gyp_utils.py
@@ -25,7 +25,7 @@
 import _env  # pylint: disable=unused-import
 from cobalt.tools import paths
 
-
+_REVINFO_KEY = 'cobalt_src'
 _VERSION_SERVER_URL = 'https://carbon-airlock-95823.appspot.com/build_version/generate'  # pylint:disable=line-too-long
 _XSSI_PREFIX = ")]}'\n"
 
@@ -34,32 +34,29 @@
 
 
 def GetRevinfo():
-  """Get absolute state of all git repos from gclient DEPS."""
+  """Get absolute state of all git repos."""
+
+  git_get_remote_args = ['config', '--get', 'remote.origin.url']
+  git_get_revision_args = ['rev-parse', 'HEAD']
 
   try:
-    revinfo_cmd = ['gclient', 'revinfo', '-a']
-
-    if sys.platform.startswith('linux') or sys.platform == 'darwin':
-      use_shell = False
-    else:
-      # Windows needs shell to find gclient in the PATH.
-      use_shell = True
-    output = subprocess.check_output(revinfo_cmd, shell=use_shell)
-    revinfo = {}
-    lines = output.splitlines()
-    for line in lines:
-      repo, url = line.split(':', 1)
-      repo = repo.strip().replace('\\', '/')
-      url = url.strip()
-      revinfo[repo] = url
-    return revinfo
-  except (subprocess.CalledProcessError, ValueError) as e:
-    logging.warning('Failed to get revision information: %s', e)
+    cobalt_remote = subprocess.check_output(['git'] +
+                                            git_get_remote_args).strip()
+    cobalt_rev = subprocess.check_output(['git'] +
+                                         git_get_revision_args).strip()
+    return {_REVINFO_KEY: '{}@{}'.format(cobalt_remote, cobalt_rev)}
+  except subprocess.CalledProcessError:
+    logging.info(
+        'Failed to get revision information. Trying again in src/ directory...')
     try:
-      logging.warning('Command output was: %s', line)
-    except NameError:
-      pass
-    return {}
+      cobalt_remote = subprocess.check_output(['git', '-C', 'src'] +
+                                              git_get_remote_args).strip()
+      cobalt_rev = subprocess.check_output(['git', '-C', 'src'] +
+                                           git_get_revision_args).strip()
+      return {_REVINFO_KEY: '{}@{}'.format(cobalt_remote, cobalt_rev)}
+    except subprocess.CalledProcessError as e:
+      logging.warning('Failed to get revision information: %s', e)
+      return {}
 
 
 def GetBuildNumber(version_server=_VERSION_SERVER_URL):
@@ -119,10 +116,10 @@
     match = search_re.search(f.read())
 
   if not match:
-    logging.critical('Could not query constant value.  The expression '
-                     'should only have numbers, operators, spaces, and '
-                     'parens.  Please check "%s" in %s.\n', constant_name,
-                     file_path)
+    logging.critical(
+        'Could not query constant value.  The expression '
+        'should only have numbers, operators, spaces, and '
+        'parens.  Please check "%s" in %s.\n', constant_name, file_path)
     sys.exit(1)
 
   expression = match.group(1)
diff --git a/src/cobalt/configuration/configuration.cc b/src/cobalt/configuration/configuration.cc
index 9c5087c..a5e9aad 100644
--- a/src/cobalt/configuration/configuration.cc
+++ b/src/cobalt/configuration/configuration.cc
@@ -155,6 +155,13 @@
 #endif
 }
 
+const char* Configuration::CobaltFallbackSplashScreenTopics() {
+  if (configuration_api_ && configuration_api_->version >= 2) {
+    return configuration_api_->CobaltFallbackSplashScreenTopics();
+  }
+  return "";
+}
+
 bool Configuration::CobaltEnableQuic() {
   if (configuration_api_) {
 #if defined(COBALT_ENABLE_QUIC)
diff --git a/src/cobalt/configuration/configuration.h b/src/cobalt/configuration/configuration.h
index 6ea8ba5..6913ea1 100644
--- a/src/cobalt/configuration/configuration.h
+++ b/src/cobalt/configuration/configuration.h
@@ -59,6 +59,7 @@
   bool CobaltGcZeal();
   const char* CobaltRasterizerType();
   bool CobaltEnableJit();
+  const char* CobaltFallbackSplashScreenTopics();
 
  private:
   Configuration();
diff --git a/src/cobalt/doc/splash_screen.md b/src/cobalt/doc/splash_screen.md
index 9122555..fbb6b6d 100644
--- a/src/cobalt/doc/splash_screen.md
+++ b/src/cobalt/doc/splash_screen.md
@@ -49,15 +49,15 @@
      first time.
 
   3. **Build-time fallback splash screen:** If a web cached splash screen is
-     unavailable and command line parameters are not passed by the system, a
-     `gyp_configuration.gypi` fallback splash screen may be used. Porters should
-     set the gypi variable `fallback_splash_screen_url` to the splash screen
-     URL.
+     unavailable and command line parameters are not passed by the system,
+     a CobaltExtensionConfigurationApi fallback splash screen may be used.
+     Porters should set the `CobaltFallbackSplashScreenUrl` value in
+     `configuration.cc` to the splash screen URL.
 
-  4. **Default splash screen:** If no web cached splash screen is
-     available, and command line and `gyp_configuration.gypi` fallbacks are not
-     set, a default splash screen will be used. This is set in `base.gypi` via
-     `fallback_splash_screen_url%` to refer to a black splash screen.
+  4. **Default splash screen:** If no web cached splash screen is available, and
+     command line and CobaltExtensionConfigurationApi fallbacks are not set, a
+     default splash screen will be used. This is set in
+     `configuration_defaults.cc` to refer to a black splash screen.
 
 ## Web-updatability
 
@@ -85,6 +85,40 @@
 Cobalt will also need to read the cached splash screen from the cache directory
 when starting up.
 
+## Topic-specific splash screens
+
+It is possible to specify multiple splash screens for a given Cobalt-based
+application, using a start-up 'topic' to select between the available splash
+screens. This can be useful when an application has multiple entry points that
+require different splash screens. The topic may be specified in the start-up url
+or deeplink as a query parameter. For example,
+`https://www.example.com/path?topic=foo`. If a splash-screen has been specified
+for topic 'foo', it will be used. Otherwise, the topic is ignored. Topic values
+should be URL encoded and limited to alphanumeric characters, hyphens,
+underscores, and percent signs.
+
+There are three ways to specify topic-specific splash screens. These methods mirror
+the types of splash screens listed above, and unless specified, the rules here
+are the same as for non-topic-based splash screens.
+
+  1. **Web cached splash screen:** A custom `rel="<topic>_splashscreen"`
+     attribute on a link element is used to specify a topic-specific splash
+     screen. There can be any number of these elements with different topics, in
+     addition to the topic-neutral `rel="splashscreen"`.
+
+  2. **Command line fallback splash screen:** The command line argument
+     `--fallback_splash_screen_topics` can be used if the cache is unavailable.
+     The argument accepts a list of topic/file parameters. If a file is not a
+     valid URL path, then it will be used as a filename at the path specified by
+     `--fallback_splash_screen_url`. For example,
+     `foo_topic=file:///foo.html&bar=bar.html`.
+
+  3. **Build-time fallback splash screen:** If a web cached splash screen is
+     unavailable and command line parameters are not passed by the system, a
+     CobaltExtensionConfigurationApi fallback splash screen may be used. Porters
+     should set the `CobaltFallbackSplashScreenTopics` value in
+     `configuration.cc` and this value should look like the command line option.
+
 ## Application-specific splash screens
 
 On systems that plan to support multiple Cobalt-based applications, an
@@ -94,9 +128,8 @@
 the Cobalt binary must be handled by the system.
 
 Alternatively, an application developer may use the default black splash screen
-specified in base.gypi whenever a cached splash screen is not available and rely
-on the web application to specify an application-specific cached splash screen
-otherwise.
+whenever a cached splash screen is not available and rely on the web application
+to specify an application-specific cached splash screen otherwise.
 
 ## Provided embedded resource splash screens
 For convenience, we currently provide the following splash screens as embedded
diff --git a/src/cobalt/dom/dom_test.gyp b/src/cobalt/dom/dom_test.gyp
index f0b181f..a2a464e 100644
--- a/src/cobalt/dom/dom_test.gyp
+++ b/src/cobalt/dom/dom_test.gyp
@@ -44,6 +44,7 @@
         'font_cache_test.cc',
         'html_element_factory_test.cc',
         'html_element_test.cc',
+        'html_link_element_test.cc',
         'intersection_observer_test.cc',
         'keyboard_event_test.cc',
         'local_storage_database_test.cc',
diff --git a/src/cobalt/dom/html_link_element.cc b/src/cobalt/dom/html_link_element.cc
index 8244909..b7150de 100644
--- a/src/cobalt/dom/html_link_element.cc
+++ b/src/cobalt/dom/html_link_element.cc
@@ -20,6 +20,7 @@
 #include <vector>
 
 #include "base/bind.h"
+#include "base/strings/string_tokenizer.h"
 #include "base/trace_event/trace_event.h"
 #include "cobalt/cssom/css_parser.h"
 #include "cobalt/cssom/css_style_sheet.h"
@@ -34,10 +35,34 @@
 namespace dom {
 namespace {
 
+bool IsValidRelChar(char const& c) {
+  return (isalnum(c) || c == '_' || c == '\\' || c == '-');
+}
+
+bool IsValidSplashScreenFormat(const std::string& rel) {
+  base::StringTokenizer tokenizer(rel, "_");
+  tokenizer.set_options(base::StringTokenizer::RETURN_DELIMS);
+  bool is_valid_format = true;
+  while (tokenizer.GetNext()) {
+    std::string token = tokenizer.token();
+    if (SbStringCompareAll(token.c_str(), "splashscreen") == 0) {
+      is_valid_format = true;
+    } else {
+      for (char const& c : token) {
+        if (!IsValidRelChar(c)) {
+          return false;
+        }
+      }
+      is_valid_format = false;
+    }
+  }
+  return is_valid_format;
+}
+
 CspDelegate::ResourceType GetCspResourceTypeForRel(const std::string& rel) {
   if (rel == "stylesheet") {
     return CspDelegate::kStyle;
-  } else if (rel == "splashscreen") {
+  } else if (IsValidSplashScreenFormat(rel)) {
     return CspDelegate::kLocation;
   } else {
     NOTIMPLEMENTED();
@@ -71,13 +96,15 @@
 const char HTMLLinkElement::kTagName[] = "link";
 // static
 const std::vector<std::string> HTMLLinkElement::kSupportedRelValues = {
-    "stylesheet", "splashscreen"};
+    "stylesheet"};
 
 void HTMLLinkElement::OnInsertedIntoDocument() {
   HTMLElement::OnInsertedIntoDocument();
   if (std::find(kSupportedRelValues.begin(), kSupportedRelValues.end(),
                 rel()) != kSupportedRelValues.end()) {
     Obtain();
+  } else if (IsValidSplashScreenFormat(rel())) {
+    Obtain();
   } else {
     LOG(WARNING) << "<link> has unsupported rel value: " << rel() << ".";
   }
@@ -202,7 +229,7 @@
   Document* document = node_document();
   if (rel() == "stylesheet") {
     OnStylesheetLoaded(document, *content);
-  } else if (rel() == "splashscreen") {
+  } else if (IsValidSplashScreenFormat(rel())) {
     OnSplashscreenLoaded(document, *content);
   } else {
     NOTIMPLEMENTED();
@@ -257,7 +284,13 @@
 void HTMLLinkElement::OnSplashscreenLoaded(Document* document,
                                            const std::string& content) {
   scoped_refptr<Window> window = document->window();
-  window->CacheSplashScreen(content);
+  std::string link = rel();
+  size_t last_underscore = link.find_last_of("_");
+  base::Optional<std::string> topic;
+  if (last_underscore != std::string::npos) {
+    topic = link.substr(0, last_underscore);
+  }
+  window->CacheSplashScreen(content, topic);
 }
 
 void HTMLLinkElement::OnStylesheetLoaded(Document* document,
diff --git a/src/cobalt/dom/html_link_element.h b/src/cobalt/dom/html_link_element.h
index ba4ee01..e38abea 100644
--- a/src/cobalt/dom/html_link_element.h
+++ b/src/cobalt/dom/html_link_element.h
@@ -67,13 +67,14 @@
 
   DEFINE_WRAPPABLE_TYPE(HTMLLinkElement);
 
- private:
+ protected:
   ~HTMLLinkElement() override {}
 
+ private:
   void ResolveAndSetAbsoluteURL();
 
   // From the spec: HTMLLinkElement.
-  void Obtain();
+  virtual void Obtain();
 
   void OnContentProduced(const loader::Origin& last_url_origin,
                          std::unique_ptr<std::string> content);
diff --git a/src/cobalt/dom/html_link_element_test.cc b/src/cobalt/dom/html_link_element_test.cc
new file mode 100644
index 0000000..380711e
--- /dev/null
+++ b/src/cobalt/dom/html_link_element_test.cc
@@ -0,0 +1,114 @@
+// Copyright 2020 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/html_link_element.h"
+#include "base/message_loop/message_loop.h"
+#include "cobalt/cssom/testing/mock_css_parser.h"
+#include "cobalt/dom/document.h"
+#include "cobalt/dom/dom_stat_tracker.h"
+#include "cobalt/dom/testing/stub_environment_settings.h"
+#include "cobalt/dom/window.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+using ::testing::NiceMock;
+
+namespace cobalt {
+namespace dom {
+
+class HTMLLinkElementMock : public HTMLLinkElement {
+ public:
+  explicit HTMLLinkElementMock(Document* document)
+      : HTMLLinkElement(document) {}
+  void Obtain() { obtained_ = true; }
+  bool obtained_ = false;
+  bool obtained() { return obtained_; }
+};
+
+class DocumentMock : public Document {
+ public:
+  explicit DocumentMock(HTMLElementContext* context) : Document(context) {}
+  scoped_refptr<HTMLLinkElementMock> CreateElement(
+      const std::string& local_name) {
+    return scoped_refptr<HTMLLinkElementMock>(new HTMLLinkElementMock(this));
+  }
+};
+
+class HtmlLinkElementTest : public ::testing::Test {
+ protected:
+  HtmlLinkElementTest()
+      : dom_stat_tracker_(new DomStatTracker("HtmlLinkElementTest")),
+        html_element_context_(&environment_settings_, NULL, NULL, &css_parser_,
+                              NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
+                              NULL, NULL, NULL, NULL, dom_stat_tracker_.get(),
+                              "", base::kApplicationStateStarted, NULL),
+        document_(new DocumentMock(&html_element_context_)),
+        message_loop_(base::MessageLoop::TYPE_DEFAULT) {}
+
+  scoped_refptr<DocumentMock> document() { return document_; }
+  scoped_refptr<HTMLLinkElementMock> CreateDocumentWithLinkElement(
+      std::string rel = "");
+
+ private:
+  std::unique_ptr<DomStatTracker> dom_stat_tracker_;
+  testing::StubEnvironmentSettings environment_settings_;
+  NiceMock<cssom::testing::MockCSSParser> css_parser_;
+  HTMLElementContext html_element_context_;
+  scoped_refptr<DocumentMock> document_;
+  base::MessageLoop message_loop_;
+};
+
+scoped_refptr<HTMLLinkElementMock>
+HtmlLinkElementTest::CreateDocumentWithLinkElement(std::string rel) {
+  scoped_refptr<HTMLLinkElementMock> element_ =
+      document_->CreateElement("link");
+  if (!rel.empty()) {
+    element_->SetAttribute("rel", rel);
+  }
+  document_->AppendChild(element_);
+  return element_;
+}
+
+TEST_F(HtmlLinkElementTest, StylesheetRelAttribute) {
+  scoped_refptr<HTMLLinkElementMock> el =
+      CreateDocumentWithLinkElement("stylesheet");
+  EXPECT_TRUE(el->obtained());
+}
+
+TEST_F(HtmlLinkElementTest, SplashScreenRelAttribute) {
+  scoped_refptr<HTMLLinkElementMock> el =
+      CreateDocumentWithLinkElement("splashscreen");
+  EXPECT_TRUE(el->obtained());
+
+  el = CreateDocumentWithLinkElement("music_splashscreen");
+  EXPECT_TRUE(el->obtained());
+
+  el = CreateDocumentWithLinkElement("music-_\\2_splashscreen");
+  EXPECT_TRUE(el->obtained());
+}
+
+TEST_F(HtmlLinkElementTest, BadSplashScreenRelAttribute) {
+  scoped_refptr<HTMLLinkElementMock> el =
+      CreateDocumentWithLinkElement("bad*_splashscreen");
+  EXPECT_FALSE(el->obtained());
+
+  el = CreateDocumentWithLinkElement("badsplashscreen");
+  EXPECT_FALSE(el->obtained());
+
+  el = CreateDocumentWithLinkElement("splashscreen_bad");
+  EXPECT_FALSE(el->obtained());
+}
+
+}  // namespace dom
+}  // namespace cobalt
diff --git a/src/cobalt/dom/window.cc b/src/cobalt/dom/window.cc
index eac877d..989d187 100644
--- a/src/cobalt/dom/window.cc
+++ b/src/cobalt/dom/window.cc
@@ -702,12 +702,13 @@
   tracer->Trace(on_screen_keyboard_);
 }
 
-void Window::CacheSplashScreen(const std::string& content) {
+void Window::CacheSplashScreen(const std::string& content,
+                               const base::Optional<std::string>& topic) {
   if (splash_screen_cache_callback_.is_null()) {
     return;
   }
   DLOG(INFO) << "Caching splash screen for URL " << location()->url();
-  splash_screen_cache_callback_.Run(location()->url(), content);
+  splash_screen_cache_callback_.Run(content, topic);
 }
 
 const scoped_refptr<OnScreenKeyboard>& Window::on_screen_keyboard() const {
diff --git a/src/cobalt/dom/window.h b/src/cobalt/dom/window.h
index 6fbfc81..e7320b4 100644
--- a/src/cobalt/dom/window.h
+++ b/src/cobalt/dom/window.h
@@ -122,7 +122,9 @@
   // close() was called.
   typedef base::Callback<void(base::TimeDelta)> CloseCallback;
   typedef UrlRegistry<MediaSource> MediaSourceRegistry;
-  typedef base::Callback<bool(const GURL&, const std::string&)> CacheCallback;
+  typedef base::Callback<void(const std::string&,
+                              const base::Optional<std::string>&)>
+      CacheCallback;
 
   enum ClockType {
     kClockTypeTestRunner,
@@ -379,7 +381,8 @@
   void OnDocumentRootElementUnableToProvideOffsetDimensions();
 
   // Cache the passed in splash screen content for the window.location URL.
-  void CacheSplashScreen(const std::string& content);
+  void CacheSplashScreen(const std::string& content,
+                         const base::Optional<std::string>& topic);
 
   const scoped_refptr<loader::CORSPreflightCache> get_preflight_cache() {
     return preflight_cache_;
diff --git a/src/cobalt/extension/configuration.h b/src/cobalt/extension/configuration.h
index 9d379c7..7c12817 100644
--- a/src/cobalt/extension/configuration.h
+++ b/src/cobalt/extension/configuration.h
@@ -219,6 +219,11 @@
   // See "cobalt/doc/performance_tuning.md" for more information on when this
   // should be used.
   bool (*CobaltEnableJit)();
+
+  // The fields below this point were added in version 2 or later.
+
+  // A mapping of splash screen topics to fallback URLs.
+  const char* (*CobaltFallbackSplashScreenTopics)();
 } CobaltExtensionConfigurationApi;
 
 #ifdef __cplusplus
diff --git a/src/cobalt/extension/extension_test.cc b/src/cobalt/extension/extension_test.cc
index 3756cba..9f4caf0 100644
--- a/src/cobalt/extension/extension_test.cc
+++ b/src/cobalt/extension/extension_test.cc
@@ -29,23 +29,22 @@
   typedef CobaltExtensionPlatformServiceApi ExtensionApi;
   const char* kExtensionName = kCobaltExtensionPlatformServiceName;
 
-  const ExtensionApi* extension_api = static_cast<const ExtensionApi*>(
-      SbSystemGetExtension(kExtensionName));
+  const ExtensionApi* extension_api =
+      static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
   if (!extension_api) {
     return;
   }
 
   EXPECT_STREQ(extension_api->name, kExtensionName);
-  EXPECT_TRUE(extension_api->version == 1 ||
-              extension_api->version == 2 ||
-              extension_api->version == 3) << "Invalid version";
-  EXPECT_TRUE(extension_api->Has != NULL);
-  EXPECT_TRUE(extension_api->Open != NULL);
-  EXPECT_TRUE(extension_api->Close != NULL);
-  EXPECT_TRUE(extension_api->Send != NULL);
+  EXPECT_GE(extension_api->version, 1u);
+  EXPECT_LE(extension_api->version, 3u);
+  EXPECT_NE(extension_api->Has, nullptr);
+  EXPECT_NE(extension_api->Open, nullptr);
+  EXPECT_NE(extension_api->Close, nullptr);
+  EXPECT_NE(extension_api->Send, nullptr);
 
-  const ExtensionApi* second_extension_api = static_cast<const ExtensionApi*>(
-      SbSystemGetExtension(kExtensionName));
+  const ExtensionApi* second_extension_api =
+      static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
   EXPECT_EQ(second_extension_api, extension_api)
       << "Extension struct should be a singleton";
 }
@@ -54,35 +53,50 @@
   typedef CobaltExtensionGraphicsApi ExtensionApi;
   const char* kExtensionName = kCobaltExtensionGraphicsName;
 
-  const ExtensionApi* extension_api = static_cast<const ExtensionApi*>(
-      SbSystemGetExtension(kExtensionName));
+  const ExtensionApi* extension_api =
+      static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
   if (!extension_api) {
     return;
   }
 
   EXPECT_STREQ(extension_api->name, kExtensionName);
-  EXPECT_TRUE(extension_api->version == 1 ||
-              extension_api->version == 2 ||
-              extension_api->version == 3) << "Invalid version";
-  EXPECT_TRUE(extension_api->GetMaximumFrameIntervalInMilliseconds != NULL);
-  if (extension_api->version >= 2) {
-    EXPECT_TRUE(extension_api->GetMinimumFrameIntervalInMilliseconds != NULL);
-  }
-  if (extension_api->version >= 3) {
-    EXPECT_TRUE(extension_api->IsMapToMeshEnabled != NULL);
-  }
+  EXPECT_GE(extension_api->version, 1u);
+  EXPECT_LE(extension_api->version, 4u);
 
+  EXPECT_NE(extension_api->GetMaximumFrameIntervalInMilliseconds, nullptr);
   float maximum_frame_interval =
       extension_api->GetMaximumFrameIntervalInMilliseconds();
   EXPECT_FALSE(std::isnan(maximum_frame_interval));
 
   if (extension_api->version >= 2) {
+    EXPECT_NE(extension_api->GetMinimumFrameIntervalInMilliseconds, nullptr);
     float minimum_frame_interval =
-      extension_api->GetMinimumFrameIntervalInMilliseconds();
+        extension_api->GetMinimumFrameIntervalInMilliseconds();
     EXPECT_GT(minimum_frame_interval, 0);
   }
-  const ExtensionApi* second_extension_api = static_cast<const ExtensionApi*>(
-      SbSystemGetExtension(kExtensionName));
+
+  if (extension_api->version >= 3) {
+    EXPECT_NE(extension_api->IsMapToMeshEnabled, nullptr);
+  }
+
+  if (extension_api->version >= 4) {
+    EXPECT_NE(extension_api->ShouldClearFrameOnShutdown, nullptr);
+    float clear_color_r, clear_color_g, clear_color_b, clear_color_a;
+    if (extension_api->ShouldClearFrameOnShutdown(
+            &clear_color_r, &clear_color_g, &clear_color_b, &clear_color_a)) {
+      EXPECT_GE(clear_color_r, 0.0f);
+      EXPECT_LE(clear_color_r, 1.0f);
+      EXPECT_GE(clear_color_g, 0.0f);
+      EXPECT_LE(clear_color_g, 1.0f);
+      EXPECT_GE(clear_color_b, 0.0f);
+      EXPECT_LE(clear_color_b, 1.0f);
+      EXPECT_GE(clear_color_a, 0.0f);
+      EXPECT_LE(clear_color_a, 1.0f);
+    }
+  }
+
+  const ExtensionApi* second_extension_api =
+      static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
   EXPECT_EQ(second_extension_api, extension_api)
       << "Extension struct should be a singleton";
 }
@@ -98,18 +112,17 @@
   }
 
   EXPECT_STREQ(extension_api->name, kExtensionName);
-  EXPECT_TRUE(extension_api->version == 1 ||
-              extension_api->version == 2 ||
-              extension_api->version == 3) << "Invalid version";
-  EXPECT_TRUE(extension_api->GetCurrentInstallationIndex != NULL);
-  EXPECT_TRUE(extension_api->MarkInstallationSuccessful != NULL);
-  EXPECT_TRUE(extension_api->RequestRollForwardToInstallation != NULL);
-  EXPECT_TRUE(extension_api->GetInstallationPath != NULL);
-  EXPECT_TRUE(extension_api->SelectNewInstallationIndex != NULL);
-  EXPECT_TRUE(extension_api->GetAppKey != NULL);
-  EXPECT_TRUE(extension_api->GetMaxNumberInstallations != NULL);
-  EXPECT_TRUE(extension_api->ResetInstallation != NULL);
-  EXPECT_TRUE(extension_api->Reset != NULL);
+  EXPECT_GE(extension_api->version, 1u);
+  EXPECT_LE(extension_api->version, 3u);
+  EXPECT_NE(extension_api->GetCurrentInstallationIndex, nullptr);
+  EXPECT_NE(extension_api->MarkInstallationSuccessful, nullptr);
+  EXPECT_NE(extension_api->RequestRollForwardToInstallation, nullptr);
+  EXPECT_NE(extension_api->GetInstallationPath, nullptr);
+  EXPECT_NE(extension_api->SelectNewInstallationIndex, nullptr);
+  EXPECT_NE(extension_api->GetAppKey, nullptr);
+  EXPECT_NE(extension_api->GetMaxNumberInstallations, nullptr);
+  EXPECT_NE(extension_api->ResetInstallation, nullptr);
+  EXPECT_NE(extension_api->Reset, nullptr);
   const ExtensionApi* second_extension_api =
       static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
   EXPECT_EQ(second_extension_api, extension_api)
@@ -127,27 +140,32 @@
   }
 
   EXPECT_STREQ(extension_api->name, kExtensionName);
-  EXPECT_TRUE(extension_api->version == 1);
-  EXPECT_TRUE(extension_api->CobaltUserOnExitStrategy != NULL);
-  EXPECT_TRUE(extension_api->CobaltRenderDirtyRegionOnly != NULL);
-  EXPECT_TRUE(extension_api->CobaltEglSwapInterval != NULL);
-  EXPECT_TRUE(extension_api->CobaltFallbackSplashScreenUrl != NULL);
-  EXPECT_TRUE(extension_api->CobaltEnableQuic != NULL);
-  EXPECT_TRUE(extension_api->CobaltSkiaCacheSizeInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltOffscreenTargetCacheSizeInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltEncodedImageCacheSizeInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltImageCacheSizeInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltLocalTypefaceCacheSizeInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltRemoteTypefaceCacheSizeInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltMeshCacheSizeInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltSoftwareSurfaceCacheSizeInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltImageCacheCapacityMultiplierWhenPlayingVideo != NULL);
-  EXPECT_TRUE(extension_api->CobaltSkiaGlyphAtlasWidth != NULL);
-  EXPECT_TRUE(extension_api->CobaltSkiaGlyphAtlasHeight != NULL);
-  EXPECT_TRUE(extension_api->CobaltJsGarbageCollectionThresholdInBytes != NULL);
-  EXPECT_TRUE(extension_api->CobaltReduceCpuMemoryBy != NULL);
-  EXPECT_TRUE(extension_api->CobaltReduceGpuMemoryBy != NULL);
-  EXPECT_TRUE(extension_api->CobaltGcZeal != NULL);
+  EXPECT_GE(extension_api->version, 1u);
+  EXPECT_LE(extension_api->version, 2u);
+  EXPECT_NE(extension_api->CobaltUserOnExitStrategy, nullptr);
+  EXPECT_NE(extension_api->CobaltRenderDirtyRegionOnly, nullptr);
+  EXPECT_NE(extension_api->CobaltEglSwapInterval, nullptr);
+  EXPECT_NE(extension_api->CobaltFallbackSplashScreenUrl, nullptr);
+  EXPECT_NE(extension_api->CobaltEnableQuic, nullptr);
+  EXPECT_NE(extension_api->CobaltSkiaCacheSizeInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltOffscreenTargetCacheSizeInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltEncodedImageCacheSizeInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltImageCacheSizeInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltLocalTypefaceCacheSizeInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltRemoteTypefaceCacheSizeInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltMeshCacheSizeInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltSoftwareSurfaceCacheSizeInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltImageCacheCapacityMultiplierWhenPlayingVideo,
+            nullptr);
+  EXPECT_NE(extension_api->CobaltSkiaGlyphAtlasWidth, nullptr);
+  EXPECT_NE(extension_api->CobaltSkiaGlyphAtlasHeight, nullptr);
+  EXPECT_NE(extension_api->CobaltJsGarbageCollectionThresholdInBytes, nullptr);
+  EXPECT_NE(extension_api->CobaltReduceCpuMemoryBy, nullptr);
+  EXPECT_NE(extension_api->CobaltReduceGpuMemoryBy, nullptr);
+  EXPECT_NE(extension_api->CobaltGcZeal, nullptr);
+  if (extension_api->version >= 2) {
+    EXPECT_NE(extension_api->CobaltFallbackSplashScreenTopics, nullptr);
+  }
 
   const ExtensionApi* second_extension_api =
       static_cast<const ExtensionApi*>(SbSystemGetExtension(kExtensionName));
diff --git a/src/cobalt/extension/graphics.h b/src/cobalt/extension/graphics.h
index 9c993c5..a1a3b4e 100644
--- a/src/cobalt/extension/graphics.h
+++ b/src/cobalt/extension/graphics.h
@@ -23,8 +23,7 @@
 extern "C" {
 #endif
 
-#define kCobaltExtensionGraphicsName \
-  "dev.cobalt.extension.Graphics"
+#define kCobaltExtensionGraphicsName "dev.cobalt.extension.Graphics"
 
 typedef struct CobaltExtensionGraphicsApi {
   // Name should be the string kCobaltExtensionGraphicsName.
@@ -62,6 +61,20 @@
 
   // Get whether the renderer should support 360 degree video or not.
   bool (*IsMapToMeshEnabled)();
+
+  // The fields below this point were added in version 4 or later.
+
+  // Specify whether the framebuffer should be cleared when the graphics
+  // system is shutdown and color to use for clearing. The graphics system
+  // is shutdown on suspend or exit. The clear color values should be in the
+  // range of [0,1]; color values are only used if this function returns true.
+  //
+  // The default behavior is to clear to opaque black on shutdown unless this
+  // API specifies otherwise.
+  bool (*ShouldClearFrameOnShutdown)(float* clear_color_red,
+                                     float* clear_color_green,
+                                     float* clear_color_blue,
+                                     float* clear_color_alpha);
 } CobaltExtensionGraphicsApi;
 
 #ifdef __cplusplus
diff --git a/src/cobalt/layout/box_generator.cc b/src/cobalt/layout/box_generator.cc
index c622e99..2bc8571 100644
--- a/src/cobalt/layout/box_generator.cc
+++ b/src/cobalt/layout/box_generator.cc
@@ -1057,12 +1057,17 @@
   container_box_before_split->SetUiNavItem(html_element->GetUiNavItem());
   boxes_.push_back(container_box_before_split);
 
-  BoxIntersectionObserverModule::IntersectionObserverRootVector roots =
-      html_element->GetLayoutIntersectionObserverRoots();
-  BoxIntersectionObserverModule::IntersectionObserverTargetVector targets =
-      html_element->GetLayoutIntersectionObserverTargets();
-  container_box_before_split->AddIntersectionObserverRootsAndTargets(
-      std::move(roots), std::move(targets));
+  // We already handle the case where the Intersection Observer root is the
+  // viewport with the initial containing block in layout.
+  if (html_element !=
+      html_element->node_document()->document_element()->AsHTMLElement()) {
+    BoxIntersectionObserverModule::IntersectionObserverRootVector roots =
+        html_element->GetLayoutIntersectionObserverRoots();
+    BoxIntersectionObserverModule::IntersectionObserverTargetVector targets =
+        html_element->GetLayoutIntersectionObserverTargets();
+    container_box_before_split->AddIntersectionObserverRootsAndTargets(
+        std::move(roots), std::move(targets));
+  }
 
   AppendPseudoElementToLine(html_element, dom::kBeforePseudoElementType);
 
diff --git a/src/cobalt/layout/intersection_observer_target.cc b/src/cobalt/layout/intersection_observer_target.cc
index 26d863d..e114025 100644
--- a/src/cobalt/layout/intersection_observer_target.cc
+++ b/src/cobalt/layout/intersection_observer_target.cc
@@ -27,108 +27,22 @@
 
 namespace cobalt {
 namespace layout {
+namespace {
 
-void IntersectionObserverTarget::UpdateIntersectionObservationsForTarget(
-    ContainerBox* target_box) {
-  TRACE_EVENT0(
-      "cobalt::layout",
-      "IntersectionObserverTarget::UpdateIntersectionObservationsForTarget()");
-  // Walk up the containing block chain looking for the box referencing the
-  // IntersectionObserverRoot corresponding to this IntersectionObserverTarget.
-  // Skip further processing for the target if it is not a descendant of the
-  // root in the containing block chain.
-  const ContainerBox* root_box = target_box->GetContainingBlock();
-  while (!root_box->ContainsIntersectionObserverRoot(
-      intersection_observer_root_)) {
-    if (!root_box->parent()) {
-      return;
-    }
-    root_box = root_box->GetContainingBlock();
-  }
-
-  // Let targetRect be target's bounding border box.
-  RectLayoutUnit target_transformed_border_box(
-      target_box->GetTransformedBoxFromRoot(
-          target_box->GetBorderBoxFromMarginBox()));
-  math::RectF target_rect =
-      math::RectF(target_transformed_border_box.x().toFloat(),
-                  target_transformed_border_box.y().toFloat(),
-                  target_transformed_border_box.width().toFloat(),
-                  target_transformed_border_box.height().toFloat());
-
-  // Let intersectionRect be the result of running the compute the intersection
-  // algorithm on target.
-  math::RectF root_bounds = GetRootBounds(
-      root_box, intersection_observer_root_->root_margin_property_value());
-  math::RectF intersection_rect = ComputeIntersectionBetweenTargetAndRoot(
-      root_box, root_bounds, target_rect, target_box);
-
-  // Let targetArea be targetRect's area.
-  float target_area = target_rect.size().GetArea();
-
-  // Let intersectionArea be intersectionRect's area.
-  float intersection_area = intersection_rect.size().GetArea();
-
-  // Let isIntersecting be true if targetRect and rootBounds intersect or are
-  // edge-adjacent, even if the intersection has zero area (because rootBounds
-  // or targetRect have zero area); otherwise, let isIntersecting be false.
-  bool is_intersecting =
-      intersection_rect.width() != 0 || intersection_rect.height() != 0;
-
-  // If targetArea is non-zero, let intersectionRatio be intersectionArea
-  // divided by targetArea. Otherwise, let intersectionRatio be 1 if
-  // isIntersecting is true, or 0 if isIntersecting is false.
-  float intersection_ratio = target_area > 0 ? intersection_area / target_area
-                                             : is_intersecting ? 1.0f : 0.0f;
-
-  // Let thresholdIndex be the index of the first entry in observer.thresholds
-  // whose value is greater than intersectionRatio, or the length of
-  // observer.thresholds if intersectionRatio is greater than or equal to the
-  // last entry in observer.thresholds.
-  const std::vector<double>& thresholds =
-      intersection_observer_root_->thresholds_vector();
-  size_t threshold_index;
-  for (threshold_index = 0; threshold_index < thresholds.size();
-       ++threshold_index) {
-    if (thresholds.at(threshold_index) > intersection_ratio) {
-      // isIntersecting is false if intersectionRatio is less than all
-      // thresholds, sorted ascending. Not in spec but follows Chrome behavior.
-      if (threshold_index == 0) {
-        is_intersecting = false;
-      }
-      break;
-    }
-  }
-
-  // If thresholdIndex does not equal previousThresholdIndex or if
-  // isIntersecting does not equal previousIsIntersecting, queue an
-  // IntersectionObserverEntry, passing in observer, time, rootBounds,
-  //         boundingClientRect, intersectionRect, isIntersecting, and target.
-  if (static_cast<int32>(threshold_index) != previous_threshold_index_ ||
-      is_intersecting != previous_is_intersecting_) {
-    on_intersection_callback_.Run(root_bounds, target_rect, intersection_rect,
-                                  is_intersecting, intersection_ratio);
-  }
-
-  // Update the previousThresholdIndex and previousIsIntersecting properties.
-  previous_threshold_index_ = static_cast<int32>(threshold_index);
-  previous_is_intersecting_ = is_intersecting;
+int32 GetUsedLengthOfRootMarginPropertyValue(
+    const scoped_refptr<cssom::PropertyValue>& length_property_value,
+    LayoutUnit percentage_base) {
+  UsedLengthValueProvider used_length_provider(percentage_base);
+  length_property_value->Accept(&used_length_provider);
+  // Not explicitly stated in web spec, but has been observed that Chrome
+  // truncates root margin decimal values.
+  return static_cast<int32>(
+      used_length_provider.used_length().value_or(LayoutUnit(0.0f)).toFloat());
 }
 
-bool IntersectionObserverTarget::IsInContainingBlockChain(
-    const ContainerBox* potential_containing_block,
-    const ContainerBox* target_box) {
-  const ContainerBox* containing_block = target_box->GetContainingBlock();
-  while (containing_block != potential_containing_block) {
-    if (!containing_block->parent()) {
-      return false;
-    }
-    containing_block = containing_block->GetContainingBlock();
-  }
-  return true;
-}
-
-math::RectF IntersectionObserverTarget::GetRootBounds(
+// Rules for determining the root intersection rectangle bounds.
+// https://www.w3.org/TR/intersection-observer/#intersectionobserver-root-intersection-rectangle
+math::RectF GetRootBounds(
     const ContainerBox* root_box,
     scoped_refptr<cssom::PropertyListValue> root_margin_property_value) {
   math::RectF root_bounds_without_margins;
@@ -175,18 +89,27 @@
   return root_bounds;
 }
 
-int32 IntersectionObserverTarget::GetUsedLengthOfRootMarginPropertyValue(
-    const scoped_refptr<cssom::PropertyValue>& length_property_value,
-    LayoutUnit percentage_base) {
-  UsedLengthValueProvider used_length_provider(percentage_base);
-  length_property_value->Accept(&used_length_provider);
-  // Not explicitly stated in web spec, but has been observed that Chrome
-  // truncates root margin decimal values.
-  return static_cast<int32>(
-      used_length_provider.used_length().value_or(LayoutUnit(0.0f)).toFloat());
+// Similar to the IntersectRects function in math::RectF, but handles edge
+// adjacent intersections as valid intersections (instead of returning a
+// rectangle with zero dimensions)
+math::RectF IntersectIntersectionObserverRects(const math::RectF& a,
+                                               const math::RectF& b) {
+  float rx = std::max(a.x(), b.x());
+  float ry = std::max(a.y(), b.y());
+  float rr = std::min(a.right(), b.right());
+  float rb = std::min(a.bottom(), b.bottom());
+
+  if (rx > rr || ry > rb) {
+    return math::RectF(0.0f, 0.0f, 0.0f, 0.0f);
+  }
+
+  return math::RectF(rx, ry, rr - rx, rb - ry);
 }
 
-math::RectF IntersectionObserverTarget::ComputeIntersectionBetweenTargetAndRoot(
+// Compute the intersection between a target and the observer's intersection
+// root.
+// https://www.w3.org/TR/intersection-observer/#calculate-intersection-rect-algo
+math::RectF ComputeIntersectionBetweenTargetAndRoot(
     const ContainerBox* root_box, const math::RectF& root_bounds,
     const math::RectF& target_rect, const ContainerBox* target_box) {
   // Let intersectionRect be target's bounding border box.
@@ -280,18 +203,95 @@
   return intersection_rect;
 }
 
-math::RectF IntersectionObserverTarget::IntersectIntersectionObserverRects(
-    const math::RectF& a, const math::RectF& b) {
-  float rx = std::max(a.x(), b.x());
-  float ry = std::max(a.y(), b.y());
-  float rr = std::min(a.right(), b.right());
-  float rb = std::min(a.bottom(), b.bottom());
+}  // namespace
 
-  if (rx > rr || ry > rb) {
-    return math::RectF(0.0f, 0.0f, 0.0f, 0.0f);
+void IntersectionObserverTarget::UpdateIntersectionObservationsForTarget(
+    ContainerBox* target_box) {
+  TRACE_EVENT0(
+      "cobalt::layout",
+      "IntersectionObserverTarget::UpdateIntersectionObservationsForTarget()");
+  // Walk up the containing block chain looking for the box referencing the
+  // IntersectionObserverRoot corresponding to this IntersectionObserverTarget.
+  // Skip further processing for the target if it is not a descendant of the
+  // root in the containing block chain.
+  const ContainerBox* root_box = target_box->GetContainingBlock();
+  while (!root_box->ContainsIntersectionObserverRoot(
+      intersection_observer_root_)) {
+    if (!root_box->parent()) {
+      return;
+    }
+    root_box = root_box->GetContainingBlock();
   }
 
-  return math::RectF(rx, ry, rr - rx, rb - ry);
+  // Let targetRect be target's bounding border box.
+  RectLayoutUnit target_transformed_border_box(
+      target_box->GetTransformedBoxFromRoot(
+          target_box->GetBorderBoxFromMarginBox()));
+  const math::RectF target_rect =
+      math::RectF(target_transformed_border_box.x().toFloat(),
+                  target_transformed_border_box.y().toFloat(),
+                  target_transformed_border_box.width().toFloat(),
+                  target_transformed_border_box.height().toFloat());
+
+  // Let intersectionRect be the result of running the compute the intersection
+  // algorithm on target.
+  const math::RectF root_bounds = GetRootBounds(
+      root_box, intersection_observer_root_->root_margin_property_value());
+  const math::RectF intersection_rect = ComputeIntersectionBetweenTargetAndRoot(
+      root_box, root_bounds, target_rect, target_box);
+
+  // Let targetArea be targetRect's area.
+  float target_area = target_rect.size().GetArea();
+
+  // Let intersectionArea be intersectionRect's area.
+  float intersection_area = intersection_rect.size().GetArea();
+
+  // Let isIntersecting be true if targetRect and rootBounds intersect or are
+  // edge-adjacent, even if the intersection has zero area (because rootBounds
+  // or targetRect have zero area); otherwise, let isIntersecting be false.
+  bool is_intersecting =
+      intersection_rect.width() != 0 || intersection_rect.height() != 0 ||
+      (target_rect.width() == 0 && target_rect.height() == 0 &&
+       root_bounds.Contains(target_rect));
+
+  // If targetArea is non-zero, let intersectionRatio be intersectionArea
+  // divided by targetArea. Otherwise, let intersectionRatio be 1 if
+  // isIntersecting is true, or 0 if isIntersecting is false.
+  float intersection_ratio = target_area > 0 ? intersection_area / target_area
+                                             : is_intersecting ? 1.0f : 0.0f;
+
+  // Let thresholdIndex be the index of the first entry in observer.thresholds
+  // whose value is greater than intersectionRatio, or the length of
+  // observer.thresholds if intersectionRatio is greater than or equal to the
+  // last entry in observer.thresholds.
+  const std::vector<double>& thresholds =
+      intersection_observer_root_->thresholds_vector();
+  size_t threshold_index;
+  for (threshold_index = 0; threshold_index < thresholds.size();
+       ++threshold_index) {
+    if (thresholds.at(threshold_index) > intersection_ratio) {
+      // isIntersecting is false if intersectionRatio is less than all
+      // thresholds, sorted ascending. Not in spec but follows Chrome behavior.
+      if (threshold_index == 0) {
+        is_intersecting = false;
+      }
+      break;
+    }
+  }
+
+  // If thresholdIndex does not equal previousThresholdIndex or if
+  // isIntersecting does not equal previousIsIntersecting, queue an
+  // IntersectionObserverEntry, passing in observer, time, rootBounds,
+  //         boundingClientRect, intersectionRect, isIntersecting, and target.
+  if (static_cast<int32>(threshold_index) != previous_threshold_index_ ||
+      is_intersecting != previous_is_intersecting_) {
+    on_intersection_callback_.Run(root_bounds, target_rect, intersection_rect,
+                                  is_intersecting, intersection_ratio);
+  }
+
+  // Update the previousThresholdIndex and previousIsIntersecting properties.
+  previous_threshold_index_ = static_cast<int32>(threshold_index);
+  previous_is_intersecting_ = is_intersecting;
 }
 
 }  // namespace layout
diff --git a/src/cobalt/layout/intersection_observer_target.h b/src/cobalt/layout/intersection_observer_target.h
index a40d41d..23a8671 100644
--- a/src/cobalt/layout/intersection_observer_target.h
+++ b/src/cobalt/layout/intersection_observer_target.h
@@ -75,34 +75,6 @@
   }
 
  private:
-  // Walk up the containing block chain, as described in
-  // http://www.w3.org/TR/CSS2/visudet.html#containing-block-details
-  bool IsInContainingBlockChain(const ContainerBox* potential_containing_block,
-                                const ContainerBox* target_box);
-
-  int32 GetUsedLengthOfRootMarginPropertyValue(
-      const scoped_refptr<cssom::PropertyValue>& length_property_value,
-      LayoutUnit percentage_base);
-
-  // Rules for determining the root intersection rectangle bounds.
-  // https://www.w3.org/TR/intersection-observer/#intersectionobserver-root-intersection-rectangle
-  math::RectF GetRootBounds(
-      const ContainerBox* root_box,
-      scoped_refptr<cssom::PropertyListValue> root_margin_property_value);
-
-  // Compute the intersection between a target and the observer's intersection
-  // root.
-  // https://www.w3.org/TR/intersection-observer/#calculate-intersection-rect-algo
-  math::RectF ComputeIntersectionBetweenTargetAndRoot(
-      const ContainerBox* root_box, const math::RectF& root_bounds,
-      const math::RectF& target_rect, const ContainerBox* target_box);
-
-  // Similar to the IntersectRects function in math::RectF, but handles edge
-  // adjacent intersections as valid intersections (instead of returning a
-  // rectangle with zero dimensions)
-  math::RectF IntersectIntersectionObserverRects(const math::RectF& a,
-                                                 const math::RectF& b);
-
   OnIntersectionCallback on_intersection_callback_;
 
   scoped_refptr<IntersectionObserverRoot> intersection_observer_root_;
diff --git a/src/cobalt/layout/topmost_event_target.cc b/src/cobalt/layout/topmost_event_target.cc
index df2cd6a..8801fef 100644
--- a/src/cobalt/layout/topmost_event_target.cc
+++ b/src/cobalt/layout/topmost_event_target.cc
@@ -241,9 +241,11 @@
         for (scoped_refptr<dom::Element> element = target_element;
              element != nearest_common_ancestor;
              element = element->parent_element()) {
-          element->DispatchEvent(new dom::PointerEvent(
-              base::Tokens::pointerenter(), dom::Event::kNotBubbles,
-              dom::Event::kNotCancelable, view, *event_init));
+          if (element) {
+            element->DispatchEvent(new dom::PointerEvent(
+                base::Tokens::pointerenter(), dom::Event::kNotBubbles,
+                dom::Event::kNotCancelable, view, *event_init));
+          }
         }
       }
 
@@ -254,9 +256,11 @@
       for (scoped_refptr<dom::Element> element = target_element;
            element != nearest_common_ancestor;
            element = element->parent_element()) {
-        element->DispatchEvent(new dom::MouseEvent(
-            base::Tokens::mouseenter(), dom::Event::kNotBubbles,
-            dom::Event::kNotCancelable, view, *event_init));
+        if (element) {
+          element->DispatchEvent(new dom::MouseEvent(
+              base::Tokens::mouseenter(), dom::Event::kNotBubbles,
+              dom::Event::kNotCancelable, view, *event_init));
+        }
       }
     }
   }
diff --git a/src/cobalt/layout_tests/testdata/web-platform-tests/cobalt_special/web_platform_tests.txt b/src/cobalt/layout_tests/testdata/web-platform-tests/cobalt_special/web_platform_tests.txt
index 25ffd6c..d6e13da 100644
--- a/src/cobalt/layout_tests/testdata/web-platform-tests/cobalt_special/web_platform_tests.txt
+++ b/src/cobalt/layout_tests/testdata/web-platform-tests/cobalt_special/web_platform_tests.txt
@@ -1,4 +1,5 @@
 # Cobalt's special tests that borrows WPT infrastructures.
 
 origin-clean.htm,PASS
-preflight-cache-2.htm,PASS
\ No newline at end of file
+preflight-cache-2.htm,PASS
+xhr_content_length.htm,PASS
diff --git a/src/cobalt/layout_tests/testdata/web-platform-tests/intersection-observer/web_platform_tests.txt b/src/cobalt/layout_tests/testdata/web-platform-tests/intersection-observer/web_platform_tests.txt
index b830268..e543994 100644
--- a/src/cobalt/layout_tests/testdata/web-platform-tests/intersection-observer/web_platform_tests.txt
+++ b/src/cobalt/layout_tests/testdata/web-platform-tests/intersection-observer/web_platform_tests.txt
@@ -7,33 +7,33 @@
 # Empty rootMargin should evaluate to default, not cause error
 empty-root-margin.html,DISABLE
 initial-observation-with-threshold.html,PASS
+# Unsupported functions measuring space width between adjacent inline elements
+inline-client-rect.html,DISABLE
 inline-with-block-child-client-rect.html,PASS
 isIntersecting-change-events.html,PASS
+# overflow: scroll results in incorrectly clipped intersection rect
+isIntersecting-threshold.html,DISABLE
+multiple-targets.html,PASS
+multiple-thresholds.html,PASS
 # rootMargin default should be "0px 0px 0px 0px", not "0px"
 observer-attributes.html,DISABLE
 # WPT testharness needs to be rebased
 observer-exceptions.html,DISABLE
+observer-without-js-reference.html,PASS
 #Deleting an element does not trigger an intersection
 remove-element.html,DISABLE
 root-margin-root-element.html,PASS
+# Root margin calculations have rounding errors
+root-margin.html,DISABLE
 # Setting IO target equal to document.documentElement crashes Cobalt
 root-margin-rounding.html,DISABLE
 rtl-clipped-root.html,PASS
+same-document-no-root.html,PASS
 same-document-root.html,PASS
+same-document-zero-size-target.html,PASS
+text-target.html,PASS
 zero-area-element-hidden.html,PASS
-#Zero-area target does not trigger an intersection
-zero-area-element-visible.html,DISABLE
-
-#No root specified - intersections with viewport incorrectly reported
-inline-client-rect.html,DISABLE
-isIntersecting-threshold.html,DISABLE
-multiple-targets.html,DISABLE
-multiple-thresholds.html,DISABLE
-observer-without-js-reference.html,DISABLE
-root-margin.html,DISABLE
-same-document-no-root.html,DISABLE
-same-document-zero-size-target.html,DISABLE
-text-target.html,DISABLE
+zero-area-element-visible.html,PASS
 
 #IntersectionObserverV2 not implemented
 v2/blur-filter.html,DISABLE
diff --git a/src/cobalt/media/base/sbplayer_pipeline.cc b/src/cobalt/media/base/sbplayer_pipeline.cc
index 4f4f9d1..8185f82 100644
--- a/src/cobalt/media/base/sbplayer_pipeline.cc
+++ b/src/cobalt/media/base/sbplayer_pipeline.cc
@@ -277,8 +277,13 @@
 
   VideoFrameProvider* video_frame_provider_;
 
+  // Read audio from the stream if |timestamp_of_last_written_audio_| is less
+  // than |seek_time_| + |kAudioPrerollLimit|, this effectively allows 10
+  // seconds of audio to be written to the SbPlayer after playback startup or
+  // seek.
+  static const SbTime kAudioPrerollLimit = 10 * kSbTimeSecond;
   // Don't read audio from the stream more than |kAudioLimit| ahead of the
-  // current media time.
+  // current media time during playing.
   static const SbTime kAudioLimit = kSbTimeSecond;
   // Only call GetMediaTime() from OnNeedData if it has been
   // |kMediaTimeCheckInterval| since the last call to GetMediaTime().
@@ -1117,22 +1122,28 @@
         kMediaTimeCheckInterval) {
       GetMediaTime();
     }
-    // The estimated time ahead of playback may be negative if no audio has been
-    // written.
-    SbTime time_ahead_of_playback =
-        timestamp_of_last_written_audio_ - last_media_time_;
-    // Delay reading audio more than |kAudioLimit| ahead of playback, taking
-    // into account that our estimate of playback time might be behind by
+
+    // Delay reading audio more than |kAudioLimit| ahead of playback after the
+    // player has received enough audio for preroll, taking into account that
+    // our estimate of playback time might be behind by
     // |kMediaTimeCheckInterval|.
-    if (time_ahead_of_playback > (kAudioLimit + kMediaTimeCheckInterval)) {
-      SbTime delay_time = (time_ahead_of_playback - kAudioLimit) /
-                          std::max(playback_rate_, 1.0f);
-      task_runner_->PostDelayedTask(
-          FROM_HERE, base::Bind(&SbPlayerPipeline::DelayedNeedData, this),
-          base::TimeDelta::FromMicroseconds(delay_time));
-      audio_read_delayed_ = true;
-      return;
+    if (timestamp_of_last_written_audio_ - seek_time_.ToSbTime() >
+        kAudioPrerollLimit) {
+      // The estimated time ahead of playback may be negative if no audio has
+      // been written.
+      SbTime time_ahead_of_playback =
+          timestamp_of_last_written_audio_ - last_media_time_;
+      if (time_ahead_of_playback > (kAudioLimit + kMediaTimeCheckInterval)) {
+        SbTime delay_time = (time_ahead_of_playback - kAudioLimit) /
+                            std::max(playback_rate_, 1.0f);
+        task_runner_->PostDelayedTask(
+            FROM_HERE, base::Bind(&SbPlayerPipeline::DelayedNeedData, this),
+            base::TimeDelta::FromMicroseconds(delay_time));
+        audio_read_delayed_ = true;
+        return;
+      }
     }
+
     audio_read_delayed_ = false;
 #endif  // SB_API_VERSION >= 11
     audio_read_in_progress_ = true;
diff --git a/src/cobalt/renderer/glimp_shaders/glsl/shaders.gypi b/src/cobalt/renderer/glimp_shaders/glsl/shaders.gypi
index 5e37306..a8801f8 100644
--- a/src/cobalt/renderer/glimp_shaders/glsl/shaders.gypi
+++ b/src/cobalt/renderer/glimp_shaders/glsl/shaders.gypi
@@ -21,8 +21,11 @@
 {
   'variables': {
     'glsl_shaders_dir': '<(DEPTH)/cobalt/renderer/glimp_shaders/glsl',
+    'glsl_shaders_0': [
+        '<!@pymod_do_main(starboard.build.gyp_functions file_glob <(DEPTH)/cobalt/renderer/glimp_shaders/glsl/ *.glsl)'
+    ],
     'glsl_shaders': [
-        '<!@(ls -1 <(DEPTH)/cobalt/renderer/glimp_shaders/glsl/*.glsl |xargs -n 1 basename)',
+        '<!@pymod_do_main(starboard.build.gyp_functions basename <@(glsl_shaders_0) )',
     ],
   }
 }
diff --git a/src/cobalt/renderer/pipeline.cc b/src/cobalt/renderer/pipeline.cc
index 97bef85..a78f0ed 100644
--- a/src/cobalt/renderer/pipeline.cc
+++ b/src/cobalt/renderer/pipeline.cc
@@ -24,12 +24,14 @@
 #include "cobalt/base/address_sanitizer.h"
 #include "cobalt/base/cobalt_paths.h"
 #include "cobalt/base/polymorphic_downcast.h"
+#include "cobalt/extension/graphics.h"
 #include "cobalt/math/rect_f.h"
 #include "cobalt/render_tree/brush.h"
 #include "cobalt/render_tree/composition_node.h"
 #include "cobalt/render_tree/dump_render_tree_to_string.h"
 #include "cobalt/render_tree/rect_node.h"
 #include "nb/memory_scope.h"
+#include "starboard/system.h"
 
 using cobalt::render_tree::Node;
 using cobalt::render_tree::animations::AnimateNode;
@@ -38,6 +40,7 @@
 namespace renderer {
 
 namespace {
+
 #if !defined(COBALT_MINIMUM_FRAME_TIME_IN_MILLISECONDS)
 // This default value has been moved from cobalt/build/cobalt_configuration.gypi
 // in favor of the usage of
@@ -76,6 +79,34 @@
   }
 }
 
+bool ShouldClearFrameOnShutdown(render_tree::ColorRGBA* out_clear_color) {
+#if SB_API_VERSION >= 11
+  const CobaltExtensionGraphicsApi* graphics_extension =
+      static_cast<const CobaltExtensionGraphicsApi*>(
+          SbSystemGetExtension(kCobaltExtensionGraphicsName));
+  if (graphics_extension &&
+      strcmp(graphics_extension->name, kCobaltExtensionGraphicsName) == 0 &&
+      graphics_extension->version >= 4) {
+    float r, g, b, a;
+    if (graphics_extension->ShouldClearFrameOnShutdown(&r, &g, &b, &a)) {
+      out_clear_color->set_r(r);
+      out_clear_color->set_g(g);
+      out_clear_color->set_b(b);
+      out_clear_color->set_a(a);
+      return true;
+    }
+    return false;
+  }
+#endif
+
+  // Default is to clear to opaque black.
+  out_clear_color->set_r(0.0f);
+  out_clear_color->set_g(0.0f);
+  out_clear_color->set_b(0.0f);
+  out_clear_color->set_a(1.0f);
+  return true;
+}
+
 }  // namespace
 
 Pipeline::Pipeline(const CreateRasterizerFunction& create_rasterizer_function,
@@ -329,13 +360,13 @@
       minimum_frame_interval_milliseconds =
           COBALT_MINIMUM_FRAME_TIME_IN_MILLISECONDS;
     } else {
-      DLOG(ERROR) <<
-          "COBALT_MINIMUM_FRAME_TIME_IN_MILLISECONDS and "
-          "CobaltExtensionGraphicsApi::GetMinimumFrameIntervalInMilliseconds"
-          "are both defined."
-          "Remove the 'cobalt_minimum_frame_time_in_milliseconds' ";
-          "from ../gyp_configuration.gypi in favor of the usage of "
-          "CobaltExtensionGraphicsApi::GetMinimumFrameIntervalInMilliseconds."
+      DLOG(ERROR)
+          << "COBALT_MINIMUM_FRAME_TIME_IN_MILLISECONDS and "
+             "CobaltExtensionGraphicsApi::GetMinimumFrameIntervalInMilliseconds"
+             "are both defined."
+             "Remove the 'cobalt_minimum_frame_time_in_milliseconds' ";
+      "from ../gyp_configuration.gypi in favor of the usage of "
+      "CobaltExtensionGraphicsApi::GetMinimumFrameIntervalInMilliseconds."
     }
 #else
     if (minimum_frame_interval_milliseconds < 0.0f) {
@@ -373,11 +404,13 @@
   bool is_new_render_tree = submission.render_tree != last_render_tree_;
   bool has_render_tree_changed =
       !last_animations_expired_ || is_new_render_tree;
-  bool force_rasterize = submit_even_if_render_tree_is_unchanged_ ||
-      fps_overlay_update_pending_;
+  bool force_rasterize =
+      submit_even_if_render_tree_is_unchanged_ || fps_overlay_update_pending_;
 
-  float maximum_frame_interval_milliseconds = graphics_context_ ?
-      graphics_context_->GetMaximumFrameIntervalInMilliseconds() : -1.0f;
+  float maximum_frame_interval_milliseconds =
+      graphics_context_
+          ? graphics_context_->GetMaximumFrameIntervalInMilliseconds()
+          : -1.0f;
   if (maximum_frame_interval_milliseconds >= 0.0f) {
     base::TimeDelta max_time_between_rasterize =
         base::TimeDelta::FromMillisecondsD(maximum_frame_interval_milliseconds);
@@ -617,18 +650,18 @@
   // Shutdown the FPS overlay which may reference render trees.
   fps_overlay_ = base::nullopt;
 
-  // Submit a black fullscreen rect node to clear the display before shutting
+  // Submit a fullscreen rect node to clear the display before shutting
   // down.  This can be helpful if we quit while playing a video via
   // punch-through, which may result in unexpected images/colors appearing for
   // a flicker behind the display.
-  if (render_target_ && (clear_on_shutdown_mode_ == kClearToBlack)) {
-    rasterizer_->Submit(
-        new render_tree::RectNode(
-            math::RectF(render_target_->GetSize()),
-            std::unique_ptr<render_tree::Brush>(
-                new render_tree::SolidColorBrush(
-                    render_tree::ColorRGBA(0.0f, 0.0f, 0.0f, 1.0f)))),
-        render_target_);
+  render_tree::ColorRGBA clear_color;
+  if (render_target_ && clear_on_shutdown_mode_ == kClearAccordingToPlatform &&
+      ShouldClearFrameOnShutdown(&clear_color)) {
+    rasterizer_->Submit(new render_tree::RectNode(
+                            math::RectF(render_target_->GetSize()),
+                            std::unique_ptr<render_tree::Brush>(
+                                new render_tree::SolidColorBrush(clear_color))),
+                        render_target_);
   }
 
   // This potential reference to a render tree whose animations may have ended
diff --git a/src/cobalt/renderer/pipeline.h b/src/cobalt/renderer/pipeline.h
index bbb9658..5848d95 100644
--- a/src/cobalt/renderer/pipeline.h
+++ b/src/cobalt/renderer/pipeline.h
@@ -58,7 +58,12 @@
       RasterizationCompleteCallback;
 
   enum ShutdownClearMode {
-    kClearToBlack,
+    // Query CobaltExtensionGraphicsApi's ShouldClearFrameOnShutdown for
+    // shutdown behavior.
+    kClearAccordingToPlatform,
+
+    // Do not clear regardless of what CobaltExtensionGraphicsApi's
+    // ShouldClearFrameOnShutdown specifies.
     kNoClear,
   };
 
diff --git a/src/cobalt/renderer/rasterizer/egl/hardware_rasterizer.cc b/src/cobalt/renderer/rasterizer/egl/hardware_rasterizer.cc
index 801112c..1f04c7a 100644
--- a/src/cobalt/renderer/rasterizer/egl/hardware_rasterizer.cc
+++ b/src/cobalt/renderer/rasterizer/egl/hardware_rasterizer.cc
@@ -234,7 +234,7 @@
   uint32_t untouched_states =
       kMSAAEnable_GrGLBackendState | kStencil_GrGLBackendState |
       kPixelStore_GrGLBackendState | kFixedFunction_GrGLBackendState |
-      kPathRendering_GrGLBackendState | kMisc_GrGLBackendState;
+      kPathRendering_GrGLBackendState;
 
   GetFallbackContext()->resetContext(~untouched_states & kAll_GrBackendState);
 }
diff --git a/src/cobalt/renderer/renderer_module.cc b/src/cobalt/renderer/renderer_module.cc
index 6b52456..9783414 100644
--- a/src/cobalt/renderer/renderer_module.cc
+++ b/src/cobalt/renderer/renderer_module.cc
@@ -102,7 +102,7 @@
         // deprecate the submit_even_if_render_tree_is_unchanged.
         false,
 #endif
-        renderer::Pipeline::kClearToBlack, pipeline_options));
+        renderer::Pipeline::kClearAccordingToPlatform, pipeline_options));
   }
 }
 
diff --git a/src/cobalt/site/docs/development/setup-linux.md b/src/cobalt/site/docs/development/setup-linux.md
index 3c4d49f..4fff20e 100644
--- a/src/cobalt/site/docs/development/setup-linux.md
+++ b/src/cobalt/site/docs/development/setup-linux.md
@@ -32,12 +32,14 @@
     Cobalt on Linux:
 
     ```
-    $ sudo apt install -qqy --no-install-recommends pkgconf ninja-build bison \
-        yasm binutils clang libgles2-mesa-dev mesa-common-dev libpulse-dev \
-        libavresample-dev libasound2-dev libxrender-dev libxcomposite-dev
+    $ sudo apt install -qqy --no-install-recommends pkgconf ninja-build \
+        bison yasm binutils clang libgles2-mesa-dev mesa-common-dev \
+        libpulse-dev libavresample-dev libasound2-dev libxrender-dev \
+        libxcomposite-dev
     ```
 
 1.  Install Node.js via `nvm`:
+
     ```
     $ export NVM_DIR=~/.nvm
     $ export NODE_VERSION=12.17.0
diff --git a/src/cobalt/site/docs/reference/starboard/modules/10/media.md b/src/cobalt/site/docs/reference/starboard/modules/10/media.md
index 7271b29..b9019a6 100644
--- a/src/cobalt/site/docs/reference/starboard/modules/10/media.md
+++ b/src/cobalt/site/docs/reference/starboard/modules/10/media.md
@@ -435,11 +435,39 @@
 `mime`: The mime information of the media in the form of `video/webm` or
 `video/mp4; codecs="avc1.42001E"`. It may include arbitrary parameters like
 "codecs", "channels", etc. Note that the "codecs" parameter may contain more
-than one codec, delimited by comma. `key_system`: A lowercase value in fhe form
+than one codec, delimited by comma. `key_system`: A lowercase value in the form
 of "com.example.somesystem" as suggested by [https://w3c.github.io/encrypted-media/#key-system](https://w3c.github.io/encrypted-media/#key-system)) that can
 be matched exactly with known DRM key systems of the platform. When `key_system`
 is an empty string, the return value is an indication for non-encrypted media.
 
+An implementation may choose to support `key_system` with extra attributes,
+separated by ';', like `com.example.somesystem; attribute_name1="value1";
+attribute_name2=value1`. If `key_system` with attributes is not supported by an
+implementation, it should treat `key_system` as if it contains only the key
+system, and reject any input containing extra attributes, i.e. it can keep using
+its existing implementation. When an implementation supports `key_system` with
+attributes, it has to support all attributes defined by the Starboard version
+the implementation uses. An implementation should ignore any unknown attributes,
+and make a decision solely based on the key system and the known attributes. For
+example, if an implementation supports "com.widevine.alpha", it should also
+return `kSbMediaSupportTypeProbably` kSbMediaSupportTypeProbably when
+`key_system` is `com.widevine.alpha; invalid_attribute="invalid_value"`.
+Currently the only attribute has to be supported is `encryptionscheme`. It
+reflects the value passed to `encryptionScheme` encryptionScheme of
+MediaKeySystemMediaCapability, as defined in [https://wicg.github.io/encrypted-media-encryption-scheme/,](https://wicg.github.io/encrypted-media-encryption-scheme/,),) which can take value "cenc", "cbcs", or "cbcs-1-9". Empty string is
+not a valid value for `encryptionscheme` and the implementation should return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported when
+`encryptionscheme` is set to "". The implementation should return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported for unknown
+values of known attributes. For example, if an implementation supports
+"encryptionscheme" with value "cenc", "cbcs", or "cbcs-1-9", then it should
+return `kSbMediaSupportTypeProbably` kSbMediaSupportTypeProbably when
+`key_system` is `com.widevine.alpha; encryptionscheme="cenc"`, and return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported when
+`key_system` is `com.widevine.alpha; encryptionscheme="invalid"`. If an
+implementation supports key system with attributes on one key system, it has to
+support key system with attributes on all key systems supported.
+
 #### Declaration ####
 
 ```
diff --git a/src/cobalt/site/docs/reference/starboard/modules/11/media.md b/src/cobalt/site/docs/reference/starboard/modules/11/media.md
index 377cb2b..22da43e 100644
--- a/src/cobalt/site/docs/reference/starboard/modules/11/media.md
+++ b/src/cobalt/site/docs/reference/starboard/modules/11/media.md
@@ -429,11 +429,39 @@
 `mime`: The mime information of the media in the form of `video/webm` or
 `video/mp4; codecs="avc1.42001E"`. It may include arbitrary parameters like
 "codecs", "channels", etc. Note that the "codecs" parameter may contain more
-than one codec, delimited by comma. `key_system`: A lowercase value in fhe form
+than one codec, delimited by comma. `key_system`: A lowercase value in the form
 of "com.example.somesystem" as suggested by [https://w3c.github.io/encrypted-media/#key-system](https://w3c.github.io/encrypted-media/#key-system)) that can
 be matched exactly with known DRM key systems of the platform. When `key_system`
 is an empty string, the return value is an indication for non-encrypted media.
 
+An implementation may choose to support `key_system` with extra attributes,
+separated by ';', like `com.example.somesystem; attribute_name1="value1";
+attribute_name2=value1`. If `key_system` with attributes is not supported by an
+implementation, it should treat `key_system` as if it contains only the key
+system, and reject any input containing extra attributes, i.e. it can keep using
+its existing implementation. When an implementation supports `key_system` with
+attributes, it has to support all attributes defined by the Starboard version
+the implementation uses. An implementation should ignore any unknown attributes,
+and make a decision solely based on the key system and the known attributes. For
+example, if an implementation supports "com.widevine.alpha", it should also
+return `kSbMediaSupportTypeProbably` kSbMediaSupportTypeProbably when
+`key_system` is `com.widevine.alpha; invalid_attribute="invalid_value"`.
+Currently the only attribute has to be supported is `encryptionscheme`. It
+reflects the value passed to `encryptionScheme` encryptionScheme of
+MediaKeySystemMediaCapability, as defined in [https://wicg.github.io/encrypted-media-encryption-scheme/,](https://wicg.github.io/encrypted-media-encryption-scheme/,),) which can take value "cenc", "cbcs", or "cbcs-1-9". Empty string is
+not a valid value for `encryptionscheme` and the implementation should return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported when
+`encryptionscheme` is set to "". The implementation should return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported for unknown
+values of known attributes. For example, if an implementation supports
+"encryptionscheme" with value "cenc", "cbcs", or "cbcs-1-9", then it should
+return `kSbMediaSupportTypeProbably` kSbMediaSupportTypeProbably when
+`key_system` is `com.widevine.alpha; encryptionscheme="cenc"`, and return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported when
+`key_system` is `com.widevine.alpha; encryptionscheme="invalid"`. If an
+implementation supports key system with attributes on one key system, it has to
+support key system with attributes on all key systems supported.
+
 #### Declaration ####
 
 ```
diff --git a/src/cobalt/site/docs/reference/starboard/modules/12/media.md b/src/cobalt/site/docs/reference/starboard/modules/12/media.md
index 5a50b33..1ca8e06 100644
--- a/src/cobalt/site/docs/reference/starboard/modules/12/media.md
+++ b/src/cobalt/site/docs/reference/starboard/modules/12/media.md
@@ -429,11 +429,39 @@
 `mime`: The mime information of the media in the form of `video/webm` or
 `video/mp4; codecs="avc1.42001E"`. It may include arbitrary parameters like
 "codecs", "channels", etc. Note that the "codecs" parameter may contain more
-than one codec, delimited by comma. `key_system`: A lowercase value in fhe form
+than one codec, delimited by comma. `key_system`: A lowercase value in the form
 of "com.example.somesystem" as suggested by [https://w3c.github.io/encrypted-media/#key-system](https://w3c.github.io/encrypted-media/#key-system)) that can
 be matched exactly with known DRM key systems of the platform. When `key_system`
 is an empty string, the return value is an indication for non-encrypted media.
 
+An implementation may choose to support `key_system` with extra attributes,
+separated by ';', like `com.example.somesystem; attribute_name1="value1";
+attribute_name2=value1`. If `key_system` with attributes is not supported by an
+implementation, it should treat `key_system` as if it contains only the key
+system, and reject any input containing extra attributes, i.e. it can keep using
+its existing implementation. When an implementation supports `key_system` with
+attributes, it has to support all attributes defined by the Starboard version
+the implementation uses. An implementation should ignore any unknown attributes,
+and make a decision solely based on the key system and the known attributes. For
+example, if an implementation supports "com.widevine.alpha", it should also
+return `kSbMediaSupportTypeProbably` kSbMediaSupportTypeProbably when
+`key_system` is `com.widevine.alpha; invalid_attribute="invalid_value"`.
+Currently the only attribute has to be supported is `encryptionscheme`. It
+reflects the value passed to `encryptionScheme` encryptionScheme of
+MediaKeySystemMediaCapability, as defined in [https://wicg.github.io/encrypted-media-encryption-scheme/,](https://wicg.github.io/encrypted-media-encryption-scheme/,),) which can take value "cenc", "cbcs", or "cbcs-1-9". Empty string is
+not a valid value for `encryptionscheme` and the implementation should return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported when
+`encryptionscheme` is set to "". The implementation should return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported for unknown
+values of known attributes. For example, if an implementation supports
+"encryptionscheme" with value "cenc", "cbcs", or "cbcs-1-9", then it should
+return `kSbMediaSupportTypeProbably` kSbMediaSupportTypeProbably when
+`key_system` is `com.widevine.alpha; encryptionscheme="cenc"`, and return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported when
+`key_system` is `com.widevine.alpha; encryptionscheme="invalid"`. If an
+implementation supports key system with attributes on one key system, it has to
+support key system with attributes on all key systems supported.
+
 #### Declaration ####
 
 ```
diff --git a/src/cobalt/site/docs/reference/starboard/modules/media.md b/src/cobalt/site/docs/reference/starboard/modules/media.md
index 5a50b33..1ca8e06 100644
--- a/src/cobalt/site/docs/reference/starboard/modules/media.md
+++ b/src/cobalt/site/docs/reference/starboard/modules/media.md
@@ -429,11 +429,39 @@
 `mime`: The mime information of the media in the form of `video/webm` or
 `video/mp4; codecs="avc1.42001E"`. It may include arbitrary parameters like
 "codecs", "channels", etc. Note that the "codecs" parameter may contain more
-than one codec, delimited by comma. `key_system`: A lowercase value in fhe form
+than one codec, delimited by comma. `key_system`: A lowercase value in the form
 of "com.example.somesystem" as suggested by [https://w3c.github.io/encrypted-media/#key-system](https://w3c.github.io/encrypted-media/#key-system)) that can
 be matched exactly with known DRM key systems of the platform. When `key_system`
 is an empty string, the return value is an indication for non-encrypted media.
 
+An implementation may choose to support `key_system` with extra attributes,
+separated by ';', like `com.example.somesystem; attribute_name1="value1";
+attribute_name2=value1`. If `key_system` with attributes is not supported by an
+implementation, it should treat `key_system` as if it contains only the key
+system, and reject any input containing extra attributes, i.e. it can keep using
+its existing implementation. When an implementation supports `key_system` with
+attributes, it has to support all attributes defined by the Starboard version
+the implementation uses. An implementation should ignore any unknown attributes,
+and make a decision solely based on the key system and the known attributes. For
+example, if an implementation supports "com.widevine.alpha", it should also
+return `kSbMediaSupportTypeProbably` kSbMediaSupportTypeProbably when
+`key_system` is `com.widevine.alpha; invalid_attribute="invalid_value"`.
+Currently the only attribute has to be supported is `encryptionscheme`. It
+reflects the value passed to `encryptionScheme` encryptionScheme of
+MediaKeySystemMediaCapability, as defined in [https://wicg.github.io/encrypted-media-encryption-scheme/,](https://wicg.github.io/encrypted-media-encryption-scheme/,),) which can take value "cenc", "cbcs", or "cbcs-1-9". Empty string is
+not a valid value for `encryptionscheme` and the implementation should return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported when
+`encryptionscheme` is set to "". The implementation should return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported for unknown
+values of known attributes. For example, if an implementation supports
+"encryptionscheme" with value "cenc", "cbcs", or "cbcs-1-9", then it should
+return `kSbMediaSupportTypeProbably` kSbMediaSupportTypeProbably when
+`key_system` is `com.widevine.alpha; encryptionscheme="cenc"`, and return
+`kSbMediaSupportTypeNotSupported` kSbMediaSupportTypeNotSupported when
+`key_system` is `com.widevine.alpha; encryptionscheme="invalid"`. If an
+implementation supports key system with attributes on one key system, it has to
+support key system with attributes on all key systems supported.
+
 #### Declaration ####
 
 ```
diff --git a/src/cobalt/tools/automated_testing/cobalt_runner.py b/src/cobalt/tools/automated_testing/cobalt_runner.py
index 4f627f7..22479f7 100644
--- a/src/cobalt/tools/automated_testing/cobalt_runner.py
+++ b/src/cobalt/tools/automated_testing/cobalt_runner.py
@@ -9,10 +9,10 @@
 import os
 import re
 import sys
-import thread
 import threading
 import time
 import traceback
+import thread
 
 import _env  # pylint: disable=unused-import
 from cobalt.tools.automated_testing import c_val_names
@@ -26,8 +26,8 @@
 RE_WEBDRIVER_FAILED = re.compile(r'Could not start WebDriver server')
 # Pattern to match Cobalt log line for when a WindowDriver has been created.
 RE_WINDOWDRIVER_CREATED = re.compile(
-    r'^\[[\d:]+/[\d.]+:INFO:browser_module\.cc\(\d+\)\] Created WindowDriver: ID=\S+'
-)
+    (r'^\[[\d:]+/[\d.]+:INFO:browser_module\.cc\(\d+\)\] Created WindowDriver: '
+     r'ID=\S+'))
 # Pattern to match Cobalt log line for when a WebModule is has been loaded.
 RE_WEBMODULE_LOADED = re.compile(
     r'^\[[\d:]+/[\d.]+:INFO:browser_module\.cc\(\d+\)\] Loaded WebModule')
@@ -231,7 +231,7 @@
       self.WaitForStart()
     except KeyboardInterrupt:
       # potentially from thread.interrupt_main(). We will treat as
-      # a timeout regardless
+      # a timeout regardless.
 
       self.Exit(should_fail=True)
       raise TimeoutException
@@ -270,8 +270,8 @@
       self.runner_thread.join(COBALT_EXIT_TIMEOUT_SECONDS)
     if self.runner_thread.isAlive():
       sys.stderr.write(
-          '***Runner thread still alive after sending graceful shutdown command, try again by killing app***\n'
-      )
+          '***Runner thread still alive after sending graceful shutdown '
+          'command, try again by killing app***\n')
       self.launcher.Kill()
     # Once the write end of the pipe has been closed by the launcher, the reader
     # thread will get EOF and exit.
@@ -312,7 +312,7 @@
       logging.info('Cobalt terminated.')
       if not self.failed and self.success_message:
         print('{}\n'.format(self.success_message))
-        logging.info('{}\n'.format(self.success_message))
+        logging.info('%s\n', self.success_message)
     # pylint: disable=broad-except
     except Exception as ex:
       sys.stderr.write('Exception running Cobalt ' + str(ex))
@@ -329,7 +329,11 @@
 
   def ExecuteJavaScript(self, js_code):
     retry_count = 0
-    while retry_count < EXECUTE_JAVASCRIPT_RETRY_LIMIT:
+    while True:
+      if retry_count >= EXECUTE_JAVASCRIPT_RETRY_LIMIT:
+        raise TimeoutException(
+            'Selenium element or window not found in {} tries'.format(
+                EXECUTE_JAVASCRIPT_RETRY_LIMIT))
       retry_count += 1
       try:
         result = self.webdriver.execute_script(js_code)
@@ -337,9 +341,6 @@
               selenium_exceptions.NoSuchWindowException):
         time.sleep(0.2)
         continue
-      except Exception:
-        sys.excepthook(*sys.exc_info())
-        logging.exception("Failed with unexpected exception")
       break
     return result
 
@@ -354,15 +355,14 @@
     """
     javascript_code = 'return h5vcc.cVal.getValue(\'{}\')'.format(cval_name)
     cval_string = self.ExecuteJavaScript(javascript_code)
-    if cval_string is None:
-      return None
-    else:
+    if cval_string:
       try:
         # Try to parse numbers and booleans.
         return json.loads(cval_string)
       except ValueError:
         # If we can't parse a value, return the cval string as-is.
         return cval_string
+    return None
 
   def GetCvalBatch(self, cval_name_list):
     """Retrieves a batch of cvals.
@@ -454,7 +454,11 @@
     # after navigation. We only introduced it because of limited time budget
     # at the moment, please don't introduce any code that relies on it.
     retry_count = 0
-    while retry_count < FIND_ELEMENT_RETRY_LIMIT:
+    while True:
+      if retry_count >= FIND_ELEMENT_RETRY_LIMIT:
+        raise TimeoutException(
+            'Selenium element or window not found in {} tries'.format(
+                FIND_ELEMENT_RETRY_LIMIT))
       retry_count += 1
       try:
         elements = self.webdriver.find_elements_by_css_selector(css_selector)
@@ -462,11 +466,8 @@
               selenium_exceptions.NoSuchWindowException):
         time.sleep(0.2)
         continue
-      except Exception:
-        sys.excepthook(*sys.exc_info())
-        logging.exception("Failed with unexpected exception")
       break
-    if expected_num is not None and len(elements) != expected_num:
+    if expected_num and len(elements) != expected_num:
       raise CobaltRunner.AssertException(
           'Expected number of element {} is: {}, got {}'.format(
               css_selector, expected_num, len(elements)))
diff --git a/src/cobalt/updater/configurator.cc b/src/cobalt/updater/configurator.cc
index 210f088..a10bd03 100644
--- a/src/cobalt/updater/configurator.cc
+++ b/src/cobalt/updater/configurator.cc
@@ -1,4 +1,4 @@
-// Copyright 2019 The Chromium Authors. All rights reserved.
+// Copyright 2020 The Cobalt Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
@@ -28,33 +28,35 @@
 // Default time constants.
 const int kDelayOneMinute = 60;
 const int kDelayOneHour = kDelayOneMinute * 60;
+const std::set<std::string> valid_channels = {
+    // Default channel for debug/devel builds.
+    "dev",
+    // Channel for dogfooders.
+    "dogfood",
+    // Default channel for gold builds.
+    "prod",
+    // Default channel for qa builds. A gold build can switch to this channel to
+    // get an official qa build.
+    "qa",
+    // Test an update with higher version than prod channel.
+    "test",
+    // Test an update with mismatched sabi.
+    "tmsabi",
+    // Test an update that does nothing.
+    "tnoop",
+    // Test an update that crashes.
+    "tcrash",
+    // Test an update that fails verification.
+    "tfailv",
+    // Test a series of continuous updates with two channels.
+    "tseries1", "tseries2",
+};
 
 #if defined(COBALT_BUILD_TYPE_DEBUG) || defined(COBALT_BUILD_TYPE_DEVEL)
-const std::set<std::string> valid_channels = {"dev"};
 const std::string kDefaultUpdaterChannel = "dev";
 #elif defined(COBALT_BUILD_TYPE_QA)
-// Find more information about these test channels in the Evergreen test plan.
-const std::set<std::string> valid_channels = {
-    "qa",
-    // A normal test channel that serves a valid update
-    "test",
-    // Test an update with mismatched sabi
-    "tmsabi",
-    // Test an update that does nothing
-    "tnoop",
-    // Test an update that crashes
-    "tcrash",
-    // Test an update that fails verification
-    "tfailv",
-    // Test a series of continuous updates with two channels
-    "tseries1",
-    "tseries2",
-    // Test an update that's larger than the available storage on the device
-    "tistore",
-};
 const std::string kDefaultUpdaterChannel = "qa";
 #elif defined(COBALT_BUILD_TYPE_GOLD)
-const std::set<std::string> valid_channels = {"prod", "dogfood"};
 const std::string kDefaultUpdaterChannel = "prod";
 #endif
 
@@ -146,8 +148,8 @@
   base::flat_map<std::string, std::string> params;
   params.insert(std::make_pair("SABI", SB_SABI_JSON_ID));
   params.insert(std::make_pair("sbversion", std::to_string(SB_API_VERSION)));
-  params.insert(std::make_pair(
-      "jsengine", script::GetJavaScriptEngineNameAndVersion()));
+  params.insert(
+      std::make_pair("jsengine", script::GetJavaScriptEngineNameAndVersion()));
   params.insert(std::make_pair(
       "updaterchannelchanged",
       SbAtomicNoBarrier_Load(&is_channel_changed_) == 1 ? "True" : "False"));
@@ -252,5 +254,16 @@
   updater_status_ = status;
 }
 
+std::string Configurator::GetPreviousUpdaterStatus() const {
+  base::AutoLock auto_lock(
+      const_cast<base::Lock&>(previous_updater_status_lock_));
+  return previous_updater_status_;
+}
+
+void Configurator::SetPreviousUpdaterStatus(const std::string& status) {
+  base::AutoLock auto_lock(previous_updater_status_lock_);
+  previous_updater_status_ = status;
+}
+
 }  // namespace updater
 }  // namespace cobalt
diff --git a/src/cobalt/updater/configurator.h b/src/cobalt/updater/configurator.h
index e335b4f..cfd1488 100644
--- a/src/cobalt/updater/configurator.h
+++ b/src/cobalt/updater/configurator.h
@@ -81,9 +81,12 @@
 
   bool IsChannelValid(const std::string& channel);
 
-  std::string GetUpdaterStatus() const;
+  std::string GetUpdaterStatus() const override;
   void SetUpdaterStatus(const std::string& status);
 
+  std::string GetPreviousUpdaterStatus() const override;
+  void SetPreviousUpdaterStatus(const std::string& status) override;
+
  private:
   friend class base::RefCountedThreadSafe<Configurator>;
   ~Configurator() override;
@@ -98,6 +101,8 @@
   SbAtomic32 is_channel_changed_;
   std::string updater_status_;
   base::Lock updater_status_lock_;
+  std::string previous_updater_status_;
+  base::Lock previous_updater_status_lock_;
 
   DISALLOW_COPY_AND_ASSIGN(Configurator);
 };
diff --git a/src/cobalt/updater/noop_sandbox.cc b/src/cobalt/updater/noop_sandbox.cc
index d9ce028..5f63965 100644
--- a/src/cobalt/updater/noop_sandbox.cc
+++ b/src/cobalt/updater/noop_sandbox.cc
@@ -15,7 +15,12 @@
 // This is a test app for Evergreen that does nothing.
 
 #include "starboard/event.h"
+#include "starboard/system.h"
+#include "starboard/thread.h"
+#include "starboard/time.h"
 
 void SbEventHandle(const SbEvent* event) {
-  // noop
+  // No-op app. Exit after 1s.
+  SbThreadSleep(kSbTimeSecond);
+  SbSystemRequestStop(0);
 }
diff --git a/src/cobalt/updater/updater_module.cc b/src/cobalt/updater/updater_module.cc
index 2f0452b..9cbbd52 100644
--- a/src/cobalt/updater/updater_module.cc
+++ b/src/cobalt/updater/updater_module.cc
@@ -50,8 +50,8 @@
     0x9e, 0x8b, 0x2d, 0x22, 0x65, 0x19, 0xb1, 0xfa, 0xba, 0x02, 0x04,
     0x3a, 0xb2, 0x7a, 0xf6, 0xfe, 0xd5, 0x35, 0xa1, 0x19, 0xd9};
 
-// The map to translate updater status from enum to readable string.
-const std::map<ComponentState, const char*> updater_status_map = {
+// The map to translate update state from ComponentState to readable string.
+const std::map<ComponentState, const char*> update_state_map = {
     {ComponentState::kNew, "Will check for update soon"},
     {ComponentState::kChecking, "Checking for update"},
     {ComponentState::kCanUpdate, "Update is available"},
@@ -78,9 +78,15 @@
 void Observer::OnEvent(Events event, const std::string& id) {
   std::string status;
   if (update_client_->GetCrxUpdateState(id, &crx_update_item_)) {
-    auto status_iterator = updater_status_map.find(crx_update_item_.state);
-    if (status_iterator == updater_status_map.end()) {
+    auto status_iterator = update_state_map.find(crx_update_item_.state);
+    if (status_iterator == update_state_map.end()) {
       status = "Status is unknown.";
+    } else if (crx_update_item_.state == ComponentState::kUpToDate &&
+               updater_configurator_->GetPreviousUpdaterStatus().compare(
+                   update_state_map.find(ComponentState::kUpdated)->second) ==
+                   0) {
+      status =
+          std::string(update_state_map.find(ComponentState::kUpdated)->second);
     } else {
       status = std::string(status_iterator->second);
     }
diff --git a/src/cobalt/version.h b/src/cobalt/version.h
index 08526a7..acdcdfa 100644
--- a/src/cobalt/version.h
+++ b/src/cobalt/version.h
@@ -35,6 +35,6 @@
 //                  release is cut.
 //.
 
-#define COBALT_VERSION "21.lts.1"
+#define COBALT_VERSION "21.lts.2"
 
 #endif  // COBALT_VERSION_H_
diff --git a/src/cobalt/xhr/url_fetcher_buffer_writer.cc b/src/cobalt/xhr/url_fetcher_buffer_writer.cc
index 3b43b8a..fd67bb4 100644
--- a/src/cobalt/xhr/url_fetcher_buffer_writer.cc
+++ b/src/cobalt/xhr/url_fetcher_buffer_writer.cc
@@ -26,6 +26,9 @@
 // Allocate 64KB if the total size is unknown to avoid allocating small buffer
 // too many times.
 const int64_t kDefaultPreAllocateSizeInBytes = 64 * 1024;
+// Set max allocate size to avoid erroneous size estimate.
+const int64_t kMaxPreAllocateSizeInBytes = 10 * 1024 * 1024;
+const uint8_t kResizingMultiplier = 2;
 
 void ReleaseMemory(std::string* str) {
   DCHECK(str);
@@ -158,9 +161,16 @@
 
   if (capacity < 0) {
     capacity = kDefaultPreAllocateSizeInBytes;
+  } else if (capacity > kMaxPreAllocateSizeInBytes) {
+    LOG(WARNING) << "Allocation of " << capacity << " bytes is capped to "
+                 << kMaxPreAllocateSizeInBytes;
+    capacity = kMaxPreAllocateSizeInBytes;
   } else {
     capacity_known_ = true;
   }
+  // Record the desired_capacity_ to avoid reserving unused memory during
+  // resizing.
+  desired_capacity_ = static_cast<size_t>(capacity);
 
   if (capacity == 0) {
     return;
@@ -212,7 +222,16 @@
       SB_LOG(WARNING) << "Data written is larger than the preset capacity "
                       << data_as_array_buffer_.byte_length();
     }
-    data_as_array_buffer_.Resize(data_as_array_buffer_size_ + num_bytes);
+    size_t new_size = std::max(
+        std::min(data_as_array_buffer_.byte_length() * kResizingMultiplier,
+                 desired_capacity_),
+        data_as_array_buffer_size_ + num_bytes);
+    if (new_size > desired_capacity_) {
+      // Content-length is wrong, response size is completely unknown.
+      // Double the capacity to avoid frequent resizing.
+      new_size *= kResizingMultiplier;
+    }
+    data_as_array_buffer_.Resize(new_size);
   }
 
   auto destination = static_cast<uint8_t*>(data_as_array_buffer_.data()) +
diff --git a/src/cobalt/xhr/url_fetcher_buffer_writer.h b/src/cobalt/xhr/url_fetcher_buffer_writer.h
index 8eb9736..35058ab 100644
--- a/src/cobalt/xhr/url_fetcher_buffer_writer.h
+++ b/src/cobalt/xhr/url_fetcher_buffer_writer.h
@@ -74,6 +74,7 @@
     Type type_;
     bool allow_preallocate_ = true;
     bool capacity_known_ = false;
+    size_t desired_capacity_ = 0;
 
     // This class can be accessed by both network and MainWebModule threads.
     mutable base::Lock lock_;
diff --git a/src/cobalt/xhr/xhr.gyp b/src/cobalt/xhr/xhr.gyp
index 051822e..708f710 100644
--- a/src/cobalt/xhr/xhr.gyp
+++ b/src/cobalt/xhr/xhr.gyp
@@ -23,8 +23,6 @@
       'sources': [
         'url_fetcher_buffer_writer.cc',
         'url_fetcher_buffer_writer.h',
-        'xhr_response_data.cc',
-        'xhr_response_data.h',
         'xml_http_request.cc',
         'xml_http_request.h',
         'xml_http_request_event_target.cc',
@@ -58,7 +56,6 @@
       'target_name': 'xhr_test',
       'type': '<(gtest_target_type)',
       'sources': [
-        'xhr_response_data_test.cc',
         'xml_http_request_test.cc',
       ],
       'dependencies': [
diff --git a/src/cobalt/xhr/xhr_response_data.cc b/src/cobalt/xhr/xhr_response_data.cc
deleted file mode 100644
index d2e5051..0000000
--- a/src/cobalt/xhr/xhr_response_data.cc
+++ /dev/null
@@ -1,84 +0,0 @@
-// Copyright 2015 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/xhr/xhr_response_data.h"
-
-#include <algorithm>
-
-#include "cobalt/dom/global_stats.h"
-
-namespace cobalt {
-namespace xhr {
-
-namespace {
-
-// When we don't have any data, we still want to return a non-null pointer to a
-// valid memory location.  Because even it will never be accessed, a null
-// pointer may trigger undefined behavior in functions like memcpy.  So we
-// create this dummy value here and return its address when we don't have any
-// data.
-uint8 s_dummy;
-
-// We are using std::string to store binary data so we want to ensure that char
-// occupies one byte.
-COMPILE_ASSERT(sizeof(char) == 1, char_should_occupy_one_byte);
-
-}  // namespace
-
-XhrResponseData::XhrResponseData() { IncreaseMemoryUsage(); }
-
-XhrResponseData::~XhrResponseData() { DecreaseMemoryUsage(); }
-
-void XhrResponseData::Clear() {
-  DecreaseMemoryUsage();
-  // Use swap to force free the memory allocated.
-  std::string dummy;
-  data_.swap(dummy);
-  IncreaseMemoryUsage();
-}
-
-void XhrResponseData::Reserve(size_t new_capacity_bytes) {
-  DecreaseMemoryUsage();
-  data_.reserve(new_capacity_bytes);
-  IncreaseMemoryUsage();
-}
-
-void XhrResponseData::Append(const uint8* source_data, size_t size_bytes) {
-  if (size_bytes == 0) {
-    return;
-  }
-  DecreaseMemoryUsage();
-  data_.resize(data_.size() + size_bytes);
-  memcpy(&data_[data_.size() - size_bytes], source_data, size_bytes);
-  IncreaseMemoryUsage();
-}
-
-const uint8* XhrResponseData::data() const {
-  return data_.empty() ? &s_dummy : reinterpret_cast<const uint8*>(&data_[0]);
-}
-
-uint8* XhrResponseData::data() {
-  return data_.empty() ? &s_dummy : reinterpret_cast<uint8*>(&data_[0]);
-}
-
-void XhrResponseData::IncreaseMemoryUsage() {
-  dom::GlobalStats::GetInstance()->IncreaseXHRMemoryUsage(capacity());
-}
-
-void XhrResponseData::DecreaseMemoryUsage() {
-  dom::GlobalStats::GetInstance()->DecreaseXHRMemoryUsage(capacity());
-}
-
-}  // namespace xhr
-}  // namespace cobalt
diff --git a/src/cobalt/xhr/xhr_response_data.h b/src/cobalt/xhr/xhr_response_data.h
deleted file mode 100644
index 894cd3f..0000000
--- a/src/cobalt/xhr/xhr_response_data.h
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2015 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_XHR_XHR_RESPONSE_DATA_H_
-#define COBALT_XHR_XHR_RESPONSE_DATA_H_
-
-#include <string>
-
-#include "base/basictypes.h"
-
-namespace cobalt {
-namespace xhr {
-
-// Simple wrapper for an array of data.
-// Used by XMLHttpRequest to construct the response body.
-class XhrResponseData {
- public:
-  XhrResponseData();
-  ~XhrResponseData();
-
-  // Destroy the data_ and reset the size and capacity to 0.
-  void Clear();
-  // Allocate storage for |new_capacity_bytes| of data.
-  void Reserve(size_t new_capacity_bytes);
-  // Append |source_data|, |size_bytes| in length, to the data array.
-  void Append(const uint8* source_data, size_t size_bytes);
-
-  const uint8* data() const;
-  uint8* data();
-
-  const std::string& string() const { return data_; }
-
-  size_t size() const { return data_.size(); }
-  size_t capacity() const { return data_.capacity(); }
-
- private:
-  void IncreaseMemoryUsage();
-  void DecreaseMemoryUsage();
-
-  std::string data_;
-};
-
-}  // namespace xhr
-}  // namespace cobalt
-
-#endif  // COBALT_XHR_XHR_RESPONSE_DATA_H_
diff --git a/src/cobalt/xhr/xhr_response_data_test.cc b/src/cobalt/xhr/xhr_response_data_test.cc
deleted file mode 100644
index f63d70e..0000000
--- a/src/cobalt/xhr/xhr_response_data_test.cc
+++ /dev/null
@@ -1,55 +0,0 @@
-// Copyright 2015 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/xhr/xhr_response_data.h"
-
-#include "testing/gtest/include/gtest/gtest.h"
-
-namespace cobalt {
-namespace xhr {
-
-namespace {
-
-TEST(XhrResponseData, InitialState) {
-  XhrResponseData empty;
-  EXPECT_EQ(0u, empty.size());
-  EXPECT_TRUE(empty.data() != NULL);
-}
-
-TEST(XhrResponseData, Append) {
-  XhrResponseData data;
-  uint8 raw_data[64];
-  for (int i = 0; i < 64; ++i) {
-    raw_data[i] = static_cast<uint8>(i);
-  }
-  data.Append(raw_data, 64);
-  EXPECT_EQ(64u, data.size());
-  EXPECT_LE(64u, data.capacity());
-
-  for (int i = 0; i < 64; ++i) {
-    EXPECT_EQ(raw_data[i], data.data()[i]);
-  }
-}
-
-TEST(XhrResponseData, Reserve) {
-  XhrResponseData data;
-  data.Reserve(1);
-  EXPECT_LE(1u, data.capacity());
-  EXPECT_EQ(0u, data.size());
-  EXPECT_TRUE(data.data() != NULL);
-}
-
-}  // namespace
-}  // namespace xhr
-}  // namespace cobalt
diff --git a/src/components/update_client/component.cc b/src/components/update_client/component.cc
index 50ec274..9be0c39 100644
--- a/src/components/update_client/component.cc
+++ b/src/components/update_client/component.cc
@@ -559,6 +559,12 @@
   DCHECK(thread_checker_.CalledOnValidThread());
 
   auto& component = State::component();
+
+#if defined(OS_STARBOARD)
+  auto& config = component.update_context_.config;
+  config->SetPreviousUpdaterStatus(config->GetUpdaterStatus());
+#endif
+
   if (component.crx_component()) {
     TransitionState(std::make_unique<StateChecking>(&component));
   } else {
diff --git a/src/components/update_client/configurator.h b/src/components/update_client/configurator.h
index ab7e01e..64d931a 100644
--- a/src/components/update_client/configurator.h
+++ b/src/components/update_client/configurator.h
@@ -171,6 +171,11 @@
   // parameters.
   virtual void SetChannel(const std::string& channel) = 0;
 
+  virtual std::string GetPreviousUpdaterStatus() const = 0;
+  virtual void SetPreviousUpdaterStatus(const std::string& status) = 0;
+
+  virtual std::string GetUpdaterStatus() const = 0;
+
   // Compare and swap the is_channel_changed flag.
   virtual void CompareAndSwapChannelChanged(int old_value, int new_value) = 0;
 
diff --git a/src/starboard/android/apk/app/build.gradle b/src/starboard/android/apk/app/build.gradle
index 5ab0feb..8e527e2 100644
--- a/src/starboard/android/apk/app/build.gradle
+++ b/src/starboard/android/apk/app/build.gradle
@@ -105,8 +105,6 @@
             signingConfig signingConfigs.debugConfig
         }
         qa {
-            debuggable true
-            jniDebuggable true
             externalNativeBuild {
                 cmake.arguments "-DCOBALT_CONFIG=qa"
             }
diff --git a/src/starboard/android/apk/app/src/main/java/dev/cobalt/coat/CobaltActivity.java b/src/starboard/android/apk/app/src/main/java/dev/cobalt/coat/CobaltActivity.java
index 9a609c0..cb9948d 100644
--- a/src/starboard/android/apk/app/src/main/java/dev/cobalt/coat/CobaltActivity.java
+++ b/src/starboard/android/apk/app/src/main/java/dev/cobalt/coat/CobaltActivity.java
@@ -27,6 +27,7 @@
 import android.view.ViewGroup.LayoutParams;
 import android.view.ViewParent;
 import android.widget.FrameLayout;
+import dev.cobalt.media.MediaCodecUtil;
 import dev.cobalt.media.VideoSurfaceView;
 import dev.cobalt.util.Log;
 import dev.cobalt.util.UsedByNative;
@@ -45,7 +46,9 @@
   private static final java.lang.String META_DATA_APP_URL = "cobalt.APP_URL";
 
   private static final String SPLASH_URL_ARG = "--fallback_splash_screen_url=";
+  private static final String SPLASH_TOPICS_ARG = "--fallback_splash_screen_topics=";
   private static final java.lang.String META_DATA_SPLASH_URL = "cobalt.SPLASH_URL";
+  private static final java.lang.String META_DATA_SPLASH_TOPICS = "cobalt.SPLASH_TOPIC";
 
   private static final String FORCE_MIGRATION_FOR_STORAGE_PARTITIONING =
       "--force_migration_for_storage_partitioning";
@@ -107,6 +110,9 @@
 
   @Override
   protected void onStart() {
+    if (!isReleaseBuild()) {
+      MediaCodecUtil.dumpAllDecoders();
+    }
     if (forceCreateNewVideoSurfaceView) {
       Log.w(TAG, "Force to create a new video surface.");
       createNewSurfaceView();
@@ -172,7 +178,9 @@
     boolean hasUrlArg = hasArg(args, URL_ARG);
     // If the splash screen url arg isn't specified, get it from AndroidManifest.xml.
     boolean hasSplashUrlArg = hasArg(args, SPLASH_URL_ARG);
-    if (!hasUrlArg || !hasSplashUrlArg) {
+    // If the splash screen topics arg isn't specified, get it from AndroidManifest.xml.
+    boolean hasSplashTopicsArg = hasArg(args, SPLASH_TOPICS_ARG);
+    if (!hasUrlArg || !hasSplashUrlArg || !hasSplashTopicsArg) {
       try {
         ActivityInfo ai =
             getPackageManager()
@@ -190,6 +198,12 @@
               args.add(SPLASH_URL_ARG + splashUrl);
             }
           }
+          if (!hasSplashTopicsArg) {
+            String splashTopics = ai.metaData.getString(META_DATA_SPLASH_TOPICS);
+            if (splashTopics != null) {
+              args.add(SPLASH_TOPICS_ARG + splashTopics);
+            }
+          }
           if (ai.metaData.getBoolean(META_FORCE_MIGRATION_FOR_STORAGE_PARTITIONING)) {
             args.add(FORCE_MIGRATION_FOR_STORAGE_PARTITIONING);
           }
diff --git a/src/starboard/android/apk/app/src/main/java/dev/cobalt/coat/VoiceRecognizer.java b/src/starboard/android/apk/app/src/main/java/dev/cobalt/coat/VoiceRecognizer.java
index 06cc02f..799aef9 100644
--- a/src/starboard/android/apk/app/src/main/java/dev/cobalt/coat/VoiceRecognizer.java
+++ b/src/starboard/android/apk/app/src/main/java/dev/cobalt/coat/VoiceRecognizer.java
@@ -122,7 +122,8 @@
     this.nativeSpeechRecognizerImpl = nativeSpeechRecognizer;
 
     if (this.audioPermissionRequester.requestRecordAudioPermission(
-        this.nativeSpeechRecognizerImpl)) {
+        this.nativeSpeechRecognizerImpl) &&
+        SpeechRecognizer.isRecognitionAvailable(context)) {
       startRecognitionInternal();
     } else {
       mainHandler.post(
diff --git a/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioOutputManager.java b/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioOutputManager.java
index 554d8d5..b80fa03 100644
--- a/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioOutputManager.java
+++ b/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioOutputManager.java
@@ -48,9 +48,18 @@
   @SuppressWarnings("unused")
   @UsedByNative
   AudioTrackBridge createAudioTrackBridge(
-      int sampleType, int sampleRate, int channelCount, int preferredBufferSizeInBytes) {
+      int sampleType,
+      int sampleRate,
+      int channelCount,
+      int preferredBufferSizeInBytes,
+      int tunnelModeAudioSessionId) {
     AudioTrackBridge audioTrackBridge =
-        new AudioTrackBridge(sampleType, sampleRate, channelCount, preferredBufferSizeInBytes);
+        new AudioTrackBridge(
+            sampleType,
+            sampleRate,
+            channelCount,
+            preferredBufferSizeInBytes,
+            tunnelModeAudioSessionId);
     if (!audioTrackBridge.isAudioTrackValid()) {
       Log.e(TAG, "AudioTrackBridge has invalid audio track");
       return null;
@@ -128,4 +137,29 @@
     }
     return AudioTrack.getMinBufferSize(sampleRate, channelConfig, sampleType);
   }
+
+  /** Generate audio session id used by tunneled playback. */
+  @SuppressWarnings("unused")
+  @UsedByNative
+  int generateTunnelModeAudioSessionId(int numberOfChannels) {
+    // Android 9.0 (Build.VERSION.SDK_INT >= 28) support v2 sync header that
+    // aligns sync header with audio frame size. V1 sync header has alignment
+    // issues for multi-channel audio.
+    if (Build.VERSION.SDK_INT < 28) {
+      // Currently we only support int16 under tunnel mode.
+      final int sampleSizeInBytes = 2;
+      final int frameSizeInBytes = sampleSizeInBytes * numberOfChannels;
+      if (AudioTrackBridge.AV_SYNC_HEADER_V1_SIZE % frameSizeInBytes != 0) {
+        Log.w(
+            TAG,
+            String.format(
+                "Disable tunnel mode due to sampleSizeInBytes (%d) * numberOfChannels (%d) isn't"
+                    + " aligned to AV_SYNC_HEADER_V1_SIZE (%d).",
+                sampleSizeInBytes, numberOfChannels, AudioTrackBridge.AV_SYNC_HEADER_V1_SIZE));
+        return -1;
+      }
+    }
+    AudioManager audioManager = (AudioManager) context.getSystemService(Context.AUDIO_SERVICE);
+    return audioManager.generateAudioSessionId();
+  }
 }
diff --git a/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java b/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java
index 419f5d8..b8d5a53 100644
--- a/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java
+++ b/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/AudioTrackBridge.java
@@ -26,18 +26,45 @@
 import dev.cobalt.util.Log;
 import dev.cobalt.util.UsedByNative;
 import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
 
-// A wrapper of the android AudioTrack class.
-// Android AudioTrack would not start playing until the buffer is fully
-// filled once.
+/**
+ * A wrapper of the android AudioTrack class. Android AudioTrack would not start playing until the
+ * buffer is fully filled once.
+ */
 @UsedByNative
 public class AudioTrackBridge {
+  // Also used by AudioOutputManager.
+  static final int AV_SYNC_HEADER_V1_SIZE = 16;
+
   private AudioTrack audioTrack;
   private AudioTimestamp audioTimestamp = new AudioTimestamp();
   private long maxFramePositionSoFar = 0;
 
+  private final boolean tunnelModeEnabled;
+  // The following variables are used only when |tunnelModeEnabled| is true.
+  private ByteBuffer avSyncHeader;
+  private int avSyncPacketBytesRemaining;
+
+  private static int getBytesPerSample(int audioFormat) {
+    switch (audioFormat) {
+      case AudioFormat.ENCODING_PCM_16BIT:
+        return 2;
+      case AudioFormat.ENCODING_PCM_FLOAT:
+        return 4;
+      case AudioFormat.ENCODING_INVALID:
+      default:
+        throw new RuntimeException("Unsupport audio format " + audioFormat);
+    }
+  }
+
   public AudioTrackBridge(
-      int sampleType, int sampleRate, int channelCount, int preferredBufferSizeInBytes) {
+      int sampleType,
+      int sampleRate,
+      int channelCount,
+      int preferredBufferSizeInBytes,
+      int tunnelModeAudioSessionId) {
+    tunnelModeEnabled = tunnelModeAudioSessionId != -1;
     int channelConfig;
     switch (channelCount) {
       case 1:
@@ -53,11 +80,40 @@
         throw new RuntimeException("Unsupported channel count: " + channelCount);
     }
 
-    AudioAttributes attributes =
-        new AudioAttributes.Builder()
-            .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
-            .setUsage(AudioAttributes.USAGE_MEDIA)
-            .build();
+    AudioAttributes attributes;
+    if (tunnelModeEnabled) {
+      // Android 9.0 (Build.VERSION.SDK_INT >= 28) support v2 sync header that aligns sync header
+      // with audio frame size. V1 sync header has alignment issues for multi-channel audio.
+      if (Build.VERSION.SDK_INT < 28) {
+        int frameSize = getBytesPerSample(sampleType) * channelCount;
+        // This shouldn't happen as it should have been checked in
+        // AudioOutputManager.generateTunnelModeAudioSessionId().
+        if (AV_SYNC_HEADER_V1_SIZE % frameSize != 0) {
+          audioTrack = null;
+          String errorMessage =
+              String.format(
+                  "Enable tunnel mode when frame size is unaligned, "
+                      + "sampleType: %d, channel: %d, sync header size: %d.",
+                  sampleType, channelCount, AV_SYNC_HEADER_V1_SIZE);
+          Log.e(TAG, errorMessage);
+          throw new RuntimeException(errorMessage);
+        }
+      }
+      attributes =
+          new AudioAttributes.Builder()
+              .setContentType(AudioAttributes.CONTENT_TYPE_MOVIE)
+              .setFlags(AudioAttributes.FLAG_HW_AV_SYNC)
+              .setUsage(AudioAttributes.USAGE_MEDIA)
+              .build();
+    } else {
+      // TODO: Investigate if we can use |CONTENT_TYPE_MOVIE| for AudioTrack
+      //       used by video playback.
+      attributes =
+          new AudioAttributes.Builder()
+              .setContentType(AudioAttributes.CONTENT_TYPE_MUSIC)
+              .setUsage(AudioAttributes.USAGE_MEDIA)
+              .build();
+    }
     AudioFormat format =
         new AudioFormat.Builder()
             .setEncoding(sampleType)
@@ -66,6 +122,10 @@
             .build();
 
     int audioTrackBufferSize = preferredBufferSizeInBytes;
+    // TODO: Investigate if this implementation could be refined.
+    // It is not necessary to loop until 0 since there is new implementation based on
+    // AudioTrack.getMinBufferSize(). Especially for tunnel mode, it would fail if audio HAL does
+    // not support tunnel mode and then it is not helpful to retry.
     while (audioTrackBufferSize > 0) {
       try {
         audioTrack =
@@ -74,7 +134,9 @@
                 format,
                 audioTrackBufferSize,
                 AudioTrack.MODE_STREAM,
-                AudioManager.AUDIO_SESSION_ID_GENERATE);
+                tunnelModeEnabled
+                    ? tunnelModeAudioSessionId
+                    : AudioManager.AUDIO_SESSION_ID_GENERATE);
       } catch (Exception e) {
         audioTrack = null;
       }
@@ -104,6 +166,8 @@
       audioTrack.release();
     }
     audioTrack = null;
+    avSyncHeader = null;
+    avSyncPacketBytesRemaining = 0;
   }
 
   @SuppressWarnings("unused")
@@ -144,15 +208,22 @@
       return;
     }
     audioTrack.flush();
+    avSyncHeader = null;
+    avSyncPacketBytesRemaining = 0;
   }
 
   @SuppressWarnings("unused")
   @UsedByNative
-  private int write(byte[] audioData, int sizeInBytes) {
+  private int write(byte[] audioData, int sizeInBytes, long presentationTimeInMicroseconds) {
     if (audioTrack == null) {
       Log.e(TAG, "Unable to write with NULL audio track.");
       return 0;
     }
+
+    if (tunnelModeEnabled) {
+      return writeWithAvSync(audioData, sizeInBytes, presentationTimeInMicroseconds);
+    }
+
     if (Build.VERSION.SDK_INT >= 23) {
       return audioTrack.write(audioData, 0, sizeInBytes, AudioTrack.WRITE_NON_BLOCKING);
     } else {
@@ -161,6 +232,66 @@
     }
   }
 
+  private int writeWithAvSync(
+      byte[] audioData, int sizeInBytes, long presentationTimeInMicroseconds) {
+    if (audioTrack == null) {
+      throw new RuntimeException("writeWithAvSync() is called when audioTrack is null.");
+    }
+
+    if (!tunnelModeEnabled) {
+      throw new RuntimeException("writeWithAvSync() is called when tunnelModeEnabled is false.");
+    }
+
+    long presentationTimeInNanoseconds = presentationTimeInMicroseconds * 1000;
+
+    // Android support tunnel mode from 5.0 (API level 21), but the app has to manually write the
+    // sync header before API 23, where the write() function with presentation timestamp is
+    // introduced.
+    // Set the following constant to |false| to test manual sync header writing in API level 23 or
+    // later.  Note that the code to write sync header manually only supports v1 sync header.
+    final boolean useAutoSyncHeaderWrite = false;
+    if (useAutoSyncHeaderWrite && Build.VERSION.SDK_INT >= 23) {
+      ByteBuffer byteBuffer = ByteBuffer.wrap(audioData);
+      return audioTrack.write(
+          byteBuffer, sizeInBytes, AudioTrack.WRITE_NON_BLOCKING, presentationTimeInNanoseconds);
+    }
+
+    if (avSyncHeader == null) {
+      avSyncHeader = ByteBuffer.allocate(AV_SYNC_HEADER_V1_SIZE);
+      avSyncHeader.order(ByteOrder.BIG_ENDIAN);
+      avSyncHeader.putInt(0x55550001);
+    }
+
+    if (avSyncPacketBytesRemaining == 0) {
+      avSyncHeader.putInt(4, sizeInBytes);
+      avSyncHeader.putLong(8, presentationTimeInNanoseconds);
+      avSyncHeader.position(0);
+      avSyncPacketBytesRemaining = sizeInBytes;
+    }
+
+    if (avSyncHeader.remaining() > 0) {
+      int ret =
+          audioTrack.write(avSyncHeader, avSyncHeader.remaining(), AudioTrack.WRITE_NON_BLOCKING);
+      if (ret < 0) {
+        avSyncPacketBytesRemaining = 0;
+        return ret;
+      }
+      if (avSyncHeader.remaining() > 0) {
+        return 0;
+      }
+    }
+
+    int sizeToWrite = Math.min(avSyncPacketBytesRemaining, sizeInBytes);
+    ByteBuffer byteBuffer = ByteBuffer.wrap(audioData);
+    int ret = audioTrack.write(byteBuffer, sizeToWrite, AudioTrack.WRITE_NON_BLOCKING);
+    if (ret < 0) {
+      avSyncPacketBytesRemaining = 0;
+      return ret;
+    }
+    avSyncPacketBytesRemaining -= ret;
+    return ret;
+  }
+
   @SuppressWarnings("unused")
   @UsedByNative
   private int write(float[] audioData, int sizeInFloats) {
@@ -168,6 +299,9 @@
       Log.e(TAG, "Unable to write with NULL audio track.");
       return 0;
     }
+    if (tunnelModeEnabled) {
+      throw new RuntimeException("Float sample is not supported under tunnel mode.");
+    }
     return audioTrack.write(audioData, 0, sizeInFloats, AudioTrack.WRITE_NON_BLOCKING);
   }
 
diff --git a/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java b/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
index faa8742..d0585e9 100644
--- a/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
+++ b/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecBridge.java
@@ -592,8 +592,25 @@
       mediaFormat.setByteBuffer(MediaFormat.KEY_HDR_STATIC_INFO, colorInfo.hdrStaticInfo);
     }
 
-    int maxWidth = findVideoDecoderResult.videoCapabilities.getSupportedWidths().getUpper();
-    int maxHeight = findVideoDecoderResult.videoCapabilities.getSupportedHeights().getUpper();
+    VideoCapabilities videoCapabilities = findVideoDecoderResult.videoCapabilities;
+    int maxWidth = videoCapabilities.getSupportedWidths().getUpper();
+    int maxHeight = videoCapabilities.getSupportedHeights().getUpper();
+    if (!videoCapabilities.isSizeSupported(maxWidth, maxHeight)) {
+      if (maxHeight >= 4320 && videoCapabilities.isSizeSupported(7680, 4320)) {
+        maxWidth = 7680;
+        maxHeight = 4320;
+      } else if (maxHeight >= 2160 && videoCapabilities.isSizeSupported(3840, 2160)) {
+        maxWidth = 3840;
+        maxHeight = 2160;
+      } else if (maxHeight >= 1080 && videoCapabilities.isSizeSupported(1920, 1080)) {
+        maxWidth = 1920;
+        maxHeight = 1080;
+      } else {
+        Log.e(TAG, "Failed to find a compatible resolution");
+        maxWidth = 1920;
+        maxHeight = 1080;
+      }
+    }
     if (!bridge.configureVideo(
         mediaFormat,
         surface,
@@ -915,8 +932,9 @@
         // adapt up to 8k at any point. We thus request 8k buffers up front,
         // unless the decoder claims to not be able to do 8k, in which case
         // we're ok, since we would've rejected a 8k stream when canPlayType
-        // was called, and then use those decoder values instead.
-        if (Build.VERSION.SDK_INT > 22) {
+        // was called, and then use those decoder values instead. We only
+        // support 8k for API level 29 and above.
+        if (Build.VERSION.SDK_INT > 28) {
           format.setInteger(MediaFormat.KEY_MAX_WIDTH, Math.min(7680, maxSupportedWidth));
           format.setInteger(MediaFormat.KEY_MAX_HEIGHT, Math.min(4320, maxSupportedHeight));
         } else {
diff --git a/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java b/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
index 40fcde0..03fb7cc 100644
--- a/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
+++ b/src/starboard/android/apk/app/src/main/java/dev/cobalt/media/MediaCodecUtil.java
@@ -573,21 +573,33 @@
         }
 
         VideoCapabilities videoCapabilities = codecCapabilities.getVideoCapabilities();
-        if (frameWidth != 0 && !videoCapabilities.getSupportedWidths().contains(frameWidth)) {
-          Log.v(
-              TAG,
-              String.format(
-                  "Rejecting %s, reason: supported widths %s does not contain %d",
-                  name, videoCapabilities.getSupportedWidths().toString(), frameWidth));
-          continue;
-        }
-        if (frameHeight != 0 && !videoCapabilities.getSupportedHeights().contains(frameHeight)) {
-          Log.v(
-              TAG,
-              String.format(
-                  "Rejecting %s, reason: supported heights %s does not contain %d",
-                  name, videoCapabilities.getSupportedHeights().toString(), frameHeight));
-          continue;
+        if (frameWidth != 0 && frameHeight != 0) {
+          if (!videoCapabilities.isSizeSupported(frameWidth, frameHeight)) {
+            Log.v(
+                TAG,
+                String.format(
+                    "Rejecting %s, reason: width %s is not compatible with height %d",
+                    name, frameWidth, frameHeight));
+            continue;
+          }
+        } else if (frameWidth != 0) {
+          if (!videoCapabilities.getSupportedWidths().contains(frameWidth)) {
+            Log.v(
+                TAG,
+                String.format(
+                    "Rejecting %s, reason: supported widths %s does not contain %d",
+                    name, videoCapabilities.getSupportedWidths().toString(), frameWidth));
+            continue;
+          }
+        } else if (frameHeight != 0) {
+          if (!videoCapabilities.getSupportedHeights().contains(frameHeight)) {
+            Log.v(
+                TAG,
+                String.format(
+                    "Rejecting %s, reason: supported heights %s does not contain %d",
+                    name, videoCapabilities.getSupportedHeights().toString(), frameHeight));
+            continue;
+          }
         }
         if (bitrate != 0 && !videoCapabilities.getBitrateRange().contains(bitrate)) {
           Log.v(
@@ -597,13 +609,31 @@
                   name, videoCapabilities.getBitrateRange().toString(), bitrate));
           continue;
         }
-        if (fps != 0 && !videoCapabilities.getSupportedFrameRates().contains(fps)) {
-          Log.v(
-              TAG,
-              String.format(
-                  "Rejecting %s, reason: supported frame rates %s does not contain %d",
-                  name, videoCapabilities.getSupportedFrameRates().toString(), fps));
-          continue;
+        if (fps != 0) {
+          if (frameHeight != 0 && frameWidth != 0) {
+            if (!videoCapabilities.areSizeAndRateSupported(frameWidth, frameHeight, fps)) {
+              Log.v(
+                  TAG,
+                  String.format(
+                      "Rejecting %s, reason: supported frame rates %s does not contain %d",
+                      name,
+                      videoCapabilities
+                          .getSupportedFrameRatesFor(frameWidth, frameHeight)
+                          .toString(),
+                      fps));
+              continue;
+            }
+          } else {
+            // At least one of frameHeight or frameWidth is 0
+            if (!videoCapabilities.getSupportedFrameRates().contains(fps)) {
+              Log.v(
+                  TAG,
+                  String.format(
+                      "Rejecting %s, reason: supported frame rates %s does not contain %d",
+                      name, videoCapabilities.getSupportedFrameRates().toString(), fps));
+              continue;
+            }
+          }
         }
         String resultName =
             (secure && !name.endsWith(SECURE_DECODER_SUFFIX))
@@ -652,52 +682,69 @@
    * Debug utility function that can be locally added to dump information about all decoders on a
    * particular system.
    */
-  @SuppressWarnings("unused")
-  private static void dumpAllDecoders() {
+  public static void dumpAllDecoders() {
+    String decoderDumpString = "";
     for (MediaCodecInfo info : new MediaCodecList(MediaCodecList.ALL_CODECS).getCodecInfos()) {
       if (info.isEncoder()) {
         continue;
       }
       for (String supportedType : info.getSupportedTypes()) {
         String name = info.getName();
-        CodecCapabilities codecCapabilities = info.getCapabilitiesForType(supportedType);
-        Log.v(TAG, "==================================================");
-        Log.v(TAG, String.format("name: %s", name));
-        Log.v(TAG, String.format("supportedType: %s", supportedType));
-        Log.v(
-            TAG, String.format("codecBlackList.contains(name): %b", codecBlackList.contains(name)));
-        Log.v(
-            TAG,
+        decoderDumpString +=
             String.format(
-                "FEATURE_SecurePlayback: %b",
-                codecCapabilities.isFeatureSupported(
-                    MediaCodecInfo.CodecCapabilities.FEATURE_SecurePlayback)));
+                "name: %s (%s, %s):",
+                name,
+                supportedType,
+                codecBlackList.contains(name) ? "blacklisted" : "not blacklisted");
+        CodecCapabilities codecCapabilities = info.getCapabilitiesForType(supportedType);
         VideoCapabilities videoCapabilities = codecCapabilities.getVideoCapabilities();
         if (videoCapabilities != null) {
-          Log.v(
-              TAG,
+          decoderDumpString +=
               String.format(
-                  "videoCapabilities.getSupportedWidths(): %s",
-                  videoCapabilities.getSupportedWidths().toString()));
-          Log.v(
-              TAG,
-              String.format(
-                  "videoCapabilities.getSupportedHeights(): %s",
-                  videoCapabilities.getSupportedHeights().toString()));
-          Log.v(
-              TAG,
-              String.format(
-                  "videoCapabilities.getBitrateRange(): %s",
-                  videoCapabilities.getBitrateRange().toString()));
-          Log.v(
-              TAG,
-              String.format(
-                  "videoCapabilities.getSupportedFrameRates(): %s",
-                  videoCapabilities.getSupportedFrameRates().toString()));
+                  "\n\t\t"
+                      + "widths: %s, "
+                      + "heights: %s, "
+                      + "bitrates: %s, "
+                      + "framerates: %s, ",
+                  videoCapabilities.getSupportedWidths().toString(),
+                  videoCapabilities.getSupportedHeights().toString(),
+                  videoCapabilities.getBitrateRange().toString(),
+                  videoCapabilities.getSupportedFrameRates().toString());
         }
-        Log.v(TAG, "==================================================");
-        Log.v(TAG, "");
+        boolean adaptivePlayback =
+            codecCapabilities.isFeatureSupported(
+                MediaCodecInfo.CodecCapabilities.FEATURE_AdaptivePlayback);
+        boolean securePlayback =
+            codecCapabilities.isFeatureSupported(
+                MediaCodecInfo.CodecCapabilities.FEATURE_SecurePlayback);
+        boolean tunneledPlayback =
+            codecCapabilities.isFeatureSupported(
+                MediaCodecInfo.CodecCapabilities.FEATURE_TunneledPlayback);
+        if (adaptivePlayback || securePlayback || tunneledPlayback) {
+          decoderDumpString +=
+              String.format(
+                  "(%s%s%s",
+                  adaptivePlayback ? "AdaptivePlayback, " : "",
+                  securePlayback ? "SecurePlayback, " : "",
+                  tunneledPlayback ? "TunneledPlayback, " : "");
+          // Remove trailing space and comma
+          decoderDumpString = decoderDumpString.substring(0, decoderDumpString.length() - 2);
+          decoderDumpString += ")";
+        } else {
+          decoderDumpString += " No extra features supported";
+        }
+        decoderDumpString += "\n";
       }
     }
+    Log.v(
+        TAG,
+        String.format(
+            " \n"
+                + "==================================================\n"
+                + "Full list of decoder features: [AdaptivePlayback, SecurePlayback,"
+                + " TunneledPlayback]\n"
+                + "Unsupported features for each codec are not listed\n"
+                + decoderDumpString
+                + "=================================================="));
   }
 }
diff --git a/src/starboard/android/shared/audio_sink_min_required_frames_tester.cc b/src/starboard/android/shared/audio_sink_min_required_frames_tester.cc
index a5a77a7..88f3762 100644
--- a/src/starboard/android/shared/audio_sink_min_required_frames_tester.cc
+++ b/src/starboard/android/shared/audio_sink_min_required_frames_tester.cc
@@ -123,7 +123,8 @@
         min_required_frames_ * task.number_of_channels *
             GetSampleSize(task.sample_type),
         &MinRequiredFramesTester::UpdateSourceStatusFunc,
-        &MinRequiredFramesTester::ConsumeFramesFunc, this);
+        &MinRequiredFramesTester::ConsumeFramesFunc,
+        &MinRequiredFramesTester::ErrorFunc, 0, -1, this);
     {
       ScopedLock scoped_lock(mutex_);
       wait_timeout = !condition_variable_.WaitTimed(kSbTimeSecond * 5);
@@ -174,6 +175,14 @@
   tester->ConsumeFrames(frames_consumed);
 }
 
+// static
+void MinRequiredFramesTester::ErrorFunc(bool capability_changed,
+                                        void* context) {
+  // TODO: Handle errors during minimum frames test, maybe by terminating the
+  //       test earlier.
+  SB_NOTREACHED();
+}
+
 void MinRequiredFramesTester::UpdateSourceStatus(int* frames_in_buffer,
                                                  int* offset_in_frames,
                                                  bool* is_playing,
diff --git a/src/starboard/android/shared/audio_sink_min_required_frames_tester.h b/src/starboard/android/shared/audio_sink_min_required_frames_tester.h
index 290011d..e689e96 100644
--- a/src/starboard/android/shared/audio_sink_min_required_frames_tester.h
+++ b/src/starboard/android/shared/audio_sink_min_required_frames_tester.h
@@ -85,6 +85,7 @@
   static void ConsumeFramesFunc(int frames_consumed,
                                 SbTime frames_consumed_at,
                                 void* context);
+  static void ErrorFunc(bool capability_changed, void* context);
   void UpdateSourceStatus(int* frames_in_buffer,
                           int* offset_in_frames,
                           bool* is_playing,
diff --git a/src/starboard/android/shared/audio_track_audio_sink_type.cc b/src/starboard/android/shared/audio_track_audio_sink_type.cc
index 44dffc8..cf9d744 100644
--- a/src/starboard/android/shared/audio_track_audio_sink_type.cc
+++ b/src/starboard/android/shared/audio_track_audio_sink_type.cc
@@ -29,11 +29,23 @@
 namespace shared {
 namespace {
 
+// The same as AudioTrack.ERROR_DEAD_OBJECT.
+const int kAudioTrackErrorDeadObject = -6;
+
 // The maximum number of frames that can be written to android audio track per
 // write request. If we don't set this cap for writing frames to audio track,
 // we will repeatedly allocate a large byte array which cannot be consumed by
 // audio track completely.
 const int kMaxFramesPerRequest = 65536;
+
+// Most Android audio HAL updates audio time for A/V synchronization on audio
+// sync frames. For example, audio HAL may try to render when it gets an entire
+// sync frame and then update audio time. Shorter duration of sync frame
+// improves the accuracy of audio time, especially at the beginning of a
+// playback, as otherwise the audio time during the initial update may be too
+// large (non zero) and results in dropped video frames.
+const SbTime kMaxDurationPerRequestInTunnelMode = 16 * kSbTimeMillisecond;
+
 const jint kNoOffset = 0;
 const size_t kSilenceFramesPerAppend = 1024;
 
@@ -74,6 +86,12 @@
   return static_cast<uint8_t*>(pointer) + offset;
 }
 
+int GetMaxFramesPerRequestForTunnelMode(int sampling_frequency_hz) {
+  auto max_frames = kMaxDurationPerRequestInTunnelMode * sampling_frequency_hz /
+                    kSbTimeSecond;
+  return (max_frames + 15) / 16 * 16;  // align to 16
+}
+
 }  // namespace
 
 AudioTrackAudioSink::AudioTrackAudioSink(
@@ -86,6 +104,9 @@
     int preferred_buffer_size_in_bytes,
     SbAudioSinkUpdateSourceStatusFunc update_source_status_func,
     ConsumeFramesFunc consume_frames_func,
+    SbAudioSinkPrivate::ErrorFunc error_func,
+    SbTime start_time,
+    int tunnel_mode_audio_session_id,
     void* context)
     : type_(type),
       channels_(channels),
@@ -95,40 +116,56 @@
       frames_per_channel_(frames_per_channel),
       update_source_status_func_(update_source_status_func),
       consume_frames_func_(consume_frames_func),
-      context_(context),
-      last_playback_head_position_(0),
-      j_audio_track_bridge_(NULL),
-      j_audio_data_(NULL),
-      quit_(false),
-      audio_out_thread_(kSbThreadInvalid),
-      playback_rate_(1.0f),
-      written_frames_(0) {
+      error_func_(error_func),
+      start_time_(start_time),
+      tunnel_mode_audio_session_id_(tunnel_mode_audio_session_id),
+      max_frames_per_request_(
+          tunnel_mode_audio_session_id_ == -1
+              ? kMaxFramesPerRequest
+              : GetMaxFramesPerRequestForTunnelMode(sampling_frequency_hz_)),
+      context_(context) {
   SB_DCHECK(update_source_status_func_);
   SB_DCHECK(consume_frames_func_);
   SB_DCHECK(frame_buffer_);
   SB_DCHECK(SbAudioSinkIsAudioSampleTypeSupported(sample_type));
 
+  // TODO: Support query if platform supports float type for tunnel mode.
+  if (tunnel_mode_audio_session_id_ != -1) {
+    SB_DCHECK(sample_type_ == kSbMediaAudioSampleTypeInt16Deprecated);
+  }
+
+  SB_LOG(INFO) << "Creating audio sink starts at " << start_time_;
+
   JniEnvExt* env = JniEnvExt::Get();
   ScopedLocalJavaRef<jobject> j_audio_output_manager(
       env->CallStarboardObjectMethodOrAbort(
           "getAudioOutputManager", "()Ldev/cobalt/media/AudioOutputManager;"));
   jobject j_audio_track_bridge = env->CallObjectMethodOrAbort(
       j_audio_output_manager.Get(), "createAudioTrackBridge",
-      "(IIII)Ldev/cobalt/media/AudioTrackBridge;",
+      "(IIIII)Ldev/cobalt/media/AudioTrackBridge;",
       GetAudioFormatSampleType(sample_type_), sampling_frequency_hz_, channels_,
-      preferred_buffer_size_in_bytes);
+      preferred_buffer_size_in_bytes, tunnel_mode_audio_session_id_);
   if (!j_audio_track_bridge) {
+    // One of the cases that this may hit is when output happened to be switched
+    // to a device that doesn't support tunnel mode.
+    // TODO: Find a way to exclude the device from tunnel mode playback, to
+    //       avoid infinite loop in creating the audio sink on a device
+    //       claims to support tunnel mode but fails to create the audio sink.
+    // TODO: Currently this will be reported as a general decode error,
+    //       investigate if this can be reported as a capability changed error.
     return;
   }
   j_audio_track_bridge_ = env->ConvertLocalRefToGlobalRef(j_audio_track_bridge);
   if (sample_type_ == kSbMediaAudioSampleTypeFloat32) {
-    j_audio_data_ = env->NewFloatArray(channels_ * kMaxFramesPerRequest);
+    j_audio_data_ = env->NewFloatArray(channels_ * max_frames_per_request_);
   } else if (sample_type_ == kSbMediaAudioSampleTypeInt16Deprecated) {
     j_audio_data_ = env->NewByteArray(channels_ * GetSampleSize(sample_type_) *
-                                      kMaxFramesPerRequest);
+                                      max_frames_per_request_);
   } else {
     SB_NOTREACHED();
   }
+  SB_CHECK(j_audio_data_) << "Failed to allocate |j_audio_data_|";
+
   j_audio_data_ = env->ConvertLocalRefToGlobalRef(j_audio_data_);
 
   audio_out_thread_ = SbThreadCreate(
@@ -183,15 +220,21 @@
   return NULL;
 }
 
+// TODO: Break down the function into manageable pieces.
 void AudioTrackAudioSink::AudioThreadFunc() {
   JniEnvExt* env = JniEnvExt::Get();
   bool was_playing = false;
 
   SB_LOG(INFO) << "AudioTrackAudioSink thread started.";
 
-#if defined(SB_PLAYER_FILTER_ENABLE_STATE_CHECK)
+  int accumulated_written_frames = 0;
+  // TODO: |last_playback_head_changed_at| is also resetted when a warning is
+  //       logged after the playback head position hasn't been updated for a
+  //       while.  We should refine the name to make it better reflect its
+  //       usage.
   SbTime last_playback_head_changed_at = -1;
-#endif  // defined(SB_PLAYER_FILTER_ENABLE_STATE_CHECK)
+  SbTime playback_head_not_changed_duration = 0;
+  SbTime last_written_succeeded_at = -1;
 
   while (!quit_) {
     int playback_head_position = 0;
@@ -214,12 +257,15 @@
           std::max(playback_head_position, last_playback_head_position_);
       int frames_consumed =
           playback_head_position - last_playback_head_position_;
+      SbTime now = SbTimeGetMonotonicNow();
 
-#if defined(SB_PLAYER_FILTER_ENABLE_STATE_CHECK)
+      if (last_playback_head_changed_at == -1) {
+        last_playback_head_changed_at = now;
+      }
       if (last_playback_head_position_ == playback_head_position) {
-        auto now = SbTimeGetMonotonicNow();
         SbTime elapsed = now - last_playback_head_changed_at;
-        if (was_playing && elapsed > 5 * kSbTimeSecond) {
+        if (elapsed > 5 * kSbTimeSecond) {
+          playback_head_not_changed_duration += elapsed;
           last_playback_head_changed_at = now;
           SB_LOG(INFO) << "last playback head position is "
                        << last_playback_head_position_
@@ -227,9 +273,9 @@
                        << " microseconds.";
         }
       } else {
-        last_playback_head_changed_at = SbTimeGetMonotonicNow();
+        last_playback_head_changed_at = now;
+        playback_head_not_changed_duration = 0;
       }
-#endif  // defined(SB_PLAYER_FILTER_ENABLE_STATE_CHECK)
 
       last_playback_head_position_ = playback_head_position;
       frames_consumed = std::min(frames_consumed, written_frames_);
@@ -260,6 +306,9 @@
       SB_LOG(INFO) << "AudioTrackAudioSink paused.";
     } else if (!was_playing && is_playing) {
       was_playing = true;
+      last_playback_head_changed_at = -1;
+      playback_head_not_changed_duration = 0;
+      last_written_succeeded_at = -1;
       env->CallVoidMethodOrAbort(j_audio_track_bridge_, "play", "()V");
       SB_LOG(INFO) << "AudioTrackAudioSink playing.";
     }
@@ -281,7 +330,7 @@
     }
 
     expected_written_frames =
-        std::min(expected_written_frames, kMaxFramesPerRequest);
+        std::min(expected_written_frames, max_frames_per_request_);
     if (expected_written_frames == 0) {
       // It is possible that all the frames in buffer are written to the
       // soundcard, but those are not being consumed. If eos is reached,
@@ -292,24 +341,84 @@
         // Currently AudioDevice and AudioRenderer will write tail silence.
         // It should be reached only in tests. It's not ideal to allocate
         // a new silence buffer every time.
-        std::vector<uint8_t> silence_buffer(
-            channels_ * GetSampleSize(sample_type_) * kSilenceFramesPerAppend);
-        WriteData(env, silence_buffer.data(), kSilenceFramesPerAppend);
+        const int silence_frames_per_append =
+            std::min<int>(kSilenceFramesPerAppend, max_frames_per_request_);
+        std::vector<uint8_t> silence_buffer(channels_ *
+                                            GetSampleSize(sample_type_) *
+                                            silence_frames_per_append);
+        auto sync_time = start_time_ + accumulated_written_frames *
+                                           kSbTimeSecond /
+                                           sampling_frequency_hz_;
+        // Not necessary to handle error of WriteData(), even for
+        // kAudioTrackErrorDeadObject, as the audio has reached the end of
+        // stream.
+        // TODO: Ensure that the audio stream can still reach the end when an
+        //       error occurs.
+        WriteData(env, silence_buffer.data(), silence_frames_per_append,
+                  sync_time);
       }
+
+      // While WriteData() returns kAudioTrackErrorDeadObject on dead object,
+      // getAudioTimestamp() doesn't, it just no longer updates its return
+      // value.  If the dead object error occurs when there isn't any audio data
+      // to write, there is no way to detect it by checking the return value of
+      // getAudioTimestamp().  Instead, we have to check if its return value has
+      // been changed during a certain period of time, to detect the underlying
+      // dead object error.
+      // Note that dead object would occur while switching audio end points in
+      // tunnel mode.  Under non-tunnel mode, the Android native AudioTrack will
+      // handle audio track dead object automatically if the new end point can
+      // support current audio format.
+      // TODO: Investigate to handle this error in non-tunnel mode.
+      if (tunnel_mode_audio_session_id_ != -1 &&
+          last_written_succeeded_at != -1) {
+        const SbTime kAudioSinkBlockedDuration = kSbTimeSecond;
+        auto time_since_last_written_success =
+            SbTimeGetMonotonicNow() - last_written_succeeded_at;
+        if (time_since_last_written_success > kAudioSinkBlockedDuration &&
+            playback_head_not_changed_duration > kAudioSinkBlockedDuration &&
+            tunnel_mode_audio_session_id_ != -1) {
+          SB_LOG(INFO) << "Over one second without frames written and consumed";
+          consume_frames_func_(written_frames_, SbTimeGetMonotonicNow(),
+                               context_);
+          error_func_(kSbPlayerErrorCapabilityChanged, context_);
+          break;
+        }
+      }
+
       SbThreadSleep(10 * kSbTimeMillisecond);
       continue;
     }
     SB_DCHECK(expected_written_frames > 0);
+    auto sync_time = start_time_ + accumulated_written_frames * kSbTimeSecond /
+                                       sampling_frequency_hz_;
+
+    SB_CHECK(start_position + expected_written_frames <= frames_per_channel_);
     int written_frames = WriteData(
         env,
         IncrementPointerByBytes(frame_buffer_, start_position * channels_ *
                                                    GetSampleSize(sample_type_)),
-        expected_written_frames);
+        expected_written_frames, sync_time);
+    SbTime now = SbTimeGetMonotonicNow();
+
+    if (written_frames < 0) {
+      // Take all |written_frames_| as consumed since audio track could be dead.
+      consume_frames_func_(written_frames_, now, context_);
+      error_func_(written_frames == kAudioTrackErrorDeadObject
+                      ? kSbPlayerErrorCapabilityChanged
+                      : kSbPlayerErrorDecode,
+                  context_);
+      break;
+    } else if (written_frames > 0) {
+      last_written_succeeded_at = now;
+    }
     written_frames_ += written_frames;
+    accumulated_written_frames += written_frames;
+
     bool written_fully = (written_frames == expected_written_frames);
     auto unplayed_frames_in_time =
         written_frames_ * kSbTimeSecond / sampling_frequency_hz_ -
-        (SbTimeGetMonotonicNow() - frames_consumed_at);
+        (now - frames_consumed_at);
     // As long as there is enough data in the buffer, run the loop in lower
     // frequency to avoid taking too much CPU.  Note that the threshold should
     // be big enough to account for the unstable playback head reported at the
@@ -332,8 +441,9 @@
 }
 
 int AudioTrackAudioSink::WriteData(JniEnvExt* env,
-                                   const void* buffer,
-                                   int expected_written_frames) {
+                                   void* buffer,
+                                   int expected_written_frames,
+                                   SbTime sync_time) {
   if (sample_type_ == kSbMediaAudioSampleTypeFloat32) {
     int expected_written_size = expected_written_frames * channels_;
     env->SetFloatArrayRegion(static_cast<jfloatArray>(j_audio_data_), kNoOffset,
@@ -342,7 +452,10 @@
     int written =
         env->CallIntMethodOrAbort(j_audio_track_bridge_, "write", "([FI)I",
                                   j_audio_data_, expected_written_size);
-    SB_DCHECK(written >= 0);
+    if (written < 0) {
+      // Error code returned as negative value, like kAudioTrackErrorDeadObject.
+      return written;
+    }
     SB_DCHECK(written % channels_ == 0);
     return written / channels_;
   }
@@ -352,10 +465,14 @@
     env->SetByteArrayRegion(static_cast<jbyteArray>(j_audio_data_), kNoOffset,
                             expected_written_size,
                             static_cast<const jbyte*>(buffer));
-    int written =
-        env->CallIntMethodOrAbort(j_audio_track_bridge_, "write", "([BI)I",
-                                  j_audio_data_, expected_written_size);
-    SB_DCHECK(written >= 0);
+
+    int written = env->CallIntMethodOrAbort(j_audio_track_bridge_, "write",
+                                            "([BIJ)I", j_audio_data_,
+                                            expected_written_size, sync_time);
+    if (written < 0) {
+      // Error code returned as negative value, like kAudioTrackErrorDeadObject.
+      return written;
+    }
     SB_DCHECK(written % (channels_ * GetSampleSize(sample_type_)) == 0);
     return written / (channels_ * GetSampleSize(sample_type_));
   }
@@ -417,6 +534,27 @@
     SbAudioSinkPrivate::ConsumeFramesFunc consume_frames_func,
     SbAudioSinkPrivate::ErrorFunc error_func,
     void* context) {
+  const SbTime kStartTime = 0;
+  const int kTunnelModeAudioSessionId = -1;  // disable tunnel mode
+  return Create(channels, sampling_frequency_hz, audio_sample_type,
+                audio_frame_storage_type, frame_buffers, frames_per_channel,
+                update_source_status_func, consume_frames_func, error_func,
+                kStartTime, kTunnelModeAudioSessionId, context);
+}
+
+SbAudioSink AudioTrackAudioSinkType::Create(
+    int channels,
+    int sampling_frequency_hz,
+    SbMediaAudioSampleType audio_sample_type,
+    SbMediaAudioFrameStorageType audio_frame_storage_type,
+    SbAudioSinkFrameBuffers frame_buffers,
+    int frames_per_channel,
+    SbAudioSinkUpdateSourceStatusFunc update_source_status_func,
+    SbAudioSinkPrivate::ConsumeFramesFunc consume_frames_func,
+    SbAudioSinkPrivate::ErrorFunc error_func,
+    SbTime start_media_time,
+    int tunnel_mode_audio_session_id,
+    void* context) {
   int min_required_frames = SbAudioSinkGetMinBufferSizeInFrames(
       channels, audio_sample_type, sampling_frequency_hz);
   SB_DCHECK(frames_per_channel >= min_required_frames);
@@ -425,7 +563,8 @@
   AudioTrackAudioSink* audio_sink = new AudioTrackAudioSink(
       this, channels, sampling_frequency_hz, audio_sample_type, frame_buffers,
       frames_per_channel, preferred_buffer_size_in_bytes,
-      update_source_status_func, consume_frames_func, context);
+      update_source_status_func, consume_frames_func, error_func,
+      start_media_time, tunnel_mode_audio_session_id, context);
   if (!audio_sink->IsAudioTrackValid()) {
     SB_DLOG(ERROR)
         << "AudioTrackAudioSinkType::Create failed to create audio track";
diff --git a/src/starboard/android/shared/audio_track_audio_sink_type.h b/src/starboard/android/shared/audio_track_audio_sink_type.h
index 43b0c86..c5b1ba7 100644
--- a/src/starboard/android/shared/audio_track_audio_sink_type.h
+++ b/src/starboard/android/shared/audio_track_audio_sink_type.h
@@ -18,6 +18,7 @@
 #include <atomic>
 #include <functional>
 #include <map>
+#include <vector>
 
 #include "starboard/android/shared/audio_sink_min_required_frames_tester.h"
 #include "starboard/android/shared/jni_env_ext.h"
@@ -54,6 +55,19 @@
       SbAudioSinkPrivate::ConsumeFramesFunc consume_frames_func,
       SbAudioSinkPrivate::ErrorFunc error_func,
       void* context) override;
+  SbAudioSink Create(
+      int channels,
+      int sampling_frequency_hz,
+      SbMediaAudioSampleType audio_sample_type,
+      SbMediaAudioFrameStorageType audio_frame_storage_type,
+      SbAudioSinkFrameBuffers frame_buffers,
+      int frames_per_channel,
+      SbAudioSinkUpdateSourceStatusFunc update_source_status_func,
+      SbAudioSinkPrivate::ConsumeFramesFunc consume_frames_func,
+      SbAudioSinkPrivate::ErrorFunc error_func,
+      SbTime start_time,
+      int tunnel_mode_audio_session_id,
+      void* context);
 
   bool IsValid(SbAudioSink audio_sink) override {
     return audio_sink != kSbAudioSinkInvalid && audio_sink->IsType(this);
@@ -92,6 +106,9 @@
       int preferred_buffer_size,
       SbAudioSinkUpdateSourceStatusFunc update_source_status_func,
       ConsumeFramesFunc consume_frames_func,
+      SbAudioSinkPrivate::ErrorFunc error_func,
+      SbTime start_media_time,
+      int tunnel_mode_audio_session_id,
       void* context);
   ~AudioTrackAudioSink() override;
 
@@ -106,8 +123,9 @@
   static void* ThreadEntryPoint(void* context);
   void AudioThreadFunc();
 
-  int WriteData(JniEnvExt* env, const void* buffer, int size);
+  int WriteData(JniEnvExt* env, void* buffer, int size, SbTime sync_time);
 
+  // TODO: Add const to the following variables where appropriate.
   Type* type_;
   int channels_;
   int sampling_frequency_hz_;
@@ -116,18 +134,25 @@
   int frames_per_channel_;
   SbAudioSinkUpdateSourceStatusFunc update_source_status_func_;
   ConsumeFramesFunc consume_frames_func_;
+  SbAudioSinkPrivate::ErrorFunc error_func_;
+  const SbTime start_time_;
+  const int tunnel_mode_audio_session_id_;
+  const int max_frames_per_request_;
+
   void* context_;
-  int last_playback_head_position_;
-  jobject j_audio_track_bridge_;
-  jobject j_audio_data_;
+  int last_playback_head_position_ = 0;
+  jobject j_audio_track_bridge_ = nullptr;
+  jobject j_audio_data_ = nullptr;
 
-  volatile bool quit_;
-  SbThread audio_out_thread_;
+  volatile bool quit_ = false;
+  SbThread audio_out_thread_ = kSbThreadInvalid;
 
-  starboard::Mutex mutex_;
-  double playback_rate_;
+  Mutex mutex_;
+  double playback_rate_ = 1.0;
 
-  int written_frames_;
+  // TODO: Rename to |frames_in_audio_track| and move it into AudioThreadFunc()
+  //       as a local variable.
+  int written_frames_ = 0;
 };
 
 }  // namespace shared
diff --git a/src/starboard/android/shared/cobalt/__init__.py b/src/starboard/android/shared/cobalt/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/starboard/android/shared/cobalt/__init__.py
diff --git a/src/starboard/android/shared/configuration.cc b/src/starboard/android/shared/configuration.cc
index 6f05a18..0de9388 100644
--- a/src/starboard/android/shared/configuration.cc
+++ b/src/starboard/android/shared/configuration.cc
@@ -43,7 +43,7 @@
 
 const CobaltExtensionConfigurationApi kConfigurationApi = {
     kCobaltExtensionConfigurationName,
-    1,
+    2,
     &CobaltUserOnExitStrategy,
     &common::CobaltRenderDirtyRegionOnlyDefault,
     &CobaltEglSwapInterval,
@@ -66,6 +66,7 @@
     &common::CobaltGcZealDefault,
     &common::CobaltRasterizerTypeDefault,
     &common::CobaltEnableJitDefault,
+    &common::CobaltFallbackSplashScreenTopicsDefault,
 };
 
 }  // namespace
diff --git a/src/starboard/android/shared/configuration_public.h b/src/starboard/android/shared/configuration_public.h
index 371a413..2064399 100644
--- a/src/starboard/android/shared/configuration_public.h
+++ b/src/starboard/android/shared/configuration_public.h
@@ -23,12 +23,6 @@
 #ifndef STARBOARD_ANDROID_SHARED_CONFIGURATION_PUBLIC_H_
 #define STARBOARD_ANDROID_SHARED_CONFIGURATION_PUBLIC_H_
 
-#if SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-#error \
-    "This platform's sabi.json file is expected to track the experimental " \
-"Starboard API version."
-#endif  // SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-
 // --- Architecture Configuration --------------------------------------------
 
 // Indicates that there is no support for alignment at greater than 16 bytes for
diff --git a/src/starboard/android/shared/launcher.py b/src/starboard/android/shared/launcher.py
new file mode 100644
index 0000000..106b2b9
--- /dev/null
+++ b/src/starboard/android/shared/launcher.py
@@ -0,0 +1,437 @@
+#
+# Copyright 2017 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.
+#
+"""Android implementation of Starboard launcher abstraction."""
+
+import os
+import re
+import socket
+import subprocess
+import sys
+import threading
+import time
+import Queue
+
+import _env  # pylint: disable=unused-import,g-bad-import-order
+
+from starboard.android.shared import sdk_utils
+from starboard.tools import abstract_launcher
+
+_APP_PACKAGE_NAME = 'dev.cobalt.coat'
+
+_APP_START_INTENT = 'dev.cobalt.coat/dev.cobalt.app.MainActivity'
+
+# Matches an "adb shell am monitor" error line.
+_RE_ADB_AM_MONITOR_ERROR = re.compile(r'\*\* ERROR')
+
+# String added to queue to indicate process has crashed
+_QUEUE_CODE_CRASHED = 'crashed'
+
+# How long to keep logging after a crash in order to emit the stack trace.
+_CRASH_LOG_SECONDS = 1.0
+
+_RUNTIME_PERMISSIONS = [
+    'android.permission.GET_ACCOUNTS',
+    'android.permission.RECORD_AUDIO',
+]
+
+
+def TargetOsPathJoin(*path_elements):
+  """os.path.join for the target (Android)."""
+  return '/'.join(path_elements)
+
+
+def CleanLine(line):
+  """Removes trailing carriages returns from ADB output."""
+  return line.replace('\r', '')
+
+
+class StepTimer(object):
+  """Class for timing how long install/run steps take."""
+
+  def __init__(self, step_name):
+    self.step_name = step_name
+    self.start_time = time.time()
+    self.end_time = None
+
+  def Stop(self):
+    if self.start_time is None:
+      sys.stderr.write('Cannot stop timer; not started\n')
+    else:
+      self.end_time = time.time()
+      total_time = self.end_time - self.start_time
+      sys.stderr.write('Step \"{}\" took {} seconds.\n'.format(
+          self.step_name, total_time))
+
+
+class AdbCommandBuilder(object):
+  """Builder for 'adb' commands."""
+
+  def __init__(self, adb, device_id=None):
+    self.adb = adb
+    self.device_id = device_id
+
+  def Build(self, *args):
+    """Builds an 'adb' commandline with the given args."""
+    result = [self.adb]
+    if self.device_id:
+      result.append('-s')
+      result.append(self.device_id)
+    result += list(args)
+    return result
+
+
+class AdbAmMonitorWatcher(object):
+  """Watches an "adb shell am monitor" process to detect crashes."""
+
+  def __init__(self, launcher, done_queue):
+    self.launcher = launcher
+    self.process = launcher._PopenAdb(
+        'shell', 'am', 'monitor', stdout=subprocess.PIPE)
+    if abstract_launcher.ARG_DRYRUN in launcher.launcher_args:
+      self.thread = None
+      return
+    self.thread = threading.Thread(target=self._Run)
+    self.thread.start()
+    self.done_queue = done_queue
+
+  def Shutdown(self):
+    self.process.kill()
+    if self.thread:
+      self.thread.join()
+
+  def _Run(self):
+    while True:
+      line = CleanLine(self.process.stdout.readline())
+      if not line:
+        return
+      # Show the crash lines reported by "am monitor".
+      sys.stderr.write(line)
+      if re.search(_RE_ADB_AM_MONITOR_ERROR, line):
+        self.done_queue.put(_QUEUE_CODE_CRASHED)
+        # This log line will wake up the main thread
+        self.launcher.CallAdb('shell', 'log', '-t', 'starboard',
+                              'am monitor detected crash')
+
+
+class Launcher(abstract_launcher.AbstractLauncher):
+  """Run an application on Android."""
+
+  def __init__(self, platform, target_name, config, device_id, **kwargs):
+
+    super(Launcher, self).__init__(platform, target_name, config, device_id,
+                                   **kwargs)
+
+    if abstract_launcher.ARG_SYSTOOLS in self.launcher_args:
+      # Use default adb binary from path.
+      self.adb = 'adb'
+    else:
+      self.adb = os.path.join(sdk_utils.GetSdkPath(), 'platform-tools', 'adb')
+
+    self.adb_builder = AdbCommandBuilder(self.adb)
+
+    if not self.device_id:
+      self.device_id = self._IdentifyDevice()
+    else:
+      self._ConnectIfNecessary()
+
+    self.adb_builder.device_id = self.device_id
+
+    # Verify connection and dump target build fingerprint.
+    self._CheckCallAdb('shell', 'getprop', 'ro.build.fingerprint')
+
+    out_directory = os.path.split(self.GetTargetPath())[0]
+    self.apk_path = os.path.join(out_directory, '{}.apk'.format(target_name))
+    if not os.path.exists(self.apk_path):
+      raise Exception("Can't find APK {}".format(self.apk_path))
+
+    # This flag is set when the main Run() loop exits.  If Kill() is called
+    # after this flag is set, it will not do anything.
+    self.killed = threading.Event()
+
+    # Keep track of the port used by ADB forward in order to remove it later
+    # on.
+    self.local_port = None
+
+  def _IsValidIPv4Address(self, address):
+    """Returns True if address is a valid IPv4 address, False otherwise."""
+    try:
+      # inet_aton throws an exception if the address is not a valid IPv4
+      # address. However addresses such as '127.1' might still be considered
+      # valid, hence the check for 3 '.' in the address.
+      # pylint: disable=g-socket-inet-aton
+      if socket.inet_aton(address) and address.count('.') == 3:
+        return True
+    except Exception:  # pylint: disable=broad-except
+      pass
+    return False
+
+  def _GetAdbDevices(self):
+    """Returns a list of names of connected devices, or empty list if none."""
+
+    # Does not use the ADBCommandBuilder class because this command should be
+    # run without targeting a specific device.
+    p = self._PopenAdb('devices', stdout=subprocess.PIPE)
+    result = p.stdout.readlines()[1:-1]
+    p.wait()
+
+    names = []
+    for device in result:
+      name_info = device.split('\t')
+      # Some devices may not have authorization for USB debugging.
+      try:
+        if 'unauthorized' not in name_info[1]:
+          names.append(name_info[0])
+      # Sometimes happens when device is found, even though none are connected.
+      except IndexError:
+        continue
+    return names
+
+  def _IdentifyDevice(self):
+    """Picks a device to be used to run the executable.
+
+    In the event that no device_id is provided, but multiple
+    devices are connected, this method chooses the first device
+    listed.
+
+    Returns:
+      The name of an attached device, or None if no devices are present.
+    """
+    device_name = None
+
+    devices = self._GetAdbDevices()
+    if devices:
+      device_name = devices[0]
+
+    return device_name
+
+  def _ConnectIfNecessary(self):
+    """Run ADB connect if needed for devices connected over IP."""
+    if not self._IsValidIPv4Address(self.device_id):
+      return
+    for device in self._GetAdbDevices():
+      # Devices returned by _GetAdbDevices might include port number, so cannot
+      # simply check if self.device_id is in the returned list.
+      if self.device_id in device:
+        return
+
+    # Device isn't connected. Run ADB connect.
+    # Does not use the ADBCommandBuilder class because this command should be
+    # run without targeting a specific device.
+    p = self._PopenAdb(
+        'connect',
+        '{}:5555'.format(self.device_id),
+        stderr=subprocess.STDOUT,
+        stdout=subprocess.PIPE,
+    )
+    result = p.stdout.readlines()[0]
+    p.wait()
+
+    if 'connected to' not in result:
+      sys.stderr.write('Failed to connect to {}\n'.format(self.device_id))
+      sys.stderr.write('connect command exited with code {} '
+                       'and returned: {}'.format(p.returncode, result))
+
+  def _Call(self, *args):
+    sys.stderr.write('{}\n'.format(' '.join(args)))
+    if abstract_launcher.ARG_DRYRUN not in self.launcher_args:
+      subprocess.call(args, close_fds=True)
+
+  def CallAdb(self, *in_args):
+    args = self.adb_builder.Build(*in_args)
+    self._Call(*args)
+
+  def _CheckCall(self, *args):
+    sys.stderr.write('{}\n'.format(' '.join(args)))
+    if abstract_launcher.ARG_DRYRUN not in self.launcher_args:
+      subprocess.check_call(args, close_fds=True)
+
+  def _CheckCallAdb(self, *in_args):
+    args = self.adb_builder.Build(*in_args)
+    self._CheckCall(*args)
+
+  def _PopenAdb(self, *args, **kwargs):
+    build_args = self.adb_builder.Build(*args)
+    sys.stderr.write('{}\n'.format(' '.join(build_args)))
+    if abstract_launcher.ARG_DRYRUN in self.launcher_args:
+      return subprocess.Popen(['echo', 'dry-run'])
+    return subprocess.Popen(build_args, close_fds=True, **kwargs)
+
+  def Run(self):
+    # The return code for binaries run on Android is read from a log line that
+    # it emitted in android_main.cc.  This return_code variable will be assigned
+    # the value read when we see that line, or left at 1 in the event of a crash
+    # or early exit.
+    return_code = 1
+
+    # Setup for running executable
+    self._CheckCallAdb('wait-for-device')
+    self._Shutdown()
+
+    # Clear logcat
+    self._CheckCallAdb('logcat', '-c')
+
+    # Install the APK, unless "noinstall" was specified.
+    if abstract_launcher.ARG_NOINSTALL not in self.launcher_args:
+      install_timer = StepTimer('install')
+      self._CheckCallAdb('install', '-r', self.apk_path)
+      install_timer.Stop()
+
+    # Send the wakeup key to ensure daydream isn't running, otherwise Activity
+    # Manager may get in a loop running the test over and over again.
+    self._CheckCallAdb('shell', 'input', 'keyevent', 'KEYCODE_WAKEUP')
+
+    # Grant runtime permissions to avoid prompts during testing.
+    if abstract_launcher.ARG_NOINSTALL not in self.launcher_args:
+      for permission in _RUNTIME_PERMISSIONS:
+        self._CheckCallAdb('shell', 'pm', 'grant', _APP_PACKAGE_NAME,
+                           permission)
+
+    done_queue = Queue.Queue()
+    am_monitor = AdbAmMonitorWatcher(self, done_queue)
+
+    # Increases the size of the logcat buffer.  Without this, the log buffer
+    # will not flush quickly enough and output will be cut off.
+    self._CheckCallAdb('logcat', '-G', '2M')
+
+    #  Ctrl + C will kill this process
+    logcat_process = self._PopenAdb(
+        'logcat',
+        '-v',
+        'raw',
+        '-s',
+        '*:F',
+        '*:E',
+        'DEBUG:*',
+        'System.err:*',
+        'starboard:*',
+        'starboard_media:*',
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT)
+
+    # Actually running executable
+    run_timer = StepTimer('running executable')
+    try:
+      args = ['shell', 'am', 'start']
+      command_line_params = [
+          '--android_log_sleep_time=1000',
+          '--disable_sign_in',
+      ]
+      for param in self.target_command_line_params:
+        if param.startswith('--link='):
+          # Android deeplinks go in the Intent data
+          link = param.split('=')[1]
+          args += ['-d', "'{}'".format(link)]
+        else:
+          command_line_params.append(param)
+      args += ['--esa', 'args', "'{}'".format(','.join(command_line_params))]
+      args += [_APP_START_INTENT]
+
+      self._CheckCallAdb(*args)
+
+      run_loop = abstract_launcher.ARG_DRYRUN not in self.launcher_args
+
+      app_crashed = False
+      while run_loop:
+        if not done_queue.empty():
+          done_queue_code = done_queue.get_nowait()
+          if done_queue_code == _QUEUE_CODE_CRASHED:
+            app_crashed = True
+            threading.Timer(_CRASH_LOG_SECONDS, logcat_process.kill).start()
+
+        # Note we cannot use "for line in logcat_process.stdout" because
+        # that uses a large buffer which will cause us to deadlock.
+        line = CleanLine(logcat_process.stdout.readline())
+
+        # Some crashes are not caught by the am_monitor thread, but they do
+        # produce the following string in logcat before they exit.
+        if 'beginning of crash' in line:
+          app_crashed = True
+          threading.Timer(_CRASH_LOG_SECONDS, logcat_process.kill).start()
+
+        if not line:  # Logcat exited, or was killed
+          break
+        else:
+          self._WriteLine(line)
+          # Don't break until we see the below text in logcat, which should be
+          # written when the Starboard application event loop finishes.
+          if '***Application Stopped***' in line:
+            try:
+              return_code = int(line.split(' ')[-1])
+            except ValueError:  # Error message was printed to stdout
+              pass
+            logcat_process.kill()
+            break
+
+    finally:
+      if app_crashed:
+        self._WriteLine('***Application Crashed***\n')
+        # Set return code to mimic segfault code on Linux
+        return_code = 11
+      else:
+        self._Shutdown()
+      if self.local_port is not None:
+        self.CallAdb('forward', '--remove', 'tcp:{}'.format(self.local_port))
+      am_monitor.Shutdown()
+      self.killed.set()
+      run_timer.Stop()
+      if logcat_process.poll() is None:
+        # This could happen when using SIGINT to kill the launcher
+        # (e.g. when using starboard/tools/example/app_launcher_client.py).
+        sys.stderr.write('Logcat process is still running. Killing it now.\n')
+        logcat_process.kill()
+
+    return return_code
+
+  def _Shutdown(self):
+    self.CallAdb('shell', 'am', 'force-stop', _APP_PACKAGE_NAME)
+
+  def SupportsDeepLink(self):
+    return True
+
+  def SendDeepLink(self, link):
+    shell_cmd = 'am start -d "{}" {}'.format(link, _APP_START_INTENT)
+    args = ['shell', shell_cmd]
+    self._CheckCallAdb(*args)
+    return True
+
+  def Kill(self):
+    if not self.killed.is_set():
+      sys.stderr.write('***Killing Launcher***\n')
+      self._CheckCallAdb('shell', 'log', '-t', 'starboard',
+                         '***Application Stopped*** 1')
+      self._Shutdown()
+    else:
+      sys.stderr.write('Cannot kill launcher: already dead.\n')
+
+  def _WriteLine(self, line):
+    """Write log output to stdout."""
+    self.output_file.write(line)
+    self.output_file.flush()
+
+  def GetHostAndPortGivenPort(self, port):
+    forward_p = self._PopenAdb(
+        'forward', 'tcp:0', 'tcp:{}'.format(port), stdout=subprocess.PIPE)
+    forward_p.wait()
+
+    self.local_port = CleanLine(forward_p.stdout.readline()).rstrip('\n')
+    sys.stderr.write('ADB forward local port {} '
+                     '=> device port {}\n'.format(self.local_port, port))
+    # pylint: disable=g-socket-gethostbyname
+    return socket.gethostbyname('localhost'), self.local_port
+
+  def GetDeviceIp(self):
+    """Gets the device IP. TODO: Implement."""
+    return None
diff --git a/src/starboard/android/shared/player_components_factory.cc b/src/starboard/android/shared/player_components_factory.cc
index 6ac984a..01dc7a6 100644
--- a/src/starboard/android/shared/player_components_factory.cc
+++ b/src/starboard/android/shared/player_components_factory.cc
@@ -12,23 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/android/shared/audio_decoder.h"
-#include "starboard/android/shared/video_decoder.h"
-#include "starboard/android/shared/video_render_algorithm.h"
-#include "starboard/common/log.h"
-#include "starboard/common/ref_counted.h"
-#include "starboard/common/scoped_ptr.h"
-#include "starboard/media.h"
-#include "starboard/shared/opus/opus_audio_decoder.h"
-#include "starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h"
-#include "starboard/shared/starboard/player/filter/audio_decoder_internal.h"
-#include "starboard/shared/starboard/player/filter/audio_renderer_sink.h"
-#include "starboard/shared/starboard/player/filter/audio_renderer_sink_impl.h"
-#include "starboard/shared/starboard/player/filter/player_components.h"
-#include "starboard/shared/starboard/player/filter/video_decoder_internal.h"
-#include "starboard/shared/starboard/player/filter/video_render_algorithm.h"
-#include "starboard/shared/starboard/player/filter/video_render_algorithm_impl.h"
-#include "starboard/shared/starboard/player/filter/video_renderer_sink.h"
+#include "starboard/android/shared/player_components_factory.h"
 
 namespace starboard {
 namespace shared {
@@ -36,121 +20,10 @@
 namespace player {
 namespace filter {
 
-namespace {
-
-const int kAudioSinkFramesAlignment = 256;
-const int kDefaultAudioSinkMinFramesPerAppend = 1024;
-const int kDefaultAudioSinkMaxCachedFrames =
-    8 * kDefaultAudioSinkMinFramesPerAppend;
-
-int AlignUp(int value, int alignment) {
-  return (value + alignment - 1) / alignment * alignment;
-}
-
-class PlayerComponentsFactory : public PlayerComponents::Factory {
-  bool CreateSubComponents(
-      const CreationParameters& creation_parameters,
-      scoped_ptr<AudioDecoder>* audio_decoder,
-      scoped_ptr<AudioRendererSink>* audio_renderer_sink,
-      scoped_ptr<VideoDecoder>* video_decoder,
-      scoped_ptr<VideoRenderAlgorithm>* video_render_algorithm,
-      scoped_refptr<VideoRendererSink>* video_renderer_sink,
-      std::string* error_message) override {
-    SB_DCHECK(error_message);
-
-    if (creation_parameters.audio_codec() != kSbMediaAudioCodecNone) {
-      SB_DCHECK(audio_decoder);
-      SB_DCHECK(audio_renderer_sink);
-
-      auto decoder_creator = [](const SbMediaAudioSampleInfo& audio_sample_info,
-                                SbDrmSystem drm_system) {
-        if (audio_sample_info.codec == kSbMediaAudioCodecAac) {
-          scoped_ptr<android::shared::AudioDecoder> audio_decoder_impl(
-              new android::shared::AudioDecoder(audio_sample_info.codec,
-                                                audio_sample_info, drm_system));
-          if (audio_decoder_impl->is_valid()) {
-            return audio_decoder_impl.PassAs<AudioDecoder>();
-          }
-        } else if (audio_sample_info.codec == kSbMediaAudioCodecOpus) {
-          scoped_ptr<opus::OpusAudioDecoder> audio_decoder_impl(
-              new opus::OpusAudioDecoder(audio_sample_info));
-          if (audio_decoder_impl->is_valid()) {
-            return audio_decoder_impl.PassAs<AudioDecoder>();
-          }
-        } else {
-          SB_NOTREACHED();
-        }
-        return scoped_ptr<AudioDecoder>();
-      };
-
-      audio_decoder->reset(new AdaptiveAudioDecoder(
-          creation_parameters.audio_sample_info(),
-          creation_parameters.drm_system(), decoder_creator));
-      audio_renderer_sink->reset(new AudioRendererSinkImpl);
-    }
-
-    if (creation_parameters.video_codec() != kSbMediaVideoCodecNone) {
-      SB_DCHECK(video_decoder);
-      SB_DCHECK(video_render_algorithm);
-      SB_DCHECK(video_renderer_sink);
-      SB_DCHECK(error_message);
-
-      scoped_ptr<android::shared::VideoDecoder> video_decoder_impl(
-          new android::shared::VideoDecoder(
-              creation_parameters.video_codec(),
-              creation_parameters.drm_system(),
-              creation_parameters.output_mode(),
-              creation_parameters.decode_target_graphics_context_provider(),
-              creation_parameters.max_video_capabilities(), error_message));
-      if (video_decoder_impl->is_valid()) {
-        video_render_algorithm->reset(new android::shared::VideoRenderAlgorithm(
-            video_decoder_impl.get()));
-        *video_renderer_sink = video_decoder_impl->GetSink();
-        video_decoder->reset(video_decoder_impl.release());
-      } else {
-        video_decoder->reset();
-        *video_renderer_sink = NULL;
-        *error_message =
-            "Failed to create video decoder with error: " + *error_message;
-        return false;
-      }
-    }
-
-    return true;
-  }
-
-  void GetAudioRendererParams(const CreationParameters& creation_parameters,
-                              int* max_cached_frames,
-                              int* min_frames_per_append) const override {
-    SB_DCHECK(max_cached_frames);
-    SB_DCHECK(min_frames_per_append);
-    SB_DCHECK(kDefaultAudioSinkMinFramesPerAppend % kAudioSinkFramesAlignment ==
-              0);
-    *min_frames_per_append = kDefaultAudioSinkMinFramesPerAppend;
-
-    // AudioRenderer prefers to use kSbMediaAudioSampleTypeFloat32 and only uses
-    // kSbMediaAudioSampleTypeInt16Deprecated when float32 is not supported.
-    int min_frames_required = SbAudioSinkGetMinBufferSizeInFrames(
-        creation_parameters.audio_sample_info().number_of_channels,
-        SbAudioSinkIsAudioSampleTypeSupported(kSbMediaAudioSampleTypeFloat32)
-            ? kSbMediaAudioSampleTypeFloat32
-            : kSbMediaAudioSampleTypeInt16Deprecated,
-        creation_parameters.audio_sample_info().samples_per_second);
-    // On Android 5.0, the size of audio renderer sink buffer need to be two
-    // times larger than AudioTrack minBufferSize. Otherwise, AudioTrack may
-    // stop working after pause.
-    *max_cached_frames =
-        min_frames_required * 2 + kDefaultAudioSinkMinFramesPerAppend;
-    *max_cached_frames = AlignUp(*max_cached_frames, kAudioSinkFramesAlignment);
-  }
-};
-
-}  // namespace
-
 // static
 scoped_ptr<PlayerComponents::Factory> PlayerComponents::Factory::Create() {
   return make_scoped_ptr<PlayerComponents::Factory>(
-      new PlayerComponentsFactory);
+      new android::shared::PlayerComponentsFactory);
 }
 
 // static
diff --git a/src/starboard/android/shared/player_components_factory.h b/src/starboard/android/shared/player_components_factory.h
new file mode 100644
index 0000000..350b00f
--- /dev/null
+++ b/src/starboard/android/shared/player_components_factory.h
@@ -0,0 +1,173 @@
+// Copyright 2017 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 STARBOARD_ANDROID_SHARED_PLAYER_COMPONENTS_FACTORY_H_
+#define STARBOARD_ANDROID_SHARED_PLAYER_COMPONENTS_FACTORY_H_
+
+#include <string>
+
+#include "starboard/android/shared/audio_decoder.h"
+#include "starboard/android/shared/video_decoder.h"
+#include "starboard/android/shared/video_render_algorithm.h"
+#include "starboard/common/log.h"
+#include "starboard/common/ref_counted.h"
+#include "starboard/common/scoped_ptr.h"
+#include "starboard/media.h"
+#include "starboard/shared/opus/opus_audio_decoder.h"
+#include "starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.h"
+#include "starboard/shared/starboard/player/filter/audio_decoder_internal.h"
+#include "starboard/shared/starboard/player/filter/audio_renderer_sink.h"
+#include "starboard/shared/starboard/player/filter/audio_renderer_sink_impl.h"
+#include "starboard/shared/starboard/player/filter/player_components.h"
+#include "starboard/shared/starboard/player/filter/video_decoder_internal.h"
+#include "starboard/shared/starboard/player/filter/video_render_algorithm.h"
+#include "starboard/shared/starboard/player/filter/video_render_algorithm_impl.h"
+#include "starboard/shared/starboard/player/filter/video_renderer_sink.h"
+
+namespace starboard {
+namespace android {
+namespace shared {
+
+class PlayerComponentsFactory : public starboard::shared::starboard::player::
+                                    filter::PlayerComponents::Factory {
+  typedef starboard::shared::opus::OpusAudioDecoder OpusAudioDecoder;
+  typedef starboard::shared::starboard::player::filter::AdaptiveAudioDecoder
+      AdaptiveAudioDecoder;
+  typedef starboard::shared::starboard::player::filter::AudioDecoder
+      AudioDecoderBase;
+  typedef starboard::shared::starboard::player::filter::AudioRendererSink
+      AudioRendererSink;
+  typedef starboard::shared::starboard::player::filter::AudioRendererSinkImpl
+      AudioRendererSinkImpl;
+  typedef starboard::shared::starboard::player::filter::VideoDecoder
+      VideoDecoderBase;
+  typedef starboard::shared::starboard::player::filter::VideoRenderAlgorithm
+      VideoRenderAlgorithmBase;
+  typedef starboard::shared::starboard::player::filter::VideoRendererSink
+      VideoRendererSink;
+
+  const int kAudioSinkFramesAlignment = 256;
+  const int kDefaultAudioSinkMinFramesPerAppend = 1024;
+  const int kDefaultAudioSinkMaxCachedFrames =
+      8 * kDefaultAudioSinkMinFramesPerAppend;
+
+  virtual SbDrmSystem GetExtendedDrmSystem(SbDrmSystem drm_system) {
+    return drm_system;
+  }
+
+  static int AlignUp(int value, int alignment) {
+    return (value + alignment - 1) / alignment * alignment;
+  }
+
+  bool CreateSubComponents(
+      const CreationParameters& creation_parameters,
+      scoped_ptr<AudioDecoderBase>* audio_decoder,
+      scoped_ptr<AudioRendererSink>* audio_renderer_sink,
+      scoped_ptr<VideoDecoderBase>* video_decoder,
+      scoped_ptr<VideoRenderAlgorithmBase>* video_render_algorithm,
+      scoped_refptr<VideoRendererSink>* video_renderer_sink,
+      std::string* error_message) override {
+    SB_DCHECK(error_message);
+
+    if (creation_parameters.audio_codec() != kSbMediaAudioCodecNone) {
+      SB_DCHECK(audio_decoder);
+      SB_DCHECK(audio_renderer_sink);
+
+      auto decoder_creator = [](const SbMediaAudioSampleInfo& audio_sample_info,
+                                SbDrmSystem drm_system) {
+        if (audio_sample_info.codec == kSbMediaAudioCodecAac) {
+          scoped_ptr<AudioDecoder> audio_decoder_impl(new AudioDecoder(
+              audio_sample_info.codec, audio_sample_info, drm_system));
+          if (audio_decoder_impl->is_valid()) {
+            return audio_decoder_impl.PassAs<AudioDecoderBase>();
+          }
+        } else if (audio_sample_info.codec == kSbMediaAudioCodecOpus) {
+          scoped_ptr<OpusAudioDecoder> audio_decoder_impl(
+              new OpusAudioDecoder(audio_sample_info));
+          if (audio_decoder_impl->is_valid()) {
+            return audio_decoder_impl.PassAs<AudioDecoderBase>();
+          }
+        } else {
+          SB_NOTREACHED();
+        }
+        return scoped_ptr<AudioDecoderBase>();
+      };
+
+      audio_decoder->reset(new AdaptiveAudioDecoder(
+          creation_parameters.audio_sample_info(),
+          GetExtendedDrmSystem(creation_parameters.drm_system()),
+          decoder_creator));
+      audio_renderer_sink->reset(new AudioRendererSinkImpl);
+    }
+
+    if (creation_parameters.video_codec() != kSbMediaVideoCodecNone) {
+      SB_DCHECK(video_decoder);
+      SB_DCHECK(video_render_algorithm);
+      SB_DCHECK(video_renderer_sink);
+      SB_DCHECK(error_message);
+
+      scoped_ptr<VideoDecoder> video_decoder_impl(new VideoDecoder(
+          creation_parameters.video_codec(),
+          GetExtendedDrmSystem(creation_parameters.drm_system()),
+          creation_parameters.output_mode(),
+          creation_parameters.decode_target_graphics_context_provider(),
+          creation_parameters.max_video_capabilities(), error_message));
+      if (video_decoder_impl->is_valid()) {
+        video_render_algorithm->reset(
+            new VideoRenderAlgorithm(video_decoder_impl.get()));
+        *video_renderer_sink = video_decoder_impl->GetSink();
+        video_decoder->reset(video_decoder_impl.release());
+      } else {
+        video_decoder->reset();
+        *video_renderer_sink = NULL;
+        *error_message =
+            "Failed to create video decoder with error: " + *error_message;
+        return false;
+      }
+    }
+
+    return true;
+  }
+
+  void GetAudioRendererParams(const CreationParameters& creation_parameters,
+                              int* max_cached_frames,
+                              int* min_frames_per_append) const override {
+    SB_DCHECK(max_cached_frames);
+    SB_DCHECK(min_frames_per_append);
+    SB_DCHECK(kDefaultAudioSinkMinFramesPerAppend % kAudioSinkFramesAlignment ==
+              0);
+    *min_frames_per_append = kDefaultAudioSinkMinFramesPerAppend;
+
+    // AudioRenderer prefers to use kSbMediaAudioSampleTypeFloat32 and only uses
+    // kSbMediaAudioSampleTypeInt16Deprecated when float32 is not supported.
+    int min_frames_required = SbAudioSinkGetMinBufferSizeInFrames(
+        creation_parameters.audio_sample_info().number_of_channels,
+        SbAudioSinkIsAudioSampleTypeSupported(kSbMediaAudioSampleTypeFloat32)
+            ? kSbMediaAudioSampleTypeFloat32
+            : kSbMediaAudioSampleTypeInt16Deprecated,
+        creation_parameters.audio_sample_info().samples_per_second);
+    // On Android 5.0, the size of audio renderer sink buffer need to be two
+    // times larger than AudioTrack minBufferSize. Otherwise, AudioTrack may
+    // stop working after pause.
+    *max_cached_frames =
+        min_frames_required * 2 + kDefaultAudioSinkMinFramesPerAppend;
+    *max_cached_frames = AlignUp(*max_cached_frames, kAudioSinkFramesAlignment);
+  }
+};
+
+}  // namespace shared
+}  // namespace android
+}  // namespace starboard
+
+#endif  // STARBOARD_ANDROID_SHARED_PLAYER_COMPONENTS_FACTORY_H_
diff --git a/src/starboard/android/shared/starboard_platform.gypi b/src/starboard/android/shared/starboard_platform.gypi
index 8ec8f70..8b27a29 100644
--- a/src/starboard/android/shared/starboard_platform.gypi
+++ b/src/starboard/android/shared/starboard_platform.gypi
@@ -134,6 +134,7 @@
         'media_is_audio_supported.cc',
         'media_is_video_supported.cc',
         'microphone_impl.cc',
+        'player_components_factory.h',
         'player_create.cc',
         'player_destroy.cc',
         'player_get_preferred_output_mode.cc',
diff --git a/src/starboard/android/x86/__init__.py b/src/starboard/android/x86/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/starboard/android/x86/__init__.py
diff --git a/src/starboard/android/x86/cobalt/__init__.py b/src/starboard/android/x86/cobalt/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/starboard/android/x86/cobalt/__init__.py
diff --git a/src/starboard/android/x86/cobalt/configuration.py b/src/starboard/android/x86/cobalt/configuration.py
new file mode 100644
index 0000000..5e11fd8
--- /dev/null
+++ b/src/starboard/android/x86/cobalt/configuration.py
@@ -0,0 +1,61 @@
+# Copyright 2017-2020 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.
+"""Starboard Android x86 Cobalt configuration."""
+
+from starboard.android.shared.cobalt import configuration
+from starboard.tools.testing import test_filter
+
+
+class CobaltAndroidX86Configuration(configuration.CobaltAndroidConfiguration):
+  """Starboard Android x86 Cobalt configuration."""
+
+  def GetTestFilters(self):
+    filters = super(CobaltAndroidX86Configuration, self).GetTestFilters()
+    for target, tests in self.__FILTERED_TESTS.iteritems():
+      filters.extend(test_filter.TestFilter(target, test) for test in tests)
+    return filters
+
+  # A map of failing or crashing tests per target
+  __FILTERED_TESTS = {  # pylint: disable=invalid-name
+      'graphics_system_test': [
+          test_filter.FILTER_ALL
+      ],
+      'layout_tests': [  # Old Android versions don't have matching fonts
+          'CSS3FontsLayoutTests/Layout.Test'
+          '/5_2_use_first_available_listed_font_family',
+          'CSS3FontsLayoutTests/Layout.Test'
+          '/5_2_use_specified_font_family_if_available',
+          'CSS3FontsLayoutTests/Layout.Test'
+          '/5_2_use_system_fallback_if_no_matching_family_is_found*',
+          'CSS3FontsLayoutTests/Layout.Test'
+          '/synthetic_bolding_should_not_occur_on_bold_font',
+          'CSS3FontsLayoutTests/Layout.Test'
+          '/synthetic_bolding_should_occur_on_non_bold_font',
+      ],
+      'nb_test': [
+          'BidirectionalFitReuseAllocatorTest.FallbackBlockMerge',
+          'BidirectionalFitReuseAllocatorTest.FreeBlockMergingLeft',
+          'BidirectionalFitReuseAllocatorTest.FreeBlockMergingRight',
+          'FirstFitReuseAllocatorTest.FallbackBlockMerge',
+          'FirstFitReuseAllocatorTest.FreeBlockMergingLeft',
+          'FirstFitReuseAllocatorTest.FreeBlockMergingRight',
+      ],
+      'net_unittests': [  # Net tests are very unstable on Android L
+          test_filter.FILTER_ALL
+      ],
+      'renderer_test': [
+          'PixelTest.YUV422UYVYImageScaledUpSupport',
+          'PixelTest.YUV422UYVYImageScaledAndTranslated',
+      ],
+  }
diff --git a/src/starboard/android/x86/gyp_configuration.py b/src/starboard/android/x86/gyp_configuration.py
index 80134e6..e3e4c2c 100644
--- a/src/starboard/android/x86/gyp_configuration.py
+++ b/src/starboard/android/x86/gyp_configuration.py
@@ -1,4 +1,4 @@
-# Copyright 2016 The Cobalt Authors. All Rights Reserved.
+# Copyright 2016-2020 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.
@@ -14,10 +14,41 @@
 """Starboard Android x86 platform build configuration."""
 
 from starboard.android.shared import gyp_configuration as shared_configuration
+from starboard.tools.testing import test_filter
 
 
 def CreatePlatformConfig():
-  return shared_configuration.AndroidConfiguration(
+  return Androidx86Configuration(
       'android-x86',
       'x86',
       sabi_json_path='starboard/sabi/x86/sabi-v{sb_api_version}.json')
+
+
+class Androidx86Configuration(shared_configuration.AndroidConfiguration):
+
+  def GetTestFilters(self):
+    filters = super(Androidx86Configuration, self).GetTestFilters()
+    for target, tests in self.__FILTERED_TESTS.iteritems():
+      filters.extend(test_filter.TestFilter(target, test) for test in tests)
+    return filters
+
+  # A map of failing or crashing tests per target
+  __FILTERED_TESTS = {  # pylint: disable=invalid-name
+      'nplb': [
+          'SbAccessibilityTest.CallSetCaptionsEnabled',
+          'SbAccessibilityTest.GetCaptionSettingsReturnIsValid',
+          'SbAudioSinkTest.*',
+          'SbMicrophoneCloseTest.*',
+          'SbMicrophoneOpenTest.*',
+          'SbMicrophoneReadTest.*',
+          'SbPlayerWriteSampleTests/SbPlayerWriteSampleTest.*',
+          'SbSocketAddressTypes/SbSocketGetInterfaceAddressTest'
+          '.SunnyDaySourceForDestination/*',
+          'SbMediaSetAudioWriteDurationTests/SbMediaSetAudioWriteDurationTest'
+          '.WriteContinuedLimitedInput/*',
+      ],
+      'player_filter_tests': [
+          'VideoDecoderTests/VideoDecoderTest.MaxNumberOfCachedFrames/2',
+          'AudioDecoderTests/*',
+      ],
+  }
diff --git a/src/starboard/build/base_configuration.gypi b/src/starboard/build/base_configuration.gypi
index b8f6d94..a723315 100644
--- a/src/starboard/build/base_configuration.gypi
+++ b/src/starboard/build/base_configuration.gypi
@@ -81,6 +81,9 @@
     # Whether this is an evergreen build.
     'sb_evergreen': 0,
 
+    # Whether to use crashpad.
+    'sb_crashpad_enabled': 0,
+
     # Whether this is an evergreen compatible platform. A compatible platform
     # can run the elf_loader and launch the evergreen build.
     'sb_evergreen_compatible%': '<(sb_evergreen_compatible)',
diff --git a/src/starboard/build/gyp_functions.py b/src/starboard/build/gyp_functions.py
new file mode 100644
index 0000000..e6f466d
--- /dev/null
+++ b/src/starboard/build/gyp_functions.py
@@ -0,0 +1,177 @@
+# Copyright 2020 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.
+"""Gyp extensions, called with pymod_do_main."""
+import argparse
+import glob
+import logging
+import os
+import stat
+import sys
+
+
+# lifted from standard lib webbrowser.py
+def isexecutable(cmd):
+  """Returns whether the input file is an exectuable."""
+  if sys.platform[:3] == 'win':
+    extensions = ('.exe', '.bat', '.cmd')
+    cmd = cmd.lower()
+    if cmd.endswith(extensions) and os.path.isfile(cmd):
+      return cmd
+    for ext in extensions:
+      if os.path.isfile(cmd + ext):
+        return cmd + ext
+  else:
+    if os.path.isfile(cmd):
+      mode = os.stat(cmd)[stat.ST_MODE]
+      if mode & (stat.S_IXUSR | stat.S_IXGRP | stat.S_IXOTH):
+        return cmd
+
+
+class ExtensionCommandParser(argparse.ArgumentParser):
+  """Helper class for parsing arguments to extended gyp functions."""
+
+  def __init__(self, list_args):
+    argparse.ArgumentParser.__init__(self)
+    for arg in list_args:
+      self.add_argument(arg)
+
+  def error(self, message):
+    print('Parse error in gyp_functions.py:' + message)
+    raise NotImplementedError('Parse error:' + message)
+
+
+class Extensions(object):
+  """Container class for extended functionality for gyp.
+
+  Supports operations such as:
+    - file globbing
+    - checking file or directory existence
+    - string manipulations
+    - retrieving environment variables
+    - searching PATH and PYTHONPATH for programs.
+  """
+
+  def __init__(self, argv):
+    parser = argparse.ArgumentParser()
+    all_cmds = [x for x in dir(self) if not x.startswith('_')]
+    parser.add_argument('command', help='Command to run', choices=all_cmds)
+    args = parser.parse_args(argv[0:1])
+    self.argv = argv[1:]
+    self.command = args.command
+
+  def call(self):
+    return getattr(self, self.command)()
+
+  def file_glob(self):
+    """Glob files in dir, with pattern glob."""
+    args = ExtensionCommandParser(['dir', 'pattern']).parse_args(self.argv)
+    path = os.path.normpath(os.path.join(args.dir, args.pattern))
+    ret = ''
+    for f in glob.iglob(path):
+      ret += f.replace(os.sep, '/') + ' '
+    return ret.strip()
+
+  def basename(self):
+    """Basename of list of files"""
+    parser = ExtensionCommandParser([])
+    parser.add_argument('input_list', nargs='*')
+    args = parser.parse_args(self.argv)
+    ret = [os.path.basename(x) for x in args.input_list]
+    return ' '.join(ret)
+
+  def replace_in_list(self):
+    """String replace in a list of arguments"""
+    parser = ExtensionCommandParser(['old', 'new'])
+    parser.add_argument('input_list', nargs='*')
+    args = parser.parse_args(self.argv)
+    inp = args.input_list
+    return ' '.join([x.replace(args.old, args.new) for x in inp])
+
+  def file_glob_sub(self):
+    """Glob files, but return filenames with string replace from->to applied."""
+    args = ExtensionCommandParser(
+        ['dir', 'pattern', 'from_string', 'to_string']).parse_args(self.argv)
+    path = os.path.normpath(os.path.join(args.dir, args.pattern))
+    ret = ''
+    for f in glob.iglob(path):
+      ret += f.replace(os.sep, '/').replace(args.from_string,
+                                            args.to_string) + ' '
+    return ret.strip()
+
+  def file_exists(self):
+    """Checks if a file exists, returning a string '1' if so, or '0'."""
+    args = ExtensionCommandParser(['file']).parse_args(self.argv)
+    filepath = args.file.replace(os.sep, '/')
+    ret = os.path.isfile(filepath)
+    return str(int(ret))
+
+  def dir_exists(self):
+    """Checks if a directory exists, returning a string 'True' or 'False'."""
+    args = ExtensionCommandParser(['dir']).parse_args(self.argv)
+    return str(os.path.isdir(args.dir))
+
+  def str_upper(self):
+    """Converts an input string to upper case."""
+    if self.argv:
+      args = ExtensionCommandParser(['str']).parse_args(self.argv)
+      return args.str.upper()
+    return ''
+
+  def find_program(self):
+    """Searches for the input program name (.exe, .cmd or .bat)."""
+    args = ExtensionCommandParser(['program']).parse_args(self.argv)
+    paths_to_check = []
+    # Collect all paths in PYTHONPATH.
+    for i in sys.path:
+      paths_to_check.append(i.replace(os.sep, '/'))
+    # Then collect all paths in PATH.
+    for i in os.environ['PATH'].split(os.pathsep):
+      paths_to_check.append(i.replace(os.sep, '/'))
+    # Check all the collected paths for the program.
+    for path in paths_to_check:
+      exe = os.path.join(path, args.program)
+      prog = isexecutable(exe)
+      if prog:
+        return prog.replace(os.sep, '/')
+    # If not in PYTHONPATH and PATH, check upwards until root.
+    # Note: This is a rare case.
+    root_dir = os.path.dirname(os.path.abspath(__file__))
+    previous_dir = os.path.abspath(__file__)
+    while root_dir and root_dir != previous_dir:
+      exe = os.path.join(root_dir, args.program)
+      prog = isexecutable(exe)
+      if prog:
+        return prog.replace(os.sep, '/')
+      previous_dir = root_dir
+      root_dir = os.path.dirname(root_dir)
+    logging.error('Failed to find program "{}".'.format(args.program))
+    return None
+
+  def getenv(self):
+    """Gets the stored value of an environment variable."""
+    args = ExtensionCommandParser(['var']).parse_args(self.argv)
+    value = os.getenv(args.var)
+    if value is not None:
+      return value.strip()
+    return ''
+
+
+def DoMain(argv):  # pylint: disable=invalid-name
+  """Script main function."""
+  return Extensions(argv).call()
+
+
+if __name__ == '__main__':
+  print(DoMain(sys.argv[1:]))
+  sys.exit(0)
diff --git a/src/starboard/common/configuration_defaults.cc b/src/starboard/common/configuration_defaults.cc
index 6dbeb7b..6a933b9 100644
--- a/src/starboard/common/configuration_defaults.cc
+++ b/src/starboard/common/configuration_defaults.cc
@@ -30,7 +30,11 @@
 }
 
 const char* CobaltFallbackSplashScreenUrlDefault() {
-  return "none";
+  return "h5vcc-embedded://black_splash_screen.html";
+}
+
+const char* CobaltFallbackSplashScreenTopicsDefault() {
+  return "";
 }
 
 bool CobaltEnableQuicDefault() {
diff --git a/src/starboard/common/configuration_defaults.h b/src/starboard/common/configuration_defaults.h
index c79c210..06114f9 100644
--- a/src/starboard/common/configuration_defaults.h
+++ b/src/starboard/common/configuration_defaults.h
@@ -26,6 +26,8 @@
 
 const char* CobaltFallbackSplashScreenUrlDefault();
 
+const char* CobaltFallbackSplashScreenTopicsDefault();
+
 bool CobaltEnableQuicDefault();
 
 int CobaltSkiaCacheSizeInBytesDefault();
diff --git a/src/starboard/elf_loader/elf_loader.gyp b/src/starboard/elf_loader/elf_loader.gyp
index 7b6a565..4970ae0 100644
--- a/src/starboard/elf_loader/elf_loader.gyp
+++ b/src/starboard/elf_loader/elf_loader.gyp
@@ -53,21 +53,17 @@
         'src/include',
         'src/src/',
       ],
+      'conditions': [
+        ['sb_evergreen_compatible == 1', {
+          'variables': {
+            'sb_crashpad_enabled': 1,
+          },
+        },],
+      ],
       'dependencies': [
         '<(DEPTH)/starboard/elf_loader/evergreen_config.gyp:evergreen_config',
         '<(DEPTH)/starboard/elf_loader/evergreen_info.gyp:evergreen_info',
-        '<(DEPTH)/starboard/starboard.gyp:starboard_base',
-      ],
-      'conditions': [
-        ['sb_evergreen_compatible == 1', {
-          'dependencies': [
-            '<(DEPTH)/third_party/crashpad/wrapper/wrapper.gyp:crashpad_wrapper',
-          ],
-        }, {
-          'dependencies': [
-            '<(DEPTH)/third_party/crashpad/wrapper/wrapper.gyp:crashpad_wrapper_stub',
-          ],
-        }],
+        '<(DEPTH)/starboard/starboard.gyp:starboard',
       ],
       'sources': [
         '<@(common_elf_loader_sources)',
@@ -113,7 +109,7 @@
       'dependencies': [
         'elf_loader',
         '<(DEPTH)/cobalt/content/fonts/fonts.gyp:copy_font_data',
-        '<(DEPTH)/starboard/starboard.gyp:starboard_full',
+        '<(DEPTH)/starboard/starboard.gyp:starboard',
         # TODO: Remove this dependency once MediaSession is migrated to use CobaltExtensions.
         '<@(cobalt_platform_dependencies)',
       ],
@@ -149,7 +145,7 @@
       ],
       'dependencies': [
         'elf_loader_sys',
-        '<(DEPTH)/starboard/starboard.gyp:starboard_full',
+        '<(DEPTH)/starboard/starboard.gyp:starboard',
       ],
       'sources': [
         'sandbox.cc',
@@ -166,7 +162,7 @@
         '<(DEPTH)/starboard/common/test_main.cc',
       ],
       'dependencies': [
-        '<(DEPTH)/starboard/starboard.gyp:starboard_full',
+        '<(DEPTH)/starboard/starboard.gyp:starboard',
         # TODO: Remove this dependency once MediaSession is migrated to use CobaltExtensions.
         '<@(cobalt_platform_dependencies)',
         '<(DEPTH)/testing/gmock.gyp:gmock',
diff --git a/src/starboard/linux/shared/configuration.cc b/src/starboard/linux/shared/configuration.cc
index 4b0f775..bb7371e 100644
--- a/src/starboard/linux/shared/configuration.cc
+++ b/src/starboard/linux/shared/configuration.cc
@@ -32,7 +32,7 @@
 
 const CobaltExtensionConfigurationApi kConfigurationApi = {
     kCobaltExtensionConfigurationName,
-    1,
+    2,
     &common::CobaltUserOnExitStrategyDefault,
     &common::CobaltRenderDirtyRegionOnlyDefault,
     &CobaltEglSwapInterval,
@@ -55,6 +55,7 @@
     &common::CobaltGcZealDefault,
     &common::CobaltRasterizerTypeDefault,
     &common::CobaltEnableJitDefault,
+    &common::CobaltFallbackSplashScreenTopicsDefault,
 };
 
 }  // namespace
diff --git a/src/starboard/linux/x64x11/configuration_public.h b/src/starboard/linux/x64x11/configuration_public.h
index 38bcc2e..1fa3098 100644
--- a/src/starboard/linux/x64x11/configuration_public.h
+++ b/src/starboard/linux/x64x11/configuration_public.h
@@ -22,12 +22,6 @@
 #ifndef STARBOARD_LINUX_X64X11_CONFIGURATION_PUBLIC_H_
 #define STARBOARD_LINUX_X64X11_CONFIGURATION_PUBLIC_H_
 
-#if SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-#error \
-    "This platform's sabi.json file is expected to track the experimental " \
-"Starboard API version."
-#endif  // SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-
 // --- Architecture Configuration --------------------------------------------
 
 // Configuration parameters that allow the application to make some general
diff --git a/src/starboard/linux/x64x11/gczeal/configuration.cc b/src/starboard/linux/x64x11/gczeal/configuration.cc
index 6d80740..5a88df1 100644
--- a/src/starboard/linux/x64x11/gczeal/configuration.cc
+++ b/src/starboard/linux/x64x11/gczeal/configuration.cc
@@ -38,7 +38,7 @@
 
 const CobaltExtensionConfigurationApi kConfigurationApi = {
     kCobaltExtensionConfigurationName,
-    1,
+    2,
     &common::CobaltUserOnExitStrategyDefault,
     &common::CobaltRenderDirtyRegionOnlyDefault,
     &CobaltEglSwapInterval,
@@ -61,6 +61,7 @@
     &CobaltGcZeal,
     &common::CobaltRasterizerTypeDefault,
     &common::CobaltEnableJitDefault,
+    &common::CobaltFallbackSplashScreenTopicsDefault,
 };
 
 }  // namespace
diff --git a/src/starboard/linux/x64x11/skia/configuration.cc b/src/starboard/linux/x64x11/skia/configuration.cc
index 3b2e26a..0c57f18 100644
--- a/src/starboard/linux/x64x11/skia/configuration.cc
+++ b/src/starboard/linux/x64x11/skia/configuration.cc
@@ -38,7 +38,7 @@
 
 const CobaltExtensionConfigurationApi kConfigurationApi = {
     kCobaltExtensionConfigurationName,
-    1,
+    2,
     &common::CobaltUserOnExitStrategyDefault,
     &common::CobaltRenderDirtyRegionOnlyDefault,
     &CobaltEglSwapInterval,
@@ -61,6 +61,7 @@
     &common::CobaltGcZealDefault,
     &CobaltRasterizerType,
     &common::CobaltEnableJitDefault,
+    &common::CobaltFallbackSplashScreenTopicsDefault,
 };
 
 }  // namespace
diff --git a/src/starboard/linux/x64x11/skia/configuration_public.h b/src/starboard/linux/x64x11/skia/configuration_public.h
index 8879563..ed69d67a 100644
--- a/src/starboard/linux/x64x11/skia/configuration_public.h
+++ b/src/starboard/linux/x64x11/skia/configuration_public.h
@@ -18,14 +18,6 @@
 #ifndef STARBOARD_LINUX_X64X11_SKIA_CONFIGURATION_PUBLIC_H_
 #define STARBOARD_LINUX_X64X11_SKIA_CONFIGURATION_PUBLIC_H_
 
-// This is not a released configuration, so it should implement the
-// experimental API version to validate trunk's viability.
-#if SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-#error \
-    "This platform's sabi.json file is expected to track the experimental " \
-"Starboard API version."
-#endif  // SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-
 // Include the X64X11 Linux configuration.
 #include "starboard/linux/x64x11/configuration_public.h"
 
diff --git a/src/starboard/loader_app/installation_manager.cc b/src/starboard/loader_app/installation_manager.cc
index 9325c94..0401b50 100644
--- a/src/starboard/loader_app/installation_manager.cc
+++ b/src/starboard/loader_app/installation_manager.cc
@@ -574,20 +574,23 @@
 
 bool InstallationManager::SaveInstallationStore() {
   ValidatePriorities();
-  char buf[IM_MAX_INSTALLATION_STORE_SIZE];
+
   if (IM_MAX_INSTALLATION_STORE_SIZE < installation_store_.ByteSize()) {
     SB_LOG(ERROR) << "SaveInstallationStore: Data too large"
                   << installation_store_.ByteSize();
     return false;
   }
 
+  const size_t buf_size = installation_store_.ByteSize();
+  std::vector<char> buf(buf_size, 0);
   loader_app::SetPendingRestart(
       installation_store_.roll_forward_to_installation() != -1);
 
-  installation_store_.SerializeToArray(buf, installation_store_.ByteSize());
+  installation_store_.SerializeToArray(buf.data(),
+                                       installation_store_.ByteSize());
 
 #if SB_API_VERSION >= 12
-  if (!SbFileAtomicReplace(store_path_.c_str(), buf,
+  if (!SbFileAtomicReplace(store_path_.c_str(), buf.data(),
                            installation_store_.ByteSize())) {
     SB_LOG(ERROR)
         << "SaveInstallationStore: Failed to store installation store: "
diff --git a/src/starboard/nplb/mutex_acquire_test.cc b/src/starboard/nplb/mutex_acquire_test.cc
index c37a465..81ad198 100644
--- a/src/starboard/nplb/mutex_acquire_test.cc
+++ b/src/starboard/nplb/mutex_acquire_test.cc
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
 #include "starboard/configuration.h"
+#include "starboard/mutex.h"
 #include "starboard/thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
diff --git a/src/starboard/nplb/mutex_acquire_try_test.cc b/src/starboard/nplb/mutex_acquire_try_test.cc
index ccd7e5b..e38e897 100644
--- a/src/starboard/nplb/mutex_acquire_try_test.cc
+++ b/src/starboard/nplb/mutex_acquire_try_test.cc
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
 #include "starboard/configuration.h"
+#include "starboard/mutex.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if SB_API_VERSION >= 12
diff --git a/src/starboard/nplb/mutex_create_test.cc b/src/starboard/nplb/mutex_create_test.cc
index 8c11eaa..f52ba08 100644
--- a/src/starboard/nplb/mutex_create_test.cc
+++ b/src/starboard/nplb/mutex_create_test.cc
@@ -12,8 +12,8 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
 #include "starboard/configuration.h"
+#include "starboard/mutex.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #if SB_API_VERSION >= 12
diff --git a/src/starboard/nplb/mutex_destroy_test.cc b/src/starboard/nplb/mutex_destroy_test.cc
index e555b70..5df8a3a 100644
--- a/src/starboard/nplb/mutex_destroy_test.cc
+++ b/src/starboard/nplb/mutex_destroy_test.cc
@@ -14,8 +14,8 @@
 
 // Destroy is mostly Sunny Day tested in Create.
 
-#include "starboard/common/mutex.h"
 #include "starboard/configuration.h"
+#include "starboard/mutex.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace starboard {
diff --git a/src/starboard/nplb/nplb_evergreen_compat_tests/sabi_test.cc b/src/starboard/nplb/nplb_evergreen_compat_tests/sabi_test.cc
index 60b6d6e..ac659ac 100644
--- a/src/starboard/nplb/nplb_evergreen_compat_tests/sabi_test.cc
+++ b/src/starboard/nplb/nplb_evergreen_compat_tests/sabi_test.cc
@@ -155,6 +155,12 @@
 };
 
 TEST_F(SabiTest, VerifySABI) {
+  SB_LOG(INFO) << "Using SB_API_VERSION=" << SB_API_VERSION;
+  SB_LOG(INFO) << "Using SABI=" << SB_SABI_JSON_ID;
+
+  ASSERT_LT(SB_API_VERSION, SB_EXPERIMENTAL_API_VERSION)
+      << "Evergreen should use SB_API_VERSION < SB_EXPERIMENTAL_API_VERSION";
+
   std::set<std::string> sabi_set;
   sabi_set.insert(kSabiJsonIdArmHardfp);
   sabi_set.insert(kSabiJsonIdArmSoftfp);
diff --git a/src/starboard/raspi/2/skia/configuration.cc b/src/starboard/raspi/2/skia/configuration.cc
index 58a6f11..925b92b 100644
--- a/src/starboard/raspi/2/skia/configuration.cc
+++ b/src/starboard/raspi/2/skia/configuration.cc
@@ -38,7 +38,7 @@
 
 const CobaltExtensionConfigurationApi kConfigurationApi = {
     kCobaltExtensionConfigurationName,
-    1,
+    2,
     &common::CobaltUserOnExitStrategyDefault,
     &common::CobaltRenderDirtyRegionOnlyDefault,
     &common::CobaltEglSwapIntervalDefault,
@@ -61,6 +61,7 @@
     &common::CobaltGcZealDefault,
     &CobaltRasterizerType,
     &common::CobaltEnableJitDefault,
+    &common::CobaltFallbackSplashScreenTopicsDefault,
 };
 
 }  // namespace
diff --git a/src/starboard/raspi/shared/configuration.cc b/src/starboard/raspi/shared/configuration.cc
index b3a9f0b..74ab33e 100644
--- a/src/starboard/raspi/shared/configuration.cc
+++ b/src/starboard/raspi/shared/configuration.cc
@@ -32,7 +32,7 @@
 }
 const CobaltExtensionConfigurationApi kConfigurationApi = {
     kCobaltExtensionConfigurationName,
-    1,
+    2,
     &common::CobaltUserOnExitStrategyDefault,
     &common::CobaltRenderDirtyRegionOnlyDefault,
     &common::CobaltEglSwapIntervalDefault,
@@ -55,6 +55,7 @@
     &common::CobaltGcZealDefault,
     &common::CobaltRasterizerTypeDefault,
     &common::CobaltEnableJitDefault,
+    &common::CobaltFallbackSplashScreenTopicsDefault,
 };
 
 }  // namespace
diff --git a/src/starboard/raspi/shared/configuration_public.h b/src/starboard/raspi/shared/configuration_public.h
index 05988f6..3478725 100644
--- a/src/starboard/raspi/shared/configuration_public.h
+++ b/src/starboard/raspi/shared/configuration_public.h
@@ -17,12 +17,6 @@
 #ifndef STARBOARD_RASPI_SHARED_CONFIGURATION_PUBLIC_H_
 #define STARBOARD_RASPI_SHARED_CONFIGURATION_PUBLIC_H_
 
-#if SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-#error \
-    "This platform's sabi.json file is expected to track the experimental " \
-"Starboard API version."
-#endif  // SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-
 // --- Architecture Configuration --------------------------------------------
 
 // --- System Header Configuration -------------------------------------------
diff --git a/src/starboard/sabi/sabi.py b/src/starboard/sabi/sabi.py
index 09d04a3..3d95166 100644
--- a/src/starboard/sabi/sabi.py
+++ b/src/starboard/sabi/sabi.py
@@ -13,4 +13,4 @@
 # limitations under the License.
 """Source of truth of the default/experimental Starboard API version."""
 
-SB_API_VERSION = 13
+SB_API_VERSION = 12
diff --git a/src/starboard/shared/pthread/mutex_acquire.cc b/src/starboard/shared/pthread/mutex_acquire.cc
index 67f26b4..6183f7d 100644
--- a/src/starboard/shared/pthread/mutex_acquire.cc
+++ b/src/starboard/shared/pthread/mutex_acquire.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 #include <pthread.h>
 
diff --git a/src/starboard/shared/pthread/mutex_acquire_try.cc b/src/starboard/shared/pthread/mutex_acquire_try.cc
index 4c216a5..8c5c241 100644
--- a/src/starboard/shared/pthread/mutex_acquire_try.cc
+++ b/src/starboard/shared/pthread/mutex_acquire_try.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 #include <pthread.h>
 
diff --git a/src/starboard/shared/pthread/mutex_create.cc b/src/starboard/shared/pthread/mutex_create.cc
index e72884d..55b6a94 100644
--- a/src/starboard/shared/pthread/mutex_create.cc
+++ b/src/starboard/shared/pthread/mutex_create.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 #include <pthread.h>
 
diff --git a/src/starboard/shared/pthread/mutex_destroy.cc b/src/starboard/shared/pthread/mutex_destroy.cc
index c131595..f2d0b15 100644
--- a/src/starboard/shared/pthread/mutex_destroy.cc
+++ b/src/starboard/shared/pthread/mutex_destroy.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 #include <pthread.h>
 
diff --git a/src/starboard/shared/pthread/mutex_release.cc b/src/starboard/shared/pthread/mutex_release.cc
index fcd7de7..d2ce183 100644
--- a/src/starboard/shared/pthread/mutex_release.cc
+++ b/src/starboard/shared/pthread/mutex_release.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 #include <pthread.h>
 
diff --git a/src/starboard/shared/signal/suspend_signals.cc b/src/starboard/shared/signal/suspend_signals.cc
index e58e065..c728e5f 100644
--- a/src/starboard/shared/signal/suspend_signals.cc
+++ b/src/starboard/shared/signal/suspend_signals.cc
@@ -58,26 +58,10 @@
   ::sigaction(signal_id, &action, NULL);
 }
 
-#if SB_IS(EVERGREEN_COMPATIBLE)
-void RequestSuspendOrStop() {
-  if (loader_app::IsPendingRestart()) {
-    SbLogRawFormatF("\nPending update restart . Stopping.\n");
-    SbLogFlush();
-    SbSystemRequestStop(0);
-  } else {
-    SbSystemRequestSuspend();
-  }
-}
-#endif
-
 void Suspend(int signal_id) {
   SignalMask(kAllSignals, SIG_BLOCK);
   LogSignalCaught(signal_id);
-#if SB_IS(EVERGREEN_COMPATIBLE)
-  RequestSuspendOrStop();
-#else
   SbSystemRequestSuspend();
-#endif
   SignalMask(kAllSignals, SIG_UNBLOCK);
 }
 
diff --git a/src/starboard/shared/signal/system_request_suspend.cc b/src/starboard/shared/signal/system_request_suspend.cc
index e76ee39..0ea5fa8 100644
--- a/src/starboard/shared/signal/system_request_suspend.cc
+++ b/src/starboard/shared/signal/system_request_suspend.cc
@@ -17,11 +17,26 @@
 #include "starboard/shared/signal/signal_internal.h"
 #include "starboard/shared/starboard/application.h"
 
+#if SB_IS(EVERGREEN_COMPATIBLE)
+#include "starboard/loader_app/pending_restart.h"
+#endif
+
 void SuspendDone(void* context) {
   // Stop all thread execution after fully transitioning into Suspended.
   raise(SIGSTOP);
 }
 
 void SbSystemRequestSuspend() {
+#if SB_IS(EVERGREEN_COMPATIBLE)
+  if (starboard::loader_app::IsPendingRestart()) {
+    SbLogRawFormatF("\nPending update restart . Stopping.\n");
+    SbLogFlush();
+    starboard::shared::starboard::Application::Get()->Stop(0);
+  } else {
+    starboard::shared::starboard::Application::Get()->Suspend(NULL,
+                                                              &SuspendDone);
+  }
+#else
   starboard::shared::starboard::Application::Get()->Suspend(NULL, &SuspendDone);
+#endif
 }
diff --git a/src/starboard/shared/starboard/audio_sink/audio_sink_internal.h b/src/starboard/shared/starboard/audio_sink/audio_sink_internal.h
index bffc40a..c1cf847 100644
--- a/src/starboard/shared/starboard/audio_sink/audio_sink_internal.h
+++ b/src/starboard/shared/starboard/audio_sink/audio_sink_internal.h
@@ -27,6 +27,7 @@
   // When |capability_changed| is true, it hints that the error is caused by a
   // a transisent capability on the platform.  The app should retry playback to
   // recover from the error.
+  // TODO: Allow to pass an error message.
   typedef void (*ErrorFunc)(bool capability_changed, void* context);
 #endif  // SB_API_VERSION >= 12
 
diff --git a/src/starboard/shared/starboard/media/media_util.cc b/src/starboard/shared/starboard/media/media_util.cc
index 3269d04..d10b991 100644
--- a/src/starboard/shared/starboard/media/media_util.cc
+++ b/src/starboard/shared/starboard/media/media_util.cc
@@ -623,6 +623,20 @@
   return "Invalid";
 }
 
+#if SB_API_VERSION >= 11
+bool IsAudioSampleInfoSubstantiallyDifferent(
+    const SbMediaAudioSampleInfo& left,
+    const SbMediaAudioSampleInfo& right) {
+  return left.codec != right.codec ||
+         left.samples_per_second != right.samples_per_second ||
+         left.number_of_channels != right.number_of_channels ||
+         left.audio_specific_config_size != right.audio_specific_config_size ||
+         SbMemoryCompare(left.audio_specific_config,
+                         right.audio_specific_config,
+                         left.audio_specific_config_size) != 0;
+}
+#endif  // SB_API_VERSION < 11
+
 }  // namespace media
 }  // namespace starboard
 }  // namespace shared
diff --git a/src/starboard/shared/starboard/media/media_util.h b/src/starboard/shared/starboard/media/media_util.h
index 72edc89..15a9742 100644
--- a/src/starboard/shared/starboard/media/media_util.h
+++ b/src/starboard/shared/starboard/media/media_util.h
@@ -104,6 +104,14 @@
 const char* GetMatrixIdName(SbMediaMatrixId matrix_id);
 const char* GetRangeIdName(SbMediaRangeId range_id);
 
+#if SB_API_VERSION >= 11
+//  When this function returns true, usually indicates that the two sample info
+//  cannot be processed by the same audio decoder.
+bool IsAudioSampleInfoSubstantiallyDifferent(
+    const SbMediaAudioSampleInfo& left,
+    const SbMediaAudioSampleInfo& right);
+#endif  // SB_API_VERSION < 11
+
 }  // namespace media
 }  // namespace starboard
 }  // namespace shared
diff --git a/src/starboard/shared/starboard/player/decoded_audio_internal.cc b/src/starboard/shared/starboard/player/decoded_audio_internal.cc
index 1e21a40..aca60f5 100644
--- a/src/starboard/shared/starboard/player/decoded_audio_internal.cc
+++ b/src/starboard/shared/starboard/player/decoded_audio_internal.cc
@@ -81,10 +81,11 @@
 
   if (samples_per_second == 0 || frames_to_remove < 0 ||
       frames_to_remove >= frames()) {
-    SB_LOG(WARNING) << "AdjustForSeekTime failed for seeking_to_time at "
-                    << seeking_to_time << " for samples_per_second "
-                    << samples_per_second << ", and there are " << frames()
-                    << " frames in the DecodedAudio object.";
+    SB_LOG(WARNING) << "AdjustForSeekTime failed for seeking_to_time: "
+                    << seeking_to_time
+                    << ", samples_per_second: " << samples_per_second
+                    << ", timestamp: " << timestamp() << ", and there are "
+                    << frames() << " frames in the DecodedAudio object.";
     return;
   }
 
diff --git a/src/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.cc b/src/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.cc
index ae3b448..8eba0ca 100644
--- a/src/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.cc
+++ b/src/starboard/shared/starboard/player/filter/adaptive_audio_decoder_internal.cc
@@ -17,6 +17,7 @@
 #include "starboard/audio_sink.h"
 #include "starboard/common/log.h"
 #include "starboard/common/reset_and_return.h"
+#include "starboard/shared/starboard/media/media_util.h"
 #include "starboard/shared/starboard/player/decoded_audio_internal.h"
 
 namespace starboard {
@@ -34,29 +35,6 @@
       kDefaultOutputSamplesPerSecond);
 }
 
-bool IsResetDecoderNecessary(const SbMediaAudioSampleInfo& current_info,
-                             const SbMediaAudioSampleInfo& new_info) {
-  if (current_info.codec != new_info.codec) {
-    return true;
-  }
-  if (current_info.samples_per_second != new_info.samples_per_second) {
-    return true;
-  }
-  if (current_info.number_of_channels != new_info.number_of_channels) {
-    return true;
-  }
-  if (current_info.audio_specific_config_size !=
-      new_info.audio_specific_config_size) {
-    return true;
-  }
-  if (SbMemoryCompare(current_info.audio_specific_config,
-                      new_info.audio_specific_config,
-                      current_info.audio_specific_config_size) != 0) {
-    return true;
-  }
-  return false;
-}
-
 AdaptiveAudioDecoder::AdaptiveAudioDecoder(
     const SbMediaAudioSampleInfo& audio_sample_info,
     SbDrmSystem drm_system,
@@ -107,8 +85,8 @@
     }
     return;
   }
-  if (IsResetDecoderNecessary(input_audio_sample_info_,
-                              input_buffer->audio_sample_info())) {
+  if (starboard::media::IsAudioSampleInfoSubstantiallyDifferent(
+          input_audio_sample_info_, input_buffer->audio_sample_info())) {
     flushing_ = true;
     pending_input_buffer_ = input_buffer;
     pending_consumed_cb_ = consumed_cb;
diff --git a/src/starboard/shared/stub/mutex_acquire.cc b/src/starboard/shared/stub/mutex_acquire.cc
index cede4d1..423202e 100644
--- a/src/starboard/shared/stub/mutex_acquire.cc
+++ b/src/starboard/shared/stub/mutex_acquire.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 SbMutexResult SbMutexAcquire(SbMutex* mutex) {
   return kSbMutexDestroyed;
diff --git a/src/starboard/shared/stub/mutex_acquire_try.cc b/src/starboard/shared/stub/mutex_acquire_try.cc
index a9f1ba8..efc87b6 100644
--- a/src/starboard/shared/stub/mutex_acquire_try.cc
+++ b/src/starboard/shared/stub/mutex_acquire_try.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 SbMutexResult SbMutexAcquireTry(SbMutex* mutex) {
   return kSbMutexDestroyed;
diff --git a/src/starboard/shared/stub/mutex_create.cc b/src/starboard/shared/stub/mutex_create.cc
index 11586de..4439ee0 100644
--- a/src/starboard/shared/stub/mutex_create.cc
+++ b/src/starboard/shared/stub/mutex_create.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 bool SbMutexCreate(SbMutex* mutex) {
   return false;
diff --git a/src/starboard/shared/stub/mutex_destroy.cc b/src/starboard/shared/stub/mutex_destroy.cc
index 7922ddd..b88ae22 100644
--- a/src/starboard/shared/stub/mutex_destroy.cc
+++ b/src/starboard/shared/stub/mutex_destroy.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 bool SbMutexDestroy(SbMutex* mutex) {
   return false;
diff --git a/src/starboard/shared/stub/mutex_release.cc b/src/starboard/shared/stub/mutex_release.cc
index 88e6071..207b642 100644
--- a/src/starboard/shared/stub/mutex_release.cc
+++ b/src/starboard/shared/stub/mutex_release.cc
@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include "starboard/common/mutex.h"
+#include "starboard/mutex.h"
 
 bool SbMutexRelease(SbMutex* mutex) {
   return false;
diff --git a/src/starboard/starboard.gyp b/src/starboard/starboard.gyp
index 0808490..9c74ba2 100644
--- a/src/starboard/starboard.gyp
+++ b/src/starboard/starboard.gyp
@@ -19,7 +19,7 @@
 {
   'targets': [
     {
-      'target_name': 'starboard_base',
+      'target_name': 'starboard',
       'type': 'none',
       'conditions': [
         ['sb_evergreen == 1', {
@@ -37,14 +37,6 @@
             'starboard_full',
           ],
         }],
-       ],
-    },
-    {
-      'target_name': 'starboard',
-      'type': 'none',
-      'dependencies': [
-        '<(DEPTH)/third_party/crashpad/wrapper/wrapper.gyp:crashpad_wrapper_stub',
-        'starboard_base',
       ],
     },
     {
@@ -60,6 +52,15 @@
         '<(DEPTH)/<(starboard_path)/starboard_platform.gyp:starboard_platform',
       ],
       'conditions': [
+        ['sb_crashpad_enabled == 1', {
+          'dependencies': [
+            '<(DEPTH)/third_party/crashpad/wrapper/wrapper.gyp:crashpad_wrapper',
+          ],
+        }, {
+          'dependencies': [
+            '<(DEPTH)/third_party/crashpad/wrapper/wrapper.gyp:crashpad_wrapper_stub',
+          ],
+        }],
         ['final_executable_type=="shared_library"', {
           'all_dependent_settings': {
             'target_conditions': [
diff --git a/src/starboard/stub/configuration.cc b/src/starboard/stub/configuration.cc
index 6af5309..1f9a6dd 100644
--- a/src/starboard/stub/configuration.cc
+++ b/src/starboard/stub/configuration.cc
@@ -28,7 +28,7 @@
 
 const CobaltExtensionConfigurationApi kConfigurationApi = {
     kCobaltExtensionConfigurationName,
-    1,
+    2,
     &common::CobaltUserOnExitStrategyDefault,
     &common::CobaltRenderDirtyRegionOnlyDefault,
     &common::CobaltEglSwapIntervalDefault,
@@ -51,6 +51,7 @@
     &common::CobaltGcZealDefault,
     &CobaltRasterizerType,
     &common::CobaltEnableJitDefault,
+    &common::CobaltFallbackSplashScreenTopicsDefault,
 };
 
 }  // namespace
diff --git a/src/starboard/stub/configuration_public.h b/src/starboard/stub/configuration_public.h
index f27313c..cc64e9d 100644
--- a/src/starboard/stub/configuration_public.h
+++ b/src/starboard/stub/configuration_public.h
@@ -22,12 +22,6 @@
 #ifndef STARBOARD_STUB_CONFIGURATION_PUBLIC_H_
 #define STARBOARD_STUB_CONFIGURATION_PUBLIC_H_
 
-#if SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-#error \
-    "This platform's sabi.json file is expected to track the experimental " \
-"Starboard API version."
-#endif  // SB_API_VERSION != SB_EXPERIMENTAL_API_VERSION
-
 // --- Architecture Configuration --------------------------------------------
 
 // Some platforms will not align variables on the stack with an alignment
diff --git a/src/starboard/tools/abstract_launcher.py b/src/starboard/tools/abstract_launcher.py
index 1ba0165..51a9d3c 100644
--- a/src/starboard/tools/abstract_launcher.py
+++ b/src/starboard/tools/abstract_launcher.py
@@ -23,6 +23,10 @@
 from starboard.tools import build
 from starboard.tools import paths
 
+ARG_NOINSTALL = "noinstall"
+ARG_SYSTOOLS = "systools"
+ARG_DRYRUN = "dryrun"
+
 
 def _GetLauncherForPlatform(platform_name):
   """Gets the module containing a platform's concrete launcher implementation.
@@ -125,6 +129,11 @@
       env_variables = {}
     self.env_variables = env_variables
 
+    launcher_args = kwargs.get("launcher_args", None)
+    if launcher_args is None:
+      launcher_args = []
+    self.launcher_args = launcher_args
+
     # Launchers that need different startup timeout times should reassign
     # this variable during initialization.
     self.startup_timeout_seconds = 2 * 60
diff --git a/src/starboard/tools/app_launcher_packager.py b/src/starboard/tools/app_launcher_packager.py
index 9090373..ee8ade8 100644
--- a/src/starboard/tools/app_launcher_packager.py
+++ b/src/starboard/tools/app_launcher_packager.py
@@ -24,6 +24,7 @@
 import logging
 import os
 import shutil
+import string
 import sys
 import tempfile
 
@@ -32,21 +33,18 @@
 from paths import THIRD_PARTY_ROOT
 sys.path.append(THIRD_PARTY_ROOT)
 # pylint: disable=g-import-not-at-top,g-bad-import-order
-import jinja2
 from starboard.tools import port_symlink
 import starboard.tools.platform
 
 # Default python directories to app launcher resources.
 _INCLUDE_FILE_PATTERNS = [
-    ('buildbot', '*.py'),
+    ('buildbot', '_env.py'),  # Only needed for device_server to execute
+    ('buildbot', '__init__.py'),  # Only needed for device_server to execute
+    ('buildbot/device_server', '*.py'),
     ('buildbot/device_server/shared/ssl_certs', '*'),
     ('cobalt', '*.py'),
-    # TODO: Test and possibly prune.
-    ('lbshell', '*.py'),
     ('starboard', '*.py'),
-    # jinja2 required by this app_launcher_packager.py script.
-    ('third_party/jinja2', '*.py'),
-    ('third_party/markupsafe', '*.py'),  # Required by third_party/jinja2
+    ('starboard/tools', 'platform.py.template')
 ]
 
 _INCLUDE_BLACK_BOX_TESTS_PATTERNS = [
@@ -124,7 +122,7 @@
   logging.info('Baking platform info files.')
   current_file = os.path.abspath(__file__)
   current_dir = os.path.dirname(current_file)
-  dest_dir = current_dir.replace(repo_root, dest_root)
+  dest_dir = os.path.join(dest_root, 'starboard', 'tools')
   platforms_map = {}
   for p in starboard.tools.platform.GetAll():
     platform_path = os.path.relpath(
@@ -132,10 +130,11 @@
     # Store posix paths even on Windows so MH Linux hosts can use them.
     # The template has code to re-normalize them when used on Windows hosts.
     platforms_map[p] = platform_path.replace('\\', '/')
-  template = jinja2.Template(
+  template = string.Template(
       open(os.path.join(current_dir, 'platform.py.template')).read())
   with open(os.path.join(dest_dir, 'platform.py'), 'w+') as f:
-    template.stream(platforms_map=platforms_map).dump(f, encoding='utf-8')
+    sub = template.substitute(platforms_map=platforms_map)
+    f.write(sub.encode('utf-8'))
   logging.info('Finished baking in platform info files.')
 
 
@@ -257,7 +256,11 @@
       help='List to stdout the application resources relative to the current '
       'directory.')
   parser.add_argument(
-      '-v', '--verbose', action='store_true', help='Verbose logging output.')
+      '-v',
+      '--verbose',
+      action='store_true',
+      help='Enables verbose logging. For more control over the '
+      "logging level use '--log_level' instead.")
   args = parser.parse_args(command_args)
 
   if not args.verbose:
diff --git a/src/starboard/tools/platform.py.template b/src/starboard/tools/platform.py.template
index 17d55b5..204d415 100644
--- a/src/starboard/tools/platform.py.template
+++ b/src/starboard/tools/platform.py.template
@@ -20,7 +20,7 @@
 from starboard.tools import environment
 
 # The name->platform path mapping.
-_PATH_MAP = {{platforms_map}}
+_PATH_MAP = $platforms_map
 _PATH_MAP = {k:os.path.normpath(v) for k,v in _PATH_MAP.iteritems()}
 
 
diff --git a/src/starboard/tools/testing/test_runner.py b/src/starboard/tools/testing/test_runner.py
index e6ca771..562bb25 100755
--- a/src/starboard/tools/testing/test_runner.py
+++ b/src/starboard/tools/testing/test_runner.py
@@ -218,7 +218,8 @@
                application_name=None,
                dry_run=False,
                xml_output_dir=None,
-               log_xml_results=False):
+               log_xml_results=False,
+               launcher_args=None):
     self.platform = platform
     self.config = config
     self.loader_platform = loader_platform
@@ -227,6 +228,7 @@
     self.target_params = target_params
     self.out_directory = out_directory
     self.loader_out_directory = loader_out_directory
+    self.launcher_args = launcher_args
     if not self.out_directory:
       self.out_directory = paths.BuildOutputDirectory(self.platform,
                                                       self.config)
@@ -336,6 +338,7 @@
     return final_targets
 
   def _GetTestFilters(self):
+    """Get test filters for a given platform and configuration."""
     filters = self._platform_config.GetTestFilters()
     app_filters = self._app_config.GetTestFilters()
     if app_filters:
@@ -348,10 +351,10 @@
       loader_platform_config = build.GetPlatformConfig(self.loader_platform)
       loader_app_config = loader_platform_config.GetApplicationConfiguration(
           self.application_name)
-      for filter in (loader_platform_config.GetTestFilters() +
-                     loader_app_config.GetTestFilters()):
-        if filter not in filters:
-          filters.append(filter)
+      for filter_ in (loader_platform_config.GetTestFilters() +
+                      loader_app_config.GetTestFilters()):
+        if filter_ not in filters:
+          filters.append(filter_)
     return filters
 
   def _GetAllTestEnvVariables(self):
@@ -430,7 +433,8 @@
         env_variables=env,
         loader_platform=self.loader_platform,
         loader_config=self.loader_config,
-        loader_out_directory=self.loader_out_directory)
+        loader_out_directory=self.loader_out_directory,
+        launcher_args=self.launcher_args)
 
     test_reader = TestLineReader(read_pipe)
     test_launcher = TestLauncher(launcher)
@@ -547,10 +551,10 @@
     total_flaky_failed_count = 0
     total_filtered_count = 0
 
-    print  # Explicit print for empty formatting line.
+    print()  # Explicit print for empty formatting line.
     logging.info("TEST RUN COMPLETE.")
     if results:
-      print  # Explicit print for empty formatting line.
+      print()  # Explicit print for empty formatting line.
 
     # If the number of run tests from a test binary cannot be
     # determined, assume an error occurred while running it.
@@ -594,7 +598,7 @@
             # Sometimes the returned test "name" includes information about the
             # parameter that was passed to it. This needs to be stripped off.
             retry_result = self._RunTest(target_name, test_case.split(",")[0])
-            print  # Explicit print for empty formatting line.
+            print()  # Explicit print for empty formatting line.
             if retry_result[2] == 1:
               flaky_passed_tests.append(test_case)
               logging.info("%s succeeded on run #%d!\n", test_case, retry + 2)
@@ -707,11 +711,12 @@
       # tests so we need to build it separately.
       if self.loader_platform:
         build_tests.BuildTargets(
-            [_LOADER_TARGET, _CRASHPAD_TARGET], self.loader_out_directory, self.dry_run,
-            extra_flags + [os.getenv('TEST_RUNNER_PLATFORM_BUILD_FLAGS', '')])
+            [_LOADER_TARGET, _CRASHPAD_TARGET], self.loader_out_directory,
+            self.dry_run,
+            extra_flags + [os.getenv("TEST_RUNNER_PLATFORM_BUILD_FLAGS", "")])
       build_tests.BuildTargets(
           self.test_targets, self.out_directory, self.dry_run,
-          extra_flags + [os.getenv('TEST_RUNNER_BUILD_FLAGS', '')])
+          extra_flags + [os.getenv("TEST_RUNNER_BUILD_FLAGS", "")])
 
     except subprocess.CalledProcessError as e:
       result = False
@@ -827,6 +832,13 @@
       action="store_true",
       help="If set, results will be logged in xml format after all tests are"
       " complete. --xml_output_dir will be ignored.")
+  arg_parser.add_argument(
+      "-w",
+      "--launcher_args",
+      help="Pass space-separated arguments to control launcher behaviour. "
+      "Arguments are plaform specific and may not be implemented for all "
+      "platforms. Common arguments are:\n\t'noinstall' - skip install steps "
+      "before running the test\n\t'systools' - use system-installed tools.")
   args = arg_parser.parse_args()
 
   if (args.loader_platform and not args.loader_config or
@@ -840,12 +852,19 @@
   if args.target_params:
     target_params = args.target_params.split(" ")
 
+  launcher_args = []
+  if args.launcher_args:
+    launcher_args = args.launcher_args.split(" ")
+
+  if args.dry_run:
+    launcher_args.append(abstract_launcher.ARG_DRYRUN)
+
   runner = TestRunner(args.platform, args.config, args.loader_platform,
                       args.loader_config, args.device_id, args.target_name,
                       target_params, args.out_directory,
                       args.loader_out_directory, args.platform_tests_only,
                       args.application_name, args.dry_run, args.xml_output_dir,
-                      args.log_xml_results)
+                      args.log_xml_results, launcher_args)
 
   def Abort(signum, frame):
     del signum, frame  # Unused.
diff --git a/src/starboard/tools/toolchain/cmd.py b/src/starboard/tools/toolchain/cmd.py
index 15a7963..cb30844 100644
--- a/src/starboard/tools/toolchain/cmd.py
+++ b/src/starboard/tools/toolchain/cmd.py
@@ -27,6 +27,10 @@
 class Shell(abstract.Shell):
   """Constructs command lines using Cmd syntax."""
 
+  def __init__(self, quote=True):
+    # Toggle whether or not to quote command line arguments.
+    self.quote = quote
+
   def MaybeQuoteArgument(self, arg):
     # Rather than attempting to enumerate the bad shell characters, just
     # whitelist common OK ones and quote anything else.
@@ -76,7 +80,10 @@
 
   def Join(self, command):
     assert not isinstance(command, basestring)
-    return ' '.join(self.MaybeQuoteArgument(argument) for argument in command)
+    if self.quote:
+      return ' '.join(self.MaybeQuoteArgument(argument) for argument in command)
+    else:
+      return ' '.join(command)
 
   def And(self, *commands):
     return ' && '.join(_MaybeJoin(self, command) for command in commands)
diff --git a/src/starboard/tools/toolchain/python.py b/src/starboard/tools/toolchain/python.py
index bee8841..0f32d88 100644
--- a/src/starboard/tools/toolchain/python.py
+++ b/src/starboard/tools/toolchain/python.py
@@ -11,18 +11,19 @@
 # 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.
-"""Allow to use gyp-win-tool via python as a copy and a stamp tools."""
+"""Allow use of gyp-win-tool via python as copy and stamp tools."""
 
 import sys
 from starboard.tools.toolchain import abstract
 
 
 class Copy(abstract.Copy):
-  """Copies individual files using python.exe."""
+  """Copies individual files."""
 
   def __init__(self, **kwargs):
     self._path = kwargs.get('path', sys.executable)
-    self._extra_flags = kwargs.get('extra_flags', [])
+    self._extra_flags = kwargs.get('extra_flags',
+                                   ['gyp-win-tool', 'recursive-mirror'])
 
   def GetPath(self):
     return self._path
@@ -55,7 +56,7 @@
 
   def __init__(self, **kwargs):
     self._path = kwargs.get('path', sys.executable)
-    self._extra_flags = kwargs.get('extra_flags', [])
+    self._extra_flags = kwargs.get('extra_flags', ['gyp-win-tool', 'stamp'])
 
   def GetPath(self):
     return self._path
diff --git a/src/third_party/angle/include/platform/Platform.h b/src/third_party/angle/include/platform/Platform.h
index 09505a3..1035f8e 100644
--- a/src/third_party/angle/include/platform/Platform.h
+++ b/src/third_party/angle/include/platform/Platform.h
@@ -236,11 +236,11 @@
 using ProgramKeyType   = std::array<uint8_t, 20>;
 using CacheProgramFunc = void (*)(PlatformMethods *platform,
                                   const ProgramKeyType &key,
-                                  size_t programSize,
+                                  std::size_t programSize,
                                   const uint8_t *programBytes);
 inline void DefaultCacheProgram(PlatformMethods *platform,
                                 const ProgramKeyType &key,
-                                size_t programSize,
+                                std::size_t programSize,
                                 const uint8_t *programBytes)
 {}
 
diff --git a/src/third_party/crashpad/util/file/file_io.h b/src/third_party/crashpad/util/file/file_io.h
index 6fa0f96..46b1ee6 100644
--- a/src/third_party/crashpad/util/file/file_io.h
+++ b/src/third_party/crashpad/util/file/file_io.h
@@ -19,6 +19,7 @@
 
 #include <string>
 
+#include "base/base_wrapper.h"
 #include "build/build_config.h"
 
 #if defined(OS_POSIX)
diff --git a/src/third_party/crashpad/util/net/http_transport_socket.cc b/src/third_party/crashpad/util/net/http_transport_socket.cc
index 5a88ccd..278a8b8 100644
--- a/src/third_party/crashpad/util/net/http_transport_socket.cc
+++ b/src/third_party/crashpad/util/net/http_transport_socket.cc
@@ -144,7 +144,12 @@
                            kSbFileSepString + "cobalt" + kSbFileSepString +
                            "content" + kSbFileSepString + "ssl" +
                            kSbFileSepString + "certs");
-
+      // If this is not Cobalt Evergreen setup use the regular content path.
+      if (!SbFileExists(cert_location.c_str())) {
+        cert_location = buffer.data();
+        cert_location.append(std::string(kSbFileSepString) + "ssl" +
+                             kSbFileSepString + "certs");
+      }
       if (SSL_CTX_load_verify_locations(
               ctx_.get(), nullptr, cert_location.c_str()) <= 0) {
         LOG(ERROR) << "SSL_CTX_load_verify_locations";
diff --git a/src/third_party/crashpad/wrapper/wrapper.cc b/src/third_party/crashpad/wrapper/wrapper.cc
index 0ab09e5..ef36040 100644
--- a/src/third_party/crashpad/wrapper/wrapper.cc
+++ b/src/third_party/crashpad/wrapper/wrapper.cc
@@ -25,6 +25,7 @@
 #include "client/settings.h"
 #include "starboard/configuration_constants.h"
 #include "starboard/directory.h"
+#include "starboard/file.h"
 #include "starboard/system.h"
 
 namespace third_party {
@@ -179,6 +180,12 @@
   ::crashpad::CrashpadClient* client = GetCrashpadClient();
 
   const base::FilePath handler_path = GetPathToCrashpadHandlerBinary();
+  if (!SbFileExists(handler_path.value().c_str())) {
+    LOG(WARNING) << "crashpad_handler not at expected location of "
+                 << handler_path.value();
+    return;
+  }
+
   const base::FilePath database_directory_path = GetDatabasePath();
   const base::FilePath default_metrics_dir;
   const std::string product_name = GetProductName();
diff --git a/src/third_party/crashpad/wrapper/wrapper.gyp b/src/third_party/crashpad/wrapper/wrapper.gyp
index a9a4382..b7196e1 100644
--- a/src/third_party/crashpad/wrapper/wrapper.gyp
+++ b/src/third_party/crashpad/wrapper/wrapper.gyp
@@ -22,22 +22,16 @@
         'wrapper.h',
       ],
     },
-  ],
-  'conditions': [
-    ['sb_evergreen_compatible == 1', {
-      'targets': [
-        {
-          'target_name': 'crashpad_wrapper',
-          'type': 'static_library',
-          'sources': [
-            'wrapper.cc',
-            'wrapper.h',
-          ],
-          'dependencies': [
-            '<(DEPTH)/third_party/crashpad/client/client.gyp:crashpad_client',
-          ],
-        },
+    {
+      'target_name': 'crashpad_wrapper',
+      'type': 'static_library',
+      'sources': [
+        'wrapper.cc',
+        'wrapper.h',
       ],
-    }],
+      'dependencies': [
+        '<(DEPTH)/third_party/crashpad/client/client.gyp:crashpad_client',
+      ],
+    },
   ],
 }
diff --git a/src/third_party/freetype2/ChangeLog b/src/third_party/freetype2/ChangeLog
index e4ea3c5..921d93e 100644
--- a/src/third_party/freetype2/ChangeLog
+++ b/src/third_party/freetype2/ChangeLog
@@ -1,3 +1,11 @@
+2020-10-19  Werner Lemberg  <wl@gnu.org>
+
+       [sfnt] Fix heap buffer overflow (#59308).
+
+       This is CVE-2020-15999.
+
+       * src/sfnt/pngshim.c (Load_SBit_Png): Test bitmap size earlier.
+
 2020-05-09  Werner Lemberg  <wl@gnu.org>
 
 	* Version 2.10.2 released.
diff --git a/src/third_party/freetype2/src/sfnt/pngshim.c b/src/third_party/freetype2/src/sfnt/pngshim.c
index 523b30a..5502108 100644
--- a/src/third_party/freetype2/src/sfnt/pngshim.c
+++ b/src/third_party/freetype2/src/sfnt/pngshim.c
@@ -328,6 +328,13 @@
 
     if ( populate_map_and_metrics )
     {
+      /* reject too large bitmaps similarly to the rasterizer */
+      if ( imgHeight > 0x7FFF || imgWidth > 0x7FFF )
+      {
+        error = FT_THROW( Array_Too_Large );
+        goto DestroyExit;
+      }
+
       metrics->width  = (FT_UShort)imgWidth;
       metrics->height = (FT_UShort)imgHeight;
 
@@ -336,13 +343,6 @@
       map->pixel_mode = FT_PIXEL_MODE_BGRA;
       map->pitch      = (int)( map->width * 4 );
       map->num_grays  = 256;
-
-      /* reject too large bitmaps similarly to the rasterizer */
-      if ( map->rows > 0x7FFF || map->width > 0x7FFF )
-      {
-        error = FT_THROW( Array_Too_Large );
-        goto DestroyExit;
-      }
     }
 
     /* convert palette/gray image to rgb */
diff --git a/src/third_party/mini_chromium/base/base.gyp b/src/third_party/mini_chromium/base/base.gyp
index 7d1dbee..71dd510 100644
--- a/src/third_party/mini_chromium/base/base.gyp
+++ b/src/third_party/mini_chromium/base/base.gyp
@@ -43,6 +43,7 @@
         'atomicops_internals_atomicword_compat.h',
         'atomicops_internals_portable.h',
         'auto_reset.h',
+        'base_wrapper.h',
         'bit_cast.h',
         'compiler_specific.h',
         'debug/alias.cc',
diff --git a/src/third_party/mini_chromium/base/base_wrapper.h b/src/third_party/mini_chromium/base/base_wrapper.h
new file mode 100644
index 0000000..ae57c30
--- /dev/null
+++ b/src/third_party/mini_chromium/base/base_wrapper.h
@@ -0,0 +1,29 @@
+// Copyright 2020 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 MINI_CHROMIUM_BASE_BASE_WRAPPER_H_
+#define MINI_CHROMIUM_BASE_BASE_WRAPPER_H_
+
+// Change the symbol name to avoid collisions with //base
+#define FilePath MFilePath
+#define GetLogMessageHandler MGetLogMessageHandler
+#define LogMessage MLogMessage
+#define ReadUnicodeCharacter MReadUnicodeCharacter
+#define SetLogMessageHandler MSetLogMessageHandler
+#define UTF16ToUTF8 MUTF16ToUTF8
+#define UmaHistogramSparse MUmaHistogramSparse
+#define WriteUnicodeCharacter MWriteUnicodeCharacter
+#define c16len mc16len
+
+#endif  // MINI_CHROMIUM_BASE_BASE_WRAPPER_H_
diff --git a/src/third_party/mini_chromium/base/files/file_path.h b/src/third_party/mini_chromium/base/files/file_path.h
index 0ac91bf..ca20380 100644
--- a/src/third_party/mini_chromium/base/files/file_path.h
+++ b/src/third_party/mini_chromium/base/files/file_path.h
@@ -107,6 +107,7 @@
 #include <iosfwd>
 #include <string>
 
+#include "base/base_wrapper.h"
 #include "base/compiler_specific.h"
 #include "build/build_config.h"
 
diff --git a/src/third_party/mini_chromium/base/logging.h b/src/third_party/mini_chromium/base/logging.h
index 37bf23b..0270090 100644
--- a/src/third_party/mini_chromium/base/logging.h
+++ b/src/third_party/mini_chromium/base/logging.h
@@ -12,6 +12,7 @@
 #include <sstream>
 #include <string>
 
+#include "base/base_wrapper.h"
 #include "base/macros.h"
 #include "build/build_config.h"
 
diff --git a/src/third_party/mini_chromium/base/metrics/histogram_functions.h b/src/third_party/mini_chromium/base/metrics/histogram_functions.h
index a96cb9d..5f2af8f 100644
--- a/src/third_party/mini_chromium/base/metrics/histogram_functions.h
+++ b/src/third_party/mini_chromium/base/metrics/histogram_functions.h
@@ -7,6 +7,8 @@
 
 #include <string>
 
+#include "base/base_wrapper.h"
+
 // These are no-op stub versions of a subset of the functions from Chromium's
 // base/metrics/histogram_functions.h. This allows us to instrument the Crashpad
 // code as necessary, while not affecting out-of-Chromium builds.
diff --git a/src/third_party/mini_chromium/base/strings/string16.h b/src/third_party/mini_chromium/base/strings/string16.h
index 04605e4..bb311c2 100644
--- a/src/third_party/mini_chromium/base/strings/string16.h
+++ b/src/third_party/mini_chromium/base/strings/string16.h
@@ -10,6 +10,7 @@
 
 #include <string>
 
+#include "base/base_wrapper.h"
 #include "build/build_config.h"
 
 namespace base {
diff --git a/src/third_party/mini_chromium/base/strings/utf_string_conversion_utils.h b/src/third_party/mini_chromium/base/strings/utf_string_conversion_utils.h
index 72f86ae..4d5353d 100644
--- a/src/third_party/mini_chromium/base/strings/utf_string_conversion_utils.h
+++ b/src/third_party/mini_chromium/base/strings/utf_string_conversion_utils.h
@@ -5,6 +5,7 @@
 #ifndef MINI_CHROMIUM_BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
 #define MINI_CHROMIUM_BASE_STRINGS_UTF_STRING_CONVERSION_UTILS_H_
 
+#include "base/base_wrapper.h"
 #include "base/strings/string16.h"
 
 namespace base {
diff --git a/src/third_party/mini_chromium/base/strings/utf_string_conversions.h b/src/third_party/mini_chromium/base/strings/utf_string_conversions.h
index c2ca674..8e97fcd 100644
--- a/src/third_party/mini_chromium/base/strings/utf_string_conversions.h
+++ b/src/third_party/mini_chromium/base/strings/utf_string_conversions.h
@@ -7,6 +7,7 @@
 
 #include <string>
 
+#include "base/base_wrapper.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_piece.h"
 
diff --git a/src/third_party/web_platform_tests/cobalt_special/resources/content_length.py b/src/third_party/web_platform_tests/cobalt_special/resources/content_length.py
new file mode 100644
index 0000000..d4282ce
--- /dev/null
+++ b/src/third_party/web_platform_tests/cobalt_special/resources/content_length.py
@@ -0,0 +1,14 @@
+# Lint as: python3
+"""
+Helper script to send XHR response with specified content length.
+"""
+
+def main(request, response):
+  headers = []
+
+  content_length = request.GET.first("content_length")
+  headers.append(("Content-Length", content_length));
+
+  body = "this is body"
+
+  return headers, body
diff --git a/src/third_party/web_platform_tests/cobalt_special/xhr_content_length.htm b/src/third_party/web_platform_tests/cobalt_special/xhr_content_length.htm
new file mode 100644
index 0000000..fc07412
--- /dev/null
+++ b/src/third_party/web_platform_tests/cobalt_special/xhr_content_length.htm
@@ -0,0 +1,27 @@
+<!DOCTYPE html>
+<meta charset=utf-8>
+<title>cobalt-special - xhr content length</title>
+
+<script src=/resources/testharness.js></script>
+<script src=/resources/testharnessreport.js></script>
+<script src=/common/utils.js></script>
+<script src=resources/support.js?pipe=sub></script>
+
+<h1></h1>
+
+<div id=log></div>
+<script>
+  var test = async_test();
+      test.step(function() {
+        var client = new XMLHttpRequest();
+        client.onloadstart = test.step_func(function() {
+          test.done();
+        });
+        // The purpose of this test is to verify that Cobalt does not crash when an
+        // erroneously long content length is specified in xhr response.
+        const too_large_buffer_size = "4987398465139";
+        client.open("GET", "resources/content_length.py?content_length=" + too_large_buffer_size);
+        client.send(null);
+      });
+</script>
+
diff --git a/src/third_party/web_platform_tests/intersection-observer/multiple-targets.html b/src/third_party/web_platform_tests/intersection-observer/multiple-targets.html
index 22353e3..51ddeff 100644
--- a/src/third_party/web_platform_tests/intersection-observer/multiple-targets.html
+++ b/src/third_party/web_platform_tests/intersection-observer/multiple-targets.html
@@ -5,13 +5,18 @@
 <script src="./resources/intersection-observer-test-utils.js"></script>
 
 <style>
+/* Cobalt does not implement HTML5 spec for body margin. */
+body {
+  margin: 8px;
+}
 pre, #log {
   position: absolute;
   top: 0;
   left: 200px;
 }
 .spacer {
-  height: calc(100vh + 100px);
+  /* Cobalt does not support calc */
+  height: 100vh;
 }
 .target {
   width: 100px;
@@ -22,7 +27,7 @@
 </style>
 
 <div class="spacer"></div>
-<div id="target1" class="target"></div>
+<div id="target1" class="target" style="margin-top:100px;"></div>
 <div id="target2" class="target"></div>
 <div id="target3" class="target"></div>
 
@@ -38,7 +43,8 @@
   target3 = document.getElementById("target3");
   assert_true(!!target3, "target3 exists.");
   var observer = new IntersectionObserver(function(changes) {
-    entries = entries.concat(changes)
+    entries = entries.concat(changes);
+    window.testRunner.DoNonMeasuredLayout();
   });
   observer.observe(target1);
   observer.observe(target2);
@@ -47,9 +53,12 @@
   assert_equals(entries.length, 0, "No initial notifications.");
   runTestCycle(step0, "First rAF.");
 }, "One observer with multiple targets.");
+window.testRunner.DoNonMeasuredLayout();
+window.testRunner.DoNonMeasuredLayout();
 
 function step0() {
-  document.scrollingElement.scrollTop = 150;
+  target1.style.marginTop = "-50px";
+  //document.scrollingElement.scrollTop = 150;
   runTestCycle(step1, "document.scrollingElement.scrollTop = 150");
   assert_equals(entries.length, 3, "Three initial notifications.");
   assert_equals(entries[0].target, target1, "entries[0].target === target1");
@@ -58,14 +67,19 @@
 }
 
 function step1() {
-  document.scrollingElement.scrollTop = 10000;
+  // document.scrollingElement.scrollTop = 10000 indicates that the page should
+  // scroll just far down enough to include all the elements in the DOM tree.
+  // Since we are using marginTop as a workaround, we need to adjust the value.
+  target1.style.marginTop = "-330px";
+  //document.scrollingElement.scrollTop = 10000;
   runTestCycle(step2, "document.scrollingElement.scrollTop = 10000");
   assert_equals(entries.length, 4, "Four notifications.");
   assert_equals(entries[3].target, target1, "entries[3].target === target1");
 }
 
 function step2() {
-  document.scrollingElement.scrollTop = 0;
+  target1.style.marginTop = "100px";
+  //document.scrollingElement.scrollTop = 0;
   runTestCycle(step3, "document.scrollingElement.scrollTop = 0");
   assert_equals(entries.length, 6, "Six notifications.");
   assert_equals(entries[4].target, target2, "entries[4].target === target2");
diff --git a/src/third_party/web_platform_tests/intersection-observer/multiple-thresholds.html b/src/third_party/web_platform_tests/intersection-observer/multiple-thresholds.html
index 3599e1f..3c92ea5 100644
--- a/src/third_party/web_platform_tests/intersection-observer/multiple-thresholds.html
+++ b/src/third_party/web_platform_tests/intersection-observer/multiple-thresholds.html
@@ -5,18 +5,26 @@
 <script src="./resources/intersection-observer-test-utils.js"></script>
 
 <style>
+/* Cobalt does not implement HTML5 spec for body margin. */
+body {
+  margin: 8px;
+}
 pre, #log {
   position: absolute;
   top: 0;
   left: 200px;
 }
 .spacer {
-  height: calc(100vh + 100px);
+  /* Cobalt does not support calc */
+  height: 100vh;
+
 }
 #target {
   width: 100px;
   height: 100px;
   background-color: green;
+  /* Adjust for subtracted 100px in class=spacer */
+  margin-top: 100px;
 }
 </style>
 
@@ -25,8 +33,8 @@
 <div class="spacer"></div>
 
 <script>
-var vw = document.documentElement.clientWidth;
-var vh = document.documentElement.clientHeight;
+var vw = window.innerWidth;
+var vh = window.innerHeight;
 
 var entries = [];
 var target;
@@ -34,64 +42,80 @@
 runTestCycle(function() {
   target = document.getElementById("target");
   var observer = new IntersectionObserver(function(changes) {
-    entries = entries.concat(changes)
+    entries = entries.concat(changes);
+    window.testRunner.DoNonMeasuredLayout();
   }, { threshold: [0, 0.25, 0.5, 0.75, 1] });
   observer.observe(target);
   entries = entries.concat(observer.takeRecords());
   assert_equals(entries.length, 0, "No initial notifications.");
   runTestCycle(step0, "First rAF.");
 }, "Observer with multiple thresholds.");
+window.testRunner.DoNonMeasuredLayout();
+window.testRunner.DoNonMeasuredLayout();
 
 function step0() {
-  document.scrollingElement.scrollTop = 120;
+  target.style.marginTop = "-20px";
+  //document.scrollingElement.scrollTop = 120;
   runTestCycle(step1, "document.scrollingElement.scrollTop = 120");
   checkLastEntry(entries, 0, [8, 108, vh + 108, vh + 208, 0, 0, 0, 0, 0, vw, 0, vh, false]);
 }
 
 function step1() {
-  document.scrollingElement.scrollTop = 160;
+  target.style.marginTop = "-60px";
+  //document.scrollingElement.scrollTop = 160;
   runTestCycle(step2, "document.scrollingElement.scrollTop = 160");
   checkLastEntry(entries, 1, [8, 108, vh - 12, vh + 88, 8, 108, vh - 12, vh, 0, vw, 0, vh, true]);
 }
 
 function step2() {
-  document.scrollingElement.scrollTop = 200;
+  target.style.marginTop = "-100px";
+  //document.scrollingElement.scrollTop = 200;
   runTestCycle(step3, "document.scrollingElement.scrollTop = 200");
   checkLastEntry(entries, 2, [8, 108, vh - 52, vh + 48, 8, 108, vh - 52, vh, 0, vw, 0, vh, true]);
 }
 
 function step3() {
-  document.scrollingElement.scrollTop = 240;
+  target.style.marginTop = "-140px"; 
+  //document.scrollingElement.scrollTop = 240;
   runTestCycle(step4, "document.scrollingElement.scrollTop = 240");
   checkLastEntry(entries, 3, [8, 108, vh - 92, vh + 8, 8, 108, vh - 92, vh, 0, vw, 0, vh, true]);
 }
 
 function step4() {
-  document.scrollingElement.scrollTop = vh + 140;
+  var marginTop = (vh + 140) * -1 + 100 + "px";
+  target.style.marginTop = marginTop;
+  //document.scrollingElement.scrollTop = vh + 140;
   runTestCycle(step5, "document.scrollingElement.scrollTop = window.innerHeight + 140");
   checkLastEntry(entries, 4, [8, 108, vh - 132, vh - 32, 8, 108, vh - 132, vh - 32, 0, vw, 0, vh, true]);
 }
 
 function step5() {
-  document.scrollingElement.scrollTop = vh + 160;
+  var marginTop = (vh + 160) * -1 + 100 + "px";
+  target.style.marginTop = marginTop;
+  //document.scrollingElement.scrollTop = vh + 160;
   runTestCycle(step6, "document.scrollingElement.scrollTop = window.innerHeight + 160");
   checkLastEntry(entries, 5, [8, 108, -32, 68, 8, 108, 0, 68, 0, vw, 0, vh, true]);
 }
 
 function step6() {
-  document.scrollingElement.scrollTop = vh + 200;
+  var marginTop = (vh + 200) * -1 + 100 + "px";
+  target.style.marginTop = marginTop;
+  //document.scrollingElement.scrollTop = vh + 200;
   runTestCycle(step7, "document.scrollingElement.scrollTop = window.innerHeight + 200");
   checkLastEntry(entries, 6, [8, 108, -52, 48, 8, 108, 0, 48, 0, vw, 0, vh, true]);
 }
 
 function step7() {
   checkLastEntry(entries, 7, [8, 108, -92, 8, 8, 108, 0, 8, 0, vw, 0, vh, true]);
-  document.scrollingElement.scrollTop = vh + 220;
+  var marginTop = (vh + 220) * -1 + 100 + "px";
+  target.style.marginTop = marginTop;
+  //document.scrollingElement.scrollTop = vh + 220;
   runTestCycle(step8, "document.scrollingElement.scrollTop = window.innerHeight + 220");
 }
 
 function step8() {
   checkLastEntry(entries, 8, [8, 108, -112, -12, 0, 0, 0, 0, 0, vw, 0, vh, false]);
-  document.scrollingElement.scrollTop = 0;
+  target.style.marginTop = "100px";
+  //document.scrollingElement.scrollTop = 0;
 }
 </script>
diff --git a/src/third_party/web_platform_tests/intersection-observer/observer-without-js-reference.html b/src/third_party/web_platform_tests/intersection-observer/observer-without-js-reference.html
index 53100c50..afb28c6 100644
--- a/src/third_party/web_platform_tests/intersection-observer/observer-without-js-reference.html
+++ b/src/third_party/web_platform_tests/intersection-observer/observer-without-js-reference.html
@@ -5,18 +5,25 @@
 <script src="./resources/intersection-observer-test-utils.js"></script>
 
 <style>
+/* Cobalt does not implement HTML5 spec for body margin. */
+body {
+  margin: 8px;
+}
 pre, #log {
   position: absolute;
   top: 0;
   left: 200px;
 }
 .spacer {
-  height: calc(100vh + 100px);
+  /* Cobalt does not support calc */
+  height: 100vh;
 }
 #target {
   width: 100px;
   height: 100px;
   background-color: green;
+  /* Adjust for subtracted 100px in class=spacer */
+  margin-top: 100px;
 }
 </style>
 <div class="spacer"></div>
@@ -31,21 +38,26 @@
   assert_true(!!target, "Target exists");
   function createObserver() {
     new IntersectionObserver(function(changes) {
-      entries = entries.concat(changes)
+      entries = entries.concat(changes);
+      window.testRunner.DoNonMeasuredLayout();
     }).observe(target);
   }
   createObserver();
   runTestCycle(step0, "First rAF");
 }, "IntersectionObserver that is unreachable in js should still generate notifications.");
+window.testRunner.DoNonMeasuredLayout();
+window.testRunner.DoNonMeasuredLayout();
 
 function step0() {
-  document.scrollingElement.scrollTop = 300;
+  document.getElementById("target").style.marginTop = "-200px";
+  //document.scrollingElement.scrollTop = 300;
   runTestCycle(step1, "document.scrollingElement.scrollTop = 300");
   assert_equals(entries.length, 1, "One notification.");
 }
 
 function step1() {
-  document.scrollingElement.scrollTop = 0;
+  document.getElementById("target").style.marginTop = "100px";
+  //document.scrollingElement.scrollTop = 0;
   assert_equals(entries.length, 2, "Two notifications.");
 }
 </script>
diff --git a/src/third_party/web_platform_tests/intersection-observer/same-document-no-root.html b/src/third_party/web_platform_tests/intersection-observer/same-document-no-root.html
index 63e9f86..957ad77 100644
--- a/src/third_party/web_platform_tests/intersection-observer/same-document-no-root.html
+++ b/src/third_party/web_platform_tests/intersection-observer/same-document-no-root.html
@@ -5,18 +5,25 @@
 <script src="./resources/intersection-observer-test-utils.js"></script>
 
 <style>
+/* Cobalt does not implement HTML5 spec for body margin. */
+body {
+  margin: 8px;
+}
 pre, #log {
   position: absolute;
   top: 0;
   left: 200px;
 }
 .spacer {
-  height: calc(100vh + 100px);
+  /* Cobalt does not support calc */
+  height: 100vh;
 }
 #target {
   width: 100px;
   height: 100px;
   background-color: green;
+  /* Adjust for subtracted 100px in class=spacer */
+  margin-top: 100px;
 }
 </style>
 
@@ -25,8 +32,8 @@
 <div class="spacer"></div>
 
 <script>
-var vw = document.documentElement.clientWidth;
-var vh = document.documentElement.clientHeight;
+var vw = window.innerWidth;
+var vh = window.innerHeight;
 
 var entries = [];
 var target;
@@ -35,28 +42,34 @@
   target = document.getElementById("target");
   assert_true(!!target, "target exists");
   var observer = new IntersectionObserver(function(changes) {
-    entries = entries.concat(changes)
+    entries = entries.concat(changes);
+    window.testRunner.DoNonMeasuredLayout();
   });
   observer.observe(target);
   entries = entries.concat(observer.takeRecords());
   assert_equals(entries.length, 0, "No initial notifications.");
   runTestCycle(step0, "First rAF.");
 }, "IntersectionObserver in a single document using the implicit root.");
+window.testRunner.DoNonMeasuredLayout();
+window.testRunner.DoNonMeasuredLayout();
 
 function step0() {
-  document.scrollingElement.scrollTop = 300;
+  target.style.marginTop = "-200px";
+  //document.scrollingElement.scrollTop = 300;
   runTestCycle(step1, "document.scrollingElement.scrollTop = 300");
   checkLastEntry(entries, 0, [8, 108, vh + 108, vh + 208, 0, 0, 0, 0, 0, vw, 0, vh, false]);
 }
 
 function step1() {
-  document.scrollingElement.scrollTop = 100;
+  target.style.marginTop = "0px";
+  //document.scrollingElement.scrollTop = 100;
   runTestCycle(step2, "document.scrollingElement.scrollTop = 100");
   checkLastEntry(entries, 1, [8, 108, vh - 192, vh - 92, 8, 108, vh - 192, vh - 92, 0, vw, 0, vh, true]);
 }
 
 function step2() {
-  document.scrollingElement.scrollTop = 0;
+  target.style.marginTop = "100px";
+  //document.scrollingElement.scrollTop = 0;
   checkLastEntry(entries, 2, [8, 108, vh + 8, vh + 108, 0, 0, 0, 0, 0, vw, 0, vh, false]);
 }
 </script>
diff --git a/src/third_party/web_platform_tests/intersection-observer/same-document-zero-size-target.html b/src/third_party/web_platform_tests/intersection-observer/same-document-zero-size-target.html
index 20bd11d..ddf6fec 100644
--- a/src/third_party/web_platform_tests/intersection-observer/same-document-zero-size-target.html
+++ b/src/third_party/web_platform_tests/intersection-observer/same-document-zero-size-target.html
@@ -5,18 +5,25 @@
 <script src="./resources/intersection-observer-test-utils.js"></script>
 
 <style>
+/* Cobalt does not implement HTML5 spec for body margin. */
+body {
+  margin: 8px;
+}
 pre, #log {
   position: absolute;
   top: 0;
   left: 200px;
 }
 .spacer {
-  height: calc(100vh + 100px);
+  /* Cobalt does not support calc */
+  height: 100vh;
 }
 #target {
   width: 0px;
   height: 0px;
   background-color: green;
+  /* Adjust for subtracted 100px in class=spacer */
+  margin-top: 100px;
 }
 </style>
 
@@ -25,8 +32,8 @@
 <div class="spacer"></div>
 
 <script>
-var vw = document.documentElement.clientWidth;
-var vh = document.documentElement.clientHeight;
+var vw = window.innerWidth;
+var vh = window.innerHeight;
 
 var entries = [];
 var target;
@@ -35,28 +42,34 @@
   target = document.getElementById("target");
   assert_true(!!target, "Target exists");
   var observer = new IntersectionObserver(function(changes) {
-    entries = entries.concat(changes)
+    entries = entries.concat(changes);
+    window.testRunner.DoNonMeasuredLayout();
   });
   observer.observe(target);
   entries = entries.concat(observer.takeRecords());
   assert_equals(entries.length, 0, "No initial notifications.");
   runTestCycle(step0, "First rAF");
 }, "Observing a zero-area target.");
+window.testRunner.DoNonMeasuredLayout();
+window.testRunner.DoNonMeasuredLayout();
 
 function step0() {
-  document.scrollingElement.scrollTop = 300;
+  target.style.marginTop = "-200px";
+  //document.scrollingElement.scrollTop = 300;
   runTestCycle(step1, "document.scrollingElement.scrollTop = 300");
   checkLastEntry(entries, 0, [8, 8, vh + 108, vh + 108, 0, 0, 0, 0, 0, vw, 0, vh, false]);
 }
 
 function step1() {
-  document.scrollingElement.scrollTop = 100;
+  target.style.marginTop = "0px";
+  //document.scrollingElement.scrollTop = 100;
   runTestCycle(step2, "document.scrollingElement.scrollTop = 100");
   checkLastEntry(entries, 1, [8, 8, vh - 192, vh - 192, 8, 8, vh - 192, vh - 192, 0, vw, 0, vh, true]);
 }
 
 function step2() {
-  document.scrollingElement.scrollTop = 0;
+  target.style.marginTop = "100px";
+  //document.scrollingElement.scrollTop = 0;
   checkLastEntry(entries, 2, [8, 8, vh + 8, vh + 8, 0, 0, 0, 0, 0, vw, 0, vh, false]);
 }
 </script>
diff --git a/src/third_party/web_platform_tests/intersection-observer/text-target.html b/src/third_party/web_platform_tests/intersection-observer/text-target.html
index 1abe535..2317a66 100644
--- a/src/third_party/web_platform_tests/intersection-observer/text-target.html
+++ b/src/third_party/web_platform_tests/intersection-observer/text-target.html
@@ -5,23 +5,33 @@
 <script src="./resources/intersection-observer-test-utils.js"></script>
 
 <style>
+/* Cobalt does not implement HTML5 spec for body margin. */
+body {
+  margin: 8px;
+}
 pre, #log {
   position: absolute;
   top: 0;
   left: 200px;
 }
 .spacer {
-  height: calc(100vh + 100px);
+  /* Cobalt does not support calc */
+  height: 100vh;
+}
+#target {
+  /* Adjust for subtracted 100px in class=spacer */
+  margin-top: 100px;
 }
 </style>
 
 <div class="spacer"></div>
-<br id="target">
+<!--br gives incorrect bounding rect in Cobalt so we use p instead-->
+<p id="target">
 <div class="spacer"></div>
 
 <script>
-var vw = document.documentElement.clientWidth;
-var vh = document.documentElement.clientHeight;
+var vw = window.innerWidth;
+var vh = window.innerHeight;
 
 var entries = [];
 var target;
@@ -34,16 +44,20 @@
   th = target_rect.height;
   assert_true(!!target, "target exists");
   var observer = new IntersectionObserver(function(changes) {
-    entries = entries.concat(changes)
+    entries = entries.concat(changes);
+    window.testRunner.DoNonMeasuredLayout();
   });
   observer.observe(target);
   entries = entries.concat(observer.takeRecords());
   assert_equals(entries.length, 0, "No initial notifications.");
   runTestCycle(step0, "First rAF.");
-}, "IntersectionObserver observing a br element.");
+}, "IntersectionObserver observing a p element.");
+window.testRunner.DoNonMeasuredLayout();
+window.testRunner.DoNonMeasuredLayout();
 
 function step0() {
-  document.scrollingElement.scrollTop = 300;
+  target.style.marginTop = "-200px";
+  //document.scrollingElement.scrollTop = 300;
   runTestCycle(step1, "document.scrollingElement.scrollTop = 300");
   // The numbers in brackets are target client rect; intersection rect;
   // and root bounds.
@@ -51,13 +65,15 @@
 }
 
 function step1() {
-  document.scrollingElement.scrollTop = 100;
+  target.style.marginTop = "0px";
+  //document.scrollingElement.scrollTop = 100;
   runTestCycle(step2, "document.scrollingElement.scrollTop = 100");
   checkLastEntry(entries, 1, [8, 8 + tw, vh - 192, vh - 192 + th, 8, 8 + tw, vh - 192, vh - 192 + th, 0, vw, 0, vh, true]);
 }
 
 function step2() {
-  document.scrollingElement.scrollTop = 0;
+  target.style.marginTop = "100px";
+  //document.scrollingElement.scrollTop = 0;
   checkLastEntry(entries, 2, [8, 8 + tw, vh + 8, vh + 8 + th, 0, 0, 0, 0, 0, vw, 0, vh, false]);
 }
 </script>
diff --git a/src/third_party/web_platform_tests/intersection-observer/zero-area-element-visible.html b/src/third_party/web_platform_tests/intersection-observer/zero-area-element-visible.html
index 5431750..be8aa0a 100644
--- a/src/third_party/web_platform_tests/intersection-observer/zero-area-element-visible.html
+++ b/src/third_party/web_platform_tests/intersection-observer/zero-area-element-visible.html
@@ -5,6 +5,10 @@
 <script src="./resources/intersection-observer-test-utils.js"></script>
 
 <style>
+/* Cobalt does not implement HTML5 spec for body margin. */
+body {
+  margin: 8px;
+}
 pre, #log {
   position: absolute;
   top: 0;
@@ -25,13 +29,16 @@
   var target = document.getElementById('target');
   assert_true(!!target, "target exists");
   var observer = new IntersectionObserver(function(changes) {
-    entries = entries.concat(changes)
+    entries = entries.concat(changes);
+    window.testRunner.DoNonMeasuredLayout();
   });
   observer.observe(target);
   entries = entries.concat(observer.takeRecords());
   assert_equals(entries.length, 0, "No initial notifications.");
   runTestCycle(step0, "First rAF should generate a notification.");
 }, "Ensure that a zero-area target intersecting root generates a notification with intersectionRatio == 1");
+window.testRunner.DoNonMeasuredLayout();
+window.testRunner.DoNonMeasuredLayout();
 
 function step0() {
   assert_equals(entries.length, 1, "One notification.");
diff --git a/src/third_party/zlib/zlib.gyp b/src/third_party/zlib/zlib.gyp
index aee6d67..1156168 100644
--- a/src/third_party/zlib/zlib.gyp
+++ b/src/third_party/zlib/zlib.gyp
@@ -520,7 +520,6 @@
         'minizip',
         'zip',
         'zlib',
-        '<(DEPTH)/base/base.gyp:base',
         '<(DEPTH)/base/base.gyp:test_support_base',
         '<(DEPTH)/starboard/common/common.gyp:common',
         '<(DEPTH)/testing/gmock.gyp:gmock',
diff --git a/src/v8/src/base/platform/platform-starboard.cc b/src/v8/src/base/platform/platform-starboard.cc
index 3cd69ec..27bfd38 100644
--- a/src/v8/src/base/platform/platform-starboard.cc
+++ b/src/v8/src/base/platform/platform-starboard.cc
@@ -17,9 +17,8 @@
 #include "src/base/platform/platform.h"
 #include "src/base/platform/time.h"
 #include "src/base/utils/random-number-generator.h"
-
 #include "src/base/timezone-cache.h"
-
+#include "starboard/client_porting/eztime/eztime.h"
 #include "starboard/common/condition_variable.h"
 #include "starboard/common/log.h"
 #include "starboard/common/string.h"
@@ -468,7 +467,6 @@
 
 class StarboardTimezoneCache : public TimezoneCache {
  public:
-  double DaylightSavingsOffset(double time_ms) override { return 0.0; }
   void Clear(TimeZoneDetection time_zone_detection) override {}
   ~StarboardTimezoneCache() override {}
 
@@ -482,7 +480,18 @@
     return SbTimeZoneGetName();
   }
   double LocalTimeOffset(double time_ms, bool is_utc) override {
-    return SbTimeZoneGetCurrent() * 60000.0;
+    // SbTimeZOneGetCurrent returns an offset west of Greenwich, which has the
+    // opposite sign V8 expects.
+    // The starboard function returns offset in minutes. We convert to return
+    // value in milliseconds.
+    return SbTimeZoneGetCurrent() * 60.0 * msPerSecond * (-1);
+  }
+  double DaylightSavingsOffset(double time_ms) override {
+    EzTimeValue value = EzTimeValueFromSbTime(SbTimeGetNow());
+    EzTimeExploded ez_exploded;
+    bool result = EzTimeValueExplode(&value, kEzTimeZoneLocal, &ez_exploded,
+                                     NULL);
+    return ez_exploded.tm_isdst > 0 ? 3600 * msPerSecond : 0;
   }
 
   ~StarboardDefaultTimezoneCache() override {}