diff --git a/src/cobalt/CHANGELOG.md b/src/cobalt/CHANGELOG.md
new file mode 100644
index 0000000..085b9a2
--- /dev/null
+++ b/src/cobalt/CHANGELOG.md
@@ -0,0 +1,11 @@
+# Cobalt Version Changelog
+
+This document records all notable changes made to Cobalt since the last release.
+
+## Version 10
+
+### Dummy example change
+Here we would put a description of a notable change that was made in Cobalt 10
+but did not make it into Cobalt 9.  This is currently the only item in a list
+that will expand to multiple items as we work on Cobalt.  When the first
+legitimate change is documented here, it should replace this example change.
diff --git a/src/cobalt/audio/audio_device.cc b/src/cobalt/audio/audio_device.cc
index c06e9fb..5d740ab 100644
--- a/src/cobalt/audio/audio_device.cc
+++ b/src/cobalt/audio/audio_device.cc
@@ -45,7 +45,7 @@
 
 namespace {
 const int kRenderBufferSizeFrames = 1024;
-const int kFramesPerChannel = kRenderBufferSizeFrames * 4;
+const int kFramesPerChannel = kRenderBufferSizeFrames * 8;
 const int kStandardOutputSampleRate = 48000;
 }  // namespace
 
diff --git a/src/cobalt/browser/application.cc b/src/cobalt/browser/application.cc
index 108115a..0bd7afe 100644
--- a/src/cobalt/browser/application.cc
+++ b/src/cobalt/browser/application.cc
@@ -52,7 +52,6 @@
 #include "lbshell/src/lb_memory_pages.h"
 #endif  // defined(__LB_SHELL__)
 #if defined(OS_STARBOARD)
-#include "nb/lexical_cast.h"
 #include "starboard/configuration.h"
 #include "starboard/log.h"
 #endif  // defined(OS_STARBOARD)
@@ -269,31 +268,6 @@
                           &options->scratch_surface_cache_size_in_bytes);
 }
 
-void ApplyCommandLineSettingsToWebModuleOptions(WebModule::Options* options) {
-  SetIntegerIfSwitchIsSet(browser::switches::kRemoteTypefaceCacheSizeInBytes,
-                          &options->remote_typeface_cache_capacity);
-}
-
-template <typename T>
-base::optional<T> ParseSetting(const CommandLine* command_line,
-                               const char* switch_name) {
-  base::optional<T> output;
-  if (!command_line->HasSwitch(switch_name)) {
-    return output;
-  }
-  std::string switch_value = command_line->GetSwitchValueNative(switch_name);
-
-  bool parse_ok = false;
-  T value = nb::lexical_cast<T>(switch_value.c_str(), &parse_ok);
-
-  if (parse_ok) {
-    output = static_cast<T>(value);
-  } else {
-    LOG(ERROR) << "Invalid value for command line setting: " << switch_name;
-  }
-  return output;
-}
-
 // Restrict navigation to a couple of whitelisted URLs by default.
 const char kYouTubeTvLocationPolicy[] =
     "h5vcc-location-src "
@@ -373,6 +347,10 @@
       math::Size(skia_glyph_atlas_texture_dimensions.width(),
                  skia_glyph_atlas_texture_dimensions.height());
 
+  options->web_module_options.remote_typeface_cache_capacity =
+      static_cast<int>(
+          auto_mem.remote_typeface_cache_size_in_bytes()->value());
+
   options->web_module_options.javascript_options.gc_threshold_bytes =
       static_cast<size_t>(auto_mem.javascript_gc_threshold_in_bytes()->value());
 
@@ -436,7 +414,6 @@
   options.network_module_options.preferred_language = language;
 
   ApplyCommandLineSettingsToRendererOptions(&options.renderer_module_options);
