diff --git a/src/base/message_pump_io_starboard.cc b/src/base/message_pump_io_starboard.cc
index e08ddb8..bb1b1de 100644
--- a/src/base/message_pump_io_starboard.cc
+++ b/src/base/message_pump_io_starboard.cc
@@ -28,7 +28,8 @@
 namespace base {
 
 MessagePumpIOStarboard::SocketWatcher::SocketWatcher()
-    : socket_(kSbSocketInvalid),
+    : interests_(kSbSocketWaiterInterestNone),
+      socket_(kSbSocketInvalid),
       pump_(NULL),
       watcher_(NULL),
       ALLOW_THIS_IN_INITIALIZER_LIST(weak_factory_(this)) {}
@@ -48,6 +49,7 @@
   }
   pump_ = NULL;
   watcher_ = NULL;
+  interests_ = kSbSocketWaiterInterestNone;
   return result;
 }
 
@@ -147,6 +149,7 @@
   controller->Init(socket, persistent);
   controller->set_watcher(delegate);
   controller->set_pump(this);
+  controller->set_interests(interests);
 
   return true;
 }
diff --git a/src/base/message_pump_io_starboard.h b/src/base/message_pump_io_starboard.h
index c840181..028115f 100644
--- a/src/base/message_pump_io_starboard.h
+++ b/src/base/message_pump_io_starboard.h
@@ -83,6 +83,7 @@
     SbSocket Release();
 
     int interests() const { return interests_; }
+    void set_interests(int interests) { interests_ = interests; }
 
     void set_pump(MessagePumpIOStarboard* pump) { pump_ = pump; }
     MessagePumpIOStarboard* pump() const { return pump_; }
diff --git a/src/cobalt/browser/application.h b/src/cobalt/browser/application.h
index e700d83..776d48b 100644
--- a/src/cobalt/browser/application.h
+++ b/src/cobalt/browser/application.h
@@ -143,7 +143,7 @@
     base::CVal<base::cval::SizeInBytes, base::CValPublic> exe_memory;
 #endif
 
-    base::CVal<int64> app_start_time;
+    base::CVal<int64, base::CValPublic> app_start_time;
     base::CVal<base::TimeDelta, base::CValPublic> app_lifetime;
   };
 
diff --git a/src/cobalt/browser/browser_module.h b/src/cobalt/browser/browser_module.h
index 5712937..8e6b08d 100644
--- a/src/cobalt/browser/browser_module.h
+++ b/src/cobalt/browser/browser_module.h
@@ -312,10 +312,10 @@
 
   // The time when a URL navigation starts. This is recorded after the previous
   // WebModule is destroyed.
-  base::CVal<int64> navigate_time_;
+  base::CVal<int64, base::CValPublic> navigate_time_;
 
   // The time when the WebModule's Window.onload event is fired.
-  base::CVal<int64> on_load_event_time_;
+  base::CVal<int64, base::CValPublic> on_load_event_time_;
 
 #if defined(ENABLE_DEBUG_CONSOLE)
   // Possibly null, but if not, will contain a reference to an instance of
diff --git a/src/cobalt/browser/splash_screen.cc b/src/cobalt/browser/splash_screen.cc
index 0ba834c..6df2dbe 100644
--- a/src/cobalt/browser/splash_screen.cc
+++ b/src/cobalt/browser/splash_screen.cc
@@ -22,7 +22,11 @@
 
 // Static
 const char SplashScreen::Options::kDefaultSplashScreenURL[] =
-    "h5vcc-embedded://splash_screen.html";
+#if defined(COBALT_USE_YOUTUBE_SPLASH_SCREEN)
+  "h5vcc-embedded://youtube_splash_screen.html";
+#else
+  "h5vcc-embedded://black_splash_screen.html";
+#endif  // COBALT_USE_YOUTUBE_SPLASH_SCREEN
 
 SplashScreen::SplashScreen(
     const WebModule::OnRenderTreeProducedCallback&
diff --git a/src/cobalt/browser/web_module.cc b/src/cobalt/browser/web_module.cc
index b575c58..3183d8b 100644
--- a/src/cobalt/browser/web_module.cc
+++ b/src/cobalt/browser/web_module.cc
@@ -226,6 +226,9 @@
     }
   }
 
+  void OnStartDispatchEvent(const scoped_refptr<dom::Event>& event);
+  void OnStopDispatchEvent(const scoped_refptr<dom::Event>& event);
+
   // Thread checker ensures all calls to the WebModule are made from the same
   // thread that it is created in.
   base::ThreadChecker thread_checker_;
@@ -499,6 +502,9 @@
       data.window_close_callback, data.window_minimize_callback,
       data.system_window_, data.options.input_poller,
       media_session_client_->GetMediaSession(),
+      base::Bind(&WebModule::Impl::OnStartDispatchEvent,
+                 base::Unretained(this)),
+      base::Bind(&WebModule::Impl::OnStopDispatchEvent, base::Unretained(this)),
       data.options.csp_insecure_allowed_token, data.dom_max_element_depth);
   DCHECK(window_);
 
@@ -614,17 +620,11 @@
   scoped_refptr<dom::KeyboardEvent> keyboard_event(
       new dom::KeyboardEvent(event));
 
-  web_module_stat_tracker_->OnStartInjectEvent(keyboard_event);
-
   if (element) {
     element->DispatchEvent(keyboard_event);
   } else {
     window_->InjectEvent(keyboard_event);
   }
-
-  web_module_stat_tracker_->OnEndInjectEvent(
-      window_->HasPendingAnimationFrameCallbacks(),
-      layout_manager_->IsRenderTreePending());
 }
 
 void WebModule::Impl::ExecuteJavascript(
@@ -753,6 +753,18 @@
   }
 }
 
