diff --git a/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousIndexedGetterInterface.cc b/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousIndexedGetterInterface.cc
index 9a486e9..ff82636 100644
--- a/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousIndexedGetterInterface.cc
+++ b/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousIndexedGetterInterface.cc
@@ -86,6 +86,7 @@
 
 bool IsSupportedIndexProperty(JSContext* context, JS::HandleObject object,
                               uint32_t index) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedIndexProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   AnonymousIndexedGetterInterface* impl =
@@ -108,6 +109,7 @@
 JSBool GetIndexedProperty(
     JSContext* context, JS::HandleObject object, JS::HandleId id,
     JS::MutableHandleValue vp) {
+  TRACE_EVENT0("cobalt::bindings", "GetIndexedProperty");
   JS::RootedValue id_value(context);
   if (!JS_IdToValue(context, id, id_value.address())) {
     NOTREACHED();
diff --git a/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousNamedGetterInterface.cc b/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousNamedGetterInterface.cc
index 5431665..a896d35 100644
--- a/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousNamedGetterInterface.cc
+++ b/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousNamedGetterInterface.cc
@@ -86,6 +86,7 @@
 
 bool IsSupportedNamedProperty(JSContext* context, JS::HandleObject object,
                               const std::string& property_name) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedNamedProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   AnonymousNamedGetterInterface* impl =
diff --git a/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousNamedIndexedGetterInterface.cc b/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousNamedIndexedGetterInterface.cc
index 0d132c4..8f883ff 100644
--- a/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousNamedIndexedGetterInterface.cc
+++ b/src/cobalt/bindings/generated/mozjs/testing/MozjsAnonymousNamedIndexedGetterInterface.cc
@@ -86,6 +86,7 @@
 
 bool IsSupportedNamedProperty(JSContext* context, JS::HandleObject object,
                               const std::string& property_name) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedNamedProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   AnonymousNamedIndexedGetterInterface* impl =
@@ -177,6 +178,7 @@
 
 bool IsSupportedIndexProperty(JSContext* context, JS::HandleObject object,
                               uint32_t index) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedIndexProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   AnonymousNamedIndexedGetterInterface* impl =
@@ -199,6 +201,7 @@
 JSBool GetIndexedProperty(
     JSContext* context, JS::HandleObject object, JS::HandleId id,
     JS::MutableHandleValue vp) {
+  TRACE_EVENT0("cobalt::bindings", "GetIndexedProperty");
   JS::RootedValue id_value(context);
   if (!JS_IdToValue(context, id, id_value.address())) {
     NOTREACHED();
diff --git a/src/cobalt/bindings/generated/mozjs/testing/MozjsDerivedGetterSetterInterface.cc b/src/cobalt/bindings/generated/mozjs/testing/MozjsDerivedGetterSetterInterface.cc
index 286e8b8..647ef55 100644
--- a/src/cobalt/bindings/generated/mozjs/testing/MozjsDerivedGetterSetterInterface.cc
+++ b/src/cobalt/bindings/generated/mozjs/testing/MozjsDerivedGetterSetterInterface.cc
@@ -86,6 +86,7 @@
 
 bool IsSupportedNamedProperty(JSContext* context, JS::HandleObject object,
                               const std::string& property_name) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedNamedProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   DerivedGetterSetterInterface* impl =
@@ -177,6 +178,7 @@
 
 bool IsSupportedIndexProperty(JSContext* context, JS::HandleObject object,
                               uint32_t index) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedIndexProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   DerivedGetterSetterInterface* impl =
@@ -199,6 +201,7 @@
 JSBool GetIndexedProperty(
     JSContext* context, JS::HandleObject object, JS::HandleId id,
     JS::MutableHandleValue vp) {
+  TRACE_EVENT0("cobalt::bindings", "GetIndexedProperty");
   JS::RootedValue id_value(context);
   if (!JS_IdToValue(context, id, id_value.address())) {
     NOTREACHED();
diff --git a/src/cobalt/bindings/generated/mozjs/testing/MozjsIndexedGetterInterface.cc b/src/cobalt/bindings/generated/mozjs/testing/MozjsIndexedGetterInterface.cc
index 66f6497..b362b42 100644
--- a/src/cobalt/bindings/generated/mozjs/testing/MozjsIndexedGetterInterface.cc
+++ b/src/cobalt/bindings/generated/mozjs/testing/MozjsIndexedGetterInterface.cc
@@ -86,6 +86,7 @@
 
 bool IsSupportedIndexProperty(JSContext* context, JS::HandleObject object,
                               uint32_t index) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedIndexProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   IndexedGetterInterface* impl =
@@ -108,6 +109,7 @@
 JSBool GetIndexedProperty(
     JSContext* context, JS::HandleObject object, JS::HandleId id,
     JS::MutableHandleValue vp) {
+  TRACE_EVENT0("cobalt::bindings", "GetIndexedProperty");
   JS::RootedValue id_value(context);
   if (!JS_IdToValue(context, id, id_value.address())) {
     NOTREACHED();
diff --git a/src/cobalt/bindings/generated/mozjs/testing/MozjsNamedGetterInterface.cc b/src/cobalt/bindings/generated/mozjs/testing/MozjsNamedGetterInterface.cc
index 51f1f54..79fb735 100644
--- a/src/cobalt/bindings/generated/mozjs/testing/MozjsNamedGetterInterface.cc
+++ b/src/cobalt/bindings/generated/mozjs/testing/MozjsNamedGetterInterface.cc
@@ -86,6 +86,7 @@
 
 bool IsSupportedNamedProperty(JSContext* context, JS::HandleObject object,
                               const std::string& property_name) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedNamedProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   NamedGetterInterface* impl =
diff --git a/src/cobalt/bindings/generated/mozjs/testing/MozjsNamedIndexedGetterInterface.cc b/src/cobalt/bindings/generated/mozjs/testing/MozjsNamedIndexedGetterInterface.cc
index b1d1234..7f0e6b7 100644
--- a/src/cobalt/bindings/generated/mozjs/testing/MozjsNamedIndexedGetterInterface.cc
+++ b/src/cobalt/bindings/generated/mozjs/testing/MozjsNamedIndexedGetterInterface.cc
@@ -86,6 +86,7 @@
 
 bool IsSupportedNamedProperty(JSContext* context, JS::HandleObject object,
                               const std::string& property_name) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedNamedProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   NamedIndexedGetterInterface* impl =
@@ -177,6 +178,7 @@
 
 bool IsSupportedIndexProperty(JSContext* context, JS::HandleObject object,
                               uint32_t index) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedIndexProperty");
   WrapperPrivate* wrapper_private =
       WrapperPrivate::GetFromObject(context, object);
   NamedIndexedGetterInterface* impl =
@@ -199,6 +201,7 @@
 JSBool GetIndexedProperty(
     JSContext* context, JS::HandleObject object, JS::HandleId id,
     JS::MutableHandleValue vp) {
+  TRACE_EVENT0("cobalt::bindings", "GetIndexedProperty");
   JS::RootedValue id_value(context);
   if (!JS_IdToValue(context, id, id_value.address())) {
     NOTREACHED();
diff --git a/src/cobalt/bindings/mozjs/templates/interface.cc.template b/src/cobalt/bindings/mozjs/templates/interface.cc.template
index 23575c7..2dfc9eb 100644
--- a/src/cobalt/bindings/mozjs/templates/interface.cc.template
+++ b/src/cobalt/bindings/mozjs/templates/interface.cc.template
@@ -126,6 +126,7 @@
 {% if named_property_getter %}
 bool IsSupportedNamedProperty(JSContext* context, JS::HandleObject object,
                               const std::string& property_name) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedNamedProperty");
 {{ get_impl_class_instance(impl_class) }}
   return impl->CanQueryNamedProperty(property_name);
 }
@@ -214,6 +215,7 @@
 {% if indexed_property_getter %}
 bool IsSupportedIndexProperty(JSContext* context, JS::HandleObject object,
                               uint32_t index) {
+  TRACE_EVENT0("cobalt::bindings", "IsSupportedIndexProperty");
 {{ get_impl_class_instance(impl_class) }}
   return index < impl->length();
 }
@@ -230,6 +232,7 @@
 JSBool GetIndexedProperty(
     JSContext* context, JS::HandleObject object, JS::HandleId id,
     JS::MutableHandleValue vp) {
+  TRACE_EVENT0("cobalt::bindings", "GetIndexedProperty");
   JS::RootedValue id_value(context);
   if (!JS_IdToValue(context, id, id_value.address())) {
     NOTREACHED();
diff --git a/src/cobalt/browser/application.cc b/src/cobalt/browser/application.cc
index 438692d..9385cc0 100644
--- a/src/cobalt/browser/application.cc
+++ b/src/cobalt/browser/application.cc
@@ -60,6 +60,7 @@
 
 namespace {
 const int kStatUpdatePeriodMs = 1000;
+const int kLiteStatUpdatePeriodMs = 16;
 
 const char kDefaultURL[] = "https://www.youtube.com/tv";
 
@@ -292,7 +293,8 @@
     : message_loop_(MessageLoop::current()),
       quit_closure_(quit_closure),
       start_time_(base::TimeTicks::Now()),
-      stats_update_timer_(true, true) {
+      stats_update_timer_(true, true),
+      lite_stats_update_timer_(true, true) {
   DCHECK(MessageLoop::current());
   DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
 
@@ -307,6 +309,10 @@
   stats_update_timer_.Start(
       FROM_HERE, base::TimeDelta::FromMilliseconds(kStatUpdatePeriodMs),
       base::Bind(&Application::UpdatePeriodicStats, base::Unretained(this)));
+  lite_stats_update_timer_.Start(
+      FROM_HERE, base::TimeDelta::FromMilliseconds(kLiteStatUpdatePeriodMs),
+      base::Bind(&Application::UpdatePeriodicLiteStats,
+                 base::Unretained(this)));
 
   // Check to see if a timed_trace has been set, indicating that we should
   // begin a timed trace upon startup.
@@ -692,6 +698,10 @@
   }
 }
 
+void Application::UpdatePeriodicLiteStats() {
+  c_val_stats_.app_lifetime = base::TimeTicks::Now() - start_time_;
+}
+
 void Application::UpdatePeriodicStats() {
 #if defined(__LB_SHELL__)
   bool memory_stats_updated = false;
@@ -731,8 +741,6 @@
     *c_val_stats_.used_gpu_memory = used_gpu_memory;
   }
 #endif
-
-  c_val_stats_.app_lifetime = base::TimeTicks::Now() - start_time_;
 }
 
 }  // namespace browser
diff --git a/src/cobalt/browser/application.h b/src/cobalt/browser/application.h
index dc4a362..da9f8b1 100644
--- a/src/cobalt/browser/application.h
+++ b/src/cobalt/browser/application.h
@@ -154,6 +154,7 @@
   void UpdateAndMaybeRegisterUserAgent();
 
   void UpdatePeriodicStats();
+  void UpdatePeriodicLiteStats();
 
   static ssize_t available_memory_;
   static int64 lifetime_in_ms_;
@@ -171,6 +172,7 @@
   CValStats c_val_stats_;
 
   base::Timer stats_update_timer_;
+  base::Timer lite_stats_update_timer_;
 };
 
 // Factory method for creating an application.  It should be implemented
diff --git a/src/cobalt/browser/browser_module.cc b/src/cobalt/browser/browser_module.cc
index 58405df..72f1dd8 100644
--- a/src/cobalt/browser/browser_module.cc
+++ b/src/cobalt/browser/browser_module.cc
@@ -179,8 +179,6 @@
   h5vcc_settings.account_manager = account_manager;
   h5vcc_settings.event_dispatcher = system_window->event_dispatcher();
   h5vcc_settings.initial_deep_link = options.initial_deep_link;
-  h5vcc_settings.on_set_record_stats = base::Bind(
-      &BrowserModule::OnSetRecordStats, base::Unretained(this));
   web_module_options_.injected_window_attributes["h5vcc"] =
       base::Bind(&CreateH5VCC, h5vcc_settings);
 
@@ -708,11 +706,5 @@
 }
 #endif  // OS_STARBOARD
 
-void BrowserModule::OnSetRecordStats(bool set) {
-  if (web_module_) {
-    web_module_->OnSetRecordStats(set);
-  }
-}
-
 }  // namespace browser
 }  // namespace cobalt
diff --git a/src/cobalt/browser/browser_module.h b/src/cobalt/browser/browser_module.h
index 677aa32..82322b3 100644
--- a/src/cobalt/browser/browser_module.h
+++ b/src/cobalt/browser/browser_module.h
@@ -210,9 +210,6 @@
   // Process all messages queued into the |render_tree_submission_queue_|.
   void ProcessRenderTreeSubmissionQueue();
 
-  // Called when h5vcc.system.record_stats is set
-  void OnSetRecordStats(bool set);
-
   // 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/web_module.cc b/src/cobalt/browser/web_module.cc
index 29a4b1d..a23cdb6 100644
--- a/src/cobalt/browser/web_module.cc
+++ b/src/cobalt/browser/web_module.cc
@@ -144,10 +144,6 @@
   void Suspend();
   void Resume(render_tree::ResourceProvider* resource_provider);
 
-  void OnSetRecordStats(bool set) {
-    web_module_stat_tracker_->OnSetRecordStats(set);
-  }
-
  private:
   class DocumentLoadedObserver;
 
@@ -394,7 +390,7 @@
 
   environment_settings_.reset(new dom::DOMSettings(
       kDOMMaxElementDepth, fetcher_factory_.get(), data.network_module, window_,
-      media_source_registry_.get(), javascript_engine_.get(),
+      media_source_registry_.get(), data.media_module, javascript_engine_.get(),
       global_environment_.get(), data.options.dom_settings_options));
   DCHECK(environment_settings_);
 
@@ -887,12 +883,5 @@
                             base::Unretained(impl_.get()), resource_provider));
 }
 
-void WebModule::OnSetRecordStats(bool set) {
-  DCHECK(message_loop());
-  DCHECK(impl_);
-  DCHECK_EQ(MessageLoop::current(), message_loop());
-  impl_->OnSetRecordStats(set);
-}
-
 }  // namespace browser
 }  // namespace cobalt
diff --git a/src/cobalt/browser/web_module.h b/src/cobalt/browser/web_module.h
index 5b6c8c2..b82f6f7 100644
--- a/src/cobalt/browser/web_module.h
+++ b/src/cobalt/browser/web_module.h
@@ -199,9 +199,6 @@
   // can only be called if we have previously suspended the WebModule.
   void Resume(render_tree::ResourceProvider* resource_provider);
 
-  // Called when h5vcc.system.recordStats is set.
-  void OnSetRecordStats(bool set);
-
 #if defined(COBALT_BUILD_TYPE_DEBUG)
   // Non-optimized builds require a bigger stack size.
   static const size_t kBaseStackSize = 2 * 1024 * 1024;
diff --git a/src/cobalt/browser/web_module_stat_tracker.cc b/src/cobalt/browser/web_module_stat_tracker.cc
index dc94278..aa4d634 100644
--- a/src/cobalt/browser/web_module_stat_tracker.cc
+++ b/src/cobalt/browser/web_module_stat_tracker.cc
@@ -20,9 +20,6 @@
 #include "cobalt/base/tokens.h"
 #include "cobalt/dom/event.h"
 
-// The maximum allowed string size of any recorded stat
-const std::string::size_type kMaxRecordedStatsBytes = 64 * 1024;
-
 namespace cobalt {
 namespace browser {
 
@@ -90,17 +87,6 @@
   layout_stat_tracker_->FlushPeriodicTracking();
 }
 
-void WebModuleStatTracker::OnSetRecordStats(bool set) {
-  record_stats_ = set;
-
-  // Every time this variable is set, we clear out our stats
-  for (ScopedVector<EventStats>::iterator it = event_stats_.begin();
-       it != event_stats_.end();
-       ++it) {
-    (*it)->event_durations = "[]";
-  }
-}
-
 WebModuleStatTracker::EventStats::EventStats(const std::string& name)
     : count_dom_html_elements_created(
           StringPrintf("Event.Count.%s.DOM.HtmlElement.Created", name.c_str()),
@@ -157,11 +143,7 @@
           StringPrintf("Event.Duration.%s.Layout.RenderAndAnimate",
                        name.c_str()),
           base::TimeDelta(),
-          "RenderAndAnimate duration for event (in microseconds)."),
-      event_durations(StringPrintf("Event.Durations.%s", name.c_str()),
-                     "[]",
-                     "JSON array of all event durations (in microseconds) "
-                     "since reset.") {}
+          "RenderAndAnimate duration for event (in microseconds).") {}
 
 bool WebModuleStatTracker::IsStopWatchEnabled(int /*id*/) const { return true; }
 
@@ -209,25 +191,9 @@
   // misleading as it merely indicates how long the user waited to initiate the
   // next event. When this occurs, the injection duration provides a much more
   // accurate picture of how long the event takes.
-  base::TimeDelta duration_total = was_render_tree_produced
+  event_stats->duration_total = was_render_tree_produced
                                     ? stop_watch_durations_[kStopWatchTypeEvent]
                                     : event_injection_duration;
-  event_stats->duration_total = duration_total;
-
-  if (record_stats_) {
-    std::string prev_durations = event_stats->event_durations.value();
-    if (prev_durations.size() <= 2) {
-      event_stats->event_durations =
-          StringPrintf("[%ld]", duration_total.InMicroseconds());
-    } else if (prev_durations.size() < kMaxRecordedStatsBytes) {
-      event_stats->event_durations
-          = StringPrintf("%s,%ld]",
-                         prev_durations.substr(
-                             0, prev_durations.size() - 1).c_str(),
-                             duration_total.InMicroseconds());
-    }
-  }
-
   event_stats->duration_dom_inject_event = event_injection_duration;
   event_stats->duration_dom_update_computed_style =
       dom_stat_tracker_->GetStopWatchTypeDuration(
diff --git a/src/cobalt/browser/web_module_stat_tracker.h b/src/cobalt/browser/web_module_stat_tracker.h
index 8ebf73d..5b317e7 100644
--- a/src/cobalt/browser/web_module_stat_tracker.h
+++ b/src/cobalt/browser/web_module_stat_tracker.h
@@ -54,9 +54,6 @@
   // triggers flushing of periodic counts within the stat trackers.
   void OnRenderTreeProduced();
 
-  // Called when h5vcc.system.record_stats is set
-  void OnSetRecordStats(bool set);
-
  private:
   enum EventType {
     kEventTypeInvalid = -1,
@@ -93,9 +90,6 @@
         duration_layout_update_used_sizes;
     base::CVal<base::TimeDelta, base::CValPublic>
         duration_layout_render_and_animate;
-
-    // Time series-related
-    base::CVal<std::string, base::CValPublic> event_durations;
   };
 
   // From base::StopWatchOwner
@@ -122,9 +116,6 @@
   std::vector<base::StopWatch> stop_watches_;
   std::vector<base::TimeDelta> stop_watch_durations_;
 
-  // Time series-related
-  bool record_stats_;
-
   std::string name_;
 
   base::CVal<int, base::CValPublic> event_is_processing_;
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index a658c30..d690671 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-13245
\ No newline at end of file
+13403
\ No newline at end of file
diff --git a/src/cobalt/build/config/base.gypi b/src/cobalt/build/config/base.gypi
index 36b2f95..8ba37eb 100644
--- a/src/cobalt/build/config/base.gypi
+++ b/src/cobalt/build/config/base.gypi
@@ -236,9 +236,6 @@
     'werror': '',
     # Cobalt doesn't currently support tcmalloc.
     'linux_use_tcmalloc': 0,
-
-    'enable_webdriver%': 0,
-
     # The event polling mechanism available on this platform to support libevent.
     # Platforms may redefine to 'poll' if necessary.
     # Other mechanisms, e.g. devpoll, kqueue, select, are not yet supported.
@@ -456,6 +453,7 @@
         'enable_network_logging': 1,
         'enable_remote_debugging%': 1,
         'enable_screenshot': 1,
+        'enable_webdriver%': 1,
       },
     },
     {
@@ -467,6 +465,7 @@
         'enable_network_logging': 0,
         'enable_remote_debugging%': 0,
         'enable_screenshot': 0,
+        'enable_webdriver': 0,
       },
     }],
   ],