-  ApplyCommandLineSettingsToWebModuleOptions(&options.web_module_options);
 
   if (command_line->HasSwitch(browser::switches::kDisableJavaScriptJit)) {
     options.web_module_options.javascript_options.disable_jit = true;
diff --git a/src/cobalt/browser/browser.gyp b/src/cobalt/browser/browser.gyp
index 9ec2956..3e5aad6 100644
--- a/src/cobalt/browser/browser.gyp
+++ b/src/cobalt/browser/browser.gyp
@@ -53,8 +53,14 @@
         'memory_tracker/tool/leak_finder_tool.h',
         'memory_tracker/tool/log_writer_tool.cc',
         'memory_tracker/tool/log_writer_tool.h',
+        'memory_tracker/tool/memory_size_binner_tool.cc',
+        'memory_tracker/tool/memory_size_binner_tool.h',
         'memory_tracker/tool/params.cc',
         'memory_tracker/tool/params.h',
+        'memory_tracker/tool/print_csv_tool.cc',
+        'memory_tracker/tool/print_csv_tool.h',
+        'memory_tracker/tool/print_tool.cc',
+        'memory_tracker/tool/print_tool.h',
         'memory_tracker/tool/tool_impl.cc',
         'memory_tracker/tool/tool_impl.h',
         'memory_tracker/tool/tool_thread.cc',
@@ -89,6 +95,8 @@
         'COBALT_IMAGE_CACHE_CAPACITY_MULTIPLIER_WHEN_PLAYING_VIDEO=<(image_cache_capacity_multiplier_when_playing_video)',
         'COBALT_SOFTWARE_SURFACE_CACHE_SIZE_IN_BYTES=<(software_surface_cache_size_in_bytes)',
         'COBALT_JS_GARBAGE_COLLECTION_THRESHOLD_IN_BYTES=<(mozjs_garbage_collection_threshold_in_bytes)',
+        'COBALT_MAX_CPU_USAGE_IN_BYTES=<(max_cobalt_cpu_usage)',
+        'COBALT_MAX_GPU_USAGE_IN_BYTES=<(max_cobalt_gpu_usage)',
       ],
       'dependencies': [
         '<@(cobalt_platform_dependencies)',
diff --git a/src/cobalt/browser/memory_settings/auto_mem.cc b/src/cobalt/browser/memory_settings/auto_mem.cc
index a3df89c..71a4570 100644
--- a/src/cobalt/browser/memory_settings/auto_mem.cc
+++ b/src/cobalt/browser/memory_settings/auto_mem.cc
@@ -27,24 +27,16 @@
 #include "cobalt/browser/memory_settings/build_settings.h"
 #include "cobalt/browser/memory_settings/calculations.h"
 #include "cobalt/browser/memory_settings/constants.h"
+#include "cobalt/browser/memory_settings/memory_settings.h"
 #include "cobalt/browser/memory_settings/pretty_print.h"
 #include "cobalt/browser/switches.h"
+#include "nb/lexical_cast.h"
 
 namespace cobalt {
 namespace browser {
 namespace memory_settings {
 namespace {
 
-int64_t GetTotalCpuMemory() { return SbSystemGetTotalCPUMemory(); }
-
-base::optional<int64_t> GetTotalGpuMemory() {
-  base::optional<int64_t> total_gpu_memory;
-  if (SbSystemHasCapability(kSbSystemCapabilityCanQueryGPUMemoryStats)) {
-    total_gpu_memory = SbSystemGetTotalGPUMemory();
-  }
-  return total_gpu_memory;
-}
-
 // Determines if the string value signals "autoset".
 bool StringValueSignalsAutoset(const std::string& value) {
   std::string value_lower_case = value;
@@ -92,6 +84,35 @@
   return output.Pass();
 }
 
+scoped_ptr<IntSetting> CreateSystemMemorySetting(
+    const char* setting_name,
+    MemorySetting::MemoryType memory_type,
+    const CommandLine& command_line,
+    const base::optional<int64_t>& build_setting,
+    const base::optional<int64_t>& starboard_value) {
+  scoped_ptr<IntSetting> setting(new IntSetting(setting_name));
+  setting->set_memory_type(memory_type);
+  if (command_line.HasSwitch(setting_name)) {
+    const std::string value = command_line.GetSwitchValueNative(setting_name);
+    if (setting->TryParseValue(MemorySetting::kCmdLine, value)) {
+      return setting.Pass();
+    }
+  }
+
+  if (build_setting) {
+    setting->set_value(MemorySetting::kBuildSetting, *build_setting);
+    return setting.Pass();
+  }
+
+  if (starboard_value) {
+    setting->set_value(MemorySetting::kStarboardAPI, *starboard_value);
+    return setting.Pass();
+  }
+
+  setting->set_value(MemorySetting::kStarboardAPI, -1);
+  return setting.Pass();
+}
+
 void EnsureValuePositive(IntSetting* setting) {
   if (setting->value() < 0) {
     setting->set_value(setting->source_type(), 0);
@@ -130,16 +151,51 @@
   return sum;
 }
 
+
+// Creates the GPU setting.
+// This setting is unique because it may not be defined by command line, or
+// build. In this was, it can be unset.
+scoped_ptr<IntSetting> CreateGpuSetting(const CommandLine& command_line,
+                                        const BuildSettings& build_settings) {
+  // Bind to the starboard api, if applicable.
+  base::optional<int64_t> starboard_setting;
+  if (SbSystemHasCapability(kSbSystemCapabilityCanQueryGPUMemoryStats)) {
+    starboard_setting = SbSystemGetTotalGPUMemory();
+  }
+
+  scoped_ptr<IntSetting> gpu_setting =
+      CreateSystemMemorySetting(
+          switches::kMaxCobaltGpuUsage,
+          MemorySetting::kGPU,
+          command_line,
+          build_settings.max_gpu_in_bytes,
+          starboard_setting);
+
+  EnsureValuePositive(gpu_setting.get());
+  return gpu_setting.Pass();
+}
+
+scoped_ptr<IntSetting> CreateCpuSetting(const CommandLine& command_line,
+                                        const BuildSettings& build_settings) {
+  scoped_ptr<IntSetting> cpu_setting =
+      CreateSystemMemorySetting(
+          switches::kMaxCobaltGpuUsage,
+          MemorySetting::kCPU,
+          command_line,
+          build_settings.max_cpu_in_bytes,
+          SbSystemGetTotalCPUMemory());
+
+  EnsureValuePositive(cpu_setting.get());
+  return cpu_setting.Pass();
+}
+
 }  // namespace
 
 AutoMem::AutoMem(const math::Size& ui_resolution,
                  const CommandLine& command_line,
                  const BuildSettings& build_settings) {
-  // Set the misc cobalt engine size to a specific size.
-  misc_cobalt_cpu_size_in_bytes_.reset(
-      new IntSetting("misc_cobalt_cpu_size_in_bytes"));
-  misc_cobalt_cpu_size_in_bytes_->set_value(
-      MemorySetting::kAutoSet, kMiscCobaltSizeInBytes);
+  max_cpu_bytes_ = CreateCpuSetting(command_line, build_settings);
+  max_gpu_bytes_ = CreateGpuSetting(command_line, build_settings);
 
   // Set the ImageCache
   image_cache_size_in_bytes_ = CreateMemorySetting<IntSetting, int64_t>(
@@ -158,6 +214,21 @@
       kDefaultJsGarbageCollectionThresholdSize);
   EnsureValuePositive(javascript_gc_threshold_in_bytes_.get());
 
+  // Set the misc cobalt size to a specific size.
+  misc_cobalt_cpu_size_in_bytes_.reset(
+      new IntSetting("misc_cobalt_cpu_size_in_bytes"));
+  misc_cobalt_cpu_size_in_bytes_->set_value(
+      MemorySetting::kAutoSet, kMiscCobaltSizeInBytes);
+
+  // Set remote_type_face_cache size.
+  remote_typeface_cache_size_in_bytes_ =
+      CreateMemorySetting<IntSetting, int64_t>(
+        switches::kRemoteTypefaceCacheSizeInBytes,
+        command_line,
+        build_settings.remote_typeface_cache_capacity_in_bytes,
+        kDefaultRemoteTypeFaceCacheSize);
+  EnsureValuePositive(remote_typeface_cache_size_in_bytes_.get());
+
   // Set skia_atlas_texture_dimensions
   skia_atlas_texture_dimensions_ =
       CreateMemorySetting<DimensionSetting, TextureDimensions>(
@@ -212,6 +283,10 @@
   return misc_cobalt_cpu_size_in_bytes_.get();
 }
 
+const IntSetting* AutoMem::remote_typeface_cache_size_in_bytes() const {
+  return remote_typeface_cache_size_in_bytes_.get();
+}
+
 const IntSetting* AutoMem::image_cache_size_in_bytes() const {
   return image_cache_size_in_bytes_.get();
 }
@@ -250,6 +325,7 @@
   all_settings.push_back(image_cache_size_in_bytes_.get());
   all_settings.push_back(javascript_gc_threshold_in_bytes_.get());
   all_settings.push_back(misc_cobalt_cpu_size_in_bytes_.get());
+  all_settings.push_back(remote_typeface_cache_size_in_bytes_.get());
   all_settings.push_back(skia_atlas_texture_dimensions_.get());
   all_settings.push_back(skia_cache_size_in_bytes_.get());
   all_settings.push_back(software_surface_cache_size_in_bytes_.get());
@@ -266,7 +342,7 @@
   int64_t gpu_consumption =
       SumMemoryConsumption(MemorySetting::kGPU, all_settings);
 
-  ss << GenerateMemoryTable(GetTotalCpuMemory(), GetTotalGpuMemory(),
+  ss << GenerateMemoryTable(*max_cpu_bytes_, *max_gpu_bytes_,
                             cpu_consumption, gpu_consumption);
 
   std::string output_str = ss.str();
diff --git a/src/cobalt/browser/memory_settings/auto_mem.h b/src/cobalt/browser/memory_settings/auto_mem.h
index 4d81db6..ad3e143 100644
--- a/src/cobalt/browser/memory_settings/auto_mem.h
+++ b/src/cobalt/browser/memory_settings/auto_mem.h
@@ -45,10 +45,12 @@
   const IntSetting* image_cache_size_in_bytes() const;
   const IntSetting* javascript_gc_threshold_in_bytes() const;
   const IntSetting* misc_engine_cpu_size_in_bytes() const;
+  const IntSetting* remote_typeface_cache_size_in_bytes() const;
   const DimensionSetting* skia_atlas_texture_dimensions() const;
   const IntSetting* skia_cache_size_in_bytes() const;
   const IntSetting* software_surface_cache_size_in_bytes() const;
 
+  // AllMemorySettings - does not include cpu & gpu max memory.
   std::vector<const MemorySetting*> AllMemorySettings() const;
   std::vector<MemorySetting*> AllMemorySettingsMutable();
 
@@ -61,9 +63,14 @@
   scoped_ptr<IntSetting> image_cache_size_in_bytes_;
   scoped_ptr<IntSetting> javascript_gc_threshold_in_bytes_;
   scoped_ptr<IntSetting> misc_cobalt_cpu_size_in_bytes_;
+  scoped_ptr<IntSetting> remote_typeface_cache_size_in_bytes_;
   scoped_ptr<DimensionSetting> skia_atlas_texture_dimensions_;
   scoped_ptr<IntSetting> skia_cache_size_in_bytes_;
   scoped_ptr<IntSetting> software_surface_cache_size_in_bytes_;
+
+  // These settings are used for constraining the memory.
+  scoped_ptr<IntSetting> max_cpu_bytes_;
+  scoped_ptr<IntSetting> max_gpu_bytes_;
 };
 
 }  // namespace memory_settings
diff --git a/src/cobalt/browser/memory_settings/build_settings.cc b/src/cobalt/browser/memory_settings/build_settings.cc
index 32c151e..dcc75a3 100644
--- a/src/cobalt/browser/memory_settings/build_settings.cc
+++ b/src/cobalt/browser/memory_settings/build_settings.cc
@@ -16,6 +16,7 @@
 
 #include "cobalt/browser/memory_settings/build_settings.h"
 
+#include "base/optional.h"
 #include "cobalt/browser/memory_settings/constants.h"
 
 namespace cobalt {
@@ -46,6 +47,7 @@
   }
   return output;
 }
+
 }  // namespace
 
 BuildSettings GetDefaultBuildSettings() {
@@ -57,15 +59,24 @@
   settings.javascript_garbage_collection_threshold_in_bytes =
       MakeValidIfGreaterThanOrEqualToZero(
           COBALT_JS_GARBAGE_COLLECTION_THRESHOLD_IN_BYTES);
+  settings.remote_typeface_cache_capacity_in_bytes =
+      MakeValidIfGreaterThanOrEqualToZero(
+          COBALT_REMOTE_TYPEFACE_CACHE_SIZE_IN_BYTES);
   settings.skia_cache_size_in_bytes =
       MakeValidIfGreaterThanOrEqualToZero(COBALT_SKIA_CACHE_SIZE_IN_BYTES);
   settings.skia_texture_atlas_dimensions =
-      MakeDimensionsIfValid(TextureDimensions(COBALT_SKIA_GLYPH_ATLAS_WIDTH,
-                                              COBALT_SKIA_GLYPH_ATLAS_HEIGHT,
-                                              kSkiaGlyphAtlasTextureBytesPerPixel));
+      MakeDimensionsIfValid(
+          TextureDimensions(COBALT_SKIA_GLYPH_ATLAS_WIDTH,
+                            COBALT_SKIA_GLYPH_ATLAS_HEIGHT,
+                            kSkiaGlyphAtlasTextureBytesPerPixel));
   settings.software_surface_cache_size_in_bytes =
       MakeValidIfGreaterThanOrEqualToZero(
           COBALT_SOFTWARE_SURFACE_CACHE_SIZE_IN_BYTES);
+
+  settings.max_cpu_in_bytes =
+      MakeValidIfGreaterThanOrEqualToZero(COBALT_MAX_CPU_USAGE_IN_BYTES);
+  settings.max_gpu_in_bytes =
+      MakeValidIfGreaterThanOrEqualToZero(COBALT_MAX_GPU_USAGE_IN_BYTES);
   return settings;
 }
 
diff --git a/src/cobalt/browser/memory_settings/build_settings.h b/src/cobalt/browser/memory_settings/build_settings.h
index 3d71e31..aff96ee 100644
--- a/src/cobalt/browser/memory_settings/build_settings.h
+++ b/src/cobalt/browser/memory_settings/build_settings.h
@@ -27,13 +27,17 @@
 namespace memory_settings {
 
 struct BuildSettings {
-  BuildSettings() : has_blitter(false) {}
+  BuildSettings() : has_blitter(false), max_cpu_in_bytes(0) {}
   bool has_blitter;
   base::optional<int64_t> cobalt_image_cache_size_in_bytes;
   base::optional<int64_t> javascript_garbage_collection_threshold_in_bytes;
+  base::optional<int64_t> remote_typeface_cache_capacity_in_bytes;
   base::optional<int64_t> skia_cache_size_in_bytes;
   base::optional<TextureDimensions> skia_texture_atlas_dimensions;
   base::optional<int64_t> software_surface_cache_size_in_bytes;
+
+  base::optional<int64_t> max_cpu_in_bytes;
+  base::optional<int64_t> max_gpu_in_bytes;
 };
 
 BuildSettings GetDefaultBuildSettings();
diff --git a/src/cobalt/browser/memory_settings/constants.h b/src/cobalt/browser/memory_settings/constants.h
index 2826296..9f397eb 100644
--- a/src/cobalt/browser/memory_settings/constants.h
+++ b/src/cobalt/browser/memory_settings/constants.h
@@ -32,7 +32,7 @@
   kMinSkiaGlyphTextureAtlasWidth = 2048,
   kMinSkiaGlyphTextureAtlasHeight = 2048,
   kSkiaGlyphAtlasTextureBytesPerPixel = 2,
-
+  kDefaultRemoteTypeFaceCacheSize = 4 * 1024 * 1024,  // 4mb.
   kDefaultJsGarbageCollectionThresholdSize = 1 * 1024 * 1024,  // 1mb
 
   kMinSkiaCacheSize = 4 * 1024 * 1024,  // 4mb.
diff --git a/src/cobalt/browser/memory_settings/memory_settings.h b/src/cobalt/browser/memory_settings/memory_settings.h
index c1e3d80..6d27358 100644
--- a/src/cobalt/browser/memory_settings/memory_settings.h
+++ b/src/cobalt/browser/memory_settings/memory_settings.h
@@ -39,7 +39,7 @@
   // SourceType defines the location where the setting was set from.
   // kNotApplicable means the setting is not supported on the current system
   // configuration.
-  enum SourceType { kUnset, kCmdLine, kBuildSetting, kAutoSet };
+  enum SourceType { kUnset, kStarboardAPI, kBuildSetting, kCmdLine, kAutoSet };
   enum ClassType { kInt, kDimensions };
   enum MemoryType { kCPU, kGPU, kNotApplicable };
 
@@ -84,6 +84,11 @@
   virtual int64_t MemoryConsumption() const OVERRIDE;
 
   int64_t value() const { return valid() ? value_ : 0; }
+  base::optional<int64_t> optional_value() const {
+    base::optional<int64_t> output;
+    if (valid()) { output = value_; }
+    return output;
+  }
   void set_value(SourceType source_type, int64_t val) {
     source_type_ = source_type;
     value_ = val;
@@ -109,6 +114,12 @@
   TextureDimensions value() const {
     return valid() ? value_ : TextureDimensions();
   }
+  base::optional<TextureDimensions> optional_value() const {
+    base::optional<TextureDimensions> output;
+    if (valid()) { output = value_; }
+    return output;
+  }
+
   void set_value(SourceType source_type, const TextureDimensions& val) {
     source_type_ = source_type;
     value_ = val;
diff --git a/src/cobalt/browser/memory_settings/pretty_print.cc b/src/cobalt/browser/memory_settings/pretty_print.cc
index 298fe3f..c8fef61 100644
--- a/src/cobalt/browser/memory_settings/pretty_print.cc
+++ b/src/cobalt/browser/memory_settings/pretty_print.cc
@@ -39,12 +39,15 @@
     case MemorySetting::kUnset: {
       return "Unset";
     }
-    case MemorySetting::kCmdLine: {
-      return "CmdLine";
+    case MemorySetting::kStarboardAPI: {
+      return "Starboard API";
     }
     case MemorySetting::kBuildSetting: {
       return "Build";
     }
+    case MemorySetting::kCmdLine: {
+      return "CmdLine";
+    }
     case MemorySetting::kAutoSet: {
       return "AutoSet";
     }
@@ -96,7 +99,7 @@
   TablePrinter printer;
 
   std::vector<std::string> header;
-  header.push_back("NAME");
+  header.push_back("SETTING NAME");
   header.push_back("VALUE");
   header.push_back("");
   header.push_back("TYPE");
@@ -123,31 +126,33 @@
   return table_string;
 }
 
-std::string GenerateMemoryTable(int64_t total_cpu_memory,
-                                base::optional<int64_t> total_gpu_memory,
+std::string GenerateMemoryTable(const IntSetting& total_cpu_memory,
+                                const IntSetting& total_gpu_memory,
                                 int64_t settings_cpu_consumption,
                                 int64_t settings_gpu_consumption) {
   TablePrinter printer;
   std::vector<std::string> header;
-  header.push_back("TYPE");
+  header.push_back("MEMORY");
+  header.push_back("SOURCE");
   header.push_back("TOTAL");
-  header.push_back("SETTINGS");
+  header.push_back("SETTINGS CONSUME");
   printer.AddRow(header);
 
   std::vector<std::string> data_row;
-  data_row.push_back("CPU");
-  data_row.push_back(ToMegabyteString(total_cpu_memory));
+  data_row.push_back(total_cpu_memory.name());
+  data_row.push_back(StringifySourceType(&total_cpu_memory));
+  data_row.push_back(ToMegabyteString(total_cpu_memory.value()));
   data_row.push_back(ToMegabyteString(settings_cpu_consumption));
   printer.AddRow(data_row);
   data_row.clear();
 
-  data_row.push_back("GPU");
-
+  data_row.push_back(total_gpu_memory.name());
+  data_row.push_back(StringifySourceType(&total_gpu_memory));
   std::string total_gpu_consumption_str;
-  if (!total_gpu_memory) {
+  if (total_gpu_memory.value() <= 0) {
     total_gpu_consumption_str = "<UNKNOWN>";
   } else {
-    total_gpu_consumption_str = ToMegabyteString(*total_gpu_memory);
+    total_gpu_consumption_str = ToMegabyteString(total_gpu_memory.value());
   }
 
   data_row.push_back(total_gpu_consumption_str);
diff --git a/src/cobalt/browser/memory_settings/pretty_print.h b/src/cobalt/browser/memory_settings/pretty_print.h
index be70421..1960e75 100644
--- a/src/cobalt/browser/memory_settings/pretty_print.h
+++ b/src/cobalt/browser/memory_settings/pretty_print.h
@@ -64,8 +64,8 @@
 //  |______|__________|__________|
 // When optional total_gpu_memory is null then the the value in the output
 // table will be <UNKNOWN>.
-std::string GenerateMemoryTable(int64_t total_cpu_memory,
-                                base::optional<int64_t> total_gpu_memory,
+std::string GenerateMemoryTable(const IntSetting& total_cpu_memory,
+                                const IntSetting& total_gpu_memory,
                                 int64_t settings_cpu_consumption,
                                 int64_t settings_gpu_consumption);
 
diff --git a/src/cobalt/browser/memory_settings/pretty_print_test.cc b/src/cobalt/browser/memory_settings/pretty_print_test.cc
index ad5108e..f0bffb5 100644
--- a/src/cobalt/browser/memory_settings/pretty_print_test.cc
+++ b/src/cobalt/browser/memory_settings/pretty_print_test.cc
@@ -126,7 +126,7 @@
       GeneratePrettyPrintTable(setting_group.AsConstVector());
 
   const char* expected_string =
-      " NAME                                   VALUE                   TYPE   SOURCE    \n"
+      " SETTING NAME                           VALUE                   TYPE   SOURCE    \n"
       " _______________________________________________________________________________ \n"
       "|                                      |             |         |      |         |\n"
       "| image_cache_size_in_bytes            |        1234 |  0.0 MB |  GPU | CmdLine |\n"
@@ -147,43 +147,54 @@
   EXPECT_STREQ(expected_string, actual_string.c_str());
 }
 
-TEST(MemorySettingsPrettyPrint, GenerateMemoryTableWithNoGpuMemory) {
-  const base::optional<int64_t> no_gpu_memory;
+TEST(MemorySettingsPrettyPrint, GenerateMemoryTableWithUnsetGpuMemory) {
+  IntSetting cpu_memory_setting("max_cpu_memory");
+  cpu_memory_setting.set_value(
+      MemorySetting::kBuildSetting, 256 * 1024 * 1024);
+  IntSetting gpu_memory_setting("max_gpu_memory");
+
   std::string actual_output =
-      GenerateMemoryTable(256 * 1024 * 1024,  // 256 MB CPU available
-                          no_gpu_memory,
+      GenerateMemoryTable(cpu_memory_setting,  // 256 MB CPU available
+                          gpu_memory_setting,
                           128 * 1024 * 1024,  // 128 MB CPU consumption
                           0);                 // 0 MB GPU consumption.
 
   const char* expected_output =
-      " TYPE   TOTAL       SETTINGS   \n"
-      " _____________________________ \n"
-      "|      |           |          |\n"
-      "| CPU  |  256.0 MB | 128.0 MB |\n"
-      "|______|___________|__________|\n"
-      "|      |           |          |\n"
-      "| GPU  | <UNKNOWN> |   0.0 MB |\n"
-      "|______|___________|__________|\n";
+      " MEMORY           SOURCE   TOTAL       SETTINGS CONSUME   \n"
+      " ________________________________________________________ \n"
+      "|                |        |           |                  |\n"
+      "| max_cpu_memory |  Build |  256.0 MB |         128.0 MB |\n"
+      "|________________|________|___________|__________________|\n"
+      "|                |        |           |                  |\n"
+      "| max_gpu_memory |  Unset | <UNKNOWN> |           0.0 MB |\n"
+      "|________________|________|___________|__________________|\n";
 
   EXPECT_STREQ(expected_output, actual_output.c_str()) << actual_output;
 }
 
 TEST(MemorySettingsPrettyPrint, GenerateMemoryTableWithGpuMemory) {
+  IntSetting cpu_memory_setting("max_cpu_memory");
+  cpu_memory_setting.set_value(
+      MemorySetting::kBuildSetting, 256 * 1024 * 1024);
+  IntSetting gpu_memory_setting("max_gpu_memory");
+  gpu_memory_setting.set_value(
+      MemorySetting::kBuildSetting, 64 * 1024 * 1024);
+
   std::string actual_output =
-      GenerateMemoryTable(256 * 1024 * 1024,  // 256 MB CPU available.
-                          64 * 1024 * 1024,   // 64 MB GPU available.
+      GenerateMemoryTable(cpu_memory_setting,  // 256 MB CPU available.
+                          gpu_memory_setting,   // 64 MB GPU available.
                           128 * 1024 * 1024,  // 128 MB CPU consumption.
                           23592960);          // 22.5 MB GPU consumption.
 
   const char* expected_output =
-      " TYPE   TOTAL      SETTINGS   \n"
-      " ____________________________ \n"
-      "|      |          |          |\n"
-      "| CPU  | 256.0 MB | 128.0 MB |\n"
-      "|______|__________|__________|\n"
-      "|      |          |          |\n"
-      "| GPU  |  64.0 MB |  22.5 MB |\n"
-      "|______|__________|__________|\n";
+      " MEMORY           SOURCE   TOTAL      SETTINGS CONSUME   \n"
+      " _______________________________________________________ \n"
+      "|                |        |          |                  |\n"
+      "| max_cpu_memory |  Build | 256.0 MB |         128.0 MB |\n"
+      "|________________|________|__________|__________________|\n"
+      "|                |        |          |                  |\n"
+      "| max_gpu_memory |  Build |  64.0 MB |          22.5 MB |\n"
+      "|________________|________|__________|__________________|\n";
 
   EXPECT_STREQ(expected_output, actual_output.c_str()) << actual_output;
 }
@@ -196,7 +207,7 @@
       test_setting_group.AsConstVector());
 
   const char* expected_string =
-      " NAME                                   VALUE                   TYPE   SOURCE    \n"
+      " SETTING NAME                           VALUE                   TYPE   SOURCE    \n"
       " _______________________________________________________________________________ \n"
       "|                                      |             |         |      |         |\n"
       "| image_cache_size_in_bytes            |        1234 |  0.0 MB |  GPU | CmdLine |\n"
@@ -218,23 +229,29 @@
 }
 
 TEST(MemorySettingsPrettyPrint, GenerateMemoryWithInvalidGpuMemoryConsumption) {
+  IntSetting cpu_memory_setting("max_cpu_memory");
+  cpu_memory_setting.set_value(
+      MemorySetting::kBuildSetting, 256 * 1024 * 1024);
+  IntSetting gpu_memory_setting("max_gpu_memory");
+  gpu_memory_setting.set_value(MemorySetting::kStarboardAPI, 0);
+
   const base::optional<int64_t> no_gpu_memory;
   std::string actual_output = GenerateMemoryTable(
-      256 * 1024 * 1024,  // 256 MB CPU available.
-      no_gpu_memory,      // Signals that no gpu memory is available
-                          //   on this system.
-      128 * 1024 * 1024,  // 128 MB CPU consumption.
-      16 * 1024 * 1024);  // 16 MB GPU consumption.
+      cpu_memory_setting,  // 256 MB CPU available.
+      gpu_memory_setting,  // Signals that no gpu memory is available
+                           //   on this system.
+      128 * 1024 * 1024,   // 128 MB CPU consumption.
+      16 * 1024 * 1024);   // 16 MB GPU consumption.
 
   const char* expected_output =
-      " TYPE   TOTAL       SETTINGS   \n"
-      " _____________________________ \n"
-      "|      |           |          |\n"
-      "| CPU  |  256.0 MB | 128.0 MB |\n"
-      "|______|___________|__________|\n"
-      "|      |           |          |\n"
-      "| GPU  | <UNKNOWN> |  16.0 MB |\n"
-      "|______|___________|__________|\n";
+      " MEMORY           SOURCE          TOTAL       SETTINGS CONSUME   \n"
+      " _______________________________________________________________ \n"
+      "|                |               |           |                  |\n"
+      "| max_cpu_memory |         Build |  256.0 MB |         128.0 MB |\n"
+      "|________________|_______________|___________|__________________|\n"
+      "|                |               |           |                  |\n"
+      "| max_gpu_memory | Starboard API | <UNKNOWN> |          16.0 MB |\n"
+      "|________________|_______________|___________|__________________|\n";
 
   EXPECT_STREQ(expected_output, actual_output.c_str()) << actual_output;
 }
diff --git a/src/cobalt/browser/memory_tracker/tool.cc b/src/cobalt/browser/memory_tracker/tool.cc
index 72cb675..e37356a 100644
--- a/src/cobalt/browser/memory_tracker/tool.cc
+++ b/src/cobalt/browser/memory_tracker/tool.cc
@@ -23,6 +23,9 @@
 #include "cobalt/browser/memory_tracker/tool/compressed_time_series_tool.h"
 #include "cobalt/browser/memory_tracker/tool/leak_finder_tool.h"
 #include "cobalt/browser/memory_tracker/tool/log_writer_tool.h"
+#include "cobalt/browser/memory_tracker/tool/memory_size_binner_tool.h"
+#include "cobalt/browser/memory_tracker/tool/print_csv_tool.h"
+#include "cobalt/browser/memory_tracker/tool/print_tool.h"
 #include "cobalt/browser/memory_tracker/tool/tool_impl.h"
 #include "cobalt/browser/memory_tracker/tool/tool_thread.h"
 #include "nb/analytics/memory_tracker_helpers.h"
@@ -315,7 +318,7 @@
       memory_tracker->InstallGlobalTrackingHooks();
       // Create a thread that will continuously report javascript memory
       // analytics.
-      tool_ptr.reset(new MemorySizeBinner(tool_arg));
+      tool_ptr.reset(new MemorySizeBinnerTool(tool_arg));
       break;
     }
     case kAllocationLogger: {
diff --git a/src/cobalt/browser/memory_tracker/tool/compressed_time_series_tool.h b/src/cobalt/browser/memory_tracker/tool/compressed_time_series_tool.h
index caa5a6b..9852be4 100644
--- a/src/cobalt/browser/memory_tracker/tool/compressed_time_series_tool.h
+++ b/src/cobalt/browser/memory_tracker/tool/compressed_time_series_tool.h
@@ -18,6 +18,7 @@
 #include <string>
 
 #include "cobalt/browser/memory_tracker/tool/tool_impl.h"
+#include "cobalt/browser/memory_tracker/tool/util.h"
 #include "nb/analytics/memory_tracker.h"
 
 namespace cobalt {
diff --git a/src/cobalt/browser/memory_tracker/tool/memory_size_binner_tool.cc b/src/cobalt/browser/memory_tracker/tool/memory_size_binner_tool.cc
new file mode 100644
index 0000000..1865fd9
--- /dev/null
+++ b/src/cobalt/browser/memory_tracker/tool/memory_size_binner_tool.cc
@@ -0,0 +1,112 @@
+// Copyright 2017 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 "cobalt/browser/memory_tracker/tool/memory_size_binner_tool.h"
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "base/threading/platform_thread.h"
+#include "base/time.h"
+#include "cobalt/base/c_val.h"
+#include "cobalt/browser/memory_tracker/tool/util.h"
+#include "nb/analytics/memory_tracker.h"
+#include "nb/analytics/memory_tracker_helpers.h"
+#include "starboard/log.h"
+#include "starboard/types.h"
+
+namespace cobalt {
+namespace browser {
+namespace memory_tracker {
+namespace {
+
+const nb::analytics::AllocationGroup* FindAllocationGroup(
+    const std::string& name,
+    nb::analytics::MemoryTracker* memory_tracker) {
+  std::vector<const nb::analytics::AllocationGroup*> groups;
+  memory_tracker->GetAllocationGroups(&groups);
+  // Find by exact string match.
+  for (size_t i = 0; i < groups.size(); ++i) {
+    const nb::analytics::AllocationGroup* group = groups[i];
+    if (group->name().compare(name) == 0) {
+      return group;
+    }
+  }
+  return NULL;
+}
+}  // namespace.
+
+MemorySizeBinnerTool::MemorySizeBinnerTool(const std::string& memory_scope_name)
+    : memory_scope_name_(memory_scope_name) {}
+
+void MemorySizeBinnerTool::Run(Params* params) {
+  const nb::analytics::AllocationGroup* target_group = NULL;
+
+  while (!params->finished()) {
+    if (target_group == NULL && !memory_scope_name_.empty()) {
+      target_group =
+          FindAllocationGroup(memory_scope_name_, params->memory_tracker());
+    }
+
+    std::stringstream ss;
+    ss.precision(2);
+    if (target_group || memory_scope_name_.empty()) {
+      AllocationSizeBinner visitor_binner = AllocationSizeBinner(target_group);
+      params->memory_tracker()->Accept(&visitor_binner);
+
+      size_t min_size = 0;
+      size_t max_size = 0;
+
+      visitor_binner.GetLargestSizeRange(&min_size, &max_size);
+
+      FindTopSizes top_size_visitor =
+          FindTopSizes(min_size, max_size, target_group);
+      params->memory_tracker()->Accept(&top_size_visitor);
+
+      ss << kNewLine;
+      ss << "TimeNow " << params->TimeInMinutesString() << " (minutes):";
+      ss << kNewLine;
+      if (!memory_scope_name_.empty()) {
+        ss << "Tracking Memory Scope \"" << memory_scope_name_ << "\", ";
+      } else {
+        ss << "Tracking whole program, ";
+      }
+      ss << "first row is allocation size range, second row is number of "
+         << kNewLine << "allocations in that range." << kNewLine;
+      ss << visitor_binner.ToCSVString();
+      ss << kNewLine;
+      ss << "Largest allocation range: \"" << min_size << "..." << max_size
+         << "\"" << kNewLine;
+      ss << "Printing out top allocations from this range: " << kNewLine;
+      ss << top_size_visitor.ToString(5) << kNewLine;
+    } else {
+      ss << "No allocations for \"" << memory_scope_name_ << "\".";
+    }
+
+    params->logger()->Output(ss.str().c_str());
+    params->logger()->Flush();
+
+    // Sleep until the next sample.
+    base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
+  }
+}
+
+std::string MemorySizeBinnerTool::tool_name() const  {
+  return "MemoryTrackerCompressedTimeSeries";
+}
+
+}  // namespace memory_tracker
+}  // namespace browser
+}  // namespace cobalt
diff --git a/src/cobalt/browser/memory_tracker/tool/memory_size_binner_tool.h b/src/cobalt/browser/memory_tracker/tool/memory_size_binner_tool.h
new file mode 100644
index 0000000..b98a421
--- /dev/null
+++ b/src/cobalt/browser/memory_tracker/tool/memory_size_binner_tool.h
@@ -0,0 +1,49 @@
+// Copyright 2017 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 COBALT_BROWSER_MEMORY_TRACKER_TOOL_MEMORY_SIZE_BINNER_TOOL_H_
+#define COBALT_BROWSER_MEMORY_TRACKER_TOOL_MEMORY_SIZE_BINNER_TOOL_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "cobalt/browser/memory_tracker/tool/params.h"
+#include "cobalt/browser/memory_tracker/tool/tool_impl.h"
+
+namespace cobalt {
+namespace browser {
+namespace memory_tracker {
+
+// This tool inspects a memory scope and reports on the memory usage.
+// The output will be a CSV file printed to stdout representing
+// the number of memory allocations for objects. The objects are binned
+// according to the size of the memory allocation. Objects within the same
+// power of two are binned together. For example 1024 will be binned with 1025.
+class MemorySizeBinnerTool : public AbstractTool {
+ public:
+  // memory_scope_name represents the memory scope that is to be investigated.
+  explicit MemorySizeBinnerTool(const std::string& memory_scope_name);
+
+  virtual void Run(Params* params) OVERRIDE;
+  virtual std::string tool_name() const OVERRIDE;
+
+ private:
+  std::string memory_scope_name_;
+};
+
+}  // namespace memory_tracker
+}  // namespace browser
+}  // namespace cobalt
+
+#endif  // COBALT_BROWSER_MEMORY_TRACKER_TOOL_MEMORY_SIZE_BINNER_TOOL_H_
diff --git a/src/cobalt/browser/memory_tracker/tool/print_csv_tool.cc b/src/cobalt/browser/memory_tracker/tool/print_csv_tool.cc
new file mode 100644
index 0000000..51ef41f
--- /dev/null
+++ b/src/cobalt/browser/memory_tracker/tool/print_csv_tool.cc
@@ -0,0 +1,262 @@
+// Copyright 2017 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 "cobalt/browser/memory_tracker/tool/print_csv_tool.h"
+
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "cobalt/base/c_val.h"
+#include "cobalt/browser/memory_tracker/tool/util.h"
+#include "nb/analytics/memory_tracker.h"
+#include "nb/analytics/memory_tracker_helpers.h"
+#include "starboard/log.h"
+#include "starboard/types.h"
+
+namespace cobalt {
+namespace browser {
+namespace memory_tracker {
+
+PrintCSVTool::PrintCSVTool(int sampling_interval_ms, int sampling_time_ms)
+    : sample_interval_ms_(sampling_interval_ms),
+      sampling_time_ms_(sampling_time_ms) {}
+
+std::string PrintCSVTool::ToCsvString(const MapAllocationSamples& samples_in) {
+  typedef MapAllocationSamples Map;
+  typedef Map::const_iterator MapIt;
+
+  size_t largest_sample_size = 0;
+  size_t smallest_sample_size = INT_MAX;
+
+  // Sanitize samples_in and store as samples.
+  MapAllocationSamples samples;
+  for (MapIt it = samples_in.begin(); it != samples_in.end(); ++it) {
+    std::string name = it->first;
+    const AllocationSamples& value = it->second;
+
+    if (value.allocated_bytes_.size() != value.number_allocations_.size()) {
+      SB_NOTREACHED() << "Error at " << __FILE__ << ":" << __LINE__;
+      return "ERROR";
+    }
+
+    const size_t n = value.allocated_bytes_.size();
+    if (n > largest_sample_size) {
+      largest_sample_size = n;
+    }
+    if (n < smallest_sample_size) {
+      smallest_sample_size = n;
+    }
+
+    const bool duplicate_found = (samples.end() != samples.find(name));
+    if (duplicate_found) {
+      SB_NOTREACHED() << "Error, duplicate found for entry: " << name
+                      << kNewLine;
+    }
+    // Store value as a sanitized sample.
+    samples[name] = value;
+  }
+
+  SB_DCHECK(largest_sample_size == smallest_sample_size);
+
+  std::stringstream ss;
+
+  // Begin output to CSV.
+  // Sometimes we need to skip the CPU memory entry.
+  const MapIt total_cpu_memory_it = samples.find(UntrackedMemoryKey());
+
+  // Preamble
+  ss << kNewLine << "//////////////////////////////////////////////";
+  ss << kNewLine << "// CSV of bytes / allocation" << kNewLine;
+  // HEADER.
+  ss << "Name" << kDelimiter << kQuote << "Bytes/Alloc" << kQuote << kNewLine;
+  // DATA.
+  for (MapIt it = samples.begin(); it != samples.end(); ++it) {
+    if (total_cpu_memory_it == it) {
+      continue;
+    }
+
+    const AllocationSamples& samples = it->second;
+    if (samples.allocated_bytes_.empty() ||
+        samples.number_allocations_.empty()) {
+      SB_NOTREACHED() << "Should not be here";
+      return "ERROR";
+    }
+    const int64 n_allocs = samples.number_allocations_.back();
+    const int64 n_bytes = samples.allocated_bytes_.back();
+    int64 bytes_per_alloc = 0;
+    if (n_allocs > 0) {
+      bytes_per_alloc = n_bytes / n_allocs;
+    }
+    const std::string& name = it->first;
+    ss << kQuote << SanitizeCSVKey(name) << kQuote << kDelimiter
+       << bytes_per_alloc << kNewLine;
+  }
+  ss << kNewLine;
+
+  // Preamble
+  ss << kNewLine << "//////////////////////////////////////////////" << kNewLine
+     << "// CSV of bytes allocated per region (MB's)." << kNewLine
+     << "// Units are in Megabytes. This is designed" << kNewLine
+     << "// to be used in a stacked graph." << kNewLine;
+
+  // HEADER.
+  for (MapIt it = samples.begin(); it != samples.end(); ++it) {
+    if (total_cpu_memory_it == it) {
+      continue;
+    }
+    // Strip out any characters that could make parsing the csv difficult.
+    const std::string name = SanitizeCSVKey(it->first);
+    ss << kQuote << name << kQuote << kDelimiter;
+  }
+  // Save the total for last.
+  if (total_cpu_memory_it != samples.end()) {
+    const std::string& name = SanitizeCSVKey(total_cpu_memory_it->first);
+    ss << kQuote << name << kQuote << kDelimiter;
+  }
+  ss << kNewLine;
+
+  // Print out the values of each of the samples.
+  for (size_t i = 0; i < smallest_sample_size; ++i) {
+    for (MapIt it = samples.begin(); it != samples.end(); ++it) {
+      if (total_cpu_memory_it == it) {
+        continue;
+      }
+      const int64 alloc_bytes = it->second.allocated_bytes_[i];
+      // Convert to float megabytes with decimals of precision.
+      double n = alloc_bytes / (1000 * 10);
+      n = n / (100.);
+      ss << n << kDelimiter;
+    }
+    if (total_cpu_memory_it != samples.end()) {
+      const int64 alloc_bytes = total_cpu_memory_it->second.allocated_bytes_[i];
+      // Convert to float megabytes with decimals of precision.
+      double n = alloc_bytes / (1000 * 10);
+      n = n / (100.);
+      ss << n << kDelimiter;
+    }
+    ss << kNewLine;
+  }
+
+  ss << kNewLine;
+  // Preamble
+  ss << kNewLine << "//////////////////////////////////////////////";
+  ss << kNewLine << "// CSV of number of allocations per region." << kNewLine;
+
+  // HEADER
+  for (MapIt it = samples.begin(); it != samples.end(); ++it) {
+    if (total_cpu_memory_it == it) {
+      continue;
+    }
+    const std::string& name = SanitizeCSVKey(it->first);
+    ss << kQuote << name << kQuote << kDelimiter;
+  }
+  ss << kNewLine;
+  for (size_t i = 0; i < smallest_sample_size; ++i) {
+    for (MapIt it = samples.begin(); it != samples.end(); ++it) {
+      if (total_cpu_memory_it == it) {
+        continue;
+      }
+      const int64 n_allocs = it->second.number_allocations_[i];
+      ss << n_allocs << kDelimiter;
+    }
+    ss << kNewLine;
+  }
+  std::string output = ss.str();
+  return output;
+}
+
+const char* PrintCSVTool::UntrackedMemoryKey() { return "Untracked Memory"; }
+
+void PrintCSVTool::Run(Params* params) {
+  params->logger()->Output("\nMemoryTrackerPrintCSVThread is sampling...\n");
+  int sample_count = 0;
+  MapAllocationSamples map_samples;
+
+  while (!TimeExpiredYet(*params) && !params->finished()) {
+    // Sample total memory used by the system.
+    nb::analytics::MemoryStats mem_stats =
+        nb::analytics::GetProcessMemoryStats();
+    int64 untracked_used_memory =
+        mem_stats.used_cpu_memory + mem_stats.used_gpu_memory;
+
+    std::vector<const nb::analytics::AllocationGroup*> vector_output;
+    params->memory_tracker()->GetAllocationGroups(&vector_output);
+
+    // Sample all known memory scopes.
+    for (size_t i = 0; i < vector_output.size(); ++i) {
+      const nb::analytics::AllocationGroup* group = vector_output[i];
+      const std::string& name = group->name();
+
+      const bool first_creation =
+          map_samples.find(group->name()) == map_samples.end();
+
+      AllocationSamples* new_entry = &(map_samples[name]);
+
+      // Didn't see it before so create new entry.
+      if (first_creation) {
+        // Make up for lost samples...
+        new_entry->allocated_bytes_.resize(sample_count, 0);
+        new_entry->number_allocations_.resize(sample_count, 0);
+      }
+
+      int32 num_allocs = -1;
+      int64 allocation_bytes = -1;
+      group->GetAggregateStats(&num_allocs, &allocation_bytes);
+
+      new_entry->allocated_bytes_.push_back(allocation_bytes);
+      new_entry->number_allocations_.push_back(num_allocs);
+
+      untracked_used_memory -= allocation_bytes;
+    }
+
+    // Now push in remaining total.
+    AllocationSamples* process_sample = &(map_samples[UntrackedMemoryKey()]);
+    if (untracked_used_memory < 0) {
+      // On some platforms, total GPU memory may not be correctly reported.
+      // However the allocations from the GPU memory may be reported. In this
+      // case untracked_used_memory will go negative. To protect the memory
+      // reporting the untracked_used_memory is set to 0 so that it doesn't
+      // cause an error in reporting.
+      untracked_used_memory = 0;
+    }
+    process_sample->allocated_bytes_.push_back(untracked_used_memory);
+    process_sample->number_allocations_.push_back(-1);
+
+    ++sample_count;
+    base::PlatformThread::Sleep(
+        base::TimeDelta::FromMilliseconds(sample_interval_ms_));
+  }
+
+  std::stringstream ss;
+  ss.precision(2);
+  ss << "Time now: " << params->TimeInMinutesString() << ",\n";
+  ss << ToCsvString(map_samples);
+  params->logger()->Output(ss.str().c_str());
+  params->logger()->Flush();
+  // Prevents the "thread exited code 0" from being interleaved into the
+  // output. This happens if flush is not implemented correctly in the system.
+  base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
+}
+
+bool PrintCSVTool::TimeExpiredYet(const Params& params) {
+  base::TimeDelta dt = params.time_since_start();
+  int64 dt_ms = dt.InMilliseconds();
+  const bool expired_time = dt_ms > sampling_time_ms_;
+  return expired_time;
+}
+
+}  // namespace memory_tracker
+}  // namespace browser
+}  // namespace cobalt
diff --git a/src/cobalt/browser/memory_tracker/tool/print_csv_tool.h b/src/cobalt/browser/memory_tracker/tool/print_csv_tool.h
new file mode 100644
index 0000000..cd54b8e
--- /dev/null
+++ b/src/cobalt/browser/memory_tracker/tool/print_csv_tool.h
@@ -0,0 +1,63 @@
+// Copyright 2017 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 COBALT_BROWSER_MEMORY_TRACKER_TOOL_PRINT_CSV_TOOL_H_
+#define COBALT_BROWSER_MEMORY_TRACKER_TOOL_PRINT_CSV_TOOL_H_
+
+#include <map>
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "cobalt/browser/memory_tracker/tool/params.h"
+#include "cobalt/browser/memory_tracker/tool/tool_impl.h"
+
+namespace cobalt {
+namespace browser {
+namespace memory_tracker {
+
+// Generates CSV values of the engine.
+// There are three sections of data including:
+//   1. average bytes / alloc
+//   2. # Bytes allocated per memory scope.
+//   3. # Allocations per memory scope.
+// This data can be pasted directly into a Google spreadsheet and visualized.
+// Note that this thread will implicitly call Start() is called during
+// construction and Cancel() & Join() during destruction.
+class PrintCSVTool : public AbstractTool {
+ public:
+  // This tool will only produce on CSV dump of the engine. This is useful
+  // for profiling startup memory consumption.
+  PrintCSVTool(int sampling_interval_ms, int sampling_time_ms);
+
+  // Overridden so that the thread can exit gracefully.
+  virtual void Run(Params* params) OVERRIDE;
+  virtual std::string tool_name() const OVERRIDE {
+    return "MemoryTrackerPrintCSV";
+  }
+
+ private:
+  typedef std::map<std::string, AllocationSamples> MapAllocationSamples;
+  static std::string ToCsvString(const MapAllocationSamples& samples);
+  static const char* UntrackedMemoryKey();
+  bool TimeExpiredYet(const Params& params);
+
+  const int sample_interval_ms_;
+  const int sampling_time_ms_;
+};
+
+}  // namespace memory_tracker
+}  // namespace browser
+}  // namespace cobalt
+
+#endif  // COBALT_BROWSER_MEMORY_TRACKER_TOOL_PRINT_CSV_TOOL_H_
diff --git a/src/cobalt/browser/memory_tracker/tool/print_tool.cc b/src/cobalt/browser/memory_tracker/tool/print_tool.cc
new file mode 100644
index 0000000..f896f2f
--- /dev/null
+++ b/src/cobalt/browser/memory_tracker/tool/print_tool.cc
@@ -0,0 +1,189 @@
+// Copyright 2017 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 "cobalt/browser/memory_tracker/tool/print_tool.h"
+
+#include <map>
+#include <sstream>
+#include <string>
+#include <vector>
+
+#include "base/basictypes.h"
+#include "base/threading/platform_thread.h"
+#include "cobalt/base/c_val.h"
+#include "cobalt/browser/memory_tracker/tool/util.h"
+#include "nb/analytics/memory_tracker.h"
+#include "nb/analytics/memory_tracker_helpers.h"
+#include "starboard/log.h"
+#include "starboard/types.h"
+
+namespace cobalt {
+namespace browser {
+namespace memory_tracker {
+
+using nb::analytics::AllocationGroup;
+
+class PrintTool::CvalsMap {
+ public:
+  typedef base::CVal<base::cval::SizeInBytes> CValType;
+
+  ~CvalsMap() {
+    while (!map_.empty()) {
+      MapCvals::iterator it = map_.begin();
+      delete it->second;
+      map_.erase(it);
+    }
+  }
+
+  void Update(const std::string& name, size_t value) {
+    std::string cval_name = GetCvalName(name);
+    CValType*& val = map_[cval_name];
+    if (!val) {
+      // Create if not found.
+      val = new CValType(cval_name, 0,
+                         "Automatically generated by the "
+                         "browser::memory_tracker system.");
+    }
+    (*val) = value;
+  }
+
+  static std::string GetCvalName(const std::string& name) {
+    std::stringstream ss;
+    ss << "Memory.Scope." << name;
+    return ss.str();
+  }
+
+ private:
+  typedef std::map<std::string, CValType*> MapCvals;
+  MapCvals map_;
+};
+
+PrintTool::PrintTool() : cvals_map_(new CvalsMap) {}
+
+PrintTool::~PrintTool() {}
+
+void PrintTool::Run(Params* params) {
+  const std::string kSeperator =
+      "--------------------------------------------------";
+
+  while (!params->finished()) {
+    std::vector<const AllocationGroup*> vector_output;
+    params->memory_tracker()->GetAllocationGroups(&vector_output);
+
+    typedef std::map<std::string, const AllocationGroup*> Map;
+    typedef Map::const_iterator MapIt;
+
+    Map output;
+    for (size_t i = 0; i < vector_output.size(); ++i) {
+      const AllocationGroup* group = vector_output[i];
+      output[group->name()] = group;
+    }
+
+    int32 num_allocs = 0;
+    int64 total_bytes = 0;
+
+    struct F {
+      static void PrintRow(std::stringstream* ss, const std::string& v1,
+                           const std::string& v2, const std::string& v3) {
+        ss->width(25);
+        *ss << std::left << v1;
+        ss->width(13);
+        *ss << std::right << v2 << "  ";
+        ss->width(10);
+        *ss << std::right << v3 << "\n";
+      }
+    };
+
+    if (params->memory_tracker()->IsMemoryTrackingEnabled()) {
+      // If this isn't true then it would cause an infinite loop. The
+      // following will likely crash.
+      SB_DCHECK(false) << "Unexpected, memory tracking should be disabled.";
+    }
+
+    std::stringstream ss;
+
+    ss << kNewLine;
+    ss << "TimeNow " << params->TimeInMinutesString()
+       << " (minutes):" << kNewLine << kNewLine;
+
+    ss << kSeperator << kNewLine;
+    nb::analytics::MemoryStats memstats =
+        nb::analytics::GetProcessMemoryStats();
+
+    F::PrintRow(&ss, "MALLOC STAT", "IN USE BYTES", "");
+    ss << kSeperator << kNewLine;
+    F::PrintRow(&ss, "Total CPU Reserved",
+                NumberFormatWithCommas(memstats.total_cpu_memory), "");
+
+    F::PrintRow(&ss, "Total CPU Used",
+                NumberFormatWithCommas(memstats.used_cpu_memory), "");
+
+    F::PrintRow(&ss, "Total GPU Reserved",
+                NumberFormatWithCommas(memstats.total_gpu_memory), "");
+
+    F::PrintRow(&ss, "Total GPU Used",
+                NumberFormatWithCommas(memstats.used_gpu_memory), "");
+
+    ss << kSeperator << kNewLine << kNewLine;
+
+    ss << kSeperator << kNewLine;
+    F::PrintRow(&ss, "MEMORY REGION", "IN USE BYTES", "NUM ALLOCS");
+    ss << kSeperator << kNewLine;
+
+    for (MapIt it = output.begin(); it != output.end(); ++it) {
+      const AllocationGroup* group = it->second;
+      if (!group) {
+        continue;
+      }
+
+      int32 num_group_allocs = -1;
+      int64 total_group_bytes = -1;
+
+      group->GetAggregateStats(&num_group_allocs, &total_group_bytes);
+      SB_DCHECK(-1 != num_group_allocs);
+      SB_DCHECK(-1 != total_group_bytes);
+
+      cvals_map_->Update(group->name(), static_cast<size_t>(total_group_bytes));
+
+      num_allocs += num_group_allocs;
+      total_bytes += total_group_bytes;
+
+      F::PrintRow(&ss, it->first, NumberFormatWithCommas(total_group_bytes),
+                  NumberFormatWithCommas(num_group_allocs));
+    }
+
+    cvals_map_->Update("Total", static_cast<size_t>(total_bytes));
+
+    ss << kNewLine;
+
+    F::PrintRow(&ss, "Total (in groups above)",
+                NumberFormatWithCommas(total_bytes),
+                NumberFormatWithCommas(num_allocs));
+
+    ss << kSeperator << kNewLine;
+    ss << kNewLine << kNewLine;
+
+    params->logger()->Output(ss.str().c_str());
+    // Output once every 5 seconds.
+    base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(5));
+  }
+}
+
+std::string PrintTool::tool_name() const  {
+  return "MemoryTrackerPrintThread";
+}
+
+}  // namespace memory_tracker
+}  // namespace browser
+}  // namespace cobalt
diff --git a/src/cobalt/browser/memory_tracker/tool/print_tool.h b/src/cobalt/browser/memory_tracker/tool/print_tool.h
new file mode 100644
index 0000000..d4bdcdd
--- /dev/null
+++ b/src/cobalt/browser/memory_tracker/tool/print_tool.h
@@ -0,0 +1,48 @@
+// Copyright 2017 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 COBALT_BROWSER_MEMORY_TRACKER_TOOL_PRINT_TOOL_H_
+#define COBALT_BROWSER_MEMORY_TRACKER_TOOL_PRINT_TOOL_H_
+
+#include <string>
+
+#include "base/compiler_specific.h"
+#include "cobalt/browser/memory_tracker/tool/params.h"
+#include "cobalt/browser/memory_tracker/tool/tool_impl.h"
+
+namespace cobalt {
+namespace browser {
+namespace memory_tracker {
+
+// Start() is called when this object is created, and Cancel() & Join() are
+// called during destruction.
+class PrintTool : public AbstractTool {
+ public:
+  PrintTool();
+  ~PrintTool() OVERRIDE;
+
+  // Overridden so that the thread can exit gracefully.
+  virtual void Run(Params* params) OVERRIDE;
+  virtual std::string tool_name() const OVERRIDE;
+
+ private:
+  class CvalsMap;
+  scoped_ptr<CvalsMap> cvals_map_;
+};
+
+}  // namespace memory_tracker
+}  // namespace browser
+}  // namespace cobalt
+
+#endif  // COBALT_BROWSER_MEMORY_TRACKER_TOOL_PRINT_TOOL_H_
diff --git a/src/cobalt/browser/memory_tracker/tool/tool_impl.cc b/src/cobalt/browser/memory_tracker/tool/tool_impl.cc
index 3f32416..01634e0 100644
--- a/src/cobalt/browser/memory_tracker/tool/tool_impl.cc
+++ b/src/cobalt/browser/memory_tracker/tool/tool_impl.cc
@@ -52,447 +52,6 @@
 using nb::analytics::MemoryStats;
 using nb::analytics::MemoryTracker;
 
-class PrintTool::CvalsMap {
- public:
-  typedef base::CVal<base::cval::SizeInBytes> CValType;
-
-  ~CvalsMap() {
-    while (!map_.empty()) {
-      MapCvals::iterator it = map_.begin();
-      delete it->second;
-      map_.erase(it);
-    }
-  }
-
-  void Update(const std::string& name, size_t value) {
-    std::string cval_name = GetCvalName(name);
-    CValType*& val = map_[cval_name];
-    if (!val) {
-      // Create if not found.
-      val = new CValType(cval_name, 0,
-                         "Automatically generated by the "
-                         "browser::memory_tracker system.");
-    }
-    (*val) = value;
-  }
-
-  static std::string GetCvalName(const std::string& name) {
-    std::stringstream ss;
-    ss << "Memory.Scope." << name;
-    return ss.str();
-  }
-
- private:
-  typedef std::map<std::string, CValType*> MapCvals;
-  MapCvals map_;
-};
-
-PrintTool::PrintTool() : cvals_map_(new CvalsMap) {}
-
-PrintTool::~PrintTool() {}
-
-void PrintTool::Run(Params* params) {
-  const std::string kSeperator =
-      "--------------------------------------------------";
-
-  while (!params->finished()) {
-    std::vector<const AllocationGroup*> vector_output;
-    params->memory_tracker()->GetAllocationGroups(&vector_output);
-
-    typedef std::map<std::string, const AllocationGroup*> Map;
-    typedef Map::const_iterator MapIt;
-
-    Map output;
-    for (size_t i = 0; i < vector_output.size(); ++i) {
-      const AllocationGroup* group = vector_output[i];
-      output[group->name()] = group;
-    }
-
-    int32 num_allocs = 0;
-    int64 total_bytes = 0;
-
-    struct F {
-      static void PrintRow(std::stringstream* ss, const std::string& v1,
-                           const std::string& v2, const std::string& v3) {
-        ss->width(25);
-        *ss << std::left << v1;
-        ss->width(13);
-        *ss << std::right << v2 << "  ";
-        ss->width(10);
-        *ss << std::right << v3 << "\n";
-      }
-    };
-
-    if (params->memory_tracker()->IsMemoryTrackingEnabled()) {
-      // If this isn't true then it would cause an infinite loop. The
-      // following will likely crash.
-      SB_DCHECK(false) << "Unexpected, memory tracking should be disabled.";
-    }
-
-    std::stringstream ss;
-
-    ss << kNewLine;
-    ss << "TimeNow " << params->TimeInMinutesString()
-       << " (minutes):" << kNewLine << kNewLine;
-
-    ss << kSeperator << kNewLine;
-    MemoryStats memstats = GetProcessMemoryStats();
-
-    F::PrintRow(&ss, "MALLOC STAT", "IN USE BYTES", "");
-    ss << kSeperator << kNewLine;
-    F::PrintRow(&ss, "Total CPU Reserved",
-                NumberFormatWithCommas(memstats.total_cpu_memory), "");
-
-    F::PrintRow(&ss, "Total CPU Used",
-                NumberFormatWithCommas(memstats.used_cpu_memory), "");
-
-    F::PrintRow(&ss, "Total GPU Reserved",
-                NumberFormatWithCommas(memstats.total_gpu_memory), "");
-
-    F::PrintRow(&ss, "Total GPU Used",
-                NumberFormatWithCommas(memstats.used_gpu_memory), "");
-
-    ss << kSeperator << kNewLine << kNewLine;
-
-    ss << kSeperator << kNewLine;
-    F::PrintRow(&ss, "MEMORY REGION", "IN USE BYTES", "NUM ALLOCS");
-    ss << kSeperator << kNewLine;
-
-    for (MapIt it = output.begin(); it != output.end(); ++it) {
-      const AllocationGroup* group = it->second;
-      if (!group) {
-        continue;
-      }
-
-      int32 num_group_allocs = -1;
-      int64 total_group_bytes = -1;
-
-      group->GetAggregateStats(&num_group_allocs, &total_group_bytes);
-      SB_DCHECK(-1 != num_group_allocs);
-      SB_DCHECK(-1 != total_group_bytes);
-
-      cvals_map_->Update(group->name(), static_cast<size_t>(total_group_bytes));
-
-      num_allocs += num_group_allocs;
-      total_bytes += total_group_bytes;
-
-      F::PrintRow(&ss, it->first, NumberFormatWithCommas(total_group_bytes),
-                  NumberFormatWithCommas(num_group_allocs));
-    }
-
-    cvals_map_->Update("Total", static_cast<size_t>(total_bytes));
-
-    ss << kNewLine;
-
-    F::PrintRow(&ss, "Total (in groups above)",
-                NumberFormatWithCommas(total_bytes),
-                NumberFormatWithCommas(num_allocs));
-
-    ss << kSeperator << kNewLine;
-    ss << kNewLine << kNewLine;
-
-    params->logger()->Output(ss.str().c_str());
-    // Output once every 5 seconds.
-    base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(5));
-  }
-}
-
-PrintCSVTool::PrintCSVTool(int sampling_interval_ms, int sampling_time_ms)
-    : sample_interval_ms_(sampling_interval_ms),
-      sampling_time_ms_(sampling_time_ms) {}
-
-std::string PrintCSVTool::ToCsvString(const MapAllocationSamples& samples_in) {
-  typedef MapAllocationSamples Map;
-  typedef Map::const_iterator MapIt;
-
-  size_t largest_sample_size = 0;
-  size_t smallest_sample_size = INT_MAX;
-
-  // Sanitize samples_in and store as samples.
-  MapAllocationSamples samples;
-  for (MapIt it = samples_in.begin(); it != samples_in.end(); ++it) {
-    std::string name = it->first;
-    const AllocationSamples& value = it->second;
-
-    if (value.allocated_bytes_.size() != value.number_allocations_.size()) {
-      SB_NOTREACHED() << "Error at " << __FILE__ << ":" << __LINE__;
-      return "ERROR";
-    }
-
-    const size_t n = value.allocated_bytes_.size();
-    if (n > largest_sample_size) {
-      largest_sample_size = n;
-    }
-    if (n < smallest_sample_size) {
-      smallest_sample_size = n;
-    }
-
-    const bool duplicate_found = (samples.end() != samples.find(name));
-    if (duplicate_found) {
-      SB_NOTREACHED() << "Error, duplicate found for entry: " << name
-                      << kNewLine;
-    }
-    // Store value as a sanitized sample.
-    samples[name] = value;
-  }
-
-  SB_DCHECK(largest_sample_size == smallest_sample_size);
-
-  std::stringstream ss;
-
-  // Begin output to CSV.
-  // Sometimes we need to skip the CPU memory entry.
-  const MapIt total_cpu_memory_it = samples.find(UntrackedMemoryKey());
-
-  // Preamble
-  ss << kNewLine << "//////////////////////////////////////////////";
-  ss << kNewLine << "// CSV of bytes / allocation" << kNewLine;
-  // HEADER.
-  ss << "Name" << kDelimiter << kQuote << "Bytes/Alloc" << kQuote << kNewLine;
-  // DATA.
-  for (MapIt it = samples.begin(); it != samples.end(); ++it) {
-    if (total_cpu_memory_it == it) {
-      continue;
-    }
-
-    const AllocationSamples& samples = it->second;
-    if (samples.allocated_bytes_.empty() ||
-        samples.number_allocations_.empty()) {
-      SB_NOTREACHED() << "Should not be here";
-      return "ERROR";
-    }
-    const int64 n_allocs = samples.number_allocations_.back();
-    const int64 n_bytes = samples.allocated_bytes_.back();
-    int64 bytes_per_alloc = 0;
-    if (n_allocs > 0) {
-      bytes_per_alloc = n_bytes / n_allocs;
-    }
-    const std::string& name = it->first;
-    ss << kQuote << SanitizeCSVKey(name) << kQuote << kDelimiter
-       << bytes_per_alloc << kNewLine;
-  }
-  ss << kNewLine;
-
-  // Preamble
-  ss << kNewLine << "//////////////////////////////////////////////" << kNewLine
-     << "// CSV of bytes allocated per region (MB's)." << kNewLine
-     << "// Units are in Megabytes. This is designed" << kNewLine
-     << "// to be used in a stacked graph." << kNewLine;
-
-  // HEADER.
-  for (MapIt it = samples.begin(); it != samples.end(); ++it) {
-    if (total_cpu_memory_it == it) {
-      continue;
-    }
-    // Strip out any characters that could make parsing the csv difficult.
-    const std::string name = SanitizeCSVKey(it->first);
-    ss << kQuote << name << kQuote << kDelimiter;
-  }
-  // Save the total for last.
-  if (total_cpu_memory_it != samples.end()) {
-    const std::string& name = SanitizeCSVKey(total_cpu_memory_it->first);
-    ss << kQuote << name << kQuote << kDelimiter;
-  }
-  ss << kNewLine;
-
-  // Print out the values of each of the samples.
-  for (size_t i = 0; i < smallest_sample_size; ++i) {
-    for (MapIt it = samples.begin(); it != samples.end(); ++it) {
-      if (total_cpu_memory_it == it) {
-        continue;
-      }
-      const int64 alloc_bytes = it->second.allocated_bytes_[i];
-      // Convert to float megabytes with decimals of precision.
-      double n = alloc_bytes / (1000 * 10);
-      n = n / (100.);
-      ss << n << kDelimiter;
-    }
-    if (total_cpu_memory_it != samples.end()) {
-      const int64 alloc_bytes = total_cpu_memory_it->second.allocated_bytes_[i];
-      // Convert to float megabytes with decimals of precision.
-      double n = alloc_bytes / (1000 * 10);
-      n = n / (100.);
-      ss << n << kDelimiter;
-    }
-    ss << kNewLine;
-  }
-
-  ss << kNewLine;
-  // Preamble
-  ss << kNewLine << "//////////////////////////////////////////////";
-  ss << kNewLine << "// CSV of number of allocations per region." << kNewLine;
-
-  // HEADER
-  for (MapIt it = samples.begin(); it != samples.end(); ++it) {
-    if (total_cpu_memory_it == it) {
-      continue;
-    }
-    const std::string& name = SanitizeCSVKey(it->first);
-    ss << kQuote << name << kQuote << kDelimiter;
-  }
-  ss << kNewLine;
-  for (size_t i = 0; i < smallest_sample_size; ++i) {
-    for (MapIt it = samples.begin(); it != samples.end(); ++it) {
-      if (total_cpu_memory_it == it) {
-        continue;
-      }
-      const int64 n_allocs = it->second.number_allocations_[i];
-      ss << n_allocs << kDelimiter;
-    }
-    ss << kNewLine;
-  }
-  std::string output = ss.str();
-  return output;
-}
-
-const char* PrintCSVTool::UntrackedMemoryKey() { return "Untracked Memory"; }
-
-void PrintCSVTool::Run(Params* params) {
-  params->logger()->Output("\nMemoryTrackerPrintCSVThread is sampling...\n");
-  int sample_count = 0;
-  MapAllocationSamples map_samples;
-
-  while (!TimeExpiredYet(*params) && !params->finished()) {
-    // Sample total memory used by the system.
-    MemoryStats mem_stats = GetProcessMemoryStats();
-    int64 untracked_used_memory =
-        mem_stats.used_cpu_memory + mem_stats.used_gpu_memory;
-
-    std::vector<const AllocationGroup*> vector_output;
-    params->memory_tracker()->GetAllocationGroups(&vector_output);
-
-    // Sample all known memory scopes.
-    for (size_t i = 0; i < vector_output.size(); ++i) {
-      const AllocationGroup* group = vector_output[i];
-      const std::string& name = group->name();
-
-      const bool first_creation =
-          map_samples.find(group->name()) == map_samples.end();
-
-      AllocationSamples* new_entry = &(map_samples[name]);
-
-      // Didn't see it before so create new entry.
-      if (first_creation) {
-        // Make up for lost samples...
-        new_entry->allocated_bytes_.resize(sample_count, 0);
-        new_entry->number_allocations_.resize(sample_count, 0);
-      }
-
-      int32 num_allocs = -1;
-      int64 allocation_bytes = -1;
-      group->GetAggregateStats(&num_allocs, &allocation_bytes);
-
-      new_entry->allocated_bytes_.push_back(allocation_bytes);
-      new_entry->number_allocations_.push_back(num_allocs);
-
-      untracked_used_memory -= allocation_bytes;
-    }
-
-    // Now push in remaining total.
-    AllocationSamples* process_sample = &(map_samples[UntrackedMemoryKey()]);
-    if (untracked_used_memory < 0) {
-      // On some platforms, total GPU memory may not be correctly reported.
-      // However the allocations from the GPU memory may be reported. In this
-      // case untracked_used_memory will go negative. To protect the memory
-      // reporting the untracked_used_memory is set to 0 so that it doesn't
-      // cause an error in reporting.
-      untracked_used_memory = 0;
-    }
-    process_sample->allocated_bytes_.push_back(untracked_used_memory);
-    process_sample->number_allocations_.push_back(-1);
-
-    ++sample_count;
-    base::PlatformThread::Sleep(
-        base::TimeDelta::FromMilliseconds(sample_interval_ms_));
-  }
-
-  std::stringstream ss;
-  ss.precision(2);
-  ss << "Time now: " << params->TimeInMinutesString() << ",\n";
-  ss << ToCsvString(map_samples);
-  params->logger()->Output(ss.str().c_str());
-  params->logger()->Flush();
-  // Prevents the "thread exited code 0" from being interleaved into the
-  // output. This happens if flush is not implemented correctly in the system.
-  base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
-}
-
-bool PrintCSVTool::TimeExpiredYet(const Params& params) {
-  base::TimeDelta dt = params.time_since_start();
-  int64 dt_ms = dt.InMilliseconds();
-  const bool expired_time = dt_ms > sampling_time_ms_;
-  return expired_time;
-}
-
-MemorySizeBinner::MemorySizeBinner(const std::string& memory_scope_name)
-    : memory_scope_name_(memory_scope_name) {}
-
-const AllocationGroup* FindAllocationGroup(const std::string& name,
-                                           MemoryTracker* memory_tracker) {
-  std::vector<const AllocationGroup*> groups;
-  memory_tracker->GetAllocationGroups(&groups);
-  // Find by exact string match.
-  for (size_t i = 0; i < groups.size(); ++i) {
-    const AllocationGroup* group = groups[i];
-    if (group->name().compare(name) == 0) {
-      return group;
-    }
-  }
-  return NULL;
-}
-
-void MemorySizeBinner::Run(Params* params) {
-  const AllocationGroup* target_group = NULL;
-
-  while (!params->finished()) {
-    if (target_group == NULL && !memory_scope_name_.empty()) {
-      target_group =
-          FindAllocationGroup(memory_scope_name_, params->memory_tracker());
-    }
-
-    std::stringstream ss;
-    ss.precision(2);
-    if (target_group || memory_scope_name_.empty()) {
-      AllocationSizeBinner visitor_binner = AllocationSizeBinner(target_group);
-      params->memory_tracker()->Accept(&visitor_binner);
-
-      size_t min_size = 0;
-      size_t max_size = 0;
-
-      visitor_binner.GetLargestSizeRange(&min_size, &max_size);
-
-      FindTopSizes top_size_visitor =
-          FindTopSizes(min_size, max_size, target_group);
-      params->memory_tracker()->Accept(&top_size_visitor);
-
-      ss << kNewLine;
-      ss << "TimeNow " << params->TimeInMinutesString() << " (minutes):";
-      ss << kNewLine;
-      if (!memory_scope_name_.empty()) {
-        ss << "Tracking Memory Scope \"" << memory_scope_name_ << "\", ";
-      } else {
-        ss << "Tracking whole program, ";
-      }
-      ss << "first row is allocation size range, second row is number of "
-         << kNewLine << "allocations in that range." << kNewLine;
-      ss << visitor_binner.ToCSVString();
-      ss << kNewLine;
-      ss << "Largest allocation range: \"" << min_size << "..." << max_size
-         << "\"" << kNewLine;
-      ss << "Printing out top allocations from this range: " << kNewLine;
-      ss << top_size_visitor.ToString(5) << kNewLine;
-    } else {
-      ss << "No allocations for \"" << memory_scope_name_ << "\".";
-    }
-
-    params->logger()->Output(ss.str().c_str());
-    params->logger()->Flush();
-
-    // Sleep until the next sample.
-    base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(1));
-  }
-}
-
 size_t AllocationSizeBinner::GetBucketIndexForAllocationSize(size_t size) {
   for (int i = 0; i < 32; ++i) {
     size_t val = 0x1 << i;
diff --git a/src/cobalt/browser/memory_tracker/tool/tool_impl.h b/src/cobalt/browser/memory_tracker/tool/tool_impl.h
index 5141d6a..9edef18 100644
--- a/src/cobalt/browser/memory_tracker/tool/tool_impl.h
+++ b/src/cobalt/browser/memory_tracker/tool/tool_impl.h
@@ -28,6 +28,7 @@
 #include "base/threading/simple_thread.h"
 #include "base/time.h"
 #include "cobalt/browser/memory_tracker/tool/buffered_file_writer.h"
+#include "cobalt/browser/memory_tracker/tool/util.h"
 #include "nb/analytics/memory_tracker.h"
 #include "nb/analytics/memory_tracker_helpers.h"
 #include "nb/concurrent_map.h"
@@ -72,89 +73,6 @@
   virtual void Run(Params* params) = 0;
 };
 
-// Start() is called when this object is created, and Cancel() & Join() are
-// called during destruction.
-class PrintTool : public AbstractTool {
- public:
-  PrintTool();
-  ~PrintTool() OVERRIDE;
-
-  // Overridden so that the thread can exit gracefully.
-  virtual void Run(Params* params) OVERRIDE;
-  virtual std::string tool_name() const OVERRIDE {
-    return "MemoryTrackerPrintThread";
-  }
-
- private:
-  class CvalsMap;
-  scoped_ptr<CvalsMap> cvals_map_;
-};
-
-// Generates CSV values of the engine.
-// There are three sections of data including:
-//   1. average bytes / alloc
-//   2. # Bytes allocated per memory scope.
-//   3. # Allocations per memory scope.
-// This data can be pasted directly into a Google spreadsheet and visualized.
-// Note that this thread will implicitly call Start() is called during
-// construction and Cancel() & Join() during destruction.
-class PrintCSVTool : public AbstractTool {
- public:
-  // This tool will only produce on CSV dump of the engine. This is useful
-  // for profiling startup memory consumption.
-  PrintCSVTool(int sampling_interval_ms, int sampling_time_ms);
-
-  // Overridden so that the thread can exit gracefully.
-  virtual void Run(Params* params) OVERRIDE;
-  virtual std::string tool_name() const OVERRIDE {
-    return "MemoryTrackerPrintCSV";
-  }
-
- private:
-  struct AllocationSamples {
-    std::vector<int32_t> number_allocations_;
-    std::vector<int64_t> allocated_bytes_;
-  };
-  typedef std::map<std::string, AllocationSamples> MapAllocationSamples;
-  static std::string ToCsvString(const MapAllocationSamples& samples);
-  static const char* UntrackedMemoryKey();
-  bool TimeExpiredYet(const Params& params);
-
-  const int sample_interval_ms_;
-  const int sampling_time_ms_;
-};
-
-struct AllocationSamples {
-  std::vector<int32_t> number_allocations_;
-  std::vector<int64_t> allocated_bytes_;
-};
-typedef std::map<std::string, AllocationSamples> MapAllocationSamples;
-typedef std::vector<base::TimeDelta> TimeStamps;
-
-struct TimeSeries {
-  MapAllocationSamples samples_;
-  TimeStamps time_stamps_;
-};
-
-// This tool inspects a memory scope and reports on the memory usage.
-// The output will be a CSV file printed to stdout representing
-// the number of memory allocations for objects. The objects are binned
-// according to the size of the memory allocation. Objects within the same
-// power of two are binned together. For example 1024 will be binned with 1025.
-class MemorySizeBinner : public AbstractTool {
- public:
-  // memory_scope_name represents the memory scope that is to be investigated.
-  explicit MemorySizeBinner(const std::string& memory_scope_name);
-
-  virtual void Run(Params* params) OVERRIDE;
-  virtual std::string tool_name() const OVERRIDE {
-    return "MemoryTrackerCompressedTimeSeries";
-  }
-
- private:
-  std::string memory_scope_name_;
-};
-
 // Bins the size according from all the encountered allocations.
 // If AllocationGroup* is non-null, then this is used as a filter such that
 // ONLY allocations belonging to that AllocationGroup are considered.
diff --git a/src/cobalt/browser/memory_tracker/tool/util.h b/src/cobalt/browser/memory_tracker/tool/util.h
index 3d44f6a..aa34660 100644
--- a/src/cobalt/browser/memory_tracker/tool/util.h
+++ b/src/cobalt/browser/memory_tracker/tool/util.h
@@ -15,8 +15,10 @@
 #ifndef COBALT_BROWSER_MEMORY_TRACKER_TOOL_UTIL_H_
 #define COBALT_BROWSER_MEMORY_TRACKER_TOOL_UTIL_H_
 
+#include <map>
 #include <sstream>
 #include <string>
+#include <vector>
 
 #include "base/time.h"
 
@@ -78,6 +80,18 @@
   base::TimeDelta time_before_expiration_;
 };
 
+struct AllocationSamples {
+  std::vector<int32_t> number_allocations_;
+  std::vector<int64_t> allocated_bytes_;
+};
+typedef std::map<std::string, AllocationSamples> MapAllocationSamples;
+typedef std::vector<base::TimeDelta> TimeStamps;
+
+struct TimeSeries {
+  MapAllocationSamples samples_;
+  TimeStamps time_stamps_;
+};
+
 // Generates a linear fit in the form of slope / y-intercept form.
 // Returns true if linear fit was calculated. False otherwise. Reasons for
 // returning false include passing in an empty range, such that
diff --git a/src/cobalt/browser/switches.cc b/src/cobalt/browser/switches.cc
index 59d9850..5e2ffd0 100644
--- a/src/cobalt/browser/switches.cc
+++ b/src/cobalt/browser/switches.cc
@@ -167,6 +167,12 @@
 
 const char kSkiaTextureAtlasDimensions[] = "skia_atlas_texture_dimensions";
 
+// Specifies the maximum CPU usage of the cobalt.
+const char kMaxCobaltCpuUsage[] = "max_cobalt_cpu_usage";
+
+// Specifies the maximum GPU usage of the cobalt.
+const char kMaxCobaltGpuUsage[] = "max_cobalt_gpu_usage";
+
 }  // namespace switches
 }  // namespace browser
 }  // namespace cobalt
diff --git a/src/cobalt/browser/switches.h b/src/cobalt/browser/switches.h
index 6b30b2b..9214784 100644
--- a/src/cobalt/browser/switches.h
+++ b/src/cobalt/browser/switches.h
@@ -59,6 +59,9 @@
 extern const char kJavaScriptGcThresholdInBytes[];
 extern const char kSkiaTextureAtlasDimensions[];
 
+extern const char kMaxCobaltCpuUsage[];
+extern const char kMaxCobaltGpuUsage[];
+
 }  // namespace switches
 }  // namespace browser
 }  // namespace cobalt
diff --git a/src/cobalt/browser/web_module.cc b/src/cobalt/browser/web_module.cc
index 5087c2d..2b6aad6 100644
--- a/src/cobalt/browser/web_module.cc
+++ b/src/cobalt/browser/web_module.cc
@@ -779,7 +779,9 @@
   debug_overlay_->ClearInput();
 #endif
 
-  // Finally mark that we have no resource provider.
+  // Finally purge the resource provider's caches and mark that we have no
+  // resource provider.
+  resource_provider_->PurgeCaches();
   resource_provider_ = NULL;
 }
 