+void WebModule::Impl::OnStartDispatchEvent(
+    const scoped_refptr<dom::Event>& event) {
+  web_module_stat_tracker_->OnStartDispatchEvent(event);
+}
+
+void WebModule::Impl::OnStopDispatchEvent(
+    const scoped_refptr<dom::Event>& event) {
+  web_module_stat_tracker_->OnStopDispatchEvent(
+      event, window_->HasPendingAnimationFrameCallbacks(),
+      layout_manager_->IsRenderTreePending());
+}
+
 void WebModule::Impl::SuspendLoaders() {
   TRACE_EVENT0("cobalt::browser", "WebModule::Impl::SuspendLoaders()");
 
diff --git a/src/cobalt/browser/web_module_stat_tracker.cc b/src/cobalt/browser/web_module_stat_tracker.cc
index 4151969..28905c9 100644
--- a/src/cobalt/browser/web_module_stat_tracker.cc
+++ b/src/cobalt/browser/web_module_stat_tracker.cc
@@ -34,6 +34,7 @@
       layout_stat_tracker_(new layout::LayoutStatTracker(name)),
       should_track_event_stats_(should_track_event_stats),
       current_event_type_(kEventTypeInvalid),
+      current_event_dispatched_event_(NULL),
       name_(name),
       event_is_processing_(StringPrintf("Event.%s.IsProcessing", name.c_str()),
                            false, "Nonzero when an event is being processed.") {
@@ -56,7 +57,7 @@
 
 WebModuleStatTracker::~WebModuleStatTracker() { EndCurrentEvent(false); }
 
-void WebModuleStatTracker::OnStartInjectEvent(
+void WebModuleStatTracker::OnStartDispatchEvent(
     const scoped_refptr<dom::Event>& event) {
   if (!should_track_event_stats_) {
     return;
@@ -81,28 +82,30 @@
   if (current_event_type_ != kEventTypeInvalid) {
     event_is_processing_ = true;
     event_start_time_ = base::TimeTicks::Now();
+    current_event_dispatched_event_ = event;
 
     dom_stat_tracker_->OnStartEvent();
     layout_stat_tracker_->OnStartEvent();
 
     stop_watch_durations_[kStopWatchTypeEvent] = base::TimeDelta();
-    stop_watch_durations_[kStopWatchTypeInjectEvent] = base::TimeDelta();
+    stop_watch_durations_[kStopWatchTypeDispatchEvent] = base::TimeDelta();
 
     stop_watches_[kStopWatchTypeEvent].Start();
-    stop_watches_[kStopWatchTypeInjectEvent].Start();
+    stop_watches_[kStopWatchTypeDispatchEvent].Start();
   }
 }
 
-void WebModuleStatTracker::OnEndInjectEvent(
+void WebModuleStatTracker::OnStopDispatchEvent(
+    const scoped_refptr<dom::Event>& event,
     bool are_animation_frame_callbacks_pending,
     bool is_new_render_tree_pending) {
-  // If the injection isn't currently being timed, then this event injection
-  // isn't being tracked. Simply return.
-  if (!stop_watches_[kStopWatchTypeInjectEvent].IsCounting()) {
+  // Verify that this dispatched event is the one currently being tracked.
+  if (event != current_event_dispatched_event_) {
     return;
   }
 
-  stop_watches_[kStopWatchTypeInjectEvent].Stop();
+  current_event_dispatched_event_ = NULL;
+  stop_watches_[kStopWatchTypeDispatchEvent].Stop();
 
   if (!are_animation_frame_callbacks_pending && !is_new_render_tree_pending) {
     EndCurrentEvent(false);
@@ -119,7 +122,9 @@
 void WebModuleStatTracker::OnRenderTreeProduced() { EndCurrentEvent(true); }
 
 WebModuleStatTracker::EventStats::EventStats(const std::string& name)
-    : produced_render_tree_(
+    : start_time(StringPrintf("Event.Time.%s.Start", name.c_str()), 0,
+          "The time that the event started."),
+      produced_render_tree(
           StringPrintf("Event.%s.ProducedRenderTree", name.c_str()), false,
           "Nonzero when the event produced a render tree."),
       count_dom_html_elements_created(
@@ -175,12 +180,12 @@
       duration_total(StringPrintf("Event.Duration.%s", name.c_str()),
                      base::TimeDelta(),
                      "Total duration of the event (in microseconds). This is "
-                     "the time elapsed from the event injection until the "
+                     "the time elapsed from the event dispatch until the "
                      "render tree is produced."),
-      duration_dom_inject_event(
-          StringPrintf("Event.Duration.%s.DOM.InjectEvent", name.c_str()),
+      duration_dom_dispatch_event(
+          StringPrintf("Event.Duration.%s.DOM.DispatchEvent", name.c_str()),
           base::TimeDelta(),
-          "Injection duration, which includes JS, for event (in "
+          "Dispatch duration, which includes JS, for event (in "
           "microseconds). This does not include subsequent DOM and Layout "
           "processing."),
       duration_dom_run_animation_frame_callbacks(
@@ -242,7 +247,8 @@
   stop_watches_[kStopWatchTypeEvent].Stop();
 
   EventStats* event_stats = event_stats_[current_event_type_];
-  event_stats->produced_render_tree_ = was_render_tree_produced;
+  event_stats->start_time = event_start_time_.ToInternalValue();
+  event_stats->produced_render_tree = was_render_tree_produced;
 
   // Update event counts
   event_stats->count_dom_html_elements_created =
@@ -274,8 +280,8 @@
 
   // Update event durations
   event_stats->duration_total = stop_watch_durations_[kStopWatchTypeEvent];
-  event_stats->duration_dom_inject_event =
-      stop_watch_durations_[kStopWatchTypeInjectEvent];
+  event_stats->duration_dom_dispatch_event =
+      stop_watch_durations_[kStopWatchTypeDispatchEvent];
   event_stats->duration_dom_run_animation_frame_callbacks =
       dom_stat_tracker_->GetStopWatchTypeDuration(
           dom::DomStatTracker::kStopWatchTypeRunAnimationFrameCallbacks);
@@ -345,7 +351,7 @@
       << "\"DurTotalUs\":"
       << stop_watch_durations_[kStopWatchTypeEvent].InMicroseconds() << ", "
       << "\"DurDomInjectEventUs\":"
-      << stop_watch_durations_[kStopWatchTypeInjectEvent].InMicroseconds()
+      << stop_watch_durations_[kStopWatchTypeDispatchEvent].InMicroseconds()
       << ", "
       << "\"DurDomRunAnimationFrameCallbacksUs\":"
       << dom_stat_tracker_
diff --git a/src/cobalt/browser/web_module_stat_tracker.h b/src/cobalt/browser/web_module_stat_tracker.h
index 08ae658..5417e06 100644
--- a/src/cobalt/browser/web_module_stat_tracker.h
+++ b/src/cobalt/browser/web_module_stat_tracker.h
@@ -34,7 +34,7 @@
 class WebModuleStatTracker : public base::StopWatchOwner {
  public:
   WebModuleStatTracker(const std::string& name,
-                       bool should_track_injected_events);
+                       bool should_track_dispatched_events);
   ~WebModuleStatTracker();
 
   dom::DomStatTracker* dom_stat_tracker() const {
@@ -45,15 +45,16 @@
     return layout_stat_tracker_.get();
   }
 
-  // |OnStartInjectEvent| starts event stat tracking if
-  // |should_track_injected_events_| is true. Otherwise, it does nothing.
-  void OnStartInjectEvent(const scoped_refptr<dom::Event>& event);
+  // |OnStartDispatchEvent| starts event stat tracking if
+  // |should_track_dispatched_events_| is true. Otherwise, it does nothing.
+  void OnStartDispatchEvent(const scoped_refptr<dom::Event>& event);
 
-  // |OnEndInjectEvent| notifies the event stat tracking that the event has
-  // finished being injected. If no animation frame callbacks and also no render
-  // tree is pending, it also ends tracking of the event.
-  void OnEndInjectEvent(bool are_animation_frame_callbacks_pending,
-                        bool is_new_render_tree_pending);
+  // |OnStopDispatchEvent| notifies the event stat tracking that |event| has
+  // finished being dispatched. If this is the event currently being tracked
+  // and nothing is pending, then it also ends tracking of the event.
+  void OnStopDispatchEvent(const scoped_refptr<dom::Event>& event,
+                           bool are_animation_frame_callbacks_pending,
+                           bool is_new_render_tree_pending);
 
   // |OnRanAnimationFrameCallbacks| ends stat tracking for the current event
   // if no render tree is pending.
@@ -72,14 +73,15 @@
 
   enum StopWatchType {
     kStopWatchTypeEvent,
-    kStopWatchTypeInjectEvent,
+    kStopWatchTypeDispatchEvent,
     kNumStopWatchTypes,
   };
 
   struct EventStats {
     explicit EventStats(const std::string& name);
 
-    base::CVal<bool, base::CValPublic> produced_render_tree_;
+    base::CVal<int64, base::CValPublic> start_time;
+    base::CVal<bool, base::CValPublic> produced_render_tree;
 
     // Count-related
     base::CVal<int, base::CValPublic> count_dom_html_elements_created;
@@ -100,7 +102,7 @@
 
     // Duration-related
     base::CVal<base::TimeDelta, base::CValPublic> duration_total;
-    base::CVal<base::TimeDelta, base::CValPublic> duration_dom_inject_event;
+    base::CVal<base::TimeDelta, base::CValPublic> duration_dom_dispatch_event;
     base::CVal<base::TimeDelta, base::CValPublic>
         duration_dom_run_animation_frame_callbacks;
     base::CVal<base::TimeDelta, base::CValPublic>
@@ -138,6 +140,10 @@
   // Event-related
   const bool should_track_event_stats_;
   EventType current_event_type_;
+  // Raw pointer to the current event. This is used to verify that the event in
+  // |OnStopDispatchEvent| is the dispatched event being tracked.
+  dom::Event* current_event_dispatched_event_;
+
   // Each individual |EventType| has its own entry in the vector.
   ScopedVector<EventStats> event_stats_;
 
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index 2f807b4..c10f57f 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-140119
\ No newline at end of file
+174384
\ No newline at end of file
diff --git a/src/cobalt/build/config/base.gypi b/src/cobalt/build/config/base.gypi
index da47e25..3cdcb28 100644
--- a/src/cobalt/build/config/base.gypi
+++ b/src/cobalt/build/config/base.gypi
@@ -429,6 +429,17 @@
     # re-download video data.  Note that the JavaScript app may experience
     # significant difficulty if this value is too low.
     'cobalt_media_buffer_video_budget_4k%': 60 * 1024 * 1024,
+
+    # Specifies the duration threshold of media source garbage collection.  When
+    # the accumulated duration in a source buffer exceeds this value, the media
+    # source implementation will try to eject existing buffers from the cache.
+    # This is usually triggered when the video being played has a simple content
+    # and the encoded data is small.  In such case this can limit how much is
+    # allocated for the book keeping data of the media buffers and avoid OOM of
+    # system heap.
+    # This should be set to 170 for most of the platforms.  But it can be
+    # further reduced on systems with extremely low memory.
+    'cobalt_media_source_garbage_collection_duration_threshold_in_seconds%': 170,
   },
 
   'target_defaults': {
@@ -451,6 +462,7 @@
       'COBALT_MEDIA_BUFFER_VIDEO_BUDGET_4K=<(cobalt_media_buffer_video_budget_4k)',
       'COBALT_MEDIA_BUFFER_INITIAL_CAPACITY=<(cobalt_media_buffer_initial_capacity)',
       'COBALT_MEDIA_BUFFER_ALLOCATION_UNIT=<(cobalt_media_buffer_allocation_unit)',
+      'COBALT_MEDIA_SOURCE_GARBAGE_COLLECTION_DURATION_THRESHOLD_IN_SECONDS=<(cobalt_media_source_garbage_collection_duration_threshold_in_seconds)',
     ],
     'cflags': [ '<@(compiler_flags)' ],
     'ldflags': [ '<@(linker_flags)' ],
diff --git a/src/cobalt/build/copy_icu_data.gypi b/src/cobalt/build/copy_icu_data.gypi
index c2bfac3..9b9ba27 100644
--- a/src/cobalt/build/copy_icu_data.gypi
+++ b/src/cobalt/build/copy_icu_data.gypi
@@ -39,15 +39,21 @@
         'little_endian%': '<(little_endian)',
         'use_icu_dat_file%': '<(use_icu_dat_file)',
       },
+      'little_endian%': '<(little_endian)',
     },
 
-    #'inputs_icu%': [ '<(inputs_icu)' ],
-    'inputs_icu%': [ '<(static_contents_source_dir)/icu/' ],
+    'conditions': [
+      ['little_endian==1', {
+        'inputs_icu%': [ '<(static_contents_source_dir)/icu/icudt56l' ],
+      }, {
+        'inputs_icu%': [ '<(static_contents_source_dir)/icu/icudt56b' ],
+      }],
+    ],
   },
 
   'copies': [
     {
-      'destination': '<(static_contents_output_data_dir)/',
+      'destination': '<(static_contents_output_data_dir)/icu/',
       'files': [ '<(inputs_icu)' ],
     },
   ],
diff --git a/src/cobalt/cssom/css_declared_style_data.h b/src/cobalt/cssom/css_declared_style_data.h
index 0ac19c7..3263fa2 100644
--- a/src/cobalt/cssom/css_declared_style_data.h
+++ b/src/cobalt/cssom/css_declared_style_data.h
@@ -17,10 +17,11 @@
 
 #include <bitset>
 #include <functional>
+#include <map>
 #include <string>
 
 #include "base/compiler_specific.h"
-#include "base/hash_tables.h"
+#include "base/containers/small_map.h"
 #include "base/memory/ref_counted.h"
 #include "cobalt/base/unused.h"
 #include "cobalt/cssom/css_declaration_data.h"
@@ -36,7 +37,10 @@
  public:
   CSSDeclaredStyleData();
 
-  typedef base::hash_map<PropertyKey, scoped_refptr<PropertyValue> >
+  // NOTE: The array size of base::SmallMap is based on extensive testing. Do
+  // not change it unless additional profiling data justifies it.
+  typedef base::SmallMap<std::map<PropertyKey, scoped_refptr<PropertyValue> >,
+                         8, std::equal_to<PropertyKey> >
       PropertyValues;
 
   // The length attribute must return the number of CSS declarations in the
diff --git a/src/cobalt/debug/debug_web_server.cc b/src/cobalt/debug/debug_web_server.cc
index 6ffd152..84e3885 100644
--- a/src/cobalt/debug/debug_web_server.cc
+++ b/src/cobalt/debug/debug_web_server.cc
@@ -188,6 +188,11 @@
 
   // Construct the local disk path corresponding to the request path.
   FilePath file_path(content_root_dir_);
+  if (!IsStringASCII(url_path)) {
+    LOG(WARNING) << "Got HTTP request with non-ASCII URL path.";
+    server_->Send404(connection_id);
+    return;
+  }
   file_path = file_path.AppendASCII(url_path);
 
   // If the disk path is a directory, look for an index file.
diff --git a/src/cobalt/dom/dom_stat_tracker.h b/src/cobalt/dom/dom_stat_tracker.h
index 35cedb7..e967385 100644
--- a/src/cobalt/dom/dom_stat_tracker.h
+++ b/src/cobalt/dom/dom_stat_tracker.h
@@ -104,11 +104,11 @@
 
   // Tracking of videos produced by an event.
   base::StopWatch event_video_start_delay_stop_watch_;
-  base::CVal<base::TimeDelta> event_video_start_delay_;
+  base::CVal<base::TimeDelta, base::CValPublic> event_video_start_delay_;
 
   // Count of HtmlScriptElement::Execute() calls and time of last call.
-  base::CVal<int> script_element_execute_count_;
-  base::CVal<int64> script_element_execute_time_;
+  base::CVal<int, base::CValPublic> script_element_execute_count_;
+  base::CVal<int64, base::CValPublic> script_element_execute_time_;
 
   // Periodic counts. The counts are cleared after the CVals are updated in
   // |FlushPeriodicTracking|.
diff --git a/src/cobalt/dom/html_link_element.cc b/src/cobalt/dom/html_link_element.cc
index ade761c..52285ae 100644
--- a/src/cobalt/dom/html_link_element.cc
+++ b/src/cobalt/dom/html_link_element.cc
@@ -106,25 +106,19 @@
   document->IncreaseLoadingCounter();
 }
 
-void HTMLLinkElement::OnLoadingDone(const std::string& content) {
-  TRACK_MEMORY_SCOPE("DOM");
+void HTMLLinkElement::OnLoadingDone(scoped_ptr<std::string> content) {
   DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(content);
+  TRACK_MEMORY_SCOPE("DOM");
   TRACE_EVENT0("cobalt::dom", "HTMLLinkElement::OnLoadingDone()");
 
   Document* document = node_document();
   scoped_refptr<cssom::CSSStyleSheet> style_sheet =
       document->html_element_context()->css_parser()->ParseStyleSheet(
-          content, base::SourceLocation(href(), 1, 1));
+          *content, base::SourceLocation(href(), 1, 1));
   style_sheet->SetLocationUrl(absolute_url_);
   document->style_sheets()->Append(style_sheet);
 
-  // Once the attempts to obtain the resource and its critical subresources are
-  // complete, the user agent must, if the loads were successful, queue a task
-  // to fire a simple event named load at the link element, or, if the resource
-  // or one of its critical subresources failed to completely load for any
-  // reason (e.g. DNS error, HTTP 404 response, a connection being prematurely
-  // closed, unsupported Content-Type), queue a task to fire a simple event
-  // named error at the link element.
   PostToDispatchEvent(FROM_HERE, base::Tokens::load());
 
   // The element must delay the load event of the element's document until all
diff --git a/src/cobalt/dom/html_link_element.h b/src/cobalt/dom/html_link_element.h
index 6f2e021..18860a8 100644
--- a/src/cobalt/dom/html_link_element.h
+++ b/src/cobalt/dom/html_link_element.h
@@ -66,7 +66,7 @@
   // From the spec: HTMLLinkElement.
   void Obtain();
 
-  void OnLoadingDone(const std::string& content);
+  void OnLoadingDone(scoped_ptr<std::string> content);
   void OnLoadingError(const std::string& error);
   void ReleaseLoader();
 
diff --git a/src/cobalt/dom/html_media_element.cc b/src/cobalt/dom/html_media_element.cc
index 0dbebf1..70a3f3f 100644
--- a/src/cobalt/dom/html_media_element.cc
+++ b/src/cobalt/dom/html_media_element.cc
@@ -1573,10 +1573,15 @@
 
   ScheduleOwnEvent(base::Tokens::durationchange());
 
-  float now = current_time(NULL);
-  float dur = duration();
-  if (now > dur) {
-    Seek(dur);
+  double now = current_time(NULL);
+  // Reset and update |duration_|.
+  duration_ = std::numeric_limits<double>::quiet_NaN();
+  if (player_ && ready_state_ >= WebMediaPlayer::kReadyStateHaveMetadata) {
+    duration_ = player_->GetDuration();
+  }
+
+  if (now > duration_) {
+    Seek(static_cast<float>(duration_));
   }
 
   EndProcessingMediaPlayerCallback();
diff --git a/src/cobalt/dom/html_script_element.cc b/src/cobalt/dom/html_script_element.cc
index 9af2bcc..6976ad3 100644
--- a/src/cobalt/dom/html_script_element.cc
+++ b/src/cobalt/dom/html_script_element.cc
@@ -15,6 +15,7 @@
 #include "cobalt/dom/html_script_element.h"
 
 #include <deque>
+#include <utility>
 
 #include "base/bind.h"
 #include "base/compiler_specific.h"
@@ -265,6 +266,8 @@
         PreventGarbageCollection();
         ExecuteExternal();
         AllowGarbageCollection();
+        // Release the content string now that we're finished with it.
+        content_.reset();
       } else {
         // Executing the script block must just consist of firing a simple event
         // named error at the element.
@@ -346,9 +349,9 @@
   }
 }
 
-void HTMLScriptElement::OnSyncLoadingDone(const std::string& content) {
+void HTMLScriptElement::OnSyncLoadingDone(scoped_ptr<std::string> content) {
   TRACE_EVENT0("cobalt::dom", "HTMLScriptElement::OnSyncLoadingDone()");
-  content_ = content;
+  content_ = content.Pass();
   is_sync_load_successful_ = true;
 }
 
@@ -359,16 +362,18 @@
 
 // Algorithm for OnLoadingDone:
 //   https://www.w3.org/TR/html5/scripting-1.html#prepare-a-script
-void HTMLScriptElement::OnLoadingDone(const std::string& content) {
+void HTMLScriptElement::OnLoadingDone(scoped_ptr<std::string> content) {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(load_option_ == 4 || load_option_ == 5);
+  DCHECK(content);
   TRACE_EVENT0("cobalt::dom", "HTMLScriptElement::OnLoadingDone()");
   if (!document_) {
     AllowGarbageCollection();
     return;
   }
 
-  content_ = content;
+  content_ = content.Pass();
+
   switch (load_option_) {
     case 4: {
       // If the element has a src attribute, does not have an async attribute,
@@ -445,6 +450,13 @@
       document_->DecreaseLoadingCounterAndMaybeDispatchLoadEvent();
     } break;
   }
+
+  // Release the content string now that we're finished with it.
+  content_.reset();
+
+  // Post a task to release the loader.
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&HTMLScriptElement::ReleaseLoader, this));
 }
 
 // Algorithm for OnLoadingError:
@@ -489,6 +501,19 @@
   // document until the task that is queued by the networking task source
   // once the resource has been fetched (defined above) has been run.
   document_->DecreaseLoadingCounterAndMaybeDispatchLoadEvent();
+
+  // Post a task to release the loader.
+  MessageLoop::current()->PostTask(
+      FROM_HERE, base::Bind(&HTMLScriptElement::ReleaseLoader, this));
+}
+
+void HTMLScriptElement::ExecuteExternal() {
+  DCHECK(content_);
+  Execute(*content_, base::SourceLocation(url_.spec(), 1, 1), true);
+}
+
+void HTMLScriptElement::ExecuteInternal() {
+  Execute(text_content().value(), inline_script_location_, false);
 }
 
 // Algorithm for Execute:
@@ -584,5 +609,11 @@
   }
 }
 
+void HTMLScriptElement::ReleaseLoader() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DCHECK(loader_);
+  loader_.reset();
+}
+
 }  // namespace dom
 }  // namespace cobalt
diff --git a/src/cobalt/dom/html_script_element.h b/src/cobalt/dom/html_script_element.h
index 8307158..d121d34 100644
--- a/src/cobalt/dom/html_script_element.h
+++ b/src/cobalt/dom/html_script_element.h
@@ -89,18 +89,14 @@
   //
   void Prepare();
 
-  void OnSyncLoadingDone(const std::string& content);
+  void OnSyncLoadingDone(scoped_ptr<std::string> content);
   void OnSyncLoadingError(const std::string& error);
 
-  void OnLoadingDone(const std::string& content);
+  void OnLoadingDone(scoped_ptr<std::string> content);
   void OnLoadingError(const std::string& error);
 
-  void ExecuteExternal() {
-    Execute(content_, base::SourceLocation(url_.spec(), 1, 1), true);
-  }
-  void ExecuteInternal() {
-    Execute(text_content().value(), inline_script_location_, false);
-  }
+  void ExecuteExternal();
+  void ExecuteInternal();
   void Execute(const std::string& content,
                const base::SourceLocation& script_location, bool is_external);
 
@@ -108,6 +104,7 @@
       const tracked_objects::Location& location, const base::Token& token);
   void PreventGarbageCollection();
   void AllowGarbageCollection();
+  void ReleaseLoader();
 
   // Whether the script has been started.
   bool is_already_started_;
@@ -131,8 +128,8 @@
   bool is_sync_load_successful_;
   // Resolved URL of the script.
   GURL url_;
-  // Content of the script.
-  std::string content_;
+  // Content of the script. Released after Execute is called.
+  scoped_ptr<std::string> content_;
   // Active requests disabling garbage collection.
   int prevent_garbage_collection_count_;
 
diff --git a/src/cobalt/dom/node.cc b/src/cobalt/dom/node.cc
index 6b15337..dc553cd 100644
--- a/src/cobalt/dom/node.cc
+++ b/src/cobalt/dom/node.cc
@@ -36,6 +36,7 @@
 #include "cobalt/dom/node_list_live.h"
 #include "cobalt/dom/rule_matching.h"
 #include "cobalt/dom/text.h"
+#include "cobalt/dom/window.h"
 #if defined(OS_STARBOARD)
 #include "starboard/configuration.h"
 #if SB_HAS(CORE_DUMP_HANDLER_SUPPORT)
@@ -102,6 +103,16 @@
   // The event is now being dispatched. Track it in the global stats.
   GlobalStats::GetInstance()->StartJavaScriptEvent();
 
+  scoped_refptr<Window> window;
+  if (IsInDocument()) {
+    DCHECK(node_document());
+    window = node_document()->default_view();
+  }
+
+  if (window) {
+    window->OnStartDispatchEvent(event);
+  }
+
   typedef std::vector<scoped_refptr<Node> > Ancestors;
   Ancestors ancestors;
   for (scoped_refptr<Node> current = this->parent_node(); current != NULL;
@@ -137,6 +148,10 @@
 
   event->set_event_phase(Event::kNone);
 
+  if (window) {
+    window->OnStopDispatchEvent(event);
+  }
+
   // The event has completed being dispatched. Stop tracking it in the global
   // stats.
   GlobalStats::GetInstance()->StopJavaScriptEvent();
diff --git a/src/cobalt/dom/testing/stub_window.h b/src/cobalt/dom/testing/stub_window.h
index ffe7834..418c7a0 100644
--- a/src/cobalt/dom/testing/stub_window.h
+++ b/src/cobalt/dom/testing/stub_window.h
@@ -63,8 +63,9 @@
         base::Closure() /* csp_policy_changed */,
         base::Closure() /* ran_animation_frame_callbacks */,
         base::Closure() /* window_close */,
-        base::Closure() /* window_minimize */,
-        NULL, NULL, NULL);
+        base::Closure() /* window_minimize */, NULL, NULL, NULL,
+        dom::Window::OnStartDispatchEventCallback(),
+        dom::Window::OnStopDispatchEventCallback());
     global_environment_->CreateGlobalObject(window_, &environment_settings_);
   }
 
