Update from https://crrev.com/319330 - New chromium clang rules require explicit external destructors so system/lib added for MessagePipe, DataPipe and SharedBuffer - New chromium clang rules require override and no virtual in declarations, so many files updated. - cc_strip_video patch updated. BUG= R=jamesr@chromium.org Review URL: https://codereview.chromium.org/988693005

diff --git a/BUILD.gn b/BUILD.gn
index 9dbc41c..402b19a 100644
--- a/BUILD.gn
+++ b/BUILD.gn

@@ -15,6 +15,8 @@
     "allocator/allocator_extension.h",
     "allocator/type_profiler_control.cc",
     "allocator/type_profiler_control.h",
+    "android/animation_frame_time_histogram.cc",
+    "android/animation_frame_time_histogram.h",
     "android/application_status_listener.cc",
     "android/application_status_listener.h",
     "android/base_jni_onload.cc",
@@ -386,18 +388,18 @@
     "metrics/histogram.h",
     "metrics/histogram_base.cc",
     "metrics/histogram_base.h",
-    "metrics/histogram_delta_serialization.cc",
-    "metrics/sample_map.cc",
-    "metrics/sample_map.h",
-    "metrics/sample_vector.cc",
-    "metrics/sample_vector.h",
     "metrics/histogram_delta_serialization.",
+    "metrics/histogram_delta_serialization.cc",
     "metrics/histogram_flattener.h",
     "metrics/histogram_macros.h",
     "metrics/histogram_samples.cc",
     "metrics/histogram_samples.h",
     "metrics/histogram_snapshot_manager.cc",
     "metrics/histogram_snapshot_manager.h",
+    "metrics/sample_map.cc",
+    "metrics/sample_map.h",
+    "metrics/sample_vector.cc",
+    "metrics/sample_vector.h",
     "metrics/sparse_histogram.cc",
     "metrics/sparse_histogram.h",
     "metrics/statistics_recorder.cc",
@@ -783,9 +785,9 @@
       "files/file_proxy.cc",
       "files/file_util.cc",
       "files/file_util_proxy.cc",
+      "files/scoped_temp_dir.cc",
       "path_service.cc",
       "scoped_native_library.cc",
-      "files/scoped_temp_dir.cc",
     ]
   }
 