@@ -840,8 +842,7 @@
     : name("WebModule"),
       layout_trigger(layout::LayoutManager::kOnDocumentMutation),
       image_cache_capacity(32 * 1024 * 1024),
-      remote_typeface_cache_capacity(
-          COBALT_REMOTE_TYPEFACE_CACHE_SIZE_IN_BYTES),
+      remote_typeface_cache_capacity(4 * 1024 * 1024),
       mesh_cache_capacity(COBALT_MESH_CACHE_SIZE_IN_BYTES),
       csp_enforcement_mode(dom::kCspEnforcementEnable),
       csp_insecure_allowed_token(0),
diff --git a/src/cobalt/build/build.id b/src/cobalt/build/build.id
index 86bfd59..9f62695 100644
--- a/src/cobalt/build/build.id
+++ b/src/cobalt/build/build.id
@@ -1 +1 @@
-51583
\ No newline at end of file
+52708
\ No newline at end of file
diff --git a/src/cobalt/build/config/base.gypi b/src/cobalt/build/config/base.gypi
index 339b511..ddfd269 100644
--- a/src/cobalt/build/config/base.gypi
+++ b/src/cobalt/build/config/base.gypi
@@ -33,9 +33,15 @@
     # implement spherical video playback.
     'enable_map_to_mesh%': 0,
 