diff --git a/src/cobalt/dom/window.cc b/src/cobalt/dom/window.cc
index 89dd4ff..e11ae87 100644
--- a/src/cobalt/dom/window.cc
+++ b/src/cobalt/dom/window.cc
@@ -74,38 +74,41 @@
 const int64_t kPerformanceTimerMinResolutionInMicroseconds = 20;
 }  // namespace
 
-Window::Window(int width, int height, cssom::CSSParser* css_parser,
-               Parser* dom_parser, loader::FetcherFactory* fetcher_factory,
-               render_tree::ResourceProvider** resource_provider,
-               loader::image::AnimatedImageTracker* animated_image_tracker,
-               loader::image::ImageCache* image_cache,
-               loader::image::ReducedCacheCapacityManager*
-                   reduced_image_cache_capacity_manager,
-               loader::font::RemoteTypefaceCache* remote_typeface_cache,
-               loader::mesh::MeshCache* mesh_cache,
-               LocalStorageDatabase* local_storage_database,
-               media::CanPlayTypeHandler* can_play_type_handler,
-               media::WebMediaPlayerFactory* web_media_player_factory,
-               script::ExecutionState* execution_state,
-               script::ScriptRunner* script_runner,
-               script::ScriptValueFactory* script_value_factory,
-               MediaSource::Registry* media_source_registry,
-               DomStatTracker* dom_stat_tracker, const GURL& url,
-               const std::string& user_agent, const std::string& language,
-               const base::Callback<void(const GURL&)> navigation_callback,
-               const base::Callback<void(const std::string&)>& error_callback,
-               network_bridge::CookieJar* cookie_jar,
-               const network_bridge::PostSender& post_sender,
-               const std::string& default_security_policy,
-               CspEnforcementType csp_enforcement_mode,
-               const base::Closure& csp_policy_changed_callback,
-               const base::Closure& ran_animation_frame_callbacks_callback,
-               const base::Closure& window_close_callback,
-               const base::Closure& window_minimize_callback,
-               system_window::SystemWindow* system_window,
-               const scoped_refptr<input::InputPoller>& input_poller,
-               const scoped_refptr<MediaSession>& media_session,
-               int csp_insecure_allowed_token, int dom_max_element_depth)
+Window::Window(
+    int width, int height, cssom::CSSParser* css_parser, Parser* dom_parser,
+    loader::FetcherFactory* fetcher_factory,
+    render_tree::ResourceProvider** resource_provider,
+    loader::image::AnimatedImageTracker* animated_image_tracker,
+    loader::image::ImageCache* image_cache,
+    loader::image::ReducedCacheCapacityManager*
+        reduced_image_cache_capacity_manager,
+    loader::font::RemoteTypefaceCache* remote_typeface_cache,
+    loader::mesh::MeshCache* mesh_cache,
+    LocalStorageDatabase* local_storage_database,
+    media::CanPlayTypeHandler* can_play_type_handler,
+    media::WebMediaPlayerFactory* web_media_player_factory,
+    script::ExecutionState* execution_state,
+    script::ScriptRunner* script_runner,
+    script::ScriptValueFactory* script_value_factory,
+    MediaSource::Registry* media_source_registry,
+    DomStatTracker* dom_stat_tracker, const GURL& url,
+    const std::string& user_agent, const std::string& language,
+    const base::Callback<void(const GURL&)> navigation_callback,
+    const base::Callback<void(const std::string&)>& error_callback,
+    network_bridge::CookieJar* cookie_jar,
+    const network_bridge::PostSender& post_sender,
+    const std::string& default_security_policy,
+    CspEnforcementType csp_enforcement_mode,
+    const base::Closure& csp_policy_changed_callback,
+    const base::Closure& ran_animation_frame_callbacks_callback,
+    const base::Closure& window_close_callback,
+    const base::Closure& window_minimize_callback,
+    system_window::SystemWindow* system_window,
+    const scoped_refptr<input::InputPoller>& input_poller,
+    const scoped_refptr<MediaSession>& media_session,
+    const OnStartDispatchEventCallback& on_start_dispatch_event_callback,
+    const OnStopDispatchEventCallback& on_stop_dispatch_event_callback,
+    int csp_insecure_allowed_token, int dom_max_element_depth)
     : width_(width),
       height_(height),
       html_element_context_(new HTMLElementContext(
@@ -116,8 +119,8 @@
           remote_typeface_cache, mesh_cache, dom_stat_tracker, language)),
       performance_(new Performance(new base::MinimumResolutionClock(
           new base::SystemMonotonicClock(),
-              base::TimeDelta::FromMicroseconds(
-                  kPerformanceTimerMinResolutionInMicroseconds)))),
+          base::TimeDelta::FromMicroseconds(
+              kPerformanceTimerMinResolutionInMicroseconds)))),
       ALLOW_THIS_IN_INITIALIZER_LIST(document_(new Document(
           html_element_context_.get(),
           Document::Options(
@@ -151,7 +154,9 @@
           ran_animation_frame_callbacks_callback),
       window_close_callback_(window_close_callback),
       window_minimize_callback_(window_minimize_callback),
-      system_window_(system_window) {
+      system_window_(system_window),
+      on_start_dispatch_event_callback_(on_start_dispatch_event_callback),
+      on_stop_dispatch_event_callback_(on_stop_dispatch_event_callback) {
 #if defined(ENABLE_TEST_RUNNER)
   test_runner_ = new TestRunner();
 #endif  // ENABLE_TEST_RUNNER
@@ -431,6 +436,18 @@
   document_->set_synchronous_layout_callback(synchronous_layout_callback);
 }
 
+void Window::OnStartDispatchEvent(const scoped_refptr<dom::Event>& event) {
+  if (!on_start_dispatch_event_callback_.is_null()) {
+    on_start_dispatch_event_callback_.Run(event);
+  }
+}
+
+void Window::OnStopDispatchEvent(const scoped_refptr<dom::Event>& event) {
+  if (!on_stop_dispatch_event_callback_.is_null()) {
+    on_stop_dispatch_event_callback_.Run(event);
+  }
+}
+
 void Window::TraceMembers(script::Tracer* tracer) {
   tracer->Trace(performance_);
   tracer->Trace(document_);
diff --git a/src/cobalt/dom/window.h b/src/cobalt/dom/window.h
index 4752a01..f43bfc3 100644
--- a/src/cobalt/dom/window.h
+++ b/src/cobalt/dom/window.h
@@ -99,6 +99,10 @@
       const base::SourceLocation&, const base::Closure&,
       const base::Callback<void(const std::string&)>&)>
       HTMLDecoderCreatorCallback;
+  typedef base::Callback<void(const scoped_refptr<dom::Event>& event)>
+      OnStartDispatchEventCallback;
+  typedef base::Callback<void(const scoped_refptr<dom::Event>& event)>
+      OnStopDispatchEventCallback;
   typedef UrlRegistry<MediaSource> MediaSourceRegistry;
 
   Window(
@@ -133,6 +137,9 @@
       system_window::SystemWindow* system_window,
       const scoped_refptr<input::InputPoller>& input_poller,
       const scoped_refptr<cobalt::media_session::MediaSession>& media_session,
+      const OnStartDispatchEventCallback&
+          start_tracking_dispatch_event_callback,
+      const OnStopDispatchEventCallback& stop_tracking_dispatch_event_callback,
       int csp_insecure_allowed_token = 0, int dom_max_element_depth = 0);
 
   // Web API: Window
@@ -280,6 +287,9 @@
 
   void TraceMembers(script::Tracer* tracer) OVERRIDE;
 
+  void OnStartDispatchEvent(const scoped_refptr<dom::Event>& event);
+  void OnStopDispatchEvent(const scoped_refptr<dom::Event>& event);
+
   DEFINE_WRAPPABLE_TYPE(Window);
 
  private:
@@ -331,6 +341,9 @@
   scoped_refptr<TestRunner> test_runner_;
 #endif  // ENABLE_TEST_RUNNER
 
+  OnStartDispatchEventCallback on_start_dispatch_event_callback_;
+  OnStopDispatchEventCallback on_stop_dispatch_event_callback_;
+
   DISALLOW_COPY_AND_ASSIGN(Window);
 };
 
diff --git a/src/cobalt/dom/window_test.cc b/src/cobalt/dom/window_test.cc
index f087c28..3487ac4 100644
--- a/src/cobalt/dom/window_test.cc
+++ b/src/cobalt/dom/window_test.cc
@@ -64,7 +64,9 @@
             base::Closure() /* ran_animation_frame_callbacks */,
             base::Closure() /* window_close */,
             base::Closure() /* window_minimize */,
-            stub_media_module_->system_window(), NULL, NULL)) {}
+            stub_media_module_->system_window(), NULL, NULL,
+            dom::Window::OnStartDispatchEventCallback(),
+            dom::Window::OnStopDispatchEventCallback())) {}
 
   ~WindowTest() OVERRIDE {}
 