@@ -1066,6 +1068,8 @@
 source_set("prefs") {
   sources = [
     "prefs/base_prefs_export.h",
+    "prefs/base_prefs_switches.cc",
+    "prefs/base_prefs_switches.h",
     "prefs/default_pref_store.cc",
     "prefs/default_pref_store.h",
     "prefs/json_pref_store.cc",
@@ -1163,6 +1167,8 @@
 }
 
 if (is_win) {
+  # Target to manually rebuild pe_image_test.dll which is checked into
+  # base/test/data/pe_image.
   shared_library("pe_image_test") {
     sources = [
       "win/pe_image_test.cc",
@@ -1487,10 +1493,6 @@
     set_sources_assignment_filter(sources_assignment_filter)
   }
 
-  if (is_win) {
-    deps += [ ":pe_image_test" ]
-  }
-
   # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
   configs += [ "//build/config/compiler:no_size_t_to_int_warning" ]
 }
@@ -1500,6 +1502,7 @@
   generate_jni("base_jni_headers") {
     sources = [
       "android/java/src/org/chromium/base/ApplicationStatus.java",
+      "android/java/src/org/chromium/base/AnimationFrameTimeHistogram.java",
       "android/java/src/org/chromium/base/BuildInfo.java",
       "android/java/src/org/chromium/base/CommandLine.java",
       "android/java/src/org/chromium/base/ContentUriUtils.java",

diff --git a/android/animation_frame_time_histogram.cc b/android/animation_frame_time_histogram.cc
new file mode 100644
index 0000000..0d79619
--- /dev/null
+++ b/android/animation_frame_time_histogram.cc

@@ -0,0 +1,36 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/android/animation_frame_time_histogram.h"
+
+#include "base/android/jni_string.h"
+#include "base/metrics/histogram_macros.h"
+#include "jni/AnimationFrameTimeHistogram_jni.h"
+
+// static
+void SaveHistogram(JNIEnv* env,
+                   jobject jcaller,
+                   jstring j_histogram_name,
+                   jlongArray j_frame_times_ms,
+                   jint j_count) {
+  jlong *frame_times_ms = env->GetLongArrayElements(j_frame_times_ms, NULL);
+  std::string histogram_name = base::android::ConvertJavaStringToUTF8(
+      env, j_histogram_name);
+
+  for (int i = 0; i < j_count; ++i) {
+    UMA_HISTOGRAM_TIMES(histogram_name.c_str(),
+                        base::TimeDelta::FromMilliseconds(frame_times_ms[i]));
+  }
+}
+
+namespace base {
+namespace android {
+
+// static
+bool RegisterAnimationFrameTimeHistogram(JNIEnv* env) {
+  return RegisterNativesImpl(env);
+}
+
+}  // namespace android
+}  // namespace base

diff --git a/android/animation_frame_time_histogram.h b/android/animation_frame_time_histogram.h
new file mode 100644
index 0000000..63f938b
--- /dev/null
+++ b/android/animation_frame_time_histogram.h

@@ -0,0 +1,18 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_ANDROID_ANIMATION_FRAME_TIME_HISTOGRAM_H_
+#define BASE_ANDROID_ANIMATION_FRAME_TIME_HISTOGRAM_H_
+
+#include <jni.h>
+
+namespace base {
+namespace android {
+
+bool RegisterAnimationFrameTimeHistogram(JNIEnv* env);
+
+}  // namespace android
+}  // namespace base
+
+#endif  // BASE_ANDROID_ANIMATION_FRAME_TIME_HISTOGRAM_H_

diff --git a/android/base_jni_registrar.cc b/android/base_jni_registrar.cc
index 4dda482..7439d3c 100644
--- a/android/base_jni_registrar.cc
+++ b/android/base_jni_registrar.cc

@@ -4,6 +4,7 @@
 
 #include "base/android/base_jni_registrar.h"
 
+#include "base/android/animation_frame_time_histogram.h"
 #include "base/android/application_status_listener.h"
 #include "base/android/build_info.h"
 #include "base/android/command_line_android.h"
@@ -33,6 +34,8 @@
 namespace android {
 
 static RegistrationMethod kBaseRegisteredMethods[] = {
+    {"AnimationFrameTimeHistogram",
+     base::android::RegisterAnimationFrameTimeHistogram},
     {"ApplicationStatusListener",
      base::android::ApplicationStatusListener::RegisterBindings},
     {"BuildInfo", base::android::BuildInfo::RegisterBindings},

diff --git a/android/java/src/org/chromium/base/AnimationFrameTimeHistogram.java b/android/java/src/org/chromium/base/AnimationFrameTimeHistogram.java
new file mode 100644
index 0000000..ad5cdd8
--- /dev/null
+++ b/android/java/src/org/chromium/base/AnimationFrameTimeHistogram.java

@@ -0,0 +1,145 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+package org.chromium.base;
+
+import android.animation.Animator;
+import android.animation.Animator.AnimatorListener;
+import android.animation.AnimatorListenerAdapter;
+import android.animation.TimeAnimator;
+import android.animation.TimeAnimator.TimeListener;
+import android.util.Log;
+
+/**
+ * Record Android animation frame rate and save it to UMA histogram. This is mainly for monitoring
+ * any jankiness of short Chrome Android animations. It is limited to few seconds of recording.
+ */
+public class AnimationFrameTimeHistogram {
+    private static final String TAG = "AnimationFrameTimeHistogram";
+    private static final int MAX_FRAME_TIME_NUM = 600; // 10 sec on 60 fps.
+
+    private final Recorder mRecorder = new Recorder();
+    private final String mHistogramName;
+
+    /**
+     * @param histogramName The histogram name that the recorded frame times will be saved.
+     *                      This must be also defined in histograms.xml
+     * @return An AnimatorListener instance that records frame time histogram on start and end
+     *         automatically.
+     */
+    public static AnimatorListener getAnimatorRecorder(final String histogramName) {
+        return new AnimatorListenerAdapter() {
+            private final AnimationFrameTimeHistogram mAnimationFrameTimeHistogram =
+                    new AnimationFrameTimeHistogram(histogramName);
+
+            @Override
+            public void onAnimationStart(Animator animation) {
+                mAnimationFrameTimeHistogram.startRecording();
+            }
+
+            @Override
+            public void onAnimationEnd(Animator animation) {
+                mAnimationFrameTimeHistogram.endRecording();
+            }
+
+            @Override
+            public void onAnimationCancel(Animator animation) {
+                mAnimationFrameTimeHistogram.endRecording();
+            }
+        };
+    }
+
+    /**
+     * @param histogramName The histogram name that the recorded frame times will be saved.
+     *                      This must be also defined in histograms.xml
+     */
+    public AnimationFrameTimeHistogram(String histogramName) {
+        mHistogramName = histogramName;
+    }
+
+    /**
+     * Start recording frame times. The recording can fail if it exceeds a few seconds.
+     */
+    public void startRecording() {
+        mRecorder.startRecording();
+    }
+
+    /**
+     * End recording and save it to histogram. It won't save histogram if the recording wasn't
+     * successful.
+     */
+    public void endRecording() {
+        if (mRecorder.endRecording()) {
+            nativeSaveHistogram(mHistogramName,
+                    mRecorder.getFrameTimesMs(), mRecorder.getFrameTimesCount());
+        }
+        mRecorder.cleanUp();
+    }
+
+    /**
+     * Record Android animation frame rate and return the result.
+     */
+    private static class Recorder implements TimeListener {
+        // TODO(kkimlabs): If we can use in the future, migrate to Choreographer for minimal
+        //                 workload.
+        private final TimeAnimator mAnimator = new TimeAnimator();
+        private long[] mFrameTimesMs;
+        private int mFrameTimesCount;
+
+        private Recorder() {
+            mAnimator.setTimeListener(this);
+        }
+
+        private void startRecording() {
+            assert !mAnimator.isRunning();
+            mFrameTimesCount = 0;
+            mFrameTimesMs = new long[MAX_FRAME_TIME_NUM];
+            mAnimator.start();
+        }
+
+        /**
+         * @return Whether the recording was successful. If successful, the result is available via
+         *         getFrameTimesNs and getFrameTimesCount.
+         */
+        private boolean endRecording() {
+            boolean succeeded = mAnimator.isStarted();
+            mAnimator.end();
+            return succeeded;
+        }
+
+        private long[] getFrameTimesMs() {
+            return mFrameTimesMs;
+        }
+
+        private int getFrameTimesCount() {
+            return mFrameTimesCount;
+        }
+
+        /**
+         * Deallocates the temporary buffer to record frame times. Must be called after ending
+         * the recording and getting the result.
+         */
+        private void cleanUp() {
+            mFrameTimesMs = null;
+        }
+
+        @Override
+        public void onTimeUpdate(TimeAnimator animation, long totalTime, long deltaTime) {
+            if (mFrameTimesCount == mFrameTimesMs.length) {
+                mAnimator.end();
+                cleanUp();
+                Log.w(TAG, "Animation frame time recording reached the maximum number. It's either"
+                        + "the animation took too long or recording end is not called.");
+                return;
+            }
+
+            // deltaTime is 0 for the first frame.
+            if (deltaTime > 0) {
+                mFrameTimesMs[mFrameTimesCount++] = deltaTime;
+            }
+        }
+    }
+
+    private native void nativeSaveHistogram(String histogramName, long[] frameTimesMs, int count);
+}

diff --git a/android/java/src/org/chromium/base/ApiCompatibilityUtils.java b/android/java/src/org/chromium/base/ApiCompatibilityUtils.java
index c03cad2..4198853 100644
--- a/android/java/src/org/chromium/base/ApiCompatibilityUtils.java
+++ b/android/java/src/org/chromium/base/ApiCompatibilityUtils.java

@@ -72,13 +72,6 @@
     }
 
     /**
-     * @return True if the running version of the Android supports HTML clipboard.
-     */
-    public static boolean isHTMLClipboardSupported() {
-        return Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN;
-    }
-
-    /**
      * @see android.view.View#setLayoutDirection(int)
      */
     public static void setLayoutDirection(View view, int layoutDirection) {

diff --git a/base.gyp b/base.gyp
index 30de275..3888ad9 100644
--- a/base.gyp
+++ b/base.gyp

@@ -338,6 +338,8 @@
       ],
       'sources': [
         'prefs/base_prefs_export.h',
+        'prefs/base_prefs_switches.cc',
+        'prefs/base_prefs_switches.h',
         'prefs/default_pref_store.cc',
         'prefs/default_pref_store.h',
         'prefs/json_pref_store.cc',
@@ -382,12 +384,18 @@
       # TODO(pasko): Remove this target when crbug.com/424562 is fixed.
       # GN: //base:protect_file_posix
       'target_name': 'protect_file_posix',
-      'type': 'static_library',
-      'dependencies': [
-        'base',
-      ],
-      'sources': [
-        'files/protect_file_posix.cc',
+      'conditions': [
+        ['os_posix == 1', {
+          'type': 'static_library',
+          'dependencies': [
+            'base',
+          ],
+          'sources': [
+            'files/protect_file_posix.cc',
+          ],
+        }, {
+          'type': 'none',
+        }],
       ],
     },
     {
@@ -778,9 +786,6 @@
             'message_loop/message_pump_libevent_unittest.cc',
             'threading/worker_pool_posix_unittest.cc',
           ],
-          'dependencies': [
-            'pe_image_test',
-          ],
           # TODO(jschuh): crbug.com/167187 fix size_t to int truncations.
           'msvs_disabled_warnings': [
             4267,
@@ -941,6 +946,8 @@
         'test/mock_chrome_application_mac.mm',
         'test/mock_devices_changed_observer.cc',
         'test/mock_devices_changed_observer.h',
+        'test/mock_log.cc',
+        'test/mock_log.h',
         'test/multiprocess_test.cc',
         'test/multiprocess_test.h',
         'test/multiprocess_test_android.cc',
@@ -1336,6 +1343,7 @@
           'type': 'none',
           'sources': [
             'android/java/src/org/chromium/base/ApplicationStatus.java',
+            'android/java/src/org/chromium/base/AnimationFrameTimeHistogram.java',
             'android/java/src/org/chromium/base/BuildInfo.java',
             'android/java/src/org/chromium/base/CommandLine.java',
             'android/java/src/org/chromium/base/ContentUriUtils.java',
@@ -1551,6 +1559,8 @@
           },
         },
         {
+          # Target to manually rebuild pe_image_test.dll which is checked into
+          # base/test/data/pe_image.
           'target_name': 'pe_image_test',
           'type': 'shared_library',
           'sources': [

diff --git a/base.gypi b/base.gypi
index 148246f..0f8fff2 100644
--- a/base.gypi
+++ b/base.gypi

@@ -17,6 +17,8 @@
           'allocator/allocator_extension.h',
           'allocator/type_profiler_control.cc',
           'allocator/type_profiler_control.h',
+          'android/animation_frame_time_histogram.cc',
+          'android/animation_frame_time_histogram.h',
           'android/application_status_listener.cc',
           'android/application_status_listener.h',
           'android/base_jni_onload.cc',

diff --git a/base_nacl.gyp b/base_nacl.gyp
index 63e1ed4..90a2893 100644
--- a/base_nacl.gyp
+++ b/base_nacl.gyp

@@ -7,8 +7,12 @@
     'chromium_code': 1,
   },
   'includes': [
-    '../build/common_untrusted.gypi',
+    # base.gypi must be included before common_untrusted.gypi.
+    #
+    # TODO(sergeyu): Replace the target_defaults magic in base.gypi with a
+    # sources variables lists. That way order of includes will not matter.
     'base.gypi',
+    '../build/common_untrusted.gypi',
   ],
   'conditions': [
     ['disable_nacl==0 and disable_nacl_untrusted==0', {

diff --git a/base_unittests.isolate b/base_unittests.isolate
index e5495e3..5126fb3 100644
--- a/base_unittests.isolate
+++ b/base_unittests.isolate

@@ -19,7 +19,6 @@
           '--brave-new-test-launcher',
           '--test-launcher-bot-mode',
           '--asan=<(asan)',
-          '--lsan=<(lsan)',
           '--msan=<(msan)',
           '--tsan=<(tsan)',
         ],
@@ -52,7 +51,6 @@
           '--brave-new-test-launcher',
           '--test-launcher-bot-mode',
           '--asan=<(asan)',
-          '--lsan=<(lsan)',
           '--msan=<(msan)',
           '--tsan=<(tsan)',
         ],
@@ -72,13 +70,6 @@
         ],
       },
     }],
-    ['OS=="win"', {
-      'variables': {
-        'files': [
-          '<(PRODUCT_DIR)/pe_image_test.dll',
-        ],
-      },
-    }],
   ],
   'includes': [
     'base.isolate',

diff --git a/files/file_path_watcher_win.cc b/files/file_path_watcher_win.cc
index 63e5480..f6d0029 100644
--- a/files/file_path_watcher_win.cc
+++ b/files/file_path_watcher_win.cc

@@ -11,7 +11,6 @@
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
-#include "base/profiler/scoped_tracker.h"
 #include "base/time/time.h"
 #include "base/win/object_watcher.h"
 
@@ -147,11 +146,6 @@
 }
 
 void FilePathWatcherImpl::OnObjectSignaled(HANDLE object) {
-  // TODO(vadimt): Remove ScopedTracker below once crbug.com/418183 is fixed.
-  tracked_objects::ScopedTracker tracking_profile(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "418183 FilePathWatcherImpl::OnObjectSignaled"));
-
   DCHECK(object == handle_);
   // Make sure we stay alive through the body of this function.
   scoped_refptr<FilePathWatcherImpl> keep_alive(this);

diff --git a/files/important_file_writer.cc b/files/important_file_writer.cc
index d256236..47b0b09 100644
--- a/files/important_file_writer.cc
+++ b/files/important_file_writer.cc

@@ -10,12 +10,14 @@
 
 #include "base/bind.h"
 #include "base/critical_closure.h"
+#include "base/debug/alias.h"
 #include "base/files/file.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_number_conversions.h"
+#include "base/strings/string_util.h"
 #include "base/task_runner.h"
 #include "base/task_runner_util.h"
 #include "base/threading/thread.h"
@@ -54,6 +56,20 @@
 // static
 bool ImportantFileWriter::WriteFileAtomically(const FilePath& path,
                                               const std::string& data) {
+#if defined(OS_CHROMEOS)
+  // On Chrome OS, chrome gets killed when it cannot finish shutdown quickly,
+  // and this function seems to be one of the slowest shutdown steps.
+  // Include some info to the report for investigation. crbug.com/418627
+  // TODO(hashimoto): Remove this.
+  struct {
+    size_t data_size;
+    char path[128];
+  } file_info;
+  file_info.data_size = data.size();
+  base::strlcpy(file_info.path, path.value().c_str(),
+                arraysize(file_info.path));
+  base::debug::Alias(&file_info);
+#endif
   // Write the data to a temp file then rename to avoid data loss if we crash
   // while writing the file. Ensure that the temp file is on the same volume
   // as target file, so it can be moved in one step, and that the temp file

diff --git a/json/json_file_value_serializer.cc b/json/json_file_value_serializer.cc
index 71033f6..72a0970 100644
--- a/json/json_file_value_serializer.cc
+++ b/json/json_file_value_serializer.cc

@@ -10,16 +10,14 @@
 
 using base::FilePath;
 
-const char JSONFileValueSerializer::kAccessDenied[] = "Access denied.";
-const char JSONFileValueSerializer::kCannotReadFile[] = "Can't read file.";
-const char JSONFileValueSerializer::kFileLocked[] = "File locked.";
-const char JSONFileValueSerializer::kNoSuchFile[] = "File doesn't exist.";
+const char JSONFileValueDeserializer::kAccessDenied[] = "Access denied.";
+const char JSONFileValueDeserializer::kCannotReadFile[] = "Can't read file.";
+const char JSONFileValueDeserializer::kFileLocked[] = "File locked.";
+const char JSONFileValueDeserializer::kNoSuchFile[] = "File doesn't exist.";
 
 JSONFileValueSerializer::JSONFileValueSerializer(
     const base::FilePath& json_file_path)
-    : json_file_path_(json_file_path),
-      allow_trailing_comma_(false),
-      last_read_size_(0U) {
+    : json_file_path_(json_file_path) {
 }
 
 JSONFileValueSerializer::~JSONFileValueSerializer() {
@@ -53,7 +51,17 @@
   return true;
 }
 
-int JSONFileValueSerializer::ReadFileToString(std::string* json_string) {
+JSONFileValueDeserializer::JSONFileValueDeserializer(
+    const base::FilePath& json_file_path)
+    : json_file_path_(json_file_path),
+      allow_trailing_comma_(false),
+      last_read_size_(0U) {
+}
+
+JSONFileValueDeserializer::~JSONFileValueDeserializer() {
+}
+
+int JSONFileValueDeserializer::ReadFileToString(std::string* json_string) {
   DCHECK(json_string);
   if (!base::ReadFileToString(json_file_path_, json_string)) {
 #if defined(OS_WIN)
@@ -74,7 +82,7 @@
   return JSON_NO_ERROR;
 }
 
-const char* JSONFileValueSerializer::GetErrorMessageForCode(int error_code) {
+const char* JSONFileValueDeserializer::GetErrorMessageForCode(int error_code) {
   switch (error_code) {
     case JSON_NO_ERROR:
       return "";
@@ -92,8 +100,8 @@
   }
 }
 
-base::Value* JSONFileValueSerializer::Deserialize(int* error_code,
-                                                  std::string* error_str) {
+base::Value* JSONFileValueDeserializer::Deserialize(int* error_code,
+                                                    std::string* error_str) {
   std::string json_string;
   int error = ReadFileToString(&json_string);
   if (error != JSON_NO_ERROR) {
@@ -104,7 +112,7 @@
     return NULL;
   }
 
-  JSONStringValueSerializer serializer(json_string);
-  serializer.set_allow_trailing_comma(allow_trailing_comma_);
-  return serializer.Deserialize(error_code, error_str);
+  JSONStringValueDeserializer deserializer(json_string);
+  deserializer.set_allow_trailing_comma(allow_trailing_comma_);
+  return deserializer.Deserialize(error_code, error_str);
 }

diff --git a/json/json_file_value_serializer.h b/json/json_file_value_serializer.h
index 6cfcbe8..aab47ee 100644
--- a/json/json_file_value_serializer.h
+++ b/json/json_file_value_serializer.h

@@ -14,10 +14,9 @@
 
 class BASE_EXPORT JSONFileValueSerializer : public base::ValueSerializer {
  public:
-  // |json_file_path_| is the path of a file that will be source of the
-  // deserialization or the destination of the serialization.
-  // When deserializing, the file should exist, but when serializing, the
-  // serializer will attempt to create the file at the specified location.
+  // |json_file_path_| is the path of a file that will be destination of the
+  // serialization. The serializer will attempt to create the file at the
+  // specified location.
   explicit JSONFileValueSerializer(const base::FilePath& json_file_path);
 
   ~JSONFileValueSerializer() override;
@@ -36,6 +35,22 @@
   // output.
   bool SerializeAndOmitBinaryValues(const base::Value& root);
 
+ private:
+  bool SerializeInternal(const base::Value& root, bool omit_binary_values);
+
+  const base::FilePath json_file_path_;
+
+  DISALLOW_IMPLICIT_CONSTRUCTORS(JSONFileValueSerializer);
+};
+
+class BASE_EXPORT JSONFileValueDeserializer : public base::ValueDeserializer {
+ public:
+  // |json_file_path_| is the path of a file that will be source of the
+  // deserialization.
+  explicit JSONFileValueDeserializer(const base::FilePath& json_file_path);
+
+  ~JSONFileValueDeserializer() override;
+
   // Attempt to deserialize the data structure encoded in the file passed
   // in to the constructor into a structure of Value objects.  If the return
   // value is NULL, and if |error_code| is non-null, |error_code| will
@@ -69,22 +84,20 @@
     allow_trailing_comma_ = new_value;
   }
 
-  // Returns the syze (in bytes) of JSON string read from disk in the last
+  // Returns the size (in bytes) of JSON string read from disk in the last
   // successful |Deserialize()| call.
   size_t get_last_read_size() const { return last_read_size_; }
 
  private:
-  bool SerializeInternal(const base::Value& root, bool omit_binary_values);
+  // A wrapper for ReadFileToString which returns a non-zero JsonFileError if
+  // there were file errors.
+  int ReadFileToString(std::string* json_string);
 
   const base::FilePath json_file_path_;
   bool allow_trailing_comma_;
   size_t last_read_size_;
 
-  // A wrapper for ReadFileToString which returns a non-zero JsonFileError if
-  // there were file errors.
-  int ReadFileToString(std::string* json_string);
-
-  DISALLOW_IMPLICIT_CONSTRUCTORS(JSONFileValueSerializer);
+  DISALLOW_IMPLICIT_CONSTRUCTORS(JSONFileValueDeserializer);
 };
 
 #endif  // BASE_JSON_JSON_FILE_VALUE_SERIALIZER_H_

diff --git a/json/json_string_value_serializer.cc b/json/json_string_value_serializer.cc
index b626640..debf9f0 100644
--- a/json/json_string_value_serializer.cc
+++ b/json/json_string_value_serializer.cc

@@ -12,17 +12,7 @@
 
 JSONStringValueSerializer::JSONStringValueSerializer(std::string* json_string)
     : json_string_(json_string),
-      json_string_readonly_(*json_string),
-      pretty_print_(false),
-      allow_trailing_comma_(false) {
-}
-
-JSONStringValueSerializer::JSONStringValueSerializer(
-    const base::StringPiece& json_string)
-    : json_string_(nullptr),
-      json_string_readonly_(json_string),
-      pretty_print_(false),
-      allow_trailing_comma_(false) {
+      pretty_print_(false) {
 }
 
 JSONStringValueSerializer::~JSONStringValueSerializer() {}
@@ -50,9 +40,17 @@
   return base::JSONWriter::WriteWithOptions(&root, options, json_string_);
 }
 
-Value* JSONStringValueSerializer::Deserialize(int* error_code,
-                                              std::string* error_str) {
-  return base::JSONReader::ReadAndReturnError(json_string_readonly_,
+JSONStringValueDeserializer::JSONStringValueDeserializer(
+    const base::StringPiece& json_string)
+    : json_string_(json_string),
+      allow_trailing_comma_(false) {
+}
+
+JSONStringValueDeserializer::~JSONStringValueDeserializer() {}
+
+Value* JSONStringValueDeserializer::Deserialize(int* error_code,
+                                                std::string* error_str) {
+  return base::JSONReader::ReadAndReturnError(json_string_,
       allow_trailing_comma_ ? base::JSON_ALLOW_TRAILING_COMMAS :
           base::JSON_PARSE_RFC,
       error_code, error_str);

diff --git a/json/json_string_value_serializer.h b/json/json_string_value_serializer.h
index 7f99bc9..bc0e66d 100644
--- a/json/json_string_value_serializer.h
+++ b/json/json_string_value_serializer.h

@@ -15,16 +15,11 @@
 
 class BASE_EXPORT JSONStringValueSerializer : public base::ValueSerializer {
  public:
-  // |json_string| is the string that will be source of the deserialization
-  // or the destination of the serialization.  The caller of the constructor
-  // retains ownership of the string. |json_string| must not be null.
+  // |json_string| is the string that will be the destination of the
+  // serialization.  The caller of the constructor retains ownership of the
+  // string. |json_string| must not be null.
   explicit JSONStringValueSerializer(std::string* json_string);
 
-  // This version allows initialization with a StringPiece for deserialization
-  // only. Retains a reference to the contents of |json_string|, so the data
-  // must outlive the JSONStringValueSerializer.
-  explicit JSONStringValueSerializer(const base::StringPiece& json_string);
-
   ~JSONStringValueSerializer() override;
 
   // Attempt to serialize the data structure represented by Value into
@@ -36,6 +31,27 @@
   // output.
   bool SerializeAndOmitBinaryValues(const base::Value& root);
 
+  void set_pretty_print(bool new_value) { pretty_print_ = new_value; }
+  bool pretty_print() { return pretty_print_; }
+
+ private:
+  bool SerializeInternal(const base::Value& root, bool omit_binary_values);
+
+  // Owned by the caller of the constructor.
+  std::string* json_string_;
+  bool pretty_print_;  // If true, serialization will span multiple lines.
+
+  DISALLOW_COPY_AND_ASSIGN(JSONStringValueSerializer);
+};
+
+class BASE_EXPORT JSONStringValueDeserializer : public base::ValueDeserializer {
+ public:
+  // This retains a reference to the contents of |json_string|, so the data
+  // must outlive the JSONStringValueDeserializer.
+  explicit JSONStringValueDeserializer(const base::StringPiece& json_string);
+
+  ~JSONStringValueDeserializer() override;
+
   // Attempt to deserialize the data structure encoded in the string passed
   // in to the constructor into a structure of Value objects.  If the return
   // value is null, and if |error_code| is non-null, |error_code| will
@@ -46,28 +62,17 @@
   base::Value* Deserialize(int* error_code,
                            std::string* error_message) override;
 
-  void set_pretty_print(bool new_value) { pretty_print_ = new_value; }
-  bool pretty_print() { return pretty_print_; }
-
   void set_allow_trailing_comma(bool new_value) {
     allow_trailing_comma_ = new_value;
   }
 
  private:
-  bool SerializeInternal(const base::Value& root, bool omit_binary_values);
-
-  // String for writing. Owned by the caller of the constructor. Will be null if
-  // the serializer was initialized with a const string.
-  std::string* json_string_;
-  // String for reading. Data is owned by the caller of the constructor. If
-  // |json_string_| is non-null, this is a view onto |json_string_|.
-  base::StringPiece json_string_readonly_;
-  bool pretty_print_;  // If true, serialization will span multiple lines.
+  // Data is owned by the caller of the constructor.
+  base::StringPiece json_string_;
   // If true, deserialization will allow trailing commas.
   bool allow_trailing_comma_;
 
-  DISALLOW_COPY_AND_ASSIGN(JSONStringValueSerializer);
+  DISALLOW_COPY_AND_ASSIGN(JSONStringValueDeserializer);
 };
 
 #endif  // BASE_JSON_JSON_STRING_VALUE_SERIALIZER_H_
-

diff --git a/json/json_value_serializer_unittest.cc b/json/json_value_serializer_unittest.cc
index d2a84de..225ee67 100644
--- a/json/json_value_serializer_unittest.cc
+++ b/json/json_value_serializer_unittest.cc

@@ -86,28 +86,10 @@
   ASSERT_EQ(1, value);
 }
 
-// Test proper JSON [de]serialization from string is working.
-TEST(JSONValueSerializerTest, ReadProperJSONFromString) {
+// Test proper JSON deserialization from string is working.
+TEST(JSONValueDeserializerTest, ReadProperJSONFromString) {
   // Try to deserialize it through the serializer.
-  JSONStringValueSerializer str_deserializer(kProperJSON);
-
-  int error_code = 0;
-  std::string error_message;
-  scoped_ptr<Value> value(
-      str_deserializer.Deserialize(&error_code, &error_message));
-  ASSERT_TRUE(value.get());
-  ASSERT_EQ(0, error_code);
-  ASSERT_TRUE(error_message.empty());
-  // Verify if the same JSON is still there.
-  CheckJSONIsStillTheSame(*value);
-}
-
-// Test proper JSON deserialization from a string pointer is working.
-TEST(JSONValueSerializerTest, ReadProperJSONFromStringPointer) {
-  // Try to deserialize a string pointer through the serializer. (This exercises
-  // a separate code path to passing a StringPiece.)
-  std::string proper_json(kProperJSON);
-  JSONStringValueSerializer str_deserializer(&proper_json);
+  JSONStringValueDeserializer str_deserializer(kProperJSON);
 
   int error_code = 0;
   std::string error_message;
@@ -121,12 +103,12 @@
 }
 
 // Test proper JSON deserialization from a StringPiece substring.
-TEST(JSONValueSerializerTest, ReadProperJSONFromStringPiece) {
+TEST(JSONValueDeserializerTest, ReadProperJSONFromStringPiece) {
   // Create a StringPiece for the substring of kProperJSONPadded that matches
   // kProperJSON.
   base::StringPiece proper_json(kProperJSONPadded);
   proper_json = proper_json.substr(5, proper_json.length() - 10);
-  JSONStringValueSerializer str_deserializer(proper_json);
+  JSONStringValueDeserializer str_deserializer(proper_json);
 
   int error_code = 0;
   std::string error_message;
@@ -141,9 +123,9 @@
 
 // Test that trialing commas are only properly deserialized from string when
 // the proper flag for that is set.
-TEST(JSONValueSerializerTest, ReadJSONWithTrailingCommasFromString) {
+TEST(JSONValueDeserializerTest, ReadJSONWithTrailingCommasFromString) {
   // Try to deserialize it through the serializer.
-  JSONStringValueSerializer str_deserializer(kProperJSONWithCommas);
+  JSONStringValueDeserializer str_deserializer(kProperJSONWithCommas);
 
   int error_code = 0;
   std::string error_message;
@@ -161,8 +143,8 @@
   CheckJSONIsStillTheSame(*value);
 }
 
-// Test proper JSON [de]serialization from file is working.
-TEST(JSONValueSerializerTest, ReadProperJSONFromFile) {
+// Test proper JSON deserialization from file is working.
+TEST(JSONValueDeserializerTest, ReadProperJSONFromFile) {
   ScopedTempDir tempdir;
   ASSERT_TRUE(tempdir.CreateUniqueTempDir());
   // Write it down in the file.
@@ -171,7 +153,7 @@
             WriteFile(temp_file, kProperJSON, strlen(kProperJSON)));
 
   // Try to deserialize it through the serializer.
-  JSONFileValueSerializer file_deserializer(temp_file);
+  JSONFileValueDeserializer file_deserializer(temp_file);
 
   int error_code = 0;
   std::string error_message;
@@ -186,7 +168,7 @@
 
 // Test that trialing commas are only properly deserialized from file when
 // the proper flag for that is set.
-TEST(JSONValueSerializerTest, ReadJSONWithCommasFromFile) {
+TEST(JSONValueDeserializerTest, ReadJSONWithCommasFromFile) {
   ScopedTempDir tempdir;
   ASSERT_TRUE(tempdir.CreateUniqueTempDir());
   // Write it down in the file.
@@ -196,7 +178,7 @@
                       strlen(kProperJSONWithCommas)));
 
   // Try to deserialize it through the serializer.
-  JSONFileValueSerializer file_deserializer(temp_file);
+  JSONFileValueDeserializer file_deserializer(temp_file);
   // This must fail without the proper flag.
   int error_code = 0;
   std::string error_message;
@@ -214,11 +196,27 @@
   CheckJSONIsStillTheSame(*value);
 }
 
+TEST(JSONValueDeserializerTest, AllowTrailingComma) {
+  scoped_ptr<Value> root;
+  scoped_ptr<Value> root_expected;
+  static const char kTestWithCommas[] = "{\"key\": [true,],}";
+  static const char kTestNoCommas[] = "{\"key\": [true]}";
+
+  JSONStringValueDeserializer deserializer(kTestWithCommas);
+  deserializer.set_allow_trailing_comma(true);
+  JSONStringValueDeserializer deserializer_expected(kTestNoCommas);
+  root.reset(deserializer.Deserialize(NULL, NULL));
+  ASSERT_TRUE(root.get());
+  root_expected.reset(deserializer_expected.Deserialize(NULL, NULL));
+  ASSERT_TRUE(root_expected.get());
+  ASSERT_TRUE(root->Equals(root_expected.get()));
+}
+
 TEST(JSONValueSerializerTest, Roundtrip) {
   static const char kOriginalSerialization[] =
     "{\"bool\":true,\"double\":3.14,\"int\":42,\"list\":[1,2],\"null\":null}";
-  JSONStringValueSerializer serializer(kOriginalSerialization);
-  scoped_ptr<Value> root(serializer.Deserialize(NULL, NULL));
+  JSONStringValueDeserializer deserializer(kOriginalSerialization);
+  scoped_ptr<Value> root(deserializer.Deserialize(NULL, NULL));
   ASSERT_TRUE(root.get());
   ASSERT_TRUE(root->IsType(Value::TYPE_DICTIONARY));
 
@@ -241,10 +239,6 @@
   ASSERT_TRUE(root_dict->GetDouble("double", &double_value));
   ASSERT_DOUBLE_EQ(3.14, double_value);
 
-  // We shouldn't be able to write using this serializer, since it was
-  // initialized with a const string.
-  ASSERT_FALSE(serializer.Serialize(*root_dict));
-
   std::string test_serialization;
   JSONStringValueSerializer mutable_serializer(&test_serialization);
   ASSERT_TRUE(mutable_serializer.Serialize(*root_dict));
@@ -331,7 +325,7 @@
   ASSERT_EQ(kExpected, actual);
 
   // escaped ascii text -> json
-  JSONStringValueSerializer deserializer(kExpected);
+  JSONStringValueDeserializer deserializer(kExpected);
   scoped_ptr<Value> deserial_root(deserializer.Deserialize(NULL, NULL));
   ASSERT_TRUE(deserial_root.get());
   DictionaryValue* dict_root =
@@ -355,7 +349,7 @@
   ASSERT_EQ(kExpected, actual);
 
   // escaped ascii text -> json
-  JSONStringValueSerializer deserializer(kExpected);
+  JSONStringValueDeserializer deserializer(kExpected);
   scoped_ptr<Value> deserial_root(deserializer.Deserialize(NULL, NULL));
   ASSERT_TRUE(deserial_root.get());
   DictionaryValue* dict_root =
@@ -366,7 +360,7 @@
 
   // Test converting escaped regular chars
   static const char kEscapedChars[] = "{\"test\":\"\\u0067\\u006f\"}";
-  JSONStringValueSerializer deserializer2(kEscapedChars);
+  JSONStringValueDeserializer deserializer2(kEscapedChars);
   deserial_root.reset(deserializer2.Deserialize(NULL, NULL));
   ASSERT_TRUE(deserial_root.get());
   dict_root = static_cast<DictionaryValue*>(deserial_root.get());
@@ -374,22 +368,6 @@
   ASSERT_EQ(ASCIIToUTF16("go"), test_value);
 }
 
-TEST(JSONValueSerializerTest, AllowTrailingComma) {
-  scoped_ptr<Value> root;
-  scoped_ptr<Value> root_expected;
-  static const char kTestWithCommas[] = "{\"key\": [true,],}";
-  static const char kTestNoCommas[] = "{\"key\": [true]}";
-
-  JSONStringValueSerializer serializer(kTestWithCommas);
-  serializer.set_allow_trailing_comma(true);
-  JSONStringValueSerializer serializer_expected(kTestNoCommas);
-  root.reset(serializer.Deserialize(NULL, NULL));
-  ASSERT_TRUE(root.get());
-  root_expected.reset(serializer_expected.Deserialize(NULL, NULL));
-  ASSERT_TRUE(root_expected.get());
-  ASSERT_TRUE(root->Equals(root_expected.get()));
-}
-
 TEST(JSONValueSerializerTest, JSONReaderComments) {
   ValidateJsonList("[ // 2, 3, ignore me ] \n1 ]");
   ValidateJsonList("[ /* 2, \n3, ignore me ]*/ \n1 ]");
@@ -435,7 +413,7 @@
 
   ASSERT_TRUE(PathExists(original_file_path));
 
-  JSONFileValueSerializer deserializer(original_file_path);
+  JSONFileValueDeserializer deserializer(original_file_path);
   scoped_ptr<Value> root;
   root.reset(deserializer.Deserialize(NULL, NULL));
 
@@ -483,7 +461,7 @@
 
   ASSERT_TRUE(PathExists(original_file_path));
 
-  JSONFileValueSerializer deserializer(original_file_path);
+  JSONFileValueDeserializer deserializer(original_file_path);
   scoped_ptr<Value> root;
   root.reset(deserializer.Deserialize(NULL, NULL));
   ASSERT_TRUE(root.get());
@@ -508,9 +486,9 @@
   source_file_path = source_file_path.Append(
       FILE_PATH_LITERAL("serializer_test_nowhitespace.json"));
   ASSERT_TRUE(PathExists(source_file_path));
-  JSONFileValueSerializer serializer(source_file_path);
+  JSONFileValueDeserializer deserializer(source_file_path);
   scoped_ptr<Value> root;
-  root.reset(serializer.Deserialize(NULL, NULL));
+  root.reset(deserializer.Deserialize(NULL, NULL));
   ASSERT_TRUE(root.get());
 }
 

diff --git a/mac/foundation_util.h b/mac/foundation_util.h
index accc0d9..353ed7c 100644
--- a/mac/foundation_util.h
+++ b/mac/foundation_util.h

@@ -296,6 +296,7 @@
 CF_CAST_DECL(CGColor);
 
 CF_CAST_DECL(CTFont);
+CF_CAST_DECL(CTFontDescriptor);
 CF_CAST_DECL(CTRun);
 
 CF_CAST_DECL(SecACL);

diff --git a/mac/foundation_util.mm b/mac/foundation_util.mm
index 2895b66..27d6e7c 100644
--- a/mac/foundation_util.mm
+++ b/mac/foundation_util.mm

@@ -362,6 +362,7 @@
 
 CF_CAST_DEFN(CGColor);
 
+CF_CAST_DEFN(CTFontDescriptor);
 CF_CAST_DEFN(CTRun);
 
 #if defined(OS_IOS)

diff --git a/mac/sdk_forward_declarations.h b/mac/sdk_forward_declarations.h
index 2795b19..25d937e 100644
--- a/mac/sdk_forward_declarations.h
+++ b/mac/sdk_forward_declarations.h

@@ -285,6 +285,10 @@
 - (NSString*)UUIDString;
 @end
 
+@interface NSControl (MountainLionSDK)
+@property BOOL allowsExpansionToolTips;
+@end
+
 #endif  // MAC_OS_X_VERSION_10_8
 
 

diff --git a/memory/discardable_memory_android.cc b/memory/discardable_memory_android.cc
index 5dcdfdc..2b35587 100644
--- a/memory/discardable_memory_android.cc
+++ b/memory/discardable_memory_android.cc

@@ -52,8 +52,8 @@
 void DiscardableMemory::GetSupportedTypes(
     std::vector<DiscardableMemoryType>* types) {
   const DiscardableMemoryType supported_types[] = {
-    DISCARDABLE_MEMORY_TYPE_ASHMEM,
     DISCARDABLE_MEMORY_TYPE_SHMEM,
+    DISCARDABLE_MEMORY_TYPE_ASHMEM,
     DISCARDABLE_MEMORY_TYPE_EMULATED
   };
   types->assign(supported_types, supported_types + arraysize(supported_types));

diff --git a/memory/discardable_memory_mac.cc b/memory/discardable_memory_mac.cc
index e0096e5..2881f5e 100644
--- a/memory/discardable_memory_mac.cc
+++ b/memory/discardable_memory_mac.cc

@@ -22,8 +22,8 @@
 void DiscardableMemory::GetSupportedTypes(
     std::vector<DiscardableMemoryType>* types) {
   const DiscardableMemoryType supported_types[] = {
-    DISCARDABLE_MEMORY_TYPE_MACH,
     DISCARDABLE_MEMORY_TYPE_SHMEM,
+    DISCARDABLE_MEMORY_TYPE_MACH,
     DISCARDABLE_MEMORY_TYPE_EMULATED
   };
   types->assign(supported_types, supported_types + arraysize(supported_types));

diff --git a/memory/discardable_shared_memory.h b/memory/discardable_shared_memory.h
index 59c5d5b..e3b437c 100644
--- a/memory/discardable_shared_memory.h
+++ b/memory/discardable_shared_memory.h

@@ -74,7 +74,7 @@
   // must have been mapped via Map().
   void* memory() const;
 
-  // Returns the last know usage time for DiscardableSharedMemory object. This
+  // Returns the last known usage time for DiscardableSharedMemory object. This
   // may be earlier than the "true" usage time when memory has been used by a
   // different process. Returns NULL time if purged.
   Time last_known_usage() const { return last_known_usage_; }
@@ -84,7 +84,7 @@
   // for two reasons; object might be locked or our last known usage timestamp
   // might be out of date. Last known usage time is updated to |current_time|
   // if locked or the actual last usage timestamp if unlocked. It is often
-  // neccesary to call this function twice for the object to successfully be
+  // necessary to call this function twice for the object to successfully be
   // purged. First call, updates |last_known_usage_|. Second call, successfully
   // purges the object using the updated |last_known_usage_|.
   // Note: there is no guarantee that multiple calls to this function will

diff --git a/prefs/base_prefs_switches.cc b/prefs/base_prefs_switches.cc
new file mode 100644
index 0000000..304248b
--- /dev/null
+++ b/prefs/base_prefs_switches.cc

@@ -0,0 +1,12 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/prefs/base_prefs_switches.h"
+
+namespace switches {
+
+// Pretty-prints pref JSON files.
+const char kPrettyPrintPrefs[] = "pretty-print-prefs";
+
+}  // namespace switches

diff --git a/prefs/base_prefs_switches.h b/prefs/base_prefs_switches.h
new file mode 100644
index 0000000..7a6b665
--- /dev/null
+++ b/prefs/base_prefs_switches.h

@@ -0,0 +1,14 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_PREFS_BASE_PREFS_SWITCHES_H_
+#define BASE_PREFS_BASE_PREFS_SWITCHES_H_
+
+namespace switches {
+
+extern const char kPrettyPrintPrefs[];
+
+}  // namespace switches
+
+#endif  // BASE_PREFS_BASE_PREFS_SWITCHES_H_

diff --git a/prefs/json_pref_store.cc b/prefs/json_pref_store.cc
index c52a95c..2e34b50 100644
--- a/prefs/json_pref_store.cc
+++ b/prefs/json_pref_store.cc

@@ -8,12 +8,14 @@
 
 #include "base/bind.h"
 #include "base/callback.h"
+#include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/json/json_file_value_serializer.h"
 #include "base/json/json_string_value_serializer.h"
 #include "base/memory/ref_counted.h"
 #include "base/metrics/histogram.h"
+#include "base/prefs/base_prefs_switches.h"
 #include "base/prefs/pref_filter.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_util.h"
@@ -56,16 +58,16 @@
     DVLOG(1) << "Error while loading JSON file: " << error_msg
              << ", file: " << path.value();
     switch (error_code) {
-      case JSONFileValueSerializer::JSON_ACCESS_DENIED:
+      case JSONFileValueDeserializer::JSON_ACCESS_DENIED:
         return PersistentPrefStore::PREF_READ_ERROR_ACCESS_DENIED;
         break;
-      case JSONFileValueSerializer::JSON_CANNOT_READ_FILE:
+      case JSONFileValueDeserializer::JSON_CANNOT_READ_FILE:
         return PersistentPrefStore::PREF_READ_ERROR_FILE_OTHER;
         break;
-      case JSONFileValueSerializer::JSON_FILE_LOCKED:
+      case JSONFileValueDeserializer::JSON_FILE_LOCKED:
         return PersistentPrefStore::PREF_READ_ERROR_FILE_LOCKED;
         break;
-      case JSONFileValueSerializer::JSON_NO_SUCH_FILE:
+      case JSONFileValueDeserializer::JSON_NO_SUCH_FILE:
         return PersistentPrefStore::PREF_READ_ERROR_NO_FILE;
         break;
       default:
@@ -119,14 +121,14 @@
   std::string error_msg;
   scoped_ptr<JsonPrefStore::ReadResult> read_result(
       new JsonPrefStore::ReadResult);
-  JSONFileValueSerializer serializer(path);
-  read_result->value.reset(serializer.Deserialize(&error_code, &error_msg));
+  JSONFileValueDeserializer deserializer(path);
+  read_result->value.reset(deserializer.Deserialize(&error_code, &error_msg));
   read_result->error =
       HandleReadErrors(read_result->value.get(), path, error_code, error_msg);
   read_result->no_dir = !base::PathExists(path.DirName());
 
   if (read_result->error == PersistentPrefStore::PREF_READ_ERROR_NONE)
-    RecordJsonDataSizeHistogram(path, serializer.get_last_read_size());
+    RecordJsonDataSizeHistogram(path, deserializer.get_last_read_size());
 
   return read_result.Pass();
 }
@@ -398,7 +400,10 @@
     pref_filter_->FilterSerializeData(prefs_.get());
 
   JSONStringValueSerializer serializer(output);
-  serializer.set_pretty_print(true);
+  if (base::CommandLine::ForCurrentProcess()->HasSwitch(
+          switches::kPrettyPrintPrefs)) {
+    serializer.set_pretty_print(true);
+  }
   return serializer.Serialize(*prefs_);
 }
 

diff --git a/process/kill.cc b/process/kill.cc
index caca348..a647d96 100644
--- a/process/kill.cc
+++ b/process/kill.cc

@@ -14,11 +14,8 @@
   bool result = true;
   NamedProcessIterator iter(executable_name, filter);
   while (const ProcessEntry* entry = iter.NextProcessEntry()) {
-#if defined(OS_WIN)
-    result &= KillProcessById(entry->pid(), exit_code, true);
-#else
-    result &= KillProcess(entry->pid(), exit_code, true);
-#endif
+    Process process = Process::Open(entry->pid());
+    result &= KillProcess(process.Handle(), exit_code, true);
   }
   return result;
 }

diff --git a/process/kill.h b/process/kill.h
index 8c0a213..df0d95e 100644
--- a/process/kill.h
+++ b/process/kill.h

@@ -57,12 +57,6 @@
 BASE_EXPORT bool KillProcessGroup(ProcessHandle process_group_id);
 #endif  // defined(OS_POSIX)
 
-#if defined(OS_WIN)
-BASE_EXPORT bool KillProcessById(ProcessId process_id,
-                                 int exit_code,
-                                 bool wait);
-#endif  // defined(OS_WIN)
-
 // Get the termination status of the process by interpreting the
 // circumstances of the child process' death. |exit_code| is set to
 // the status returned by waitpid() on POSIX, and from
@@ -94,22 +88,6 @@
     ProcessHandle handle, int* exit_code);
 #endif  // defined(OS_POSIX)
 
-// Waits for process to exit. On POSIX systems, if the process hasn't been
-// signaled then puts the exit code in |exit_code|; otherwise it's considered
-// a failure. On Windows |exit_code| is always filled. Returns true on success,
-// and closes |handle| in any case.
-BASE_EXPORT bool WaitForExitCode(ProcessHandle handle, int* exit_code);
-
-// Waits for process to exit. If it did exit within |timeout_milliseconds|,
-// then puts the exit code in |exit_code|, and returns true.
-// In POSIX systems, if the process has been signaled then |exit_code| is set
-// to -1. Returns false on failure (the caller is then responsible for closing
-// |handle|).
-// The caller is always responsible for closing the |handle|.
-BASE_EXPORT bool WaitForExitCodeWithTimeout(ProcessHandle handle,
-                                            int* exit_code,
-                                            base::TimeDelta timeout);
-
 // Wait for all the processes based on the named executable to exit.  If filter
 // is non-null, then only processes selected by the filter are waited on.
 // Returns after all processes have exited or wait_milliseconds have expired.

diff --git a/process/kill_posix.cc b/process/kill_posix.cc
index 77705ee..298486b 100644
--- a/process/kill_posix.cc
+++ b/process/kill_posix.cc

@@ -22,161 +22,6 @@
 
 namespace {
 
-#if !defined(OS_NACL_NONSFI)
-bool WaitpidWithTimeout(ProcessHandle handle,
-                        int* status,
-                        base::TimeDelta wait) {
-  // This POSIX version of this function only guarantees that we wait no less
-  // than |wait| for the process to exit.  The child process may
-  // exit sometime before the timeout has ended but we may still block for up
-  // to 256 milliseconds after the fact.
-  //
-  // waitpid() has no direct support on POSIX for specifying a timeout, you can
-  // either ask it to block indefinitely or return immediately (WNOHANG).
-  // When a child process terminates a SIGCHLD signal is sent to the parent.
-  // Catching this signal would involve installing a signal handler which may
-  // affect other parts of the application and would be difficult to debug.
-  //
-  // Our strategy is to call waitpid() once up front to check if the process
-  // has already exited, otherwise to loop for |wait|, sleeping for
-  // at most 256 milliseconds each time using usleep() and then calling
-  // waitpid().  The amount of time we sleep starts out at 1 milliseconds, and
-  // we double it every 4 sleep cycles.
-  //
-  // usleep() is speced to exit if a signal is received for which a handler
-  // has been installed.  This means that when a SIGCHLD is sent, it will exit
-  // depending on behavior external to this function.
-  //
-  // This function is used primarily for unit tests, if we want to use it in
-  // the application itself it would probably be best to examine other routes.
-
-  if (wait.InMilliseconds() == base::kNoTimeout) {
-    return HANDLE_EINTR(waitpid(handle, status, 0)) > 0;
-  }
-
-  pid_t ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
-  static const int64 kMaxSleepInMicroseconds = 1 << 18;  // ~256 milliseconds.
-  int64 max_sleep_time_usecs = 1 << 10;  // ~1 milliseconds.
-  int64 double_sleep_time = 0;
-
-  // If the process hasn't exited yet, then sleep and try again.
-  TimeTicks wakeup_time = TimeTicks::Now() + wait;
-  while (ret_pid == 0) {
-    TimeTicks now = TimeTicks::Now();
-    if (now > wakeup_time)
-      break;
-    // Guaranteed to be non-negative!
-    int64 sleep_time_usecs = (wakeup_time - now).InMicroseconds();
-    // Sleep for a bit while we wait for the process to finish.
-    if (sleep_time_usecs > max_sleep_time_usecs)
-      sleep_time_usecs = max_sleep_time_usecs;
-
-    // usleep() will return 0 and set errno to EINTR on receipt of a signal
-    // such as SIGCHLD.
-    usleep(sleep_time_usecs);
-    ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
-
-    if ((max_sleep_time_usecs < kMaxSleepInMicroseconds) &&
-        (double_sleep_time++ % 4 == 0)) {
-      max_sleep_time_usecs *= 2;
-    }
-  }
-
-  return ret_pid > 0;
-}
-
-#if defined(OS_MACOSX)
-// Using kqueue on Mac so that we can wait on non-child processes.
-// We can't use kqueues on child processes because we need to reap
-// our own children using wait.
-static bool WaitForSingleNonChildProcess(ProcessHandle handle,
-                                         TimeDelta wait) {
-  DCHECK_GT(handle, 0);
-  DCHECK(wait.InMilliseconds() == kNoTimeout || wait > TimeDelta());
-
-  ScopedFD kq(kqueue());
-  if (!kq.is_valid()) {
-    DPLOG(ERROR) << "kqueue";
-    return false;
-  }
-
-  struct kevent change = {0};
-  EV_SET(&change, handle, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
-  int result = HANDLE_EINTR(kevent(kq.get(), &change, 1, NULL, 0, NULL));
-  if (result == -1) {
-    if (errno == ESRCH) {
-      // If the process wasn't found, it must be dead.
-      return true;
-    }
-
-    DPLOG(ERROR) << "kevent (setup " << handle << ")";
-    return false;
-  }
-
-  // Keep track of the elapsed time to be able to restart kevent if it's
-  // interrupted.
-  bool wait_forever = wait.InMilliseconds() == kNoTimeout;
-  TimeDelta remaining_delta;
-  TimeTicks deadline;
-  if (!wait_forever) {
-    remaining_delta = wait;
-    deadline = TimeTicks::Now() + remaining_delta;
-  }
-
-  result = -1;
-  struct kevent event = {0};
-
-  while (wait_forever || remaining_delta > TimeDelta()) {
-    struct timespec remaining_timespec;
-    struct timespec* remaining_timespec_ptr;
-    if (wait_forever) {
-      remaining_timespec_ptr = NULL;
-    } else {
-      remaining_timespec = remaining_delta.ToTimeSpec();
-      remaining_timespec_ptr = &remaining_timespec;
-    }
-
-    result = kevent(kq.get(), NULL, 0, &event, 1, remaining_timespec_ptr);
-
-    if (result == -1 && errno == EINTR) {
-      if (!wait_forever) {
-        remaining_delta = deadline - TimeTicks::Now();
-      }
-      result = 0;
-    } else {
-      break;
-    }
-  }
-
-  if (result < 0) {
-    DPLOG(ERROR) << "kevent (wait " << handle << ")";
-    return false;
-  } else if (result > 1) {
-    DLOG(ERROR) << "kevent (wait " << handle << "): unexpected result "
-                << result;
-    return false;
-  } else if (result == 0) {
-    // Timed out.
-    return false;
-  }
-
-  DCHECK_EQ(result, 1);
-
-  if (event.filter != EVFILT_PROC ||
-      (event.fflags & NOTE_EXIT) == 0 ||
-      event.ident != static_cast<uintptr_t>(handle)) {
-    DLOG(ERROR) << "kevent (wait " << handle
-                << "): unexpected event: filter=" << event.filter
-                << ", fflags=" << event.fflags
-                << ", ident=" << event.ident;
-    return false;
-  }
-
-  return true;
-}
-#endif  // OS_MACOSX
-#endif  // !defined(OS_NACL_NONSFI)
-
 TerminationStatus GetTerminationStatusImpl(ProcessHandle handle,
                                            bool can_block,
                                            int* exit_code) {
@@ -302,52 +147,6 @@
 }
 
 #if !defined(OS_NACL_NONSFI)
-bool WaitForExitCode(ProcessHandle handle, int* exit_code) {
-  int status;
-  if (HANDLE_EINTR(waitpid(handle, &status, 0)) == -1) {
-    NOTREACHED();
-    return false;
-  }
-
-  if (WIFEXITED(status)) {
-    *exit_code = WEXITSTATUS(status);
-    return true;
-  }
-
-  // If it didn't exit cleanly, it must have been signaled.
-  DCHECK(WIFSIGNALED(status));
-  return false;
-}
-
-bool WaitForExitCodeWithTimeout(ProcessHandle handle,
-                                int* exit_code,
-                                TimeDelta timeout) {
-  ProcessHandle parent_pid = GetParentProcessId(handle);
-  ProcessHandle our_pid = GetCurrentProcessHandle();
-  if (parent_pid != our_pid) {
-#if defined(OS_MACOSX)
-    // On Mac we can wait on non child processes.
-    return WaitForSingleNonChildProcess(handle, timeout);
-#else
-    // Currently on Linux we can't handle non child processes.
-    NOTIMPLEMENTED();
-#endif  // OS_MACOSX
-  }
-
-  int status;
-  if (!WaitpidWithTimeout(handle, &status, timeout))
-    return false;
-  if (WIFSIGNALED(status)) {
-    *exit_code = -1;
-    return true;
-  }
-  if (WIFEXITED(status)) {
-    *exit_code = WEXITSTATUS(status);
-    return true;
-  }
-  return false;
-}
-
 bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
                             TimeDelta wait,
                             const ProcessFilter* filter) {

diff --git a/process/kill_win.cc b/process/kill_win.cc
index 7daf5f8..3c93047 100644
--- a/process/kill_win.cc
+++ b/process/kill_win.cc

@@ -12,7 +12,6 @@
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/process/process_iterator.h"
-#include "base/profiler/scoped_tracker.h"
 #include "base/win/object_watcher.h"
 
 namespace base {
@@ -71,11 +70,6 @@
 }
 
 void TimerExpiredTask::OnObjectSignaled(HANDLE object) {
-  // TODO(vadimt): Remove ScopedTracker below once crbug.com/418183 is fixed.
-  tracked_objects::ScopedTracker tracking_profile(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "418183 TimerExpiredTask::OnObjectSignaled"));
-
   process_.Close();
 }
 
@@ -107,22 +101,6 @@
   return result;
 }
 
-// Attempts to kill the process identified by the given process
-// entry structure, giving it the specified exit code.
-// Returns true if this is successful, false otherwise.
-bool KillProcessById(ProcessId process_id, int exit_code, bool wait) {
-  HANDLE process = OpenProcess(PROCESS_TERMINATE | SYNCHRONIZE,
-                               FALSE,  // Don't inherit handle
-                               process_id);
-  if (!process) {
-    DPLOG(ERROR) << "Unable to open process " << process_id;
-    return false;
-  }
-  bool ret = KillProcess(process, exit_code, wait);
-  CloseHandle(process);
-  return ret;
-}
-
 TerminationStatus GetTerminationStatus(ProcessHandle handle, int* exit_code) {
   DWORD tmp_exit_code = 0;
 
@@ -181,26 +159,6 @@
   }
 }
 
-bool WaitForExitCode(ProcessHandle handle, int* exit_code) {
-  // TODO(rvargas) crbug.com/417532: Remove this function.
-  Process process(handle);
-  return process.WaitForExit(exit_code);
-}
-
-bool WaitForExitCodeWithTimeout(ProcessHandle handle,
-                                int* exit_code,
-                                TimeDelta timeout) {
-  if (::WaitForSingleObject(
-      handle, static_cast<DWORD>(timeout.InMilliseconds())) != WAIT_OBJECT_0)
-    return false;
-  DWORD temp_code;  // Don't clobber out-parameters in case of failure.
-  if (!::GetExitCodeProcess(handle, &temp_code))
-    return false;
-
-  *exit_code = temp_code;
-  return true;
-}
-
 bool WaitForProcessesToExit(const FilePath::StringType& executable_name,
                             TimeDelta wait,
                             const ProcessFilter* filter) {

diff --git a/process/launch_posix.cc b/process/launch_posix.cc
index 203b7c8..f9963fa 100644
--- a/process/launch_posix.cc
+++ b/process/launch_posix.cc

@@ -33,7 +33,7 @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/posix/eintr_wrapper.h"
-#include "base/process/kill.h"
+#include "base/process/process.h"
 #include "base/process/process_metrics.h"
 #include "base/strings/stringprintf.h"
 #include "base/synchronization/waitable_event.h"
@@ -684,7 +684,8 @@
 
         // Always wait for exit code (even if we know we'll declare
         // GOT_MAX_OUTPUT).
-        bool success = WaitForExitCode(pid, exit_code);
+        Process process(pid);
+        bool success = process.WaitForExit(exit_code);
 
         // If we stopped because we read as much as we wanted, we return
         // GOT_MAX_OUTPUT (because the child may exit due to |SIGPIPE|).

diff --git a/process/process_posix.cc b/process/process_posix.cc
index bc2f3f8..a36bf77 100644
--- a/process/process_posix.cc
+++ b/process/process_posix.cc

@@ -5,12 +5,206 @@
 #include "base/process/process.h"
 
 #include <sys/resource.h>
-#include <sys/time.h>
-#include <sys/types.h>
+#include <sys/wait.h>
 
+#include "base/files/scoped_file.h"
 #include "base/logging.h"
+#include "base/posix/eintr_wrapper.h"
 #include "base/process/kill.h"
 
+#if defined(OS_MACOSX)
+#include <sys/event.h>
+#endif
+
+namespace {
+
+#if !defined(OS_NACL_NONSFI)
+
+bool WaitpidWithTimeout(base::ProcessHandle handle,
+                        int* status,
+                        base::TimeDelta wait) {
+  // This POSIX version of this function only guarantees that we wait no less
+  // than |wait| for the process to exit.  The child process may
+  // exit sometime before the timeout has ended but we may still block for up
+  // to 256 milliseconds after the fact.
+  //
+  // waitpid() has no direct support on POSIX for specifying a timeout, you can
+  // either ask it to block indefinitely or return immediately (WNOHANG).
+  // When a child process terminates a SIGCHLD signal is sent to the parent.
+  // Catching this signal would involve installing a signal handler which may
+  // affect other parts of the application and would be difficult to debug.
+  //
+  // Our strategy is to call waitpid() once up front to check if the process
+  // has already exited, otherwise to loop for |wait|, sleeping for
+  // at most 256 milliseconds each time using usleep() and then calling
+  // waitpid().  The amount of time we sleep starts out at 1 milliseconds, and
+  // we double it every 4 sleep cycles.
+  //
+  // usleep() is speced to exit if a signal is received for which a handler
+  // has been installed.  This means that when a SIGCHLD is sent, it will exit
+  // depending on behavior external to this function.
+  //
+  // This function is used primarily for unit tests, if we want to use it in
+  // the application itself it would probably be best to examine other routes.
+
+  if (wait == base::TimeDelta::Max()) {
+    return HANDLE_EINTR(waitpid(handle, status, 0)) > 0;
+  }
+
+  pid_t ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
+  static const int64 kMaxSleepInMicroseconds = 1 << 18;  // ~256 milliseconds.
+  int64 max_sleep_time_usecs = 1 << 10;  // ~1 milliseconds.
+  int64 double_sleep_time = 0;
+
+  // If the process hasn't exited yet, then sleep and try again.
+  base::TimeTicks wakeup_time = base::TimeTicks::Now() + wait;
+  while (ret_pid == 0) {
+    base::TimeTicks now = base::TimeTicks::Now();
+    if (now > wakeup_time)
+      break;
+    // Guaranteed to be non-negative!
+    int64 sleep_time_usecs = (wakeup_time - now).InMicroseconds();
+    // Sleep for a bit while we wait for the process to finish.
+    if (sleep_time_usecs > max_sleep_time_usecs)
+      sleep_time_usecs = max_sleep_time_usecs;
+
+    // usleep() will return 0 and set errno to EINTR on receipt of a signal
+    // such as SIGCHLD.
+    usleep(sleep_time_usecs);
+    ret_pid = HANDLE_EINTR(waitpid(handle, status, WNOHANG));
+
+    if ((max_sleep_time_usecs < kMaxSleepInMicroseconds) &&
+        (double_sleep_time++ % 4 == 0)) {
+      max_sleep_time_usecs *= 2;
+    }
+  }
+
+  return ret_pid > 0;
+}
+
+#if defined(OS_MACOSX)
+// Using kqueue on Mac so that we can wait on non-child processes.
+// We can't use kqueues on child processes because we need to reap
+// our own children using wait.
+static bool WaitForSingleNonChildProcess(base::ProcessHandle handle,
+                                         base::TimeDelta wait) {
+  DCHECK_GT(handle, 0);
+  DCHECK_GT(wait, base::TimeDelta());
+
+  base::ScopedFD kq(kqueue());
+  if (!kq.is_valid()) {
+    DPLOG(ERROR) << "kqueue";
+    return false;
+  }
+
+  struct kevent change = {0};
+  EV_SET(&change, handle, EVFILT_PROC, EV_ADD, NOTE_EXIT, 0, NULL);
+  int result = HANDLE_EINTR(kevent(kq.get(), &change, 1, NULL, 0, NULL));
+  if (result == -1) {
+    if (errno == ESRCH) {
+      // If the process wasn't found, it must be dead.
+      return true;
+    }
+
+    DPLOG(ERROR) << "kevent (setup " << handle << ")";
+    return false;
+  }
+
+  // Keep track of the elapsed time to be able to restart kevent if it's
+  // interrupted.
+  bool wait_forever = (wait == base::TimeDelta::Max());
+  base::TimeDelta remaining_delta;
+  base::TimeTicks deadline;
+  if (!wait_forever) {
+    remaining_delta = wait;
+    deadline = base::TimeTicks::Now() + remaining_delta;
+  }
+
+  result = -1;
+  struct kevent event = {0};
+
+  while (wait_forever || remaining_delta > base::TimeDelta()) {
+    struct timespec remaining_timespec;
+    struct timespec* remaining_timespec_ptr;
+    if (wait_forever) {
+      remaining_timespec_ptr = NULL;
+    } else {
+      remaining_timespec = remaining_delta.ToTimeSpec();
+      remaining_timespec_ptr = &remaining_timespec;
+    }
+
+    result = kevent(kq.get(), NULL, 0, &event, 1, remaining_timespec_ptr);
+
+    if (result == -1 && errno == EINTR) {
+      if (!wait_forever) {
+        remaining_delta = deadline - base::TimeTicks::Now();
+      }
+      result = 0;
+    } else {
+      break;
+    }
+  }
+
+  if (result < 0) {
+    DPLOG(ERROR) << "kevent (wait " << handle << ")";
+    return false;
+  } else if (result > 1) {
+    DLOG(ERROR) << "kevent (wait " << handle << "): unexpected result "
+                << result;
+    return false;
+  } else if (result == 0) {
+    // Timed out.
+    return false;
+  }
+
+  DCHECK_EQ(result, 1);
+
+  if (event.filter != EVFILT_PROC ||
+      (event.fflags & NOTE_EXIT) == 0 ||
+      event.ident != static_cast<uintptr_t>(handle)) {
+    DLOG(ERROR) << "kevent (wait " << handle
+                << "): unexpected event: filter=" << event.filter
+                << ", fflags=" << event.fflags
+                << ", ident=" << event.ident;
+    return false;
+  }
+
+  return true;
+}
+#endif  // OS_MACOSX
+
+bool WaitForExitWithTimeoutImpl(base::ProcessHandle handle,
+                                int* exit_code,
+                                base::TimeDelta timeout) {
+  base::ProcessHandle parent_pid = base::GetParentProcessId(handle);
+  base::ProcessHandle our_pid = base::GetCurrentProcessHandle();
+  if (parent_pid != our_pid) {
+#if defined(OS_MACOSX)
+    // On Mac we can wait on non child processes.
+    return WaitForSingleNonChildProcess(handle, timeout);
+#else
+    // Currently on Linux we can't handle non child processes.
+    NOTIMPLEMENTED();
+#endif  // OS_MACOSX
+  }
+
+  int status;
+  if (!WaitpidWithTimeout(handle, &status, timeout))
+    return false;
+  if (WIFSIGNALED(status)) {
+    *exit_code = -1;
+    return true;
+  }
+  if (WIFEXITED(status)) {
+    *exit_code = WEXITSTATUS(status);
+    return true;
+  }
+  return false;
+}
+#endif  // !defined(OS_NACL_NONSFI)
+
+}  // namespace
+
 namespace base {
 
 Process::Process(ProcessHandle handle) : process_(handle) {
@@ -102,15 +296,11 @@
 }
 
 bool Process::WaitForExit(int* exit_code) {
-  // TODO(rvargas) crbug.com/417532: Remove this constant.
-  const int kNoTimeout = -1;
-  return WaitForExitWithTimeout(TimeDelta::FromMilliseconds(kNoTimeout),
-                                exit_code);
+  return WaitForExitWithTimeout(TimeDelta::Max(), exit_code);
 }
 
 bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) {
-  // TODO(rvargas) crbug.com/417532: Move the implementation here.
-  return base::WaitForExitCodeWithTimeout(Handle(), exit_code, timeout);
+  return WaitForExitWithTimeoutImpl(Handle(), exit_code, timeout);
 }
 
 #if !defined(OS_LINUX)

diff --git a/process/process_win.cc b/process/process_win.cc
index 8e5360b..b62fdb4 100644
--- a/process/process_win.cc
+++ b/process/process_win.cc

@@ -7,6 +7,7 @@
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/field_trial.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/process/kill.h"
 #include "base/win/windows_version.h"
 
@@ -141,10 +142,17 @@
 }
 
 bool Process::WaitForExitWithTimeout(TimeDelta timeout, int* exit_code) {
-  // TODO(rvargas) crbug.com/417532: Move the implementation here.
-  if (timeout > TimeDelta::FromMilliseconds(INFINITE))
-    timeout = TimeDelta::FromMilliseconds(INFINITE);
-  return base::WaitForExitCodeWithTimeout(Handle(), exit_code, timeout);
+  // Limit timeout to INFINITE.
+  DWORD timeout_ms = saturated_cast<DWORD>(timeout.InMilliseconds());
+  if (::WaitForSingleObject(Handle(), timeout_ms) != WAIT_OBJECT_0)
+    return false;
+
+  DWORD temp_code;  // Don't clobber out-parameters in case of failure.
+  if (!::GetExitCodeProcess(Handle(), &temp_code))
+    return false;
+
+  *exit_code = temp_code;
+  return true;
 }
 
 bool Process::IsProcessBackgrounded() const {

diff --git a/synchronization/waitable_event.h b/synchronization/waitable_event.h
index 5adc1ec..c35af54 100644
--- a/synchronization/waitable_event.h
+++ b/synchronization/waitable_event.h

@@ -21,9 +21,6 @@
 
 namespace base {
 
-// This replaces INFINITE from Win32
-static const int kNoTimeout = -1;
-
 class TimeDelta;
 
 // A WaitableEvent can be a useful thread synchronization tool when you want to

diff --git a/synchronization/waitable_event_watcher_win.cc b/synchronization/waitable_event_watcher_win.cc
index a04a435..46d47ac 100644
--- a/synchronization/waitable_event_watcher_win.cc
+++ b/synchronization/waitable_event_watcher_win.cc

@@ -5,7 +5,6 @@
 #include "base/synchronization/waitable_event_watcher.h"
 
 #include "base/compiler_specific.h"
-#include "base/profiler/scoped_tracker.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/win/object_watcher.h"
 
@@ -37,11 +36,6 @@
 }
 
 void WaitableEventWatcher::OnObjectSignaled(HANDLE h) {
-  // TODO(vadimt): Remove ScopedTracker below once crbug.com/418183 is fixed.
-  tracked_objects::ScopedTracker tracking_profile(
-      FROM_HERE_WITH_EXPLICIT_FUNCTION(
-          "418183 WaitableEventWatcher::OnObjectSignaled"));
-
   WaitableEvent* event = event_;
   EventCallback callback = callback_;
   event_ = NULL;

diff --git a/test/BUILD.gn b/test/BUILD.gn
index 05a3dc3..120159e 100644
--- a/test/BUILD.gn
+++ b/test/BUILD.gn

@@ -36,6 +36,8 @@
     "mock_chrome_application_mac.mm",
     "mock_devices_changed_observer.cc",
     "mock_devices_changed_observer.h",
+    "mock_log.cc",
+    "mock_log.h",
     "multiprocess_test.cc",
     "multiprocess_test.h",
     "multiprocess_test_android.cc",

diff --git a/test/data/pe_image/pe_image_test_32.dll b/test/data/pe_image/pe_image_test_32.dll
new file mode 100755
index 0000000..118ce11
--- /dev/null
+++ b/test/data/pe_image/pe_image_test_32.dll
Binary files differ

diff --git a/test/data/pe_image/pe_image_test_64.dll b/test/data/pe_image/pe_image_test_64.dll
new file mode 100755
index 0000000..70f8ea4
--- /dev/null
+++ b/test/data/pe_image/pe_image_test_64.dll
Binary files differ

diff --git a/test/data/prefs/write.golden.json b/test/data/prefs/write.golden.json
index 9a5523c..fb1fff1 100644
--- a/test/data/prefs/write.golden.json
+++ b/test/data/prefs/write.golden.json

@@ -1,11 +1 @@
-{
-   "homepage": "http://www.cnn.com",
-   "long_int": {
-      "pref": "214748364842"
-   },
-   "some_directory": "/usr/sbin/",
-   "tabs": {
-      "max_tabs": 10,
-      "new_windows_in_tabs": false
-   }
-}
+{"homepage":"http://www.cnn.com","long_int":{"pref":"214748364842"},"some_directory":"/usr/sbin/","tabs":{"max_tabs":10,"new_windows_in_tabs":false}}
\ No newline at end of file

diff --git a/test/gtest_util.cc b/test/gtest_util.cc
index c0bc04a..b811194 100644
--- a/test/gtest_util.cc
+++ b/test/gtest_util.cc

@@ -47,7 +47,7 @@
 
 bool ReadTestNamesFromFile(const FilePath& path,
                            std::vector<SplitTestName>* output) {
-  JSONFileValueSerializer deserializer(path);
+  JSONFileValueDeserializer deserializer(path);
   int error_code = 0;
   std::string error_message;
   scoped_ptr<base::Value> value(
@@ -80,4 +80,4 @@
   return true;
 }
 
-}  // namespace
+}  // namespace base

diff --git a/test/mock_log.cc b/test/mock_log.cc
new file mode 100644
index 0000000..fa511d4
--- /dev/null
+++ b/test/mock_log.cc

@@ -0,0 +1,68 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "base/test/mock_log.h"
+
+namespace base {
+namespace test {
+
+// static
+MockLog* MockLog::g_instance_ = nullptr;
+Lock MockLog::g_lock;
+
+MockLog::MockLog() : is_capturing_logs_(false) {
+}
+
+MockLog::~MockLog() {
+  if (is_capturing_logs_) {
+    StopCapturingLogs();
+  }
+}
+
+void MockLog::StartCapturingLogs() {
+  AutoLock scoped_lock(g_lock);
+
+  // We don't use CHECK(), which can generate a new LOG message, and
+  // thus can confuse MockLog objects or other registered
+  // LogSinks.
+  RAW_CHECK(!is_capturing_logs_);
+  RAW_CHECK(!g_instance_);
+
+  is_capturing_logs_ = true;
+  g_instance_ = this;
+  previous_handler_ = logging::GetLogMessageHandler();
+  logging::SetLogMessageHandler(LogMessageHandler);
+}
+
+void MockLog::StopCapturingLogs() {
+  AutoLock scoped_lock(g_lock);
+
+  // We don't use CHECK(), which can generate a new LOG message, and
+  // thus can confuse MockLog objects or other registered
+  // LogSinks.
+  RAW_CHECK(is_capturing_logs_);
+  RAW_CHECK(g_instance_ == this);
+
+  is_capturing_logs_ = false;
+  logging::SetLogMessageHandler(previous_handler_);
+  g_instance_ = nullptr;
+}
+
+// static
+bool MockLog::LogMessageHandler(int severity,
+                                const char* file,
+                                int line,
+                                size_t message_start,
+                                const std::string& str) {
+  // gMock guarantees thread-safety for calling a mocked method
+  // (https://code.google.com/p/googlemock/wiki/CookBook#Using_Google_Mock_and_Threads)
+  // but we also need to make sure that Start/StopCapturingLogs are synchronized
+  // with LogMessageHandler.
+  AutoLock scoped_lock(g_lock);
+
+  return g_instance_->Log(severity, file, line, message_start, str);
+}
+
+}  // namespace test
+}  // namespace base

diff --git a/test/mock_log.h b/test/mock_log.h
new file mode 100644
index 0000000..315ef1f
--- /dev/null
+++ b/test/mock_log.h

@@ -0,0 +1,98 @@
+// Copyright 2015 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef BASE_TEST_MOCK_LOG_H_
+#define BASE_TEST_MOCK_LOG_H_
+
+#include <string>
+
+#include "base/logging.h"
+#include "base/macros.h"
+#include "base/synchronization/lock.h"
+#include "testing/gmock/include/gmock/gmock.h"
+
+namespace base {
+namespace test {
+
+// A MockLog object intercepts LOG() messages issued during its lifespan.  Using
+// this together with gMock, it's very easy to test how a piece of code calls
+// LOG().  The typical usage:
+//
+//   TEST(FooTest, LogsCorrectly) {
+//     MockLog log;
+//
+//     // We expect the WARNING "Something bad!" exactly twice.
+//     EXPECT_CALL(log, Log(WARNING, _, "Something bad!"))
+//         .Times(2);
+//
+//     // We allow foo.cc to call LOG(INFO) any number of times.
+//     EXPECT_CALL(log, Log(INFO, HasSubstr("/foo.cc"), _))
+//         .Times(AnyNumber());
+//
+//     log.StartCapturingLogs();  // Call this after done setting expectations.
+//     Foo();  // Exercises the code under test.
+//   }
+//
+// CAVEAT: base/logging does not allow a thread to call LOG() again when it's
+// already inside a LOG() call.  Doing so will cause a deadlock.  Therefore,
+// it's the user's responsibility to not call LOG() in an action triggered by
+// MockLog::Log().  You may call RAW_LOG() instead.
+class MockLog {
+ public:
+  // Creates a MockLog object that is not capturing logs.  If it were to start
+  // to capture logs, it could be a problem if some other threads already exist
+  // and are logging, as the user hasn't had a chance to set up expectation on
+  // this object yet (calling a mock method before setting the expectation is
+  // UNDEFINED behavior).
+  MockLog();
+
+  // When the object is destructed, it stops intercepting logs.
+  ~MockLog();
+
+  // Starts log capturing if the object isn't already doing so.
+  // Otherwise crashes.
+  void StartCapturingLogs();
+
+  // Stops log capturing if the object is capturing logs.  Otherwise crashes.
+  void StopCapturingLogs();
+
+  // Log method is invoked for every log message before it's sent to other log
+  // destinations (if any).  The method should return true to signal that it
+  // handled the message and the message should not be sent to other log
+  // destinations.
+  MOCK_METHOD5(Log,
+               bool(int severity,
+                    const char* file,
+                    int line,
+                    size_t message_start,
+                    const std::string& str));
+
+ private:
+  // The currently active mock log.
+  static MockLog* g_instance_;
+
+  // Lock protecting access to g_instance_.
+  static Lock g_lock;
+
+  // Static function which is set as the logging message handler.
+  // Called once for each message.
+  static bool LogMessageHandler(int severity,
+                                const char* file,
+                                int line,
+                                size_t message_start,
+                                const std::string& str);
+
+  // True if this object is currently capturing logs.
+  bool is_capturing_logs_;
+
+  // The previous handler to restore when the MockLog is destroyed.
+  logging::LogMessageHandlerFunction previous_handler_;
+
+  DISALLOW_COPY_AND_ASSIGN(MockLog);
+};
+
+}  // namespace test
+}  // namespace base
+
+#endif  // BASE_TEST_MOCK_LOG_H_

diff --git a/test/test_mock_time_task_runner.cc b/test/test_mock_time_task_runner.cc
index a878280..8e65ccf 100644
--- a/test/test_mock_time_task_runner.cc
+++ b/test/test_mock_time_task_runner.cc

@@ -154,8 +154,7 @@
     const tracked_objects::Location& from_here,
     const Closure& task,
     TimeDelta delay) {
-  NOTREACHED();
-  return false;
+  return PostDelayedTask(from_here, task, delay);
 }
 
 void TestMockTimeTaskRunner::OnBeforeSelectingTask() {

diff --git a/test/test_mock_time_task_runner.h b/test/test_mock_time_task_runner.h
index 1a651f6..5f06013 100644
--- a/test/test_mock_time_task_runner.h
+++ b/test/test_mock_time_task_runner.h

@@ -32,13 +32,12 @@
 //   - It allows for reentrancy, in that it handles the running of tasks that in
 //     turn call back into it (e.g., to post more tasks).
 //   - Tasks are stored in a priority queue, and executed in the increasing
-//     order of post time + delay.
+//     order of post time + delay, but ignoring nestability.
 //   - It does not check for overflow when doing time arithmetic. A sufficient
 //     condition for preventing overflows is to make sure that the sum of all
 //     posted task delays and fast-forward increments is still representable by
 //     a TimeDelta, and that adding this delta to the starting values of Time
 //     and TickTime is still within their respective range.
-//   - Non-nestable tasks are not supported.
 //   - Tasks aren't guaranteed to be destroyed immediately after they're run.
 //
 // This is a slightly more sophisticated version of TestSimpleTaskRunner, in

diff --git a/third_party/nspr/BUILD.gn b/third_party/nspr/BUILD.gn
index c0b2ec2..a67e168 100644
--- a/third_party/nspr/BUILD.gn
+++ b/third_party/nspr/BUILD.gn

@@ -3,9 +3,7 @@
 # found in the LICENSE file.
 
 source_set("nspr") {
-  visibility = [
-    "//base/*",
-  ]
+  visibility = [ "//base/*" ]
 
   sources = [
     "prtime.cc",

diff --git a/threading/sequenced_worker_pool.cc b/threading/sequenced_worker_pool.cc
index 89224f7..19b81b7 100644
--- a/threading/sequenced_worker_pool.cc
+++ b/threading/sequenced_worker_pool.cc

@@ -798,9 +798,11 @@
         // to run them. Also, there may be some tasks stuck behind running
         // ones with the same sequence token, but additional threads won't
         // help this case.
-        if (shutdown_called_ &&
-            blocking_shutdown_pending_task_count_ == 0)
+        if (shutdown_called_ && blocking_shutdown_pending_task_count_ == 0) {
+          AutoUnlock unlock(lock_);
+          delete_these_outside_lock.clear();
           break;
+        }
         waiting_thread_count_++;
 
         switch (status) {

diff --git a/threading/sequenced_worker_pool_unittest.cc b/threading/sequenced_worker_pool_unittest.cc
index ed5f896..9d0f607 100644
--- a/threading/sequenced_worker_pool_unittest.cc
+++ b/threading/sequenced_worker_pool_unittest.cc

@@ -67,6 +67,23 @@
   size_t unblock_counter_;
 };
 
+class DestructionDeadlockChecker
+    : public base::RefCountedThreadSafe<DestructionDeadlockChecker> {
+ public:
+  DestructionDeadlockChecker(const scoped_refptr<SequencedWorkerPool>& pool)
+      : pool_(pool) {}
+
+ protected:
+  virtual ~DestructionDeadlockChecker() {
+    // This method should not deadlock.
+    pool_->RunsTasksOnCurrentThread();
+  }
+
+ private:
+  scoped_refptr<SequencedWorkerPool> pool_;
+  friend class base::RefCountedThreadSafe<DestructionDeadlockChecker>;
+};
+
 class TestTracker : public base::RefCountedThreadSafe<TestTracker> {
  public:
   TestTracker()
@@ -117,6 +134,20 @@
     SignalWorkerDone(id);
   }
 
+  // This task posts itself back onto the SequencedWorkerPool before it
+  // finishes running. Each instance of the task maintains a strong reference
+  // to a DestructionDeadlockChecker. The DestructionDeadlockChecker is only
+  // destroyed when the task is destroyed without being run, which only happens
+  // during destruction of the SequencedWorkerPool.
+  void PostRepostingTask(
+      const scoped_refptr<SequencedWorkerPool>& pool,
+      const scoped_refptr<DestructionDeadlockChecker>& checker) {
+    Closure reposting_task =
+        base::Bind(&TestTracker::PostRepostingTask, this, pool, checker);
+    pool->PostWorkerTaskWithShutdownBehavior(
+        FROM_HERE, reposting_task, SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+  }
+
   // Waits until the given number of tasks have started executing.
   void WaitUntilTasksBlocked(size_t count) {
     {
@@ -749,6 +780,21 @@
   unused_pool->Shutdown();
 }
 
+// Checks that tasks are destroyed in the right context during shutdown. If a
+// task is destroyed while SequencedWorkerPool's global lock is held,
+// SequencedWorkerPool might deadlock.
+TEST_F(SequencedWorkerPoolTest, AvoidsDeadlockOnShutdown) {
+  for (int i = 0; i < 4; ++i) {
+    scoped_refptr<DestructionDeadlockChecker> checker(
+        new DestructionDeadlockChecker(pool()));
+    tracker()->PostRepostingTask(pool(), checker);
+  }
+
+  // Shutting down the pool should destroy the DestructionDeadlockCheckers,
+  // which in turn should not deadlock in their destructors.
+  pool()->Shutdown();
+}
+
 // Verify that FlushForTesting works as intended.
 TEST_F(SequencedWorkerPoolTest, FlushForTesting) {
   // Should be fine to call on a new instance.

diff --git a/threading/thread_restrictions.h b/threading/thread_restrictions.h
index 7c46fd2..1e5f510 100644
--- a/threading/thread_restrictions.h
+++ b/threading/thread_restrictions.h

@@ -22,6 +22,7 @@
 
 namespace cc {
 class CompletionEvent;
+class TaskGraphRunner;
 }
 namespace chromeos {
 class BlockingMethodCaller;
@@ -177,6 +178,7 @@
   friend class ::HistogramSynchronizer;
   friend class ::ScopedAllowWaitForLegacyWebViewApi;
   friend class cc::CompletionEvent;
+  friend class cc::TaskGraphRunner;
   friend class mojo::common::WatcherThreadManager;
   friend class remoting::AutoThread;
   friend class MessagePumpDefault;

diff --git a/timer/timer.cc b/timer/timer.cc
index 11f73ca..fa6b8cd 100644
--- a/timer/timer.cc
+++ b/timer/timer.cc

@@ -163,8 +163,10 @@
   }
   // Remember the thread ID that posts the first task -- this will be verified
   // later when the task is abandoned to detect misuse from multiple threads.
-  if (!thread_id_)
+  if (!thread_id_) {
+    DCHECK(GetTaskRunner()->BelongsToCurrentThread());
     thread_id_ = static_cast<int>(PlatformThread::CurrentId());
+  }
 }
 
 scoped_refptr<SingleThreadTaskRunner> Timer::GetTaskRunner() {

diff --git a/timer/timer.h b/timer/timer.h
index ea34a9f..1ef58a3 100644
--- a/timer/timer.h
+++ b/timer/timer.h

@@ -89,7 +89,8 @@
   virtual TimeDelta GetCurrentDelay() const;
 
   // Set the task runner on which the task should be scheduled. This method can
-  // only be called before any tasks have been scheduled.
+  // only be called before any tasks have been scheduled. The task runner must
+  // run tasks on the same thread the timer is used on.
   virtual void SetTaskRunner(scoped_refptr<SingleThreadTaskRunner> task_runner);
 
   // Start the timer to run at the given |delay| from now. If the timer is

diff --git a/trace_event/memory_dump_manager.cc b/trace_event/memory_dump_manager.cc
index c8be8f8..cbed238 100644
--- a/trace_event/memory_dump_manager.cc
+++ b/trace_event/memory_dump_manager.cc

@@ -6,6 +6,7 @@
 
 #include <algorithm>
 
+#include "base/atomic_sequence_num.h"
 #include "base/compiler_specific.h"
 #include "base/trace_event/memory_dump_provider.h"
 #include "base/trace_event/process_memory_dump.h"
@@ -15,7 +16,27 @@
 namespace trace_event {
 
 namespace {
+
 MemoryDumpManager* g_instance_for_testing = nullptr;
+const int kTraceEventNumArgs = 1;
+const char* kTraceEventArgNames[] = {"dumps"};
+const unsigned char kTraceEventArgTypes[] = {TRACE_VALUE_TYPE_CONVERTABLE};
+StaticAtomicSequenceNumber g_next_guid;
+
+const char* DumpPointTypeToString(const DumpPointType& dump_point_type) {
+  switch (dump_point_type) {
+    case DumpPointType::TASK_BEGIN:
+      return "TASK_BEGIN";
+    case DumpPointType::TASK_END:
+      return "TASK_END";
+    case DumpPointType::PERIODIC_INTERVAL:
+      return "PERIODIC_INTERVAL";
+    case DumpPointType::EXPLICITLY_TRIGGERED:
+      return "EXPLICITLY_TRIGGERED";
+  }
+  NOTREACHED();
+  return "UNKNOWN";
+}
 }
 
 // TODO(primiano): this should be smarter and should do something similar to
@@ -76,13 +97,18 @@
     dump_providers_enabled_.erase(it);
 }
 
-void MemoryDumpManager::RequestDumpPoint(DumpPointType type) {
-  // TODO(primiano): this will have more logic, IPC broadcast & co.
+void MemoryDumpManager::RequestDumpPoint(DumpPointType dump_point_type) {
+  // TODO(primiano): this will have more logic to coordinate dump points across
+  // multiple processes via IPC. See crbug.com/462930.
+
   // Bail out immediately if tracing is not enabled at all.
   if (!UNLIKELY(subtle::NoBarrier_Load(&memory_tracing_enabled_)))
     return;
 
-  CreateLocalDumpPoint();
+  // TODO(primiano): Make guid actually unique (cross-process) by hashing it
+  // with the PID. See crbug.com/462931 for details.
+  const uint64 guid = g_next_guid.GetNext();
+  CreateLocalDumpPoint(dump_point_type, guid);
 }
 
 void MemoryDumpManager::BroadcastDumpRequest() {
@@ -90,17 +116,44 @@
 }
 
 // Creates a dump point for the current process and appends it to the trace.
-void MemoryDumpManager::CreateLocalDumpPoint() {
-  AutoLock lock(lock_);
+void MemoryDumpManager::CreateLocalDumpPoint(DumpPointType dump_point_type,
+                                             uint64 guid) {
+  bool did_any_provider_dump = false;
   scoped_ptr<ProcessMemoryDump> pmd(new ProcessMemoryDump());
 
-  for (MemoryDumpProvider* dump_provider : dump_providers_enabled_) {
-    dump_provider->DumpInto(pmd.get());
+  // Serialize dump point generation so that memory dump providers don't have to
+  // deal with thread safety.
+  {
+    AutoLock lock(lock_);
+    for (auto it = dump_providers_enabled_.begin();
+         it != dump_providers_enabled_.end();) {
+      MemoryDumpProvider* dump_provider = *it;
+      if (dump_provider->DumpInto(pmd.get())) {
+        did_any_provider_dump = true;
+        ++it;
+      } else {
+        LOG(ERROR) << "The memory dumper " << dump_provider->GetFriendlyName()
+                   << " failed, possibly due to sandboxing (crbug.com/461788), "
+                      "disabling it for current process. Try restarting chrome "
+                      "with the --no-sandbox switch.";
+        it = dump_providers_enabled_.erase(it);
+      }
+    }
   }
 
-  scoped_refptr<TracedValue> value(new TracedValue());
-  pmd->AsValueInto(value.get());
-  // TODO(primiano): add the dump point to the trace at this point.
+  // Don't create a dump point if all the dumpers failed.
+  if (!did_any_provider_dump)
+    return;
+
+  scoped_refptr<ConvertableToTraceFormat> event_value(new TracedValue());
+  pmd->AsValueInto(static_cast<TracedValue*>(event_value.get()));
+  const char* const event_name = DumpPointTypeToString(dump_point_type);
+
+  TRACE_EVENT_API_ADD_TRACE_EVENT(
+      TRACE_EVENT_PHASE_MEMORY_DUMP,
+      TraceLog::GetCategoryGroupEnabled(kTraceCategory), event_name, guid,
+      kTraceEventNumArgs, kTraceEventArgNames, kTraceEventArgTypes,
+      NULL /* arg_values */, &event_value, TRACE_EVENT_FLAG_HAS_ID);
 }
 
 void MemoryDumpManager::OnTraceLogEnabled() {

diff --git a/trace_event/memory_dump_manager.h b/trace_event/memory_dump_manager.h
index 1a22e61..8a9b3b7 100644
--- a/trace_event/memory_dump_manager.h
+++ b/trace_event/memory_dump_manager.h

@@ -43,7 +43,7 @@
 
   // Requests a memory dump. The dump might happen or not depending on the
   // filters and categories specified when enabling tracing.
-  void RequestDumpPoint(DumpPointType type);
+  void RequestDumpPoint(DumpPointType dump_point_type);
 
   // TraceLog::EnabledStateObserver implementation.
   void OnTraceLogEnabled() override;
@@ -65,7 +65,7 @@
   void BroadcastDumpRequest();
 
   // Creates a dump point for the current process and appends it to the trace.
-  void CreateLocalDumpPoint();
+  void CreateLocalDumpPoint(DumpPointType dump_point_type, uint64 guid);
 
   std::vector<MemoryDumpProvider*> dump_providers_registered_;  // Not owned.
   std::vector<MemoryDumpProvider*> dump_providers_enabled_;     // Not owned.

diff --git a/trace_event/memory_dump_manager_unittest.cc b/trace_event/memory_dump_manager_unittest.cc
index 1ba73e6..78be377 100644
--- a/trace_event/memory_dump_manager_unittest.cc
+++ b/trace_event/memory_dump_manager_unittest.cc

@@ -10,6 +10,7 @@
 #include "testing/gtest/include/gtest/gtest.h"
 
 using testing::_;
+using testing::Return;
 
 namespace base {
 namespace trace_event {
@@ -48,7 +49,9 @@
 
 class MockDumpProvider : public MemoryDumpProvider {
  public:
-  MOCK_METHOD1(DumpInto, void(ProcessMemoryDump* pmd));
+  MOCK_METHOD1(DumpInto, bool(ProcessMemoryDump* pmd));
+
+  const char* GetFriendlyName() const override { return "MockDumpProvider"; }
 };
 
 TEST_F(MemoryDumpManagerTest, SingleDumper) {
@@ -64,7 +67,7 @@
   // Now repeat enabling the memory category and check that the dumper is
   // invoked this time.
   EnableTracing(kTraceCategory);
-  EXPECT_CALL(mdp, DumpInto(_)).Times(3);
+  EXPECT_CALL(mdp, DumpInto(_)).Times(3).WillRepeatedly(Return(true));
   for (int i = 0; i < 3; ++i)
     mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
   DisableTracing();
@@ -83,7 +86,7 @@
   mdm_->RegisterDumpProvider(&mdp);
 
   EnableTracing(kTraceCategory);
-  EXPECT_CALL(mdp, DumpInto(_)).Times(1);
+  EXPECT_CALL(mdp, DumpInto(_)).Times(1).WillRepeatedly(Return(true));
   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
 
   mdm_->UnregisterDumpProvider(&mdp);
@@ -100,7 +103,7 @@
   // Enable only mdp1.
   mdm_->RegisterDumpProvider(&mdp1);
   EnableTracing(kTraceCategory);
-  EXPECT_CALL(mdp1, DumpInto(_)).Times(1);
+  EXPECT_CALL(mdp1, DumpInto(_)).Times(1).WillRepeatedly(Return(true));
   EXPECT_CALL(mdp2, DumpInto(_)).Times(0);
   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
   DisableTracing();
@@ -110,18 +113,40 @@
   mdm_->RegisterDumpProvider(&mdp2);
   EnableTracing(kTraceCategory);
   EXPECT_CALL(mdp1, DumpInto(_)).Times(0);
-  EXPECT_CALL(mdp2, DumpInto(_)).Times(1);
+  EXPECT_CALL(mdp2, DumpInto(_)).Times(1).WillRepeatedly(Return(true));
   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
   DisableTracing();
 
   // Enable both mdp1 and mdp2.
   mdm_->RegisterDumpProvider(&mdp1);
   EnableTracing(kTraceCategory);
-  EXPECT_CALL(mdp1, DumpInto(_)).Times(1);
-  EXPECT_CALL(mdp2, DumpInto(_)).Times(1);
+  EXPECT_CALL(mdp1, DumpInto(_)).Times(1).WillRepeatedly(Return(true));
+  EXPECT_CALL(mdp2, DumpInto(_)).Times(1).WillRepeatedly(Return(true));
   mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
   DisableTracing();
 }
 
+// Enable both dump providers, make mdp1 fail and assert that only mdp2 is
+// invoked the 2nd time.
+// FIXME(primiano): remove once crbug.com/461788 gets fixed.
+TEST_F(MemoryDumpManagerTest, DisableFailingDumpers) {
+  MockDumpProvider mdp1;
+  MockDumpProvider mdp2;
+
+  mdm_->RegisterDumpProvider(&mdp1);
+  mdm_->RegisterDumpProvider(&mdp2);
+  EnableTracing(kTraceCategory);
+
+  EXPECT_CALL(mdp1, DumpInto(_)).Times(1).WillRepeatedly(Return(false));
+  EXPECT_CALL(mdp2, DumpInto(_)).Times(1).WillRepeatedly(Return(true));
+  mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
+
+  EXPECT_CALL(mdp1, DumpInto(_)).Times(0);
+  EXPECT_CALL(mdp2, DumpInto(_)).Times(1).WillRepeatedly(Return(false));
+  mdm_->RequestDumpPoint(DumpPointType::EXPLICITLY_TRIGGERED);
+
+  DisableTracing();
+}
+
 }  // namespace trace_Event
 }  // namespace base

diff --git a/trace_event/memory_dump_provider.h b/trace_event/memory_dump_provider.h
index 18363c5..1c5bbb1 100644
--- a/trace_event/memory_dump_provider.h
+++ b/trace_event/memory_dump_provider.h

@@ -17,7 +17,10 @@
 class BASE_EXPORT MemoryDumpProvider {
  public:
   // Called by the MemoryDumpManager when generating dump points.
-  virtual void DumpInto(ProcessMemoryDump* pmd) = 0;
+  // Returns: true if the |pmd| was successfully populated, false otherwise.
+  virtual bool DumpInto(ProcessMemoryDump* pmd) = 0;
+
+  virtual const char* GetFriendlyName() const = 0;
 
  protected:
   MemoryDumpProvider() {}

diff --git a/trace_event/process_memory_maps_dump_provider.cc b/trace_event/process_memory_maps_dump_provider.cc
index e1cefc3..93feded 100644
--- a/trace_event/process_memory_maps_dump_provider.cc
+++ b/trace_event/process_memory_maps_dump_provider.cc

@@ -15,6 +15,10 @@
 namespace base {
 namespace trace_event {
 
+namespace {
+const char kDumperFriendlyName[] = "ProcessMemoryMaps";
+}
+
 #if defined(OS_LINUX) || defined(OS_ANDROID)
 // static
 std::istream* ProcessMemoryMapsDumpProvider::proc_smaps_for_testing = nullptr;
@@ -104,10 +108,9 @@
 }
 
 uint32 ReadLinuxProcSmapsFile(std::istream* smaps, ProcessMemoryMaps* pmm) {
-  if (!smaps->good()) {
-    LOG(ERROR) << "Could not read smaps file.";
+  if (!smaps->good())
     return 0;
-  }
+
   const uint32 kNumExpectedCountersPerRegion = 2;
   uint32 counters_parsed_for_current_region = 0;
   uint32 num_valid_regions = 0;
@@ -154,7 +157,7 @@
 
 // Called at trace dump point time. Creates a snapshot the memory maps for the
 // current process.
-void ProcessMemoryMapsDumpProvider::DumpInto(ProcessMemoryDump* pmd) {
+bool ProcessMemoryMapsDumpProvider::DumpInto(ProcessMemoryDump* pmd) {
   uint32 res = 0;
 
 #if defined(OS_LINUX) || defined(OS_ANDROID)
@@ -168,8 +171,16 @@
   LOG(ERROR) << "ProcessMemoryMaps dump provider is supported only on Linux";
 #endif
 
-  if (res > 0)
+  if (res > 0) {
     pmd->set_has_process_mmaps();
+    return true;
+  }
+
+  return false;
+}
+
+const char* ProcessMemoryMapsDumpProvider::GetFriendlyName() const {
+  return kDumperFriendlyName;
 }
 
 }  // namespace trace_event

diff --git a/trace_event/process_memory_maps_dump_provider.h b/trace_event/process_memory_maps_dump_provider.h
index 543f7fd..0d30db2 100644
--- a/trace_event/process_memory_maps_dump_provider.h
+++ b/trace_event/process_memory_maps_dump_provider.h

@@ -20,7 +20,8 @@
   static ProcessMemoryMapsDumpProvider* GetInstance();
 
   // MemoryDumpProvider implementation.
-  void DumpInto(ProcessMemoryDump* pmd) override;
+  bool DumpInto(ProcessMemoryDump* pmd) override;
+  const char* GetFriendlyName() const override;
 
  private:
   friend struct DefaultSingletonTraits<ProcessMemoryMapsDumpProvider>;

diff --git a/trace_event/process_memory_totals_dump_provider.cc b/trace_event/process_memory_totals_dump_provider.cc
index cda0ff1..125be38 100644
--- a/trace_event/process_memory_totals_dump_provider.cc
+++ b/trace_event/process_memory_totals_dump_provider.cc

@@ -15,6 +15,9 @@
 uint64 ProcessMemoryTotalsDumpProvider::rss_bytes_for_testing = 0;
 
 namespace {
+
+const char kDumperFriendlyName[] = "ProcessMemoryTotals";
+
 ProcessMetrics* CreateProcessMetricsForCurrentProcess() {
 #if !defined(OS_MACOSX) || defined(OS_IOS)
   return ProcessMetrics::CreateProcessMetrics(GetCurrentProcessHandle());
@@ -41,12 +44,22 @@
 
 // Called at trace dump point time. Creates a snapshot the memory counters for
 // the current process.
-void ProcessMemoryTotalsDumpProvider::DumpInto(ProcessMemoryDump* pmd) {
+bool ProcessMemoryTotalsDumpProvider::DumpInto(ProcessMemoryDump* pmd) {
   const uint64 rss_bytes = rss_bytes_for_testing
                                ? rss_bytes_for_testing
                                : process_metrics_->GetWorkingSetSize();
-  pmd->process_totals()->set_resident_set_bytes(rss_bytes);
-  pmd->set_has_process_totals();
+
+  if (rss_bytes > 0) {
+    pmd->process_totals()->set_resident_set_bytes(rss_bytes);
+    pmd->set_has_process_totals();
+    return true;
+  }
+
+  return false;
+}
+
+const char* ProcessMemoryTotalsDumpProvider::GetFriendlyName() const {
+  return kDumperFriendlyName;
 }
 
 }  // namespace trace_event

diff --git a/trace_event/process_memory_totals_dump_provider.h b/trace_event/process_memory_totals_dump_provider.h
index 45917a8..8dae966 100644
--- a/trace_event/process_memory_totals_dump_provider.h
+++ b/trace_event/process_memory_totals_dump_provider.h

@@ -22,7 +22,8 @@
   static ProcessMemoryTotalsDumpProvider* GetInstance();
 
   // MemoryDumpProvider implementation.
-  void DumpInto(ProcessMemoryDump* pmd) override;
+  bool DumpInto(ProcessMemoryDump* pmd) override;
+  const char* GetFriendlyName() const override;
 
  private:
   friend struct DefaultSingletonTraits<ProcessMemoryTotalsDumpProvider>;

diff --git a/trace_event/trace_event.h b/trace_event/trace_event.h
index e12d8f4..c30a84a 100644
--- a/trace_event/trace_event.h
+++ b/trace_event/trace_event.h

@@ -1039,6 +1039,7 @@
 #define TRACE_EVENT_PHASE_CREATE_OBJECT ('N')
 #define TRACE_EVENT_PHASE_SNAPSHOT_OBJECT ('O')
 #define TRACE_EVENT_PHASE_DELETE_OBJECT ('D')
+#define TRACE_EVENT_PHASE_MEMORY_DUMP ('v')
 
 // Flags for changing the behavior of TRACE_EVENT_API_ADD_TRACE_EVENT.
 #define TRACE_EVENT_FLAG_NONE         (static_cast<unsigned char>(0))

diff --git a/values.cc b/values.cc
index 061b7a1..52876cf 100644
--- a/values.cc
+++ b/values.cc

@@ -1143,6 +1143,9 @@
 ValueSerializer::~ValueSerializer() {
 }
 
+ValueDeserializer::~ValueDeserializer() {
+}
+
 std::ostream& operator<<(std::ostream& out, const Value& value) {
   std::string json;
   JSONWriter::WriteWithOptions(&value,

diff --git a/values.h b/values.h
index 4648283..1e1cae3 100644
--- a/values.h
+++ b/values.h

@@ -492,13 +492,20 @@
   DISALLOW_COPY_AND_ASSIGN(ListValue);
 };
 
-// This interface is implemented by classes that know how to serialize and
-// deserialize Value objects.
+// This interface is implemented by classes that know how to serialize
+// Value objects.
 class BASE_EXPORT ValueSerializer {
  public:
   virtual ~ValueSerializer();
 
   virtual bool Serialize(const Value& root) = 0;
+};
+
+// This interface is implemented by classes that know how to deserialize Value
+// objects.
+class BASE_EXPORT ValueDeserializer {
+ public:
+  virtual ~ValueDeserializer();
 
   // This method deserializes the subclass-specific format into a Value object.
   // If the return value is non-NULL, the caller takes ownership of returned

diff --git a/win/pe_image_unittest.cc b/win/pe_image_unittest.cc
index 4134741..28b65a4 100644
--- a/win/pe_image_unittest.cc
+++ b/win/pe_image_unittest.cc

@@ -6,129 +6,10 @@
 #include <algorithm>
 #include <vector>
 
-#include "testing/gtest/include/gtest/gtest.h"
+#include "base/files/file_path.h"
+#include "base/path_service.h"
 #include "base/win/pe_image.h"
-#include "base/win/windows_version.h"
-
-namespace {
-
-class Expectations {
- public:
-  enum Value {
-    SECTIONS = 0,
-    IMPORTS_DLLS,
-    DELAY_DLLS,
-    EXPORTS,
-    IMPORTS,
-    DELAY_IMPORTS,
-    RELOCS
-  };
-
-  enum Arch {
-    ARCH_X86 = 0,
-    ARCH_X64,
-    ARCH_ALL
-  };
-
-  Expectations();
-
-  void SetDefault(Value value, int count);
-  void SetOverride(Value value, base::win::Version version,
-                   Arch arch, int count);
-  void SetOverride(Value value, base::win::Version version, int count);
-  void SetOverride(Value value, Arch arch, int count);
-
-  // returns -1 on failure.
-  int GetExpectation(Value value);
-
- private:
-  class Override {
-   public:
-    enum MatchType { MATCH_VERSION, MATCH_ARCH, MATCH_BOTH, MATCH_NONE };
-
-    Override(Value value, base::win::Version version, Arch arch, int count)
-      : value_(value), version_(version), arch_(arch), count_(count) {
-    };
-
-    bool Matches(Value value, base::win::Version version,
-                 Arch arch, MatchType type) {
-      if (value_ != value)
-        return false;
-
-      switch (type) {
-        case MATCH_BOTH:
-          return (arch == arch_ && version == version_);
-        case MATCH_ARCH:
-          return (arch == arch_ && version_ == base::win::VERSION_WIN_LAST);
-        case MATCH_VERSION:
-          return (arch_ == ARCH_ALL && version == version_);
-        case MATCH_NONE:
-          return (arch_ == ARCH_ALL && version_ == base::win::VERSION_WIN_LAST);
-      }
-      return false;
-    }
-
-    int GetCount() { return count_; }
-
-   private:
-    Value value_;
-    base::win::Version version_;
-    Arch arch_;
-    int count_;
-  };
-
-  bool MatchesMyArch(Arch arch);
-
-  std::vector<Override> overrides_;
-  Arch my_arch_;
-  base::win::Version my_version_;
-};
-
-Expectations::Expectations() {
-  my_version_ = base::win::GetVersion();
-#if defined(ARCH_CPU_64_BITS)
-  my_arch_ = ARCH_X64;
-#else
-  my_arch_ = ARCH_X86;
-#endif
-}
-
-int Expectations::GetExpectation(Value value) {
-  // Prefer OS version specificity over Arch specificity.
-  for (auto type : { Override::MATCH_BOTH,
-                     Override::MATCH_VERSION,
-                     Override::MATCH_ARCH,
-                     Override::MATCH_NONE }) {
-    for (auto override : overrides_) {
-      if (override.Matches(value, my_version_, my_arch_, type))
-        return override.GetCount();
-    }
-  }
-  return -1;
-}
-
-void Expectations::SetDefault(Value value, int count) {
-  SetOverride(value, base::win::VERSION_WIN_LAST, ARCH_ALL, count);
-}
-
-void Expectations::SetOverride(Value value,
-                               base::win::Version version,
-                               Arch arch,
-                               int count) {
-  overrides_.push_back(Override(value, version, arch, count));
-}
-
-void Expectations::SetOverride(Value value,
-                               base::win::Version version,
-                               int count) {
-  SetOverride(value, version, ARCH_ALL, count);
-}
-
-void Expectations::SetOverride(Value value, Arch arch, int count) {
-  SetOverride(value, base::win::VERSION_WIN_LAST, arch, count);
-}
-
-}  // namespace
+#include "testing/gtest/include/gtest/gtest.h"
 
 namespace base {
 namespace win {
@@ -210,41 +91,35 @@
 }  // namespace
 
 // Tests that we are able to enumerate stuff from a PE file, and that
-// the actual number of items found is within the expected range.
+// the actual number of items found matches an expected value.
 TEST(PEImageTest, EnumeratesPE) {
-  Expectations expectations;
+  base::FilePath pe_image_test_path;
+  ASSERT_TRUE(PathService::Get(DIR_TEST_DATA, &pe_image_test_path));
+  pe_image_test_path = pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image"));
 
-#ifndef NDEBUG
-  // Default Debug expectations.
-  expectations.SetDefault(Expectations::SECTIONS, 7);
-  expectations.SetDefault(Expectations::IMPORTS_DLLS, 3);
-  expectations.SetDefault(Expectations::DELAY_DLLS, 2);
-  expectations.SetDefault(Expectations::EXPORTS, 2);
-  expectations.SetDefault(Expectations::IMPORTS, 49);
-  expectations.SetDefault(Expectations::DELAY_IMPORTS, 2);
-  expectations.SetDefault(Expectations::RELOCS, 438);
-
-  // 64-bit Debug expectations.
-  expectations.SetOverride(Expectations::SECTIONS, Expectations::ARCH_X64, 8);
-  expectations.SetOverride(Expectations::IMPORTS, Expectations::ARCH_X64, 69);
-  expectations.SetOverride(Expectations::RELOCS, Expectations::ARCH_X64, 632);
+#if defined(ARCH_CPU_64_BITS)
+  pe_image_test_path =
+      pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image_test_64.dll"));
+  const int sections = 6;
+  const int imports_dlls = 2;
+  const int delay_dlls = 2;
+  const int exports = 2;
+  const int imports = 69;
+  const int delay_imports = 2;
+  const int relocs = 632;
 #else
-  // Default Release expectations.
-  expectations.SetDefault(Expectations::SECTIONS, 5);
-  expectations.SetDefault(Expectations::IMPORTS_DLLS, 2);
-  expectations.SetDefault(Expectations::DELAY_DLLS, 2);
-  expectations.SetDefault(Expectations::EXPORTS, 2);
-  expectations.SetDefault(Expectations::IMPORTS, 66);
-  expectations.SetDefault(Expectations::DELAY_IMPORTS, 2);
-  expectations.SetDefault(Expectations::RELOCS, 1586);
-
-  // 64-bit Release expectations.
-  expectations.SetOverride(Expectations::SECTIONS, Expectations::ARCH_X64, 6);
-  expectations.SetOverride(Expectations::IMPORTS, Expectations::ARCH_X64, 69);
-  expectations.SetOverride(Expectations::RELOCS, Expectations::ARCH_X64, 632);
+  pe_image_test_path =
+      pe_image_test_path.Append(FILE_PATH_LITERAL("pe_image_test_32.dll"));
+  const int sections = 5;
+  const int imports_dlls = 2;
+  const int delay_dlls = 2;
+  const int exports = 2;
+  const int imports = 66;
+  const int delay_imports = 2;
+  const int relocs = 1586;
 #endif
 
-  HMODULE module = LoadLibrary(L"pe_image_test.dll");
+  HMODULE module = LoadLibrary(pe_image_test_path.value().c_str());
   ASSERT_TRUE(NULL != module);
 
   PEImage pe(module);
@@ -252,31 +127,31 @@
   EXPECT_TRUE(pe.VerifyMagic());
 
   pe.EnumSections(SectionsCallback, &count);
-  EXPECT_EQ(expectations.GetExpectation(Expectations::SECTIONS), count);
+  EXPECT_EQ(sections, count);
 
   count = 0;
   pe.EnumImportChunks(ImportChunksCallback, &count);
-  EXPECT_EQ(expectations.GetExpectation(Expectations::IMPORTS_DLLS), count);
+  EXPECT_EQ(imports_dlls, count);
 
   count = 0;
   pe.EnumDelayImportChunks(DelayImportChunksCallback, &count);
-  EXPECT_EQ(expectations.GetExpectation(Expectations::DELAY_DLLS), count);
+  EXPECT_EQ(delay_dlls, count);
 
   count = 0;
   pe.EnumExports(ExportsCallback, &count);
-  EXPECT_EQ(expectations.GetExpectation(Expectations::EXPORTS), count);
+  EXPECT_EQ(exports, count);
 
   count = 0;
   pe.EnumAllImports(ImportsCallback, &count);
-  EXPECT_EQ(expectations.GetExpectation(Expectations::IMPORTS), count);
+  EXPECT_EQ(imports, count);
 
   count = 0;
   pe.EnumAllDelayImports(ImportsCallback, &count);
-  EXPECT_EQ(expectations.GetExpectation(Expectations::DELAY_IMPORTS), count);
+  EXPECT_EQ(delay_imports, count);
 
   count = 0;
   pe.EnumRelocs(RelocsCallback, &count);
-  EXPECT_EQ(expectations.GetExpectation(Expectations::RELOCS), count);
+  EXPECT_EQ(relocs, count);
 
   FreeLibrary(module);
 }

diff --git a/win/scoped_process_information_unittest.cc b/win/scoped_process_information_unittest.cc
index ccfa729..614504d 100644
--- a/win/scoped_process_information_unittest.cc
+++ b/win/scoped_process_information_unittest.cc

@@ -8,6 +8,7 @@
 
 #include "base/command_line.h"
 #include "base/process/kill.h"
+#include "base/process/process.h"
 #include "base/test/multiprocess_test.h"
 #include "base/win/scoped_process_information.h"
 #include "testing/multiprocess_func_list.h"
@@ -135,13 +136,13 @@
 
   // Validate that we have separate handles that are good.
   int exit_code = 0;
-  ASSERT_TRUE(base::WaitForExitCode(process_info.TakeProcessHandle(),
-                                    &exit_code));
+  base::Process process(process_info.TakeProcessHandle());
+  ASSERT_TRUE(process.WaitForExit(&exit_code));
   ASSERT_EQ(7, exit_code);
 
   exit_code = 0;
-  ASSERT_TRUE(base::WaitForExitCode(duplicate.TakeProcessHandle(),
-                                    &exit_code));
+  base::Process dup_process(duplicate.TakeProcessHandle());
+  ASSERT_TRUE(dup_process.WaitForExit(&exit_code));
   ASSERT_EQ(7, exit_code);
 
   ASSERT_TRUE(::CloseHandle(process_info.TakeThreadHandle()));

diff --git a/win/win_util.cc b/win/win_util.cc
index a3c9ece..957f937 100644
--- a/win/win_util.cc
+++ b/win/win_util.cc

@@ -57,7 +57,7 @@
 
 // Returns true if a physical keyboard is detected on Windows 8 and up.
 // Uses the Setup APIs to enumerate the attached keyboards and returns true
-// if the keyboard count is more than 1. While this will work in most cases
+// if the keyboard count is 1 or more.. While this will work in most cases
 // it won't work if there are devices which expose keyboard interfaces which
 // are attached to the machine.
 bool IsKeyboardPresentOnSlate() {
@@ -89,6 +89,7 @@
     device_info_data.cbSize = sizeof(device_info_data);
     if (!SetupDiEnumDeviceInfo(device_info, i, &device_info_data))
       break;
+
     // Get the device ID.
     wchar_t device_id[MAX_DEVICE_ID_LEN];
     CONFIGRET status = CM_Get_Device_ID(device_info_data.DevInst,
@@ -96,20 +97,19 @@
                                         MAX_DEVICE_ID_LEN,
                                         0);
     if (status == CR_SUCCESS) {
-      // To reduce the scope of the hack we only look for PNP and HID
+      // To reduce the scope of the hack we only look for PNP, MSF and HID
       // keyboards.
-      if (StartsWith(L"ACPI\\PNP", device_id, false) ||
-          StartsWith(L"HID\\VID", device_id, false)) {
+      if (StartsWith(device_id, L"ACPI\\PNP", false) ||
+          StartsWith(device_id, L"ACPI\\MSF", false) ||
+          StartsWith(device_id, L"HID\\VID", false)) {
         keyboard_count++;
       }
     }
   }
-  // On a Windows machine, the API's always report 1 keyboard at least
-  // regardless of whether the machine has a keyboard attached or not.
-  // The heuristic we are using is to check the count and return true
-  // if the API's report more than one keyboard. Please note that this
+  // The heuristic we are using is to check the count of keyboards and return
+  // true if the API's report one or more keyboards. Please note that this
   // will break for non keyboard devices which expose a keyboard PDO.
-  return keyboard_count > 1;
+  return keyboard_count >= 1;
 }
 
 }  // namespace