-    # Enables embedding Cobalt as a shared library within another app. This
-    # requires a 'lib' starboard implementation for the corresponding platform.
-    'cobalt_enable_lib%': 0,
+    # 'sb_enable_lib' is initially defined inside this inner 'variables' dict so
+    # that it can be accessed by 'cobalt_enable_lib' below here.
+    'variables': {
+      # Enables embedding Cobalt as a shared library within another app. This
+      # requires a 'lib' starboard implementation for the corresponding platform.
+      'sb_enable_lib%': 0,
+    },
+    'sb_enable_lib%': '<(sb_enable_lib)',
+    'cobalt_enable_lib': '<(sb_enable_lib)',
 
     # Contains the current font package selection.  This can be used to trade
     # font quality, coverage, and latency for different font package sizes.
@@ -325,6 +331,18 @@
     # from 8MB to 1MB.
     'mozjs_garbage_collection_threshold_in_bytes%': 8 * 1024 * 1024,
 
+    # Max Cobalt CPU usage specifies that the cobalt program should
+    # keep it's size below the specified size. A value of -1 causes this
+    # value to be assumed from the starboard API function:
+    # SbSystemGetTotalCPUMemory().
+    'max_cobalt_cpu_usage%': -1,
+
+    # Max Cobalt GPU usage specifies that the cobalt program should
+    # keep it's size below the specified size. A value of -1 causes this
+    # value to be assumed from the starboard API function:
+    # SbSystemGetTotalGPUMemory().
+    'max_cobalt_gpu_usage%': -1,
+
     # Compiler configuration.
 
     # The following variables are used to specify compiler and linker
diff --git a/src/cobalt/doc/spherical_video.md b/src/cobalt/doc/spherical_video.md
index 2a5adf4..f117617 100644
--- a/src/cobalt/doc/spherical_video.md
+++ b/src/cobalt/doc/spherical_video.md
@@ -7,7 +7,7 @@
 for spherical video in Cobalt requires a GLES rasterizer (i.e. it is not
 supported for the Starboard Blitter API), and Starboard platform support for
 the player
-[decode-to-texture output mode](../starboard/doc/howto_decode_to_texture.md).
+[decode-to-texture output mode](../../starboard/doc/howto_decode_to_texture.md).
 
 ## Enabling spherical video support
 