diff --git a/src/cobalt/layout_tests/testdata/web-platform-tests/content-security-policy/web_platform_tests.txt b/src/cobalt/layout_tests/testdata/web-platform-tests/content-security-policy/web_platform_tests.txt
index 48b16c9..47bb2bd 100644
--- a/src/cobalt/layout_tests/testdata/web-platform-tests/content-security-policy/web_platform_tests.txt
+++ b/src/cobalt/layout_tests/testdata/web-platform-tests/content-security-policy/web_platform_tests.txt
@@ -165,7 +165,7 @@
 blink-contrib/policy-does-not-affect-child.sub.html,DISABLE
 
 blink-contrib/report-blocked-data-uri.sub.html,PASS
-blink-contrib/report-cross-origin-no-cookies.sub.html,PASS
+blink-contrib/report-cross-origin-no-cookies.sub.html,DISABLE
 
 blink-contrib/report-disallowed-from-meta.sub.html,PASS
 blink-contrib/report-same-origin-with-cookies.sub.html,PASS
diff --git a/src/cobalt/loader/embedded_resources/splash_screen.html b/src/cobalt/loader/embedded_resources/black_splash_screen.html
similarity index 100%
rename from src/cobalt/loader/embedded_resources/splash_screen.html
rename to src/cobalt/loader/embedded_resources/black_splash_screen.html
diff --git a/src/cobalt/loader/embedded_resources/splash_screen.css b/src/cobalt/loader/embedded_resources/splash_screen.css
deleted file mode 100644
index 9fbe2a3..0000000
--- a/src/cobalt/loader/embedded_resources/splash_screen.css
+++ /dev/null
@@ -1,142 +0,0 @@
-body {
-  overflow: hidden;
-  font-size: 1.4815vh;  /* Corresponds to 16px at 1080p. */
-}
-
-#splash {
-  background-color: #e62117;
-  background-image: url("h5vcc-embedded://you_tube_logo.png");
-  background-position: center center;
-  background-repeat: no-repeat;
-  background-size: 50%;
-  height: 100%;
-  left: 0;
-  position: absolute;
-  top: 0;
-  width: 100%;
-}
-
-#loading {
-  position: absolute;
-  top: 52em;
-  width: 100%;
-}
-
-#spinner {
-  /* The spinner starts with display set to none, and JavaScript will set this
-     to 'block' after some time has passed, if the splash screen is still
-     visible. */
-  display: none;
-
-  height: 5.33em;
-  margin: 0 auto;
-  position: relative;
-  width: 5.33em;
-}
-
-.dot {
-  background-color: #cbcbcb;
-  border-radius: 50%;
-  height: 1.17em;
-  position: absolute;
-  width: 1.17em;
-}
-
-@keyframes fade1 {
-  0%,100% {opacity: 0}
-  50% {opacity: 1}
-}
-
-@keyframes fade2 {
-  0%,100% {opacity: .25}
-  37.5% {opacity: 1}
-  87.5% {opacity: 0}
-}
-
-@keyframes fade3 {
-  0%,100% {opacity: .5}
-  25% {opacity: 1}
-  75% {opacity: 0}
-}
-
-@keyframes fade4 {
-  0%,100% {opacity: .75}
-  12.5% {opacity: 1}
-  62.5% {opacity: 0}
-}
-
-@keyframes fade5 {
-  0%,100% {opacity: 1}
-  50% {opacity: 0}
-}
-
-@keyframes fade6 {
-  0%,100% {opacity: .75}
-  37.5% {opacity: 0}
-  87.5% {opacity: 1}
-}
-
-@keyframes fade7 {
-  0%,100% {opacity: .5}
-  25% {opacity: 0}
-  75% {opacity: 1}
-}
-
-@keyframes fade8 {
-  0%,100% {opacity: .25}
-  12.5% {opacity: 0}
-  62.5% {opacity: 1}
-}
-
-#dot1 {
-  animation: fade8 .72s infinite ease;
-  left: 0;
-  top: 2.09em;
-}
-
-#dot2 {
-  animation: fade7 .72s infinite ease;
-  left: .61em;
-  top: .61em;
-}
-
-#dot3 {
-  animation: fade6 .72s infinite ease;
-  left: 2.09em;
-  top: 0;
-}
-
-#dot4 {
-  animation: fade5 .72s infinite ease;
-  right: .61em;
-  top: .61em;
-}
-
-#dot5 {
-  animation: fade4 .72s infinite ease;
-  right: 0;
-  top: 2.09em;
-}
-
-#dot6 {
-  animation: fade3 .72s infinite ease;
-  bottom: .61em;
-  right: .61em;
-}
-
-#dot7 {
-  animation: fade2 .72s infinite ease;
-  bottom: 0;
-  left: 2.09em;
-}
-
-#dot8 {
-  animation: fade1 .72s infinite ease;
-  bottom: .61em;
-  left: .61em;
-}
-
-.hidden {
-  height: 0;
-  visibility: hidden;
-}
diff --git a/src/cobalt/loader/embedded_resources/splash_screen.js b/src/cobalt/loader/embedded_resources/splash_screen.js
deleted file mode 100644
index 0d30edc..0000000
--- a/src/cobalt/loader/embedded_resources/splash_screen.js
+++ /dev/null
@@ -1,5 +0,0 @@
-  // Enable the spinner after 3 seconds have passed.
-  window.setTimeout(function() {
-    var spinner = document.getElementById('spinner');
-    spinner.style.display = 'block';
-  }, 3000);
diff --git a/src/cobalt/loader/embedded_resources/you_tube_logo.png b/src/cobalt/loader/embedded_resources/you_tube_logo.png
deleted file mode 100644
index 14563d0..0000000
--- a/src/cobalt/loader/embedded_resources/you_tube_logo.png
+++ /dev/null
Binary files differ
diff --git a/src/cobalt/loader/loader.gyp b/src/cobalt/loader/loader.gyp
index 0c9edff..aeebef5 100644
--- a/src/cobalt/loader/loader.gyp
+++ b/src/cobalt/loader/loader.gyp
@@ -175,11 +175,17 @@
         'input_directory': 'embedded_resources',
       },
       'sources': [
+        '<(input_directory)/black_splash_screen.html',
         '<(input_directory)/equirectangular_40_40.msh',
-        '<(input_directory)/splash_screen.css',
-        '<(input_directory)/splash_screen.html',
-        '<(input_directory)/splash_screen.js',
-        '<(input_directory)/you_tube_logo.png',
+      ],
+      'conditions': [
+        ['target_arch == "ps3"', {
+          'sources': [
+            '<(input_directory)/youtube_splash_screen.css',
+            '<(input_directory)/youtube_splash_screen.html',
+            '<(input_directory)/youtube_splash_screen.png',
+          ],
+        }],
       ],
       'actions': [
         {
diff --git a/src/cobalt/loader/loader_test.cc b/src/cobalt/loader/loader_test.cc
index 1e7872a..570d839 100644
--- a/src/cobalt/loader/loader_test.cc
+++ b/src/cobalt/loader/loader_test.cc
@@ -16,6 +16,7 @@
 
 #include "base/bind.h"
 #include "base/file_util.h"
+#include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
 #include "base/run_loop.h"
@@ -40,8 +41,8 @@
  public:
   explicit TextDecoderCallback(base::RunLoop* run_loop) : run_loop_(run_loop) {}
 
-  void OnDone(const std::string& text) {
-    text_ = text;
+  void OnDone(scoped_ptr<std::string> text) {
+    text_ = *text;
     MessageLoop::current()->PostTask(FROM_HERE, run_loop_->QuitClosure());
   }
 
diff --git a/src/cobalt/loader/resource_cache.h b/src/cobalt/loader/resource_cache.h
index 024cc55..5573eac 100644
--- a/src/cobalt/loader/resource_cache.h
+++ b/src/cobalt/loader/resource_cache.h
@@ -513,12 +513,13 @@
   base::CVal<base::cval::SizeInBytes, base::CValPublic> memory_size_in_bytes_;
   base::CVal<base::cval::SizeInBytes, base::CValPublic>
       memory_capacity_in_bytes_;
-  base::CVal<base::cval::SizeInBytes> memory_resources_loaded_in_bytes_;
+  base::CVal<base::cval::SizeInBytes, base::CValPublic>
+      memory_resources_loaded_in_bytes_;
 
-  base::CVal<int> count_resources_requested_;
-  base::CVal<int> count_resources_loading_;
-  base::CVal<int> count_resources_loaded_;
-  base::CVal<int> count_pending_callbacks_;
+  base::CVal<int, base::CValPublic> count_resources_requested_;
+  base::CVal<int, base::CValPublic> count_resources_loading_;
+  base::CVal<int, base::CValPublic> count_resources_loaded_;
+  base::CVal<int, base::CValPublic> count_pending_callbacks_;
 
   DISALLOW_COPY_AND_ASSIGN(ResourceCache);
 };
diff --git a/src/cobalt/loader/text_decoder.h b/src/cobalt/loader/text_decoder.h
index 11b78d4..2c1761c 100644
--- a/src/cobalt/loader/text_decoder.h
+++ b/src/cobalt/loader/text_decoder.h
@@ -17,6 +17,7 @@
 
 #include <algorithm>
 #include <string>
+#include <utility>
 
 #include "base/callback.h"
 #include "base/compiler_specific.h"
@@ -32,13 +33,14 @@
 // results.
 class TextDecoder : public Decoder {
  public:
-  explicit TextDecoder(base::Callback<void(const std::string&)> done_callback)
+  explicit TextDecoder(
+      base::Callback<void(scoped_ptr<std::string>)> done_callback)
       : done_callback_(done_callback), suspended_(false) {}
   ~TextDecoder() OVERRIDE {}
 
   // This function is used for binding callback for creating TextDecoder.
   static scoped_ptr<Decoder> Create(
-      base::Callback<void(const std::string&)> done_callback) {
+      base::Callback<void(scoped_ptr<std::string>)> done_callback) {
     return scoped_ptr<Decoder>(new TextDecoder(done_callback));
   }
 
@@ -48,7 +50,10 @@
     if (suspended_) {
       return;
     }
-    text_.append(data, size);
+    if (!text_) {
+      text_.reset(new std::string);
+    }
+    text_->append(data, size);
   }
 
   void DecodeChunkPassed(scoped_ptr<std::string> data) OVERRIDE {
@@ -58,10 +63,10 @@
       return;
     }
 
-    if (text_.empty()) {
-      std::swap(*data, text_);
+    if (!text_) {
+      text_ = data.Pass();
     } else {
-      text_.append(*data);
+      text_->append(*data);
     }
   }
 
@@ -70,11 +75,14 @@
     if (suspended_) {
       return;
     }
-    done_callback_.Run(text_);
+    if (!text_) {
+      text_.reset(new std::string);
+    }
+    done_callback_.Run(text_.Pass());
   }
   bool Suspend() OVERRIDE {
     suspended_ = true;
-    text_.clear();
+    text_.reset();
     return true;
   }
   void Resume(render_tree::ResourceProvider* /*resource_provider*/) OVERRIDE {
@@ -83,8 +91,8 @@
 
  private:
   base::ThreadChecker thread_checker_;
-  std::string text_;
-  base::Callback<void(const std::string&)> done_callback_;
+  base::Callback<void(scoped_ptr<std::string>)> done_callback_;
+  scoped_ptr<std::string> text_;
   bool suspended_;
 };
 
diff --git a/src/cobalt/loader/text_decoder_test.cc b/src/cobalt/loader/text_decoder_test.cc
index 7c62696..29402dd 100644
--- a/src/cobalt/loader/text_decoder_test.cc
+++ b/src/cobalt/loader/text_decoder_test.cc
@@ -15,6 +15,7 @@
 #include "cobalt/loader/text_decoder.h"
 
 #include "base/bind.h"
+#include "base/memory/scoped_ptr.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -23,7 +24,7 @@
 namespace {
 
 struct TextDecoderCallback {
-  void Callback(const std::string& value) { text = value; }
+  void Callback(scoped_ptr<std::string> value) { text = *value; }
   std::string text;
 };
 
diff --git a/src/cobalt/media/base/decoder_buffer.cc b/src/cobalt/media/base/decoder_buffer.cc
index b01b364..93c85d9 100644
--- a/src/cobalt/media/base/decoder_buffer.cc
+++ b/src/cobalt/media/base/decoder_buffer.cc
@@ -68,15 +68,19 @@
     return;
   }
 
-  SbMemoryCopy(data_.get(), data, size_);
+  if (has_data()) {
+    SbMemoryCopy(data_.get(), data, size_);
+  }
 
   if (!side_data) {
     CHECK_EQ(side_data_size, 0u);
     return;
   }
 
-  DCHECK_GT(side_data_size_, 0u);
-  SbMemoryCopy(side_data_.get(), side_data, side_data_size_);
+  if (has_side_data()) {
+    DCHECK_GT(side_data_size_, 0u);
+    SbMemoryCopy(side_data_.get(), side_data, side_data_size_);
+  }
 }
 
 DecoderBuffer::~DecoderBuffer() {}