diff --git a/src/cobalt/build/config/win.gypi b/src/cobalt/build/config/win.gypi
index 6a8cab4..8504e8b 100644
--- a/src/cobalt/build/config/win.gypi
+++ b/src/cobalt/build/config/win.gypi
@@ -34,6 +34,9 @@
     # there for acceptable values for this variable.
     'javascript_engine': 'javascriptcore',
 
+    # Webdriver won't compile on MSVC because of UTF8 string constant issues
+    'enable_webdriver': 0,
+
     # Compile with "PREfast" on by default.
     'static_analysis%': 'true',
 
diff --git a/src/cobalt/css_parser/parser.cc b/src/cobalt/css_parser/parser.cc
index c3ff81a..25f4d35 100644
--- a/src/cobalt/css_parser/parser.cc
+++ b/src/cobalt/css_parser/parser.cc
@@ -24,6 +24,7 @@
 #include <string>
 
 #include "base/bind.h"
+#include "base/debug/trace_event.h"
 #include "base/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/optional.h"
@@ -365,6 +366,7 @@
 bool ParserImpl::Parse() {
   // For more information on error codes
   // see http://www.gnu.org/software/bison/manual/html_node/Parser-Function.html
+  TRACE_EVENT0("cobalt::css_parser", "ParseImpl::Parse");
   last_syntax_error_location_ = base::nullopt;
   int error_code(yyparse(this));
   switch (error_code) {
diff --git a/src/cobalt/cssom/css_declared_style_declaration.cc b/src/cobalt/cssom/css_declared_style_declaration.cc
index c1d455c..6c4557e 100644
--- a/src/cobalt/cssom/css_declared_style_declaration.cc
+++ b/src/cobalt/cssom/css_declared_style_declaration.cc
@@ -16,6 +16,7 @@
 
 #include "cobalt/cssom/css_declared_style_declaration.h"
 
+#include "base/debug/trace_event.h"
 #include "base/lazy_instance.h"
 #include "cobalt/cssom/css_declared_style_data.h"
 #include "cobalt/cssom/css_parser.h"
@@ -63,6 +64,7 @@
 
 void CSSDeclaredStyleDeclaration::set_css_text(
     const std::string& css_text, script::ExceptionState* /*exception_state*/) {
+  TRACE_EVENT0("cobalt::cssom", "CSSDeclaredStyleDeclaration::set_css_text");
   DCHECK(css_parser_);
   scoped_refptr<CSSDeclaredStyleData> declaration =
       css_parser_->ParseStyleDeclarationList(
diff --git a/src/cobalt/dom/MediaSource.idl b/src/cobalt/dom/MediaSource.idl
index a53419c..65eeb35 100644
--- a/src/cobalt/dom/MediaSource.idl
+++ b/src/cobalt/dom/MediaSource.idl
@@ -28,4 +28,6 @@
   readonly attribute DOMString readyState;
 
   [RaisesException] void endOfStream(optional DOMString error);
+
+  [CallWith=EnvironmentSettings] static boolean isTypeSupported(DOMString type);
 };
diff --git a/src/cobalt/dom/dom_settings.cc b/src/cobalt/dom/dom_settings.cc
index 6588e93..1eca2a2 100644
--- a/src/cobalt/dom/dom_settings.cc
+++ b/src/cobalt/dom/dom_settings.cc
@@ -26,6 +26,7 @@
                          network::NetworkModule* network_module,
                          const scoped_refptr<Window>& window,
                          MediaSource::Registry* media_source_registry,
+                         media::CanPlayTypeHandler* can_play_type_handler,
                          script::JavaScriptEngine* engine,
                          script::GlobalEnvironment* global_environment,
                          const Options& options)
@@ -36,6 +37,7 @@
       array_buffer_allocator_(options.array_buffer_allocator),
       array_buffer_cache_(options.array_buffer_cache),
       media_source_registry_(media_source_registry),
+      can_play_type_handler_(can_play_type_handler),
       javascript_engine_(engine),
       global_environment_(global_environment) {
   if (array_buffer_allocator_) {
diff --git a/src/cobalt/dom/dom_settings.h b/src/cobalt/dom/dom_settings.h
index 8366e67..5bd39e1 100644
--- a/src/cobalt/dom/dom_settings.h
+++ b/src/cobalt/dom/dom_settings.h
@@ -22,6 +22,7 @@
 #include "cobalt/dom/array_buffer.h"
 #include "cobalt/dom/media_source.h"
 #include "cobalt/dom/window.h"
+#include "cobalt/media/can_play_type_handler.h"
 #include "cobalt/script/environment_settings.h"
 
 namespace cobalt {
@@ -62,6 +63,7 @@
               network::NetworkModule* network_module,
               const scoped_refptr<Window>& window,
               MediaSource::Registry* media_source_registry,
+              media::CanPlayTypeHandler* can_play_type_handler,
               script::JavaScriptEngine* engine,
               script::GlobalEnvironment* global_environment_proxy,
               const Options& options = Options());
@@ -95,6 +97,9 @@
   MediaSource::Registry* media_source_registry() const {
     return media_source_registry_;
   }
+  media::CanPlayTypeHandler* can_play_type_handler() const {
+    return can_play_type_handler_;
+  }
 
   // An absolute URL used to resolve relative URLs.
   virtual GURL base_url() const;
@@ -107,6 +112,7 @@
   ArrayBuffer::Allocator* array_buffer_allocator_;
   ArrayBuffer::Cache* array_buffer_cache_;
   MediaSource::Registry* media_source_registry_;
+  media::CanPlayTypeHandler* can_play_type_handler_;
   script::JavaScriptEngine* javascript_engine_;
   script::GlobalEnvironment* global_environment_;
 
diff --git a/src/cobalt/dom/media_source.cc b/src/cobalt/dom/media_source.cc
index fa881bf..f20ffb0 100644
--- a/src/cobalt/dom/media_source.cc
+++ b/src/cobalt/dom/media_source.cc
@@ -26,9 +26,12 @@
 #include "base/logging.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
+#include "cobalt/base/polymorphic_downcast.h"
 #include "cobalt/base/tokens.h"
 #include "cobalt/dom/dom_exception.h"
+#include "cobalt/dom/dom_settings.h"
 #include "cobalt/dom/event.h"
+#include "cobalt/media/can_play_type_handler.h"
 
 namespace cobalt {
 namespace dom {
@@ -252,6 +255,19 @@
   player_->SourceEndOfStream(eos_status);
 }
 
+// static
+bool MediaSource::IsTypeSupported(script::EnvironmentSettings* settings,
+                                  const std::string& type) {
+  DOMSettings* dom_settings =
+      base::polymorphic_downcast<DOMSettings*>(settings);
+  DCHECK(dom_settings);
+  media::CanPlayTypeHandler* handler = dom_settings->can_play_type_handler();
+  DCHECK(handler);
+  std::string result = handler->CanPlayType(type, "");
+  DLOG(INFO) << "MediaSource::IsTypeSupported(" << type << ") -> " << result;
+  return result == "probably";
+}
+
 void MediaSource::SetPlayer(WebMediaPlayer* player) {
   // It is possible to reuse a MediaSource object but unlikely. DCHECK it until
   // it is used in this way.
diff --git a/src/cobalt/dom/media_source.h b/src/cobalt/dom/media_source.h
index ec769e1..a30e5c3 100644
--- a/src/cobalt/dom/media_source.h
+++ b/src/cobalt/dom/media_source.h
@@ -25,6 +25,7 @@
 #include "cobalt/dom/event_target.h"
 #include "cobalt/dom/source_buffer.h"
 #include "cobalt/dom/source_buffer_list.h"
+#include "cobalt/script/environment_settings.h"
 #include "cobalt/script/exception_state.h"
 #include "media/player/web_media_player.h"
 
@@ -87,6 +88,9 @@
   void EndOfStream(const std::string& error,
                    script::ExceptionState* exception_state);
 
+  static bool IsTypeSupported(script::EnvironmentSettings* settings,
+                              const std::string& type);
+
   // Custom, not in any spec.
   //
   // The player is set when the media source is attached to a media element.
diff --git a/src/cobalt/h5vcc/H5vccSystem.idl b/src/cobalt/h5vcc/H5vccSystem.idl
index abf2017..25bbe3b 100644
--- a/src/cobalt/h5vcc/H5vccSystem.idl
+++ b/src/cobalt/h5vcc/H5vccSystem.idl
@@ -20,7 +20,6 @@
   readonly attribute DOMString platform;
   readonly attribute DOMString region;
   readonly attribute DOMString version;
-  attribute boolean recordStats;
   boolean triggerHelp();
   DOMString getVideoContainerSizeOverride();
 };
diff --git a/src/cobalt/h5vcc/h5vcc.cc b/src/cobalt/h5vcc/h5vcc.cc
index 16cb6c9..9792fcb 100644
--- a/src/cobalt/h5vcc/h5vcc.cc
+++ b/src/cobalt/h5vcc/h5vcc.cc
@@ -27,7 +27,7 @@
       new H5vccRuntime(settings.event_dispatcher, settings.initial_deep_link);
   settings_ = new H5vccSettings(settings.media_module);
   storage_ = new H5vccStorage(settings.network_module);
-  system_ = new H5vccSystem(settings.on_set_record_stats);
+  system_ = new H5vccSystem();
 }
 
 }  // namespace h5vcc
diff --git a/src/cobalt/h5vcc/h5vcc.h b/src/cobalt/h5vcc/h5vcc.h
index 8f46d2f..369cad3 100644
--- a/src/cobalt/h5vcc/h5vcc.h
+++ b/src/cobalt/h5vcc/h5vcc.h
@@ -45,7 +45,6 @@
     account::AccountManager* account_manager;
     base::EventDispatcher* event_dispatcher;
     std::string initial_deep_link;
-    base::Callback<void(bool)> on_set_record_stats;
   };
 
   explicit H5vcc(const Settings& config);
diff --git a/src/cobalt/h5vcc/h5vcc_system.cc b/src/cobalt/h5vcc/h5vcc_system.cc
index 5b668cd..3bf8cf3 100644
--- a/src/cobalt/h5vcc/h5vcc_system.cc
+++ b/src/cobalt/h5vcc/h5vcc_system.cc
@@ -24,9 +24,7 @@
 namespace cobalt {
 namespace h5vcc {
 
-H5vccSystem::H5vccSystem(const base::Callback<void(bool)>& on_set_record_stats)
-    : on_set_record_stats_(on_set_record_stats) {
-}
+H5vccSystem::H5vccSystem() {}
 
 bool H5vccSystem::are_keys_reversed() const {
   return deprecated::PlatformDelegate::Get()->AreKeysReversed();
diff --git a/src/cobalt/h5vcc/h5vcc_system.h b/src/cobalt/h5vcc/h5vcc_system.h
index 3ce8764..be0db79 100644
--- a/src/cobalt/h5vcc/h5vcc_system.h
+++ b/src/cobalt/h5vcc/h5vcc_system.h
@@ -26,21 +26,13 @@
 
 class H5vccSystem : public script::Wrappable {
  public:
-  explicit H5vccSystem(const base::Callback<void(bool)>& on_set_record_stats);
+  H5vccSystem();
 
   bool are_keys_reversed() const;
   std::string build_id() const;
   std::string platform() const;
   std::string region() const;
   std::string version() const;
-  bool record_stats() const {
-    return record_stats_;
-  }
-  void set_record_stats(bool record_stats) {
-    record_stats_ = record_stats;
-
-    on_set_record_stats_.Run(record_stats);
-  }
 
   bool TriggerHelp() const;
   std::string GetVideoContainerSizeOverride() const;
@@ -48,8 +40,6 @@
   DEFINE_WRAPPABLE_TYPE(H5vccSystem);
 
  private:
-  base::Callback<void(bool)> on_set_record_stats_;
-  bool record_stats_;
   DISALLOW_COPY_AND_ASSIGN(H5vccSystem);
 };
 
diff --git a/src/cobalt/renderer/rasterizer/skia/render_tree_node_visitor.cc b/src/cobalt/renderer/rasterizer/skia/render_tree_node_visitor.cc
index 748aefd..e7225dc 100644
--- a/src/cobalt/renderer/rasterizer/skia/render_tree_node_visitor.cc
+++ b/src/cobalt/renderer/rasterizer/skia/render_tree_node_visitor.cc
@@ -366,7 +366,22 @@
 
 void RenderTreeNodeVisitor::Visit(render_tree::FilterNode* filter_node) {
   if (filter_node->data().map_to_mesh_filter) {
-    // TODO: Implement support for MapToMeshFilter.
+    // TODO: Implement support for MapToMeshFilter instead of punching out
+    //       the area that it occupies.
+    SkPaint paint;
+    paint.setXfermodeMode(SkXfermode::kSrc_Mode);
+    paint.setARGB(0, 0, 0, 0);
+
+    math::RectF bounds = filter_node->GetBounds();
+    SkRect sk_rect = SkRect::MakeXYWH(bounds.x(), bounds.y(), bounds.width(),
+                                      bounds.height());
+
+    draw_state_.render_target->drawRect(sk_rect, paint);
+
+#if ENABLE_FLUSH_AFTER_EVERY_NODE
+    draw_state_.render_target->flush();
+#endif
+
     return;
   }
 
diff --git a/src/cobalt/script/mozjs/mozjs_callback_function.h b/src/cobalt/script/mozjs/mozjs_callback_function.h
index cb3abc6..71d8914 100644
--- a/src/cobalt/script/mozjs/mozjs_callback_function.h
+++ b/src/cobalt/script/mozjs/mozjs_callback_function.h
@@ -57,6 +57,7 @@
 
   CallbackResult<R> Run()
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
@@ -110,6 +111,7 @@
   CallbackResult<R> Run(
       typename base::internal::CallbackParamTraits<A1>::ForwardType a1)
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
@@ -169,6 +171,7 @@
       typename base::internal::CallbackParamTraits<A1>::ForwardType a1,
       typename base::internal::CallbackParamTraits<A2>::ForwardType a2)
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
@@ -230,6 +233,7 @@
       typename base::internal::CallbackParamTraits<A2>::ForwardType a2,
       typename base::internal::CallbackParamTraits<A3>::ForwardType a3)
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
@@ -293,6 +297,7 @@
       typename base::internal::CallbackParamTraits<A3>::ForwardType a3,
       typename base::internal::CallbackParamTraits<A4>::ForwardType a4)
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
@@ -359,6 +364,7 @@
       typename base::internal::CallbackParamTraits<A4>::ForwardType a4,
       typename base::internal::CallbackParamTraits<A5>::ForwardType a5)
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
@@ -427,6 +433,7 @@
       typename base::internal::CallbackParamTraits<A5>::ForwardType a5,
       typename base::internal::CallbackParamTraits<A6>::ForwardType a6)
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
@@ -497,6 +504,7 @@
       typename base::internal::CallbackParamTraits<A6>::ForwardType a6,
       typename base::internal::CallbackParamTraits<A7>::ForwardType a7)
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
diff --git a/src/cobalt/script/mozjs/mozjs_callback_function.h.pump b/src/cobalt/script/mozjs/mozjs_callback_function.h.pump
index 14067e9..861dcd3 100644
--- a/src/cobalt/script/mozjs/mozjs_callback_function.h.pump
+++ b/src/cobalt/script/mozjs/mozjs_callback_function.h.pump
@@ -76,6 +76,7 @@
 
       typename base::internal::CallbackParamTraits<A$(ARG)>::ForwardType a$(ARG)]])
       const OVERRIDE {
+    TRACE_EVENT0("cobalt::script::mozjs", "MozjsCallbackFunction::Run");
     CallbackResult<R> callback_result;
     JSAutoRequest auto_request(context_);
     JS::RootedObject function(context_, weak_function_.Get());
diff --git a/src/cobalt/webdriver_benchmarks/tests/guide.py b/src/cobalt/webdriver_benchmarks/tests/guide.py
index 442eef1..2ebf58e 100755
--- a/src/cobalt/webdriver_benchmarks/tests/guide.py
+++ b/src/cobalt/webdriver_benchmarks/tests/guide.py
@@ -26,12 +26,11 @@
 class GuideTest(tv_testcase.TvTestCase):
 
   def test_simple(self):
+    layout_times_us = []
+
     self.load_tv()
     self.assert_displayed(tv.FOCUSED_SHELF)
 
-    print(str(self.get_webdriver().execute_script(
-        "h5vcc.system.recordStats = true")))
-
     for _ in xrange(REPEAT_COUNT):
       self.send_keys(tv.FOCUSED_SHELF, keys.Keys.ARROW_LEFT)
       self.assert_displayed(tv.FOCUSED_GUIDE)
@@ -40,8 +39,9 @@
       self.poll_until_found(tv.FOCUSED_SHELF)
       self.assert_displayed(tv.FOCUSED_SHELF_TITLE)
       self.wait_for_layout_complete()
+      layout_times_us.append(self.get_keyup_layout_duration_us())
 
-    self.record_results("GuideTest.test_simple")
+    self.record_results("GuideTest.test_simple", layout_times_us)
 
 
 if __name__ == "__main__":
diff --git a/src/cobalt/webdriver_benchmarks/tests/shelf.py b/src/cobalt/webdriver_benchmarks/tests/shelf.py
index b47e379..7372e55 100755
--- a/src/cobalt/webdriver_benchmarks/tests/shelf.py
+++ b/src/cobalt/webdriver_benchmarks/tests/shelf.py
@@ -27,25 +27,25 @@
 class ShelfTest(tv_testcase.TvTestCase):
 
   def test_simple(self):
+    layout_times_us = []
     self.load_tv()
     self.assert_displayed(tv.FOCUSED_SHELF)
 
-    print(str(self.get_webdriver().execute_script(
-        "h5vcc.system.recordStats = true")))
-
     for _ in xrange(DEFAULT_SHELVES_COUNT):
       self.send_keys(tv.FOCUSED_SHELF, keys.Keys.ARROW_DOWN)
       self.poll_until_found(tv.FOCUSED_SHELF)
       self.assert_displayed(tv.FOCUSED_SHELF_TITLE)
       self.wait_for_layout_complete()
+      layout_times_us.append(self.get_keyup_layout_duration_us())
 
     for _ in xrange(SHELF_ITEMS_COUNT):
       self.send_keys(tv.FOCUSED_TILE, keys.Keys.ARROW_RIGHT)
       self.poll_until_found(tv.FOCUSED_TILE)
       self.assert_displayed(tv.FOCUSED_SHELF_TITLE)
       self.wait_for_layout_complete()
+      layout_times_us.append(self.get_keyup_layout_duration_us())
 
-    self.record_results("ShelfTest.test_simple")
+    self.record_results("ShelfTest.test_simple", layout_times_us)
 
 
 if __name__ == "__main__":
diff --git a/src/cobalt/webdriver_benchmarks/tv_testcase.py b/src/cobalt/webdriver_benchmarks/tv_testcase.py
index 23649ec..3189523 100644
--- a/src/cobalt/webdriver_benchmarks/tv_testcase.py
+++ b/src/cobalt/webdriver_benchmarks/tv_testcase.py
@@ -4,6 +4,7 @@
 from __future__ import division
 from __future__ import print_function
 
+import json
 import os
 import sys
 import time
@@ -25,7 +26,7 @@
     partial_layout_benchmark.ImportSeleniumModule(
         submodule="common.exceptions").ElementNotVisibleException)
 