@@ -37,4 +37,4 @@
 ```
 
 Finally, it is required that your platform provides
-[decode-to-texture support](../starboard/doc/howto_decode_to_texture.md).
+[decode-to-texture support](../../starboard/doc/howto_decode_to_texture.md).
diff --git a/src/cobalt/dom/comment_test.cc b/src/cobalt/dom/comment_test.cc
index 1e9cf83..00de4e0 100644
--- a/src/cobalt/dom/comment_test.cc
+++ b/src/cobalt/dom/comment_test.cc
@@ -38,9 +38,7 @@
   scoped_refptr<Document> document_;
 };
 
-CommentTest::CommentTest()
-    : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL, NULL, NULL, "") {
+CommentTest::CommentTest() {
   EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
   document_ = new Document(&html_element_context_);
 }
diff --git a/src/cobalt/dom/document.cc b/src/cobalt/dom/document.cc
index 2f3ad0e..754ee9b 100644
--- a/src/cobalt/dom/document.cc
+++ b/src/cobalt/dom/document.cc
@@ -43,6 +43,7 @@
 #include "cobalt/dom/html_element_factory.h"
 #include "cobalt/dom/html_head_element.h"
 #include "cobalt/dom/html_html_element.h"
+#include "cobalt/dom/html_script_element.h"
 #include "cobalt/dom/initial_computed_style.h"
 #include "cobalt/dom/keyframes_map_updater.h"
 #include "cobalt/dom/location.h"
@@ -52,7 +53,6 @@
 #include "cobalt/dom/ui_event.h"
 #include "cobalt/dom/window.h"
 #include "cobalt/script/global_environment.h"
-
 #include "nb/memory_scope.h"
 
 namespace cobalt {
@@ -197,7 +197,7 @@
 scoped_refptr<Element> Document::CreateElementNS(
     const std::string& namespace_uri, const std::string& local_name) {
   // TODO: Implement namespaces, if we actually need this.
-  NOTIMPLEMENTED() << namespace_uri;
+  UNREFERENCED_PARAMETER(namespace_uri);
   return CreateElement(local_name);
 }
 
@@ -700,6 +700,25 @@
       ->DisableJit();
 }
 
+void Document::TraceMembers(script::Tracer* tracer) {
+  Node::TraceMembers(tracer);
+
+  tracer->Trace(implementation_);
+  tracer->Trace(style_sheets_);
+  for (std::deque<HTMLScriptElement*>::iterator it =
+           scripts_to_be_executed_.begin();
+       it != scripts_to_be_executed_.end(); ++it) {
+    tracer->Trace(static_cast<Wrappable*>(*it));
+  }
+  for (cssom::CSSKeyframesRule::NameMap::iterator it = keyframes_map_.begin();
+       it != keyframes_map_.end(); ++it) {
+    tracer->Trace(it->second);
+  }
+  tracer->Trace(location_);
+  tracer->Trace(user_agent_style_sheet_);
+  tracer->Trace(initial_computed_style_declaration_);
+}
+
 void Document::DispatchOnLoadEvent() {
   TRACE_EVENT0("cobalt::dom", "Document::DispatchOnLoadEvent()");
 
diff --git a/src/cobalt/dom/document.h b/src/cobalt/dom/document.h
index f1e121b..4e63114 100644
--- a/src/cobalt/dom/document.h
+++ b/src/cobalt/dom/document.h
@@ -331,6 +331,8 @@
   // Disable just-in-time compilation of JavaScript code.
   void DisableJit();
 
+  void TraceMembers(script::Tracer* tracer) OVERRIDE;
+
   DEFINE_WRAPPABLE_TYPE(Document);
 
  protected:
diff --git a/src/cobalt/dom/document_type_test.cc b/src/cobalt/dom/document_type_test.cc
index e2e7efe..2dabb5c 100644
--- a/src/cobalt/dom/document_type_test.cc
+++ b/src/cobalt/dom/document_type_test.cc
@@ -23,10 +23,7 @@
 
 class DocumentTypeTest : public ::testing::Test {
  protected:
-  DocumentTypeTest()
-      : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                              NULL, NULL, NULL, NULL, NULL, NULL, NULL, ""),
-        document_(new Document(&html_element_context_)) {}
+  DocumentTypeTest() : document_(new Document(&html_element_context_)) {}
   ~DocumentTypeTest() OVERRIDE {}
 
   HTMLElementContext html_element_context_;
diff --git a/src/cobalt/dom/dom_implementation.cc b/src/cobalt/dom/dom_implementation.cc
index e7c73c7..cda0129 100644
--- a/src/cobalt/dom/dom_implementation.cc
+++ b/src/cobalt/dom/dom_implementation.cc
@@ -15,6 +15,7 @@
 #include "cobalt/dom/dom_implementation.h"
 
 #include "cobalt/dom/dom_settings.h"
+#include "cobalt/dom/element.h"
 #include "cobalt/dom/window.h"
 
 namespace cobalt {
@@ -32,13 +33,38 @@
   return CreateDocument(namespace_name, qualified_name, NULL);
 }
 
+// Algorithm for CreateDocument:
+//   https://www.w3.org/TR/dom/#dom-domimplementation-createdocument
 scoped_refptr<XMLDocument> DOMImplementation::CreateDocument(
     base::optional<std::string> namespace_name,
     const std::string& qualified_name, scoped_refptr<DocumentType> doctype) {
-  UNREFERENCED_PARAMETER(namespace_name);
-  UNREFERENCED_PARAMETER(qualified_name);
-  DCHECK(!doctype);
-  return new XMLDocument(html_element_context_);
+  UNREFERENCED_PARAMETER(doctype);
+
+  // 1. Let document be a new XMLDocument.
+  scoped_refptr<XMLDocument> document = new XMLDocument(html_element_context_);
+
+  // 2. Let element be null.
+  scoped_refptr<Element> element;
+
+  // 3. If qualifiedName is not the empty string, set element to the result of
+  // invoking the createElementNS() method with the arguments namespace and
+  // qualifiedName on document. Rethrow any exceptions.
+  if (!qualified_name.empty()) {
+    element =
+        document->CreateElementNS(namespace_name.value_or(""), qualified_name);
+  }
+
+  // 4. Not needed by Cobalt.
+
+  // 5. If element is not null, append element to document.
+  if (element) {
+    document->AppendChild(element);
+  }
+
+  // 6. Not needed by Cobalt.
+
+  // 7. Return document.
+  return document;
 }
 
 }  // namespace dom
diff --git a/src/cobalt/dom/dom_implementation.h b/src/cobalt/dom/dom_implementation.h
index 66a04f6..06d5f99 100644
--- a/src/cobalt/dom/dom_implementation.h
+++ b/src/cobalt/dom/dom_implementation.h
@@ -33,7 +33,7 @@
 // The DOMImplementation interface represent an object providing methods which
 // are not dependent on any particular document. Such an object is returned by
 // the Document.implementation property.
-//   https://www.w3.org/TR/2015/WD-dom-20150618/#interface-domimplementation
+//   https://www.w3.org/TR/dom/#domimplementation
 class DOMImplementation : public script::Wrappable {
  public:
   explicit DOMImplementation(script::EnvironmentSettings* settings);
diff --git a/src/cobalt/dom/dom_implementation_test.cc b/src/cobalt/dom/dom_implementation_test.cc
index f161a30..54336f5 100644
--- a/src/cobalt/dom/dom_implementation_test.cc
+++ b/src/cobalt/dom/dom_implementation_test.cc
@@ -16,6 +16,7 @@
 
 #include "base/memory/ref_counted.h"
 #include "cobalt/dom/document.h"
+#include "cobalt/dom/element.h"
 #include "cobalt/dom/html_element_context.h"
 #include "cobalt/dom/xml_document.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ -23,15 +24,27 @@
 namespace cobalt {
 namespace dom {
 
-TEST(DOMImplementationTest, CreateDocumentShouldCreateXMLDocument) {
-  HTMLElementContext html_element_context(NULL, NULL, NULL, NULL, NULL, NULL,
-                                          NULL, NULL, NULL, NULL, NULL, NULL,
-                                          NULL, NULL, NULL, "");
+TEST(DOMImplementationTest, CreateDocumentWithEmptyName) {
+  HTMLElementContext html_element_context;
   scoped_refptr<DOMImplementation> dom_implementation =
       new DOMImplementation(&html_element_context);
   scoped_refptr<Document> document =
       dom_implementation->CreateDocument(base::optional<std::string>(""), "");
+  ASSERT_TRUE(document);
   EXPECT_TRUE(document->IsXMLDocument());
+  EXPECT_FALSE(document->first_element_child());
+}
+
+TEST(DOMImplementationTest, CreateDocumentWithName) {
+  HTMLElementContext html_element_context;
+  scoped_refptr<DOMImplementation> dom_implementation =
+      new DOMImplementation(&html_element_context);
+  scoped_refptr<Document> document = dom_implementation->CreateDocument(
+      base::optional<std::string>(""), "ROOT");
+  ASSERT_TRUE(document);
+  EXPECT_TRUE(document->IsXMLDocument());
+  ASSERT_TRUE(document->first_element_child());
+  EXPECT_EQ("ROOT", document->first_element_child()->tag_name());
 }
 
 }  // namespace dom
diff --git a/src/cobalt/dom/dom_string_map_test.cc b/src/cobalt/dom/dom_string_map_test.cc
index cf8a9a5..545dd07 100644
--- a/src/cobalt/dom/dom_string_map_test.cc
+++ b/src/cobalt/dom/dom_string_map_test.cc
@@ -42,9 +42,7 @@
 };
 
 DOMStringMapTest::DOMStringMapTest()
-    : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL, NULL, NULL, ""),
-      document_(new Document(&html_element_context_)),
+    : document_(new Document(&html_element_context_)),
       element_(new Element(document_, base::Token("element"))),
       dom_string_map_(new DOMStringMap(element_)) {}
 
diff --git a/src/cobalt/dom/dom_token_list_test.cc b/src/cobalt/dom/dom_token_list_test.cc
index a40f8be..c39a226 100644
--- a/src/cobalt/dom/dom_token_list_test.cc
+++ b/src/cobalt/dom/dom_token_list_test.cc
@@ -36,9 +36,7 @@
   scoped_refptr<Document> document_;
 };
 
-DOMTokenListTest::DOMTokenListTest()
-    : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL, NULL, NULL, "") {
+DOMTokenListTest::DOMTokenListTest() {
   EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
   document_ = new Document(&html_element_context_);
 }
diff --git a/src/cobalt/dom/event_target.cc b/src/cobalt/dom/event_target.cc
index 6a77ff0..b923be1 100644
--- a/src/cobalt/dom/event_target.cc
+++ b/src/cobalt/dom/event_target.cc
@@ -149,6 +149,12 @@
   return !event_listener_infos_.empty();
 }
 
+void EventTarget::TraceMembers(script::Tracer* tracer) {
+  UNREFERENCED_PARAMETER(tracer);
+  // TODO: EventListenerInfo references can be removed and logically live here
+  // instead.
+}
+
 void EventTarget::FireEventOnListeners(const scoped_refptr<Event>& event) {
   DCHECK(event->IsBeingDispatched());
   DCHECK(event->target());
diff --git a/src/cobalt/dom/event_target.h b/src/cobalt/dom/event_target.h
index 6ec9450..a31a414 100644
--- a/src/cobalt/dom/event_target.h
+++ b/src/cobalt/dom/event_target.h
@@ -135,6 +135,8 @@
   // Returns a string that represents the target for debug purpose.
   virtual std::string GetDebugName() { return ""; }
 
+  void TraceMembers(script::Tracer* tracer) OVERRIDE;
+
   DEFINE_WRAPPABLE_TYPE(EventTarget);
 
  protected:
diff --git a/src/cobalt/dom/html_element_context.cc b/src/cobalt/dom/html_element_context.cc
index 3cf96f0..b7aeed0 100644
--- a/src/cobalt/dom/html_element_context.cc
+++ b/src/cobalt/dom/html_element_context.cc
@@ -19,6 +19,27 @@
 namespace cobalt {
 namespace dom {
 
+HTMLElementContext::HTMLElementContext()
+    : fetcher_factory_(NULL),
+      css_parser_(NULL),
+      dom_parser_(NULL),
+      can_play_type_handler_(NULL),
+      web_media_player_factory_(NULL),
+      script_runner_(NULL),
+      script_value_factory_(NULL),
+      media_source_registry_(NULL),
+      resource_provider_(NULL),
+      animated_image_tracker_(NULL),
+      image_cache_(NULL),
+      reduced_image_cache_capacity_manager_(NULL),
+      remote_typeface_cache_(NULL),
+      mesh_cache_(NULL),
+      dom_stat_tracker_(NULL),
+      sync_load_thread_("Synchronous Load"),
+      html_element_factory_(new HTMLElementFactory()) {
+  sync_load_thread_.Start();
+}
+
 HTMLElementContext::HTMLElementContext(
     loader::FetcherFactory* fetcher_factory, cssom::CSSParser* css_parser,
     Parser* dom_parser, media::CanPlayTypeHandler* can_play_type_handler,
diff --git a/src/cobalt/dom/html_element_context.h b/src/cobalt/dom/html_element_context.h
index 4650c31..cae6ad8 100644
--- a/src/cobalt/dom/html_element_context.h
+++ b/src/cobalt/dom/html_element_context.h
@@ -46,6 +46,7 @@
  public:
   typedef UrlRegistry<MediaSource> MediaSourceRegistry;
 
+  HTMLElementContext();
   HTMLElementContext(
       loader::FetcherFactory* fetcher_factory, cssom::CSSParser* css_parser,
       Parser* dom_parser, media::CanPlayTypeHandler* can_play_type_handler,
diff --git a/src/cobalt/dom/named_node_map_test.cc b/src/cobalt/dom/named_node_map_test.cc
index d99df3b..fe8a605 100644
--- a/src/cobalt/dom/named_node_map_test.cc
+++ b/src/cobalt/dom/named_node_map_test.cc
@@ -38,9 +38,7 @@
   scoped_refptr<Element> element_;
 };
 
-NamedNodeMapTest::NamedNodeMapTest()
-    : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL, NULL, NULL, "") {
+NamedNodeMapTest::NamedNodeMapTest() {
   EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
   document_ = new Document(&html_element_context_);
   element_ = new Element(document_, base::Token("element"));
diff --git a/src/cobalt/dom/node.cc b/src/cobalt/dom/node.cc
index fdc872e..b1f0569 100644
--- a/src/cobalt/dom/node.cc
+++ b/src/cobalt/dom/node.cc
@@ -435,6 +435,22 @@
 
 scoped_refptr<Text> Node::AsText() { return NULL; }
 
+void Node::TraceMembers(script::Tracer* tracer) {
+  EventTarget::TraceMembers(tracer);
+
+  tracer->Trace(node_document_);
+  tracer->Trace(parent_);
+  tracer->Trace(previous_sibling_);
+  tracer->Trace(last_child_);
+  tracer->Trace(first_child_);
+  tracer->Trace(next_sibling_);
+  for (RegisteredObserverList::RegisteredObserverVector::const_iterator it =
+           registered_observers_.registered_observers().begin();
+       it != registered_observers_.registered_observers().end(); ++it) {
+    tracer->Trace(it->observer());
+  }
+}
+
 Node::Node(Document* document)
     : node_document_(base::AsWeakPtr(document)),
       parent_(NULL),
diff --git a/src/cobalt/dom/node.h b/src/cobalt/dom/node.h
index 695ce4d..e1fbecb 100644
--- a/src/cobalt/dom/node.h
+++ b/src/cobalt/dom/node.h
@@ -233,6 +233,8 @@
     registered_observers_.RemoveMutationObserver(observer);
   }
 
+  void TraceMembers(script::Tracer* tracer) OVERRIDE;
+
   DEFINE_WRAPPABLE_TYPE(Node);
 
  protected:
diff --git a/src/cobalt/dom/node_dispatch_event_test.cc b/src/cobalt/dom/node_dispatch_event_test.cc
index 5758126..997fafe 100644
--- a/src/cobalt/dom/node_dispatch_event_test.cc
+++ b/src/cobalt/dom/node_dispatch_event_test.cc
@@ -56,9 +56,7 @@
   scoped_ptr<MockEventListener> event_listener_bubbling_;
 };
 
-NodeDispatchEventTest::NodeDispatchEventTest()
-    : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL, NULL, NULL, "") {
+NodeDispatchEventTest::NodeDispatchEventTest() {
   EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
 
   document_ = new Document(&html_element_context_);
diff --git a/src/cobalt/dom/node_test.cc b/src/cobalt/dom/node_test.cc
index cd8e4f1..36b0330 100644
--- a/src/cobalt/dom/node_test.cc
+++ b/src/cobalt/dom/node_test.cc
@@ -74,9 +74,7 @@
   scoped_refptr<Document> document_;
 };
 
-NodeTest::NodeTest()
-    : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL, NULL, NULL, "") {
+NodeTest::NodeTest() {
   EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
 
   document_ = new Document(&html_element_context_);
diff --git a/src/cobalt/dom/text_test.cc b/src/cobalt/dom/text_test.cc
index 75ab826..3ec5550 100644
--- a/src/cobalt/dom/text_test.cc
+++ b/src/cobalt/dom/text_test.cc
@@ -37,9 +37,7 @@
   scoped_refptr<Document> document_;
 };
 
-TextTest::TextTest()
-    : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL, NULL, NULL, "") {
+TextTest::TextTest() {
   EXPECT_TRUE(GlobalStats::GetInstance()->CheckNoLeaks());
   document_ = new Document(&html_element_context_);
 }
diff --git a/src/cobalt/dom/window.cc b/src/cobalt/dom/window.cc
index 665126d..a270c9d 100644
--- a/src/cobalt/dom/window.cc
+++ b/src/cobalt/dom/window.cc
@@ -420,6 +420,20 @@
   document_->set_synchronous_layout_callback(synchronous_layout_callback);
 }
 
+void Window::TraceMembers(script::Tracer* tracer) {
+  tracer->Trace(performance_);
+  tracer->Trace(document_);
+  tracer->Trace(history_);
+  tracer->Trace(navigator_);
+  tracer->Trace(console_);
+  tracer->Trace(camera_3d_);
+  tracer->Trace(crypto_);
+  tracer->Trace(speech_synthesis_);
+  tracer->Trace(local_storage_);
+  tracer->Trace(session_storage_);
+  tracer->Trace(screen_);
+}
+
 Window::~Window() {}
 
 void Window::FireHashChangeEvent() {
diff --git a/src/cobalt/dom/window.h b/src/cobalt/dom/window.h
index 36eddab..7a90c00 100644
--- a/src/cobalt/dom/window.h
+++ b/src/cobalt/dom/window.h
@@ -278,6 +278,8 @@
   void SetSynchronousLayoutCallback(
       const base::Closure& synchronous_layout_callback);
 
+  void TraceMembers(script::Tracer* tracer) OVERRIDE;
+
   DEFINE_WRAPPABLE_TYPE(Window);
 
  private:
diff --git a/src/cobalt/dom/xml_document_test.cc b/src/cobalt/dom/xml_document_test.cc
index d4294eb..c1c11a7 100644
--- a/src/cobalt/dom/xml_document_test.cc
+++ b/src/cobalt/dom/xml_document_test.cc
@@ -23,9 +23,7 @@
 namespace dom {
 
 TEST(XMLDocumentTest, IsXMLDocument) {
-  HTMLElementContext html_element_context(NULL, NULL, NULL, NULL, NULL, NULL,
-                                          NULL, NULL, NULL, NULL, NULL, NULL,
-                                          NULL, NULL, NULL, "");
+  HTMLElementContext html_element_context;
   scoped_refptr<Document> document = new XMLDocument(&html_element_context);
   EXPECT_TRUE(document->IsXMLDocument());
 }
diff --git a/src/cobalt/dom_parser/libxml_parser_wrapper.cc b/src/cobalt/dom_parser/libxml_parser_wrapper.cc
index b85ba7a..5b7e6bc 100644
--- a/src/cobalt/dom_parser/libxml_parser_wrapper.cc
+++ b/src/cobalt/dom_parser/libxml_parser_wrapper.cc
@@ -293,7 +293,7 @@
   DCHECK(severity >= kWarning && severity <= kFatal);
 
   xmlErrorPtr error = xmlGetLastError();
-  if (error->code == XML_HTML_UNKNOWN_TAG) {
+  if (error && error->code == XML_HTML_UNKNOWN_TAG) {
     return;
   }
 
diff --git a/src/cobalt/dom_parser/xml_decoder_test.cc b/src/cobalt/dom_parser/xml_decoder_test.cc
index 3fb2732..725a989 100644
--- a/src/cobalt/dom_parser/xml_decoder_test.cc
+++ b/src/cobalt/dom_parser/xml_decoder_test.cc
@@ -48,9 +48,7 @@
 };
 
 XMLDecoderTest::XMLDecoderTest()
-    : html_element_context_(NULL, NULL, NULL, NULL, NULL, NULL, NULL, NULL,
-                            NULL, NULL, NULL, NULL, NULL, NULL, NULL, ""),
-      document_(new dom::XMLDocument(&html_element_context_)),
+    : document_(new dom::XMLDocument(&html_element_context_)),
       source_location_(base::SourceLocation("[object XMLDecoderTest]", 1, 1)) {}
 
 TEST_F(XMLDecoderTest, ShouldNotAddImpliedTags) {
diff --git a/src/cobalt/media/filters/source_buffer_stream.h b/src/cobalt/media/filters/source_buffer_stream.h
index 6fe9229..edeac1a 100644
--- a/src/cobalt/media/filters/source_buffer_stream.h
+++ b/src/cobalt/media/filters/source_buffer_stream.h
@@ -151,7 +151,7 @@
 class MEDIA_EXPORT SourceBufferStream : private SourceBufferStreamState {
  public:
   using SourceBufferStreamState::BufferQueue;
-  using SourceBufferStreamState::RangeList;
+  typedef SourceBufferStreamState::RangeList RangeList;
 
   // Status returned by GetNextBuffer().
   // kSuccess: Indicates that the next buffer was returned.
diff --git a/src/cobalt/media/shell_video_data_allocator_common.cc b/src/cobalt/media/shell_video_data_allocator_common.cc
index f1b4e6f..8cbb35c 100644
--- a/src/cobalt/media/shell_video_data_allocator_common.cc
+++ b/src/cobalt/media/shell_video_data_allocator_common.cc
@@ -131,6 +131,13 @@
   // issues.
   gfx::Size plane_size(param.visible_rect().size());
 
+  // When plane_size.height() is only aligned to 2, the height of U/V plane
+  // will be odd, which is not supported on most platforms.  Align height to 4
+  // to work around this issue.
+  if (param.decoded_height() % 4 == 0 && plane_size.height() % 4 != 0) {
+    plane_size.set_height((plane_size.height() + 3) / 4 * 4);
+  }
+
   intptr_t offset = 0;
   int pitch_in_bytes = param.y_pitch();
 
diff --git a/src/cobalt/render_tree/mock_resource_provider.h b/src/cobalt/render_tree/mock_resource_provider.h
index 1d13b6c..0fba09f 100644
--- a/src/cobalt/render_tree/mock_resource_provider.h
+++ b/src/cobalt/render_tree/mock_resource_provider.h
@@ -164,6 +164,8 @@
       Mesh::DrawMode draw_mode) {
     return make_scoped_refptr(CreateMeshMock(vertices.get(), draw_mode));
   }
+
+  virtual void PurgeCaches() {}
 };
 
 }  // namespace render_tree
diff --git a/src/cobalt/render_tree/resource_provider.h b/src/cobalt/render_tree/resource_provider.h
index 69e0f6c..be1c28e 100644
--- a/src/cobalt/render_tree/resource_provider.h
+++ b/src/cobalt/render_tree/resource_provider.h
@@ -218,6 +218,9 @@
 
   virtual scoped_refptr<Image> DrawOffscreenImage(
       const scoped_refptr<render_tree::Node>& root) = 0;
+
+  // Purges any caches being used by the render_tree consumer.
+  virtual void PurgeCaches() = 0;
 };
 
 }  // namespace render_tree
diff --git a/src/cobalt/render_tree/resource_provider_stub.h b/src/cobalt/render_tree/resource_provider_stub.h
index 5d33cd0..0f70147 100644
--- a/src/cobalt/render_tree/resource_provider_stub.h
+++ b/src/cobalt/render_tree/resource_provider_stub.h
@@ -331,6 +331,8 @@
     UNREFERENCED_PARAMETER(root);
     return scoped_refptr<Image>(NULL);
   }
+
+  void PurgeCaches() OVERRIDE {}
 };
 
 }  // namespace render_tree
diff --git a/src/cobalt/renderer/rasterizer/blitter/resource_provider.cc b/src/cobalt/renderer/rasterizer/blitter/resource_provider.cc
index 2315836..f72fafa 100644
--- a/src/cobalt/renderer/rasterizer/blitter/resource_provider.cc
+++ b/src/cobalt/renderer/rasterizer/blitter/resource_provider.cc
@@ -213,6 +213,8 @@
       new SinglePlaneImage(root, submit_offscreen_callback_, device_));
 }
 
+void ResourceProvider::PurgeCaches() { skia_resource_provider_->PurgeCaches(); }
+
 }  // namespace blitter
 }  // namespace rasterizer
 }  // namespace renderer
diff --git a/src/cobalt/renderer/rasterizer/blitter/resource_provider.h b/src/cobalt/renderer/rasterizer/blitter/resource_provider.h
index 3f01c64..bf67280 100644
--- a/src/cobalt/renderer/rasterizer/blitter/resource_provider.h
+++ b/src/cobalt/renderer/rasterizer/blitter/resource_provider.h
@@ -113,6 +113,8 @@
   scoped_refptr<render_tree::Image> DrawOffscreenImage(
       const scoped_refptr<render_tree::Node>& root) OVERRIDE;
 
+  void PurgeCaches() OVERRIDE;
+
  private:
   SbBlitterDevice device_;
 
diff --git a/src/cobalt/renderer/rasterizer/lib/renderer_module_default_options_lib.cc b/src/cobalt/renderer/rasterizer/lib/renderer_module_default_options_lib.cc
index 43a1a0d..955ea45 100644
--- a/src/cobalt/renderer/rasterizer/lib/renderer_module_default_options_lib.cc
+++ b/src/cobalt/renderer/rasterizer/lib/renderer_module_default_options_lib.cc
@@ -25,8 +25,8 @@
   return scoped_ptr<rasterizer::Rasterizer>(
       new rasterizer::lib::ExternalRasterizer(
         graphics_context,
-        options.skia_texture_atlas_dimensions.width(),
-        options.skia_texture_atlas_dimensions.height(),
+        options.skia_glyph_texture_atlas_dimensions.width(),
+        options.skia_glyph_texture_atlas_dimensions.height(),
         options.skia_cache_size_in_bytes,
         options.scratch_surface_cache_size_in_bytes,
         options.surface_cache_size_in_bytes));
diff --git a/src/cobalt/renderer/rasterizer/skia/hardware_resource_provider.cc b/src/cobalt/renderer/rasterizer/skia/hardware_resource_provider.cc
index a892498..504faab 100644
--- a/src/cobalt/renderer/rasterizer/skia/hardware_resource_provider.cc
+++ b/src/cobalt/renderer/rasterizer/skia/hardware_resource_provider.cc
@@ -380,6 +380,13 @@
       self_message_loop_));
 }
 
+void HardwareResourceProvider::PurgeCaches() {
+  SkAutoTUnref<SkFontMgr> font_manager(SkFontMgr::RefDefault());
+  SkFontMgr_Cobalt* cobalt_font_manager =
+      base::polymorphic_downcast<SkFontMgr_Cobalt*>(font_manager.get());
+  cobalt_font_manager->PurgeCaches();
+}
+
 }  // namespace skia
 }  // namespace rasterizer
 }  // namespace renderer
diff --git a/src/cobalt/renderer/rasterizer/skia/hardware_resource_provider.h b/src/cobalt/renderer/rasterizer/skia/hardware_resource_provider.h
index 6532ff2..5fe7814 100644
--- a/src/cobalt/renderer/rasterizer/skia/hardware_resource_provider.h
+++ b/src/cobalt/renderer/rasterizer/skia/hardware_resource_provider.h
@@ -136,6 +136,8 @@
   scoped_refptr<render_tree::Image> DrawOffscreenImage(
       const scoped_refptr<render_tree::Node>& root) OVERRIDE;
 
+  void PurgeCaches() OVERRIDE;
+
  private:
   backend::GraphicsContextEGL* cobalt_context_;
   GrContext* gr_context_;
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.cc b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.cc
index 206c6e3..6160f4f 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.cc
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.cc
@@ -253,23 +253,25 @@
   kOtherElementType,
 };
 
-// The FamilyData structure is passed around by the parser so that each handler
-// can read these variables that are relevant to the current parsing.
-struct FamilyData {
-  explicit FamilyData(SkTDArray<FontFamily*>* families_array)
+// The ParserContext structure is passed around by the parser so that each
+// handler can read these variables that are relevant to the current parsing.
+struct ParserContext {
+  explicit ParserContext(SkTDArray<FontFamilyInfo*>* families_array)
       : families(families_array), current_font_info(NULL) {}
 
   // The array that each family is put into as it is parsed
-  SkTDArray<FontFamily*>* families;
+  SkTDArray<FontFamilyInfo*>* families;
   // The current family being created. FamilyData owns this object while it is
   // not NULL.
-  scoped_ptr<FontFamily> current_family;
-  // The current fontInfo being created. It is owned by FontFamily.
+  scoped_ptr<FontFamilyInfo> current_family;
+  // The current FontFileInfo being created. It is owned by FontFamilyInfo.
   FontFileInfo* current_font_info;
+
+  // Contains all of the elements that are actively being parsed.
   std::stack<ElementType> element_stack;
 };
 
-void FamilyElementHandler(FontFamily* family, const char** attributes) {
+void FamilyElementHandler(FontFamilyInfo* family, const char** attributes) {
   if (attributes == NULL) {
     return;
   }
@@ -399,10 +401,10 @@
   }
 }
 
-FontFamily* FindFamily(FamilyData* family_data, const char* family_name) {
+FontFamilyInfo* FindFamily(ParserContext* context, const char* family_name) {
   size_t name_len = strlen(family_name);
-  for (int i = 0; i < family_data->families->count(); i++) {
-    FontFamily* candidate = (*family_data->families)[i];
+  for (int i = 0; i < context->families->count(); i++) {
+    FontFamilyInfo* candidate = (*context->families)[i];
     for (int j = 0; j < candidate->names.count(); j++) {
       if (!strncmp(candidate->names[j].c_str(), family_name, name_len) &&
           name_len == strlen(candidate->names[j].c_str())) {
@@ -414,7 +416,7 @@
   return NULL;
 }
 
-void AliasElementHandler(FamilyData* family_data, const char** attributes) {
+void AliasElementHandler(ParserContext* context, const char** attributes) {
   // An <alias> must have name and to attributes.
   // It is a variant name for a <family>.
 
@@ -434,7 +436,7 @@
   }
 
   // Assumes that the named family is already declared
-  FontFamily* target_family = FindFamily(family_data, to.c_str());
+  FontFamilyInfo* target_family = FindFamily(context, to.c_str());
   if (!target_family) {
     LOG(ERROR) << "---- Invalid alias target [name: " << alias_name.c_str()
                << ", to: " << to.c_str() << "]";
@@ -449,55 +451,56 @@
   target_family->names.push_back().set(alias_name);
 }
 
-void StartElement(void* data, const xmlChar* xml_tag,
+void StartElement(void* context, const xmlChar* xml_tag,
                   const xmlChar** xml_attribute_pairs) {
-  FamilyData* family_data = reinterpret_cast<FamilyData*>(data);
+  ParserContext* parser_context = reinterpret_cast<ParserContext*>(context);
   const char* tag = reinterpret_cast<const char*>(xml_tag);
   const char** attribute_pairs =
       reinterpret_cast<const char**>(xml_attribute_pairs);
   size_t tag_len = strlen(tag);
 
   if (tag_len == 6 && strncmp("family", tag, tag_len) == 0) {
-    family_data->element_stack.push(kFamilyElementType);
-    family_data->current_family = make_scoped_ptr(new FontFamily());
-    FamilyElementHandler(family_data->current_family.get(), attribute_pairs);
+    parser_context->element_stack.push(kFamilyElementType);
+    parser_context->current_family = make_scoped_ptr(new FontFamilyInfo());
+    FamilyElementHandler(parser_context->current_family.get(), attribute_pairs);
   } else if (tag_len == 4 && strncmp("font", tag, tag_len) == 0) {
-    family_data->element_stack.push(kFontElementType);
-    FontFileInfo* file = &family_data->current_family->fonts.push_back();
-    family_data->current_font_info = file;
+    parser_context->element_stack.push(kFontElementType);
+    FontFileInfo* file = &parser_context->current_family->fonts.push_back();
+    parser_context->current_font_info = file;
     FontElementHandler(file, attribute_pairs);
   } else if (tag_len == 5 && strncmp("alias", tag, tag_len) == 0) {
-    family_data->element_stack.push(kAliasElementType);
-    AliasElementHandler(family_data, attribute_pairs);
+    parser_context->element_stack.push(kAliasElementType);
+    AliasElementHandler(parser_context, attribute_pairs);
   } else {
-    family_data->element_stack.push(kOtherElementType);
+    parser_context->element_stack.push(kOtherElementType);
   }
 }
 
-void EndElement(void* data, const xmlChar* xml_tag) {
-  FamilyData* family_data = reinterpret_cast<FamilyData*>(data);
+void EndElement(void* context, const xmlChar* xml_tag) {
+  ParserContext* parser_context = reinterpret_cast<ParserContext*>(context);
   const char* tag = reinterpret_cast<const char*>(xml_tag);
   size_t tag_len = strlen(tag);
 
   if (tag_len == 6 && strncmp("family", tag, tag_len) == 0) {
-    if (family_data->current_family != NULL) {
-      *family_data->families->append() = family_data->current_family.release();
+    if (parser_context->current_family != NULL) {
+      *parser_context->families->append() =
+          parser_context->current_family.release();
     } else {
       LOG(ERROR) << "---- Encountered end family tag with no current family";
       NOTREACHED();
     }
   }
 
-  family_data->element_stack.pop();
+  parser_context->element_stack.pop();
 }
 
-void Characters(void* data, const xmlChar* xml_characters, int len) {
-  FamilyData* family_data = reinterpret_cast<FamilyData*>(data);
+void Characters(void* context, const xmlChar* xml_characters, int len) {
+  ParserContext* parser_context = reinterpret_cast<ParserContext*>(context);
   const char* characters = reinterpret_cast<const char*>(xml_characters);
 
-  if (family_data->element_stack.size() > 0 &&
-      family_data->element_stack.top() == kFontElementType) {
-    family_data->current_font_info->file_name.set(characters, len);
+  if (parser_context->element_stack.size() > 0 &&
+      parser_context->element_stack.top() == kFontElementType) {
+    parser_context->current_font_info->file_name.set(characters, len);
   }
 }
 
@@ -529,7 +532,8 @@
 
 // This function parses the given filename and stores the results in the given
 // families array.
-void ParseConfigFile(const char* directory, SkTDArray<FontFamily*>* families) {
+void ParseConfigFile(const char* directory,
+                     SkTDArray<FontFamilyInfo*>* families) {
   SkString file_path = SkOSPath::Join(directory, kConfigFile);
 
   SkAutoTUnref<SkStream> file_stream(SkStream::NewFromFile(file_path.c_str()));
@@ -545,8 +549,8 @@
     return;
   }
 
-  FamilyData family_data(families);
-  xmlSAXUserParseMemory(&xml_sax_handler, &family_data,
+  ParserContext parser_context(families);
+  xmlSAXUserParseMemory(&xml_sax_handler, &parser_context,
                         static_cast<const char*>(file_data->data()),
                         static_cast<int>(file_data->size()));
 }
@@ -558,7 +562,7 @@
 // Loads data on font families from the configuration file. The resulting data
 // is returned in the given fontFamilies array.
 void GetFontFamilies(const char* directory,
-                     SkTDArray<FontFamily*>* font_families) {
+                     SkTDArray<FontFamilyInfo*>* font_families) {
   ParseConfigFile(directory, font_families);
 }
 
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.h b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.h
index d2cb6d9..40e00d4 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.h
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.h
@@ -23,7 +23,7 @@
 // Parses all system font configuration files and returns the results in an
 // array of FontFamily structures.
 void GetFontFamilies(const char* directory,
-                     SkTDArray<FontFamily*>* font_families);
+                     SkTDArray<FontFamilyInfo*>* font_families);
 
 }  // namespace SkFontConfigParser
 
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.cc b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.cc
index 850a112..36d4b6f 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.cc
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.cc
@@ -18,6 +18,7 @@
 #include "cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontConfigParser_cobalt.h"
 #include "cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h"
 #include "SkData.h"
+#include "SkGraphics.h"
 #include "SkStream.h"
 #include "SkString.h"
 #include "SkTSearch.h"
@@ -59,38 +60,43 @@
   FindDefaultFamily(default_families);
 }
 
+void SkFontMgr_Cobalt::PurgeCaches() {
+  SkGraphics::PurgeFontCache();
+  local_typeface_stream_manager_.PurgeUnusedMemoryChunks();
+}
+
 SkTypeface* SkFontMgr_Cobalt::MatchFaceName(const char face_name[]) {
-  if (!face_name) {
+  if (face_name == NULL) {
     return NULL;
   }
 
   SkAutoAsciiToLC face_name_to_lc(face_name);
   std::string face_name_string(face_name_to_lc.lc(), face_name_to_lc.length());
 
-  // Lock the style sets mutex prior to accessing them.
-  SkAutoMutexAcquire scoped_mutex(style_sets_mutex_);
+  // Lock the family mutex prior to accessing them.
+  SkAutoMutexAcquire scoped_mutex(family_mutex_);
 
   // Prioritize looking up the postscript name first since some of our client
   // applications prefer this method to specify face names.
   for (int i = 0; i <= 1; ++i) {
-    NameToStyleSetMap& name_to_style_set_map =
-        i == 0 ? font_postscript_name_to_style_set_map_
-               : full_font_name_to_style_set_map_;
+    NameToStyleSetMap& name_to_family_map =
+        i == 0 ? font_postscript_name_to_family_map_
+               : full_font_name_to_family_map_;
 
-    NameToStyleSetMap::iterator style_set_iterator =
-        name_to_style_set_map.find(face_name_string);
-    if (style_set_iterator != name_to_style_set_map.end()) {
-      SkFontStyleSet_Cobalt* style_set = style_set_iterator->second;
+    NameToStyleSetMap::iterator family_map_iterator =
+        name_to_family_map.find(face_name_string);
+    if (family_map_iterator != name_to_family_map.end()) {
+      SkFontStyleSet_Cobalt* family = family_map_iterator->second;
       SkTypeface* typeface =
-          i == 0 ? style_set->MatchFontPostScriptName(face_name_string)
-                 : style_set->MatchFullFontName(face_name_string);
+          i == 0 ? family->MatchFontPostScriptName(face_name_string)
+                 : family->MatchFullFontName(face_name_string);
       if (typeface != NULL) {
         return typeface;
       } else {
         // If no typeface was successfully created then remove the entry from
         // the map. It won't provide a successful result in subsequent calls
         // either.
-        name_to_style_set_map.erase(style_set_iterator);
+        name_to_family_map.erase(family_map_iterator);
       }
     }
   }
@@ -124,7 +130,7 @@
 
 SkFontStyleSet_Cobalt* SkFontMgr_Cobalt::onMatchFamily(
     const char family_name[]) const {
-  if (!family_name) {
+  if (family_name == NULL) {
     return NULL;
   }
 
@@ -143,12 +149,12 @@
     const char family_name[], const SkFontStyle& style) const {
   SkTypeface* typeface = NULL;
 
-  if (family_name) {
-    SkAutoTUnref<SkFontStyleSet> style_set(matchFamily(family_name));
-    typeface = style_set->matchStyle(style);
+  if (family_name != NULL) {
+    SkAutoTUnref<SkFontStyleSet> family(matchFamily(family_name));
+    typeface = family->matchStyle(style);
   }
 
-  if (NULL == typeface) {
+  if (typeface == NULL) {
     typeface = default_family_->matchStyle(style);
   }
 
@@ -157,13 +163,13 @@
 
 SkTypeface* SkFontMgr_Cobalt::onMatchFaceStyle(const SkTypeface* family_member,
                                                const SkFontStyle& style) const {
-  // Lock the style sets mutex prior to calling private |SkFontStyleSet_Cobalt|
+  // Lock the family mutex prior to calling private SkFontStyleSet_Cobalt
   // functions that expect the mutex to already be locked.
-  SkAutoMutexAcquire scoped_mutex(style_sets_mutex_);
+  SkAutoMutexAcquire scoped_mutex(family_mutex_);
 
-  for (int i = 0; i < font_style_sets_.count(); ++i) {
-    if (font_style_sets_[i]->ContainsTypeface(family_member)) {
-      return font_style_sets_[i]->MatchStyleWithoutLocking(style);
+  for (int i = 0; i < families_.count(); ++i) {
+    if (families_[i]->ContainsTypeface(family_member)) {
+      return families_[i]->MatchStyleWithoutLocking(style);
     }
   }
   return NULL;
@@ -177,11 +183,11 @@
 
   // Remove const from the manager. SkFontMgr_Cobalt modifies its internals
   // within FindFamilyStyleCharacter().
-  SkFontMgr_Cobalt* font_mgr = const_cast<SkFontMgr_Cobalt*>(this);
+  SkFontMgr_Cobalt* font_manager = const_cast<SkFontMgr_Cobalt*>(this);
 
-  // Lock the style sets mutex prior to calling |FindFamilyStyleCharacter|. It
+  // Lock the family mutex prior to calling FindFamilyStyleCharacter(). It
   // expects the mutex to already be locked.
-  SkAutoMutexAcquire scoped_mutex(style_sets_mutex_);
+  SkAutoMutexAcquire scoped_mutex(family_mutex_);
 
   // Search the fallback families for ones matching the requested language.
   // They are given priority over other fallback families in checking for
@@ -189,7 +195,7 @@
   for (int bcp47_index = bcp47_count; bcp47_index-- > 0;) {
     SkLanguage language(bcp47[bcp47_index]);
     while (!language.GetTag().isEmpty()) {
-      SkTypeface* matching_typeface = font_mgr->FindFamilyStyleCharacter(
+      SkTypeface* matching_typeface = font_manager->FindFamilyStyleCharacter(
           style, language.GetTag(), character);
       if (matching_typeface) {
         return matching_typeface;
@@ -203,7 +209,7 @@
   // requirement. This will select the first encountered family that contains
   // the character.
   SkTypeface* matching_typeface =
-      font_mgr->FindFamilyStyleCharacter(style, SkString(), character);
+      font_manager->FindFamilyStyleCharacter(style, SkString(), character);
 
   // If no family was found that supports the character, then just fall back
   // to the default family.
@@ -253,56 +259,58 @@
 void SkFontMgr_Cobalt::ParseConfigAndBuildFamilies(
     const char* font_config_directory, const char* font_files_directory,
     PriorityStyleSetArrayMap* priority_fallback_families) {
-  SkTDArray<FontFamily*> font_families;
+  SkTDArray<FontFamilyInfo*> config_font_families;
   {
     TRACE_EVENT0("cobalt::renderer", "SkFontConfigParser::GetFontFamilies()");
-    SkFontConfigParser::GetFontFamilies(font_config_directory, &font_families);
+    SkFontConfigParser::GetFontFamilies(font_config_directory,
+                                        &config_font_families);
   }
-  BuildNameToFamilyMap(font_files_directory, &font_families,
+  BuildNameToFamilyMap(font_files_directory, &config_font_families,
                        priority_fallback_families);
-  font_families.deleteAll();
+  config_font_families.deleteAll();
 }
 
 void SkFontMgr_Cobalt::BuildNameToFamilyMap(
-    const char* font_files_directory, SkTDArray<FontFamily*>* families,
+    const char* font_files_directory,
+    SkTDArray<FontFamilyInfo*>* config_font_families,
     PriorityStyleSetArrayMap* priority_fallback_families) {
   TRACE_EVENT0("cobalt::renderer", "SkFontMgr_Cobalt::BuildNameToFamilyMap()");
-  for (int i = 0; i < families->count(); i++) {
-    FontFamily& family = *(*families)[i];
-    bool named_family = family.names.count() > 0;
+  for (int i = 0; i < config_font_families->count(); i++) {
+    FontFamilyInfo& family_info = *(*config_font_families)[i];
+    bool is_named_family = family_info.names.count() > 0;
 
-    if (!named_family) {
+    if (!is_named_family) {
       // Unnamed families should always be fallback families.
-      DCHECK(family.is_fallback_family);
-      SkString& fallback_name = family.names.push_back();
-      fallback_name.printf("%.2x##fallback", font_style_sets_.count());
+      DCHECK(family_info.is_fallback_family);
+      SkString& fallback_name = family_info.names.push_back();
+      fallback_name.printf("%.2x##fallback", families_.count());
     }
 
-    SkAutoTUnref<SkFontStyleSet_Cobalt> new_set(
+    SkAutoTUnref<SkFontStyleSet_Cobalt> new_family(
         SkNEW_ARGS(SkFontStyleSet_Cobalt,
-                   (family, font_files_directory,
-                    &local_typeface_stream_manager_, &style_sets_mutex_)));
+                   (family_info, font_files_directory,
+                    &local_typeface_stream_manager_, &family_mutex_)));
 
-    // Do not add the set if none of its fonts were available. This allows the
-    // config file to specify a superset of all fonts, and ones that are not
-    // included in the final package are stripped out.
-    if (new_set->styles_.count() == 0) {
+    // Do not add the family if none of its fonts were available. This allows
+    // the configuration files to specify a superset of all fonts, and ones that
+    // are not included in the final package are stripped out.
+    if (new_family->styles_.count() == 0) {
       continue;
     }
 
-    font_style_sets_.push_back().reset(SkRef(new_set.get()));
+    families_.push_back().reset(SkRef(new_family.get()));
 
-    if (named_family) {
-      for (int j = 0; j < family.names.count(); j++) {
+    if (is_named_family) {
+      for (int j = 0; j < family_info.names.count(); j++) {
         // Verify that the name was not previously added.
-        if (name_to_family_map_.find(family.names[j].c_str()) ==
+        if (name_to_family_map_.find(family_info.names[j].c_str()) ==
             name_to_family_map_.end()) {
-          family_names_.push_back(family.names[j]);
+          family_names_.push_back(family_info.names[j]);
           name_to_family_map_.insert(
-              std::make_pair(family.names[j].c_str(), new_set.get()));
+              std::make_pair(family_info.names[j].c_str(), new_family.get()));
         } else {
-          NOTREACHED() << "Duplicate Font name: \"" << family.names[j].c_str()
-                       << "\"";
+          NOTREACHED() << "Duplicate Font name: \""
+                       << family_info.names[j].c_str() << "\"";
         }
       }
     }
@@ -311,35 +319,35 @@
     // that corresponds to its priority. This will be used to generate a
     // priority-ordered fallback families list once the family map is fully
     // built.
-    if (family.is_fallback_family) {
-      (*priority_fallback_families)[family.fallback_priority].push_back(
-          new_set.get());
+    if (family_info.is_fallback_family) {
+      (*priority_fallback_families)[family_info.fallback_priority].push_back(
+          new_family.get());
     }
 
     for (SkAutoTUnref<SkFontStyleSet_Cobalt::SkFontStyleSetEntry_Cobalt>*
-             font_style_set_entry = new_set->styles_.begin();
-         font_style_set_entry != new_set->styles_.end();
-         ++font_style_set_entry) {
+             family_style_entry = new_family->styles_.begin();
+         family_style_entry != new_family->styles_.end();
+         ++family_style_entry) {
       // On the first pass through, process the full font name.
       // On the second pass through, process the font postscript name.
       for (int i = 0; i <= 1; ++i) {
         const std::string& font_face_name =
-            i == 0 ? (*font_style_set_entry)->full_font_name
-                   : (*font_style_set_entry)->font_postscript_name;
+            i == 0 ? (*family_style_entry)->full_font_name
+                   : (*family_style_entry)->font_postscript_name;
         // If there is no font face name for this style entry, then there's
         // nothing to add. Simply skip past it.
         if (font_face_name.empty()) {
           continue;
         }
 
-        NameToStyleSetMap& font_face_name_style_set_map =
-            i == 0 ? full_font_name_to_style_set_map_
-                   : font_postscript_name_to_style_set_map_;
+        NameToStyleSetMap& font_face_name_to_family_map =
+            i == 0 ? full_font_name_to_family_map_
+                   : font_postscript_name_to_family_map_;
 
         // Verify that the font face name was not already added.
-        if (font_face_name_style_set_map.find(font_face_name) ==
-            font_face_name_style_set_map.end()) {
-          font_face_name_style_set_map[font_face_name] = new_set.get();
+        if (font_face_name_to_family_map.find(font_face_name) ==
+            font_face_name_to_family_map.end()) {
+          font_face_name_to_family_map[font_face_name] = new_family.get();
         } else {
           const std::string font_face_name_type =
               i == 0 ? "Full Font" : "Postscript";
@@ -375,28 +383,28 @@
 
 void SkFontMgr_Cobalt::FindDefaultFamily(
     const SkTArray<SkString, true>& default_families) {
-  CHECK(!font_style_sets_.empty());
+  CHECK(!families_.empty());
 
   for (size_t i = 0; i < default_families.count(); ++i) {
-    SkAutoTUnref<SkFontStyleSet_Cobalt> check_style_set(
+    SkAutoTUnref<SkFontStyleSet_Cobalt> check_family(
         onMatchFamily(default_families[i].c_str()));
-    if (NULL == check_style_set) {
+    if (check_family.get() == NULL) {
       continue;
     }
 
     SkAutoTUnref<SkTypeface> check_typeface(
-        check_style_set->MatchStyleWithoutLocking(SkFontStyle()));
-    if (NULL != check_typeface) {
-      default_family_ = check_style_set.get();
+        check_family->MatchStyleWithoutLocking(SkFontStyle()));
+    if (check_typeface.get() != NULL) {
+      default_family_ = check_family.get();
       break;
     }
   }
 
-  if (NULL == default_family_) {
+  if (default_family_ == NULL) {
     SkAutoTUnref<SkTypeface> check_typeface(
-        font_style_sets_[0]->MatchStyleWithoutLocking(SkFontStyle()));
-    if (NULL != check_typeface) {
-      default_family_ = font_style_sets_[0].get();
+        families_[0]->MatchStyleWithoutLocking(SkFontStyle()));
+    if (check_typeface.get() != NULL) {
+      default_family_ = families_[0].get();
     }
   }
 
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.h b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.h
index 5ea8eec..6ea9f51 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.h
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontMgr_cobalt.h
@@ -29,18 +29,25 @@
 #include "SkTArray.h"
 #include "SkTypeface.h"
 
-//  This class is essentially a collection of SkFontStyleSet_Cobalt, one
-//  SkFontStyleSet_Cobalt for each family. This class may be modified to load
-//  fonts from any source by changing the initialization.
+// This class, which is thread-safe, is Cobalt's implementation of SkFontMgr. It
+// is responsible for the creation of remote typefaces and for, given a set of
+// constraints, providing Cobalt with its best matching local typeface.
 //
-//  In addition to containing a collection of SkFontStyleSet_Cobalt, the class
-//  also contains a mapping of names to families, allowing for multiple aliases
-//  to map to the same back-end family.
+// When a remote typeface's raw data is downloaded from the web, it is provided
+// to the font manager, which returns a typeface created from that data.
 //
-//  It also contains a list of fallback fonts, which are used when attempting
-//  to match a character, rather than a family name. If a language is provided
-//  then fallback fonts with that language are given priority. Otherwise, the
-//  fallback fonts are checked in order.
+// For local typefaces, the font manager uses Cobalt-specific and
+// system-specific configuration files to generate named font families and
+// fallback font families. Cobalt uses named families when it needs a typeface
+// for a family with a specific name. It utilizes fallback families when none
+// of the listed named families supported a given character. In that case,
+// the manager finds the best match among the fallback families that can provide
+// a glyph for that character.
+//
+// For both named families and fallback families, after the manager locates the
+// best matching family, the determination of the specific typeface to use is
+// left to the family. The manager provides the family with the requested style
+// and the family returns the typeface that best fits that style.
 class SkFontMgr_Cobalt : public SkFontMgr {
  public:
   typedef std::vector<SkFontStyleSet_Cobalt*> StyleSetArray;
@@ -52,6 +59,9 @@
                    const char* system_font_files_directory,
                    const SkTArray<SkString, true>& default_fonts);
 
+  // Purges all font caching in Skia and the local stream manager.
+  void PurgeCaches();
+
   // NOTE: This returns NULL if a match is not found.
   SkTypeface* MatchFaceName(const char face_name[]);
 
@@ -74,8 +84,8 @@
   virtual SkTypeface* onMatchFamilyStyle(
       const char family_name[], const SkFontStyle& style) const SK_OVERRIDE;
 
-// NOTE: This always returns a non-NULL value. If no match can be found, then
-// the best match among the default family is returned.
+  // NOTE: This always returns a non-NULL value. If no match can be found, then
+  // the best match among the default family is returned.
   virtual SkTypeface* onMatchFamilyStyleCharacter(
       const char family_name[], const SkFontStyle& style, const char bcp47[],
       SkUnichar character) const SK_OVERRIDE;
@@ -111,7 +121,8 @@
       const char* font_config_directory, const char* font_files_directory,
       PriorityStyleSetArrayMap* priority_fallback_families);
   void BuildNameToFamilyMap(
-      const char* font_files_directory, SkTDArray<FontFamily*>* families,
+      const char* font_files_directory,
+      SkTDArray<FontFamilyInfo*>* config_font_families,
       PriorityStyleSetArrayMap* priority_fallback_families);
   void GeneratePriorityOrderedFallbackFamilies(
       const PriorityStyleSetArrayMap& priority_fallback_families);
@@ -131,14 +142,14 @@
 
   SkFileMemoryChunkStreamManager local_typeface_stream_manager_;
 
-  SkTArray<SkAutoTUnref<SkFontStyleSet_Cobalt>, true> font_style_sets_;
+  SkTArray<SkAutoTUnref<SkFontStyleSet_Cobalt>, true> families_;
 
   SkTArray<SkString> family_names_;
-  //  Map names to the back end so that all names for a given family refer to
-  //  the same (non-replicated) set of typefaces.
+  // Map names to the back end so that all names for a given family refer to
+  // the same (non-replicated) set of typefaces.
   NameToStyleSetMap name_to_family_map_;
-  NameToStyleSetMap full_font_name_to_style_set_map_;
-  NameToStyleSetMap font_postscript_name_to_style_set_map_;
+  NameToStyleSetMap full_font_name_to_family_map_;
+  NameToStyleSetMap font_postscript_name_to_family_map_;
 
   // Fallback families that are used during character fallback.
   // All fallback families, regardless of language.
@@ -148,12 +159,12 @@
   ScopedVector<StyleSetArray> language_fallback_families_array_;
   NameToStyleSetArrayMap language_fallback_families_map_;
 
-  // The default family that is used when no specific match is found during  a
+  // The default family that is used when no specific match is found during a
   // request.
   SkFontStyleSet_Cobalt* default_family_;
 
-  // Mutex shared by all style sets for accessing their modifiable data.
-  mutable SkMutex style_sets_mutex_;
+  // Mutex shared by all families for accessing their modifiable data.
+  mutable SkMutex family_mutex_;
 };
 
 #endif  // COBALT_RENDERER_RASTERIZER_SKIA_SKIA_SRC_PORTS_SKFONTMGR_COBALT_H_
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontStyleSet_cobalt.cc b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontStyleSet_cobalt.cc
index 4774f00..2b5718b 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontStyleSet_cobalt.cc
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontStyleSet_cobalt.cc
@@ -87,27 +87,27 @@
 }
 
 SkFontStyleSet_Cobalt::SkFontStyleSet_Cobalt(
-    const FontFamily& family, const char* base_path,
+    const FontFamilyInfo& family_info, const char* base_path,
     SkFileMemoryChunkStreamManager* const local_typeface_stream_manager,
     SkMutex* const manager_owned_mutex)
     : local_typeface_stream_manager_(local_typeface_stream_manager),
       manager_owned_mutex_(manager_owned_mutex),
-      is_fallback_family_(family.is_fallback_family),
-      language_(family.language),
-      page_ranges_(family.page_ranges),
+      is_fallback_family_(family_info.is_fallback_family),
+      language_(family_info.language),
+      page_ranges_(family_info.page_ranges),
       is_character_map_generated_(!is_fallback_family_) {
   TRACE_EVENT0("cobalt::renderer",
                "SkFontStyleSet_Cobalt::SkFontStyleSet_Cobalt()");
   DCHECK(manager_owned_mutex_);
 
-  if (family.names.count() == 0) {
+  if (family_info.names.count() == 0) {
     return;
   }
 
-  family_name_ = family.names[0];
+  family_name_ = family_info.names[0];
 
-  for (int i = 0; i < family.fonts.count(); ++i) {
-    const FontFileInfo& font_file = family.fonts[i];
+  for (int i = 0; i < family_info.fonts.count(); ++i) {
+    const FontFileInfo& font_file = family_info.fonts[i];
 
     SkString file_path(SkOSPath::Join(base_path, font_file.file_name.c_str()));
 
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontStyleSet_cobalt.h b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontStyleSet_cobalt.h
index 3d1f7c7..7d6648a 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontStyleSet_cobalt.h
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontStyleSet_cobalt.h
@@ -25,20 +25,27 @@
 #include "SkTArray.h"
 #include "SkTypeface.h"
 
-// This class is used by SkFontMgr_Cobalt to store families of
-// SkTypeface_Cobalt objects.
+// This class, which is thread-safe, is Cobalt's implementation of
+// SkFontStyleSet. It represents a collection of local typefaces that support
+// the same set of characters but with different styles. When a specific style
+// is requested, SkFontStyleSet returns the typeface that best matches that
+// style.
 //
-// Both the full character map of the style set and the typeface of each
-// individual entry are lazily loaded the first time that they are needed. After
-// this, they are retained in memory.
+// SkFontStyleSet contains a map of the characters that it supports. It uses
+// this map to quickly check for whether or not its typefaces can provide glyphs
+// for specific characters during fallback.
+//
+// Both the character map of the style set and the typeface of each individual
+// entry are lazily loaded the first time that they are needed. After this, they
+// are retained in memory.
 class SkFontStyleSet_Cobalt : public SkFontStyleSet {
  public:
   struct SkFontStyleSetEntry_Cobalt : public SkRefCnt {
-    // NOTE: |SkFontStyleSetEntry_Cobalt| objects are not guaranteed to last for
-    // the lifetime of |SkFontMgr_Cobalt| and can be removed by their owning
-    // |SkFontStyleSet_Cobalt| if their typeface fails to load properly. As a
+    // NOTE: SkFontStyleSetEntry_Cobalt objects are not guaranteed to last for
+    // the lifetime of SkFontMgr_Cobalt and can be removed by their owning
+    // SkFontStyleSet_Cobalt if their typeface fails to load properly. As a
     // result, it is not safe to store their pointers outside of
-    // |SkFontStyleSet_Cobalt|.
+    // SkFontStyleSet_Cobalt.
     SkFontStyleSetEntry_Cobalt(const SkString& file_path, const int face_index,
                                const SkFontStyle& style,
                                const std::string& full_name,
@@ -72,17 +79,17 @@
   };
 
   SkFontStyleSet_Cobalt(
-      const FontFamily& family, const char* base_path,
+      const FontFamilyInfo& family_info, const char* base_path,
       SkFileMemoryChunkStreamManager* const local_typeface_stream_manager,
       SkMutex* const manager_owned_mutex);
 
   // From SkFontStyleSet
   virtual int count() SK_OVERRIDE;
-  // NOTE: SkFontStyleSet_Cobalt does not support |getStyle|, as publicly
+  // NOTE: SkFontStyleSet_Cobalt does not support getStyle(), as publicly
   // accessing styles by index is unsafe.
   virtual void getStyle(int index, SkFontStyle* style,
                         SkString* name) SK_OVERRIDE;
-  // NOTE: SkFontStyleSet_Cobalt does not support |createTypeface|, as
+  // NOTE: SkFontStyleSet_Cobalt does not support createTypeface(), as
   // publicly accessing styles by index is unsafe.
   virtual SkTypeface* createTypeface(int index) SK_OVERRIDE;
 
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontUtil_cobalt.h b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontUtil_cobalt.h
index 5aeb2c8..6b3b175 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontUtil_cobalt.h
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkFontUtil_cobalt.h
@@ -117,16 +117,22 @@
   SkString postscript_name;
 };
 
-// A font family provides one or more names for a collection of fonts, each of
-// which has a different style (normal, italic) or weight (thin, light, bold,
-// etc).
-// Cobalt distinguishes "fallback" fonts to support non-ASCII character sets.
-// Page ranges are used to indicate the pages where a fallback font supports
-// at least one character. This allows Cobalt to quickly determine fonts that
-// cannot possible contain a character, without needing to load the font file
-// and generate a full mapping of the font's characters.
-struct FontFamily {
-  FontFamily() : is_fallback_family(true), fallback_priority(0) {}
+// A font family is a collection of fonts, which support the same characters,
+// each of which has a different style (normal, italic) or weight (thin, light,
+// bold, etc).
+//
+// Families can have any number of names, each of which can be used to look up
+// the family.
+//
+// Additionally, families can be fallback families, which are used to support
+// character sets that are unavailable within the named fonts.
+//
+// Page ranges are used with fallback families to indicate 256 character pages
+// where it contains at least one character. This allows Cobalt to quickly
+// determine that a family cannot support a character, without needing to
+// generate a full mapping of the family's characters.
+struct FontFamilyInfo {
+  FontFamilyInfo() : is_fallback_family(true), fallback_priority(0) {}
 
   SkTArray<SkString> names;
   SkTArray<FontFileInfo> fonts;
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkStream_cobalt.cc b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkStream_cobalt.cc
index 60d30dc..237cfb1 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkStream_cobalt.cc
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkStream_cobalt.cc
@@ -23,12 +23,12 @@
 #include "SkOSFile.h"
 
 SkFileMemoryChunkStreamManager::SkFileMemoryChunkStreamManager(
-    const std::string& name, int cache_size_in_bytes)
-    : available_chunk_count_(cache_size_in_bytes /
+    const std::string& name, int cache_capacity_in_bytes)
+    : available_chunk_count_(cache_capacity_in_bytes /
                              SkFileMemoryChunk::kSizeInBytes),
-      cache_limit_in_bytes_(StringPrintf("Memory.%s.Capacity", name.c_str()),
-                            cache_size_in_bytes,
-                            "The byte capacity of the cache."),
+      cache_capacity_in_bytes_(StringPrintf("Memory.%s.Capacity", name.c_str()),
+                               cache_capacity_in_bytes,
+                               "The byte capacity of the cache."),
       cache_size_in_bytes_(
           StringPrintf("Memory.%s.Size", name.c_str()), 0,
           "Total number of bytes currently used by the cache.") {}
@@ -56,6 +56,15 @@
   return stream_provider;
 }
 
+void SkFileMemoryChunkStreamManager::PurgeUnusedMemoryChunks() {
+  SkAutoMutexAcquire scoped_mutex(stream_provider_mutex_);
+  for (ScopedVector<SkFileMemoryChunkStreamProvider>::iterator iter =
+           stream_provider_array_.begin();
+       iter != stream_provider_array_.end(); ++iter) {
+    (*iter)->PurgeUnusedMemoryChunks();
+  }
+}
+
 bool SkFileMemoryChunkStreamManager::TryReserveMemoryChunk() {
   // First check to see if the count is already 0. If it is, then there's no
   // available memory chunk to try to reserve. Simply return failure.
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkStream_cobalt.h b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkStream_cobalt.h
index 7adb62f..77266cc 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkStream_cobalt.h
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkStream_cobalt.h
@@ -67,13 +67,16 @@
 class SkFileMemoryChunkStreamManager {
  public:
   SkFileMemoryChunkStreamManager(const std::string& name,
-                                 int cache_size_in_bytes);
+                                 int cache_capacity_in_bytes);
 
   // Returns the stream provider associated with the file path. If it does not
   // exist then it is created.
   SkFileMemoryChunkStreamProvider* GetStreamProvider(
       const std::string& file_path);
 
+  // Purges unused memory chunks from all existing stream providers.
+  void PurgeUnusedMemoryChunks();
+
  private:
   friend SkFileMemoryChunkStreamProvider;
 
@@ -90,7 +93,7 @@
   base::subtle::Atomic32 available_chunk_count_;
 
   const base::CVal<base::cval::SizeInBytes, base::CValPublic>
-      cache_limit_in_bytes_;
+      cache_capacity_in_bytes_;
   base::CVal<base::cval::SizeInBytes, base::CValPublic> cache_size_in_bytes_;
 
   DISALLOW_COPY_AND_ASSIGN(SkFileMemoryChunkStreamManager);
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.cc b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.cc
index 4bec9d0..4ad07b9 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.cc
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.cc
@@ -19,7 +19,7 @@
 
 SkTypeface_Cobalt::SkTypeface_Cobalt(int face_index, Style style,
                                      bool is_fixed_pitch,
-                                     const SkString family_name)
+                                     const SkString& family_name)
     : INHERITED(style, SkTypefaceCache::NewFontID(), is_fixed_pitch),
       face_index_(face_index),
       family_name_(family_name),
@@ -32,7 +32,7 @@
 SkTypeface_CobaltStream::SkTypeface_CobaltStream(SkStreamAsset* stream,
                                                  int face_index, Style style,
                                                  bool is_fixed_pitch,
-                                                 const SkString family_name)
+                                                 const SkString& family_name)
     : INHERITED(face_index, style, is_fixed_pitch, family_name),
       stream_(SkRef(stream)) {
   LOG(INFO) << "Created SkTypeface_CobaltStream: " << family_name.c_str() << "("
@@ -56,7 +56,7 @@
 
 SkTypeface_CobaltStreamProvider::SkTypeface_CobaltStreamProvider(
     SkFileMemoryChunkStreamProvider* stream_provider, int face_index,
-    Style style, bool is_fixed_pitch, const SkString family_name,
+    Style style, bool is_fixed_pitch, const SkString& family_name,
     bool disable_synthetic_bolding)
     : INHERITED(face_index, style, is_fixed_pitch, family_name),
       stream_provider_(stream_provider) {
diff --git a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h
index 4fcbda5..2ac66ab 100644
--- a/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h
+++ b/src/cobalt/renderer/rasterizer/skia/skia/src/ports/SkTypeface_cobalt.h
@@ -26,7 +26,7 @@
 class SkTypeface_Cobalt : public SkTypeface_FreeType {
  public:
   SkTypeface_Cobalt(int face_index, Style style, bool is_fixed_pitch,
-                    const SkString family_name);
+                    const SkString& family_name);
 
   bool synthesizes_bold() const { return synthesizes_bold_; }
 
@@ -44,7 +44,7 @@
 class SkTypeface_CobaltStream : public SkTypeface_Cobalt {
  public:
   SkTypeface_CobaltStream(SkStreamAsset* stream, int face_index, Style style,
-                          bool is_fixed_pitch, const SkString family_name);
+                          bool is_fixed_pitch, const SkString& family_name);
 
   virtual void onGetFontDescriptor(SkFontDescriptor* descriptor,
                                    bool* serialize) const SK_OVERRIDE;
@@ -61,7 +61,7 @@
  public:
   SkTypeface_CobaltStreamProvider(
       SkFileMemoryChunkStreamProvider* stream_provider, int face_index,
-      Style style, bool is_fixed_pitch, const SkString family_name,
+      Style style, bool is_fixed_pitch, const SkString& family_name,
       bool disable_synthetic_bolding);
 
   virtual void onGetFontDescriptor(SkFontDescriptor* descriptor,
diff --git a/src/cobalt/renderer/rasterizer/skia/software_resource_provider.cc b/src/cobalt/renderer/rasterizer/skia/software_resource_provider.cc
index e4db0c1..32d795e 100644
--- a/src/cobalt/renderer/rasterizer/skia/software_resource_provider.cc
+++ b/src/cobalt/renderer/rasterizer/skia/software_resource_provider.cc
@@ -233,6 +233,13 @@
   return scoped_refptr<render_tree::Image>(NULL);
 }
 
+void SoftwareResourceProvider::PurgeCaches() {
+  SkAutoTUnref<SkFontMgr> font_manager(SkFontMgr::RefDefault());
+  SkFontMgr_Cobalt* cobalt_font_manager =
+      base::polymorphic_downcast<SkFontMgr_Cobalt*>(font_manager.get());
+  cobalt_font_manager->PurgeCaches();
+}
+
 }  // namespace skia
 }  // namespace rasterizer
 }  // namespace renderer
diff --git a/src/cobalt/renderer/rasterizer/skia/software_resource_provider.h b/src/cobalt/renderer/rasterizer/skia/software_resource_provider.h
index 4ed9bde..1f0d1f4 100644
--- a/src/cobalt/renderer/rasterizer/skia/software_resource_provider.h
+++ b/src/cobalt/renderer/rasterizer/skia/software_resource_provider.h
@@ -121,6 +121,8 @@
   scoped_refptr<render_tree::Image> DrawOffscreenImage(
       const scoped_refptr<render_tree::Node>& root) OVERRIDE;
 
+  void PurgeCaches() OVERRIDE;
+
  private:
   TextShaper text_shaper_;
 };
diff --git a/src/cobalt/script/mozjs-45/mozjs_global_environment.cc b/src/cobalt/script/mozjs-45/mozjs_global_environment.cc
index 624d591..2f5af46 100644
--- a/src/cobalt/script/mozjs-45/mozjs_global_environment.cc
+++ b/src/cobalt/script/mozjs-45/mozjs_global_environment.cc
@@ -382,26 +382,38 @@
 void MozjsGlobalEnvironment::BeginGarbageCollection() {
   TRACK_MEMORY_SCOPE("Javascript");
   // It's possible that a GC could be triggered from within the
-  // BeginGarbageCollection callback. Only create the OpaqueRootState the first
-  // time we enter.
+  // BeginGarbageCollection callback. Only create the OpaqueRootState the
+  // first time we enter. Also, only verify that |visisted_wrappables_| is
+  // empty in this case.
+  // TODO: Opaque root logic is a special case of tracing wrappables, and
+  // should be removed.
   garbage_collection_count_++;
-  if (global_object_proxy_ && garbage_collection_count_ == 1) {
-    DCHECK(!opaque_root_state_);
-    JSAutoRequest auto_request(context_);
-    JSAutoCompartment auto_compartment(context_, global_object_proxy_);
-    // Get the current state of opaque root relationships. Keep this object
-    // alive for the duration of the GC phase to ensure that reachability
-    // between roots and reachable objects is maintained.
-    opaque_root_state_ = opaque_root_tracker_->GetCurrentOpaqueRootState();
+
+  if (garbage_collection_count_ == 1) {
+    if (global_object_proxy_) {
+      DCHECK(!opaque_root_state_);
+      JSAutoRequest auto_request(context_);
+      JSAutoCompartment auto_compartment(context_, global_object_proxy_);
+      // Get the current state of opaque root relationships. Keep this object
+      // alive for the duration of the GC phase to ensure that reachability
+      // between roots and reachable objects is maintained.
+      opaque_root_state_ = opaque_root_tracker_->GetCurrentOpaqueRootState();
+    }
+
+    DCHECK_EQ(visited_wrappables_.size(), 0);
   }
 }
 
 void MozjsGlobalEnvironment::EndGarbageCollection() {
-  // Reset opaque root reachability relationships.
+  // Reset opaque root reachability relationships. Also reset
+  // |visisted_wrappables_|.
+  // TODO: Opaque root logic is a special case of tracing wrappables, and
+  // should be removed.
   garbage_collection_count_--;
   DCHECK_GE(garbage_collection_count_, 0);
   if (garbage_collection_count_ == 0) {
     opaque_root_state_.reset(NULL);
+    visited_wrappables_.clear();
   }
 }
 
diff --git a/src/cobalt/script/mozjs-45/mozjs_global_environment.h b/src/cobalt/script/mozjs-45/mozjs_global_environment.h
index e23f1bb..c6cfb2a 100644
--- a/src/cobalt/script/mozjs-45/mozjs_global_environment.h
+++ b/src/cobalt/script/mozjs-45/mozjs_global_environment.h
@@ -103,6 +103,10 @@
     return opaque_root_tracker_.get();
   }
 
+  base::hash_set<Wrappable*>* visited_wrappables() {
+    return &visited_wrappables_;
+  }
+
   // Used for CallWith=EnvironmentSettings
   void SetEnvironmentSettings(EnvironmentSettings* environment_settings) {
     DCHECK(!environment_settings_);
@@ -174,6 +178,8 @@
   scoped_ptr<OpaqueRootTracker::OpaqueRootState> opaque_root_state_;
   JS::Heap<JSObject*> global_object_proxy_;
   EnvironmentSettings* environment_settings_;
+  // TODO: Should be |std::unordered_set| once C++11 is enabled.
+  base::hash_set<Wrappable*> visited_wrappables_;
 
   // If non-NULL, the error message from the ReportErrorHandler will get
   // assigned to this instead of being printed.
diff --git a/src/cobalt/script/mozjs-45/wrapper_factory.cc b/src/cobalt/script/mozjs-45/wrapper_factory.cc
index c4ed731..9395b73 100644
--- a/src/cobalt/script/mozjs-45/wrapper_factory.cc
+++ b/src/cobalt/script/mozjs-45/wrapper_factory.cc
@@ -56,6 +56,13 @@
   return wrapper_proxy;
 }
 
+bool WrapperFactory::HasWrapperProxy(
+    const scoped_refptr<Wrappable>& wrappable) const {
+  return wrappable &&
+         !!MozjsWrapperHandle::GetObjectProxy(
+             GetCachedWrapper(wrappable.get()));
+}
+
 bool WrapperFactory::IsWrapper(JS::HandleObject wrapper) const {
   return JS_GetPrivate(wrapper) != NULL;
 }
diff --git a/src/cobalt/script/mozjs-45/wrapper_factory.h b/src/cobalt/script/mozjs-45/wrapper_factory.h
index ba83745..043b96c 100644
--- a/src/cobalt/script/mozjs-45/wrapper_factory.h
+++ b/src/cobalt/script/mozjs-45/wrapper_factory.h
@@ -46,6 +46,12 @@
   // Gets the Proxy for the Wrapper object for this Wrappable. It may create a
   // new Wrapper and Proxy.
   JSObject* GetWrapperProxy(const scoped_refptr<Wrappable>& wrappable) const;
+
+  // Check whether the Proxy for the Wrapper object for this Wrappable exists
+  // or not. This will NOT create a new Wrapper and Proxy if they do not
+  // already exist.
+  bool HasWrapperProxy(const scoped_refptr<Wrappable>& wrappable) const;
+
   // Returns true if this JSObject is a Wrapper object.
   bool IsWrapper(JS::HandleObject wrapper) const;
 
diff --git a/src/cobalt/script/mozjs-45/wrapper_private.cc b/src/cobalt/script/mozjs-45/wrapper_private.cc
index ecb9fdd..44a0930 100644
--- a/src/cobalt/script/mozjs-45/wrapper_private.cc
+++ b/src/cobalt/script/mozjs-45/wrapper_private.cc
@@ -14,6 +14,7 @@
 
 #include "cobalt/script/mozjs-45/wrapper_private.h"
 
+#include "base/hash_tables.h"
 #include "cobalt/script/mozjs-45/mozjs_global_environment.h"
 #include "cobalt/script/mozjs-45/proxy_handler.h"
 #include "cobalt/script/mozjs-45/referenced_object_map.h"
@@ -26,6 +27,68 @@
 namespace script {
 namespace mozjs {
 
+void Tracer::Trace(Wrappable* wrappable) {
+  // Clearly, a null wrappable could not possibly reference any other
+  // wrappables.
+  if (!wrappable) {
+    return;
+  }
+
+  // Unfortunately, |JSTracer| will only supply us with a |JSRuntime|,
+  // rather than a |JSContext|. Fortunately, Cobalt will only create one
+  // global environment per runtime, so we can still safely get back to our
+  // context, and thus our global environment.
+  JSContext* context = NULL;
+  JS_ContextIterator(js_tracer_->runtime(), &context);
+  DCHECK(context);
+  MozjsGlobalEnvironment* global_environment =
+      MozjsGlobalEnvironment::GetFromContext(context);
+  DCHECK(global_environment);
+
+  // Clearly, if we have already visited this wrappable during the current
+  // tracing session, there is no need to visit it again. We rely on
+  // |JS_SetGCCallback| in the |MozjsEngine| to properly manage clearing
+  // |visited_wrappables_| in between GC sessions.
+  base::hash_set<Wrappable*>* visited_wrappables =
+      global_environment->visited_wrappables();
+  DCHECK(visited_wrappables);
+  if (!visited_wrappables->insert(wrappable).second) {
+    return;
+  }
+
+  // There are now two cases left to handle. Since we cannot create the
+  // wrapper while tracing due to internal SpiderMonkey restrictions, we will
+  // instead directly call |TraceMembers| here if the wrapper does not exist.
+  // In the case where the wrapper already does exist, we will pass the
+  // wrapper to |JS_CallObjectTracer|, and rely on SpiderMonkey to begin
+  // another |WrapperPrivate::Trace| on that wrapper.
+  WrapperFactory* wrapper_factory = global_environment->wrapper_factory();
+  if (!wrapper_factory->HasWrapperProxy(wrappable)) {
+    frontier_.push_back(wrappable);
+  } else {
+    JSObject* proxy_object = wrapper_factory->GetWrapperProxy(wrappable);
+    JSObject* target = js::GetProxyTargetObject(proxy_object);
+    WrapperPrivate* wrapper_private =
+        static_cast<WrapperPrivate*>(JS_GetPrivate(target));
+    DCHECK(wrapper_private->context_ == context);
+    DCHECK(wrapper_private->wrapper_proxy_);
+    JS_CallObjectTracer(js_tracer_, &wrapper_private->wrapper_proxy_,
+                        "WrapperPrivate::TraceWrappable");
+  }
+
+  DCHECK(JS_ContextIterator(js_tracer_->runtime(), &context) == NULL);
+}
+
+void Tracer::TraceFrom(Wrappable* wrappable) {
+  DCHECK(frontier_.empty());
+  frontier_.push_back(wrappable);
+  while (!frontier_.empty()) {
+    Wrappable* wrappable = frontier_.back();
+    frontier_.pop_back();
+    wrappable->TraceMembers(this);
+  }
+}
+
 Wrappable* WrapperPrivate::GetOpaqueRoot() const {
   if (!get_opaque_root_function_.is_null()) {
     return get_opaque_root_function_.Run(wrappable_);
@@ -152,6 +215,8 @@
         wrapper_private->wrappable_.get());
     global_environment->referenced_objects()->TraceReferencedObjects(trace,
                                                                      key);
+    Tracer tracer(trace);
+    tracer.TraceFrom(wrapper_private->wrappable_);
   }
 }
 
diff --git a/src/cobalt/script/mozjs-45/wrapper_private.h b/src/cobalt/script/mozjs-45/wrapper_private.h
index dc1a955..7e4b917 100644
--- a/src/cobalt/script/mozjs-45/wrapper_private.h
+++ b/src/cobalt/script/mozjs-45/wrapper_private.h
@@ -28,6 +28,29 @@
 namespace script {
 namespace mozjs {
 
+// Our mozjs specific implementation of |script::Tracer|. Tracing sessions
+// will be initiated from a |Wrapper| of SpiderMonkey's choice, and then it
+// will be the |mozjs::Tracer|'s job to assist SpiderMonkey's garbage
+// collector in traversing the graph of |Wrapper|s and |Wrappable|s.
+// |Wrappable|s will inform us about what they can reach through their
+// |TraceMembers| implementation, and then we will pass the reachable
+// |Wrappable|'s |Wrapper| to SpiderMonkey GC if it exists, and otherwise
+// continue traversing ourselves from |Wrappable| to (the unwrapped)
+// |Wrappable|.
+class Tracer : public ::cobalt::script::Tracer {
+ public:
+  explicit Tracer(JSTracer* js_tracer) : js_tracer_(js_tracer) {}
+  void Trace(Wrappable* wrappable) OVERRIDE;
+
+  void TraceFrom(Wrappable* wrappable);
+
+ private:
+  JSTracer* js_tracer_;
+  // Pending |Wrappable|s that we must traverse ourselves, since they did not
+  // have a |Wrapper|.
+  std::vector<Wrappable*> frontier_;
+};
+
 // Contains private data associated with a JSObject representing a JS wrapper
 // for a Cobalt platform object. There should be a one-to-one mapping of such
 // JSObjects and WrapperPrivate instances, and the corresponding WrapperPrivate
@@ -107,6 +130,8 @@
   JS::Heap<JSObject*> wrapper_proxy_;
   GetOpaqueRootFunction get_opaque_root_function_;
   GetReachableWrappablesFunction get_reachable_wrappables_function_;
+
+  friend Tracer;
 };
 
 }  // namespace mozjs
diff --git a/src/cobalt/script/mozjs/mozjs_global_environment.cc b/src/cobalt/script/mozjs/mozjs_global_environment.cc
index a6bc89f..e306a50 100644
--- a/src/cobalt/script/mozjs/mozjs_global_environment.cc
+++ b/src/cobalt/script/mozjs/mozjs_global_environment.cc
@@ -394,26 +394,38 @@
 void MozjsGlobalEnvironment::BeginGarbageCollection() {
   TRACK_MEMORY_SCOPE("Javascript");
   // It's possible that a GC could be triggered from within the
-  // BeginGarbageCollection callback. Only create the OpaqueRootState the first
-  // time we enter.
+  // BeginGarbageCollection callback. Only create the OpaqueRootState the
+  // first time we enter. Also, only verify that |visisted_wrappables_| is
+  // empty in this case.
+  // TODO: Opaque root logic is a special case of tracing wrappables, and
+  // should be removed.
   garbage_collection_count_++;
-  if (global_object_proxy_ && garbage_collection_count_ == 1) {
-    DCHECK(!opaque_root_state_);
-    JSAutoRequest auto_request(context_);
-    JSAutoCompartment auto_compartment(context_, global_object_proxy_);
-    // Get the current state of opaque root relationships. Keep this object
-    // alive for the duration of the GC phase to ensure that reachability
-    // between roots and reachable objects is maintained.
-    opaque_root_state_ = opaque_root_tracker_->GetCurrentOpaqueRootState();
+
+  if (garbage_collection_count_ == 1) {
+    if (global_object_proxy_) {
+      DCHECK(!opaque_root_state_);
+      JSAutoRequest auto_request(context_);
+      JSAutoCompartment auto_compartment(context_, global_object_proxy_);
+      // Get the current state of opaque root relationships. Keep this object
+      // alive for the duration of the GC phase to ensure that reachability
+      // between roots and reachable objects is maintained.
+      opaque_root_state_ = opaque_root_tracker_->GetCurrentOpaqueRootState();
+    }
+
+    DCHECK_EQ(visited_wrappables_.size(), 0);
   }
 }
 
 void MozjsGlobalEnvironment::EndGarbageCollection() {
-  // Reset opaque root reachability relationships.
+  // Reset opaque root reachability relationships. Also reset
+  // |visisted_wrappables_|.
+  // TODO: Opaque root logic is a special case of tracing wrappables, and
+  // should be removed.
   garbage_collection_count_--;
   DCHECK_GE(garbage_collection_count_, 0);
   if (garbage_collection_count_ == 0) {
     opaque_root_state_.reset(NULL);
+    visited_wrappables_.clear();
   }
 }
 
diff --git a/src/cobalt/script/mozjs/mozjs_global_environment.h b/src/cobalt/script/mozjs/mozjs_global_environment.h
index 628631a..6c79872 100644
--- a/src/cobalt/script/mozjs/mozjs_global_environment.h
+++ b/src/cobalt/script/mozjs/mozjs_global_environment.h
@@ -102,6 +102,10 @@
     return opaque_root_tracker_.get();
   }
 
+  base::hash_set<Wrappable*>* visited_wrappables() {
+    return &visited_wrappables_;
+  }
+
   // Used for CallWith=EnvironmentSettings
   void SetEnvironmentSettings(EnvironmentSettings* environment_settings) {
     DCHECK(!environment_settings_);
@@ -174,6 +178,8 @@
   scoped_ptr<OpaqueRootTracker::OpaqueRootState> opaque_root_state_;
   JS::Heap<JSObject*> global_object_proxy_;
   EnvironmentSettings* environment_settings_;
+  // TODO: Should be |std::unordered_set| once C++11 is enabled.
+  base::hash_set<Wrappable*> visited_wrappables_;
 
   // If non-NULL, the error message from the ReportErrorHandler will get
   // assigned to this instead of being printed.
diff --git a/src/cobalt/script/mozjs/wrapper_factory.cc b/src/cobalt/script/mozjs/wrapper_factory.cc
index 968003c..c456283 100644
--- a/src/cobalt/script/mozjs/wrapper_factory.cc
+++ b/src/cobalt/script/mozjs/wrapper_factory.cc
@@ -56,6 +56,13 @@
   return wrapper_proxy;
 }
 
+bool WrapperFactory::HasWrapperProxy(
+    const scoped_refptr<Wrappable>& wrappable) const {
+  return wrappable &&
+         !!MozjsWrapperHandle::GetObjectProxy(
+             GetCachedWrapper(wrappable.get()));
+}
+
 bool WrapperFactory::IsWrapper(JS::HandleObject wrapper) const {
   return JS_GetPrivate(wrapper) != NULL;
 }
diff --git a/src/cobalt/script/mozjs/wrapper_factory.h b/src/cobalt/script/mozjs/wrapper_factory.h
index 357132d..ffe4e3d 100644
--- a/src/cobalt/script/mozjs/wrapper_factory.h
+++ b/src/cobalt/script/mozjs/wrapper_factory.h
@@ -46,6 +46,12 @@
   // Gets the Proxy for the Wrapper object for this Wrappable. It may create a
   // new Wrapper and Proxy.
   JSObject* GetWrapperProxy(const scoped_refptr<Wrappable>& wrappable) const;
+
+  // Check whether the Proxy for the Wrapper object for this Wrappable exists
+  // or not. This will NOT create a new Wrapper and Proxy if they do not
+  // already exist.
+  bool HasWrapperProxy(const scoped_refptr<Wrappable>& wrappable) const;
+
   // Returns true if this JSObject is a Wrapper object.
   bool IsWrapper(JS::HandleObject wrapper) const;
 
diff --git a/src/cobalt/script/mozjs/wrapper_private.cc b/src/cobalt/script/mozjs/wrapper_private.cc
index 0095269..7b8d983 100644
--- a/src/cobalt/script/mozjs/wrapper_private.cc
+++ b/src/cobalt/script/mozjs/wrapper_private.cc
@@ -14,6 +14,7 @@
 
 #include "cobalt/script/mozjs/wrapper_private.h"
 
+#include "base/hash_tables.h"
 #include "cobalt/script/mozjs/mozjs_global_environment.h"
 #include "cobalt/script/mozjs/proxy_handler.h"
 #include "cobalt/script/mozjs/referenced_object_map.h"
@@ -25,6 +26,68 @@
 namespace script {
 namespace mozjs {
 
+void Tracer::Trace(Wrappable* wrappable) {
+  // Clearly, a null wrappable could not possibly reference any other
+  // wrappables.
+  if (!wrappable) {
+    return;
+  }
+
+  // Unfortunately, |JSTracer| will only supply us with a |JSRuntime|,
+  // rather than a |JSContext|. Fortunately, Cobalt will only create one
+  // global environment per runtime, so we can still safely get back to our
+  // context, and thus our global environment.
+  JSContext* context = NULL;
+  JS_ContextIterator(js_tracer_->runtime, &context);
+  DCHECK(context);
+  MozjsGlobalEnvironment* global_environment =
+      MozjsGlobalEnvironment::GetFromContext(context);
+  DCHECK(global_environment);
+
+  // Clearly, if we have already visited this wrappable during the current
+  // tracing session, there is no need to visit it again. We rely on
+  // |JS_SetGCCallback| in the |MozjsEngine| to properly manage clearing
+  // |visited_wrappables_| in between GC sessions.
+  base::hash_set<Wrappable*>* visited_wrappables =
+      global_environment->visited_wrappables();
+  DCHECK(visited_wrappables);
+  if (!visited_wrappables->insert(wrappable).second) {
+    return;
+  }
+
+  // There are now two cases left to handle. Since we cannot create the
+  // wrapper while tracing due to internal SpiderMonkey restrictions, we
+  // will instead directly call |TraceMembers| here if the wrapper does not
+  // exist. In the case where the wrapper already does exist, we will pass
+  // the wrapper to |JS_CallHeapObjectTracer|, and rely on SpiderMonkey to
+  // begin another |WrapperPrivate::Trace| on that wrapper.
+  WrapperFactory* wrapper_factory = global_environment->wrapper_factory();
+  if (!wrapper_factory->HasWrapperProxy(wrappable)) {
+    frontier_.push_back(wrappable);
+  } else {
+    JSObject* proxy_object = wrapper_factory->GetWrapperProxy(wrappable);
+    JSObject* target = js::GetProxyTargetObject(proxy_object);
+    WrapperPrivate* wrapper_private =
+        static_cast<WrapperPrivate*>(JS_GetPrivate(target));
+    DCHECK(wrapper_private->context_ == context);
+    DCHECK(wrapper_private->wrapper_proxy_);
+    JS_CallHeapObjectTracer(js_tracer_, &wrapper_private->wrapper_proxy_,
+                            "WrapperPrivate::TraceWrappable");
+  }
+
+  DCHECK(JS_ContextIterator(js_tracer_->runtime, &context) == NULL);
+}
+
+void Tracer::TraceFrom(Wrappable* wrappable) {
+  DCHECK(frontier_.empty());
+  frontier_.push_back(wrappable);
+  while (!frontier_.empty()) {
+    Wrappable* wrappable = frontier_.back();
+    frontier_.pop_back();
+    wrappable->TraceMembers(this);
+  }
+}
+
 Wrappable* WrapperPrivate::GetOpaqueRoot() const {
   if (!get_opaque_root_function_.is_null()) {
     return get_opaque_root_function_.Run(wrappable_);
@@ -148,6 +211,8 @@
         wrapper_private->wrappable_.get());
     global_environment->referenced_objects()->TraceReferencedObjects(trace,
                                                                      key);
+    Tracer tracer(trace);
+    tracer.TraceFrom(wrapper_private->wrappable_);
   }
 }
 
diff --git a/src/cobalt/script/mozjs/wrapper_private.h b/src/cobalt/script/mozjs/wrapper_private.h
index 85a1ee4..1ac464f 100644
--- a/src/cobalt/script/mozjs/wrapper_private.h
+++ b/src/cobalt/script/mozjs/wrapper_private.h
@@ -28,6 +28,29 @@
 namespace script {
 namespace mozjs {
 
+// Our mozjs specific implementation of |script::Tracer|. Tracing sessions
+// will be initiated from a |Wrapper| of SpiderMonkey's choice, and then it
+// will be the |mozjs::Tracer|'s job to assist SpiderMonkey's garbage
+// collector in traversing the graph of |Wrapper|s and |Wrappable|s.
+// |Wrappable|s will inform us about what they can reach through their
+// |TraceMembers| implementation, and then we will pass the reachable
+// |Wrappable|'s |Wrapper| to SpiderMonkey GC if it exists, and otherwise
+// continue traversing ourselves from |Wrappable| to (the unwrapped)
+// |Wrappable|.
+class Tracer : public ::cobalt::script::Tracer {
+ public:
+  explicit Tracer(JSTracer* js_tracer) : js_tracer_(js_tracer) {}
+  void Trace(Wrappable* wrappable) OVERRIDE;
+
+  void TraceFrom(Wrappable* wrappable);
+
+ private:
+  JSTracer* js_tracer_;
+  // Pending |Wrappable|s that we must traverse ourselves, since they did not
+  // have a |Wrapper|.
+  std::vector<Wrappable*> frontier_;
+};
+
 // Contains private data associated with a JSObject representing a JS wrapper
 // for a Cobalt platform object. There should be a one-to-one mapping of such
 // JSObjects and WrapperPrivate instances, and the corresponding WrapperPrivate
@@ -107,6 +130,8 @@
   JS::Heap<JSObject*> wrapper_proxy_;
   GetOpaqueRootFunction get_opaque_root_function_;
   GetReachableWrappablesFunction get_reachable_wrappables_function_;
+
+  friend Tracer;
 };
 
 }  // namespace mozjs
diff --git a/src/cobalt/script/wrappable.h b/src/cobalt/script/wrappable.h
index 7d7f32f..e803fe4 100644
--- a/src/cobalt/script/wrappable.h
+++ b/src/cobalt/script/wrappable.h
@@ -24,6 +24,12 @@
 namespace cobalt {
 namespace script {
 
+class Wrappable;
+class Tracer {
+ public:
+  virtual void Trace(Wrappable* wrappable) = 0;
+};
+
 class Wrappable : public base::RefCounted<Wrappable> {
  public:
   // A handle to this Wrappable's corresponding Wrapper object. It may be
@@ -65,6 +71,12 @@
   // this (which will result in the Wrappable being destructed as well.)
   virtual bool ShouldKeepWrapperAlive() { return false; }
 
+  // Trace all native |Wrappable|s accessible by the |Wrappable|. Must be
+  // manually implemented by the |Wrappable|.
+  // TODO: Should be pure virtual after static analysis tool for |Wrappable|s
+  // is created.
+  virtual void TraceMembers(Tracer* /*tracer*/) {}
+
  protected:
   virtual ~Wrappable() { }
 
diff --git a/src/cobalt/webdriver/stub_web_driver_module.cc b/src/cobalt/webdriver/stub_web_driver_module.cc
new file mode 100644
index 0000000..0a63ec1
--- /dev/null
+++ b/src/cobalt/webdriver/stub_web_driver_module.cc
@@ -0,0 +1,25 @@
+// Copyright 2017 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.
+
+// A source file used to create a nearly empty library that is needed for
+// dependency purposes. On Windows one cannot create a library that does not
+// define any previously undefined public symbols.
+// See related Linker Tools Warning LNK4221:
+// https://msdn.microsoft.com/en-us/library/604bzebd.aspx
+
+namespace cobalt {
+namespace webdriver {
+class WebDriverModule {};
+}
+}
\ No newline at end of file
diff --git a/src/cobalt/webdriver/webdriver.gyp b/src/cobalt/webdriver/webdriver.gyp
index 6fd1acf..e6b431b 100644
--- a/src/cobalt/webdriver/webdriver.gyp
+++ b/src/cobalt/webdriver/webdriver.gyp
@@ -80,6 +80,11 @@
             'defines': [ 'ENABLE_WEBDRIVER', ],
           },
         }],
+        ['enable_webdriver==0', {
+          'sources': [
+          'stub_web_driver_module.cc'
+          ]
+        }],
       ],
       'dependencies': [
         '<(DEPTH)/base/base.gyp:base',
diff --git a/src/cobalt/webdriver_benchmarks/tests/README.md b/src/cobalt/webdriver_benchmarks/tests/README.md
index 752f1a0..ca89b03 100644
--- a/src/cobalt/webdriver_benchmarks/tests/README.md
+++ b/src/cobalt/webdriver_benchmarks/tests/README.md
@@ -102,7 +102,8 @@
 
 ### Interesting benchmarks
 
-Some particularly interesting benchmark results are:
+#### Timing-related
+Some particularly interesting timing-related benchmark results are:
 
  - `wbStartupDurBlankToBrowseUs*`: Measures the startup time, until all images
    finish loading.
@@ -120,10 +121,34 @@
 
 In each case above, the `*` symbol can be one of either `Mean`, `Pct25`,
 `Pct50`, `Pct75` or `Pct95`.  For example, `wbStartupDurBlankToBrowseUsMean` or
-`wbStartupDurBlankToBrowseUsPct95` are both valid measurements.  The
+`wbStartupDurBlankToBrowseUsPct95` are both valid measurements. The webdriver
+benchmarks runs its tests many times in order to obtain multiple samples, so you
+can drill into the data by exploring either the mean, or the various
+percentiles.
+
+#### Object count-related
+Some particularly interesting count-related benchmark results are:
+
+ - `wbBrowseVerticalCntDomHtmlElements*`: Lists the number of HTML elements in
+   existence after the event. This includes HTML elements that are no longer in
+   the DOM but have not been garbage collected yet.
+ - `wbBrowseVerticalCntLayoutBoxes*`: Lists the number of layout boxes within
+   the layout tree after the event.
+ - `wbBrowseVerticalCntLayoutBoxesCreated*`: Lists the number of new layout
+   boxes that were created during the event.
+ - `wbBrowseHorizontalCntDomHtmlElements*`: Same as
+   `wbBrowseVerticalCntDomHtmlElements*` except for horizontal scroll events.
+ - `wbBrowseHorizontalCntLayoutBoxes*`: Same as
+   `wbBrowseVerticalCntLayoutBoxes*` except for horizontal scroll events.
+ - `wbBrowseHorizontalCntLayoutBoxesCreated*`: Same as
+   `wbBrowseVerticalCntLayoutBoxesCreated*` except for horizontal scroll events.
+
+In each case above,  the `*` symbol can be one of either `Max`, `Median`, or
+`Mean`. For example, `wbBrowseVerticalCntDomHtmlElementsMax` or
+`wbBrowseVerticalCntDomHtmlElementsMedian` are both valid measurements. The
 webdriver benchmarks runs its tests many times in order to obtain multiple
-samples, so you can drill into the data by exploring either the mean, or the
-various percentiles.
+samples, so you can drill into the data by exploring either the max, median, or
+mean.
 
 ### Filtering results
 
@@ -140,6 +165,10 @@
 grep -o "wbBrowseVerticalDurRasterizeAnimationsUs.*$" results.txt >> filtered_results.txt
 grep -o "wbBrowseHorizontalDurTotalUs.*$" results.txt >> filtered_results.txt
 grep -o "wbBrowseHorizontalDurRasterizeAnimationsUs.*$" results.txt >> filtered_results.txt
+grep -o "wbBrowseVerticalCntDomHtmlElements.*$" results.txt >> filtered_results.txt
+grep -o "wbBrowseVerticalCntLayoutBoxes.*$" results.txt >> filtered_results.txt
+grep -o "wbBrowseHorizontalCntDomHtmlElements.*$" results.txt >> filtered_results.txt
+grep -o "wbBrowseHorizontalCntLayoutBoxes.*$" results.txt >> filtered_results.txt
 cat filtered_results.txt
 ```
 