diff --git a/src/cobalt/media/base/stream_parser_buffer.cc b/src/cobalt/media/base/stream_parser_buffer.cc
index 3680f9c..0656fb8 100644
--- a/src/cobalt/media/base/stream_parser_buffer.cc
+++ b/src/cobalt/media/base/stream_parser_buffer.cc
@@ -45,8 +45,13 @@
 scoped_refptr<StreamParserBuffer> StreamParserBuffer::CopyFrom(
     Allocator* allocator, const uint8_t* data, int data_size, bool is_key_frame,
     Type type, TrackId track_id) {
-  return make_scoped_refptr(new StreamParserBuffer(
-      allocator, data, data_size, NULL, 0, is_key_frame, type, track_id));
+  scoped_refptr<StreamParserBuffer> stream_parser_buffer =
+      make_scoped_refptr(new StreamParserBuffer(
+          allocator, data, data_size, NULL, 0, is_key_frame, type, track_id));
+  if (stream_parser_buffer->has_data()) {
+    return stream_parser_buffer;
+  }
+  return NULL;
 }
 
 scoped_refptr<StreamParserBuffer> StreamParserBuffer::CopyFrom(
@@ -93,6 +98,10 @@
     set_duration(kNoTimestamp);
   }
 
+  if (!has_data()) {
+    return;
+  }
+
   if (is_key_frame) set_is_key_frame(true);
 }
 