-BASE_URL = "https://www.youtube.com/tv"
+BASE_URL = "https://www.youtube.com/tv?env_forcedOffAllExperiments=true"
 PAGE_LOAD_WAIT_SECONDS = 30
 LAYOUT_TIMEOUT_SECONDS = 5
 
@@ -163,18 +164,21 @@
 
       time.sleep(0.1)
 
-  def record_results(self, name):
+  def get_keyup_layout_duration_us(self):
+    return int(self.get_webdriver().execute_script(
+        "return h5vcc.cVal.getValue('Event.Duration.MainWebModule.KeyUp')"))
+
+  def record_results(self, name, results):
     """Records results of benchmark.
 
     The duration of KeyUp events will be recorded.
 
     Args:
       name: name of test case
+      results: Test results. Must be JSON encodable
     """
     print("tv_testcase RESULT: " + name + " "
-          + str(self.get_webdriver().execute_script(
-              "return h5vcc.cVal.getValue("
-              "'Event.Durations.MainWebModule.KeyUp')")))
+          + json.JSONEncoder().encode(results))
 
 
 def main():
diff --git a/src/cobalt/xhr/xml_http_request_test.cc b/src/cobalt/xhr/xml_http_request_test.cc
index ac3b5c1..e39fe5f 100644
--- a/src/cobalt/xhr/xml_http_request_test.cc
+++ b/src/cobalt/xhr/xml_http_request_test.cc
@@ -92,7 +92,8 @@
 
 class FakeSettings : public dom::DOMSettings {
  public:
-  FakeSettings() : dom::DOMSettings(0, NULL, NULL, NULL, NULL, NULL, NULL) {}
+  FakeSettings()
+      : dom::DOMSettings(0, NULL, NULL, NULL, NULL, NULL, NULL, NULL) {}
   GURL base_url() const OVERRIDE { return GURL("http://example.com"); }
 };
 