diff --git a/src/starboard/CHANGELOG.md b/src/starboard/CHANGELOG.md
index fbddb4a..d9629f6 100644
--- a/src/starboard/CHANGELOG.md
+++ b/src/starboard/CHANGELOG.md
@@ -16,6 +16,7 @@
     `SB_IS_PLAYER_COMPOSITED` now no longer need to be defined (and should not
     be defined) by platforms.  Instead, these capabilities are detected at
     runtime via `SbPlayerOutputModeSupported()`.
+
 In `starboard/player.h`,
   * The enum `SbPlayerOutputMode` is introduced.
   * `SbPlayerOutputModeSupported()` is introduced to let applications query
@@ -28,6 +29,7 @@
   * The function `SbPlayerGetCompositionHandle()` is removed.
   * The function `SbPlayerGetTextureId()` is replaced by the new
     `SbPlayerGetCurrentFrame()`, which returns a `SbDecodeTarget`.
+
 In `starboard/decode_target.h`,
   * All get methods (`SbDecodeTargetGetPlane()` and `SbDecodeTargetGetFormat()`,
     `SbDecodeTargetIsOpaque()`) are now replaced with `SbDecodeTargetGetInfo()`.
@@ -40,6 +42,7 @@
     (`EGLDisplay`, `EGLContext`) replaced by `void*` types, so that
     `decode_target.h` can avoid #including EGL/GLES2 headers.
   * `SbDecodeTargetDestroy()` is renamed to `SbDecodeTargetRelease()`.