diff --git a/src/cobalt/media/filters/source_buffer_stream.cc b/src/cobalt/media/filters/source_buffer_stream.cc
index 2602fd0..8ab87ce 100644
--- a/src/cobalt/media/filters/source_buffer_stream.cc
+++ b/src/cobalt/media/filters/source_buffer_stream.cc
@@ -730,10 +730,30 @@
     return false;
   }
 
-  // Return if we're under or at the memory limit.
-  if (ranges_size + newDataSize <= memory_limit_) return true;
+  base::TimeDelta duration = GetBufferedDurationForGarbageCollection();
 
-  size_t bytes_to_free = ranges_size + newDataSize - memory_limit_;
+  size_t bytes_to_free = 0;
+
+  // Check if we're under or at the memory/duration limit.
+  const int64 kGcDurationThresholdInMilliseconds =
+      COBALT_MEDIA_SOURCE_GARBAGE_COLLECTION_DURATION_THRESHOLD_IN_SECONDS *
+      1000;
+
+  if (ranges_size + newDataSize > memory_limit_) {
+    bytes_to_free = ranges_size + newDataSize - memory_limit_;
+  } else if (duration.InMilliseconds() > kGcDurationThresholdInMilliseconds) {
+    // Estimate the size to free.
+    int64 duration_to_free =
+        duration.InMilliseconds() - kGcDurationThresholdInMilliseconds;
+    bytes_to_free = static_cast<size_t>(ranges_size * duration_to_free /
+                                        duration.InMilliseconds());
+  }
+
+  if (bytes_to_free == 0) {
+    return true;
+  }
+
+  DCHECK_GT(bytes_to_free, 0);
 
   DVLOG(2) << __func__ << " " << GetStreamTypeName()
            << ": Before GC media_time=" << media_time.InSecondsF()
@@ -1833,5 +1853,15 @@
   return true;
 }
 
+base::TimeDelta SourceBufferStream::GetBufferedDurationForGarbageCollection()
+    const {
+  base::TimeDelta duration;
+  for (RangeList::const_iterator itr = ranges_.begin(); itr != ranges_.end();
+       ++itr) {
+    duration += (*itr)->GetEndTimestamp() - (*itr)->GetStartTimestamp();
+  }
+  return duration;
+}
+
 }  // namespace media
 }  // namespace cobalt
diff --git a/src/cobalt/media/filters/source_buffer_stream.h b/src/cobalt/media/filters/source_buffer_stream.h
index 6fe9229..c473d4a 100644
--- a/src/cobalt/media/filters/source_buffer_stream.h
+++ b/src/cobalt/media/filters/source_buffer_stream.h
@@ -471,6 +471,10 @@
   // appropriately and returns true.  Otherwise returns false.
   bool SetPendingBuffer(scoped_refptr<StreamParserBuffer>* out_buffer);
 
+  // Returns the accumulated duration of all ranges.  This is solely used by
+  // garbage collection.
+  base::TimeDelta GetBufferedDurationForGarbageCollection() const;
+
   // Used to report log messages that can help the web developer figure out what
   // is wrong with the content.
   scoped_refptr<MediaLog> media_log_;
diff --git a/src/cobalt/media/formats/mp4/mp4_stream_parser.cc b/src/cobalt/media/formats/mp4/mp4_stream_parser.cc
index d8074e9..dd13d30 100644
--- a/src/cobalt/media/formats/mp4/mp4_stream_parser.cc
+++ b/src/cobalt/media/formats/mp4/mp4_stream_parser.cc
@@ -618,6 +618,10 @@
       buffer_allocator_, &frame_buf[0], frame_buf.size(), runs_->is_keyframe(),
       buffer_type, runs_->track_id());
 
+  if (!stream_buf) {
+    return false;
+  }
+
   if (decrypt_config) stream_buf->set_decrypt_config(decrypt_config.Pass());
 
   stream_buf->set_duration(runs_->duration());
diff --git a/src/cobalt/media/formats/mpeg/mpeg_audio_stream_parser_base.cc b/src/cobalt/media/formats/mpeg/mpeg_audio_stream_parser_base.cc
index 31d415a..602b166 100644
--- a/src/cobalt/media/formats/mpeg/mpeg_audio_stream_parser_base.cc
+++ b/src/cobalt/media/formats/mpeg/mpeg_audio_stream_parser_base.cc
@@ -233,6 +233,9 @@
   scoped_refptr<StreamParserBuffer> buffer =
       StreamParserBuffer::CopyFrom(buffer_allocator_, data, frame_size, true,
                                    DemuxerStream::AUDIO, kMpegAudioTrackId);
+  if (!buffer) {
+    return -1;
+  }
   buffer->set_timestamp(timestamp_helper_->GetTimestamp());
   buffer->set_duration(timestamp_helper_->GetFrameDuration(sample_count));
   buffers->push_back(buffer);
diff --git a/src/cobalt/media/formats/webm/webm_cluster_parser.cc b/src/cobalt/media/formats/webm/webm_cluster_parser.cc
index a8fac84..48a4850 100644
--- a/src/cobalt/media/formats/webm/webm_cluster_parser.cc
+++ b/src/cobalt/media/formats/webm/webm_cluster_parser.cc
@@ -512,7 +512,10 @@
     buffer = StreamParserBuffer::CopyFrom(
         buffer_allocator_, data + data_offset, size - data_offset, additional,
         additional_size, is_keyframe, buffer_type, track_num);
-
+    if (!buffer) {
+      MEDIA_LOG(ERROR, media_log_) << "Failed to allocate StreamParserBuffer";
+      return false;
+    }
     if (decrypt_config) buffer->set_decrypt_config(decrypt_config.Pass());
   } else {
     std::string id, settings, content;
@@ -529,6 +532,10 @@
         buffer_allocator_, reinterpret_cast<const uint8_t*>(content.data()),
         content.length(), &side_data[0], side_data.size(), true, buffer_type,
         track_num);
+    if (!buffer) {
+      MEDIA_LOG(ERROR, media_log_) << "Failed to allocate StreamParserBuffer";
+      return false;
+    }
   }
 
   buffer->set_timestamp(timestamp);
diff --git a/src/cobalt/renderer/pipeline.cc b/src/cobalt/renderer/pipeline.cc
index 187e684..b2c7967 100644
--- a/src/cobalt/renderer/pipeline.cc
+++ b/src/cobalt/renderer/pipeline.cc
@@ -84,9 +84,6 @@
       last_did_rasterize_(false),
       last_animations_expired_(true),
       last_stat_tracked_animations_expired_(true),
-      rasterize_periodic_timer_("Renderer.Rasterize.Duration",
-                                kRasterizePeriodicTimerEntriesPerUpdate,
-                                false /*enable_entry_list_c_val*/),
       rasterize_animations_timer_("Renderer.Rasterize.Animations",
                                   kRasterizeAnimationsTimerMaxEntries,
                                   true /*enable_entry_list_c_val*/),
@@ -310,14 +307,6 @@
   bool animations_active =
       !are_stat_tracked_animations_expired && did_rasterize;
 
-  // The rasterization is only timed with the periodic timer when the render
-  // tree has changed. This ensures that the frames being timed are consistent
-  // between platforms that submit unchanged trees and those that don't.
-  if (did_rasterize) {
-    rasterize_periodic_timer_.Start(start_time);
-    rasterize_periodic_timer_.Stop(end_time);
-  }
-
   if (last_animations_active || animations_active) {
     // The rasterization is only timed with the animations timer when there are
     // animations to track. This applies when animations were active during
diff --git a/src/cobalt/renderer/pipeline.h b/src/cobalt/renderer/pipeline.h
index a9abff7..571f274 100644
--- a/src/cobalt/renderer/pipeline.h
+++ b/src/cobalt/renderer/pipeline.h
@@ -209,13 +209,9 @@
   bool last_did_rasterize_;
 
   // Timer tracking the amount of time spent in
-  // |RasterizeSubmissionToRenderTarget| when the render tree has changed.
-  // The tracking is flushed when the max count is hit.
-  base::CValCollectionTimerStats<base::CValPublic> rasterize_periodic_timer_;
-  // Timer tracking the amount of time spent in
   // |RasterizeSubmissionToRenderTarget| while animations are active. The
   // tracking is flushed when the animations expire.
-  base::CValCollectionTimerStats<base::CValDebug> rasterize_animations_timer_;
+  base::CValCollectionTimerStats<base::CValPublic> rasterize_animations_timer_;
 
   // Accumulates render tree rasterization interval times but does not flush
   // them until the maximum number of samples is gathered.
@@ -229,16 +225,16 @@
       rasterize_animations_interval_timer_;
 
   // The total number of new render trees that have been rasterized.
-  base::CVal<int> new_render_tree_rasterize_count_;
+  base::CVal<int, base::CValPublic> new_render_tree_rasterize_count_;
   // The last time that a newly encountered render tree was first rasterized.
-  base::CVal<int64> new_render_tree_rasterize_time_;
+  base::CVal<int64, base::CValPublic> new_render_tree_rasterize_time_;
 
   // Whether or not animations are currently playing.
-  base::CVal<bool> has_active_animations_c_val_;
+  base::CVal<bool, base::CValPublic> has_active_animations_c_val_;
   // The most recent time animations started playing.
-  base::CVal<int64> animations_start_time_;
+  base::CVal<int64, base::CValPublic> animations_start_time_;
   // The most recent time animations ended playing.
-  base::CVal<int64> animations_end_time_;
+  base::CVal<int64, base::CValPublic> animations_end_time_;
 
 #if defined(ENABLE_DEBUG_CONSOLE)
   // Dumps the current render tree to the console.
diff --git a/src/cobalt/renderer/rasterizer/blitter/cached_software_rasterizer.cc b/src/cobalt/renderer/rasterizer/blitter/cached_software_rasterizer.cc
index 1c5e2d4..2dd5667 100644
--- a/src/cobalt/renderer/rasterizer/blitter/cached_software_rasterizer.cc
+++ b/src/cobalt/renderer/rasterizer/blitter/cached_software_rasterizer.cc
@@ -234,6 +234,7 @@
       // This surface may have already been in the cache if it was in there
       // with a different scale.  In that case, replace the old one.
       cache_memory_usage_ -= found->second.GetEstimatedMemoryUsage();
+      SbBlitterDestroySurface(found->second.surface);
       surface_map_.erase(found);
     }
 
diff --git a/src/media/base/pipeline_impl.cc b/src/media/base/pipeline_impl.cc
index aff759d..cf2bef0 100644
--- a/src/media/base/pipeline_impl.cc
+++ b/src/media/base/pipeline_impl.cc
@@ -745,6 +745,25 @@
                              const BufferingStateCB& buffering_state_cb,
                              const base::Closure& duration_change_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