diff --git a/src/nb/nb.gyp b/src/nb/nb.gyp
index b3b9a0d..3780eb9 100644
--- a/src/nb/nb.gyp
+++ b/src/nb/nb.gyp
@@ -63,6 +63,7 @@
         'fixed_no_free_allocator_test.cc',
         'reuse_allocator_test.cc',
         'run_all_unittests.cc',
+        'thread_local_object_test.cc',
       ],
       'dependencies': [
         'nb',
diff --git a/src/nb/thread_local_object.h b/src/nb/thread_local_object.h
new file mode 100644
index 0000000..4b6a7ab
--- /dev/null
+++ b/src/nb/thread_local_object.h
@@ -0,0 +1,214 @@
+/*
+ * Copyright 2016 Google Inc. 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 BASE_THREADING_THREAD_LOCAL_OBJECT_H_
+#define BASE_THREADING_THREAD_LOCAL_OBJECT_H_
+
+#include <set>
+
+#include "starboard/configuration.h"
+#include "starboard/log.h"
+#include "starboard/mutex.h"
+#include "starboard/thread.h"
+
+namespace base {
+
+// Like base::ThreadLocalPointer<T> but destroys objects. This is important
+// for using ThreadLocalObjects that aren't tied to a singleton, or for
+// access by threads which will call join().
+//
+// FEATURE COMPARISON TABLE:
+//                         |  Thread Join       | Container Destroyed
+//   ------------------------------------------------------------------
+//   ThreadLocalPointer<T> | LEAKS              | LEAKS
+//   ThreadLocalObject<T>  | Object Destroyed   | Objects Destroyed
+//
+// EXAMPLE:
+//  ThreadLocalObject<std::map<std::string, int> > map_tls;
+//  Map* map = map_tls->GetOrCreate();
+//  (*map)["my string"] = 15;
+//  Thread t = new Thread(&map_tls);
+//  t->start();
+//  // t creates it's own thread local map.
+//  t->join();  // Make sure that thread joins before map_tls is destroyed!
+//
+// OBJECT DESTRUCTION:
+//   There are two ways for an object to be destroyed by the ThreadLocalObject.
+//   The first way is via a thread join. In this case only the object
+//   associated with the thread is deleted.
+//   The second way an object is destroyed is by the ThreadLocalObject
+//   container to be destroyed, in this case ALL thread local objects are
+//   destroyed.
+//
+// PERFORMANCE:
+//   ThreadLocalObject is fast for the Get() function if the object has
+//   has already been created, requiring one extra pointer dereference
+//   over ThreadLocalPointer<T>.
+template <typename Type>
+class ThreadLocalObject {
+ public:
+  ThreadLocalObject() : slot_() {
+    slot_ = SbThreadCreateLocalKey(DeleteEntry);
+    SB_DCHECK(kSbThreadLocalKeyInvalid != slot_);
+    constructing_thread_id_ = SbThreadGetId();
+  }
+
+  // Enables destruction by any other thread. Otherwise, the class instance
+  // will warn when a different thread than the constructing destroys this.
+  void EnableDestructionByAnyThread() {
+    constructing_thread_id_ = kSbThreadInvalidId;
+  }
+
+  // Thread Local Objects are destroyed after this call.
+  ~ThreadLocalObject() {
+    CheckCurrentThreadAllowedToDestruct();
+    SB_DCHECK(entry_set_.size() < 2)
+        << "Logic error: Some threads may still be accessing the objects that "
+        << "are about to be destroyed. Only one object is expected and that "
+        << "should be for the main thread. The caller should ensure that "
+        << "other threads that access this object are externally "
+        << "synchronized.";
+    // No locking is done because the entries should not be accessed by
+    // different threads while this object is shutting down. If access is
+    // occuring then the caller has a race condition, external to this class.
+    typedef typename Set::iterator Iter;
+    for (Iter it = entry_set_.begin(); it != entry_set_.end(); ++it) {
+      Entry* entry = *it;
+      SB_DCHECK(entry->owner_ == this);
+      delete entry->ptr_;
+      delete entry;
+    }
+
+    // Cleanup the thread local key.
+    SbThreadDestroyLocalKey(slot_);
+  }
+
+  // Warns if there is a misuse of this object.
+  void CheckCurrentThreadAllowedToDestruct() const {
+    if (kSbThreadInvalidId == constructing_thread_id_) {
+      return;   // EnableDestructionByAnyThread() called.
+    }
+    const SbThreadId curr_thread_id = SbThreadGetId();
+    if (curr_thread_id == constructing_thread_id_) {
+      return;   // Same thread that constructed this.
+    }
+
+    if (SB_DLOG_IS_ON(FATAL)) {
+      SB_DCHECK(false)
+          << "ThreadLocalObject<T> was created in thread "
+          << constructing_thread_id_ << "\nbut was destroyed by "
+          << curr_thread_id << ". If this is intentional then call "
+          << "EnableDestructionByAnyThread() to silence this "
+          << "warning.";
+    }
+  }
+
+  // Either returns the created pointer for the current thread, or otherwise
+  // constructs the object using the default constructor and returns it.
+  Type* GetOrCreate() {
+    Type* object = GetIfExists();
+    if (!object) {  // create object.
+      object = new Type();
+      Entry* entry = new Entry(this, object);
+      // Insert into the set of tls entries.
+      // Performance: Its assumed that creation of objects is much less
+      // frequent than getting an object.
+      {
+        starboard::ScopedLock lock(entry_set_mutex_);
+        entry_set_.insert(entry);
+      }
+      SbThreadSetLocalValue(slot_, entry);
+    }
+    return object;
+  }
+
+  // Returns the pointer if it exists in the current thread, otherwise NULL.
+  Type* GetIfExists() const {
+    Entry* entry = GetEntryIfExists();
+    if (!entry) { return NULL; }
+    return entry->ptr_;
+  }
+
+  // Releases ownership of the pointer FROM THE CURRENT THREAD.
+  // The caller has responsibility to make sure that the pointer is destroyed.
+  Type* Release() {
+    if (Entry* entry = GetEntryIfExists()) {
+      // The entry will no longer run it's destructor on thread join.
+      SbThreadSetLocalValue(slot_, NULL);  // NULL out pointer for TLS.
+      Type* object = entry->ptr_;
+      RemoveEntry(entry);
+      return object;
+    } else {
+      return NULL;
+    }
+  }
+
+ private:
+  struct Entry {
+    Entry(ThreadLocalObject* own, Type* ptr) : owner_(own), ptr_(ptr) {
+    }
+    ~Entry() {
+      ptr_ = NULL;
+      owner_ = NULL;
+    }
+    ThreadLocalObject* owner_;
+    Type* ptr_;
+  };
+
+  // Deletes the TLSEntry.
+  static void DeleteEntry(void* ptr) {
+    if (!ptr) {
+      SB_NOTREACHED();
+      return;
+    }
+    Entry* entry = reinterpret_cast<Entry*>(ptr);
+    ThreadLocalObject* tls = entry->owner_;
+    Type* object = entry->ptr_;
+    tls->RemoveEntry(entry);
+    delete object;
+  }
+
+  void RemoveEntry(Entry* entry) {
+    {
+      starboard::ScopedLock lock(entry_set_mutex_);
+      entry_set_.erase(entry);
+    }
+    delete entry;
+  }
+
+  Entry* GetEntryIfExists() const {
+    void* ptr = SbThreadGetLocalValue(slot_);
+    Entry* entry = static_cast<Entry*>(ptr);
+    return entry;
+  }
+
+  typedef std::set<Entry*> Set;
+  // Allows GetIfExists() to be const.
+  mutable SbThreadLocalKey slot_;
+  // entry_set_ contains all the outstanding entries for the thread local
+  // objects that have been created.
+  Set entry_set_;
+  mutable starboard::Mutex entry_set_mutex_;
+  // Used to warn when there is a mismatch between thread that constructed and
+  // thread that destroyed this object.
+  SbThreadId constructing_thread_id_;
+
+  SB_DISALLOW_COPY_AND_ASSIGN(ThreadLocalObject<Type>);
+};
+
+}  // namespace base
+
+#endif  // BASE_THREADING_THREAD_LOCAL_H_
diff --git a/src/nb/thread_local_object_test.cc b/src/nb/thread_local_object_test.cc
new file mode 100644
index 0000000..000c6f4
--- /dev/null
+++ b/src/nb/thread_local_object_test.cc
@@ -0,0 +1,346 @@
+// Copyright 2016 Google Inc. 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 <map>
+#include <string>
+
+#include "nb/thread_local_object.h"
+#include "nb/scoped_ptr.h"
+#include "starboard/mutex.h"
+#include "starboard/thread.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace base {
+namespace {
+
+// Similar to C++11 std::atomic<T>.
+// Atomic<T> may be instantiated with any TriviallyCopyable type T.
+// Atomic<T> is neither copyable nor movable.
+// TODO: Lift this class out into the library.
+template <typename T>
+class Atomic {
+ public:
+  // C++11 forbids a copy constructor for std::atomic<T>, it also forbids
+  // a move operation.
+  Atomic() : value_() {}
+  explicit Atomic(T v) : value_(v) {}
+
+  // Checks whether the atomic operations on all objects of this type
+  // are lock-free.
+  // Returns true if the atomic operations on the objects of this type
+  // are lock-free, false otherwise.
+  //
+  // All atomic types may be implemented using mutexes or other locking
+  // operations, rather than using the lock-free atomic CPU instructions.
+  // Atomic types are also allowed to be sometimes lock-free, e.g. if only
+  // aligned memory accesses are naturally atomic on a given architecture,
+  // misaligned objects of the same type have to use locks.
+  bool is_lock_free() const { return false; }
+  bool is_lock_free() const volatile { return false; }
+
+  // Atomically replaces the value of the atomic object
+  // and returns the value held previously.
+  T Swap(T new_val) {
+    int old_value = -1;
+    {
+      starboard::ScopedLock lock(mutex_);
+      old_value = value_;
+      value_ = new_val;
+    }
+    return old_value;
+  }
+
+  // Atomically obtains the value of the atomic object.
+  T Get() const {
+    starboard::ScopedLock lock(mutex_);
+    return value_;
+  }
+
+  // Returns the new updated value after the operation has been applied.
+  T Add(T val) {
+    starboard::ScopedLock lock(mutex_);
+    value_ += val;
+    return value_;
+  }
+
+  // TrySwap(...) sets the new value if and only if "expected_old_value"
+  // matches the actual value during the atomic assignment operation. If this
+  // succeeds then true is returned. If there is a mismatch then the value is
+  // left unchanged and false is returned.
+  // Inputs:
+  //  new_value: Attempt to set the value to this new value.
+  //  expected_old_value: A test condition for success. If the actual value
+  //    matches the expected_old_value then the swap will succeed.
+  //  optional_actual_value: If non-null, then the actual value at the time
+  //    of the attempted operation is set to this value.
+  bool TrySwap(T new_value, T expected_old_value,
+               T* optional_actual_value) {
+    starboard::ScopedLock lock(mutex_);
+    if (optional_actual_value) {
+      *optional_actual_value = value_;
+    }
+    if (expected_old_value == value_) {
+      value_ = new_value;
+      return true;
+    }
+    return false;
+  }
+
+ private:
+  T value_;
+  starboard::Mutex mutex_;
+};
+
+// Simple atomic int class. This could be optimized for speed using
+// compiler intrinsics for concurrent integer modification.
+class AtomicInt : public Atomic<int> {
+ public:
+  AtomicInt() : Atomic<int>(0) {}
+  explicit AtomicInt(int initial_val) : Atomic<int>(initial_val) {}
+  void Increment() { Add(1); }
+  void Decrement() { Add(-1); }
+};
+
+// Simple atomic bool class. This could be optimized for speed using
+// compiler intrinsics for concurrent integer modification.
+class AtomicBool : public Atomic<bool>  {
+ public:
+  AtomicBool() : Atomic<bool>(false) {}
+  explicit AtomicBool(bool initial_val) : Atomic<bool>(initial_val) {}
+};
+
+// AbstractTestThread that is a bare bones class wrapper around Starboard
+// thread. Subclasses must override Run().
+// TODO: Move this to nplb/thread_helpers.h
+class AbstractTestThread {
+ public:
+  explicit AbstractTestThread() : thread_(kSbThreadInvalid) {}
+  virtual ~AbstractTestThread() {}
+
+  // Subclasses should override the Run method.
+  virtual void Run() = 0;
+
+  // Calls SbThreadCreate() with default parameters.
+  void Start() {
+    SbThreadEntryPoint entry_point = ThreadEntryPoint;
+
+    thread_ = SbThreadCreate(
+        0,                     // default stack_size.
+        kSbThreadNoPriority,   // default priority.
+        kSbThreadNoAffinity,   // default affinity.
+        true,                  // joinable.
+        "AbstractTestThread",
+        entry_point,
+        this);
+
+    if (kSbThreadInvalid == thread_) {
+      ADD_FAILURE_AT(__FILE__, __LINE__) << "Invalid thread.";
+    }
+    return;
+  }
+
+  void Join() {
+    if (!SbThreadJoin(thread_, NULL)) {
+      ADD_FAILURE_AT(__FILE__, __LINE__) << "Could not join thread.";
+    }
+  }
+
+ private:
+  static void* ThreadEntryPoint(void* ptr) {
+    AbstractTestThread* this_ptr = static_cast<AbstractTestThread*>(ptr);
+    this_ptr->Run();
+    return NULL;
+  }
+
+  SbThread thread_;
+};
+
+// Simple class that counts the number of instances alive.
+struct CountsInstances {
+  CountsInstances() { s_instances_.Increment(); }
+  ~CountsInstances() { s_instances_.Decrement(); }
+  static AtomicInt s_instances_;
+  static int NumInstances() { return s_instances_.Get(); }
+  static void ResetNumInstances() { s_instances_.Swap(0); }
+};
+AtomicInt CountsInstances::s_instances_(0);
+
+// A simple thread that just creates the an object from the supplied
+// ThreadLocalObject<T> and then exits.
+template <typename TYPE>
+class CreateThreadLocalObjectThenExit : public AbstractTestThread {
+ public:
+  explicit CreateThreadLocalObjectThenExit(
+      ThreadLocalObject<TYPE>* tlo) : tlo_(tlo) {}
+
+  virtual void Run() {
+    // volatile as a defensive measure to prevent compiler from optimizing this
+    // statement out.
+    volatile TYPE* val = tlo_->GetOrCreate();
+  }
+  ThreadLocalObject<TYPE>* tlo_;
+};
+
+// A simple thread that just deletes the object supplied on a thread and then
+// exists.
+template <typename TYPE>
+class DestroyTypeOnThread : public AbstractTestThread {
+ public:
+  explicit DestroyTypeOnThread(TYPE* ptr)
+      : ptr_(ptr) {}
+  virtual void Run() {
+    ptr_.reset(NULL);  // Destroys the object.
+  }
+ private:
+  nb::scoped_ptr<TYPE> ptr_;
+};
+
+// Tests the expectation that a ThreadLocalObject can be simply used by
+// the main thread.
+TEST(ThreadLocalObject, MainThread) {
+  ThreadLocalObject<bool> tlo_bool;
+  EXPECT_TRUE(NULL == tlo_bool.GetIfExists());
+  bool* the_bool = tlo_bool.GetOrCreate();
+  EXPECT_TRUE(the_bool != NULL);
+  EXPECT_FALSE(*the_bool);
+  *the_bool = true;
+  EXPECT_TRUE(*(tlo_bool.GetIfExists()));
+}
+
+// Tests the expectation that a ThreadLocalObject can be used on
+// complex objects type (i.e. non pod types).
+TEST(ThreadLocalObject, MainThreadComplexObject) {
+  typedef std::map<std::string, int> Map;
+  ThreadLocalObject<Map> map_tlo;
+  EXPECT_FALSE(map_tlo.GetIfExists());
+  ASSERT_TRUE(map_tlo.GetOrCreate());
+  Map* map = map_tlo.GetIfExists();
+  const Map* const_map = map_tlo.GetIfExists();
+  ASSERT_TRUE(map);
+  ASSERT_TRUE(const_map);
+  // If the object is properly constructed then this find operation
+  // should succeed.
+  (*map)["my string"] = 15;
+  ASSERT_EQ(15, (*map)["my string"]);
+}
+
+// Tests that when a ThreadLocalObject is destroyed on the main thread that
+// the pointers it contained are also destroyed.
+TEST(ThreadLocalObject, DestroysObjectOnTLODestruction) {
+  CountsInstances::ResetNumInstances();
+  typedef ThreadLocalObject<CountsInstances> TLO;
+
+  // Create the TLO object and then immediately destroy it.
+  nb::scoped_ptr<TLO> tlo_ptr(new TLO);
+  tlo_ptr->GetOrCreate(); // Instantiate the internal object.
+  EXPECT_EQ(1, CountsInstances::NumInstances());
+  tlo_ptr.reset(NULL);    // Should destroy all outstanding allocs.
+  // Now the TLO is destroyed and therefore the destructor should run on the
+  // internal object.
+  EXPECT_EQ(0, CountsInstances::NumInstances());
+
+  CountsInstances::ResetNumInstances();
+}
+
+// Tests the expectation that the object can be released and that the pointer
+// won't be deleted when the ThreadLocalObject that created it is destroyed.
+TEST(ThreadLocalObject, ReleasesObject) {
+  CountsInstances::ResetNumInstances();
+  typedef ThreadLocalObject<CountsInstances> TLO;
+
+  nb::scoped_ptr<TLO> tlo_ptr(new TLO);
+  // Instantiate the internal object.
+  tlo_ptr->GetOrCreate();
+  // Now release the pointer into the container.
+  nb::scoped_ptr<CountsInstances> last_ref(tlo_ptr->Release());
+  // Destroying the TLO should not trigger the destruction of the object,
+  // because it was released.
+  tlo_ptr.reset(NULL);
+  // 1 instance left, which is held in last_ref.
+  EXPECT_EQ(1, CountsInstances::NumInstances());
+  last_ref.reset(NULL);   // Now the object should be destroyed and the
+                          // instance count drops to 0.
+  EXPECT_EQ(0, CountsInstances::NumInstances());
+  CountsInstances::ResetNumInstances();
+}
+
+// Tests the expectation that a thread that creates an object from
+// the ThreadLocalObject store will automatically be destroyed by the
+// thread joining.
+TEST(ThreadLocalObject, ThreadJoinDestroysObject) {
+  CountsInstances::ResetNumInstances();
+  typedef ThreadLocalObject<CountsInstances> TLO;
+
+  nb::scoped_ptr<TLO> tlo(new TLO);
+  {
+    AbstractTestThread* thread =
+        new CreateThreadLocalObjectThenExit<CountsInstances>(tlo.get());
+    thread->Start();
+    thread->Join();
+    // Once the thread joins, the object should be deleted and the instance
+    // counter falls to 0.
+    EXPECT_EQ(0, CountsInstances::NumInstances());
+    delete thread;
+  }
+
+  tlo.reset(NULL);  // Now TLO destructor runs.
+  EXPECT_EQ(0, CountsInstances::NumInstances());
+  CountsInstances::ResetNumInstances();
+}
+
+// Tests the expectation that objects created on the main thread are not
+// leaked.
+TEST(ThreadLocalObject, NoLeaksOnMainThread) {
+  CountsInstances::ResetNumInstances();
+
+  ThreadLocalObject<CountsInstances>* tlo =
+      new ThreadLocalObject<CountsInstances>;
+  tlo->EnableDestructionByAnyThread();
+
+  // Creates the object on the main thread. This is important because the
+  // main thread will never join and therefore at-exit functions won't get
+  // run.
+  CountsInstances* main_thread_object = tlo->GetOrCreate();
+
+  EXPECT_EQ(1, CountsInstances::NumInstances());
+
+  // Thread will simply create the thread local object (CountsInstances)
+  // and then return.
+  nb::scoped_ptr<AbstractTestThread> thread_ptr(
+        new CreateThreadLocalObjectThenExit<CountsInstances>(tlo));
+  thread_ptr->Start();  // Object is now created.
+  thread_ptr->Join();   // ...then destroyed.
+  thread_ptr.reset(NULL);
+
+  // Only main_thread_object should be alive now, therefore the count is 1.
+  EXPECT_EQ(1, CountsInstances::NumInstances());
+
+  // We COULD destroy the TLO on the main thread, but to be even fancier lets
+  // create a thread that will destroy the object on a back ground thread.
+  // The end result is that the TLO entry should be cleared out.
+  thread_ptr.reset(
+      new DestroyTypeOnThread<ThreadLocalObject<CountsInstances> >(tlo));
+  thread_ptr->Start();
+  thread_ptr->Join();
+  thread_ptr.reset(NULL);
+
+  // Now we expect that number of instances to be 0.
+  EXPECT_EQ(0, CountsInstances::NumInstances());
+  CountsInstances::ResetNumInstances();
+}
+
+}  // anonymous namespace
+}  // namespace base
+
diff --git a/src/starboard/file.h b/src/starboard/file.h
index bda6f3a..3f15daf 100644
--- a/src/starboard/file.h
+++ b/src/starboard/file.h
@@ -117,6 +117,9 @@
 // can happen with kSbFileCreateAlways), and false otherwise.  |out_error| can
 // be NULL. If creation failed, it will return kSbFileInvalid. The read/write
 // position is at the beginning of the file.
+//
+// It only guarantees the correct behavior when |path| points to a file. If
+// |path| points to directory, the behavior is undefined.
 SB_EXPORT SbFile SbFileOpen(const char* path,
                             int flags,
                             bool* out_created,
diff --git a/src/starboard/linux/shared/gyp_configuration.gypi b/src/starboard/linux/shared/gyp_configuration.gypi
index e4ca809..af152fe 100644
--- a/src/starboard/linux/shared/gyp_configuration.gypi
+++ b/src/starboard/linux/shared/gyp_configuration.gypi
@@ -21,7 +21,6 @@
     'target_os': 'linux',
     #'starboard_path%': 'starboard/linux/x64x11',
 
-    'enable_webdriver': '1',
     'in_app_dial%': 1,
     'gl_type%': 'system_gles3',
 
diff --git a/src/starboard/nplb/file_get_info_test.cc b/src/starboard/nplb/file_get_info_test.cc
index 1722577..fa61d8b 100644
--- a/src/starboard/nplb/file_get_info_test.cc
+++ b/src/starboard/nplb/file_get_info_test.cc
@@ -40,6 +40,11 @@
     // Assuming platforms have at least 1 second precision on filesystem
     // timestamps, we need to go back two seconds to avoid rounding issues.
     SbTime time = SbTimeGetNow() - (2 * kSbTimeSecond);
+#if SB_HAS_QUIRK(FILESYSTEM_COARSE_ACCESS_TIME)
+    // On platforms with coarse access time, we assume 1 day precision and go
+    // back 2 days to avoid rounding issues.
+    SbTime coarse_time = SbTimeGetNow() - (2 * kSbTimeDay);
+#endif
 
     const int kFileSize = 12;
     starboard::nplb::ScopedRandomFile random_file(kFileSize);
@@ -56,7 +61,11 @@
       EXPECT_FALSE(info.is_directory);
       EXPECT_FALSE(info.is_symbolic_link);
       EXPECT_LE(time, info.last_modified);
+#if SB_HAS_QUIRK(FILESYSTEM_COARSE_ACCESS_TIME)
+      EXPECT_LE(coarse_time, info.last_accessed);
+#else
       EXPECT_LE(time, info.last_accessed);
+#endif
       EXPECT_LE(time, info.creation_time);
     }
 
@@ -65,30 +74,6 @@
   }
 }
 
-TEST(SbFileGetInfoTest, WorksOnADirectory) {
-  char path[SB_FILE_MAX_PATH] = {0};
-  bool result =
-      SbSystemGetPath(kSbSystemPathTempDirectory, path, SB_FILE_MAX_PATH);
-  EXPECT_TRUE(result);
-
-  SbFile file = SbFileOpen(path, kSbFileOpenOnly | kSbFileRead, NULL, NULL);
-  ASSERT_TRUE(SbFileIsValid(file));
-
-  {
-    SbFileInfo info = {0};
-    bool result = SbFileGetInfo(file, &info);
-    EXPECT_LE(0, info.size);
-    EXPECT_TRUE(info.is_directory);
-    EXPECT_FALSE(info.is_symbolic_link);
-    EXPECT_LE(0, info.last_modified);
-    EXPECT_LE(0, info.last_accessed);
-    EXPECT_LE(0, info.creation_time);
-  }
-
-  result = SbFileClose(file);
-  EXPECT_TRUE(result);
-}
-
 }  // namespace
 }  // namespace nplb
 }  // namespace starboard
diff --git a/src/starboard/nplb/file_get_path_info_test.cc b/src/starboard/nplb/file_get_path_info_test.cc
index f96e205..fc024ff 100644
--- a/src/starboard/nplb/file_get_path_info_test.cc
+++ b/src/starboard/nplb/file_get_path_info_test.cc
@@ -52,6 +52,11 @@
     // Assuming platforms have at least 1 second precision on filesystem
     // timestamps, we need to go back two seconds to avoid rounding issues.
     SbTime time = SbTimeGetNow() - (2 * kSbTimeSecond);
+#if SB_HAS_QUIRK(FILESYSTEM_COARSE_ACCESS_TIME)
+    // On platforms with coarse access time, we assume 1 day precision and go
+    // back 2 days to avoid rounding issues.
+    SbTime coarse_time = SbTimeGetNow() - (2 * kSbTimeDay);
+#endif
 
     const int kFileSize = 12;
     ScopedRandomFile random_file(kFileSize);
@@ -64,7 +69,11 @@
       EXPECT_FALSE(info.is_directory);
       EXPECT_FALSE(info.is_symbolic_link);
       EXPECT_LE(time, info.last_modified);
+#if SB_HAS_QUIRK(FILESYSTEM_COARSE_ACCESS_TIME)
+      EXPECT_LE(coarse_time, info.last_accessed);
+#else
       EXPECT_LE(time, info.last_accessed);
+#endif
       EXPECT_LE(time, info.creation_time);
     }
   }
diff --git a/src/starboard/nplb/thread_helpers.h b/src/starboard/nplb/thread_helpers.h
index 0ebbd03..aa4e32d 100644
--- a/src/starboard/nplb/thread_helpers.h
+++ b/src/starboard/nplb/thread_helpers.h
@@ -16,10 +16,14 @@
 #define STARBOARD_NPLB_THREAD_HELPERS_H_
 
 #include "starboard/condition_variable.h"
+#include "starboard/configuration.h"
 #include "starboard/mutex.h"
+#include "starboard/thread.h"
 #include "starboard/time.h"
 #include "starboard/types.h"
 
+#include "testing/gtest/include/gtest/gtest.h"
+
 namespace starboard {
 namespace nplb {
 
@@ -93,6 +97,53 @@
   SbTime delay_after_signal;
 };
 
+// AbstractTestThread that is a bare bones class wrapper around Starboard
+// thread. Subclasses must override Run().
+class AbstractTestThread {
+ public:
+  AbstractTestThread() : thread_(kSbThreadInvalid) {}
+  virtual ~AbstractTestThread() {}
+
+  // Subclasses should override the Run method.
+  virtual void Run() = 0;
+
+  // Calls SbThreadCreate() with default parameters.
+  void Start() {
+    SbThreadEntryPoint entry_point = ThreadEntryPoint;
+
+    thread_ = SbThreadCreate(
+        0,                     // default stack_size.
+        kSbThreadNoPriority,   // default priority.
+        kSbThreadNoAffinity,   // default affinity.
+        true,                  // joinable.
+        "AbstractTestThread",
+        entry_point,
+        this);
+
+    if (kSbThreadInvalid == thread_) {
+      ADD_FAILURE_AT(__FILE__, __LINE__) << "Invalid thread.";
+    }
+    return;
+  }
+
+  void Join() {
+    if (!SbThreadJoin(thread_, NULL)) {
+      ADD_FAILURE_AT(__FILE__, __LINE__) << "Could not join thread.";
+    }
+  }
+
+ private:
+  static void* ThreadEntryPoint(void* ptr) {
+    AbstractTestThread* this_ptr = static_cast<AbstractTestThread*>(ptr);
+    this_ptr->Run();
+    return NULL;
+  }
+
+  SbThread thread_;
+
+  SB_DISALLOW_COPY_AND_ASSIGN(AbstractTestThread);
+};
+
 }  // namespace nplb
 }  // namespace starboard
 
diff --git a/src/starboard/nplb/thread_join_test.cc b/src/starboard/nplb/thread_join_test.cc
index 42a2b6c..8b93e32 100644
--- a/src/starboard/nplb/thread_join_test.cc
+++ b/src/starboard/nplb/thread_join_test.cc
@@ -28,6 +28,45 @@
   EXPECT_EQ(NULL, result);
 }
 
+// Tests the expectation that SbThreadJoin() will block until
+// the thread function has been run.
+TEST(SbThreadLocalValueTest, ThreadJoinWaitsForFunctionRun) {
+  // Thread functionality needs to bind to functions. In C++11 we'd use a
+  // lambda function to tie everything together locally, but this
+  // function-scoped struct with static function emulates this functionality
+  // pretty well.
+  struct LocalStatic {
+    static void* ThreadEntryPoint(void* input) {
+      int* value = static_cast<int*>(input);
+      static const SbTime kSleepTime = 10*kSbTimeMillisecond;  // 10 ms.
+      // Wait to write the value to increase likelyhood of catching
+      // a race condition.
+      SbThreadSleep(kSleepTime);
+      (*value)++;
+      return NULL;
+    }
+  };
+
+  // Try to increase likelyhood of a race condition by running multiple times.
+  for (int i = 0; i < 10; ++i) {
+    int num_times_thread_entry_point_run = 0;
+    SbThread thread = SbThreadCreate(
+        0,                    // Signals automatic thread stack size.
+        kSbThreadNoPriority,  // Signals default priority.
+        kSbThreadNoAffinity,  // Signals default affinity.
+        true,                 // joinable thread.
+        "TestThread",
+        LocalStatic::ThreadEntryPoint,
+        &num_times_thread_entry_point_run);
+
+    ASSERT_NE(kSbThreadInvalid, thread) << "Thread creation not successful";
+    ASSERT_TRUE(SbThreadJoin(thread, NULL));
+
+    ASSERT_EQ(1, num_times_thread_entry_point_run)
+        << "Expected SbThreadJoin() to be blocked until ThreadFunction runs.";
+  }
+}
+
 }  // namespace
 }  // namespace nplb
 }  // namespace starboard
diff --git a/src/starboard/nplb/thread_local_value_test.cc b/src/starboard/nplb/thread_local_value_test.cc
index 43d32c4..4083684 100644
--- a/src/starboard/nplb/thread_local_value_test.cc
+++ b/src/starboard/nplb/thread_local_value_test.cc
@@ -92,6 +92,73 @@
   EXPECT_FALSE(my_value.destroyed);
 }
 
+// Helper function that ensures that the returned key is not recycled.
+SbThreadLocalKey CreateTLSKey_NoRecycle(SbThreadLocalDestructor dtor) {
+  SbThreadLocalKey key = SbThreadCreateLocalKey(NULL);
+  EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
+  // Some Starboard implementations may recycle the original key, so this test
+  // ensures that in that case it will be reset to NULL.
+  SbThreadSetLocalValue(key, reinterpret_cast<void*>(1));
+  SbThreadDestroyLocalKey(key);
+  key = SbThreadCreateLocalKey(DestroyThreadLocalValue);
+  return key;
+}
+
+// Tests the expectation that thread at-exit destructors don't
+// run for ThreadLocal pointers that are set to NULL.
+TEST(SbThreadLocalValueTest, NoDestructorsForNullValue) {
+  static int s_num_destructor_calls = 0;  // Must be initialized to 0.
+  s_num_destructor_calls = 0;             // Allows test to be re-run.
+
+  // Thread functionality needs to bind to functions. In C++11 we'd use a
+  // lambda function to tie everything together locally, but this
+  // function-scoped struct with static members emulates this functionality
+  // pretty well.
+  struct LocalStatic {
+    // Used as a fake destructor for thread-local-storage objects in this
+    // test.
+    static void CountsDestructorCalls(void* /*value*/) {
+      s_num_destructor_calls++;
+    }
+
+    // Sets a thread local non-NULL value, and then sets it back to NULL.
+    static void* ThreadEntryPoint(void* ptr) {
+      SbThreadLocalKey key = *static_cast<SbThreadLocalKey*>(ptr);
+      EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
+      // Set the value and then NULL it out. We expect that because the final
+      // value set was NULL, that the destructor attached to the thread's
+      // at-exit function will not run.
+      SbThreadSetLocalValue(key, reinterpret_cast<void*>(1));
+      SbThreadSetLocalValue(key, NULL);
+      return NULL;
+    }
+  };
+
+  // Setup the thread key and bind the fake test destructor.
+  SbThreadLocalKey key =
+      CreateTLSKey_NoRecycle(LocalStatic::CountsDestructorCalls);
+  EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
+
+  // Spawn the thread.
+  SbThread thread = SbThreadCreate(
+      0,                    // Signals automatic thread stack size.
+      kSbThreadNoPriority,  // Signals default priority.
+      kSbThreadNoAffinity,  // Signals default affinity.
+      true,                 // joinable thread.
+      "TestThread",
+      LocalStatic::ThreadEntryPoint,
+      static_cast<void*>(&key));
+
+  ASSERT_NE(kSbThreadInvalid, thread) << "Thread creation not successful";
+  // 2nd param is return value from ThreadEntryPoint, which is always NULL.
+  ASSERT_TRUE(SbThreadJoin(thread, NULL));
+
+  // No destructors should have run.
+  EXPECT_EQ(0, s_num_destructor_calls);
+
+  SbThreadDestroyLocalKey(key);
+}
+
 TEST(SbThreadLocalValueTest, SunnyDay) {
   DoSunnyDayTest(true);
 }