+
 In `starboard/player.h`, `starboard/image.h` and `starboard/decode_target.h`,
   * Replace `SbDecodeTargetProvider` with
     `SbDecodeTargetGraphicsContextProvider`.
diff --git a/src/starboard/client_porting/pr_starboard/pr_starboard.cc b/src/starboard/client_porting/pr_starboard/pr_starboard.cc
index 52a7ebc..89767be 100644
--- a/src/starboard/client_porting/pr_starboard/pr_starboard.cc
+++ b/src/starboard/client_porting/pr_starboard/pr_starboard.cc
@@ -28,7 +28,9 @@
 namespace {
 
 typedef starboard::Queue<PRThread*> SetupSignalQueue;
-nb::ThreadLocalObject<PRThread> g_local_pr_thread;
+typedef nb::ThreadLocalObject<PRThread> ThreadLocalPRThread;
+SB_ONCE_INITIALIZE_FUNCTION(ThreadLocalPRThread,
+                            g_local_pr_thread);
 
 // Utility function to convert a PRInterval to signed 64 bit integer
 // microseconds.
@@ -61,8 +63,8 @@
 
   delete context;
 
-  SB_DCHECK(g_local_pr_thread.GetIfExists() == NULL);
-  PRThread* pr_thread = g_local_pr_thread.GetOrCreate(SbThreadGetCurrent());
+  SB_DCHECK(g_local_pr_thread()->GetIfExists() == NULL);
+  PRThread* pr_thread = g_local_pr_thread()->GetOrCreate(SbThreadGetCurrent());
   SB_DCHECK(pr_thread);
   setup_signal_queue->Put(pr_thread);
   pr_entry_point(pr_context);
@@ -119,7 +121,7 @@
 }
 
 PRThread* PR_GetCurrentThread() {
-  return g_local_pr_thread.GetOrCreate(SbThreadGetCurrent());
+  return g_local_pr_thread()->GetOrCreate(SbThreadGetCurrent());
 }
 
 uint32_t PR_snprintf(char* out, uint32_t outlen, const char* fmt, ...) {
diff --git a/src/starboard/export.h b/src/starboard/export.h
index b19c1c7..78d5892 100644
--- a/src/starboard/export.h
+++ b/src/starboard/export.h
@@ -31,10 +31,13 @@
 // SB_IMPORT: Specification for a symbol that is expected to be defined
 // externally to this module.
 
-#if defined(COMPONENT_BUILD)
+#if defined(COMPONENT_BUILD) || SB_IS(LIBRARY)
 // COMPONENT_BUILD is defined when generating shared libraries for each project,
 // rather than static libraries. This means we need to be careful about
 // EXPORT/IMPORT.
+// SB_IS_LIBRARY is defined when building Starboard as a shared library to be
+// linked into a client app. In this case, we want to explicitly define
+// EXPORT/IMPORT so that Starboard's symbols are visible to such clients.
 #if defined(STARBOARD_IMPLEMENTATION)
 // STARBOARD_IMPLEMENTATION is defined when building the Starboard library
 // sources, and shouldn't be defined when building sources that are clients of
@@ -47,7 +50,7 @@
 #define SB_EXPORT_PRIVATE SB_IMPORT_PLATFORM
 #define SB_IMPORT SB_EXPORT_PLATFORM
 #endif
-#else  // defined(COMPONENT_BUILD)
+#else  // defined(COMPONENT_BUILD) || SB_IS(LIBRARY)
 #define SB_EXPORT
 #define SB_EXPORT_PRIVATE
 #define SB_IMPORT
diff --git a/src/starboard/nplb/file_helpers.cc b/src/starboard/nplb/file_helpers.cc
index 327b0d5..f6a9f43 100644
--- a/src/starboard/nplb/file_helpers.cc
+++ b/src/starboard/nplb/file_helpers.cc
@@ -62,7 +62,7 @@
   }
 
   std::ostringstream filename_stream;