+
+  // Suspend() can be called from a thread other than the WebModule thread.  In
+  // such case it is possible that Stop() is called before Start() and |state_|
+  // will be set to |kStopping| or |kStopped|.
+  if (state_ == kStopping || state_ == kStopped) {
+    return;
+  }
+
+  // Check for individual state so we have more clue when one of them is hit.
+  CHECK_NE(kInitDemuxer, state_) << "state shouldn't be kInitDemuxer";
+  CHECK_NE(kInitAudioRenderer, state_)
+      << "state shouldn't be kInitAudioRenderer";
+  CHECK_NE(kInitVideoRenderer, state_)
+      << "state shouldn't be kInitVideoRenderer";
+  CHECK_NE(kInitPrerolling, state_) << "state shouldn't be kInitPrerolling";
+  CHECK_NE(kSeeking, state_) << "state shouldn't be kSeeking";
+  CHECK_NE(kStarting, state_) << "state shouldn't be kStarting";
+  CHECK_NE(kStarted, state_) << "state shouldn't be kStarted";
+
   CHECK_EQ(kCreated, state_)
       << "Media pipeline cannot be started more than once";
 
diff --git a/src/starboard/linux/x64x11/clang/3.3/download_clang.sh b/src/starboard/linux/x64x11/clang/3.3/download_clang.sh
index f552ae8..54dded5 100755
--- a/src/starboard/linux/x64x11/clang/3.3/download_clang.sh
+++ b/src/starboard/linux/x64x11/clang/3.3/download_clang.sh
@@ -37,7 +37,7 @@
 
   cd llvm
   # Specify a bootstrap compiler that is known to be available.
-  CC=clang-3.6 CXX=clang++-3.6 \
+  CC=clang CXX=clang++ \
   ./configure --enable-optimized --disable-doxygen --prefix=${PWD}/bin
   make -j"$(nproc)"
   cd ${toolchain_path}
diff --git a/src/starboard/linux/x64x11/gcc/4.4/compiler_flags.gypi b/src/starboard/linux/x64x11/gcc/4.4/compiler_flags.gypi
index 9fc908e..6f7d411 100644
--- a/src/starboard/linux/x64x11/gcc/4.4/compiler_flags.gypi
+++ b/src/starboard/linux/x64x11/gcc/4.4/compiler_flags.gypi
@@ -47,6 +47,9 @@
       '-O2',
     ],
     'common_compiler_flags': [
+      # Add the target specific include path that is not compatible with gcc
+      # 4.4 default search locations.
+      '-I/usr/include/x86_64-linux-gnu',
       # Default visibility to hidden, to enable dead stripping.
       '-fvisibility=hidden',
       # protobuf uses hash_map.
diff --git a/src/starboard/linux/x64x11/gcc/4.4/download_gcc.sh b/src/starboard/linux/x64x11/gcc/4.4/download_gcc.sh
new file mode 100755
index 0000000..8bac360
--- /dev/null
+++ b/src/starboard/linux/x64x11/gcc/4.4/download_gcc.sh
@@ -0,0 +1,139 @@
+#!/bin/bash
+# Copyright 2018 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.
+
+# This script downloads and compiles gcc version 4.4.7
+
+set -e
+unset GOMA_DIR
+export GOMA_DIR
+
+toolchain_name="gcc"
+version="4.4.7"
+toolchain_folder="x86_64-linux-gnu-${toolchain_name}-${version}"
+
+binary_path="gcc/bin/g++"
+build_duration="about 10 minutes"
+
+cd $(dirname $0)
+source ../../toolchain_paths.sh
+cd ${toolchain_path}
+
+(
+  texinfo_install_folder=${toolchain_path}/texinfo
+  if [ ! -f ${texinfo_install_folder}/bin/info ]; then
+    # Download and compile texinfo
+    texinfo_version="texinfo-4.13"
+    texinfo_tar_file=${texinfo_version}a.tar.gz
+    wget -c https://ftp.gnu.org/gnu/texinfo/${texinfo_tar_file}
+
+    checksum_invalid=$(sha256sum ${texinfo_tar_file} | grep -q -c 1303e91a1c752b69a32666a407e9fbdd6e936def4b09bc7de30f416301530d68)
+    if [ $checksum_invalid ]; then echo "Invalid checksum"; exit 1 ; fi
+    rm -rf texinfo ${texinfo_version}
+    tar -xzf ${texinfo_tar_file}
+    cd ${texinfo_version}/
+    ./configure --prefix=${texinfo_install_folder}
+    make -j$(nproc) && make install
+    cd ${toolchain_path}
+  fi
+  export PATH=${texinfo_install_folder}/bin:${PATH}
+
+  if [ ! -e gmp/lib/libgmp.a ]; then
+    gmp_version="gmp-4.3.2"
+    gmp_tar_file=${gmp_version}.tar.bz2
+    wget -c https://ftp.gnu.org/gnu/gmp/${gmp_tar_file}
+
+    checksum_invalid=$(sha256sum ${gmp_tar_file} | grep -q -c 936162c0312886c21581002b79932829aa048cfaf9937c6265aeaa14f1cd1775)
+    if [ $checksum_invalid ]; then echo "Invalid checksum" ; exit 1 ; fi
+
+    rm -rf gmp ${gmp_version}
+    tar -xjf ${gmp_tar_file}
+    cd ${gmp_version}
+    ./configure --disable-shared --enable-static --prefix=${PWD}/../gmp
+    make -j$(nproc) && make install
+    cd ${toolchain_path}
+  fi
+
+  if [ ! -e mpfr/lib/libmpfr.a ]; then
+    mpfr_version="mpfr-2.4.2"
+    mpfr_tar_file=${mpfr_version}.tar.xz
+    wget -c https://ftp.gnu.org/gnu/mpfr/${mpfr_version}.tar.xz
+
+    checksum_invalid=$(sha256sum ${mpfr_tar_file} | grep -q -c d7271bbfbc9ddf387d3919df8318cd7192c67b232919bfa1cb3202d07843da1b)
+    if [ $checksum_invalid ]; then echo "Invalid checksum" ; exit 1 ; fi
+
+    rm -rf mpfr ${mpfr_version}
+    tar -xJf ${mpfr_version}.tar.xz
+    cd ${mpfr_version}
+    ./configure --disable-shared --enable-static --with-gmp=../gmp --prefix=${PWD}/../mpfr
+    make -j$(nproc) && make install
+    cd ${toolchain_path}
+  fi
+
+  # Download gcc
+  if [ ! -e gcc-${version}/README ]; then
+    file="gcc-${version}.tar.bz2"
+    wget -c https://ftp.gnu.org/gnu/gcc/gcc-${version}/${file}
+    wget -c https://ftp.gnu.org/gnu/gcc/gcc-${version}/${file}.sig
+    wget -c https://ftp.gnu.org/gnu/gnu-keyring.gpg
+    signature_invalid=`gpg --verify --no-default-keyring --keyring ./gnu-keyring.gpg ${file}.sig`
+    if [ $signature_invalid ]; then echo "Invalid signature" ; exit 1 ; fi
+
+    checksum_invalid=$(sha256sum ${file} | grep -q -c 5ff75116b8f763fa0fb5621af80fc6fb3ea0f1b1a57520874982f03f26cd607f)
+    if [ $checksum_invalid ]; then echo "Invalid checksum" ; exit 1 ; fi
+
+    rm -rf gcc-${version}
+    tar -xjf ${file}
+    cd gcc-${version}
+    if [ -f ./contrib/download_prerequisites ]; then
+      ./contrib/download_prerequisites
+    fi
+
+    # Replace 'struct siginfo' with 'siginfo_t' in linux-unwind.h (compilation fix).
+    sed -i 's:struct siginfo:siginfo_t:g' ${toolchain_path}/gcc-${version}/gcc/config/i386/linux-unwind.h
+
+    cd ${toolchain_path}
+  fi
+
+  # Create clean build folder for gcc
+  rm -rf gcc gcc-${version}-build
+  mkdir gcc-${version}-build
+  cd gcc-${version}-build
+
+  export LIBRARY_PATH=/usr/lib/x86_64-linux-gnu:/usr/lib32:${toolchain_path}/gmp/lib:${toolchain_path}/mpfr/lib
+  export LD_LIBRARY_PATH=$LIBRARY_PATH
+  echo LIBRARY_PATH = $LIBRARY_PATH
+
+  export C_INCLUDE_PATH=/usr/include/x86_64-linux-gnu
+  export CPLUS_INCLUDE_PATH=/usr/include/x86_64-linux-gnu
+  export TARGET_SYSTEM_ROOT=/usr/include/x86_64-linux-gnu
+
+  export CC="gcc -fgnu89-inline"
+  export CXX="g++ -fgnu89-inline"
+
+  ${toolchain_path}/gcc-${version}/configure \
+    --prefix=${toolchain_path}/gcc \
+    --disable-multilib \
+    --enable-languages=c,c++ \
+    --with-gmp=${toolchain_path}/gmp \
+    --with-mpfr=${toolchain_path}/mpfr \
+    --with-mpfr-lib=${toolchain_path}/mpfr/lib
+
+  make -j$(nproc) && make install
+  cd ${toolchain_path}
+
+  ls -l ${toolchain_binary}
+  ${toolchain_binary} --version
+) >${logfile} 2>&1
+
diff --git a/src/starboard/linux/x64x11/gcc/4.4/gyp_configuration.py b/src/starboard/linux/x64x11/gcc/4.4/gyp_configuration.py
index 3d6e006..dbb14af 100644
--- a/src/starboard/linux/x64x11/gcc/4.4/gyp_configuration.py
+++ b/src/starboard/linux/x64x11/gcc/4.4/gyp_configuration.py
@@ -15,6 +15,7 @@
 
 import logging
 import os
+import subprocess
 import sys
 
 # Import the shared Linux platform configuration.
@@ -25,6 +26,7 @@
             'shared')))
 # pylint: disable=import-self,g-import-not-at-top
 import gyp_configuration as shared_configuration
+import gyp_utils
 
 
 class PlatformConfig(shared_configuration.PlatformConfig):
@@ -34,16 +36,28 @@
     super(PlatformConfig, self).__init__(
         platform, asan_enabled_by_default, goma_supports_compiler=False)
 
+    # Run the script that ensures gcc 4.4.7 is installed.
+    script_path = os.path.dirname(os.path.realpath(__file__))
+    subprocess.call(
+        os.path.join(script_path, 'download_gcc.sh'), cwd=script_path)
+
   def GetVariables(self, configuration):
     variables = super(PlatformConfig, self).GetVariables(configuration)
-    variables.update({'clang': 0,})
+    variables.update({
+        'clang': 0,
+    })
     return variables
 
   def GetEnvironmentVariables(self):
     env_variables = super(PlatformConfig, self).GetEnvironmentVariables()
+    toolchain_bin_dir = os.path.join(gyp_utils.GetToolchainsDir(),
+                                     'x86_64-linux-gnu-gcc-4.4.7', 'gcc', 'bin')
     env_variables.update({
-        'CC': 'gcc-4.4',
-        'CXX': 'g++-4.4',
+        'CC':
+            os.path.join(toolchain_bin_dir, 'gcc'),
+        'CXX':
+            'LIBRARY_PATH=/usr/lib/x86_64-linux-gnu ' +
+            os.path.join(toolchain_bin_dir, 'g++'),
     })
     return env_variables
 
diff --git a/src/starboard/nplb/socket_resolve_test.cc b/src/starboard/nplb/socket_resolve_test.cc
index ebca117..bf96ac3 100644
--- a/src/starboard/nplb/socket_resolve_test.cc
+++ b/src/starboard/nplb/socket_resolve_test.cc
@@ -37,7 +37,7 @@
 const void* kNull = NULL;
 
 // A random host name to use to test DNS resolution.