@@ -101,15 +168,9 @@
 }
 
 TEST(SbThreadLocalValueTest, SunnyDayFreshlyCreatedValuesAreNull) {
-  SbThreadLocalKey key = SbThreadCreateLocalKey(NULL);
+  SbThreadLocalKey key = CreateTLSKey_NoRecycle(NULL);  // NULL dtor.
   EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
 
-  // Some Starboard implementations may recycle the original key, so this test
-  // ensures that in that case it will be reset to NULL.
-  SbThreadSetLocalValue(key, reinterpret_cast<void*>(1));
-  SbThreadDestroyLocalKey(key);
-
-  key = SbThreadCreateLocalKey(NULL);
   EXPECT_EQ(NULL, SbThreadGetLocalValue(key));
   SbThreadDestroyLocalKey(key);
 }
diff --git a/src/starboard/raspi/1/gyp_configuration.gypi b/src/starboard/raspi/1/gyp_configuration.gypi
index 1b41d36..fbccc08 100644
--- a/src/starboard/raspi/1/gyp_configuration.gypi
+++ b/src/starboard/raspi/1/gyp_configuration.gypi
@@ -17,7 +17,6 @@
     'target_arch': 'arm',
     'target_os': 'linux',
 
-    'enable_webdriver': '1',
     'in_app_dial%': 0,
     'sysroot%': '/',
     'gl_type': 'system_gles2',