-  filename_stream << path << "/ScopedRandomFile.File_"
+  filename_stream << path << SB_FILE_SEP_CHAR << "ScopedRandomFile.File_"
                   << SbSystemGetRandomUInt64();
   return filename_stream.str();
 }
diff --git a/src/starboard/nplb/nplb.gyp b/src/starboard/nplb/nplb.gyp
index 92c4f2d..782c729 100644
--- a/src/starboard/nplb/nplb.gyp
+++ b/src/starboard/nplb/nplb.gyp
@@ -172,6 +172,12 @@
         'socket_waiter_wait_test.cc',
         'socket_waiter_wait_timed_test.cc',
         'socket_waiter_wake_up_test.cc',
+        'speech_recognizer_cancel_test.cc',
+        'speech_recognizer_create_test.cc',
+        'speech_recognizer_destroy_test.cc',
+        'speech_recognizer_helper.h',
+        'speech_recognizer_start_test.cc',
+        'speech_recognizer_stop_test.cc',
         'speech_synthesis_basic_test.cc',
         'storage_close_record_test.cc',
         'storage_delete_record_test.cc',
@@ -250,6 +256,7 @@
         '<!@(python "<(DEPTH)/starboard/tools/find_private_files.py" "<(DEPTH)" "nplb/*_test.cc")',
       ],
       'dependencies': [
+        '<@(cobalt_platform_dependencies)',
         '<(DEPTH)/testing/gmock.gyp:gmock',
         '<(DEPTH)/testing/gtest.gyp:gtest',
         '<(DEPTH)/starboard/starboard.gyp:starboard',
diff --git a/src/starboard/nplb/socket_get_local_interface_address_test.cc b/src/starboard/nplb/socket_get_local_interface_address_test.cc
index 566aad3..a282f61 100644
--- a/src/starboard/nplb/socket_get_local_interface_address_test.cc
+++ b/src/starboard/nplb/socket_get_local_interface_address_test.cc
@@ -20,13 +20,7 @@
 namespace nplb {
 namespace {
 
-class SbSocketGetLocalInterfaceAddressTest
-    : public ::testing::TestWithParam<SbSocketAddressType> {
- public:
-  SbSocketAddressType GetAddressType() { return GetParam(); }
-};
-
-TEST_F(SbSocketGetLocalInterfaceAddressTest, SunnyDay) {
+TEST(SbSocketGetLocalInterfaceAddressTest, SunnyDay) {
   SbSocketAddress address;
   // Initialize to something invalid.
   SbMemorySet(&address, 0xFE, sizeof(address));
@@ -40,7 +34,7 @@
   EXPECT_FALSE(IsLocalhost(&address));
 }
 
-TEST_F(SbSocketGetLocalInterfaceAddressTest, RainyDayNull) {
+TEST(SbSocketGetLocalInterfaceAddressTest, RainyDayNull) {
 #if SB_API_VERSION < 4
   EXPECT_FALSE(SbSocketGetLocalInterfaceAddress(NULL));
 #else
@@ -48,17 +42,6 @@
 #endif  // SB_API_VERSION < 4
 }
 
-#if SB_HAS(IPV6)
-INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
-                        SbSocketGetLocalInterfaceAddressTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4,
-                                          kSbSocketAddressTypeIpv6));
-#else
-INSTANTIATE_TEST_CASE_P(SbSocketAddressTypes,
-                        SbSocketGetLocalInterfaceAddressTest,
-                        ::testing::Values(kSbSocketAddressTypeIpv4));
-#endif
-
 }  // namespace
 }  // namespace nplb
 }  // namespace starboard
diff --git a/src/starboard/nplb/speech_recognizer_cancel_test.cc b/src/starboard/nplb/speech_recognizer_cancel_test.cc
new file mode 100644
index 0000000..471275e
--- /dev/null
+++ b/src/starboard/nplb/speech_recognizer_cancel_test.cc
@@ -0,0 +1,73 @@
+// Copyright 2017 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 "starboard/nplb/speech_recognizer_helper.h"
+#include "starboard/speech_recognizer.h"
+#include "starboard/thread.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace nplb {
+
+#if SB_HAS(SPEECH_RECOGNIZER) && \
+    SB_API_VERSION >= SB_SPEECH_RECOGNIZER_API_VERSION
+
+TEST_F(SpeechRecognizerTest, CancelTestSunnyDay) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {true, true, 1};
+
+  if (!SbSpeechRecognizerStart(recognizer, &configuration)) {
+    SB_LOG(WARNING) << "SbSpeechRecognizerStart failed. Test skipped.";
+    SbSpeechRecognizerDestroy(recognizer);
+    return;
+  }
+
+  SbSpeechRecognizerCancel(recognizer);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+TEST_F(SpeechRecognizerTest, CancelIsCalledMultipleTimes) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {true, false, 1};
+
+  if (!SbSpeechRecognizerStart(recognizer, &configuration)) {
+    SB_LOG(WARNING) << "SbSpeechRecognizerStart failed. Test skipped.";
+    SbSpeechRecognizerDestroy(recognizer);
+    return;
+  }
+
+  SbSpeechRecognizerCancel(recognizer);
+  SbSpeechRecognizerCancel(recognizer);
+  SbSpeechRecognizerCancel(recognizer);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+TEST_F(SpeechRecognizerTest, CancelTestStartIsNotCalled) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechRecognizerCancel(recognizer);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+TEST_F(SpeechRecognizerTest, CancelWithInvalidSpeechRecognizer) {
+  SbSpeechRecognizerCancel(kSbSpeechRecognizerInvalid);
+}
+
+#endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
+        // SB_SPEECH_RECOGNIZER_API_VERSION
+
+}  // namespace nplb
+}  // namespace starboard
diff --git a/src/starboard/nplb/speech_recognizer_create_test.cc b/src/starboard/nplb/speech_recognizer_create_test.cc
new file mode 100644
index 0000000..ddbc93f
--- /dev/null
+++ b/src/starboard/nplb/speech_recognizer_create_test.cc
@@ -0,0 +1,35 @@
+// Copyright 2017 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 "starboard/nplb/speech_recognizer_helper.h"
+#include "starboard/speech_recognizer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace nplb {
+
+#if SB_HAS(SPEECH_RECOGNIZER) && \
+    SB_API_VERSION >= SB_SPEECH_RECOGNIZER_API_VERSION
+
+TEST_F(SpeechRecognizerTest, CreateTestSunnyDay) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+#endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
+        // SB_SPEECH_RECOGNIZER_API_VERSION
+
+}  // namespace nplb
+}  // namespace starboard
diff --git a/src/starboard/nplb/speech_recognizer_destroy_test.cc b/src/starboard/nplb/speech_recognizer_destroy_test.cc
new file mode 100644
index 0000000..ffd14de
--- /dev/null
+++ b/src/starboard/nplb/speech_recognizer_destroy_test.cc
@@ -0,0 +1,41 @@
+// Copyright 2017 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 "starboard/nplb/speech_recognizer_helper.h"
+#include "starboard/speech_recognizer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace nplb {
+
+#if SB_HAS(SPEECH_RECOGNIZER) && \
+    SB_API_VERSION >= SB_SPEECH_RECOGNIZER_API_VERSION
+
+TEST_F(SpeechRecognizerTest, DestroyInvalidSpeechRecognizer) {
+  SbSpeechRecognizerDestroy(kSbSpeechRecognizerInvalid);
+}
+
+TEST_F(SpeechRecognizerTest, DestroyRecognizerWithoutStopping) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {true, true, 1};
+  SbSpeechRecognizerStart(recognizer, &configuration);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+#endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
+        // SB_SPEECH_RECOGNIZER_API_VERSION
+
+}  // namespace nplb
+}  // namespace starboard
diff --git a/src/starboard/nplb/speech_recognizer_helper.h b/src/starboard/nplb/speech_recognizer_helper.h
new file mode 100644
index 0000000..727a993
--- /dev/null
+++ b/src/starboard/nplb/speech_recognizer_helper.h
@@ -0,0 +1,103 @@
+// Copyright 2017 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 STARBOARD_NPLB_SPEECH_RECOGNIZER_HELPER_H_
+#define STARBOARD_NPLB_SPEECH_RECOGNIZER_HELPER_H_
+
+#include "starboard/common/ref_counted.h"
+#include "starboard/common/semaphore.h"
+#include "starboard/speech_recognizer.h"
+#include "starboard/time.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace nplb {
+
+#if SB_HAS(SPEECH_RECOGNIZER) && \
+    SB_API_VERSION >= SB_SPEECH_RECOGNIZER_API_VERSION
+
+class EventMock : public RefCounted<EventMock> {
+ public:
+  MOCK_METHOD0(OnEvent, void(void));
+};
+
+class SpeechRecognizerTest : public ::testing::Test {
+ public:
+  SpeechRecognizerTest()
+      : handler_(), test_mock_(new ::testing::StrictMock<EventMock>()) {
+    handler_.on_speech_detected = OnSpeechDetected;
+    handler_.on_error = OnError;
+    handler_.on_results = OnResults;
+    handler_.context = this;
+  }
+
+  static void OnSpeechDetected(void* context, bool detected) {
+    SpeechRecognizerTest* test = static_cast<SpeechRecognizerTest*>(context);
+    test->OnSignalEvent();
+  }
+  static void OnError(void* context, SbSpeechRecognizerError error) {
+    SpeechRecognizerTest* test = static_cast<SpeechRecognizerTest*>(context);
+    test->OnSignalEvent();
+  }
+  static void OnResults(void* context,
+                        SbSpeechResult* results,
+                        int results_size,
+                        bool is_final) {
+    SpeechRecognizerTest* test = static_cast<SpeechRecognizerTest*>(context);
+    test->OnSignalEvent();
+  }
+
+  SbSpeechRecognizerHandler* handler() { return &handler_; }
+
+  EventMock& test_mock() { return *test_mock_.get(); }
+
+  void Wait() {
+    if (!event_semaphore_.TakeWait(kWaitTime)) {
+      SB_LOG(WARNING) << "Waiting for recognizer event to come, but timeout!";
+    }
+  }
+
+  void OnSignalEvent() {
+    test_mock_->OnEvent();
+    event_semaphore_.Put();
+  }
+
+ protected:
+  // Per test teardown.
+  virtual void TearDown() {
+    // Wait for the speech recognizer server to tear down in order to start
+    // a new one for the next test. The speech recognizer server was running in
+    // another thread.
+    SbThreadSleep(kTearDownTime);
+  }
+
+ private:
+  const SbTime kTearDownTime = 10 * kSbTimeMillisecond;
+  const SbTime kWaitTime = 600 * kSbTimeMillisecond;
+
+  SbSpeechRecognizerHandler handler_;
+
+  starboard::Semaphore event_semaphore_;
+
+  const scoped_refptr<EventMock> test_mock_;
+};
+
+#endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
+        // SB_SPEECH_RECOGNIZER_API_VERSION
+
+}  // namespace nplb
+}  // namespace starboard
+
+#endif  // STARBOARD_NPLB_SPEECH_RECOGNIZER_HELPER_H_
diff --git a/src/starboard/nplb/speech_recognizer_start_test.cc b/src/starboard/nplb/speech_recognizer_start_test.cc
new file mode 100644
index 0000000..65fb03d
--- /dev/null
+++ b/src/starboard/nplb/speech_recognizer_start_test.cc
@@ -0,0 +1,119 @@
+// Copyright 2017 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 "starboard/nplb/speech_recognizer_helper.h"
+#include "starboard/speech_recognizer.h"
+#include "starboard/thread.h"
+
+namespace starboard {
+namespace nplb {
+
+#if SB_HAS(SPEECH_RECOGNIZER) && \
+    SB_API_VERSION >= SB_SPEECH_RECOGNIZER_API_VERSION
+
+TEST_F(SpeechRecognizerTest, StartTestSunnyDay) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {false, false, 1};
+  if (!SbSpeechRecognizerStart(recognizer, &configuration)) {
+    SB_LOG(WARNING) << "SbSpeechRecognizerStart failed. Test skipped.";
+    SbSpeechRecognizerDestroy(recognizer);
+    return;
+  }
+
+  EXPECT_CALL(test_mock(), OnEvent()).Times(testing::AtLeast(1));
+  Wait();
+  SbSpeechRecognizerStop(recognizer);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+TEST_F(SpeechRecognizerTest, StartRecognizerWithContinuousRecognition) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {true, false, 1};
+  if (!SbSpeechRecognizerStart(recognizer, &configuration)) {
+    SB_LOG(WARNING) << "SbSpeechRecognizerStart failed. Test skipped.";
+    SbSpeechRecognizerDestroy(recognizer);
+    return;
+  }
+
+  EXPECT_CALL(test_mock(), OnEvent()).Times(testing::AtLeast(1));
+  Wait();
+  SbSpeechRecognizerStop(recognizer);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+TEST_F(SpeechRecognizerTest, StartRecognizerWithInterimResults) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {false, true, 1};
+  if (!SbSpeechRecognizerStart(recognizer, &configuration)) {
+    SB_LOG(WARNING) << "SbSpeechRecognizerStart failed. Test skipped.";
+    SbSpeechRecognizerDestroy(recognizer);
+    return;
+  }
+
+  EXPECT_CALL(test_mock(), OnEvent()).Times(testing::AtLeast(1));
+  Wait();
+  SbSpeechRecognizerStop(recognizer);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+TEST_F(SpeechRecognizerTest, StartRecognizerWith10MaxAlternatives) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {true, true, 10};
+  if (!SbSpeechRecognizerStart(recognizer, &configuration)) {
+    SB_LOG(WARNING) << "SbSpeechRecognizerStart failed. Test skipped.";
+    SbSpeechRecognizerDestroy(recognizer);
+    return;
+  }
+
+  EXPECT_CALL(test_mock(), OnEvent()).Times(testing::AtLeast(1));
+  Wait();
+  SbSpeechRecognizerStop(recognizer);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+TEST_F(SpeechRecognizerTest, StartIsCalledMultipleTimes) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {true, true, 1};
+  if (!SbSpeechRecognizerStart(recognizer, &configuration)) {
+    SB_LOG(WARNING) << "SbSpeechRecognizerStart failed. Test skipped.";
+    SbSpeechRecognizerDestroy(recognizer);
+    return;
+  }
+
+  EXPECT_CALL(test_mock(), OnEvent()).Times(testing::AtLeast(1));
+  bool success = SbSpeechRecognizerStart(recognizer, &configuration);
+  EXPECT_FALSE(success);
+  success = SbSpeechRecognizerStart(recognizer, &configuration);
+  EXPECT_FALSE(success);
+  Wait();
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+TEST_F(SpeechRecognizerTest, StartWithInvalidSpeechRecognizer) {
+  SbSpeechConfiguration configuration = {true, true, 1};
+  bool success =
+      SbSpeechRecognizerStart(kSbSpeechRecognizerInvalid, &configuration);
+  EXPECT_FALSE(success);
+}
+
+#endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
+        // SB_SPEECH_RECOGNIZER_API_VERSION
+
+}  // namespace nplb
+}  // namespace starboard
diff --git a/src/starboard/nplb/speech_recognizer_stop_test.cc b/src/starboard/nplb/speech_recognizer_stop_test.cc
new file mode 100644
index 0000000..0663a50
--- /dev/null
+++ b/src/starboard/nplb/speech_recognizer_stop_test.cc
@@ -0,0 +1,45 @@
+// Copyright 2017 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 "starboard/nplb/speech_recognizer_helper.h"
+#include "starboard/speech_recognizer.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace starboard {
+namespace nplb {
+
+#if SB_HAS(SPEECH_RECOGNIZER) && \
+    SB_API_VERSION >= SB_SPEECH_RECOGNIZER_API_VERSION
+
+TEST_F(SpeechRecognizerTest, StopIsCalledMultipleTimes) {
+  SbSpeechRecognizer recognizer = SbSpeechRecognizerCreate(handler());
+  EXPECT_TRUE(SbSpeechRecognizerIsValid(recognizer));
+  SbSpeechConfiguration configuration = {true, true, 1};
+  if (!SbSpeechRecognizerStart(recognizer, &configuration)) {
+    SB_LOG(WARNING) << "SbSpeechRecognizerStart failed. Test skipped.";
+    SbSpeechRecognizerDestroy(recognizer);
+    return;
+  }
+
+  SbSpeechRecognizerStop(recognizer);
+  SbSpeechRecognizerStop(recognizer);
+  SbSpeechRecognizerStop(recognizer);
+  SbSpeechRecognizerDestroy(recognizer);
+}
+
+#endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
+        // SB_SPEECH_RECOGNIZER_API_VERSION
+
+}  // namespace nplb
+}  // namespace starboard
diff --git a/src/starboard/player.h b/src/starboard/player.h
index de12f42..5335bd9 100644
--- a/src/starboard/player.h
+++ b/src/starboard/player.h
@@ -179,7 +179,9 @@
                                    SbPlayerState state,
                                    int ticket);
 
-// Callback to free the given sample buffer data.
+// Callback to free the given sample buffer data.  When more than one buffer
+// are sent in SbPlayerWriteSample(), the implementation only has to call this
+// callback with |sample_buffer| points to the the first buffer.
 typedef void (*SbPlayerDeallocateSampleFunc)(SbPlayer player,
                                              void* context,
                                              const void* sample_buffer);
diff --git a/src/starboard/shared/linux/socket_get_interface_address.cc b/src/starboard/shared/linux/socket_get_interface_address.cc
index 752d898..923e4c0 100644
--- a/src/starboard/shared/linux/socket_get_interface_address.cc
+++ b/src/starboard/shared/linux/socket_get_interface_address.cc
@@ -26,7 +26,6 @@
 #include <sys/socket.h>
 #include <sys/types.h>
 
-#include "net/base/net_util.h"
 #include "starboard/byte_swap.h"
 #include "starboard/log.h"
 #include "starboard/memory.h"
@@ -36,6 +35,9 @@
 
 namespace {
 
+// TODO: Move this constant to socket.h.
+const int kIPv6AddressSize = 16;
+
 bool IsAnyAddress(const SbSocketAddress& address) {
   switch (address.type) {
     case kSbSocketAddressTypeIpv4:
@@ -44,7 +46,7 @@
 #if SB_HAS(IPV6)
     case kSbSocketAddressTypeIpv6: {
       bool found_nonzero = false;
-      for (std::size_t i = 0; i != net::kIPv6AddressSize; ++i) {
+      for (std::size_t i = 0; i != kIPv6AddressSize; ++i) {
         found_nonzero |= (address.address[i] != 0);
       }
       return !found_nonzero;
diff --git a/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_cancel.cc b/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_cancel.cc
index aa77349..e831818 100644
--- a/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_cancel.cc
+++ b/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_cancel.cc
@@ -21,8 +21,9 @@
 #include "starboard/shared/starboard/speech_recognizer/speech_recognizer_internal.h"
 
 void SbSpeechRecognizerCancel(SbSpeechRecognizer recognizer) {
-  SB_DCHECK(SbSpeechRecognizerIsValid(recognizer));
-  recognizer->Cancel();
+  if (SbSpeechRecognizerIsValid(recognizer)) {
+    recognizer->Cancel();
+  }
 }
 
 #endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
diff --git a/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_destroy.cc b/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_destroy.cc
index b7b052b..3948cc7 100644
--- a/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_destroy.cc
+++ b/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_destroy.cc
@@ -20,7 +20,9 @@
 #include "starboard/shared/starboard/speech_recognizer/speech_recognizer_internal.h"
 
 void SbSpeechRecognizerDestroy(SbSpeechRecognizer recognizer) {
-  SbSpeechRecognizerPrivate::DestroySpeechRecognizer(recognizer);
+  if (SbSpeechRecognizerIsValid(recognizer)) {
+    SbSpeechRecognizerPrivate::DestroySpeechRecognizer(recognizer);
+  }
 }
 
 #endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
diff --git a/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_stop.cc b/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_stop.cc
index e8cadfd..717d229 100644
--- a/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_stop.cc
+++ b/src/starboard/shared/starboard/speech_recognizer/speech_recognizer_stop.cc
@@ -21,8 +21,9 @@
 #include "starboard/shared/starboard/speech_recognizer/speech_recognizer_internal.h"
 
 void SbSpeechRecognizerStop(SbSpeechRecognizer recognizer) {
-  SB_DCHECK(SbSpeechRecognizerIsValid(recognizer));
-  recognizer->Stop();
+  if (SbSpeechRecognizerIsValid(recognizer)) {
+    recognizer->Stop();
+  }
 }
 
 #endif  // SB_HAS(SPEECH_RECOGNIZER) && SB_API_VERSION >=
diff --git a/src/starboard/starboard_base_target.gypi b/src/starboard/starboard_base_target.gypi
index dd66b79..a4d07a7 100644
--- a/src/starboard/starboard_base_target.gypi
+++ b/src/starboard/starboard_base_target.gypi
@@ -41,6 +41,11 @@
         'STARBOARD_ALLOWS_MEMORY_TRACKING',
       ],
     }],
+    ['sb_enable_lib==1', {
+      'defines': [
+        'SB_IS_LIBRARY=1',
+      ],
+    }],
     ['starboard_path == ""', {
       'defines': [
         # There doesn't appear to be any way to use the C preprocessor to do
diff --git a/src/third_party/mozjs/js/public/Value.h b/src/third_party/mozjs/js/public/Value.h
index f2345f4..3637495 100644
--- a/src/third_party/mozjs/js/public/Value.h
+++ b/src/third_party/mozjs/js/public/Value.h
@@ -802,7 +802,13 @@
 
 #endif  /* JS_BITS_PER_WORD */
 
+#if defined(STARBOARD) && SB_IS(COMPILER_MSVC)
+// Note that the Value class's data member is private
+// if !defined(_MSC_VER) && !defined(__sparc) and is public otherwise.
+#define JSVAL_TO_IMPL(v) v.data
+#else
 static inline jsval_layout JSVAL_TO_IMPL(JS::Value v);
+#endif
 static inline JS::Value IMPL_TO_JSVAL(jsval_layout l);
 
 namespace JS {
@@ -1187,8 +1193,11 @@
         JS_STATIC_ASSERT(sizeof(JSWhyMagic) <= 4);
         JS_STATIC_ASSERT(sizeof(Value) == 8);
     }
-
+#if defined(STARBOARD) && SB_IS(COMPILER_MSVC)
+    // Do not declare JSVAL_TO_IMPL a friend. It is a macro.
+#else
     friend jsval_layout (::JSVAL_TO_IMPL)(Value);
+#endif
     friend Value (::IMPL_TO_JSVAL)(jsval_layout l);
 };
 
@@ -1620,11 +1629,15 @@
 
 } // namespace js
 
+#if defined(STARBOARD) && SB_IS(COMPILER_MSVC)
+// Do not define JSVAL_TO_IMPL as a function. It is a macro.
+#else
 inline jsval_layout
 JSVAL_TO_IMPL(JS::Value v)
 {
     return v.data;
 }
+#endif
 
 inline JS::Value
 IMPL_TO_JSVAL(jsval_layout l)