-const char* kTestHostName = "www.yahoo.com";
+const char kTestHostName[] = "www.example.com";
 
 #define LOG_ADDRESS(i) "In returned address #" << (i)
 
diff --git a/src/third_party/protobuf/src/google/protobuf/stubs/strutil.cc b/src/third_party/protobuf/src/google/protobuf/stubs/strutil.cc
index 296694c..8f5ff59 100644
--- a/src/third_party/protobuf/src/google/protobuf/stubs/strutil.cc
+++ b/src/third_party/protobuf/src/google/protobuf/stubs/strutil.cc
@@ -29,12 +29,39 @@
 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 // from google3/strings/strutil.cc
-#include "starboard/client_porting/poem/stdlib_poem.h"
-#include "starboard/client_porting/poem/stdio_poem.h"
-#include "starboard/client_porting/poem/string_poem.h"
 
 #ifndef STARBOARD
+
 #include <stdio.h>
+
+// We need to be able to build this library using the host toolchain for some
+// platforms, and Starboard is not available there.  So we define these
+// "reverse poems" to move past this issue for host builds.  For why we don't
+// just use poems, see the comment in the #else clause.
+#define SbMemoryCopy memcpy
+#define SbMemoryMove memmove
+#define SbStringGetLength strlen
+#define SbStringCopyUnsafe strcpy
+#define PoemFindCharacterInString strchr
+#define SbStringFormatF snprintf
+#define SbStringFormatUnsafeF sprintf
+#define SbStringParseUnsignedInteger strtoul
+#define SbStringParseSignedInteger strtol
+#define SbStringParseDouble strtod
+
+#else  // STARBOARD
+
+// We avoid using poems here because a subsequent #include of math.h may
+// result, on some platforms, of the indirect inclusion of stdlib.h, which
+// will then conflict with our poem includes.
+#define POEM_NO_EMULATION
+// For access to PoemFindCharacterInString() as a replacement for strchr().
+#include "starboard/client_porting/poem/string_poem.h"
+#undef POEM_NO_EMULATION
+
+#include "starboard/memory.h"
+#include "starboard/string.h"
+
 #endif  // STARBOARD
 
 #include <errno.h>
@@ -276,7 +303,7 @@
                                 string* result) {
   GOOGLE_CHECK(result != NULL);
   result->clear();
-  int delim_length = strlen(delim);
+  int delim_length = SbStringGetLength(delim);
 
   // Precompute resulting length so we can reserve() memory in one shot.
   int length = 0;
@@ -515,7 +542,7 @@
              (last_hex_escape && isxdigit(*src)))) {
           if (dest_len - used < 4) // need space for 4 letter escape
             return -1;
-          sprintf(dest + used, (use_hex ? "\\x%02x" : "\\%03o"),
+          SbStringFormatUnsafeF(dest + used, (use_hex ? "\\x%02x" : "\\%03o"),
                   static_cast<uint8>(*src));
           is_hex_escape = use_hex;
           used += 4;
@@ -643,7 +670,7 @@
 int32 strto32_adaptor(const char *nptr, char **endptr, int base) {
   const int saved_errno = errno;
   errno = 0;
-  const long result = strtol(nptr, endptr, base);
+  const long result = SbStringParseSignedInteger(nptr, endptr, base);
   if (errno == ERANGE && result == LONG_MIN) {
     return kint32min;
   } else if (errno == ERANGE && result == LONG_MAX) {
@@ -663,7 +690,7 @@
 uint32 strtou32_adaptor(const char *nptr, char **endptr, int base) {
   const int saved_errno = errno;
   errno = 0;
-  const unsigned long result = strtoul(nptr, endptr, base);
+  const unsigned long result = SbStringParseUnsignedInteger(nptr, endptr, base);
   if (errno == ERANGE && result == ULONG_MAX) {
     return kuint32max;
   } else if (errno == 0 && result > kuint32max) {
@@ -1225,7 +1252,7 @@
 void DelocalizeRadix(char* buffer) {
   // Fast check:  if the buffer has a normal decimal point, assume no
   // translation is needed.
-  if (strchr(buffer, '.') != NULL) return;
+  if (PoemFindCharacterInString(buffer, '.') != NULL) return;
 
   // Find the first unknown character.
   while (IsValidFloatChar(*buffer)) ++buffer;
@@ -1245,7 +1272,7 @@
     // extra bytes.
     char* target = buffer;
     do { ++buffer; } while (!IsValidFloatChar(*buffer) && *buffer != '\0');
-    memmove(target, buffer, strlen(buffer) + 1);
+    SbMemoryMove(target, buffer, SbStringGetLength(buffer) + 1);
   }
 }
 
@@ -1257,20 +1284,20 @@
   GOOGLE_COMPILE_ASSERT(DBL_DIG < 20, DBL_DIG_is_too_big);
 
   if (value == numeric_limits<double>::infinity()) {
-    strcpy(buffer, "inf");
+    SbStringCopyUnsafe(buffer, "inf");
     return buffer;
   } else if (value == -numeric_limits<double>::infinity()) {
-    strcpy(buffer, "-inf");
+    SbStringCopyUnsafe(buffer, "-inf");
     return buffer;
   } else if (MathLimits<double>::IsNaN(value)) {
-    strcpy(buffer, "nan");
+    SbStringCopyUnsafe(buffer, "nan");
     return buffer;
   }
 
   int snprintf_result =
-    snprintf(buffer, kDoubleToBufferSize, "%.*g", DBL_DIG, value);
+    SbStringFormatF(buffer, kDoubleToBufferSize, "%.*g", DBL_DIG, value);
 
-  // The snprintf should never overflow because the buffer is significantly
+  // The SbStringFormatF should never overflow because the buffer is significantly
   // larger than the precision we asked for.
   GOOGLE_DCHECK(snprintf_result > 0 && snprintf_result < kDoubleToBufferSize);
 
@@ -1280,10 +1307,10 @@
   // of a double.  This long double may have extra bits that make it compare
   // unequal to "value" even though it would be exactly equal if it were
   // truncated to a double.
-  volatile double parsed_value = strtod(buffer, NULL);
+  volatile double parsed_value = SbStringParseDouble(buffer, NULL);
   if (parsed_value != value) {
     int snprintf_result =
-      snprintf(buffer, kDoubleToBufferSize, "%.*g", DBL_DIG+2, value);
+      SbStringFormatF(buffer, kDoubleToBufferSize, "%.*g", DBL_DIG+2, value);
 
     // Should never overflow; see above.
     GOOGLE_DCHECK(snprintf_result > 0 && snprintf_result < kDoubleToBufferSize);
@@ -1332,7 +1359,7 @@
   char* endptr;
   errno = 0;  // errno only gets set on errors
 #if defined(_WIN32) || defined (__hpux) || defined(STARBOARD)  // has no strtof()
-  *value = strtod(str, &endptr);
+  *value = SbStringParseDouble(str, &endptr);
 #else
   *value = strtof(str, &endptr);
 #endif
@@ -1341,7 +1368,7 @@
 
 bool safe_strtod(const char* str, double* value) {
   char* endptr;
-  *value = strtod(str, &endptr);
+  *value = SbStringParseDouble(str, &endptr);
   if (endptr != str) {
     while (ascii_isspace(*endptr)) ++endptr;
   }
@@ -1375,27 +1402,27 @@
   GOOGLE_COMPILE_ASSERT(FLT_DIG < 10, FLT_DIG_is_too_big);
 
   if (value == numeric_limits<double>::infinity()) {
-    strcpy(buffer, "inf");
+    SbStringCopyUnsafe(buffer, "inf");
     return buffer;
   } else if (value == -numeric_limits<double>::infinity()) {
-    strcpy(buffer, "-inf");
+    SbStringCopyUnsafe(buffer, "-inf");
     return buffer;
   } else if (MathLimits<float>::IsNaN(value)) {
-    strcpy(buffer, "nan");
+    SbStringCopyUnsafe(buffer, "nan");
     return buffer;
   }
 
   int snprintf_result =
-    snprintf(buffer, kFloatToBufferSize, "%.*g", FLT_DIG, value);
+    SbStringFormatF(buffer, kFloatToBufferSize, "%.*g", FLT_DIG, value);
 
-  // The snprintf should never overflow because the buffer is significantly
-  // larger than the precision we asked for.
+  // The SbStringFormatF should never overflow because the buffer is
+  // significantly larger than the precision we asked for.
   GOOGLE_DCHECK(snprintf_result > 0 && snprintf_result < kFloatToBufferSize);
 
   float parsed_value;
   if (!safe_strtof(buffer, &parsed_value) || parsed_value != value) {
     int snprintf_result =
-      snprintf(buffer, kFloatToBufferSize, "%.*g", FLT_DIG+2, value);
+      SbStringFormatF(buffer, kFloatToBufferSize, "%.*g", FLT_DIG+2, value);
 
     // Should never overflow; see above.
     GOOGLE_DCHECK(snprintf_result > 0 && snprintf_result < kFloatToBufferSize);
@@ -1435,35 +1462,35 @@
 //    of a mix of raw C strings, C++ strings, and integer values.
 // ----------------------------------------------------------------------
 
-// Append is merely a version of memcpy that returns the address of the byte
+// Append is merely a version of SbMemoryCopy that returns the address of the byte
 // after the area just overwritten.  It comes in multiple flavors to minimize
 // call overhead.
 static char *Append1(char *out, const AlphaNum &x) {
-  memcpy(out, x.data(), x.size());
+  SbMemoryCopy(out, x.data(), x.size());
   return out + x.size();
 }
 
 static char *Append2(char *out, const AlphaNum &x1, const AlphaNum &x2) {
-  memcpy(out, x1.data(), x1.size());
+  SbMemoryCopy(out, x1.data(), x1.size());
   out += x1.size();
 
-  memcpy(out, x2.data(), x2.size());
+  SbMemoryCopy(out, x2.data(), x2.size());
   return out + x2.size();
 }
 
 static char *Append4(char *out,
                      const AlphaNum &x1, const AlphaNum &x2,
                      const AlphaNum &x3, const AlphaNum &x4) {
-  memcpy(out, x1.data(), x1.size());
+  SbMemoryCopy(out, x1.data(), x1.size());
   out += x1.size();
 
-  memcpy(out, x2.data(), x2.size());
+  SbMemoryCopy(out, x2.data(), x2.size());
   out += x2.size();
 
-  memcpy(out, x3.data(), x3.size());
+  SbMemoryCopy(out, x3.data(), x3.size());
   out += x3.size();
 
-  memcpy(out, x4.data(), x4.size());
+  SbMemoryCopy(out, x4.data(), x4.size());
   return out + x4.size();
 }
 
@@ -2269,7 +2296,7 @@
     len = 4;
   }
   tmp = ghtonl(tmp);
-  memcpy(output, reinterpret_cast<const char*>(&tmp) + sizeof(tmp) - len, len);
+  SbMemoryCopy(output, reinterpret_cast<const char*>(&tmp) + sizeof(tmp) - len, len);
   return len;
 }