diff --git a/src/starboard/stub/configuration_public.h b/src/starboard/stub/configuration_public.h
index f243cfa..90b83b7 100644
--- a/src/starboard/stub/configuration_public.h
+++ b/src/starboard/stub/configuration_public.h
@@ -241,6 +241,11 @@
 // The string form of SB_PATH_SEP_CHAR.
 #define SB_PATH_SEP_STRING ":"
 
+// On some platforms the file system stores access times at a coarser
+// granularity than other times. When this quirk is defined, we assume the
+// access time is of 1 day precision.
+#undef SB_HAS_QUIRK_FILESYSTEM_COARSE_ACCESS_TIME
+
 // --- Memory Configuration --------------------------------------------------
 
 // The memory page size, which controls the size of chunks on memory that
diff --git a/src/starboard/stub/gyp_configuration.gypi b/src/starboard/stub/gyp_configuration.gypi
index 24cabf4..c1dc7d2 100644
--- a/src/starboard/stub/gyp_configuration.gypi
+++ b/src/starboard/stub/gyp_configuration.gypi
@@ -16,8 +16,6 @@
     'target_arch': 'x64',
     'target_os': 'linux',
 
-    'enable_webdriver': '1',
-
     # Use a stub rasterizer and graphical setup.
     'rasterizer_type': 'stub',
 
diff --git a/src/starboard/thread.h b/src/starboard/thread.h
index 4396c6c..2ad1006 100644
--- a/src/starboard/thread.h
+++ b/src/starboard/thread.h
@@ -172,8 +172,8 @@
 // Yields the currently executing thread, so another thread has a chance to run.
 SB_EXPORT void SbThreadYield();
 
-// Sleeps the currently executing thread for at least the given |duration|. A
-// negative duration does nothing.
+// Sleeps the currently executing thread for at least the given |duration| in
+// microseconds. A negative duration does nothing.
 SB_EXPORT void SbThreadSleep(SbTime duration);
 
 // Gets the handle of the currently executing thread.
@@ -198,7 +198,8 @@
 //
 // When does |destructor| get called? It can only be called in the owning
 // thread, and let's just say thread interruption isn't viable. The destructor,
-// if specified, is called on every thread's local values when the thread exits.
+// if specified, is called on every thread's local values when the thread exits,
+// if and only if the value in the key is non-NULL.
 SB_EXPORT SbThreadLocalKey
 SbThreadCreateLocalKey(SbThreadLocalDestructor destructor);