Update mojo sdk to rev e01f9a49449381a5eb430c1fd88bf2cae73ec35a

Includes updates to ipc/mojo/ipc_channel_mojo.cc for mojo::embedder API
changes and updates to use mojo::Binding<> in ui/keyboard and
device/battery.

Review URL: https://codereview.chromium.org/728133002

Cr-Commit-Position: refs/heads/master@{#304731}

57 files changed, 1691 insertions, 2514 deletions

diff --git a/mojo/edk/system/BUILD.gn b/mojo/edk/system/BUILD.gn
index 791a192..d0bfda7 100644
--- a/mojo/edk/system/BUILD.gn
+++ b/mojo/edk/system/BUILD.gn
@@ -12,19 +12,6 @@ config("system_config") {
 component("system") {
   output_name = "mojo_system_impl"
 
-  deps = [
-    "//base",
-    "//base/third_party/dynamic_annotations",
-    "//mojo/edk/embedder",
-  ]
-
-  defines = [
-    "MOJO_SYSTEM_IMPL_IMPLEMENTATION",
-    "MOJO_SYSTEM_IMPLEMENTATION",
-  ]
-
-  all_dependent_configs = [ ":system_config" ]
-
   sources = [
     "channel.cc",
     "channel.h",
@@ -34,7 +21,10 @@ component("system") {
     "channel_endpoint_id.h",
     "channel_info.cc",
     "channel_info.h",
-    "constants.h",
+    "channel_manager.cc",
+    "channel_manager.h",
+    "configuration.cc",
+    "configuration.h",
     "core.cc",
     "core.h",
     "data_pipe.cc",
@@ -45,7 +35,6 @@ component("system") {
     "data_pipe_producer_dispatcher.h",
     "dispatcher.cc",
     "dispatcher.h",
-    "entrypoints.cc",
     "handle_signals_state.h",
     "handle_table.cc",
     "handle_table.h",
@@ -87,18 +76,30 @@ component("system") {
     "waiter_list.cc",
     "waiter_list.h",
   ]
-}
 
-# GYP version: mojo/edk/mojo_edk.gyp:mojo_system_unittests
-test("mojo_system_unittests") {
+  defines = [
+    "MOJO_SYSTEM_IMPL_IMPLEMENTATION",
+    "MOJO_SYSTEM_IMPLEMENTATION",
+  ]
+
+  all_dependent_configs = [ ":system_config" ]
+
+  public_deps = [
+    "//mojo/edk/embedder",
+    "//mojo/edk/embedder:platform",
+    "//mojo/public/c/system",
+  ]
+
   deps = [
-    ":system",
     "//base",
-    "//mojo/edk/embedder:embedder_unittests",
-    "//mojo/edk/test:test_support",
-    "//testing/gtest",
+    "//base/third_party/dynamic_annotations",
   ]
 
+  allow_circular_includes_from = [ "//mojo/edk/embedder" ]
+}
+
+# GYP version: mojo/edk/mojo_edk.gyp:mojo_system_unittests
+test("mojo_system_unittests") {
   sources = [
     "../test/multiprocess_test_helper_unittest.cc",
     "channel_endpoint_id_unittest.cc",
@@ -122,6 +123,7 @@ test("mojo_system_unittests") {
     "run_all_unittests.cc",
     "shared_buffer_dispatcher_unittest.cc",
     "simple_dispatcher_unittest.cc",
+    # TODO(vtl): Factor test_utils.* into their own source set.
     "test_utils.cc",
     "test_utils.h",
     "waiter_list_unittest.cc",
@@ -129,19 +131,21 @@ test("mojo_system_unittests") {
     "waiter_test_utils.h",
     "waiter_unittest.cc",
   ]
-}
 
-# GYP version: mojo/edk/mojo_edk.gyp:mojo_message_pipe_perftests
-test("mojo_message_pipe_perftests") {
   deps = [
     ":system",
     "//base",
     "//base/test:test_support",
-    "//base/test:test_support_perf",
+    "//mojo/edk/embedder:embedder_unittests",
     "//mojo/edk/test:test_support",
     "//testing/gtest",
   ]
 
+  allow_circular_includes_from = [ "//mojo/edk/embedder:embedder_unittests" ]
+}
+
+# GYP version: mojo/edk/mojo_edk.gyp:mojo_message_pipe_perftests
+test("mojo_message_pipe_perftests") {
   sources = [
     "message_pipe_perftest.cc",
     "message_pipe_test_utils.h",
@@ -149,4 +153,13 @@ test("mojo_message_pipe_perftests") {
     "test_utils.cc",
     "test_utils.h",
   ]
+
+  deps = [
+    ":system",
+    "//base",
+    "//base/test:test_support",
+    "//base/test:test_support_perf",
+    "//mojo/edk/test:test_support",
+    "//testing/gtest",
+  ]
 }
diff --git a/mojo/edk/system/channel.cc b/mojo/edk/system/channel.cc
index b63aaeb..2f2a2ab 100644
--- a/mojo/edk/system/channel.cc
+++ b/mojo/edk/system/channel.cc
@@ -20,7 +20,8 @@ namespace system {
 Channel::Channel(embedder::PlatformSupport* platform_support)
     : platform_support_(platform_support),
       is_running_(false),
-      is_shutting_down_(false) {
+      is_shutting_down_(false),
+      channel_manager_(nullptr) {
 }
 
 bool Channel::Init(scoped_ptr<RawChannel> raw_channel) {
@@ -41,6 +42,15 @@ bool Channel::Init(scoped_ptr<RawChannel> raw_channel) {
   return true;
 }
 
+void Channel::SetChannelManager(ChannelManager* channel_manager) {
+  DCHECK(channel_manager);
+
+  base::AutoLock locker(lock_);
+  DCHECK(!is_shutting_down_);
+  DCHECK(!channel_manager_);
+  channel_manager_ = channel_manager;
+}
+
 void Channel::Shutdown() {
   DCHECK(creation_thread_checker_.CalledOnValidThread());
 
@@ -62,8 +72,7 @@ void Channel::Shutdown() {
   size_t num_live = 0;
   size_t num_zombies = 0;
   for (IdToEndpointMap::iterator it = to_destroy.begin();
-       it != to_destroy.end();
-       ++it) {
+       it != to_destroy.end(); ++it) {
     if (it->second.get()) {
       num_live++;
       it->second->OnDisconnect();
@@ -80,6 +89,7 @@ void Channel::Shutdown() {
 void Channel::WillShutdownSoon() {
   base::AutoLock locker(lock_);
   is_shutting_down_ = true;
+  channel_manager_ = nullptr;
 }
 
 // Note: |endpoint| being a |scoped_refptr| makes this function safe, since it
@@ -120,8 +130,7 @@ ChannelEndpointId Channel::AttachAndRunEndpoint(
 
   if (!is_bootstrap) {
     if (!SendControlMessage(
-            MessageInTransit::kSubtypeChannelAttachAndRunEndpoint,
-            local_id,
+            MessageInTransit::kSubtypeChannelAttachAndRunEndpoint, local_id,
             remote_id)) {
       HandleLocalError(base::StringPrintf(
           "Failed to send message to run remote message pipe endpoint (local "
@@ -185,8 +194,7 @@ void Channel::DetachEndpoint(ChannelEndpoint* endpoint,
   }
 
   if (!SendControlMessage(
-          MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint,
-          local_id,
+          MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpoint, local_id,
           remote_id)) {
     HandleLocalError(base::StringPrintf(
         "Failed to send message to remove remote message pipe endpoint (local "
@@ -207,7 +215,7 @@ scoped_refptr<MessagePipe> Channel::PassIncomingMessagePipe(
 
   auto it = incoming_message_pipes_.find(local_id);
   if (it == incoming_message_pipes_.end())
-    return scoped_refptr<MessagePipe>();
+    return nullptr;
 
   scoped_refptr<MessagePipe> rv;
   rv.swap(it->second);
@@ -459,8 +467,7 @@ bool Channel::OnRemoveMessagePipeEndpoint(ChannelEndpointId local_id,
 
   if (!SendControlMessage(
           MessageInTransit::kSubtypeChannelRemoveMessagePipeEndpointAck,
-          local_id,
-          remote_id)) {
+          local_id, remote_id)) {
     HandleLocalError(base::StringPrintf(
         "Failed to send message to remove remote message pipe endpoint ack "
         "(local ID %u, remote ID %u)",
diff --git a/mojo/edk/system/channel.h b/mojo/edk/system/channel.h
index 6697965..715d1f2 100644
--- a/mojo/edk/system/channel.h
+++ b/mojo/edk/system/channel.h
@@ -32,6 +32,7 @@ class PlatformSupport;
 namespace system {
 
 class ChannelEndpoint;
+class ChannelManager;
 
 // This class is mostly thread-safe. It must be created on an I/O thread.
 // |Init()| must be called on that same thread before it becomes thread-safe (in
@@ -61,6 +62,11 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel
   // failure, no other methods should be called (including |Shutdown()|).
   bool Init(scoped_ptr<RawChannel> raw_channel);
 
+  // Sets the channel manager associated with this channel. This should be set
+  // at most once and only called before |WillShutdownSoon()| (and
+  // |Shutdown()|).
+  void SetChannelManager(ChannelManager* channel_manager);
+
   // This must be called on the creation thread before destruction (which can
   // happen on any thread).
   void Shutdown();
@@ -69,6 +75,8 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel
   // thread, unlike |Shutdown()|). Warnings will be issued if, e.g., messages
   // are written after this is called; other warnings may be suppressed. (This
   // may be called multiple times, or not at all.)
+  //
+  // If set, the channel manager associated with this channel will be reset.
   void WillShutdownSoon();
 
   // Attaches the given endpoint to this channel and runs it. |is_bootstrap|
@@ -175,6 +183,9 @@ class MOJO_SYSTEM_IMPL_EXPORT Channel
   // Set when |WillShutdownSoon()| is called.
   bool is_shutting_down_;
 
+  // Has a reference to us.
+  ChannelManager* channel_manager_;
+
   typedef base::hash_map<ChannelEndpointId, scoped_refptr<ChannelEndpoint>>
       IdToEndpointMap;
   // Map from local IDs to endpoints. If the endpoint is null, this means that
diff --git a/mojo/edk/system/channel_endpoint.cc b/mojo/edk/system/channel_endpoint.cc
index 8b64643..dd7cd5b 100644
--- a/mojo/edk/system/channel_endpoint.cc
+++ b/mojo/edk/system/channel_endpoint.cc
@@ -109,8 +109,7 @@ bool ChannelEndpoint::OnReadMessage(
       DCHECK(message_view.transport_data_buffer());
       message->SetDispatchers(TransportData::DeserializeDispatchers(
           message_view.transport_data_buffer(),
-          message_view.transport_data_buffer_size(),
-          platform_handles.Pass(),
+          message_view.transport_data_buffer_size(), platform_handles.Pass(),
           channel_));
     }
 
diff --git a/mojo/edk/system/channel_endpoint.h b/mojo/edk/system/channel_endpoint.h
index 377599d..3c415ea 100644
--- a/mojo/edk/system/channel_endpoint.h
+++ b/mojo/edk/system/channel_endpoint.h
@@ -26,13 +26,13 @@ class MessagePipe;
 //     refcounted, and not copyable. Make |Channel| a friend. Make things work.
 //   - (Done.) Give |ChannelEndpoint| a lock. The lock order (in order of
 //     allowable acquisition) is: |MessagePipe|, |ChannelEndpoint|, |Channel|.
-//   - Stop having |Channel| as a friend.
-//   - Move logic from |ProxyMessagePipeEndpoint| into |ChannelEndpoint|. Right
-//     now, we have to go through lots of contortions to manipulate state owned
-//     by |ProxyMessagePipeEndpoint| (in particular, |Channel::Endpoint| doesn't
-//     know about the remote ID; the local ID is duplicated in two places).
-//     Hollow out |ProxyMessagePipeEndpoint|, and have it just own a reference
-//     to |ChannelEndpoint| (hence the refcounting).
+//   - (Done) Stop having |Channel| as a friend.
+//   - (Done) Move logic from |ProxyMessagePipeEndpoint| into |ChannelEndpoint|.
+//     Right now, we have to go through lots of contortions to manipulate state
+//     owned by |ProxyMessagePipeEndpoint| (in particular, |Channel::Endpoint|
+//     doesn't know about the remote ID; the local ID is duplicated in two
+//     places). Hollow out |ProxyMessagePipeEndpoint|, and have it just own a
+//     reference to |ChannelEndpoint| (hence the refcounting).
 //   - In essence, |ChannelEndpoint| becomes the thing that knows about
 //     channel-specific aspects of an endpoint (notably local and remote IDs,
 //     and knowledge about handshaking), and mediates between the |Channel| and
diff --git a/mojo/edk/system/channel_info.cc b/mojo/edk/system/channel_info.cc
index efc5f04..6d23215 100644
--- a/mojo/edk/system/channel_info.cc
+++ b/mojo/edk/system/channel_info.cc
@@ -4,6 +4,8 @@
 
 #include "mojo/edk/system/channel_info.h"
 
+#include <algorithm>
+
 namespace mojo {
 namespace system {
 
@@ -19,5 +21,11 @@ ChannelInfo::ChannelInfo(
 ChannelInfo::~ChannelInfo() {
 }
 
+void ChannelInfo::Swap(ChannelInfo* other) {
+  // Note: Swapping avoids refcount churn.
+  std::swap(channel, other->channel);
+  std::swap(channel_thread_task_runner, other->channel_thread_task_runner);
+}
+
 }  // namespace system
 }  // namespace mojo
diff --git a/mojo/edk/system/channel_info.h b/mojo/edk/system/channel_info.h
index bd84e16..5167cca 100644
--- a/mojo/edk/system/channel_info.h
+++ b/mojo/edk/system/channel_info.h
@@ -19,6 +19,8 @@ struct MOJO_SYSTEM_IMPL_EXPORT ChannelInfo {
               scoped_refptr<base::TaskRunner> channel_thread_task_runner);
   ~ChannelInfo();
 
+  void Swap(ChannelInfo* other);
+
   scoped_refptr<Channel> channel;
   // The task runner for |channel|'s creation thread (a.k.a. its I/O thread), on
   // which it must, e.g., be shut down.
diff --git a/mojo/edk/system/channel_manager.cc b/mojo/edk/system/channel_manager.cc
new file mode 100644
index 0000000..4e58f89
--- /dev/null
+++ b/mojo/edk/system/channel_manager.cc
@@ -0,0 +1,78 @@
+// Copyright 2014 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 "mojo/edk/system/channel_manager.h"
+
+#include "base/bind.h"
+#include "base/location.h"
+#include "base/message_loop/message_loop_proxy.h"
+
+namespace mojo {
+namespace system {
+
+namespace {
+
+void ShutdownChannelHelper(const ChannelInfo& channel_info) {
+  if (base::MessageLoopProxy::current() ==
+      channel_info.channel_thread_task_runner) {
+    channel_info.channel->Shutdown();
+  } else {
+    channel_info.channel->WillShutdownSoon();
+    channel_info.channel_thread_task_runner->PostTask(
+        FROM_HERE, base::Bind(&Channel::Shutdown, channel_info.channel));
+  }
+}
+
+}  // namespace
+
+ChannelManager::ChannelManager() {
+}
+
+ChannelManager::~ChannelManager() {
+  // No need to take the lock.
+  for (const auto& map_elem : channel_infos_)
+    ShutdownChannelHelper(map_elem.second);
+}
+
+ChannelId ChannelManager::AddChannel(
+    scoped_refptr<Channel> channel,
+    scoped_refptr<base::TaskRunner> channel_thread_task_runner) {
+  ChannelId channel_id = GetChannelId(channel.get());
+
+  {
+    base::AutoLock locker(lock_);
+    DCHECK(channel_infos_.find(channel_id) == channel_infos_.end());
+    channel_infos_[channel_id] =
+        ChannelInfo(channel, channel_thread_task_runner);
+  }
+  channel->SetChannelManager(this);
+
+  return channel_id;
+}
+
+void ChannelManager::WillShutdownChannel(ChannelId channel_id) {
+  GetChannelInfo(channel_id).channel->WillShutdownSoon();
+}
+
+void ChannelManager::ShutdownChannel(ChannelId channel_id) {
+  ChannelInfo channel_info;
+  {
+    base::AutoLock locker(lock_);
+    auto it = channel_infos_.find(channel_id);
+    DCHECK(it != channel_infos_.end());
+    channel_info.Swap(&it->second);
+    channel_infos_.erase(it);
+  }
+  ShutdownChannelHelper(channel_info);
+}
+
+ChannelInfo ChannelManager::GetChannelInfo(ChannelId channel_id) {
+  base::AutoLock locker(lock_);
+  auto it = channel_infos_.find(channel_id);
+  DCHECK(it != channel_infos_.end());
+  return it->second;
+}
+
+}  // namespace system
+}  // namespace mojo
diff --git a/mojo/edk/system/channel_manager.h b/mojo/edk/system/channel_manager.h
new file mode 100644
index 0000000..60a3048
--- /dev/null
+++ b/mojo/edk/system/channel_manager.h
@@ -0,0 +1,83 @@
+// Copyright 2014 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 MOJO_EDK_SYSTEM_CHANNEL_MANAGER_H_
+#define MOJO_EDK_SYSTEM_CHANNEL_MANAGER_H_
+
+#include <stdint.h>
+
+#include "base/containers/hash_tables.h"
+#include "base/macros.h"
+#include "base/memory/ref_counted.h"
+#include "base/synchronization/lock.h"
+#include "base/task_runner.h"
+#include "mojo/edk/system/channel.h"
+#include "mojo/edk/system/channel_info.h"
+
+namespace mojo {
+namespace system {
+
+// IDs for |Channel|s managed by a |ChannelManager|. (IDs should be thought of
+// as specific to a given |ChannelManager|.) 0 is never a valid ID.
+//
+// Note: We currently just use the pointer of the |Channel| casted to a
+// |uintptr_t|, but we reserve the right to change this.
+typedef uintptr_t ChannelId;
+
+// This class manages and "owns" |Channel|s (which typically connect to other
+// processes) for a given process. This class is thread-safe.
+class MOJO_SYSTEM_IMPL_EXPORT ChannelManager {
+ public:
+  ChannelManager();
+  ~ChannelManager();
+
+  // Gets the ID for a given channel.
+  //
+  // Note: This is currently a static method and thus may be called under
+  // |lock_|. If this is ever made non-static (i.e., made specific to a given
+  // |ChannelManager|), those call sites may have to changed.
+  static ChannelId GetChannelId(const Channel* channel) {
+    return reinterpret_cast<ChannelId>(channel);
+  }
+
+  // Adds |channel| to the set of |Channel|s managed by this |ChannelManager|;
+  // |channel_thread_task_runner| should be the task runner for |channel|'s
+  // creation (a.k.a. I/O) thread. |channel| should either already be
+  // initialized. It should not be managed by any |ChannelManager| yet. Returns
+  // the ID for the added channel.
+  ChannelId AddChannel(
+      scoped_refptr<Channel> channel,
+      scoped_refptr<base::TaskRunner> channel_thread_task_runner);
+
+  // Informs the channel manager (and thus channel) that it will be shutdown
+  // soon (by calling |ShutdownChannel()|). Calling this is optional (and may in
+  // fact be called multiple times) but it will suppress certain warnings (e.g.,
+  // for the channel being broken) and enable others (if messages are written to
+  // the channel).
+  void WillShutdownChannel(ChannelId channel_id);
+
+  // Shuts down the channel specified by the given ID. It is up to the caller to
+  // guarantee that this is only called once per channel (that was added using
+  // |AddChannel()|). If called from the chanel's creation thread (i.e.,
+  // |base::MessageLoopProxy::current()| is the channel thread's |TaskRunner|),
+  // this will complete synchronously.
+  void ShutdownChannel(ChannelId channel_id);
+
+ private:
+  // Gets the |ChannelInfo| for the channel specified by the given ID. (This
+  // should *not* be called under lock.)
+  ChannelInfo GetChannelInfo(ChannelId channel_id);
+
+  // Note: |Channel| methods should not be called under |lock_|.
+  base::Lock lock_;  // Protects the members below.
+
+  base::hash_map<ChannelId, ChannelInfo> channel_infos_;
+
+  DISALLOW_COPY_AND_ASSIGN(ChannelManager);
+};
+
+}  // namespace system
+}  // namespace mojo
+
+#endif  // MOJO_EDK_SYSTEM_CHANNEL_MANAGER_H_
diff --git a/mojo/edk/system/channel_unittest.cc b/mojo/edk/system/channel_unittest.cc
index f6cf896..68b1315 100644
--- a/mojo/edk/system/channel_unittest.cc
+++ b/mojo/edk/system/channel_unittest.cc
@@ -104,9 +104,8 @@ TEST_F(ChannelTest, InitShutdown) {
   EXPECT_EQ(TRISTATE_TRUE, init_result());
 
   io_thread()->PostTaskAndWait(
-      FROM_HERE,
-      base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
-                 base::Unretained(this)));
+      FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
+                            base::Unretained(this)));
 
   // Okay to destroy |Channel| on not-the-I/O-thread.
   EXPECT_TRUE(channel()->HasOneRef());
@@ -203,9 +202,8 @@ TEST_F(ChannelTest, CloseBeforeRun) {
   channel()->AttachAndRunEndpoint(channel_endpoint, true);
 
   io_thread()->PostTaskAndWait(
-      FROM_HERE,
-      base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
-                 base::Unretained(this)));
+      FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
+                            base::Unretained(this)));
 
   EXPECT_TRUE(channel()->HasOneRef());
 }
@@ -273,9 +271,8 @@ TEST_F(ChannelTest, WaitAfterAttachRunAndShutdown) {
   channel()->AttachAndRunEndpoint(channel_endpoint, true);
 
   io_thread()->PostTaskAndWait(
-      FROM_HERE,
-      base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
-                 base::Unretained(this)));
+      FROM_HERE, base::Bind(&ChannelTest::ShutdownChannelOnIOThread,
+                            base::Unretained(this)));
 
   Waiter waiter;
   waiter.Init();
diff --git a/mojo/edk/system/configuration.cc b/mojo/edk/system/configuration.cc
new file mode 100644
index 0000000..4756c99
--- /dev/null
+++ b/mojo/edk/system/configuration.cc
@@ -0,0 +1,26 @@
+// Copyright 2014 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 "mojo/edk/system/configuration.h"
+
+namespace mojo {
+namespace system {
+namespace internal {
+
+// These default values should be synced with the documentation in
+// mojo/edk/embedder/configuration.h.
+embedder::Configuration g_configuration = {
+    1000000,              // max_handle_table_size
+    1000000,              // max_mapping_table_sze
+    1000000,              // max_wait_many_num_handles
+    4 * 1024 * 1024,      // max_message_num_bytes
+    10000,                // max_message_num_handles
+    256 * 1024 * 1024,    // max_data_pipe_capacity_bytes
+    1024 * 1024,          // default_data_pipe_capacity_bytes
+    16,                   // data_pipe_buffer_alignment_bytes
+    1024 * 1024 * 1024};  // max_shared_memory_num_bytes
+
+}  // namespace internal
+}  // namespace system
+}  // namespace mojo
diff --git a/mojo/edk/system/configuration.h b/mojo/edk/system/configuration.h
new file mode 100644
index 0000000..007277a
--- /dev/null
+++ b/mojo/edk/system/configuration.h
@@ -0,0 +1,31 @@
+// Copyright 2014 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 MOJO_EDK_SYSTEM_CONFIGURATION_H_
+#define MOJO_EDK_SYSTEM_CONFIGURATION_H_
+
+#include "mojo/edk/embedder/configuration.h"
+#include "mojo/edk/system/system_impl_export.h"
+
+namespace mojo {
+namespace system {
+
+namespace internal {
+MOJO_SYSTEM_IMPL_EXPORT extern embedder::Configuration g_configuration;
+}  // namespace internal
+
+MOJO_SYSTEM_IMPL_EXPORT inline const embedder::Configuration&
+GetConfiguration() {
+  return internal::g_configuration;
+}
+
+MOJO_SYSTEM_IMPL_EXPORT inline embedder::Configuration*
+GetMutableConfiguration() {
+  return &internal::g_configuration;
+}
+
+}  // namespace system
+}  // namespace mojo
+
+#endif  // MOJO_EDK_SYSTEM_CONFIGURATION_H_
diff --git a/mojo/edk/system/constants.h b/mojo/edk/system/constants.h
deleted file mode 100644
index 23f35d8..0000000
--- a/mojo/edk/system/constants.h
+++ /dev/null
@@ -1,48 +0,0 @@
-// Copyright 2013 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 MOJO_EDK_SYSTEM_CONSTANTS_H_
-#define MOJO_EDK_SYSTEM_CONSTANTS_H_
-
-#include <stddef.h>
-
-namespace mojo {
-namespace system {
-
-// Maximum number of open (Mojo) handles.
-// TODO(vtl): This doesn't count "live" handles, some of which may live in
-// messages.
-const size_t kMaxHandleTableSize = 1000000;
-
-// Maximum number of active memory mappings.
-const size_t kMaxMappingTableSize = 1000000;
-
-const size_t kMaxWaitManyNumHandles = kMaxHandleTableSize;
-
-const size_t kMaxMessageNumBytes = 4 * 1024 * 1024;
-
-const size_t kMaxMessageNumHandles = 10000;
-
-// Maximum capacity of a data pipe, in bytes. This value must fit into a
-// |uint32_t|.
-// WARNING: If you bump it closer to 2^32, you must audit all the code to check
-// that we don't overflow (2^31 would definitely be risky; up to 2^30 is
-// probably okay).
-const size_t kMaxDataPipeCapacityBytes = 256 * 1024 * 1024;  // 256 MB.
-
-const size_t kDefaultDataPipeCapacityBytes = 1024 * 1024;  // 1 MB.
-
-// Alignment for the "start" of the data buffer used by data pipes. (The
-// alignment of elements will depend on this and the element size.)
-const size_t kDataPipeBufferAlignmentBytes = 16;
-
-// TODO(vtl): Set this hard limit appropriately (e.g., higher on 64-bit). (This
-// will also entail some auditing to make sure I'm not messing up my checks
-// anywhere.)
-const size_t kMaxSharedMemoryNumBytes = 1024 * 1024 * 1024;  // 1 GB.
-
-}  // namespace system
-}  // namespace mojo
-
-#endif  // MOJO_EDK_SYSTEM_CONSTANTS_H_
diff --git a/mojo/edk/system/core.cc b/mojo/edk/system/core.cc
index c67a626..27d33b2 100644
--- a/mojo/edk/system/core.cc
+++ b/mojo/edk/system/core.cc
@@ -10,7 +10,7 @@
 #include "base/time/time.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
 #include "mojo/edk/embedder/platform_support.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/data_pipe.h"
 #include "mojo/edk/system/data_pipe_consumer_dispatcher.h"
 #include "mojo/edk/system/data_pipe_producer_dispatcher.h"
@@ -126,11 +126,7 @@ MojoResult Core::Wait(MojoHandle handle,
                       UserPointer<MojoHandleSignalsState> signals_state) {
   uint32_t unused = static_cast<uint32_t>(-1);
   HandleSignalsState hss;
-  MojoResult rv = WaitManyInternal(&handle,
-                                   &signals,
-                                   1,
-                                   deadline,
-                                   &unused,
+  MojoResult rv = WaitManyInternal(&handle, &signals, 1, deadline, &unused,
                                    signals_state.IsNull() ? nullptr : &hss);
   if (rv != MOJO_RESULT_INVALID_ARGUMENT && !signals_state.IsNull())
     signals_state.Put(hss);
@@ -145,7 +141,7 @@ MojoResult Core::WaitMany(UserPointer<const MojoHandle> handles,
                           UserPointer<MojoHandleSignalsState> signals_states) {
   if (num_handles < 1)
     return MOJO_RESULT_INVALID_ARGUMENT;
-  if (num_handles > kMaxWaitManyNumHandles)
+  if (num_handles > GetConfiguration().max_wait_many_num_handles)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   UserPointer<const MojoHandle>::Reader handles_reader(handles, num_handles);
@@ -155,23 +151,17 @@ MojoResult Core::WaitMany(UserPointer<const MojoHandle> handles,
   MojoResult rv;
   if (signals_states.IsNull()) {
     rv = WaitManyInternal(handles_reader.GetPointer(),
-                          signals_reader.GetPointer(),
-                          num_handles,
-                          deadline,
-                          &index,
-                          nullptr);
+                          signals_reader.GetPointer(), num_handles, deadline,
+                          &index, nullptr);
   } else {
     UserPointer<MojoHandleSignalsState>::Writer signals_states_writer(
         signals_states, num_handles);
     // Note: The |reinterpret_cast| is safe, since |HandleSignalsState| is a
     // subclass of |MojoHandleSignalsState| that doesn't add any data members.
     rv = WaitManyInternal(handles_reader.GetPointer(),
-                          signals_reader.GetPointer(),
-                          num_handles,
-                          deadline,
-                          &index,
-                          reinterpret_cast<HandleSignalsState*>(
-                              signals_states_writer.GetPointer()));
+                          signals_reader.GetPointer(), num_handles, deadline,
+                          &index, reinterpret_cast<HandleSignalsState*>(
+                                      signals_states_writer.GetPointer()));
     if (rv != MOJO_RESULT_INVALID_ARGUMENT)
       signals_states_writer.Commit();
   }
@@ -246,7 +236,7 @@ MojoResult Core::WriteMessage(MojoHandle message_pipe_handle,
   // validity, even for dispatchers that don't support |WriteMessage()| and will
   // simply return failure unconditionally. It also breaks the usual
   // left-to-right verification order of arguments.)
-  if (num_handles > kMaxMessageNumHandles)
+  if (num_handles > GetConfiguration().max_message_num_handles)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   UserPointer<const MojoHandle>::Reader handles_reader(handles, num_handles);
@@ -263,11 +253,9 @@ MojoResult Core::WriteMessage(MojoHandle message_pipe_handle,
   // handles from the handle table.
   {
     base::AutoLock locker(handle_table_lock_);
-    MojoResult result =
-        handle_table_.MarkBusyAndStartTransport(message_pipe_handle,
-                                                handles_reader.GetPointer(),
-                                                num_handles,
-                                                &transports);
+    MojoResult result = handle_table_.MarkBusyAndStartTransport(
+        message_pipe_handle, handles_reader.GetPointer(), num_handles,
+        &transports);
     if (result != MOJO_RESULT_OK)
       return result;
   }
@@ -308,12 +296,12 @@ MojoResult Core::ReadMessage(MojoHandle message_pipe_handle,
   MojoResult rv;
   if (num_handles_value == 0) {
     // Easy case: won't receive any handles.
-    rv = dispatcher->ReadMessage(
-        bytes, num_bytes, nullptr, &num_handles_value, flags);
+    rv = dispatcher->ReadMessage(bytes, num_bytes, nullptr, &num_handles_value,
+                                 flags);
   } else {
     DispatcherVector dispatchers;
-    rv = dispatcher->ReadMessage(
-        bytes, num_bytes, &dispatchers, &num_handles_value, flags);
+    rv = dispatcher->ReadMessage(bytes, num_bytes, &dispatchers,
+                                 &num_handles_value, flags);
     if (!dispatchers.empty()) {
       DCHECK_EQ(rv, MOJO_RESULT_OK);
       DCHECK(!num_handles.IsNull());
@@ -466,8 +454,8 @@ MojoResult Core::CreateSharedBuffer(
     return result;
 
   scoped_refptr<SharedBufferDispatcher> dispatcher;
-  result = SharedBufferDispatcher::Create(
-      platform_support(), validated_options, num_bytes, &dispatcher);
+  result = SharedBufferDispatcher::Create(platform_support(), validated_options,
+                                          num_bytes, &dispatcher);
   if (result != MOJO_RESULT_OK) {
     DCHECK(!dispatcher.get());
     return result;
diff --git a/mojo/edk/system/core_test_base.cc b/mojo/edk/system/core_test_base.cc
index d1a1a24..ea06c29 100644
--- a/mojo/edk/system/core_test_base.cc
+++ b/mojo/edk/system/core_test_base.cc
@@ -10,7 +10,7 @@
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "mojo/edk/embedder/simple_platform_support.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/core.h"
 #include "mojo/edk/system/dispatcher.h"
 #include "mojo/edk/system/memory.h"
@@ -50,7 +50,7 @@ class MockDispatcher : public Dispatcher {
     info_->IncrementWriteMessageCallCount();
     lock().AssertAcquired();
 
-    if (num_bytes > kMaxMessageNumBytes)
+    if (num_bytes > GetConfiguration().max_message_num_bytes)
       return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
     if (transports)
diff --git a/mojo/edk/system/core_unittest.cc b/mojo/edk/system/core_unittest.cc
index e6607df..96780f7 100644
--- a/mojo/edk/system/core_unittest.cc
+++ b/mojo/edk/system/core_unittest.cc
@@ -42,45 +42,34 @@ TEST_F(CoreTest, Basic) {
 
   EXPECT_EQ(0u, info.GetWriteMessageCallCount());
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h,
-                                 NullUserPointer(),
-                                 0,
-                                 NullUserPointer(),
-                                 0,
+            core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 
   EXPECT_EQ(0u, info.GetReadMessageCallCount());
   uint32_t num_bytes = 0;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h,
-                                NullUserPointer(),
-                                MakeUserPointer(&num_bytes),
-                                NullUserPointer(),
-                                NullUserPointer(),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      core()->ReadMessage(h, NullUserPointer(), MakeUserPointer(&num_bytes),
+                          NullUserPointer(), NullUserPointer(),
+                          MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(1u, info.GetReadMessageCallCount());
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h,
-                                NullUserPointer(),
-                                NullUserPointer(),
-                                NullUserPointer(),
-                                NullUserPointer(),
+            core()->ReadMessage(h, NullUserPointer(), NullUserPointer(),
+                                NullUserPointer(), NullUserPointer(),
                                 MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(2u, info.GetReadMessageCallCount());
 
   EXPECT_EQ(0u, info.GetWriteDataCallCount());
-  EXPECT_EQ(
-      MOJO_RESULT_UNIMPLEMENTED,
-      core()->WriteData(
-          h, NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
+            core()->WriteData(h, NullUserPointer(), NullUserPointer(),
+                              MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(1u, info.GetWriteDataCallCount());
 
   EXPECT_EQ(0u, info.GetBeginWriteDataCallCount());
-  EXPECT_EQ(
-      MOJO_RESULT_UNIMPLEMENTED,
-      core()->BeginWriteData(
-          h, NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
+            core()->BeginWriteData(h, NullUserPointer(), NullUserPointer(),
+                                   MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(1u, info.GetBeginWriteDataCallCount());
 
   EXPECT_EQ(0u, info.GetEndWriteDataCallCount());
@@ -88,17 +77,15 @@ TEST_F(CoreTest, Basic) {
   EXPECT_EQ(1u, info.GetEndWriteDataCallCount());
 
   EXPECT_EQ(0u, info.GetReadDataCallCount());
-  EXPECT_EQ(
-      MOJO_RESULT_UNIMPLEMENTED,
-      core()->ReadData(
-          h, NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
+            core()->ReadData(h, NullUserPointer(), NullUserPointer(),
+                             MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(1u, info.GetReadDataCallCount());
 
   EXPECT_EQ(0u, info.GetBeginReadDataCallCount());
-  EXPECT_EQ(
-      MOJO_RESULT_UNIMPLEMENTED,
-      core()->BeginReadData(
-          h, NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
+            core()->BeginReadData(h, NullUserPointer(), NullUserPointer(),
+                                  MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(1u, info.GetBeginReadDataCallCount());
 
   EXPECT_EQ(0u, info.GetEndReadDataCallCount());
@@ -107,9 +94,7 @@ TEST_F(CoreTest, Basic) {
 
   EXPECT_EQ(0u, info.GetAddWaiterCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h,
-                         ~MOJO_HANDLE_SIGNAL_NONE,
-                         MOJO_DEADLINE_INDEFINITE,
+            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
                          NullUserPointer()));
   EXPECT_EQ(1u, info.GetAddWaiterCallCount());
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
@@ -117,9 +102,7 @@ TEST_F(CoreTest, Basic) {
   EXPECT_EQ(2u, info.GetAddWaiterCallCount());
   MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h,
-                         ~MOJO_HANDLE_SIGNAL_NONE,
-                         MOJO_DEADLINE_INDEFINITE,
+            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, MOJO_DEADLINE_INDEFINITE,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(3u, info.GetAddWaiterCallCount());
   EXPECT_EQ(0u, hss.satisfied_signals);
@@ -130,51 +113,43 @@ TEST_F(CoreTest, Basic) {
   EXPECT_EQ(4u, info.GetAddWaiterCallCount());
   hss = kFullMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(
-                h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000, MakeUserPointer(&hss)));
+            core()->Wait(h, ~MOJO_HANDLE_SIGNAL_NONE, 10 * 1000,
+                         MakeUserPointer(&hss)));
   EXPECT_EQ(5u, info.GetAddWaiterCallCount());
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
 
   MojoHandleSignals handle_signals = ~MOJO_HANDLE_SIGNAL_NONE;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->WaitMany(MakeUserPointer(&h),
-                             MakeUserPointer(&handle_signals),
-                             1,
-                             MOJO_DEADLINE_INDEFINITE,
-                             NullUserPointer(),
-                             NullUserPointer()));
+  EXPECT_EQ(
+      MOJO_RESULT_FAILED_PRECONDITION,
+      core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
+                       MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                       NullUserPointer()));
   EXPECT_EQ(6u, info.GetAddWaiterCallCount());
   uint32_t result_index = static_cast<uint32_t>(-1);
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->WaitMany(MakeUserPointer(&h),
-                             MakeUserPointer(&handle_signals),
-                             1,
-                             MOJO_DEADLINE_INDEFINITE,
-                             MakeUserPointer(&result_index),
-                             NullUserPointer()));
+  EXPECT_EQ(
+      MOJO_RESULT_FAILED_PRECONDITION,
+      core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
+                       MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+                       NullUserPointer()));
   EXPECT_EQ(7u, info.GetAddWaiterCallCount());
   EXPECT_EQ(0u, result_index);
   hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->WaitMany(MakeUserPointer(&h),
-                             MakeUserPointer(&handle_signals),
-                             1,
-                             MOJO_DEADLINE_INDEFINITE,
-                             NullUserPointer(),
-                             MakeUserPointer(&hss)));
+  EXPECT_EQ(
+      MOJO_RESULT_FAILED_PRECONDITION,
+      core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
+                       MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                       MakeUserPointer(&hss)));
   EXPECT_EQ(8u, info.GetAddWaiterCallCount());
   EXPECT_EQ(0u, hss.satisfied_signals);
   EXPECT_EQ(0u, hss.satisfiable_signals);
   result_index = static_cast<uint32_t>(-1);
   hss = kFullMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->WaitMany(MakeUserPointer(&h),
-                             MakeUserPointer(&handle_signals),
-                             1,
-                             MOJO_DEADLINE_INDEFINITE,
-                             MakeUserPointer(&result_index),
-                             MakeUserPointer(&hss)));
+  EXPECT_EQ(
+      MOJO_RESULT_FAILED_PRECONDITION,
+      core()->WaitMany(MakeUserPointer(&h), MakeUserPointer(&handle_signals), 1,
+                       MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+                       MakeUserPointer(&hss)));
   EXPECT_EQ(9u, info.GetAddWaiterCallCount());
   EXPECT_EQ(0u, result_index);
   EXPECT_EQ(0u, hss.satisfied_signals);
@@ -211,22 +186,16 @@ TEST_F(CoreTest, InvalidArguments) {
   // |Wait()|:
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(MOJO_HANDLE_INVALID,
-                           ~MOJO_HANDLE_SIGNAL_NONE,
-                           MOJO_DEADLINE_INDEFINITE,
-                           NullUserPointer()));
+              core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(10,
-                           ~MOJO_HANDLE_SIGNAL_NONE,
-                           MOJO_DEADLINE_INDEFINITE,
-                           NullUserPointer()));
+              core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_DEADLINE_INDEFINITE, NullUserPointer()));
 
     MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(MOJO_HANDLE_INVALID,
-                           ~MOJO_HANDLE_SIGNAL_NONE,
-                           MOJO_DEADLINE_INDEFINITE,
-                           MakeUserPointer(&hss)));
+              core()->Wait(MOJO_HANDLE_INVALID, ~MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss)));
     // On invalid argument, it shouldn't modify the handle signals state.
     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
               hss.satisfied_signals);
@@ -234,10 +203,8 @@ TEST_F(CoreTest, InvalidArguments) {
               hss.satisfiable_signals);
     hss = kFullMojoHandleSignalsState;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->Wait(10,
-                           ~MOJO_HANDLE_SIGNAL_NONE,
-                           MOJO_DEADLINE_INDEFINITE,
-                           MakeUserPointer(&hss)));
+              core()->Wait(10, ~MOJO_HANDLE_SIGNAL_NONE,
+                           MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&hss)));
     // On invalid argument, it shouldn't modify the handle signals state.
     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
               hss.satisfied_signals);
@@ -250,19 +217,14 @@ TEST_F(CoreTest, InvalidArguments) {
     MojoHandle handles[2] = {MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID};
     MojoHandleSignals signals[2] = {~MOJO_HANDLE_SIGNAL_NONE,
                                     ~MOJO_HANDLE_SIGNAL_NONE};
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 0,
+                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                         NullUserPointer()));
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(MakeUserPointer(handles),
-                               MakeUserPointer(signals),
-                               0,
-                               MOJO_DEADLINE_INDEFINITE,
-                               NullUserPointer(),
-                               NullUserPointer()));
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(NullUserPointer(),
-                               MakeUserPointer(signals),
-                               0,
-                               MOJO_DEADLINE_INDEFINITE,
-                               NullUserPointer(),
+              core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0,
+                               MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
                                NullUserPointer()));
     // If |num_handles| is invalid, it should leave |result_index| and
     // |signals_states| alone.
@@ -270,9 +232,7 @@ TEST_F(CoreTest, InvalidArguments) {
     uint32_t result_index = 123;
     MojoHandleSignalsState hss = kFullMojoHandleSignalsState;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(NullUserPointer(),
-                               MakeUserPointer(signals),
-                               0,
+              core()->WaitMany(NullUserPointer(), MakeUserPointer(signals), 0,
                                MOJO_DEADLINE_INDEFINITE,
                                MakeUserPointer(&result_index),
                                MakeUserPointer(&hss)));
@@ -283,30 +243,23 @@ TEST_F(CoreTest, InvalidArguments) {
               hss.satisfiable_signals);
 
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(MakeUserPointer(handles),
-                               NullUserPointer(),
-                               0,
-                               MOJO_DEADLINE_INDEFINITE,
-                               NullUserPointer(),
-                               NullUserPointer()));
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(MakeUserPointer(handles),
-                               MakeUserPointer(signals),
-                               1,
-                               MOJO_DEADLINE_INDEFINITE,
-                               NullUserPointer(),
+              core()->WaitMany(MakeUserPointer(handles), NullUserPointer(), 0,
+                               MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
                                NullUserPointer()));
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 1,
+                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                         NullUserPointer()));
     // But if a handle is bad, then it should set |result_index| but still leave
     // |signals_states| alone.
     result_index = static_cast<uint32_t>(-1);
     hss = kFullMojoHandleSignalsState;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(MakeUserPointer(handles),
-                               MakeUserPointer(signals),
-                               1,
-                               MOJO_DEADLINE_INDEFINITE,
-                               MakeUserPointer(&result_index),
-                               MakeUserPointer(&hss)));
+              core()->WaitMany(
+                  MakeUserPointer(handles), MakeUserPointer(signals), 1,
+                  MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+                  MakeUserPointer(&hss)));
     EXPECT_EQ(0u, result_index);
     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
               hss.satisfied_signals);
@@ -319,12 +272,10 @@ TEST_F(CoreTest, InvalidArguments) {
     result_index = static_cast<uint32_t>(-1);
     hss = kFullMojoHandleSignalsState;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              core()->WaitMany(MakeUserPointer(handles),
-                               MakeUserPointer(signals),
-                               1,
-                               MOJO_DEADLINE_INDEFINITE,
-                               MakeUserPointer(&result_index),
-                               MakeUserPointer(&hss)));
+              core()->WaitMany(
+                  MakeUserPointer(handles), MakeUserPointer(signals), 1,
+                  MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+                  MakeUserPointer(&hss)));
     EXPECT_EQ(0u, result_index);
     EXPECT_EQ(0u, hss.satisfied_signals);
     EXPECT_EQ(0u, hss.satisfiable_signals);
@@ -333,33 +284,27 @@ TEST_F(CoreTest, InvalidArguments) {
     result_index = static_cast<uint32_t>(-1);
     hss = kFullMojoHandleSignalsState;
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(MakeUserPointer(handles),
-                               MakeUserPointer(signals),
-                               2,
-                               MOJO_DEADLINE_INDEFINITE,
-                               MakeUserPointer(&result_index),
-                               MakeUserPointer(&hss)));
+              core()->WaitMany(
+                  MakeUserPointer(handles), MakeUserPointer(signals), 2,
+                  MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+                  MakeUserPointer(&hss)));
     EXPECT_EQ(1u, result_index);
     EXPECT_EQ(kFullMojoHandleSignalsState.satisfied_signals,
               hss.satisfied_signals);
     EXPECT_EQ(kFullMojoHandleSignalsState.satisfiable_signals,
               hss.satisfiable_signals);
     handles[1] = handles[0] + 1;  // Invalid handle.
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WaitMany(MakeUserPointer(handles),
-                               MakeUserPointer(signals),
-                               2,
-                               MOJO_DEADLINE_INDEFINITE,
-                               NullUserPointer(),
-                               NullUserPointer()));
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2,
+                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                         NullUserPointer()));
     handles[1] = CreateMockHandle(&info[1]);
-    EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              core()->WaitMany(MakeUserPointer(handles),
-                               MakeUserPointer(signals),
-                               2,
-                               MOJO_DEADLINE_INDEFINITE,
-                               NullUserPointer(),
-                               NullUserPointer()));
+    EXPECT_EQ(
+        MOJO_RESULT_FAILED_PRECONDITION,
+        core()->WaitMany(MakeUserPointer(handles), MakeUserPointer(signals), 2,
+                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                         NullUserPointer()));
 
     // TODO(vtl): Test one where we get "failed precondition" only for the
     // second handle (and the first one is valid to wait on).
@@ -376,11 +321,8 @@ TEST_F(CoreTest, InvalidArguments) {
   // |num_handles|.
   {
     EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WriteMessage(MOJO_HANDLE_INVALID,
-                                   NullUserPointer(),
-                                   0,
-                                   NullUserPointer(),
-                                   0,
+              core()->WriteMessage(MOJO_HANDLE_INVALID, NullUserPointer(), 0,
+                                   NullUserPointer(), 0,
                                    MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     MockHandleInfo info;
@@ -392,55 +334,41 @@ TEST_F(CoreTest, InvalidArguments) {
     // Note: This may return either |MOJO_RESULT_INVALID_ARGUMENT| or
     // |MOJO_RESULT_RESOURCE_EXHAUSTED|, depending on whether it's plausible or
     // not.
-    EXPECT_NE(MOJO_RESULT_OK,
-              core()->WriteMessage(h,
-                                   NullUserPointer(),
-                                   0,
-                                   MakeUserPointer(handles),
-                                   std::numeric_limits<uint32_t>::max(),
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_NE(
+        MOJO_RESULT_OK,
+        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+                             std::numeric_limits<uint32_t>::max(),
+                             MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 
     // Huge handle count (plausibly big).
     EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
               core()->WriteMessage(
-                  h,
-                  NullUserPointer(),
-                  0,
-                  MakeUserPointer(handles),
+                  h, NullUserPointer(), 0, MakeUserPointer(handles),
                   std::numeric_limits<uint32_t>::max() / sizeof(handles[0]),
                   MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 
     // Invalid handle in |handles|.
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WriteMessage(h,
-                                   NullUserPointer(),
-                                   0,
-                                   MakeUserPointer(handles),
-                                   1,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+                             1, MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 
     // Two invalid handles in |handles|.
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WriteMessage(h,
-                                   NullUserPointer(),
-                                   0,
-                                   MakeUserPointer(handles),
-                                   2,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+                             2, MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 
     // Can't send a handle over itself.
     handles[0] = h;
-    EXPECT_EQ(MOJO_RESULT_BUSY,
-              core()->WriteMessage(h,
-                                   NullUserPointer(),
-                                   0,
-                                   MakeUserPointer(handles),
-                                   1,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_BUSY,
+        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+                             1, MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(0u, info.GetWriteMessageCallCount());
 
     MockHandleInfo info2;
@@ -448,45 +376,33 @@ TEST_F(CoreTest, InvalidArguments) {
 
     // This is "okay", but |MockDispatcher| doesn't implement it.
     handles[0] = h2;
-    EXPECT_EQ(MOJO_RESULT_UNIMPLEMENTED,
-              core()->WriteMessage(h,
-                                   NullUserPointer(),
-                                   0,
-                                   MakeUserPointer(handles),
-                                   1,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_UNIMPLEMENTED,
+        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+                             1, MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 
     // One of the |handles| is still invalid.
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->WriteMessage(h,
-                                   NullUserPointer(),
-                                   0,
-                                   MakeUserPointer(handles),
-                                   2,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+                             2, MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 
     // One of the |handles| is the same as |handle|.
     handles[1] = h;
-    EXPECT_EQ(MOJO_RESULT_BUSY,
-              core()->WriteMessage(h,
-                                   NullUserPointer(),
-                                   0,
-                                   MakeUserPointer(handles),
-                                   2,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_BUSY,
+        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+                             2, MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 
     // Can't send a handle twice in the same message.
     handles[1] = h2;
-    EXPECT_EQ(MOJO_RESULT_BUSY,
-              core()->WriteMessage(h,
-                                   NullUserPointer(),
-                                   0,
-                                   MakeUserPointer(handles),
-                                   2,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_BUSY,
+        core()->WriteMessage(h, NullUserPointer(), 0, MakeUserPointer(handles),
+                             2, MOJO_WRITE_MESSAGE_FLAG_NONE));
     EXPECT_EQ(1u, info.GetWriteMessageCallCount());
 
     // Note: Since we never successfully sent anything with it, |h2| should
@@ -500,13 +416,11 @@ TEST_F(CoreTest, InvalidArguments) {
   // Only check arguments checked by |Core|, namely |handle|, |handles|, and
   // |num_handles|.
   {
-    EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-              core()->ReadMessage(MOJO_HANDLE_INVALID,
-                                  NullUserPointer(),
-                                  NullUserPointer(),
-                                  NullUserPointer(),
-                                  NullUserPointer(),
-                                  MOJO_READ_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_INVALID_ARGUMENT,
+        core()->ReadMessage(MOJO_HANDLE_INVALID, NullUserPointer(),
+                            NullUserPointer(), NullUserPointer(),
+                            NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
 
     MockHandleInfo info;
     MojoHandle h = CreateMockHandle(&info);
@@ -514,12 +428,9 @@ TEST_F(CoreTest, InvalidArguments) {
     // Okay.
     uint32_t handle_count = 0;
     EXPECT_EQ(MOJO_RESULT_OK,
-              core()->ReadMessage(h,
-                                  NullUserPointer(),
-                                  NullUserPointer(),
-                                  NullUserPointer(),
-                                  MakeUserPointer(&handle_count),
-                                  MOJO_READ_MESSAGE_FLAG_NONE));
+              core()->ReadMessage(
+                  h, NullUserPointer(), NullUserPointer(), NullUserPointer(),
+                  MakeUserPointer(&handle_count), MOJO_READ_MESSAGE_FLAG_NONE));
     // Checked by |Core|, shouldn't go through to the dispatcher.
     EXPECT_EQ(1u, info.GetReadMessageCallCount());
 
@@ -540,20 +451,16 @@ TEST_F(CoreTest, InvalidArgumentsDeath) {
   {
     MojoHandle handle = MOJO_HANDLE_INVALID;
     MojoHandleSignals signals = ~MOJO_HANDLE_SIGNAL_NONE;
-    EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(NullUserPointer(),
-                                               MakeUserPointer(&signals),
-                                               1,
-                                               MOJO_DEADLINE_INDEFINITE,
-                                               NullUserPointer(),
-                                               NullUserPointer()),
-                              kMemoryCheckFailedRegex);
-    EXPECT_DEATH_IF_SUPPORTED(core()->WaitMany(MakeUserPointer(&handle),
-                                               NullUserPointer(),
-                                               1,
-                                               MOJO_DEADLINE_INDEFINITE,
-                                               NullUserPointer(),
-                                               NullUserPointer()),
-                              kMemoryCheckFailedRegex);
+    EXPECT_DEATH_IF_SUPPORTED(
+        core()->WaitMany(NullUserPointer(), MakeUserPointer(&signals), 1,
+                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                         NullUserPointer()),
+        kMemoryCheckFailedRegex);
+    EXPECT_DEATH_IF_SUPPORTED(
+        core()->WaitMany(MakeUserPointer(&handle), NullUserPointer(), 1,
+                         MOJO_DEADLINE_INDEFINITE, NullUserPointer(),
+                         NullUserPointer()),
+        kMemoryCheckFailedRegex);
     // TODO(vtl): |result_index| and |signals_states| are optional. Test them
     // with non-null invalid pointers?
   }
@@ -562,16 +469,16 @@ TEST_F(CoreTest, InvalidArgumentsDeath) {
   {
     MojoHandle h;
     EXPECT_DEATH_IF_SUPPORTED(
-        core()->CreateMessagePipe(
-            NullUserPointer(), NullUserPointer(), NullUserPointer()),
+        core()->CreateMessagePipe(NullUserPointer(), NullUserPointer(),
+                                  NullUserPointer()),
         kMemoryCheckFailedRegex);
     EXPECT_DEATH_IF_SUPPORTED(
-        core()->CreateMessagePipe(
-            NullUserPointer(), MakeUserPointer(&h), NullUserPointer()),
+        core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h),
+                                  NullUserPointer()),
         kMemoryCheckFailedRegex);
     EXPECT_DEATH_IF_SUPPORTED(
-        core()->CreateMessagePipe(
-            NullUserPointer(), NullUserPointer(), MakeUserPointer(&h)),
+        core()->CreateMessagePipe(NullUserPointer(), NullUserPointer(),
+                                  MakeUserPointer(&h)),
         kMemoryCheckFailedRegex);
   }
 
@@ -584,11 +491,7 @@ TEST_F(CoreTest, InvalidArgumentsDeath) {
 
     // Null |handles| with nonzero |num_handles|.
     EXPECT_DEATH_IF_SUPPORTED(
-        core()->WriteMessage(h,
-                             NullUserPointer(),
-                             0,
-                             NullUserPointer(),
-                             1,
+        core()->WriteMessage(h, NullUserPointer(), 0, NullUserPointer(), 1,
                              MOJO_WRITE_MESSAGE_FLAG_NONE),
         kMemoryCheckFailedRegex);
 
@@ -604,11 +507,8 @@ TEST_F(CoreTest, InvalidArgumentsDeath) {
 
     uint32_t handle_count = 1;
     EXPECT_DEATH_IF_SUPPORTED(
-        core()->ReadMessage(h,
-                            NullUserPointer(),
-                            NullUserPointer(),
-                            NullUserPointer(),
-                            MakeUserPointer(&handle_count),
+        core()->ReadMessage(h, NullUserPointer(), NullUserPointer(),
+                            NullUserPointer(), MakeUserPointer(&handle_count),
                             MOJO_READ_MESSAGE_FLAG_NONE),
         kMemoryCheckFailedRegex);
 
@@ -625,10 +525,9 @@ TEST_F(CoreTest, MessagePipe) {
   MojoHandleSignalsState hss[2];
   uint32_t result_index;
 
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->CreateMessagePipe(
-          NullUserPointer(), MakeUserPointer(&h[0]), MakeUserPointer(&h[1])));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            core()->CreateMessagePipe(NullUserPointer(), MakeUserPointer(&h[0]),
+                                      MakeUserPointer(&h[1])));
   // Should get two distinct, valid handles.
   EXPECT_NE(h[0], MOJO_HANDLE_INVALID);
   EXPECT_NE(h[1], MOJO_HANDLE_INVALID);
@@ -640,13 +539,10 @@ TEST_F(CoreTest, MessagePipe) {
   result_index = static_cast<uint32_t>(-1);
   hss[0] = kEmptyMojoHandleSignalsState;
   hss[1] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
-            core()->WaitMany(MakeUserPointer(h),
-                             MakeUserPointer(signals),
-                             2,
-                             0,
-                             MakeUserPointer(&result_index),
-                             MakeUserPointer(hss)));
+  EXPECT_EQ(
+      MOJO_RESULT_DEADLINE_EXCEEDED,
+      core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2, 0,
+                       MakeUserPointer(&result_index), MakeUserPointer(hss)));
   EXPECT_EQ(static_cast<uint32_t>(-1), result_index);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ -658,33 +554,25 @@ TEST_F(CoreTest, MessagePipe) {
   // Try to read anyway.
   char buffer[1] = {'a'};
   uint32_t buffer_size = 1;
-  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            core()->ReadMessage(h[0],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&buffer_size),
-                                NullUserPointer(),
-                                NullUserPointer(),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_SHOULD_WAIT,
+      core()->ReadMessage(h[0], UserPointer<void>(buffer),
+                          MakeUserPointer(&buffer_size), NullUserPointer(),
+                          NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
   // Check that it left its inputs alone.
   EXPECT_EQ('a', buffer[0]);
   EXPECT_EQ(1u, buffer_size);
 
   // Both should be writable.
   hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h[0],
-                         MOJO_HANDLE_SIGNAL_WRITABLE,
-                         1000000000,
-                         MakeUserPointer(&hss[0])));
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[0], MOJO_HANDLE_SIGNAL_WRITABLE,
+                                         1000000000, MakeUserPointer(&hss[0])));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss[0].satisfiable_signals);
   hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h[1],
-                         MOJO_HANDLE_SIGNAL_WRITABLE,
-                         1000000000,
-                         MakeUserPointer(&hss[0])));
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE,
+                                         1000000000, MakeUserPointer(&hss[0])));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss[0].satisfiable_signals);
@@ -695,13 +583,11 @@ TEST_F(CoreTest, MessagePipe) {
   result_index = static_cast<uint32_t>(-1);
   hss[0] = kEmptyMojoHandleSignalsState;
   hss[1] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WaitMany(MakeUserPointer(h),
-                             MakeUserPointer(signals),
-                             2,
-                             MOJO_DEADLINE_INDEFINITE,
-                             MakeUserPointer(&result_index),
-                             MakeUserPointer(hss)));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2,
+                       MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+                       MakeUserPointer(hss)));
   EXPECT_EQ(1u, result_index);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ -712,13 +598,10 @@ TEST_F(CoreTest, MessagePipe) {
 
   // Write to |h[1]|.
   buffer[0] = 'b';
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h[1],
-                                 UserPointer<const void>(buffer),
-                                 1,
-                                 NullUserPointer(),
-                                 0,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1,
+                           NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Check that |h[0]| is now readable.
   signals[0] = MOJO_HANDLE_SIGNAL_READABLE;
@@ -726,13 +609,11 @@ TEST_F(CoreTest, MessagePipe) {
   result_index = static_cast<uint32_t>(-1);
   hss[0] = kEmptyMojoHandleSignalsState;
   hss[1] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WaitMany(MakeUserPointer(h),
-                             MakeUserPointer(signals),
-                             2,
-                             MOJO_DEADLINE_INDEFINITE,
-                             MakeUserPointer(&result_index),
-                             MakeUserPointer(hss)));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      core()->WaitMany(MakeUserPointer(h), MakeUserPointer(signals), 2,
+                       MOJO_DEADLINE_INDEFINITE, MakeUserPointer(&result_index),
+                       MakeUserPointer(hss)));
   EXPECT_EQ(0u, result_index);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss[0].satisfied_signals);
@@ -745,46 +626,38 @@ TEST_F(CoreTest, MessagePipe) {
   // Read from |h[0]|.
   // First, get only the size.
   buffer_size = 0;
-  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            core()->ReadMessage(h[0],
-                                NullUserPointer(),
-                                MakeUserPointer(&buffer_size),
-                                NullUserPointer(),
-                                NullUserPointer(),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_RESOURCE_EXHAUSTED,
+      core()->ReadMessage(h[0], NullUserPointer(),
+                          MakeUserPointer(&buffer_size), NullUserPointer(),
+                          NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(1u, buffer_size);
   // Then actually read it.
   buffer[0] = 'c';
   buffer_size = 1;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h[0],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&buffer_size),
-                                NullUserPointer(),
-                                NullUserPointer(),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      core()->ReadMessage(h[0], UserPointer<void>(buffer),
+                          MakeUserPointer(&buffer_size), NullUserPointer(),
+                          NullUserPointer(), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ('b', buffer[0]);
   EXPECT_EQ(1u, buffer_size);
 
   // |h[0]| should no longer be readable.
   hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_DEADLINE_EXCEEDED,
-      core()->Wait(
-          h[0], MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss[0])));
+  EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED,
+            core()->Wait(h[0], MOJO_HANDLE_SIGNAL_READABLE, 0,
+                         MakeUserPointer(&hss[0])));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss[0].satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss[0].satisfiable_signals);
 
   // Write to |h[0]|.
   buffer[0] = 'd';
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h[0],
-                                 UserPointer<const void>(buffer),
-                                 1,
-                                 NullUserPointer(),
-                                 0,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      core()->WriteMessage(h[0], UserPointer<const void>(buffer), 1,
+                           NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Close |h[0]|.
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[0]));
@@ -792,51 +665,38 @@ TEST_F(CoreTest, MessagePipe) {
   // Check that |h[1]| is no longer writable (and will never be).
   hss[0] = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h[1],
-                         MOJO_HANDLE_SIGNAL_WRITABLE,
-                         1000000000,
+            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_WRITABLE, 1000000000,
                          MakeUserPointer(&hss[0])));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfiable_signals);
 
   // Check that |h[1]| is still readable (for the moment).
   hss[0] = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
-                         MakeUserPointer(&hss[0])));
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE,
+                                         1000000000, MakeUserPointer(&hss[0])));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss[0].satisfiable_signals);
 
   // Discard a message from |h[1]|.
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            core()->ReadMessage(h[1],
-                                NullUserPointer(),
-                                NullUserPointer(),
-                                NullUserPointer(),
-                                NullUserPointer(),
+            core()->ReadMessage(h[1], NullUserPointer(), NullUserPointer(),
+                                NullUserPointer(), NullUserPointer(),
                                 MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // |h[1]| is no longer readable (and will never be).
   hss[0] = kFullMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->Wait(h[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss[0])));
   EXPECT_EQ(0u, hss[0].satisfied_signals);
   EXPECT_EQ(0u, hss[0].satisfiable_signals);
 
   // Try writing to |h[1]|.
   buffer[0] = 'e';
-  EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            core()->WriteMessage(h[1],
-                                 UserPointer<const void>(buffer),
-                                 1,
-                                 NullUserPointer(),
-                                 0,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_FAILED_PRECONDITION,
+      core()->WriteMessage(h[1], UserPointer<const void>(buffer), 1,
+                           NullUserPointer(), 0, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, core()->Close(h[1]));
 }
@@ -863,17 +723,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
 
   // Make sure that |h_passing[]| work properly.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 NullUserPointer(),
-                                 0,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+                                 kHelloSize, NullUserPointer(), 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
@@ -882,12 +737,10 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h_passing[1],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&num_bytes),
-                                MakeUserPointer(handles),
-                                MakeUserPointer(&num_handles),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+            core()->ReadMessage(
+                h_passing[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
@@ -895,18 +748,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
   // Make sure that you can't pass either of the message pipe's handles over
   // itself.
   EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 MakeUserPointer(&h_passing[0]),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+                                 kHelloSize, MakeUserPointer(&h_passing[0]), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 MakeUserPointer(&h_passing[1]),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+                                 kHelloSize, MakeUserPointer(&h_passing[1]), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   MojoHandle h_passed[2];
@@ -917,17 +764,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
 
   // Make sure that |h_passed[]| work properly.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passed[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 NullUserPointer(),
-                                 0,
+            core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello),
+                                 kHelloSize, NullUserPointer(), 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passed[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h_passed[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
@@ -936,29 +778,22 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h_passed[1],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&num_bytes),
-                                MakeUserPointer(handles),
-                                MakeUserPointer(&num_handles),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+            core()->ReadMessage(
+                h_passed[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
 
   // Send |h_passed[1]| from |h_passing[0]| to |h_passing[1]|.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kWorld),
-                                 kWorldSize,
-                                 MakeUserPointer(&h_passed[1]),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
+                                 kWorldSize, MakeUserPointer(&h_passed[1]), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
@@ -967,12 +802,10 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h_passing[1],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&num_bytes),
-                                MakeUserPointer(handles),
-                                MakeUserPointer(&num_handles),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+            core()->ReadMessage(
+                h_passing[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kWorldSize, num_bytes);
   EXPECT_STREQ(kWorld, buffer);
   EXPECT_EQ(1u, num_handles);
@@ -991,17 +824,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
 
   // Write to |h_passed[0]|. Should receive on |h_received|.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passed[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 NullUserPointer(),
-                                 0,
+            core()->WriteMessage(h_passed[0], UserPointer<const void>(kHello),
+                                 kHelloSize, NullUserPointer(), 0,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_received,
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
@@ -1010,12 +838,10 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing1) {
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h_received,
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&num_bytes),
-                                MakeUserPointer(handles),
-                                MakeUserPointer(&num_handles),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+            core()->ReadMessage(
+                h_received, UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(0u, num_handles);
@@ -1031,8 +857,8 @@ TEST_F(CoreTest, DataPipe) {
   MojoHandleSignalsState hss;
 
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->CreateDataPipe(
-                NullUserPointer(), MakeUserPointer(&ph), MakeUserPointer(&ch)));
+            core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph),
+                                   MakeUserPointer(&ch)));
   // Should get two distinct, valid handles.
   EXPECT_NE(ph, MOJO_HANDLE_INVALID);
   EXPECT_NE(ch, MOJO_HANDLE_INVALID);
@@ -1046,9 +872,8 @@ TEST_F(CoreTest, DataPipe) {
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
   hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0, MakeUserPointer(&hss)));
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ph, MOJO_HANDLE_SIGNAL_WRITABLE, 0,
+                                         MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfiable_signals);
 
@@ -1070,17 +895,15 @@ TEST_F(CoreTest, DataPipe) {
   char elements[2] = {'A', 'B'};
   uint32_t num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteData(ph,
-                              UserPointer<const void>(elements),
+            core()->WriteData(ph, UserPointer<const void>(elements),
                               MakeUserPointer(&num_bytes),
                               MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(2u, num_bytes);
 
   // Consumer should now be readable.
   hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0, MakeUserPointer(&hss)));
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE, 0,
+                                         MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
@@ -1090,9 +913,7 @@ TEST_F(CoreTest, DataPipe) {
   num_bytes = 1u;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(
-                ch,
-                UserPointer<void>(elements),
-                MakeUserPointer(&num_bytes),
+                ch, UserPointer<void>(elements), MakeUserPointer(&num_bytes),
                 MOJO_READ_DATA_FLAG_NONE | MOJO_READ_DATA_FLAG_PEEK));
   EXPECT_EQ('A', elements[0]);
   EXPECT_EQ(-1, elements[1]);
@@ -1101,11 +922,9 @@ TEST_F(CoreTest, DataPipe) {
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = 1u;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(ch,
-                             UserPointer<void>(elements),
-                             MakeUserPointer(&num_bytes),
-                             MOJO_READ_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_OK, core()->ReadData(ch, UserPointer<void>(elements),
+                                             MakeUserPointer(&num_bytes),
+                                             MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ('A', elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
@@ -1113,8 +932,7 @@ TEST_F(CoreTest, DataPipe) {
   void* write_ptr = nullptr;
   num_bytes = 0u;
   ASSERT_EQ(MOJO_RESULT_OK,
-            core()->BeginWriteData(ph,
-                                   MakeUserPointer(&write_ptr),
+            core()->BeginWriteData(ph, MakeUserPointer(&write_ptr),
                                    MakeUserPointer(&num_bytes),
                                    MOJO_WRITE_DATA_FLAG_NONE));
   // We count on the default options providing a decent buffer size.
@@ -1124,8 +942,7 @@ TEST_F(CoreTest, DataPipe) {
   elements[0] = 'X';
   num_bytes = 1u;
   EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->WriteData(ph,
-                              UserPointer<const void>(elements),
+            core()->WriteData(ph, UserPointer<const void>(elements),
                               MakeUserPointer(&num_bytes),
                               MOJO_WRITE_DATA_FLAG_NONE));
 
@@ -1138,63 +955,51 @@ TEST_F(CoreTest, DataPipe) {
   // Query how much data we have.
   num_bytes = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(ch,
-                             NullUserPointer(),
-                             MakeUserPointer(&num_bytes),
+            core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                              MOJO_READ_DATA_FLAG_QUERY));
   EXPECT_EQ(4u, num_bytes);
 
   // Try to query with peek. Should fail.
   num_bytes = 0;
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            core()->ReadData(
-                ch,
-                NullUserPointer(),
-                MakeUserPointer(&num_bytes),
-                MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK));
+  EXPECT_EQ(
+      MOJO_RESULT_INVALID_ARGUMENT,
+      core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
+                       MOJO_READ_DATA_FLAG_QUERY | MOJO_READ_DATA_FLAG_PEEK));
   EXPECT_EQ(0u, num_bytes);
 
   // Try to discard ten characters, in all-or-none mode. Should fail.
   num_bytes = 10;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
             core()->ReadData(
-                ch,
-                NullUserPointer(),
-                MakeUserPointer(&num_bytes),
+                ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 
   // Try to discard two characters, in peek mode. Should fail.
   num_bytes = 2;
-  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            core()->ReadData(
-                ch,
-                NullUserPointer(),
-                MakeUserPointer(&num_bytes),
-                MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK));
+  EXPECT_EQ(
+      MOJO_RESULT_INVALID_ARGUMENT,
+      core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
+                       MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_PEEK));
 
   // Discard two characters.
   num_bytes = 2;
   EXPECT_EQ(MOJO_RESULT_OK,
             core()->ReadData(
-                ch,
-                NullUserPointer(),
-                MakeUserPointer(&num_bytes),
+                ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                 MOJO_READ_DATA_FLAG_DISCARD | MOJO_READ_DATA_FLAG_ALL_OR_NONE));
 
   // Try a two-phase read of the remaining two bytes with peek. Should fail.
   const void* read_ptr = nullptr;
   num_bytes = 2;
   ASSERT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            core()->BeginReadData(ch,
-                                  MakeUserPointer(&read_ptr),
+            core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
                                   MakeUserPointer(&num_bytes),
                                   MOJO_READ_DATA_FLAG_PEEK));
 
   // Read the remaining two characters, in two-phase mode (all-or-none).
   num_bytes = 2;
   ASSERT_EQ(MOJO_RESULT_OK,
-            core()->BeginReadData(ch,
-                                  MakeUserPointer(&read_ptr),
+            core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
                                   MakeUserPointer(&num_bytes),
                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
   // Note: Count on still being able to do the contiguous read here.
@@ -1203,9 +1008,7 @@ TEST_F(CoreTest, DataPipe) {
   // Discarding right now should fail.
   num_bytes = 1;
   EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->ReadData(ch,
-                             NullUserPointer(),
-                             MakeUserPointer(&num_bytes),
+            core()->ReadData(ch, NullUserPointer(), MakeUserPointer(&num_bytes),
                              MOJO_READ_DATA_FLAG_DISCARD));
 
   // Actually check our data and end the two-phase read.
@@ -1258,22 +1061,17 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
 
   MojoHandle ph, ch;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->CreateDataPipe(
-                NullUserPointer(), MakeUserPointer(&ph), MakeUserPointer(&ch)));
+            core()->CreateDataPipe(NullUserPointer(), MakeUserPointer(&ph),
+                                   MakeUserPointer(&ch)));
 
   // Send |ch| from |h_passing[0]| to |h_passing[1]|.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 MakeUserPointer(&ch),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+                                 kHelloSize, MakeUserPointer(&ch), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
@@ -1282,12 +1080,10 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h_passing[1],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&num_bytes),
-                                MakeUserPointer(handles),
-                                MakeUserPointer(&num_handles),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+            core()->ReadMessage(
+                h_passing[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(1u, num_handles);
@@ -1307,22 +1103,18 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   // Write to |ph|. Should receive on |ch_received|.
   num_bytes = kWorldSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteData(ph,
-                              UserPointer<const void>(kWorld),
+            core()->WriteData(ph, UserPointer<const void>(kWorld),
                               MakeUserPointer(&num_bytes),
                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ch_received,
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
   num_bytes = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(ch_received,
-                             UserPointer<void>(buffer),
+            core()->ReadData(ch_received, UserPointer<void>(buffer),
                              MakeUserPointer(&num_bytes),
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kWorldSize, num_bytes);
@@ -1330,17 +1122,12 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
 
   // Now pass |ph| in the same direction.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kWorld),
-                                 kWorldSize,
-                                 MakeUserPointer(&ph),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
+                                 kWorldSize, MakeUserPointer(&ph), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
@@ -1349,12 +1136,10 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h_passing[1],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&num_bytes),
-                                MakeUserPointer(handles),
-                                MakeUserPointer(&num_handles),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+            core()->ReadMessage(
+                h_passing[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kWorldSize, num_bytes);
   EXPECT_STREQ(kWorld, buffer);
   EXPECT_EQ(1u, num_handles);
@@ -1374,22 +1159,18 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   // Write to |ph_received|. Should receive on |ch_received|.
   num_bytes = kHelloSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteData(ph_received,
-                              UserPointer<const void>(kHello),
+            core()->WriteData(ph_received, UserPointer<const void>(kHello),
                               MakeUserPointer(&num_bytes),
                               MOJO_WRITE_DATA_FLAG_ALL_OR_NONE));
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(ch_received,
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(ch_received, MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
   num_bytes = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadData(ch_received,
-                             UserPointer<void>(buffer),
+            core()->ReadData(ch_received, UserPointer<void>(buffer),
                              MakeUserPointer(&num_bytes),
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
@@ -1404,42 +1185,31 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   void* write_ptr = nullptr;
   num_bytes = 0;
   ASSERT_EQ(MOJO_RESULT_OK,
-            core()->BeginWriteData(ph,
-                                   MakeUserPointer(&write_ptr),
+            core()->BeginWriteData(ph, MakeUserPointer(&write_ptr),
                                    MakeUserPointer(&num_bytes),
                                    MOJO_WRITE_DATA_FLAG_NONE));
   ASSERT_GE(num_bytes, 1u);
   EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 MakeUserPointer(&ph),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+                                 kHelloSize, MakeUserPointer(&ph), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // But |ch| can, even if |ph| is in a two-phase write.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 MakeUserPointer(&ch),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+                                 kHelloSize, MakeUserPointer(&ch), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   ch = MOJO_HANDLE_INVALID;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          NullUserPointer()));
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h_passing[1],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&num_bytes),
-                                MakeUserPointer(handles),
-                                MakeUserPointer(&num_handles),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+            core()->ReadMessage(
+                h_passing[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kHelloSize, num_bytes);
   EXPECT_STREQ(kHello, buffer);
   EXPECT_EQ(1u, num_handles);
@@ -1452,10 +1222,8 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
 
   // Wait for |ch| to be readable.
   hss = kEmptyMojoHandleSignalsState;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      core()->Wait(
-          ch, MOJO_HANDLE_SIGNAL_READABLE, 1000000000, MakeUserPointer(&hss)));
+  EXPECT_EQ(MOJO_RESULT_OK, core()->Wait(ch, MOJO_HANDLE_SIGNAL_READABLE,
+                                         1000000000, MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
@@ -1463,32 +1231,23 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   const void* read_ptr = nullptr;
   num_bytes = 1;
   ASSERT_EQ(MOJO_RESULT_OK,
-            core()->BeginReadData(ch,
-                                  MakeUserPointer(&read_ptr),
+            core()->BeginReadData(ch, MakeUserPointer(&read_ptr),
                                   MakeUserPointer(&num_bytes),
                                   MOJO_READ_DATA_FLAG_ALL_OR_NONE));
   EXPECT_EQ(MOJO_RESULT_BUSY,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kHello),
-                                 kHelloSize,
-                                 MakeUserPointer(&ch),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kHello),
+                                 kHelloSize, MakeUserPointer(&ch), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // But |ph| can, even if |ch| is in a two-phase read.
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->WriteMessage(h_passing[0],
-                                 UserPointer<const void>(kWorld),
-                                 kWorldSize,
-                                 MakeUserPointer(&ph),
-                                 1,
+            core()->WriteMessage(h_passing[0], UserPointer<const void>(kWorld),
+                                 kWorldSize, MakeUserPointer(&ph), 1,
                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   ph = MOJO_HANDLE_INVALID;
   hss = kEmptyMojoHandleSignalsState;
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->Wait(h_passing[1],
-                         MOJO_HANDLE_SIGNAL_READABLE,
-                         1000000000,
+            core()->Wait(h_passing[1], MOJO_HANDLE_SIGNAL_READABLE, 1000000000,
                          MakeUserPointer(&hss)));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
@@ -1497,12 +1256,10 @@ TEST_F(CoreTest, MessagePipeBasicLocalHandlePassing2) {
   num_bytes = kBufferSize;
   num_handles = arraysize(handles);
   EXPECT_EQ(MOJO_RESULT_OK,
-            core()->ReadMessage(h_passing[1],
-                                UserPointer<void>(buffer),
-                                MakeUserPointer(&num_bytes),
-                                MakeUserPointer(handles),
-                                MakeUserPointer(&num_handles),
-                                MOJO_READ_MESSAGE_FLAG_NONE));
+            core()->ReadMessage(
+                h_passing[1], UserPointer<void>(buffer),
+                MakeUserPointer(&num_bytes), MakeUserPointer(handles),
+                MakeUserPointer(&num_handles), MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kWorldSize, num_bytes);
   EXPECT_STREQ(kWorld, buffer);
   EXPECT_EQ(1u, num_handles);
diff --git a/mojo/edk/system/data_pipe.cc b/mojo/edk/system/data_pipe.cc
index e9525bc..cbacb89 100644
--- a/mojo/edk/system/data_pipe.cc
+++ b/mojo/edk/system/data_pipe.cc
@@ -10,7 +10,7 @@
 #include <limits>
 
 #include "base/logging.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/options_validation.h"
 #include "mojo/edk/system/waiter_list.h"
@@ -19,11 +19,15 @@ namespace mojo {
 namespace system {
 
 // static
-const MojoCreateDataPipeOptions DataPipe::kDefaultCreateOptions = {
-    static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)),
-    MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
-    1u,
-    static_cast<uint32_t>(kDefaultDataPipeCapacityBytes)};
+MojoCreateDataPipeOptions DataPipe::GetDefaultCreateOptions() {
+  MojoCreateDataPipeOptions result = {
+      static_cast<uint32_t>(sizeof(MojoCreateDataPipeOptions)),
+      MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_NONE,
+      1u,
+      static_cast<uint32_t>(
+          GetConfiguration().default_data_pipe_capacity_bytes)};
+  return result;
+}
 
 // static
 MojoResult DataPipe::ValidateCreateOptions(
@@ -32,7 +36,7 @@ MojoResult DataPipe::ValidateCreateOptions(
   const MojoCreateDataPipeOptionsFlags kKnownFlags =
       MOJO_CREATE_DATA_PIPE_OPTIONS_FLAG_MAY_DISCARD;
 
-  *out_options = kDefaultCreateOptions;
+  *out_options = GetDefaultCreateOptions();
   if (in_options.IsNull())
     return MOJO_RESULT_OK;
 
@@ -48,28 +52,31 @@ MojoResult DataPipe::ValidateCreateOptions(
 
   // Checks for fields beyond |flags|:
 
-  if (!OPTIONS_STRUCT_HAS_MEMBER(
-          MojoCreateDataPipeOptions, element_num_bytes, reader))
+  if (!OPTIONS_STRUCT_HAS_MEMBER(MojoCreateDataPipeOptions, element_num_bytes,
+                                 reader))
     return MOJO_RESULT_OK;
   if (reader.options().element_num_bytes == 0)
     return MOJO_RESULT_INVALID_ARGUMENT;
   out_options->element_num_bytes = reader.options().element_num_bytes;
 
-  if (!OPTIONS_STRUCT_HAS_MEMBER(
-          MojoCreateDataPipeOptions, capacity_num_bytes, reader) ||
+  if (!OPTIONS_STRUCT_HAS_MEMBER(MojoCreateDataPipeOptions, capacity_num_bytes,
+                                 reader) ||
       reader.options().capacity_num_bytes == 0) {
     // Round the default capacity down to a multiple of the element size (but at
     // least one element).
+    size_t default_data_pipe_capacity_bytes =
+        GetConfiguration().default_data_pipe_capacity_bytes;
     out_options->capacity_num_bytes =
-        std::max(static_cast<uint32_t>(kDefaultDataPipeCapacityBytes -
-                                       (kDefaultDataPipeCapacityBytes %
+        std::max(static_cast<uint32_t>(default_data_pipe_capacity_bytes -
+                                       (default_data_pipe_capacity_bytes %
                                         out_options->element_num_bytes)),
                  out_options->element_num_bytes);
     return MOJO_RESULT_OK;
   }
   if (reader.options().capacity_num_bytes % out_options->element_num_bytes != 0)
     return MOJO_RESULT_INVALID_ARGUMENT;
-  if (reader.options().capacity_num_bytes > kMaxDataPipeCapacityBytes)
+  if (reader.options().capacity_num_bytes >
+      GetConfiguration().max_data_pipe_capacity_bytes)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
   out_options->capacity_num_bytes = reader.options().capacity_num_bytes;
 
@@ -148,8 +155,8 @@ MojoResult DataPipe::ProducerBeginWriteData(
       return MOJO_RESULT_INVALID_ARGUMENT;
   }
 
-  MojoResult rv = ProducerBeginWriteDataImplNoLock(
-      buffer, buffer_num_bytes, min_num_bytes_to_write);
+  MojoResult rv = ProducerBeginWriteDataImplNoLock(buffer, buffer_num_bytes,
+                                                   min_num_bytes_to_write);
   if (rv != MOJO_RESULT_OK)
     return rv;
   // Note: No need to awake producer waiters, even though we're going from
@@ -345,8 +352,8 @@ MojoResult DataPipe::ConsumerBeginReadData(
       return MOJO_RESULT_INVALID_ARGUMENT;
   }
 
-  MojoResult rv = ConsumerBeginReadDataImplNoLock(
-      buffer, buffer_num_bytes, min_num_bytes_to_read);
+  MojoResult rv = ConsumerBeginReadDataImplNoLock(buffer, buffer_num_bytes,
+                                                  min_num_bytes_to_read);
   if (rv != MOJO_RESULT_OK)
     return rv;
   DCHECK(consumer_in_two_phase_read_no_lock());
diff --git a/mojo/edk/system/data_pipe.h b/mojo/edk/system/data_pipe.h
index d4afdda..767d405 100644
--- a/mojo/edk/system/data_pipe.h
+++ b/mojo/edk/system/data_pipe.h
@@ -35,7 +35,7 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe
   // The default options for |MojoCreateDataPipe()|. (Real uses should obtain
   // this via |ValidateCreateOptions()| with a null |in_options|; this is
   // exposed directly for testing convenience.)
-  static const MojoCreateDataPipeOptions kDefaultCreateOptions;
+  static MojoCreateDataPipeOptions GetDefaultCreateOptions();
 
   // Validates and/or sets default options for |MojoCreateDataPipeOptions|. If
   // non-null, |in_options| must point to a struct of at least
@@ -117,12 +117,11 @@ class MOJO_SYSTEM_IMPL_EXPORT DataPipe
 
   virtual void ConsumerCloseImplNoLock() = 0;
   // |*num_bytes| will be a nonzero multiple of |element_num_bytes_|.
-  virtual MojoResult ConsumerReadDataImplNoLock(
-      UserPointer<void> elements,
-      UserPointer<uint32_t> num_bytes,
-      uint32_t max_num_bytes_to_read,
-      uint32_t min_num_bytes_to_read,
-      bool peek) = 0;
+  virtual MojoResult ConsumerReadDataImplNoLock(UserPointer<void> elements,
+                                                UserPointer<uint32_t> num_bytes,
+                                                uint32_t max_num_bytes_to_read,
+                                                uint32_t min_num_bytes_to_read,
+                                                bool peek) = 0;
   virtual MojoResult ConsumerDiscardDataImplNoLock(
       UserPointer<uint32_t> num_bytes,
       uint32_t max_num_bytes_to_discard,
diff --git a/mojo/edk/system/data_pipe_consumer_dispatcher.cc b/mojo/edk/system/data_pipe_consumer_dispatcher.cc
index fa103c3..3c14f35 100644
--- a/mojo/edk/system/data_pipe_consumer_dispatcher.cc
+++ b/mojo/edk/system/data_pipe_consumer_dispatcher.cc
@@ -77,9 +77,7 @@ MojoResult DataPipeConsumerDispatcher::ReadDataImplNoLock(
   }
 
   return data_pipe_->ConsumerReadData(
-      elements,
-      num_bytes,
-      !!(flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE),
+      elements, num_bytes, !!(flags & MOJO_READ_DATA_FLAG_ALL_OR_NONE),
       !!(flags & MOJO_READ_DATA_FLAG_PEEK));
 }
 
@@ -91,8 +89,7 @@ MojoResult DataPipeConsumerDispatcher::BeginReadDataImplNoLock(
 
   // These flags may not be used in two-phase mode.
   if ((flags & MOJO_READ_DATA_FLAG_DISCARD) ||
-      (flags & MOJO_READ_DATA_FLAG_QUERY) ||
-      (flags & MOJO_READ_DATA_FLAG_PEEK))
+      (flags & MOJO_READ_DATA_FLAG_QUERY) || (flags & MOJO_READ_DATA_FLAG_PEEK))
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   return data_pipe_->ConsumerBeginReadData(
diff --git a/mojo/edk/system/data_pipe_unittest.cc b/mojo/edk/system/data_pipe_unittest.cc
index 8d2e4eb..ad02222 100644
--- a/mojo/edk/system/data_pipe_unittest.cc
+++ b/mojo/edk/system/data_pipe_unittest.cc
@@ -9,7 +9,7 @@
 
 #include <limits>
 
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace mojo {
@@ -28,9 +28,8 @@ void RevalidateCreateOptions(
   // Nothing to check for flags.
   EXPECT_GT(validated_options.element_num_bytes, 0u);
   EXPECT_GT(validated_options.capacity_num_bytes, 0u);
-  EXPECT_EQ(0u,
-            validated_options.capacity_num_bytes %
-                validated_options.element_num_bytes);
+  EXPECT_EQ(0u, validated_options.capacity_num_bytes %
+                    validated_options.element_num_bytes);
 
   MojoCreateDataPipeOptions revalidated_options = {};
   EXPECT_EQ(MOJO_RESULT_OK,
@@ -48,10 +47,10 @@ void RevalidateCreateOptions(
 // checks done by |RevalidateCreateOptions()|.)
 void CheckDefaultCapacity(const MojoCreateDataPipeOptions& validated_options) {
   EXPECT_LE(validated_options.capacity_num_bytes,
-            kDefaultDataPipeCapacityBytes);
+            GetConfiguration().default_data_pipe_capacity_bytes);
   EXPECT_GT(validated_options.capacity_num_bytes +
                 validated_options.element_num_bytes,
-            kDefaultDataPipeCapacityBytes);
+            GetConfiguration().default_data_pipe_capacity_bytes);
 }
 
 // Tests valid inputs to |ValidateCreateOptions()|.
@@ -59,9 +58,8 @@ TEST(DataPipeTest, ValidateCreateOptionsValid) {
   // Default options.
   {
     MojoCreateDataPipeOptions validated_options = {};
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        DataPipe::ValidateCreateOptions(NullUserPointer(), &validated_options));
+    EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                  NullUserPointer(), &validated_options));
     RevalidateCreateOptions(validated_options);
     CheckDefaultCapacity(validated_options);
   }
diff --git a/mojo/edk/system/dispatcher.cc b/mojo/edk/system/dispatcher.cc
index 5607125..bed5f9e 100644
--- a/mojo/edk/system/dispatcher.cc
+++ b/mojo/edk/system/dispatcher.cc
@@ -5,7 +5,7 @@
 #include "mojo/edk/system/dispatcher.h"
 
 #include "base/logging.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 #include "mojo/edk/system/platform_handle_dispatcher.h"
 #include "mojo/edk/system/shared_buffer_dispatcher.h"
@@ -58,8 +58,8 @@ bool Dispatcher::TransportDataAccess::EndSerializeAndClose(
     size_t* actual_size,
     embedder::PlatformHandleVector* platform_handles) {
   DCHECK(dispatcher);
-  return dispatcher->EndSerializeAndClose(
-      channel, destination, actual_size, platform_handles);
+  return dispatcher->EndSerializeAndClose(channel, destination, actual_size,
+                                          platform_handles);
 }
 
 // static
@@ -72,7 +72,7 @@ scoped_refptr<Dispatcher> Dispatcher::TransportDataAccess::Deserialize(
   switch (static_cast<int32_t>(type)) {
     case kTypeUnknown:
       DVLOG(2) << "Deserializing invalid handle";
-      return scoped_refptr<Dispatcher>();
+      return nullptr;
     case kTypeMessagePipe:
       return scoped_refptr<Dispatcher>(
           MessagePipeDispatcher::Deserialize(channel, source, size));
@@ -81,7 +81,7 @@ scoped_refptr<Dispatcher> Dispatcher::TransportDataAccess::Deserialize(
       // TODO(vtl): Implement.
       LOG(WARNING) << "Deserialization of dispatcher type " << type
                    << " not supported";
-      return scoped_refptr<Dispatcher>();
+      return nullptr;
     case kTypeSharedBuffer:
       return scoped_refptr<Dispatcher>(SharedBufferDispatcher::Deserialize(
           channel, source, size, platform_handles));
@@ -90,7 +90,7 @@ scoped_refptr<Dispatcher> Dispatcher::TransportDataAccess::Deserialize(
           channel, source, size, platform_handles));
   }
   LOG(WARNING) << "Unknown dispatcher type " << type;
-  return scoped_refptr<Dispatcher>();
+  return nullptr;
 }
 
 MojoResult Dispatcher::Close() {
@@ -107,8 +107,9 @@ MojoResult Dispatcher::WriteMessage(
     uint32_t num_bytes,
     std::vector<DispatcherTransport>* transports,
     MojoWriteMessageFlags flags) {
-  DCHECK(!transports || (transports->size() > 0 &&
-                         transports->size() < kMaxMessageNumHandles));
+  DCHECK(!transports ||
+         (transports->size() > 0 &&
+          transports->size() < GetConfiguration().max_message_num_handles));
 
   base::AutoLock locker(lock_);
   if (is_closed_)
@@ -129,8 +130,8 @@ MojoResult Dispatcher::ReadMessage(UserPointer<void> bytes,
   if (is_closed_)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
-  return ReadMessageImplNoLock(
-      bytes, num_bytes, dispatchers, num_dispatchers, flags);
+  return ReadMessageImplNoLock(bytes, num_bytes, dispatchers, num_dispatchers,
+                               flags);
 }
 
 MojoResult Dispatcher::WriteData(UserPointer<const void> elements,
@@ -473,8 +474,8 @@ bool Dispatcher::EndSerializeAndClose(
   base::AutoLock locker(lock_);
 #endif
 
-  return EndSerializeAndCloseImplNoLock(
-      channel, destination, actual_size, platform_handles);
+  return EndSerializeAndCloseImplNoLock(channel, destination, actual_size,
+                                        platform_handles);
 }
 
 // DispatcherTransport ---------------------------------------------------------
diff --git a/mojo/edk/system/dispatcher.h b/mojo/edk/system/dispatcher.h
index 8d3edd4..b17bfae 100644
--- a/mojo/edk/system/dispatcher.h
+++ b/mojo/edk/system/dispatcher.h
@@ -14,7 +14,6 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
-#include "mojo/edk/embedder/platform_handle.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/memory.h"
@@ -48,7 +47,7 @@ namespace test {
 
 // Test helper. We need to declare it here so we can friend it.
 MOJO_SYSTEM_IMPL_EXPORT DispatcherTransport
-    DispatcherTryStartTransport(Dispatcher* dispatcher);
+DispatcherTryStartTransport(Dispatcher* dispatcher);
 
 }  // namespace test
 
diff --git a/mojo/edk/system/dispatcher_unittest.cc b/mojo/edk/system/dispatcher_unittest.cc
index b5a05d4..0b15436 100644
--- a/mojo/edk/system/dispatcher_unittest.cc
+++ b/mojo/edk/system/dispatcher_unittest.cc
@@ -44,31 +44,24 @@ TEST(DispatcherTest, Basic) {
   EXPECT_EQ(Dispatcher::kTypeUnknown, d->GetType());
 
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->WriteMessage(
-                NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+            d->WriteMessage(NullUserPointer(), 0, nullptr,
+                            MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->ReadMessage(NullUserPointer(),
-                           NullUserPointer(),
-                           nullptr,
-                           nullptr,
-                           MOJO_WRITE_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      d->WriteData(
-          NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      d->BeginWriteData(
-          NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
+            d->ReadMessage(NullUserPointer(), NullUserPointer(), nullptr,
+                           nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->WriteData(NullUserPointer(), NullUserPointer(),
+                         MOJO_WRITE_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->BeginWriteData(NullUserPointer(), NullUserPointer(),
+                              MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndWriteData(0));
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      d->ReadData(
-          NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      d->BeginReadData(
-          NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->ReadData(NullUserPointer(), NullUserPointer(),
+                        MOJO_READ_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->BeginReadData(NullUserPointer(), NullUserPointer(),
+                             MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0));
   Waiter w;
   w.Init();
@@ -90,31 +83,24 @@ TEST(DispatcherTest, Basic) {
   EXPECT_EQ(MOJO_RESULT_OK, d->Close());
 
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->WriteMessage(
-                NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+            d->WriteMessage(NullUserPointer(), 0, nullptr,
+                            MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->ReadMessage(NullUserPointer(), NullUserPointer(), nullptr,
+                           nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            d->ReadMessage(NullUserPointer(),
-                           NullUserPointer(),
-                           nullptr,
-                           nullptr,
-                           MOJO_WRITE_MESSAGE_FLAG_NONE));
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      d->WriteData(
-          NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      d->BeginWriteData(
-          NullUserPointer(), NullUserPointer(), MOJO_WRITE_DATA_FLAG_NONE));
+            d->WriteData(NullUserPointer(), NullUserPointer(),
+                         MOJO_WRITE_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->BeginWriteData(NullUserPointer(), NullUserPointer(),
+                              MOJO_WRITE_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndWriteData(0));
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      d->ReadData(
-          NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      d->BeginReadData(
-          NullUserPointer(), NullUserPointer(), MOJO_READ_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->ReadData(NullUserPointer(), NullUserPointer(),
+                        MOJO_READ_DATA_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            d->BeginReadData(NullUserPointer(), NullUserPointer(),
+                             MOJO_READ_DATA_FLAG_NONE));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, d->EndReadData(0));
   hss = HandleSignalsState();
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
@@ -172,45 +158,40 @@ class ThreadSafetyStressThread : public base::SimpleThread {
         break;
       }
       case WRITE_MESSAGE:
-        EXPECT_EQ(
-            MOJO_RESULT_INVALID_ARGUMENT,
-            dispatcher_->WriteMessage(
-                NullUserPointer(), 0, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
+        EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+                  dispatcher_->WriteMessage(NullUserPointer(), 0, nullptr,
+                                            MOJO_WRITE_MESSAGE_FLAG_NONE));
         break;
       case READ_MESSAGE:
         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-                  dispatcher_->ReadMessage(NullUserPointer(),
-                                           NullUserPointer(),
-                                           nullptr,
-                                           nullptr,
+                  dispatcher_->ReadMessage(NullUserPointer(), NullUserPointer(),
+                                           nullptr, nullptr,
                                            MOJO_WRITE_MESSAGE_FLAG_NONE));
         break;
       case WRITE_DATA:
         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-                  dispatcher_->WriteData(NullUserPointer(),
-                                         NullUserPointer(),
+                  dispatcher_->WriteData(NullUserPointer(), NullUserPointer(),
                                          MOJO_WRITE_DATA_FLAG_NONE));
         break;
       case BEGIN_WRITE_DATA:
-        EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-                  dispatcher_->BeginWriteData(NullUserPointer(),
-                                              NullUserPointer(),
-                                              MOJO_WRITE_DATA_FLAG_NONE));
+        EXPECT_EQ(
+            MOJO_RESULT_INVALID_ARGUMENT,
+            dispatcher_->BeginWriteData(NullUserPointer(), NullUserPointer(),
+                                        MOJO_WRITE_DATA_FLAG_NONE));
         break;
       case END_WRITE_DATA:
         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher_->EndWriteData(0));
         break;
       case READ_DATA:
         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-                  dispatcher_->ReadData(NullUserPointer(),
-                                        NullUserPointer(),
+                  dispatcher_->ReadData(NullUserPointer(), NullUserPointer(),
                                         MOJO_READ_DATA_FLAG_NONE));
         break;
       case BEGIN_READ_DATA:
-        EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-                  dispatcher_->BeginReadData(NullUserPointer(),
-                                             NullUserPointer(),
-                                             MOJO_READ_DATA_FLAG_NONE));
+        EXPECT_EQ(
+            MOJO_RESULT_INVALID_ARGUMENT,
+            dispatcher_->BeginReadData(NullUserPointer(), NullUserPointer(),
+                                       MOJO_READ_DATA_FLAG_NONE));
         break;
       case END_READ_DATA:
         EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dispatcher_->EndReadData(0));
diff --git a/mojo/edk/system/entrypoints.cc b/mojo/edk/system/entrypoints.cc
deleted file mode 100644
index 7ec5bb4..0000000
--- a/mojo/edk/system/entrypoints.cc
+++ /dev/null
@@ -1,191 +0,0 @@
-// Copyright 2014 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 "mojo/edk/system/entrypoints.h"
-
-#include "base/logging.h"
-#include "mojo/edk/system/core.h"
-#include "mojo/public/c/system/buffer.h"
-#include "mojo/public/c/system/data_pipe.h"
-#include "mojo/public/c/system/functions.h"
-#include "mojo/public/c/system/message_pipe.h"
-
-static mojo::system::Core* g_core = nullptr;
-
-using mojo::system::MakeUserPointer;
-
-namespace mojo {
-namespace system {
-namespace entrypoints {
-
-void SetCore(Core* core) {
-  g_core = core;
-}
-
-Core* GetCore() {
-  return g_core;
-}
-
-}  // namespace entrypoints
-}  // namepace system
-}  // namespace mojo
-
-// Definitions of the system functions.
-extern "C" {
-MojoTimeTicks MojoGetTimeTicksNow() {
-  return g_core->GetTimeTicksNow();
-}
-
-MojoResult MojoClose(MojoHandle handle) {
-  return g_core->Close(handle);
-}
-
-MojoResult MojoWait(MojoHandle handle,
-                    MojoHandleSignals signals,
-                    MojoDeadline deadline) {
-  return g_core->Wait(
-      handle, signals, deadline, mojo::system::NullUserPointer());
-}
-
-MojoResult MojoWaitMany(const MojoHandle* handles,
-                        const MojoHandleSignals* signals,
-                        uint32_t num_handles,
-                        MojoDeadline deadline) {
-  uint32_t result_index = static_cast<uint32_t>(-1);
-  MojoResult result = g_core->WaitMany(MakeUserPointer(handles),
-                                       MakeUserPointer(signals),
-                                       num_handles,
-                                       deadline,
-                                       MakeUserPointer(&result_index),
-                                       mojo::system::NullUserPointer());
-  return (result == MOJO_RESULT_OK) ? static_cast<MojoResult>(result_index)
-                                    : result;
-}
-
-MojoResult MojoCreateMessagePipe(const MojoCreateMessagePipeOptions* options,
-                                 MojoHandle* message_pipe_handle0,
-                                 MojoHandle* message_pipe_handle1) {
-  return g_core->CreateMessagePipe(MakeUserPointer(options),
-                                   MakeUserPointer(message_pipe_handle0),
-                                   MakeUserPointer(message_pipe_handle1));
-}
-
-MojoResult MojoWriteMessage(MojoHandle message_pipe_handle,
-                            const void* bytes,
-                            uint32_t num_bytes,
-                            const MojoHandle* handles,
-                            uint32_t num_handles,
-                            MojoWriteMessageFlags flags) {
-  return g_core->WriteMessage(message_pipe_handle,
-                              MakeUserPointer(bytes),
-                              num_bytes,
-                              MakeUserPointer(handles),
-                              num_handles,
-                              flags);
-}
-
-MojoResult MojoReadMessage(MojoHandle message_pipe_handle,
-                           void* bytes,
-                           uint32_t* num_bytes,
-                           MojoHandle* handles,
-                           uint32_t* num_handles,
-                           MojoReadMessageFlags flags) {
-  return g_core->ReadMessage(message_pipe_handle,
-                             MakeUserPointer(bytes),
-                             MakeUserPointer(num_bytes),
-                             MakeUserPointer(handles),
-                             MakeUserPointer(num_handles),
-                             flags);
-}
-
-MojoResult MojoCreateDataPipe(const MojoCreateDataPipeOptions* options,
-                              MojoHandle* data_pipe_producer_handle,
-                              MojoHandle* data_pipe_consumer_handle) {
-  return g_core->CreateDataPipe(MakeUserPointer(options),
-                                MakeUserPointer(data_pipe_producer_handle),
-                                MakeUserPointer(data_pipe_consumer_handle));
-}
-
-MojoResult MojoWriteData(MojoHandle data_pipe_producer_handle,
-                         const void* elements,
-                         uint32_t* num_elements,
-                         MojoWriteDataFlags flags) {
-  return g_core->WriteData(data_pipe_producer_handle,
-                           MakeUserPointer(elements),
-                           MakeUserPointer(num_elements),
-                           flags);
-}
-
-MojoResult MojoBeginWriteData(MojoHandle data_pipe_producer_handle,
-                              void** buffer,
-                              uint32_t* buffer_num_elements,
-                              MojoWriteDataFlags flags) {
-  return g_core->BeginWriteData(data_pipe_producer_handle,
-                                MakeUserPointer(buffer),
-                                MakeUserPointer(buffer_num_elements),
-                                flags);
-}
-
-MojoResult MojoEndWriteData(MojoHandle data_pipe_producer_handle,
-                            uint32_t num_elements_written) {
-  return g_core->EndWriteData(data_pipe_producer_handle, num_elements_written);
-}
-
-MojoResult MojoReadData(MojoHandle data_pipe_consumer_handle,
-                        void* elements,
-                        uint32_t* num_elements,
-                        MojoReadDataFlags flags) {
-  return g_core->ReadData(data_pipe_consumer_handle,
-                          MakeUserPointer(elements),
-                          MakeUserPointer(num_elements),
-                          flags);
-}
-
-MojoResult MojoBeginReadData(MojoHandle data_pipe_consumer_handle,
-                             const void** buffer,
-                             uint32_t* buffer_num_elements,
-                             MojoReadDataFlags flags) {
-  return g_core->BeginReadData(data_pipe_consumer_handle,
-                               MakeUserPointer(buffer),
-                               MakeUserPointer(buffer_num_elements),
-                               flags);
-}
-
-MojoResult MojoEndReadData(MojoHandle data_pipe_consumer_handle,
-                           uint32_t num_elements_read) {
-  return g_core->EndReadData(data_pipe_consumer_handle, num_elements_read);
-}
-
-MojoResult MojoCreateSharedBuffer(
-    const struct MojoCreateSharedBufferOptions* options,
-    uint64_t num_bytes,
-    MojoHandle* shared_buffer_handle) {
-  return g_core->CreateSharedBuffer(MakeUserPointer(options),
-                                    num_bytes,
-                                    MakeUserPointer(shared_buffer_handle));
-}
-
-MojoResult MojoDuplicateBufferHandle(
-    MojoHandle buffer_handle,
-    const struct MojoDuplicateBufferHandleOptions* options,
-    MojoHandle* new_buffer_handle) {
-  return g_core->DuplicateBufferHandle(buffer_handle,
-                                       MakeUserPointer(options),
-                                       MakeUserPointer(new_buffer_handle));
-}
-
-MojoResult MojoMapBuffer(MojoHandle buffer_handle,
-                         uint64_t offset,
-                         uint64_t num_bytes,
-                         void** buffer,
-                         MojoMapBufferFlags flags) {
-  return g_core->MapBuffer(
-      buffer_handle, offset, num_bytes, MakeUserPointer(buffer), flags);
-}
-
-MojoResult MojoUnmapBuffer(void* buffer) {
-  return g_core->UnmapBuffer(MakeUserPointer(buffer));
-}
-
-}  // extern "C"
diff --git a/mojo/edk/system/entrypoints.h b/mojo/edk/system/entrypoints.h
deleted file mode 100644
index 46c41b4..0000000
--- a/mojo/edk/system/entrypoints.h
+++ /dev/null
@@ -1,24 +0,0 @@
-// Copyright 2014 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 MOJO_EDK_SYSTEM_ENTRYPOINTS_H_
-#define MOJO_EDK_SYSTEM_ENTRYPOINTS_H_
-
-namespace mojo {
-namespace system {
-
-class Core;
-
-namespace entrypoints {
-
-// Sets the instance of Core to be used by system functions.
-void SetCore(Core* core);
-// Gets the instance of Core to be used by system functions.
-Core* GetCore();
-
-}  // namespace entrypoints
-}  // namepace system
-}  // namespace mojo
-
-#endif  // MOJO_EDK_SYSTEM_ENTRYPOINTS_H_
diff --git a/mojo/edk/system/handle_table.cc b/mojo/edk/system/handle_table.cc
index 9c01230..05d5260 100644
--- a/mojo/edk/system/handle_table.cc
+++ b/mojo/edk/system/handle_table.cc
@@ -4,9 +4,10 @@
 
 #include "mojo/edk/system/handle_table.h"
 
+#include <limits>
 #include "base/logging.h"
 #include "base/macros.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/dispatcher.h"
 
 namespace mojo {
@@ -59,7 +60,7 @@ MojoResult HandleTable::GetAndRemoveDispatcher(
 
 MojoHandle HandleTable::AddDispatcher(
     const scoped_refptr<Dispatcher>& dispatcher) {
-  if (handle_to_entry_map_.size() >= kMaxHandleTableSize)
+  if (handle_to_entry_map_.size() >= GetConfiguration().max_handle_table_size)
     return MOJO_HANDLE_INVALID;
   return AddDispatcherNoSizeCheck(dispatcher);
 }
@@ -67,7 +68,8 @@ MojoHandle HandleTable::AddDispatcher(
 std::pair<MojoHandle, MojoHandle> HandleTable::AddDispatcherPair(
     const scoped_refptr<Dispatcher>& dispatcher0,
     const scoped_refptr<Dispatcher>& dispatcher1) {
-  if (handle_to_entry_map_.size() + 1 >= kMaxHandleTableSize)
+  if (handle_to_entry_map_.size() + 1 >=
+      GetConfiguration().max_handle_table_size)
     return std::make_pair(MOJO_HANDLE_INVALID, MOJO_HANDLE_INVALID);
   return std::make_pair(AddDispatcherNoSizeCheck(dispatcher0),
                         AddDispatcherNoSizeCheck(dispatcher1));
@@ -75,17 +77,17 @@ std::pair<MojoHandle, MojoHandle> HandleTable::AddDispatcherPair(
 
 bool HandleTable::AddDispatcherVector(const DispatcherVector& dispatchers,
                                       MojoHandle* handles) {
-  DCHECK_LE(dispatchers.size(), kMaxMessageNumHandles);
+  size_t max_message_num_handles = GetConfiguration().max_message_num_handles;
+  size_t max_handle_table_size = GetConfiguration().max_handle_table_size;
+
+  DCHECK_LE(dispatchers.size(), max_message_num_handles);
   DCHECK(handles);
-  // TODO(vtl): |std::numeric_limits<size_t>::max()| isn't a compile-time
-  // expression in C++03.
-  static_assert(
-      static_cast<uint64_t>(kMaxHandleTableSize) + kMaxMessageNumHandles <
-          (sizeof(size_t) == 8 ? kuint64max
-                               : static_cast<uint64_t>(kuint32max)),
-      "Addition may overflow");
-
-  if (handle_to_entry_map_.size() + dispatchers.size() > kMaxHandleTableSize)
+  DCHECK_LT(
+      static_cast<uint64_t>(max_handle_table_size) + max_message_num_handles,
+      std::numeric_limits<size_t>::max())
+      << "Addition may overflow";
+
+  if (handle_to_entry_map_.size() + dispatchers.size() > max_handle_table_size)
     return false;
 
   for (size_t i = 0; i < dispatchers.size(); i++) {
@@ -106,7 +108,7 @@ MojoResult HandleTable::MarkBusyAndStartTransport(
     std::vector<DispatcherTransport>* transports) {
   DCHECK_NE(disallowed_handle, MOJO_HANDLE_INVALID);
   DCHECK(handles);
-  DCHECK_LE(num_handles, kMaxMessageNumHandles);
+  DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles);
   DCHECK(transports);
   DCHECK_EQ(transports->size(), num_handles);
 
@@ -187,7 +189,8 @@ MojoResult HandleTable::MarkBusyAndStartTransport(
 MojoHandle HandleTable::AddDispatcherNoSizeCheck(
     const scoped_refptr<Dispatcher>& dispatcher) {
   DCHECK(dispatcher.get());
-  DCHECK_LT(handle_to_entry_map_.size(), kMaxHandleTableSize);
+  DCHECK_LT(handle_to_entry_map_.size(),
+            GetConfiguration().max_handle_table_size);
   DCHECK_NE(next_handle_, MOJO_HANDLE_INVALID);
 
   // TODO(vtl): Maybe we want to do something different/smarter. (Or maybe try
@@ -212,7 +215,7 @@ MojoHandle HandleTable::AddDispatcherNoSizeCheck(
 void HandleTable::RemoveBusyHandles(const MojoHandle* handles,
                                     uint32_t num_handles) {
   DCHECK(handles);
-  DCHECK_LE(num_handles, kMaxMessageNumHandles);
+  DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles);
 
   for (uint32_t i = 0; i < num_handles; i++) {
     HandleToEntryMap::iterator it = handle_to_entry_map_.find(handles[i]);
@@ -226,7 +229,7 @@ void HandleTable::RemoveBusyHandles(const MojoHandle* handles,
 void HandleTable::RestoreBusyHandles(const MojoHandle* handles,
                                      uint32_t num_handles) {
   DCHECK(handles);
-  DCHECK_LE(num_handles, kMaxMessageNumHandles);
+  DCHECK_LE(num_handles, GetConfiguration().max_message_num_handles);
 
   for (uint32_t i = 0; i < num_handles; i++) {
     HandleToEntryMap::iterator it = handle_to_entry_map_.find(handles[i]);
diff --git a/mojo/edk/system/local_data_pipe.cc b/mojo/edk/system/local_data_pipe.cc
index fdfaf28..177b238 100644
--- a/mojo/edk/system/local_data_pipe.cc
+++ b/mojo/edk/system/local_data_pipe.cc
@@ -15,7 +15,7 @@
 #include <algorithm>
 
 #include "base/logging.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 
 namespace mojo {
 namespace system {
@@ -301,7 +301,8 @@ void LocalDataPipe::EnsureBufferNoLock() {
   if (buffer_)
     return;
   buffer_.reset(static_cast<char*>(
-      base::AlignedAlloc(capacity_num_bytes(), kDataPipeBufferAlignmentBytes)));
+      base::AlignedAlloc(capacity_num_bytes(),
+                         GetConfiguration().data_pipe_buffer_alignment_bytes)));
 }
 
 void LocalDataPipe::DestroyBufferNoLock() {
diff --git a/mojo/edk/system/local_data_pipe.h b/mojo/edk/system/local_data_pipe.h
index c98cb7e..abe3a46 100644
--- a/mojo/edk/system/local_data_pipe.h
+++ b/mojo/edk/system/local_data_pipe.h
@@ -44,12 +44,11 @@ class MOJO_SYSTEM_IMPL_EXPORT LocalDataPipe : public DataPipe {
       uint32_t num_bytes_written) override;
   HandleSignalsState ProducerGetHandleSignalsStateImplNoLock() const override;
   void ConsumerCloseImplNoLock() override;
-  MojoResult ConsumerReadDataImplNoLock(
-      UserPointer<void> elements,
-      UserPointer<uint32_t> num_bytes,
-      uint32_t max_num_bytes_to_read,
-      uint32_t min_num_bytes_to_read,
-      bool peek) override;
+  MojoResult ConsumerReadDataImplNoLock(UserPointer<void> elements,
+                                        UserPointer<uint32_t> num_bytes,
+                                        uint32_t max_num_bytes_to_read,
+                                        uint32_t min_num_bytes_to_read,
+                                        bool peek) override;
   MojoResult ConsumerDiscardDataImplNoLock(
       UserPointer<uint32_t> num_bytes,
       uint32_t max_num_bytes_to_discard,
diff --git a/mojo/edk/system/local_data_pipe_unittest.cc b/mojo/edk/system/local_data_pipe_unittest.cc
index e8bc716..9ba6b21 100644
--- a/mojo/edk/system/local_data_pipe_unittest.cc
+++ b/mojo/edk/system/local_data_pipe_unittest.cc
@@ -25,9 +25,8 @@ TEST(LocalDataPipeTest, Creation) {
   {
     // Get default options.
     MojoCreateDataPipeOptions default_options = {0};
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        DataPipe::ValidateCreateOptions(NullUserPointer(), &default_options));
+    EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                  NullUserPointer(), &default_options));
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(default_options));
     dp->ProducerClose();
     dp->ConsumerClose();
@@ -105,9 +104,8 @@ TEST(LocalDataPipeTest, SimpleReadWrite) {
       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
@@ -116,12 +114,9 @@ TEST(LocalDataPipeTest, SimpleReadWrite) {
 
   // Try reading; nothing there yet.
   num_bytes = static_cast<uint32_t>(arraysize(elements) * sizeof(elements[0]));
-  EXPECT_EQ(
-      MOJO_RESULT_SHOULD_WAIT,
-      dp->ConsumerReadData(UserPointer<void>(elements),
-                           MakeUserPointer(&num_bytes),
-                           false,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
+            dp->ConsumerReadData(UserPointer<void>(elements),
+                                 MakeUserPointer(&num_bytes), false, false));
 
   // Query; nothing there yet.
   num_bytes = 0;
@@ -135,12 +130,9 @@ TEST(LocalDataPipeTest, SimpleReadWrite) {
 
   // Read with invalid |num_bytes|.
   num_bytes = sizeof(elements[0]) + 1;
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      dp->ConsumerReadData(UserPointer<void>(elements),
-                           MakeUserPointer(&num_bytes),
-                           false,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            dp->ConsumerReadData(UserPointer<void>(elements),
+                                 MakeUserPointer(&num_bytes), false, false));
 
   // Write two elements.
   elements[0] = 123;
@@ -148,8 +140,7 @@ TEST(LocalDataPipeTest, SimpleReadWrite) {
   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
   // It should have written everything (even without "all or none").
   EXPECT_EQ(2u * sizeof(elements[0]), num_bytes);
 
@@ -162,12 +153,9 @@ TEST(LocalDataPipeTest, SimpleReadWrite) {
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerReadData(UserPointer<void>(elements),
-                           MakeUserPointer(&num_bytes),
-                           false,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerReadData(UserPointer<void>(elements),
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   EXPECT_EQ(123, elements[0]);
   EXPECT_EQ(-1, elements[1]);
@@ -181,12 +169,9 @@ TEST(LocalDataPipeTest, SimpleReadWrite) {
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerReadData(UserPointer<void>(elements),
-                           MakeUserPointer(&num_bytes),
-                           false,
-                           true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerReadData(UserPointer<void>(elements),
+                                 MakeUserPointer(&num_bytes), false, true));
   EXPECT_EQ(1u * sizeof(elements[0]), num_bytes);
   EXPECT_EQ(456, elements[0]);
   EXPECT_EQ(-1, elements[1]);
@@ -200,12 +185,9 @@ TEST(LocalDataPipeTest, SimpleReadWrite) {
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
-  EXPECT_EQ(
-      MOJO_RESULT_OUT_OF_RANGE,
-      dp->ConsumerReadData(UserPointer<void>(elements),
-                           MakeUserPointer(&num_bytes),
-                           true,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+            dp->ConsumerReadData(UserPointer<void>(elements),
+                                 MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(-1, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
@@ -213,12 +195,9 @@ TEST(LocalDataPipeTest, SimpleReadWrite) {
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerReadData(UserPointer<void>(elements),
-                           MakeUserPointer(&num_bytes),
-                           false,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerReadData(UserPointer<void>(elements),
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(456, elements[0]);
   EXPECT_EQ(-1, elements[1]);
 
@@ -245,9 +224,8 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) {
       2 * sizeof(int32_t)                       // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
   Waiter waiter;
@@ -275,8 +253,7 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) {
   uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
-                                  MakeUserPointer(&num_bytes),
-                                  true));
+                                  MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
 
   // Adding a waiter should now succeed.
@@ -295,12 +272,9 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) {
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerReadData(UserPointer<void>(elements),
-                           MakeUserPointer(&num_bytes),
-                           true,
-                           true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerReadData(UserPointer<void>(elements),
+                                 MakeUserPointer(&num_bytes), true, true));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   EXPECT_EQ(123, elements[0]);
   EXPECT_EQ(-1, elements[1]);
@@ -327,12 +301,9 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) {
   elements[0] = -1;
   elements[1] = -1;
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerReadData(UserPointer<void>(elements),
-                           MakeUserPointer(&num_bytes),
-                           true,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerReadData(UserPointer<void>(elements),
+                                 MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
   EXPECT_EQ(123, elements[0]);
   EXPECT_EQ(-1, elements[1]);
@@ -349,15 +320,14 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) {
   void* buffer = nullptr;
   num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerBeginWriteData(
-                MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), false));
+            dp->ProducerBeginWriteData(MakeUserPointer(&buffer),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(buffer);
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 
   static_cast<int32_t*>(buffer)[0] = 789;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ProducerEndWriteData(
-                static_cast<uint32_t>(1u * sizeof(elements[0]))));
+  EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(static_cast<uint32_t>(
+                                1u * sizeof(elements[0]))));
 
   // Add a waiter.
   waiter.Init();
@@ -368,10 +338,9 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) {
   // Read one element, using a two-phase read.
   const void* read_buffer = nullptr;
   num_bytes = 0u;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerBeginReadData(
-          MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(read_buffer);
   // Since we only read one element (after having written three in all), the
   // two-phase read should only allow us to read one. This checks an
@@ -395,8 +364,7 @@ TEST(LocalDataPipeTest, BasicProducerWaiting) {
   num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
 
   // Add a waiter.
@@ -427,9 +395,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   {
     scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
@@ -449,8 +416,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     // Not yet readable.
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerAddWaiter(
-                  &waiter, MOJO_HANDLE_SIGNAL_READABLE, 34, nullptr));
+              dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 34,
+                                    nullptr));
     EXPECT_EQ(MOJO_RESULT_DEADLINE_EXCEEDED, waiter.Wait(0, nullptr));
     hss = HandleSignalsState();
     dp->ConsumerRemoveWaiter(&waiter, &hss);
@@ -462,8 +429,7 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     uint32_t num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(UserPointer<const void>(elements),
-                                    MakeUserPointer(&num_bytes),
-                                    true));
+                                    MakeUserPointer(&num_bytes), true));
 
     // Should already be readable.
     waiter.Init();
@@ -493,12 +459,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     elements[0] = -1;
     elements[1] = -1;
     num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        dp->ConsumerReadData(UserPointer<void>(elements),
-                             MakeUserPointer(&num_bytes),
-                             true,
-                             true));
+    EXPECT_EQ(MOJO_RESULT_OK,
+              dp->ConsumerReadData(UserPointer<void>(elements),
+                                   MakeUserPointer(&num_bytes), true, true));
     EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
     EXPECT_EQ(456, elements[0]);
     EXPECT_EQ(-1, elements[1]);
@@ -516,12 +479,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     elements[0] = -1;
     elements[1] = -1;
     num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        dp->ConsumerReadData(UserPointer<void>(elements),
-                             MakeUserPointer(&num_bytes),
-                             true,
-                             false));
+    EXPECT_EQ(MOJO_RESULT_OK,
+              dp->ConsumerReadData(UserPointer<void>(elements),
+                                   MakeUserPointer(&num_bytes), true, false));
     EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
     EXPECT_EQ(456, elements[0]);
     EXPECT_EQ(-1, elements[1]);
@@ -529,8 +489,8 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     // Adding a waiter should now succeed.
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerAddWaiter(
-                  &waiter, MOJO_HANDLE_SIGNAL_READABLE, 90, nullptr));
+              dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 90,
+                                    nullptr));
 
     // Write one element.
     elements[0] = 789;
@@ -538,8 +498,7 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(UserPointer<const void>(elements),
-                                    MakeUserPointer(&num_bytes),
-                                    true));
+                                    MakeUserPointer(&num_bytes), true));
 
     // Waiting should now succeed.
     EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(1000, &context));
@@ -565,12 +524,9 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     elements[0] = -1;
     elements[1] = -1;
     num_bytes = static_cast<uint32_t>(1u * sizeof(elements[0]));
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        dp->ConsumerReadData(UserPointer<void>(elements),
-                             MakeUserPointer(&num_bytes),
-                             true,
-                             false));
+    EXPECT_EQ(MOJO_RESULT_OK,
+              dp->ConsumerReadData(UserPointer<void>(elements),
+                                   MakeUserPointer(&num_bytes), true, false));
     EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
     EXPECT_EQ(789, elements[0]);
     EXPECT_EQ(-1, elements[1]);
@@ -601,16 +557,15 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     // Request room for three (but we'll only write two).
     uint32_t num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
     EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ProducerBeginWriteData(
-                  MakeUserPointer(&buffer), MakeUserPointer(&num_bytes), true));
+              dp->ProducerBeginWriteData(MakeUserPointer(&buffer),
+                                         MakeUserPointer(&num_bytes), true));
     EXPECT_TRUE(buffer);
     EXPECT_GE(num_bytes, static_cast<uint32_t>(3u * sizeof(elements[0])));
     elements = static_cast<int32_t*>(buffer);
     elements[0] = 123;
     elements[1] = 456;
-    EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ProducerEndWriteData(
-                  static_cast<uint32_t>(2u * sizeof(elements[0]))));
+    EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(static_cast<uint32_t>(
+                                  2u * sizeof(elements[0]))));
 
     // Should already be readable.
     waiter.Init();
@@ -625,17 +580,15 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     // Request two in all-or-none mode, but only read one.
     const void* read_buffer = nullptr;
     num_bytes = static_cast<uint32_t>(2u * sizeof(elements[0]));
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        dp->ConsumerBeginReadData(
-            MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), true));
+    EXPECT_EQ(MOJO_RESULT_OK,
+              dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+                                        MakeUserPointer(&num_bytes), true));
     EXPECT_TRUE(read_buffer);
     EXPECT_EQ(static_cast<uint32_t>(2u * sizeof(elements[0])), num_bytes);
     const int32_t* read_elements = static_cast<const int32_t*>(read_buffer);
     EXPECT_EQ(123, read_elements[0]);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerEndReadData(
-                  static_cast<uint32_t>(1u * sizeof(elements[0]))));
+    EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(static_cast<uint32_t>(
+                                  1u * sizeof(elements[0]))));
 
     // Should still be readable.
     waiter.Init();
@@ -650,23 +603,21 @@ TEST(LocalDataPipeTest, BasicConsumerWaiting) {
     // Request three, but not in all-or-none mode.
     read_buffer = nullptr;
     num_bytes = static_cast<uint32_t>(3u * sizeof(elements[0]));
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        dp->ConsumerBeginReadData(
-            MakeUserPointer(&read_buffer), MakeUserPointer(&num_bytes), false));
+    EXPECT_EQ(MOJO_RESULT_OK,
+              dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer),
+                                        MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(read_buffer);
     EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(elements[0])), num_bytes);
     read_elements = static_cast<const int32_t*>(read_buffer);
     EXPECT_EQ(456, read_elements[0]);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerEndReadData(
-                  static_cast<uint32_t>(1u * sizeof(elements[0]))));
+    EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(static_cast<uint32_t>(
+                                  1u * sizeof(elements[0]))));
 
     // Adding a waiter should now succeed.
     waiter.Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              dp->ConsumerAddWaiter(
-                  &waiter, MOJO_HANDLE_SIGNAL_READABLE, 56, nullptr));
+              dp->ConsumerAddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 56,
+                                    nullptr));
 
     // Close the producer.
     dp->ProducerClose();
@@ -692,9 +643,8 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
       1000 * sizeof(int32_t)                    // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
   Waiter waiter;
@@ -711,10 +661,9 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
 
   uint32_t num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
   void* write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(write_ptr);
   EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
 
@@ -741,9 +690,8 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE, hss.satisfiable_signals);
 
   static_cast<int32_t*>(write_ptr)[0] = 123;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerEndWriteData(static_cast<uint32_t>(1u * sizeof(int32_t))));
+  EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(
+                                static_cast<uint32_t>(1u * sizeof(int32_t))));
 
   // It should be writable again.
   waiter.Init();
@@ -767,10 +715,9 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
   // middle of it.
   num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(write_ptr);
   EXPECT_GE(num_bytes, static_cast<uint32_t>(1u * sizeof(int32_t)));
 
@@ -789,10 +736,9 @@ TEST(LocalDataPipeTest, BasicTwoPhaseWaiting) {
   // Start a two-phase read.
   num_bytes = static_cast<uint32_t>(1u * sizeof(int32_t));
   const void* read_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerBeginReadData(
-          MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(read_ptr);
   EXPECT_EQ(static_cast<uint32_t>(1u * sizeof(int32_t)), num_bytes);
 
@@ -841,9 +787,8 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) {
       1 * sizeof(int32_t)                              // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
   Waiter waiter;
@@ -873,8 +818,7 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) {
   int32_t element = 123;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(&element),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
 
   // Still writable (even though it's full).
@@ -900,8 +844,7 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) {
   element = 456;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(&element),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
 
   // Still writable.
@@ -925,12 +868,9 @@ TEST(LocalDataPipeTest, BasicMayDiscardWaiting) {
   // Read that element.
   num_bytes = static_cast<uint32_t>(sizeof(int32_t));
   element = 0;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerReadData(UserPointer<void>(&element),
-                           MakeUserPointer(&num_bytes),
-                           false,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerReadData(UserPointer<void>(&element),
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(int32_t)), num_bytes);
   EXPECT_EQ(456, element);
 
@@ -971,9 +911,8 @@ TEST(LocalDataPipeTest, MayDiscard) {
       10 * sizeof(int32_t)                             // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
@@ -984,10 +923,9 @@ TEST(LocalDataPipeTest, MayDiscard) {
   Seq(0, arraysize(buffer), buffer);
   // Try writing more than capacity. (This test relies on the implementation
   // enforcing the capacity strictly.)
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
 
   // Read half of what we wrote.
@@ -995,9 +933,7 @@ TEST(LocalDataPipeTest, MayDiscard) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 false,
-                                 false));
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
   int32_t expected_buffer[100];
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
@@ -1009,10 +945,9 @@ TEST(LocalDataPipeTest, MayDiscard) {
   // Write a bit more than the space that's available.
   num_bytes = 8u * sizeof(int32_t);
   Seq(100, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(8u * sizeof(int32_t), num_bytes);
   // Internally, a circular buffer would now look like:
   //   100, 101, 102, 103, 104, 105, 106, 107, 8, 9
@@ -1022,9 +957,7 @@ TEST(LocalDataPipeTest, MayDiscard) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 false,
-                                 false));
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   expected_buffer[0] = 8;
@@ -1039,10 +972,9 @@ TEST(LocalDataPipeTest, MayDiscard) {
   // Write one integer.
   num_bytes = 1u * sizeof(int32_t);
   Seq(200, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
   // Internally, a circular buffer would now look like:
   //   -, -, -, 103, 104, 105, 106, 107, 200, -
@@ -1050,10 +982,9 @@ TEST(LocalDataPipeTest, MayDiscard) {
   // Write five more.
   num_bytes = 5u * sizeof(int32_t);
   Seq(300, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
   // Internally, a circular buffer would now look like:
   //   301, 302, 303, 304, 104, 105, 106, 107, 200, 300
@@ -1063,9 +994,7 @@ TEST(LocalDataPipeTest, MayDiscard) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 false,
-                                 false));
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   expected_buffer[0] = 104;
@@ -1087,10 +1016,9 @@ TEST(LocalDataPipeTest, MayDiscard) {
 
   num_bytes = 0u;
   void* write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(write_ptr);
   EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
   Seq(400, 6, static_cast<int32_t*>(write_ptr));
@@ -1102,10 +1030,9 @@ TEST(LocalDataPipeTest, MayDiscard) {
   // mode.
   num_bytes = 6u * sizeof(int32_t);
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(4u * sizeof(int32_t), num_bytes);
   static_cast<int32_t*>(write_ptr)[0] = 500;
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(1u * sizeof(int32_t)));
@@ -1115,19 +1042,17 @@ TEST(LocalDataPipeTest, MayDiscard) {
   // Requesting a 10-element buffer in all-or-none mode fails at this point.
   num_bytes = 10u * sizeof(int32_t);
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OUT_OF_RANGE,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
 
   // But requesting, say, a 5-element (up to 9, really) buffer should be okay.
   // It will discard two elements.
   num_bytes = 5u * sizeof(int32_t);
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
   // Only write 4 elements though.
   Seq(600, 4, static_cast<int32_t*>(write_ptr));
@@ -1139,10 +1064,9 @@ TEST(LocalDataPipeTest, MayDiscard) {
   // the internal buffer.
   num_bytes = 5u * sizeof(int32_t);
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
   // Only write 3 elements though.
   Seq(700, 3, static_cast<int32_t*>(write_ptr));
@@ -1155,9 +1079,7 @@ TEST(LocalDataPipeTest, MayDiscard) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 false,
-                                 false));
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(8u * sizeof(int32_t), num_bytes);
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   expected_buffer[0] = 500;
@@ -1182,9 +1104,8 @@ TEST(LocalDataPipeTest, AllOrNone) {
       10 * sizeof(int32_t)                      // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
@@ -1192,10 +1113,9 @@ TEST(LocalDataPipeTest, AllOrNone) {
   uint32_t num_bytes = 20u * sizeof(int32_t);
   int32_t buffer[100];
   Seq(0, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OUT_OF_RANGE,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
 
   // Should still be empty.
   num_bytes = ~0u;
@@ -1205,10 +1125,9 @@ TEST(LocalDataPipeTest, AllOrNone) {
   // Write some data.
   num_bytes = 5u * sizeof(int32_t);
   Seq(100, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
 
   // Half full.
@@ -1219,19 +1138,16 @@ TEST(LocalDataPipeTest, AllOrNone) {
   // Too much.
   num_bytes = 6u * sizeof(int32_t);
   Seq(200, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OUT_OF_RANGE,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
 
   // Try reading too much.
   num_bytes = 11u * sizeof(int32_t);
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 true,
-                                 false));
+                                 MakeUserPointer(&num_bytes), true, false));
   int32_t expected_buffer[100];
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
@@ -1244,19 +1160,17 @@ TEST(LocalDataPipeTest, AllOrNone) {
   // Just a little.
   num_bytes = 2u * sizeof(int32_t);
   Seq(300, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
 
   // Just right.
   num_bytes = 3u * sizeof(int32_t);
   Seq(400, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(3u * sizeof(int32_t), num_bytes);
 
   // Exactly full.
@@ -1269,9 +1183,7 @@ TEST(LocalDataPipeTest, AllOrNone) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 true,
-                                 false));
+                                 MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   Seq(100, 5, expected_buffer);
@@ -1282,9 +1194,7 @@ TEST(LocalDataPipeTest, AllOrNone) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 true,
-                                 false));
+                                 MakeUserPointer(&num_bytes), true, false));
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
 
@@ -1312,9 +1222,7 @@ TEST(LocalDataPipeTest, AllOrNone) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 true,
-                                 false));
+                                 MakeUserPointer(&num_bytes), true, false));
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
 
@@ -1328,9 +1236,7 @@ TEST(LocalDataPipeTest, AllOrNone) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 true,
-                                 false));
+                                 MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(2u * sizeof(int32_t), num_bytes);
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   Seq(400, 2, expected_buffer);
@@ -1358,9 +1264,8 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
       10 * sizeof(int32_t)                             // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
@@ -1368,27 +1273,24 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
   uint32_t num_bytes = 20u * sizeof(int32_t);
   int32_t buffer[100];
   Seq(0, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OUT_OF_RANGE,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
 
   // Write some stuff.
   num_bytes = 5u * sizeof(int32_t);
   Seq(100, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(5u * sizeof(int32_t), num_bytes);
 
   // Write lots of stuff (discarding all but "104").
   num_bytes = 9u * sizeof(int32_t);
   Seq(200, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(9u * sizeof(int32_t), num_bytes);
 
   // Read one.
@@ -1396,9 +1298,7 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 true,
-                                 false));
+                                 MakeUserPointer(&num_bytes), true, false));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
   int32_t expected_buffer[100];
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
@@ -1410,9 +1310,7 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 true,
-                                 false));
+                                 MakeUserPointer(&num_bytes), true, false));
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   EXPECT_EQ(0, memcmp(buffer, expected_buffer, sizeof(buffer)));
 
@@ -1434,10 +1332,9 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
   // Write as much as possible.
   num_bytes = 10u * sizeof(int32_t);
   Seq(300, arraysize(buffer), buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
 
   // Read everything.
@@ -1445,9 +1342,7 @@ TEST(LocalDataPipeTest, AllOrNoneMayDiscard) {
   memset(buffer, 0xab, sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerReadData(UserPointer<void>(buffer),
-                                 MakeUserPointer(&num_bytes),
-                                 true,
-                                 false));
+                                 MakeUserPointer(&num_bytes), true, false));
   memset(expected_buffer, 0xab, sizeof(expected_buffer));
   EXPECT_EQ(10u * sizeof(int32_t), num_bytes);
   Seq(300, 10, expected_buffer);
@@ -1468,44 +1363,40 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
       10 * sizeof(int32_t)                      // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
   // Try writing way too much (two-phase).
   uint32_t num_bytes = 20u * sizeof(int32_t);
   void* write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OUT_OF_RANGE,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
 
   // Try writing an amount which isn't a multiple of the element size
   // (two-phase).
   static_assert(sizeof(int32_t) > 1u, "Wow! int32_t's have size 1");
   num_bytes = 1u;
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_INVALID_ARGUMENT,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
 
   // Try reading way too much (two-phase).
   num_bytes = 20u * sizeof(int32_t);
   const void* read_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            dp->ConsumerBeginReadData(
-                MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
 
   // Write half (two-phase).
   num_bytes = 5u * sizeof(int32_t);
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
   // May provide more space than requested.
   EXPECT_GE(num_bytes, 5u * sizeof(int32_t));
   EXPECT_TRUE(write_ptr);
@@ -1517,15 +1408,15 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   num_bytes = 1u;
   read_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
-            dp->ConsumerBeginReadData(
-                MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
 
   // Read one (two-phase).
   num_bytes = 1u * sizeof(int32_t);
   read_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(
-                MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
   EXPECT_GE(num_bytes, 1u * sizeof(int32_t));
   EXPECT_EQ(0, static_cast<const int32_t*>(read_ptr)[0]);
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(1u * sizeof(int32_t)));
@@ -1539,19 +1430,17 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   // two-phase write of six now.
   num_bytes = 6u * sizeof(int32_t);
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OUT_OF_RANGE,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), true));
 
   // Write six elements (simple), filling the buffer.
   num_bytes = 6u * sizeof(int32_t);
   int32_t buffer[100];
   Seq(100, 6, buffer);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerWriteData(
-          UserPointer<const void>(buffer), MakeUserPointer(&num_bytes), true));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerWriteData(UserPointer<const void>(buffer),
+                                  MakeUserPointer(&num_bytes), true));
   EXPECT_EQ(6u * sizeof(int32_t), num_bytes);
 
   // We have ten.
@@ -1563,8 +1452,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   num_bytes = 10u * sizeof(int32_t);
   read_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_OUT_OF_RANGE,
-            dp->ConsumerBeginReadData(
-                MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
 
   // Close the producer.
   dp->ProducerClose();
@@ -1573,8 +1462,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   num_bytes = 9u * sizeof(int32_t);
   read_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_OK,
-            dp->ConsumerBeginReadData(
-                MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
   EXPECT_GE(num_bytes, 9u * sizeof(int32_t));
   EXPECT_EQ(1, static_cast<const int32_t*>(read_ptr)[0]);
   EXPECT_EQ(2, static_cast<const int32_t*>(read_ptr)[1]);
@@ -1591,8 +1480,8 @@ TEST(LocalDataPipeTest, TwoPhaseAllOrNone) {
   num_bytes = 2u * sizeof(int32_t);
   read_ptr = nullptr;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            dp->ConsumerBeginReadData(
-                MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), true));
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), true));
 
   dp->ConsumerClose();
 }
@@ -1613,9 +1502,8 @@ TEST(LocalDataPipeTest, WrapAround) {
       100u                                      // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
   // This test won't be valid if |ValidateCreateOptions()| decides to give the
   // pipe more space.
   ASSERT_EQ(100u, validated_options.capacity_num_bytes);
@@ -1626,19 +1514,15 @@ TEST(LocalDataPipeTest, WrapAround) {
   uint32_t num_bytes = 20u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(&test_data[0]),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(20u, num_bytes);
 
   // Read 10 bytes.
   unsigned char read_buffer[1000] = {0};
   num_bytes = 10u;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerReadData(UserPointer<void>(read_buffer),
-                           MakeUserPointer(&num_bytes),
-                           false,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerReadData(UserPointer<void>(read_buffer),
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(10u, num_bytes);
   EXPECT_EQ(0, memcmp(read_buffer, &test_data[0], 10u));
 
@@ -1649,8 +1533,7 @@ TEST(LocalDataPipeTest, WrapAround) {
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                       MakeUserPointer(&num_bytes),
-                                       false));
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(write_buffer_ptr);
   EXPECT_EQ(80u, num_bytes);
   EXPECT_EQ(MOJO_RESULT_OK, dp->ProducerEndWriteData(0u));
@@ -1660,8 +1543,7 @@ TEST(LocalDataPipeTest, WrapAround) {
   num_bytes = 200u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(&test_data[20]),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(90u, num_bytes);
 
   // Check that a two-phase read can now only read (at most) 90 bytes. (This
@@ -1671,8 +1553,7 @@ TEST(LocalDataPipeTest, WrapAround) {
   num_bytes = 0u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                      MakeUserPointer(&num_bytes),
-                                      false));
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_TRUE(read_buffer_ptr);
   EXPECT_EQ(90u, num_bytes);
   EXPECT_EQ(MOJO_RESULT_OK, dp->ConsumerEndReadData(0u));
@@ -1682,12 +1563,9 @@ TEST(LocalDataPipeTest, WrapAround) {
   num_bytes =
       static_cast<uint32_t>(arraysize(read_buffer) * sizeof(read_buffer[0]));
   memset(read_buffer, 0, num_bytes);
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerReadData(UserPointer<void>(read_buffer),
-                           MakeUserPointer(&num_bytes),
-                           false,
-                           false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerReadData(UserPointer<void>(read_buffer),
+                                 MakeUserPointer(&num_bytes), false, false));
   EXPECT_EQ(100u, num_bytes);
   EXPECT_EQ(0, memcmp(read_buffer, &test_data[10], 100u));
 
@@ -1708,9 +1586,8 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
       1000u                                     // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   // Close producer first, then consumer.
   {
@@ -1720,16 +1597,14 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     uint32_t num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(UserPointer<const void>(kTestData),
-                                    MakeUserPointer(&num_bytes),
-                                    false));
+                                    MakeUserPointer(&num_bytes), false));
     EXPECT_EQ(kTestDataSize, num_bytes);
 
     // Write it again, so we'll have something left over.
     num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(UserPointer<const void>(kTestData),
-                                    MakeUserPointer(&num_bytes),
-                                    false));
+                                    MakeUserPointer(&num_bytes), false));
     EXPECT_EQ(kTestDataSize, num_bytes);
 
     // Start two-phase write.
@@ -1737,8 +1612,7 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                         MakeUserPointer(&num_bytes),
-                                         false));
+                                         MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(write_buffer_ptr);
     EXPECT_GT(num_bytes, 0u);
 
@@ -1747,8 +1621,7 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes),
-                                        false));
+                                        MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(read_buffer_ptr);
     EXPECT_EQ(2u * kTestDataSize, num_bytes);
 
@@ -1764,8 +1637,7 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes),
-                                        false));
+                                        MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(read_buffer_ptr);
     EXPECT_EQ(kTestDataSize, num_bytes);
 
@@ -1781,8 +1653,7 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     uint32_t num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(UserPointer<const void>(kTestData),
-                                    MakeUserPointer(&num_bytes),
-                                    false));
+                                    MakeUserPointer(&num_bytes), false));
     EXPECT_EQ(kTestDataSize, num_bytes);
 
     // Start two-phase write.
@@ -1790,8 +1661,7 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                         MakeUserPointer(&num_bytes),
-                                         false));
+                                         MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(write_buffer_ptr);
     ASSERT_GT(num_bytes, kTestDataSize);
 
@@ -1800,8 +1670,7 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes),
-                                        false));
+                                        MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(read_buffer_ptr);
     EXPECT_EQ(kTestDataSize, num_bytes);
 
@@ -1819,16 +1688,14 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               dp->ProducerWriteData(UserPointer<const void>(kTestData),
-                                    MakeUserPointer(&num_bytes),
-                                    false));
+                                    MakeUserPointer(&num_bytes), false));
 
     // As will trying to start another two-phase write.
     write_buffer_ptr = nullptr;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                         MakeUserPointer(&num_bytes),
-                                         false));
+                                         MakeUserPointer(&num_bytes), false));
 
     dp->ProducerClose();
   }
@@ -1843,8 +1710,7 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     uint32_t num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerBeginWriteData(MakeUserPointer(&write_buffer_ptr),
-                                         MakeUserPointer(&num_bytes),
-                                         false));
+                                         MakeUserPointer(&num_bytes), false));
     EXPECT_TRUE(write_buffer_ptr);
     ASSERT_GT(num_bytes, kTestDataSize);
 
@@ -1860,8 +1726,7 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     uint32_t num_bytes = kTestDataSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               dp->ProducerWriteData(UserPointer<const void>(kTestData),
-                                    MakeUserPointer(&num_bytes),
-                                    false));
+                                    MakeUserPointer(&num_bytes), false));
     EXPECT_EQ(kTestDataSize, num_bytes);
 
     // Close the producer.
@@ -1870,43 +1735,33 @@ TEST(LocalDataPipeTest, CloseWriteRead) {
     // Peek that data.
     char buffer[1000];
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        dp->ConsumerReadData(UserPointer<void>(buffer),
-                             MakeUserPointer(&num_bytes),
-                             false,
-                             true));
+    EXPECT_EQ(MOJO_RESULT_OK,
+              dp->ConsumerReadData(UserPointer<void>(buffer),
+                                   MakeUserPointer(&num_bytes), false, true));
     EXPECT_EQ(kTestDataSize, num_bytes);
     EXPECT_EQ(0, memcmp(buffer, kTestData, kTestDataSize));
 
     // Read that data.
     memset(buffer, 0, 1000);
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
-    EXPECT_EQ(
-        MOJO_RESULT_OK,
-        dp->ConsumerReadData(UserPointer<void>(buffer),
-                             MakeUserPointer(&num_bytes),
-                             false,
-                             false));
+    EXPECT_EQ(MOJO_RESULT_OK,
+              dp->ConsumerReadData(UserPointer<void>(buffer),
+                                   MakeUserPointer(&num_bytes), false, false));
     EXPECT_EQ(kTestDataSize, num_bytes);
     EXPECT_EQ(0, memcmp(buffer, kTestData, kTestDataSize));
 
     // A second read should fail.
     num_bytes = static_cast<uint32_t>(sizeof(buffer));
-    EXPECT_EQ(
-        MOJO_RESULT_FAILED_PRECONDITION,
-        dp->ConsumerReadData(UserPointer<void>(buffer),
-                             MakeUserPointer(&num_bytes),
-                             false,
-                             false));
+    EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
+              dp->ConsumerReadData(UserPointer<void>(buffer),
+                                   MakeUserPointer(&num_bytes), false, false));
 
     // A two-phase read should also fail.
     const void* read_buffer_ptr = nullptr;
     num_bytes = 0u;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               dp->ConsumerBeginReadData(MakeUserPointer(&read_buffer_ptr),
-                                        MakeUserPointer(&num_bytes),
-                                        false));
+                                        MakeUserPointer(&num_bytes), false));
 
     // Ditto for discard.
     num_bytes = 10u;
@@ -1925,9 +1780,8 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
       10 * sizeof(int32_t)                      // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
@@ -1948,10 +1802,9 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
   // Try ending a two-phase write with an invalid amount (too much).
   num_bytes = 0u;
   void* write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             dp->ProducerEndWriteData(num_bytes +
                                      static_cast<uint32_t>(sizeof(int32_t))));
@@ -1968,10 +1821,9 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
   // element size).
   num_bytes = 0u;
   write_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ProducerBeginWriteData(
-          MakeUserPointer(&write_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ProducerBeginWriteData(MakeUserPointer(&write_ptr),
+                                       MakeUserPointer(&num_bytes), false));
   EXPECT_GE(num_bytes, 1u);
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ProducerEndWriteData(1u));
 
@@ -1988,8 +1840,7 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
   num_bytes = 1u * sizeof(int32_t);
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(&element),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
 
   // One element available.
   num_bytes = 0u;
@@ -2008,10 +1859,9 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
   // Try ending a two-phase read with an invalid amount (too much).
   num_bytes = 0u;
   const void* read_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerBeginReadData(
-          MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             dp->ConsumerEndReadData(num_bytes +
                                     static_cast<uint32_t>(sizeof(int32_t))));
@@ -2025,10 +1875,9 @@ TEST(LocalDataPipeTest, TwoPhaseMoreInvalidArguments) {
   // element size).
   num_bytes = 0u;
   read_ptr = nullptr;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerBeginReadData(
-          MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(1u * sizeof(int32_t), num_bytes);
   EXPECT_EQ(123, static_cast<const int32_t*>(read_ptr)[0]);
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT, dp->ConsumerEndReadData(1u));
@@ -2057,9 +1906,8 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) {
       2                                                // |capacity_num_bytes|.
   };
   MojoCreateDataPipeOptions validated_options = {0};
-  EXPECT_EQ(MOJO_RESULT_OK,
-            DataPipe::ValidateCreateOptions(MakeUserPointer(&options),
-                                            &validated_options));
+  EXPECT_EQ(MOJO_RESULT_OK, DataPipe::ValidateCreateOptions(
+                                MakeUserPointer(&options), &validated_options));
 
   scoped_refptr<LocalDataPipe> dp(new LocalDataPipe(validated_options));
 
@@ -2068,17 +1916,15 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) {
   uint32_t num_bytes = 2u;
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(2u, num_bytes);
 
   // Begin reading.
   const void* read_ptr = nullptr;
   num_bytes = 2u;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerBeginReadData(
-          MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(2u, num_bytes);
   EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
   EXPECT_EQ('b', static_cast<const char*>(read_ptr)[1]);
@@ -2094,8 +1940,7 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) {
   // this through reveals the significant consequence.
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
 
   // Check that our read buffer hasn't changed underneath us.
   EXPECT_EQ('a', static_cast<const char*>(read_ptr)[0]);
@@ -2107,16 +1952,14 @@ TEST(LocalDataPipeTest, DISABLED_MayDiscardTwoPhaseConsistent) {
   // Now writing should succeed.
   EXPECT_EQ(MOJO_RESULT_OK,
             dp->ProducerWriteData(UserPointer<const void>(elements),
-                                  MakeUserPointer(&num_bytes),
-                                  false));
+                                  MakeUserPointer(&num_bytes), false));
 
   // And if we read, we should get the new values.
   read_ptr = nullptr;
   num_bytes = 2u;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dp->ConsumerBeginReadData(
-          MakeUserPointer(&read_ptr), MakeUserPointer(&num_bytes), false));
+  EXPECT_EQ(MOJO_RESULT_OK,
+            dp->ConsumerBeginReadData(MakeUserPointer(&read_ptr),
+                                      MakeUserPointer(&num_bytes), false));
   EXPECT_EQ(2u, num_bytes);
   EXPECT_EQ('x', static_cast<const char*>(read_ptr)[0]);
   EXPECT_EQ('y', static_cast<const char*>(read_ptr)[1]);
diff --git a/mojo/edk/system/mapping_table.cc b/mojo/edk/system/mapping_table.cc
index 0a28a1d..693e8d7 100644
--- a/mojo/edk/system/mapping_table.cc
+++ b/mojo/edk/system/mapping_table.cc
@@ -6,7 +6,7 @@
 
 #include "base/logging.h"
 #include "mojo/edk/embedder/platform_shared_buffer.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 
 namespace mojo {
 namespace system {
@@ -23,7 +23,8 @@ MojoResult MappingTable::AddMapping(
     scoped_ptr<embedder::PlatformSharedBufferMapping> mapping) {
   DCHECK(mapping);
 
-  if (address_to_mapping_map_.size() >= kMaxMappingTableSize)
+  if (address_to_mapping_map_.size() >=
+      GetConfiguration().max_mapping_table_sze)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   uintptr_t address = reinterpret_cast<uintptr_t>(mapping->GetBase());
diff --git a/mojo/edk/system/memory.cc b/mojo/edk/system/memory.cc
index 1d7f792..0e3d9a9 100644
--- a/mojo/edk/system/memory.cc
+++ b/mojo/edk/system/memory.cc
@@ -40,20 +40,20 @@ template void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer<8, 8>(const void*);
 
 template <size_t size, size_t alignment>
 void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithCount(const void* pointer, size_t count) {
+CheckUserPointerWithCount(const void* pointer, size_t count) {
   CHECK_LE(count, std::numeric_limits<size_t>::max() / size);
   CHECK(count == 0 || (pointer && IsAligned<alignment>(pointer)));
 }
 
 // Explicitly instantiate the sizes we need. Add instantiations as needed.
 template void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithCount<1, 1>(const void*, size_t);
+CheckUserPointerWithCount<1, 1>(const void*, size_t);
 template void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithCount<4, 4>(const void*, size_t);
+CheckUserPointerWithCount<4, 4>(const void*, size_t);
 template void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithCount<8, 4>(const void*, size_t);
+CheckUserPointerWithCount<8, 4>(const void*, size_t);
 template void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithCount<8, 8>(const void*, size_t);
+CheckUserPointerWithCount<8, 8>(const void*, size_t);
 
 template <size_t alignment>
 void CheckUserPointerWithSize(const void* pointer, size_t size) {
@@ -65,9 +65,9 @@ void CheckUserPointerWithSize(const void* pointer, size_t size) {
 
 // Explicitly instantiate the sizes we need. Add instantiations as needed.
 template void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithSize<1>(const void*, size_t);
+CheckUserPointerWithSize<1>(const void*, size_t);
 template void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithSize<4>(const void*, size_t);
+CheckUserPointerWithSize<4>(const void*, size_t);
 // Whereas the other |Check...()| functions are usually used with integral typs
 // or arrays of integral types, this one is used with Options structs for which
 // alignment has been explicitly been specified (using |MOJO_ALIGNAS()|), which
@@ -75,13 +75,13 @@ template void MOJO_SYSTEM_IMPL_EXPORT
 #if defined(COMPILER_MSVC) && defined(ARCH_CPU_32_BITS)
 template <>
 void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithSize<8>(const void* pointer, size_t size) {
+CheckUserPointerWithSize<8>(const void* pointer, size_t size) {
   CHECK(size == 0 ||
         (!!pointer && reinterpret_cast<uintptr_t>(pointer) % 8 == 0));
 }
 #else
 template void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithSize<8>(const void*, size_t);
+CheckUserPointerWithSize<8>(const void*, size_t);
 #endif
 
 }  // namespace internal
diff --git a/mojo/edk/system/memory.h b/mojo/edk/system/memory.h
index 7b5b724..96cf219 100644
--- a/mojo/edk/system/memory.h
+++ b/mojo/edk/system/memory.h
@@ -53,13 +53,13 @@ void MOJO_SYSTEM_IMPL_EXPORT CheckUserPointer(const void* pointer);
 // a buffer of |count| elements of the given size and alignment (both in bytes).
 template <size_t size, size_t alignment>
 void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithCount(const void* pointer, size_t count);
+CheckUserPointerWithCount(const void* pointer, size_t count);
 
 // Checks (insofar as appropriate/possible) that |pointer| is a valid pointer to
 // a buffer of the given size and alignment (both in bytes).
 template <size_t alignment>
 void MOJO_SYSTEM_IMPL_EXPORT
-    CheckUserPointerWithSize(const void* pointer, size_t size);
+CheckUserPointerWithSize(const void* pointer, size_t size);
 
 }  // namespace internal
 
diff --git a/mojo/edk/system/message_in_transit.cc b/mojo/edk/system/message_in_transit.cc
index 95a7d23..0f2ff5e 100644
--- a/mojo/edk/system/message_in_transit.cc
+++ b/mojo/edk/system/message_in_transit.cc
@@ -8,7 +8,7 @@
 
 #include "base/compiler_specific.h"
 #include "base/logging.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/transport_data.h"
 
 namespace mojo {
@@ -38,23 +38,13 @@ struct MessageInTransit::PrivateStructForCompileAsserts {
   // The size of |Header| must be a multiple of the alignment.
   static_assert(sizeof(Header) % kMessageAlignment == 0,
                 "sizeof(MessageInTransit::Header) invalid");
-  // Avoid dangerous situations, but making sure that the size of the "header" +
-  // the size of the data fits into a 31-bit number.
-  static_assert(static_cast<uint64_t>(sizeof(Header)) + kMaxMessageNumBytes <=
-                    0x7fffffffULL,
-                "kMaxMessageNumBytes too big");
-
-  // We assume (to avoid extra rounding code) that the maximum message (data)
-  // size is a multiple of the alignment.
-  static_assert(kMaxMessageNumBytes % kMessageAlignment == 0,
-                "kMessageAlignment not a multiple of alignment");
 };
 
 MessageInTransit::View::View(size_t message_size, const void* buffer)
     : buffer_(buffer) {
   size_t next_message_size = 0;
-  DCHECK(MessageInTransit::GetNextMessageSize(
-      buffer_, message_size, &next_message_size));
+  DCHECK(MessageInTransit::GetNextMessageSize(buffer_, message_size,
+                                              &next_message_size));
   DCHECK_EQ(message_size, next_message_size);
   // This should be equivalent.
   DCHECK_EQ(message_size, total_size());
@@ -62,18 +52,29 @@ MessageInTransit::View::View(size_t message_size, const void* buffer)
 
 bool MessageInTransit::View::IsValid(size_t serialized_platform_handle_size,
                                      const char** error_message) const {
+  size_t max_message_num_bytes = GetConfiguration().max_message_num_bytes;
+  // Avoid dangerous situations, but making sure that the size of the "header" +
+  // the size of the data fits into a 31-bit number.
+  DCHECK_LE(static_cast<uint64_t>(sizeof(Header)) + max_message_num_bytes,
+            0x7fffffffULL)
+      << "GetConfiguration().max_message_num_bytes too big";
+
+  // We assume (to avoid extra rounding code) that the maximum message (data)
+  // size is a multiple of the alignment.
+  DCHECK_EQ(max_message_num_bytes % kMessageAlignment, 0U)
+      << "GetConfiguration().max_message_num_bytes not a multiple of alignment";
+
   // Note: This also implies a check on the |main_buffer_size()|, which is just
   // |RoundUpMessageAlignment(sizeof(Header) + num_bytes())|.
-  if (num_bytes() > kMaxMessageNumBytes) {
+  if (num_bytes() > max_message_num_bytes) {
     *error_message = "Message data payload too large";
     return false;
   }
 
   if (transport_data_buffer_size() > 0) {
-    const char* e =
-        TransportData::ValidateBuffer(serialized_platform_handle_size,
-                                      transport_data_buffer(),
-                                      transport_data_buffer_size());
+    const char* e = TransportData::ValidateBuffer(
+        serialized_platform_handle_size, transport_data_buffer(),
+        transport_data_buffer_size());
     if (e) {
       *error_message = e;
       return false;
@@ -93,8 +94,7 @@ MessageInTransit::MessageInTransit(Type type,
   ConstructorHelper(type, subtype, num_bytes);
   if (bytes) {
     memcpy(MessageInTransit::bytes(), bytes, num_bytes);
-    memset(static_cast<char*>(MessageInTransit::bytes()) + num_bytes,
-           0,
+    memset(static_cast<char*>(MessageInTransit::bytes()) + num_bytes, 0,
            main_buffer_size_ - sizeof(Header) - num_bytes);
   } else {
     memset(MessageInTransit::bytes(), 0, main_buffer_size_ - sizeof(Header));
@@ -195,7 +195,7 @@ void MessageInTransit::SerializeAndCloseDispatchers(Channel* channel) {
 void MessageInTransit::ConstructorHelper(Type type,
                                          Subtype subtype,
                                          uint32_t num_bytes) {
-  DCHECK_LE(num_bytes, kMaxMessageNumBytes);
+  DCHECK_LE(num_bytes, GetConfiguration().max_message_num_bytes);
 
   // |total_size| is updated below, from the other values.
   header()->type = type;
diff --git a/mojo/edk/system/message_pipe.cc b/mojo/edk/system/message_pipe.cc
index e215730..731fd90 100644
--- a/mojo/edk/system/message_pipe.cc
+++ b/mojo/edk/system/message_pipe.cc
@@ -5,7 +5,9 @@
 #include "mojo/edk/system/message_pipe.h"
 
 #include "base/logging.h"
+#include "mojo/edk/system/channel.h"
 #include "mojo/edk/system/channel_endpoint.h"
+#include "mojo/edk/system/channel_endpoint_id.h"
 #include "mojo/edk/system/local_message_pipe_endpoint.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/message_pipe_dispatcher.h"
@@ -15,6 +17,19 @@
 namespace mojo {
 namespace system {
 
+namespace {
+
+// TODO(vtl): Move this into |Channel| (and possible further).
+struct SerializedMessagePipe {
+  // This is the endpoint ID on the receiving side, and should be a "remote ID".
+  // (The receiving side should already have had an endpoint attached and been
+  // run via the |Channel|s. This endpoint will have both IDs assigned, so this
+  // ID is only needed to associate that endpoint with a particular dispatcher.)
+  ChannelEndpointId receiver_endpoint_id;
+};
+
+}  // namespace
+
 // static
 MessagePipe* MessagePipe::CreateLocalLocal() {
   MessagePipe* message_pipe = new MessagePipe();
@@ -53,6 +68,34 @@ unsigned MessagePipe::GetPeerPort(unsigned port) {
   return port ^ 1;
 }
 
+// static
+bool MessagePipe::Deserialize(Channel* channel,
+                              const void* source,
+                              size_t size,
+                              scoped_refptr<MessagePipe>* message_pipe,
+                              unsigned* port) {
+  DCHECK(!message_pipe->get());  // Not technically wrong, but unlikely.
+
+  if (size != sizeof(SerializedMessagePipe)) {
+    LOG(ERROR) << "Invalid serialized message pipe";
+    return false;
+  }
+
+  const SerializedMessagePipe* s =
+      static_cast<const SerializedMessagePipe*>(source);
+  *message_pipe = channel->PassIncomingMessagePipe(s->receiver_endpoint_id);
+  if (!message_pipe->get()) {
+    LOG(ERROR) << "Failed to deserialize message pipe (ID = "
+               << s->receiver_endpoint_id << ")";
+    return false;
+  }
+
+  DVLOG(2) << "Deserializing message pipe dispatcher (new local ID = "
+           << s->receiver_endpoint_id << ")";
+  *port = 0;
+  return true;
+}
+
 MessagePipeEndpoint::Type MessagePipe::GetType(unsigned port) {
   DCHECK(port == 0 || port == 1);
   base::AutoLock locker(lock_);
@@ -100,9 +143,7 @@ MojoResult MessagePipe::WriteMessage(
       GetPeerPort(port),
       make_scoped_ptr(new MessageInTransit(
           MessageInTransit::kTypeMessagePipeEndpoint,
-          MessageInTransit::kSubtypeMessagePipeEndpointData,
-          num_bytes,
-          bytes)),
+          MessageInTransit::kSubtypeMessagePipeEndpointData, num_bytes, bytes)),
       transports);
 }
 
@@ -117,8 +158,8 @@ MojoResult MessagePipe::ReadMessage(unsigned port,
   base::AutoLock locker(lock_);
   DCHECK(endpoints_[port]);
 
-  return endpoints_[port]->ReadMessage(
-      bytes, num_bytes, dispatchers, num_dispatchers, flags);
+  return endpoints_[port]->ReadMessage(bytes, num_bytes, dispatchers,
+                                       num_dispatchers, flags);
 }
 
 HandleSignalsState MessagePipe::GetHandleSignalsState(unsigned port) const {
@@ -154,6 +195,32 @@ void MessagePipe::RemoveWaiter(unsigned port,
   endpoints_[port]->RemoveWaiter(waiter, signals_state);
 }
 
+void MessagePipe::StartSerialize(unsigned /*port*/,
+                                 Channel* /*channel*/,
+                                 size_t* max_size,
+                                 size_t* max_platform_handles) {
+  *max_size = sizeof(SerializedMessagePipe);
+  *max_platform_handles = 0;
+}
+
+bool MessagePipe::EndSerialize(
+    unsigned port,
+    Channel* channel,
+    void* destination,
+    size_t* actual_size,
+    embedder::PlatformHandleVector* /*platform_handles*/) {
+  SerializedMessagePipe* s = static_cast<SerializedMessagePipe*>(destination);
+
+  // Convert the local endpoint to a proxy endpoint (moving the message queue)
+  // and attach it to the channel.
+  s->receiver_endpoint_id =
+      channel->AttachAndRunEndpoint(ConvertLocalToProxy(port), false);
+  DVLOG(2) << "Serializing message pipe (remote ID = "
+           << s->receiver_endpoint_id << ")";
+  *actual_size = sizeof(SerializedMessagePipe);
+  return true;
+}
+
 scoped_refptr<ChannelEndpoint> MessagePipe::ConvertLocalToProxy(unsigned port) {
   DCHECK(port == 0 || port == 1);
 
@@ -165,10 +232,8 @@ scoped_refptr<ChannelEndpoint> MessagePipe::ConvertLocalToProxy(unsigned port) {
   // send the already-queued messages.
   if (!endpoints_[GetPeerPort(port)]) {
     scoped_refptr<ChannelEndpoint> channel_endpoint(new ChannelEndpoint(
-        nullptr,
-        0,
-        static_cast<LocalMessagePipeEndpoint*>(endpoints_[port].get())
-            ->message_queue()));
+        nullptr, 0, static_cast<LocalMessagePipeEndpoint*>(
+                        endpoints_[port].get())->message_queue()));
     endpoints_[port]->Close();
     endpoints_[port].reset();
     return channel_endpoint;
@@ -177,18 +242,15 @@ scoped_refptr<ChannelEndpoint> MessagePipe::ConvertLocalToProxy(unsigned port) {
   // TODO(vtl): Allowing this case is a temporary hack. It'll set up a
   // |MessagePipe| with two proxy endpoints, which will then act as a proxy
   // (rather than trying to connect the two ends directly).
-  DLOG_IF(WARNING,
-          endpoints_[GetPeerPort(port)]->GetType() !=
-              MessagePipeEndpoint::kTypeLocal)
+  DLOG_IF(WARNING, endpoints_[GetPeerPort(port)]->GetType() !=
+                       MessagePipeEndpoint::kTypeLocal)
       << "Direct message pipe passing across multiple channels not yet "
          "implemented; will proxy";
 
   scoped_ptr<MessagePipeEndpoint> old_endpoint(endpoints_[port].Pass());
   scoped_refptr<ChannelEndpoint> channel_endpoint(new ChannelEndpoint(
-      this,
-      port,
-      static_cast<LocalMessagePipeEndpoint*>(old_endpoint.get())
-          ->message_queue()));
+      this, port, static_cast<LocalMessagePipeEndpoint*>(old_endpoint.get())
+                      ->message_queue()));
   endpoints_[port].reset(new ProxyMessagePipeEndpoint(channel_endpoint.get()));
   old_endpoint->Close();
 
@@ -280,7 +342,7 @@ MojoResult MessagePipe::AttachTransportsNoLock(
           (*transports)[i].CreateEquivalentDispatcherAndClose());
     } else {
       LOG(WARNING) << "Enqueueing null dispatcher";
-      dispatchers->push_back(scoped_refptr<Dispatcher>());
+      dispatchers->push_back(nullptr);
     }
   }
   message->SetDispatchers(dispatchers.Pass());
diff --git a/mojo/edk/system/message_pipe.h b/mojo/edk/system/message_pipe.h
index a52743d..b39e517 100644
--- a/mojo/edk/system/message_pipe.h
+++ b/mojo/edk/system/message_pipe.h
@@ -5,6 +5,7 @@
 #ifndef MOJO_EDK_SYSTEM_MESSAGE_PIPE_H_
 #define MOJO_EDK_SYSTEM_MESSAGE_PIPE_H_
 
+#include <stddef.h>
 #include <stdint.h>
 
 #include <vector>
@@ -13,6 +14,7 @@
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/synchronization/lock.h"
+#include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/system/dispatcher.h"
 #include "mojo/edk/system/handle_signals_state.h"
 #include "mojo/edk/system/memory.h"
@@ -25,6 +27,7 @@
 namespace mojo {
 namespace system {
 
+class Channel;
 class ChannelEndpoint;
 class Waiter;
 
@@ -55,6 +58,15 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipe
   // Gets the other port number (i.e., 0 -> 1, 1 -> 0).
   static unsigned GetPeerPort(unsigned port);
 
+  // Used by |MessagePipeDispatcher::Deserialize()|. Returns true on success (in
+  // which case, |*message_pipe|/|*port| are set appropriately) and false on
+  // failure (in which case |*message_pipe| may or may not be set to null).
+  static bool Deserialize(Channel* channel,
+                          const void* source,
+                          size_t size,
+                          scoped_refptr<MessagePipe>* message_pipe,
+                          unsigned* port);
+
   // Gets the type of the endpoint (used for assertions, etc.).
   MessagePipeEndpoint::Type GetType(unsigned port);
 
@@ -84,9 +96,18 @@ class MOJO_SYSTEM_IMPL_EXPORT MessagePipe
   void RemoveWaiter(unsigned port,
                     Waiter* waiter,
                     HandleSignalsState* signals_state);
-
-  // This is called by the dispatcher to convert a local endpoint to a proxy
-  // endpoint.
+  void StartSerialize(unsigned port,
+                      Channel* channel,
+                      size_t* max_size,
+                      size_t* max_platform_handles);
+  bool EndSerialize(unsigned port,
+                    Channel* channel,
+                    void* destination,
+                    size_t* actual_size,
+                    embedder::PlatformHandleVector* platform_handles);
+
+  // Used by |EndSerialize()|. TODO(vtl): Remove this (merge it into
+  // |EndSerialize()|).
   scoped_refptr<ChannelEndpoint> ConvertLocalToProxy(unsigned port);
 
   // This is used by |Channel| to enqueue messages (typically to a
diff --git a/mojo/edk/system/message_pipe_dispatcher.cc b/mojo/edk/system/message_pipe_dispatcher.cc
index 7db16e8..df861df 100644
--- a/mojo/edk/system/message_pipe_dispatcher.cc
+++ b/mojo/edk/system/message_pipe_dispatcher.cc
@@ -5,10 +5,7 @@
 #include "mojo/edk/system/message_pipe_dispatcher.h"
 
 #include "base/logging.h"
-#include "mojo/edk/system/channel.h"
-#include "mojo/edk/system/channel_endpoint.h"
-#include "mojo/edk/system/channel_endpoint_id.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/local_message_pipe_endpoint.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/message_pipe.h"
@@ -18,20 +15,8 @@
 namespace mojo {
 namespace system {
 
-namespace {
-
 const unsigned kInvalidPort = static_cast<unsigned>(-1);
 
-struct SerializedMessagePipeDispatcher {
-  // This is the endpoint ID on the receiving side, and should be a "remote ID".
-  // (The receiving side should have already have an endpoint attached and run
-  // via the |Channel|s. This endpoint will have both IDs assigned, so this ID
-  // is only needed to associated that endpoint with a particular dispatcher.)
-  ChannelEndpointId receiver_endpoint_id;
-};
-
-}  // namespace
-
 // MessagePipeDispatcher -------------------------------------------------------
 
 // static
@@ -103,26 +88,16 @@ scoped_refptr<MessagePipeDispatcher> MessagePipeDispatcher::Deserialize(
     Channel* channel,
     const void* source,
     size_t size) {
-  if (size != sizeof(SerializedMessagePipeDispatcher)) {
-    LOG(ERROR) << "Invalid serialized message pipe dispatcher";
-    return scoped_refptr<MessagePipeDispatcher>();
-  }
-
-  const SerializedMessagePipeDispatcher* s =
-      static_cast<const SerializedMessagePipeDispatcher*>(source);
-  scoped_refptr<MessagePipe> message_pipe =
-      channel->PassIncomingMessagePipe(s->receiver_endpoint_id);
-  if (!message_pipe.get()) {
-    LOG(ERROR) << "Failed to deserialize message pipe dispatcher (ID = "
-               << s->receiver_endpoint_id << ")";
-    return scoped_refptr<MessagePipeDispatcher>();
-  }
-
-  DVLOG(2) << "Deserializing message pipe dispatcher (new local ID = "
-           << s->receiver_endpoint_id << ")";
+  unsigned port = kInvalidPort;
+  scoped_refptr<MessagePipe> message_pipe;
+  if (!MessagePipe::Deserialize(channel, source, size, &message_pipe, &port))
+    return nullptr;
+  DCHECK(message_pipe.get());
+  DCHECK(port == 0 || port == 1);
+
   scoped_refptr<MessagePipeDispatcher> dispatcher(
       new MessagePipeDispatcher(MessagePipeDispatcher::kDefaultCreateOptions));
-  dispatcher->Init(message_pipe, 0);
+  dispatcher->Init(message_pipe, port);
   return dispatcher;
 }
 
@@ -173,16 +148,17 @@ MojoResult MessagePipeDispatcher::WriteMessageImplNoLock(
     uint32_t num_bytes,
     std::vector<DispatcherTransport>* transports,
     MojoWriteMessageFlags flags) {
-  DCHECK(!transports || (transports->size() > 0 &&
-                         transports->size() <= kMaxMessageNumHandles));
+  DCHECK(!transports ||
+         (transports->size() > 0 &&
+          transports->size() <= GetConfiguration().max_message_num_handles));
 
   lock().AssertAcquired();
 
-  if (num_bytes > kMaxMessageNumBytes)
+  if (num_bytes > GetConfiguration().max_message_num_bytes)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
-  return message_pipe_->WriteMessage(
-      port_, bytes, num_bytes, transports, flags);
+  return message_pipe_->WriteMessage(port_, bytes, num_bytes, transports,
+                                     flags);
 }
 
 MojoResult MessagePipeDispatcher::ReadMessageImplNoLock(
@@ -192,8 +168,8 @@ MojoResult MessagePipeDispatcher::ReadMessageImplNoLock(
     uint32_t* num_dispatchers,
     MojoReadMessageFlags flags) {
   lock().AssertAcquired();
-  return message_pipe_->ReadMessage(
-      port_, bytes, num_bytes, dispatchers, num_dispatchers, flags);
+  return message_pipe_->ReadMessage(port_, bytes, num_bytes, dispatchers,
+                                    num_dispatchers, flags);
 }
 
 HandleSignalsState MessagePipeDispatcher::GetHandleSignalsStateImplNoLock()
@@ -208,8 +184,8 @@ MojoResult MessagePipeDispatcher::AddWaiterImplNoLock(
     uint32_t context,
     HandleSignalsState* signals_state) {
   lock().AssertAcquired();
-  return message_pipe_->AddWaiter(
-      port_, waiter, signals, context, signals_state);
+  return message_pipe_->AddWaiter(port_, waiter, signals, context,
+                                  signals_state);
 }
 
 void MessagePipeDispatcher::RemoveWaiterImplNoLock(
@@ -220,36 +196,26 @@ void MessagePipeDispatcher::RemoveWaiterImplNoLock(
 }
 
 void MessagePipeDispatcher::StartSerializeImplNoLock(
-    Channel* /*channel*/,
+    Channel* channel,
     size_t* max_size,
     size_t* max_platform_handles) {
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
-  *max_size = sizeof(SerializedMessagePipeDispatcher);
-  *max_platform_handles = 0;
+  return message_pipe_->StartSerialize(port_, channel, max_size,
+                                       max_platform_handles);
 }
 
 bool MessagePipeDispatcher::EndSerializeAndCloseImplNoLock(
     Channel* channel,
     void* destination,
     size_t* actual_size,
-    embedder::PlatformHandleVector* /*platform_handles*/) {
+    embedder::PlatformHandleVector* platform_handles) {
   DCHECK(HasOneRef());  // Only one ref => no need to take the lock.
 
-  SerializedMessagePipeDispatcher* s =
-      static_cast<SerializedMessagePipeDispatcher*>(destination);
-
-  // Convert the local endpoint to a proxy endpoint (moving the message queue)
-  // and attach it to the channel.
-  s->receiver_endpoint_id = channel->AttachAndRunEndpoint(
-      message_pipe_->ConvertLocalToProxy(port_), false);
-  DVLOG(2) << "Serializing message pipe dispatcher (remote ID = "
-           << s->receiver_endpoint_id << ")";
-
+  bool rv = message_pipe_->EndSerialize(port_, channel, destination,
+                                        actual_size, platform_handles);
   message_pipe_ = nullptr;
   port_ = kInvalidPort;
-
-  *actual_size = sizeof(SerializedMessagePipeDispatcher);
-  return true;
+  return rv;
 }
 
 // MessagePipeDispatcherTransport ----------------------------------------------
diff --git a/mojo/edk/system/message_pipe_dispatcher_unittest.cc b/mojo/edk/system/message_pipe_dispatcher_unittest.cc
index ae651fa..8076a99 100644
--- a/mojo/edk/system/message_pipe_dispatcher_unittest.cc
+++ b/mojo/edk/system/message_pipe_dispatcher_unittest.cc
@@ -68,10 +68,8 @@ TEST(MessagePipeDispatcherTest, Basic) {
               d0->AddWaiter(&w, MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
     buffer[0] = 123456789;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d1->WriteMessage(UserPointer<const void>(buffer),
-                               kBufferSize,
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
     stopwatch.Start();
     EXPECT_EQ(MOJO_RESULT_OK, w.Wait(MOJO_DEADLINE_INDEFINITE, &context));
     EXPECT_EQ(1u, context);
@@ -99,9 +97,7 @@ TEST(MessagePipeDispatcherTest, Basic) {
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               d0->ReadMessage(UserPointer<void>(buffer),
-                              MakeUserPointer(&buffer_size),
-                              0,
-                              nullptr,
+                              MakeUserPointer(&buffer_size), 0, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(kBufferSize, buffer_size);
     EXPECT_EQ(123456789, buffer[0]);
@@ -157,8 +153,7 @@ TEST(MessagePipeDispatcherTest, InvalidParams) {
   // Huge buffer size.
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
             d0->WriteMessage(UserPointer<const void>(buffer),
-                             std::numeric_limits<uint32_t>::max(),
-                             nullptr,
+                             std::numeric_limits<uint32_t>::max(), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
@@ -186,26 +181,21 @@ TEST(MessagePipeDispatcherTest, InvalidParamsDeath) {
 
   // |WriteMessage|:
   // Null buffer with nonzero buffer size.
-  EXPECT_DEATH_IF_SUPPORTED(
-      d0->WriteMessage(
-          NullUserPointer(), 1, nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE),
-      kMemoryCheckFailedRegex);
+  EXPECT_DEATH_IF_SUPPORTED(d0->WriteMessage(NullUserPointer(), 1, nullptr,
+                                             MOJO_WRITE_MESSAGE_FLAG_NONE),
+                            kMemoryCheckFailedRegex);
 
   // |ReadMessage|:
   // Null buffer with nonzero buffer size.
   // First write something so that we actually have something to read.
   EXPECT_EQ(MOJO_RESULT_OK,
-            d1->WriteMessage(UserPointer<const void>("x"),
-                             1,
-                             nullptr,
+            d1->WriteMessage(UserPointer<const void>("x"), 1, nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   uint32_t buffer_size = 1;
-  EXPECT_DEATH_IF_SUPPORTED(d0->ReadMessage(NullUserPointer(),
-                                            MakeUserPointer(&buffer_size),
-                                            0,
-                                            nullptr,
-                                            MOJO_READ_MESSAGE_FLAG_NONE),
-                            kMemoryCheckFailedRegex);
+  EXPECT_DEATH_IF_SUPPORTED(
+      d0->ReadMessage(NullUserPointer(), MakeUserPointer(&buffer_size), 0,
+                      nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
+      kMemoryCheckFailedRegex);
 
   EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
   EXPECT_EQ(MOJO_RESULT_OK, d1->Close());
@@ -234,16 +224,12 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     // Write (twice) to |d1|.
     buffer[0] = 123456789;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d1->WriteMessage(UserPointer<const void>(buffer),
-                               kBufferSize,
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
     buffer[0] = 234567890;
     EXPECT_EQ(MOJO_RESULT_OK,
-              d1->WriteMessage(UserPointer<const void>(buffer),
-                               kBufferSize,
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              d1->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     // Try waiting for readable on |d0|; should fail (already satisfied).
     w.Init();
@@ -260,9 +246,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
               d1->ReadMessage(UserPointer<void>(buffer),
-                              MakeUserPointer(&buffer_size),
-                              0,
-                              nullptr,
+                              MakeUserPointer(&buffer_size), 0, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
 
     // Close |d1|.
@@ -281,9 +265,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               d0->ReadMessage(UserPointer<void>(buffer),
-                              MakeUserPointer(&buffer_size),
-                              0,
-                              nullptr,
+                              MakeUserPointer(&buffer_size), 0, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(kBufferSize, buffer_size);
     EXPECT_EQ(123456789, buffer[0]);
@@ -301,9 +283,7 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               d0->ReadMessage(UserPointer<void>(buffer),
-                              MakeUserPointer(&buffer_size),
-                              0,
-                              nullptr,
+                              MakeUserPointer(&buffer_size), 0, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(kBufferSize, buffer_size);
     EXPECT_EQ(234567890, buffer[0]);
@@ -330,18 +310,14 @@ TEST(MessagePipeDispatcherTest, BasicClosed) {
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
               d0->ReadMessage(UserPointer<void>(buffer),
-                              MakeUserPointer(&buffer_size),
-                              0,
-                              nullptr,
+                              MakeUserPointer(&buffer_size), 0, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
 
     // Try writing to |d0|; should fail (other end closed).
     buffer[0] = 345678901;
     EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-              d0->WriteMessage(UserPointer<const void>(buffer),
-                               kBufferSize,
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              d0->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     EXPECT_EQ(MOJO_RESULT_OK, d0->Close());
   }
@@ -378,24 +354,17 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) {
 
     // Wait for readable on |d1|, which will become readable after some time.
     {
-      test::WaiterThread thread(d1,
-                                MOJO_HANDLE_SIGNAL_READABLE,
-                                MOJO_DEADLINE_INDEFINITE,
-                                1,
-                                &did_wait,
-                                &result,
-                                &context,
-                                &hss);
+      test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
+                                MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result,
+                                &context, &hss);
       stopwatch.Start();
       thread.Start();
       base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
       // Wake it up by writing to |d0|.
       buffer[0] = 123456789;
       EXPECT_EQ(MOJO_RESULT_OK,
-                d0->WriteMessage(UserPointer<const void>(buffer),
-                                 kBufferSize,
-                                 nullptr,
-                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
+                d0->WriteMessage(UserPointer<const void>(buffer), kBufferSize,
+                                 nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
     }  // Joins the thread.
     elapsed = stopwatch.Elapsed();
     EXPECT_GT(elapsed, (2 - 1) * test::EpsilonTimeout());
@@ -410,14 +379,9 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) {
 
     // Now |d1| is already readable. Try waiting for it again.
     {
-      test::WaiterThread thread(d1,
-                                MOJO_HANDLE_SIGNAL_READABLE,
-                                MOJO_DEADLINE_INDEFINITE,
-                                2,
-                                &did_wait,
-                                &result,
-                                &context,
-                                &hss);
+      test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
+                                MOJO_DEADLINE_INDEFINITE, 2, &did_wait, &result,
+                                &context, &hss);
       stopwatch.Start();
       thread.Start();
     }  // Joins the thread.
@@ -434,9 +398,7 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) {
     buffer_size = kBufferSize;
     EXPECT_EQ(MOJO_RESULT_OK,
               d1->ReadMessage(UserPointer<void>(buffer),
-                              MakeUserPointer(&buffer_size),
-                              0,
-                              nullptr,
+                              MakeUserPointer(&buffer_size), 0, nullptr,
                               MOJO_READ_MESSAGE_FLAG_NONE));
     EXPECT_EQ(kBufferSize, buffer_size);
     EXPECT_EQ(123456789, buffer[0]);
@@ -444,14 +406,9 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) {
     // Wait for readable on |d1| and close |d0| after some time, which should
     // cancel that wait.
     {
-      test::WaiterThread thread(d1,
-                                MOJO_HANDLE_SIGNAL_READABLE,
-                                MOJO_DEADLINE_INDEFINITE,
-                                3,
-                                &did_wait,
-                                &result,
-                                &context,
-                                &hss);
+      test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
+                                MOJO_DEADLINE_INDEFINITE, 3, &did_wait, &result,
+                                &context, &hss);
       stopwatch.Start();
       thread.Start();
       base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -483,14 +440,9 @@ TEST(MessagePipeDispatcherTest, MAYBE_BasicThreaded) {
     // Wait for readable on |d1| and close |d1| after some time, which should
     // cancel that wait.
     {
-      test::WaiterThread thread(d1,
-                                MOJO_HANDLE_SIGNAL_READABLE,
-                                MOJO_DEADLINE_INDEFINITE,
-                                4,
-                                &did_wait,
-                                &result,
-                                &context,
-                                &hss);
+      test::WaiterThread thread(d1, MOJO_HANDLE_SIGNAL_READABLE,
+                                MOJO_DEADLINE_INDEFINITE, 4, &did_wait, &result,
+                                &context, &hss);
       stopwatch.Start();
       thread.Start();
       base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -546,18 +498,15 @@ class WriterThread : public base::SimpleThread {
           base::RandInt(1, static_cast<int>(kMaxMessageSize)));
       EXPECT_EQ(MOJO_RESULT_OK,
                 write_dispatcher_->WriteMessage(UserPointer<const void>(buffer),
-                                                bytes_to_write,
-                                                nullptr,
+                                                bytes_to_write, nullptr,
                                                 MOJO_WRITE_MESSAGE_FLAG_NONE));
       *bytes_written_ += bytes_to_write;
     }
 
     // Write one last "quit" message.
-    EXPECT_EQ(MOJO_RESULT_OK,
-              write_dispatcher_->WriteMessage(UserPointer<const void>("quit"),
-                                              4,
-                                              nullptr,
-                                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(MOJO_RESULT_OK, write_dispatcher_->WriteMessage(
+                                  UserPointer<const void>("quit"), 4, nullptr,
+                                  MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
 
   const scoped_refptr<Dispatcher> write_dispatcher_;
@@ -612,11 +561,9 @@ class ReaderThread : public base::SimpleThread {
       // Clear the buffer so that we can check the result.
       memset(buffer, 0, sizeof(buffer));
       uint32_t buffer_size = static_cast<uint32_t>(sizeof(buffer));
-      result = read_dispatcher_->ReadMessage(UserPointer<void>(buffer),
-                                             MakeUserPointer(&buffer_size),
-                                             0,
-                                             nullptr,
-                                             MOJO_READ_MESSAGE_FLAG_NONE);
+      result = read_dispatcher_->ReadMessage(
+          UserPointer<void>(buffer), MakeUserPointer(&buffer_size), 0, nullptr,
+          MOJO_READ_MESSAGE_FLAG_NONE);
       EXPECT_TRUE(result == MOJO_RESULT_OK || result == MOJO_RESULT_SHOULD_WAIT)
           << "result: " << result;
       // We're racing with others to read, so maybe we failed.
diff --git a/mojo/edk/system/message_pipe_perftest.cc b/mojo/edk/system/message_pipe_perftest.cc
index 9861e0b..9f1ac5d 100644
--- a/mojo/edk/system/message_pipe_perftest.cc
+++ b/mojo/edk/system/message_pipe_perftest.cc
@@ -47,31 +47,23 @@ class MultiprocessMessagePipePerfTest
 
  protected:
   void WriteWaitThenRead(scoped_refptr<MessagePipe> mp) {
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(payload_.data()),
-                              static_cast<uint32_t>(payload_.size()),
-                              nullptr,
+    CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(payload_.data()),
+                              static_cast<uint32_t>(payload_.size()), nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     HandleSignalsState hss;
     CHECK_EQ(test::WaitIfNecessary(mp, MOJO_HANDLE_SIGNAL_READABLE, &hss),
              MOJO_RESULT_OK);
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer_.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&read_buffer_[0]),
-                             MakeUserPointer(&read_buffer_size),
-                             nullptr,
-                             nullptr,
-                             MOJO_READ_MESSAGE_FLAG_NONE),
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer_[0]),
+                             MakeUserPointer(&read_buffer_size), nullptr,
+                             nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     CHECK_EQ(read_buffer_size, static_cast<uint32_t>(payload_.size()));
   }
 
   void SendQuitMessage(scoped_refptr<MessagePipe> mp) {
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(""),
-                              0,
-                              nullptr,
+    CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(""), 0, nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
@@ -81,8 +73,7 @@ class MultiprocessMessagePipePerfTest
     WriteWaitThenRead(mp);
 
     std::string test_name =
-        base::StringPrintf("IPC_Perf_%dx_%u",
-                           message_count_,
+        base::StringPrintf("IPC_Perf_%dx_%u", message_count_,
                            static_cast<unsigned>(message_size_));
     base::PerfTimeLogger logger(test_name.c_str());
 
@@ -127,11 +118,8 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(PingPongClient) {
     }
 
     uint32_t read_size = static_cast<uint32_t>(buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&buffer[0]),
-                             MakeUserPointer(&read_size),
-                             nullptr,
-                             nullptr,
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&buffer[0]),
+                             MakeUserPointer(&read_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
 
@@ -139,10 +127,8 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(PingPongClient) {
     if (0 == read_size)
       break;
 
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(&buffer[0]),
-                              static_cast<uint32_t>(read_size),
-                              nullptr,
+    CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(&buffer[0]),
+                              static_cast<uint32_t>(read_size), nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
diff --git a/mojo/edk/system/message_pipe_test_utils.cc b/mojo/edk/system/message_pipe_test_utils.cc
index 8f217ca..e5df26d 100644
--- a/mojo/edk/system/message_pipe_test_utils.cc
+++ b/mojo/edk/system/message_pipe_test_utils.cc
@@ -46,10 +46,8 @@ void ChannelThread::Start(embedder::ScopedPlatformHandle platform_handle,
   test_io_thread_.Start();
   test_io_thread_.PostTaskAndWait(
       FROM_HERE,
-      base::Bind(&ChannelThread::InitChannelOnIOThread,
-                 base::Unretained(this),
-                 base::Passed(&platform_handle),
-                 channel_endpoint));
+      base::Bind(&ChannelThread::InitChannelOnIOThread, base::Unretained(this),
+                 base::Passed(&platform_handle), channel_endpoint));
 }
 
 void ChannelThread::Stop() {
@@ -61,9 +59,8 @@ void ChannelThread::Stop() {
       base::PlatformThread::Sleep(base::TimeDelta::FromMilliseconds(20));
 
     test_io_thread_.PostTaskAndWait(
-        FROM_HERE,
-        base::Bind(&ChannelThread::ShutdownChannelOnIOThread,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&ChannelThread::ShutdownChannelOnIOThread,
+                              base::Unretained(this)));
   }
   test_io_thread_.Stop();
 }
diff --git a/mojo/edk/system/message_pipe_unittest.cc b/mojo/edk/system/message_pipe_unittest.cc
index dbffb4c..030084b 100644
--- a/mojo/edk/system/message_pipe_unittest.cc
+++ b/mojo/edk/system/message_pipe_unittest.cc
@@ -39,11 +39,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 456;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kBufferSize, buffer_size);
   EXPECT_EQ(123, buffer[0]);
@@ -54,21 +51,16 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 456;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp->ReadMessage(1,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(1, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Write from port 1 (to port 0).
   buffer[0] = 789012345;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(1,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(1, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Read from port 0.
@@ -76,11 +68,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 456;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(789012345, buffer[0]);
@@ -89,41 +78,30 @@ TEST(MessagePipeTest, Basic) {
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Write two messages from port 0 (to port 1).
   buffer[0] = 123456789;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(0, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   buffer[0] = 234567890;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(0, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Read from port 1 with buffer size 0 (should get the size of next message).
   // Also test that giving a null buffer is okay when the buffer size is 0.
   buffer_size = 0;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            mp->ReadMessage(1,
-                            NullUserPointer(),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
-                            MOJO_READ_MESSAGE_FLAG_NONE));
+            mp->ReadMessage(1, NullUserPointer(), MakeUserPointer(&buffer_size),
+                            0, nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
   // Read from port 1 with buffer size 1 (too small; should get the size of next
@@ -132,11 +110,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 456;
   buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            mp->ReadMessage(1,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(1, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(123, buffer[0]);
@@ -147,11 +122,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 456;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(1,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(1, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(123456789, buffer[0]);
@@ -162,11 +134,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 456;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(1,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(1, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(234567890, buffer[0]);
@@ -175,21 +144,16 @@ TEST(MessagePipeTest, Basic) {
   // Read again from port 1 -- it should be empty.
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp->ReadMessage(1,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(1, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Write from port 0 (to port 1).
   buffer[0] = 345678901;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(0, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Close port 0.
@@ -199,10 +163,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[0] = 456789012;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->WriteMessage(1,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(1, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Read from port 1; should still get message (even though port 0 was closed).
@@ -210,11 +172,8 @@ TEST(MessagePipeTest, Basic) {
   buffer[1] = 456;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(1,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(1, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(345678901, buffer[0]);
@@ -223,11 +182,8 @@ TEST(MessagePipeTest, Basic) {
   // Read again from port 1 -- it should be empty (and port 0 is closed).
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_FAILED_PRECONDITION,
-            mp->ReadMessage(1,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(1, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
 
   mp->Close(1);
@@ -244,22 +200,15 @@ TEST(MessagePipeTest, CloseWithQueuedIncomingMessages) {
   for (int32_t i = 0; i < 5; i++) {
     buffer[0] = i;
     EXPECT_EQ(MOJO_RESULT_OK,
-              mp->WriteMessage(1,
-                               UserPointer<const void>(buffer),
-                               kBufferSize,
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              mp->WriteMessage(1, UserPointer<const void>(buffer), kBufferSize,
+                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
 
   // Port 0 shouldn't be empty.
   buffer_size = 0;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            mp->ReadMessage(0,
-                            NullUserPointer(),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
-                            MOJO_READ_MESSAGE_FLAG_NONE));
+            mp->ReadMessage(0, NullUserPointer(), MakeUserPointer(&buffer_size),
+                            0, nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(kBufferSize, buffer_size);
 
   // Close port 0 first, which should have outstanding (incoming) messages.
@@ -278,41 +227,30 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer[0] = 789012345;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(1,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(1, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Read/discard from port 0 (no buffer); get size.
   buffer_size = 0;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            mp->ReadMessage(0,
-                            NullUserPointer(),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
-                            MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
+            mp->ReadMessage(0, NullUserPointer(), MakeUserPointer(&buffer_size),
+                            0, nullptr, MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // Write from port 1 (to port 0).
   buffer[0] = 890123456;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(1,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(1, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Read from port 0 (buffer big enough).
@@ -320,11 +258,8 @@ TEST(MessagePipeTest, DiscardMode) {
   buffer[1] = 456;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
   EXPECT_EQ(890123456, buffer[0]);
@@ -333,72 +268,52 @@ TEST(MessagePipeTest, DiscardMode) {
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // Write from port 1 (to port 0).
   buffer[0] = 901234567;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(1,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(1, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Read/discard from port 0 (buffer too small); get size.
   buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
   EXPECT_EQ(static_cast<uint32_t>(sizeof(buffer[0])), buffer_size);
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // Write from port 1 (to port 0).
   buffer[0] = 123456789;
   buffer[1] = 0;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(1,
-                             UserPointer<const void>(buffer),
-                             static_cast<uint32_t>(sizeof(buffer[0])),
-                             nullptr,
+            mp->WriteMessage(1, UserPointer<const void>(buffer),
+                             static_cast<uint32_t>(sizeof(buffer[0])), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Discard from port 0.
   buffer_size = 1;
   EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            mp->ReadMessage(0,
-                            NullUserPointer(),
-                            NullUserPointer(),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, NullUserPointer(), NullUserPointer(), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   // Read again from port 0 -- it should be empty.
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp->ReadMessage(0,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_MAY_DISCARD));
 
   mp->Close(0);
@@ -424,13 +339,10 @@ TEST(MessagePipeTest, BasicWaiting) {
             hss.satisfiable_signals);
   waiter.Init();
   hss = HandleSignalsState();
-  EXPECT_EQ(
-      MOJO_RESULT_ALREADY_EXISTS,
-      mp->AddWaiter(0,
-                    &waiter,
-                    MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-                    0,
-                    &hss));
+  EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+            mp->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE |
+                                          MOJO_HANDLE_SIGNAL_WRITABLE,
+                          0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_WRITABLE, hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
@@ -449,11 +361,8 @@ TEST(MessagePipeTest, BasicWaiting) {
   // Write from port 0 (to port 1), to make port 1 readable.
   buffer[0] = 123456789;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(buffer),
-                             kBufferSize,
-                             nullptr,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+            mp->WriteMessage(0, UserPointer<const void>(buffer), kBufferSize,
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Port 1 should already be readable now.
   waiter.Init();
@@ -466,13 +375,10 @@ TEST(MessagePipeTest, BasicWaiting) {
             hss.satisfiable_signals);
   waiter.Init();
   hss = HandleSignalsState();
-  EXPECT_EQ(
-      MOJO_RESULT_ALREADY_EXISTS,
-      mp->AddWaiter(1,
-                    &waiter,
-                    MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
-                    0,
-                    &hss));
+  EXPECT_EQ(MOJO_RESULT_ALREADY_EXISTS,
+            mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE |
+                                          MOJO_HANDLE_SIGNAL_WRITABLE,
+                          0, &hss));
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
@@ -510,11 +416,8 @@ TEST(MessagePipeTest, BasicWaiting) {
   buffer[0] = 0;
   buffer_size = kBufferSize;
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(1,
-                            UserPointer<void>(buffer),
-                            MakeUserPointer(&buffer_size),
-                            0,
-                            nullptr,
+            mp->ReadMessage(1, UserPointer<void>(buffer),
+                            MakeUserPointer(&buffer_size), 0, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(123456789, buffer[0]);
 
@@ -543,18 +446,15 @@ TEST(MessagePipeTest, ThreadedWaiting) {
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(
-                  1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1, nullptr));
+              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 1,
+                            nullptr));
     thread.Start();
 
     buffer[0] = 123456789;
     // Write from port 0 (to port 1), which should wake up the waiter.
     EXPECT_EQ(MOJO_RESULT_OK,
-              mp->WriteMessage(0,
-                               UserPointer<const void>(buffer),
-                               kBufferSize,
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+              mp->WriteMessage(0, UserPointer<const void>(buffer), kBufferSize,
+                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
     HandleSignalsState hss;
     mp->RemoveWaiter(1, thread.waiter(), &hss);
@@ -577,8 +477,8 @@ TEST(MessagePipeTest, ThreadedWaiting) {
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(
-                  1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2, nullptr));
+              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 2,
+                            nullptr));
     thread.Start();
 
     // Close port 1 first -- this should result in the waiter being cancelled.
@@ -600,8 +500,8 @@ TEST(MessagePipeTest, ThreadedWaiting) {
 
     thread.waiter()->Init();
     ASSERT_EQ(MOJO_RESULT_OK,
-              mp->AddWaiter(
-                  1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3, nullptr));
+              mp->AddWaiter(1, thread.waiter(), MOJO_HANDLE_SIGNAL_READABLE, 3,
+                            nullptr));
     thread.Start();
 
     // Close port 0 first -- this should wake the waiter up, since port 1 will
diff --git a/mojo/edk/system/multiprocess_message_pipe_unittest.cc b/mojo/edk/system/multiprocess_message_pipe_unittest.cc
index 2f22d67..ab2e75c 100644
--- a/mojo/edk/system/multiprocess_message_pipe_unittest.cc
+++ b/mojo/edk/system/multiprocess_message_pipe_unittest.cc
@@ -72,12 +72,9 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
 
     std::string read_buffer(1000, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&read_buffer[0]),
-                             MakeUserPointer(&read_buffer_size),
-                             nullptr,
-                             nullptr,
-                             MOJO_READ_MESSAGE_FLAG_NONE),
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                             MakeUserPointer(&read_buffer_size), nullptr,
+                             nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
     VLOG(2) << "Child got: " << read_buffer;
@@ -88,11 +85,9 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(EchoEcho) {
     }
 
     std::string write_buffer = read_buffer + read_buffer;
-    CHECK_EQ(mp->WriteMessage(0,
-                              UserPointer<const void>(write_buffer.data()),
+    CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(write_buffer.data()),
                               static_cast<uint32_t>(write_buffer.size()),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE),
+                              nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
   }
 
@@ -110,10 +105,8 @@ TEST_F(MultiprocessMessagePipeTest, Basic) {
 
   std::string hello("hello");
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(hello.data()),
-                             static_cast<uint32_t>(hello.size()),
-                             nullptr,
+            mp->WriteMessage(0, UserPointer<const void>(hello.data()),
+                             static_cast<uint32_t>(hello.size()), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   HandleSignalsState hss;
@@ -127,11 +120,8 @@ TEST_F(MultiprocessMessagePipeTest, Basic) {
 
   std::string read_buffer(1000, '\0');
   uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&read_buffer_size),
-                           nullptr,
-                           nullptr,
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&read_buffer_size), nullptr, nullptr,
                            MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(read_buffer_size);
@@ -157,20 +147,16 @@ TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
   for (size_t i = 0; i < kNumMessages; i++) {
     std::string write_buffer(i, 'A' + (i % 26));
     EXPECT_EQ(MOJO_RESULT_OK,
-              mp->WriteMessage(0,
-                               UserPointer<const void>(write_buffer.data()),
+              mp->WriteMessage(0, UserPointer<const void>(write_buffer.data()),
                                static_cast<uint32_t>(write_buffer.size()),
-                               nullptr,
-                               MOJO_WRITE_MESSAGE_FLAG_NONE));
+                               nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   }
 
   const std::string quitquitquit("quitquitquit");
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(quitquitquit.data()),
+            mp->WriteMessage(0, UserPointer<const void>(quitquitquit.data()),
                              static_cast<uint32_t>(quitquitquit.size()),
-                             nullptr,
-                             MOJO_WRITE_MESSAGE_FLAG_NONE));
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   for (size_t i = 0; i < kNumMessages; i++) {
     HandleSignalsState hss;
@@ -184,12 +170,9 @@ TEST_F(MultiprocessMessagePipeTest, QueueMessages) {
 
     std::string read_buffer(kNumMessages * 2, '\0');
     uint32_t read_buffer_size = static_cast<uint32_t>(read_buffer.size());
-    CHECK_EQ(mp->ReadMessage(0,
-                             UserPointer<void>(&read_buffer[0]),
-                             MakeUserPointer(&read_buffer_size),
-                             nullptr,
-                             nullptr,
-                             MOJO_READ_MESSAGE_FLAG_NONE),
+    CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                             MakeUserPointer(&read_buffer_size), nullptr,
+                             nullptr, MOJO_READ_MESSAGE_FLAG_NONE),
              MOJO_RESULT_OK);
     read_buffer.resize(read_buffer_size);
 
@@ -236,12 +219,9 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   DispatcherVector dispatchers;
   uint32_t num_dispatchers = 10;  // Maximum number to receive.
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           &dispatchers,
-                           &num_dispatchers,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), &dispatchers,
+                           &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(num_bytes);
   CHECK_EQ(read_buffer, std::string("go 1"));
@@ -269,10 +249,8 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
 
   // And send a message to signal that we've written stuff.
   const std::string go2("go 2");
-  CHECK_EQ(mp->WriteMessage(0,
-                            UserPointer<const void>(&go2[0]),
-                            static_cast<uint32_t>(go2.size()),
-                            nullptr,
+  CHECK_EQ(mp->WriteMessage(0, UserPointer<const void>(&go2[0]),
+                            static_cast<uint32_t>(go2.size()), nullptr,
                             MOJO_WRITE_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
 
@@ -287,11 +265,8 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckSharedBuffer) {
 
   read_buffer = std::string(100, '\0');
   num_bytes = static_cast<uint32_t>(read_buffer.size());
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           nullptr,
-                           nullptr,
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), nullptr, nullptr,
                            MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   read_buffer.resize(num_bytes);
@@ -322,12 +297,10 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
 
   // Make a shared buffer.
   scoped_refptr<SharedBufferDispatcher> dispatcher;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher));
+  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+                                platform_support(),
+                                SharedBufferDispatcher::kDefaultCreateOptions,
+                                100, &dispatcher));
   ASSERT_TRUE(dispatcher.get());
 
   // Make a mapping.
@@ -347,10 +320,8 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
   std::vector<DispatcherTransport> transports;
   transports.push_back(transport);
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&go1[0]),
-                             static_cast<uint32_t>(go1.size()),
-                             &transports,
+            mp->WriteMessage(0, UserPointer<const void>(&go1[0]),
+                             static_cast<uint32_t>(go1.size()), &transports,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   transport.End();
 
@@ -367,11 +338,8 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
   std::string read_buffer(100, '\0');
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->ReadMessage(0,
-                            UserPointer<void>(&read_buffer[0]),
-                            MakeUserPointer(&num_bytes),
-                            nullptr,
-                            nullptr,
+            mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                            MakeUserPointer(&num_bytes), nullptr, nullptr,
                             MOJO_READ_MESSAGE_FLAG_NONE));
   read_buffer.resize(num_bytes);
   EXPECT_EQ(std::string("go 2"), read_buffer);
@@ -388,10 +356,8 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_SharedBufferPassing) {
   // And send a message to signal that we've written stuff.
   const std::string go3("go 3");
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&go3[0]),
-                             static_cast<uint32_t>(go3.size()),
-                             nullptr,
+            mp->WriteMessage(0, UserPointer<const void>(&go3[0]),
+                             static_cast<uint32_t>(go3.size()), nullptr,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait for |mp| to become readable, which should fail.
@@ -428,12 +394,9 @@ MOJO_MULTIPROCESS_TEST_CHILD_MAIN(CheckPlatformHandleFile) {
   uint32_t num_bytes = static_cast<uint32_t>(read_buffer.size());
   DispatcherVector dispatchers;
   uint32_t num_dispatchers = 10;  // Maximum number to receive.
-  CHECK_EQ(mp->ReadMessage(0,
-                           UserPointer<void>(&read_buffer[0]),
-                           MakeUserPointer(&num_bytes),
-                           &dispatchers,
-                           &num_dispatchers,
-                           MOJO_READ_MESSAGE_FLAG_NONE),
+  CHECK_EQ(mp->ReadMessage(0, UserPointer<void>(&read_buffer[0]),
+                           MakeUserPointer(&num_bytes), &dispatchers,
+                           &num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE),
            MOJO_RESULT_OK);
   mp->Close(0);
 
@@ -496,10 +459,8 @@ TEST_F(MultiprocessMessagePipeTest, MAYBE_PlatformHandlePassing) {
   std::vector<DispatcherTransport> transports;
   transports.push_back(transport);
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp->WriteMessage(0,
-                             UserPointer<const void>(&hello[0]),
-                             static_cast<uint32_t>(hello.size()),
-                             &transports,
+            mp->WriteMessage(0, UserPointer<const void>(&hello[0]),
+                             static_cast<uint32_t>(hello.size()), &transports,
                              MOJO_WRITE_MESSAGE_FLAG_NONE));
   transport.End();
 
diff --git a/mojo/edk/system/options_validation.h b/mojo/edk/system/options_validation.h
index 4772508..9724e38 100644
--- a/mojo/edk/system/options_validation.h
+++ b/mojo/edk/system/options_validation.h
@@ -18,7 +18,6 @@
 
 #include "base/logging.h"
 #include "base/macros.h"
-#include "mojo/edk/system/constants.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/system_impl_export.h"
 #include "mojo/public/c/system/types.h"
diff --git a/mojo/edk/system/platform_handle_dispatcher.cc b/mojo/edk/system/platform_handle_dispatcher.cc
index a6072cf..f064c67 100644
--- a/mojo/edk/system/platform_handle_dispatcher.cc
+++ b/mojo/edk/system/platform_handle_dispatcher.cc
@@ -43,7 +43,7 @@ scoped_refptr<PlatformHandleDispatcher> PlatformHandleDispatcher::Deserialize(
     embedder::PlatformHandleVector* platform_handles) {
   if (size != sizeof(SerializedPlatformHandleDispatcher)) {
     LOG(ERROR) << "Invalid serialized platform handle dispatcher (bad size)";
-    return scoped_refptr<PlatformHandleDispatcher>();
+    return nullptr;
   }
 
   const SerializedPlatformHandleDispatcher* serialization =
@@ -58,7 +58,7 @@ scoped_refptr<PlatformHandleDispatcher> PlatformHandleDispatcher::Deserialize(
         platform_handle_index >= platform_handles->size()) {
       LOG(ERROR)
           << "Invalid serialized platform handle dispatcher (missing handles)";
-      return scoped_refptr<PlatformHandleDispatcher>();
+      return nullptr;
     }
 
     // We take ownership of the handle, so we have to invalidate the one in
diff --git a/mojo/edk/system/raw_channel.cc b/mojo/edk/system/raw_channel.cc
index 0bfe104..4331166 100644
--- a/mojo/edk/system/raw_channel.cc
+++ b/mojo/edk/system/raw_channel.cc
@@ -133,9 +133,8 @@ void RawChannel::WriteBuffer::GetBuffers(std::vector<Buffer>* buffers) const {
   // attached.
 
   // Write from both buffers.
-  DCHECK_EQ(
-      bytes_to_write,
-      message->main_buffer_size() - data_offset_ + transport_data_buffer_size);
+  DCHECK_EQ(bytes_to_write, message->main_buffer_size() - data_offset_ +
+                                transport_data_buffer_size);
   Buffer buffer1 = {
       static_cast<const char*>(message->main_buffer()) + data_offset_,
       message->main_buffer_size() - data_offset_};
@@ -195,11 +194,9 @@ bool RawChannel::Init(Delegate* delegate) {
   if (io_result != IO_PENDING) {
     // This will notify the delegate about the read failure. Although we're on
     // the I/O thread, don't call it in the nested context.
-    message_loop_for_io_->PostTask(FROM_HERE,
-                                   base::Bind(&RawChannel::OnReadCompleted,
-                                              weak_ptr_factory_.GetWeakPtr(),
-                                              io_result,
-                                              0));
+    message_loop_for_io_->PostTask(
+        FROM_HERE, base::Bind(&RawChannel::OnReadCompleted,
+                              weak_ptr_factory_.GetWeakPtr(), io_result, 0));
   }
 
   // ScheduleRead() failure is treated as a read failure (by notifying the
@@ -246,15 +243,15 @@ bool RawChannel::WriteMessage(scoped_ptr<MessageInTransit> message) {
   if (io_result == IO_PENDING)
     return true;
 
-  bool result = OnWriteCompletedNoLock(
-      io_result, platform_handles_written, bytes_written);
+  bool result = OnWriteCompletedNoLock(io_result, platform_handles_written,
+                                       bytes_written);
   if (!result) {
     // Even if we're on the I/O thread, don't call |OnError()| in the nested
     // context.
-    message_loop_for_io_->PostTask(FROM_HERE,
-                                   base::Bind(&RawChannel::CallOnError,
-                                              weak_ptr_factory_.GetWeakPtr(),
-                                              Delegate::ERROR_WRITE));
+    message_loop_for_io_->PostTask(
+        FROM_HERE,
+        base::Bind(&RawChannel::CallOnError, weak_ptr_factory_.GetWeakPtr(),
+                   Delegate::ERROR_WRITE));
   }
 
   return result;
@@ -312,8 +309,7 @@ void RawChannel::OnReadCompleted(IOResult io_result, size_t bytes_read) {
     // TODO(vtl): Validate that |message_size| is sane.
     while (remaining_bytes > 0 && MessageInTransit::GetNextMessageSize(
                                       &read_buffer_->buffer_[read_buffer_start],
-                                      remaining_bytes,
-                                      &message_size) &&
+                                      remaining_bytes, &message_size) &&
            remaining_bytes >= message_size) {
       MessageInTransit::View message_view(
           message_size, &read_buffer_->buffer_[read_buffer_start]);
@@ -341,8 +337,7 @@ void RawChannel::OnReadCompleted(IOResult io_result, size_t bytes_read) {
           size_t num_platform_handles;
           const void* platform_handle_table;
           TransportData::GetPlatformHandleTable(
-              message_view.transport_data_buffer(),
-              &num_platform_handles,
+              message_view.transport_data_buffer(), &num_platform_handles,
               &platform_handle_table);
 
           if (num_platform_handles > 0) {
@@ -383,8 +378,7 @@ void RawChannel::OnReadCompleted(IOResult io_result, size_t bytes_read) {
       read_buffer_->num_valid_bytes_ = remaining_bytes;
       if (read_buffer_->num_valid_bytes_ > 0) {
         memmove(&read_buffer_->buffer_[0],
-                &read_buffer_->buffer_[read_buffer_start],
-                remaining_bytes);
+                &read_buffer_->buffer_[read_buffer_start], remaining_bytes);
       }
       read_buffer_start = 0;
     }
@@ -433,8 +427,8 @@ void RawChannel::OnWriteCompleted(IOResult io_result,
       return;
     }
 
-    did_fail = !OnWriteCompletedNoLock(
-                   io_result, platform_handles_written, bytes_written);
+    did_fail = !OnWriteCompletedNoLock(io_result, platform_handles_written,
+                                       bytes_written);
   }
 
   if (did_fail)
diff --git a/mojo/edk/system/raw_channel.h b/mojo/edk/system/raw_channel.h
index 1a077ef..62e13ff 100644
--- a/mojo/edk/system/raw_channel.h
+++ b/mojo/edk/system/raw_channel.h
@@ -14,7 +14,6 @@
 #include "base/synchronization/lock.h"
 #include "mojo/edk/embedder/platform_handle_vector.h"
 #include "mojo/edk/embedder/scoped_platform_handle.h"
-#include "mojo/edk/system/constants.h"
 #include "mojo/edk/system/message_in_transit.h"
 #include "mojo/edk/system/system_impl_export.h"
 
diff --git a/mojo/edk/system/raw_channel_posix.cc b/mojo/edk/system/raw_channel_posix.cc
index 45d93e86..71ec02f 100644
--- a/mojo/edk/system/raw_channel_posix.cc
+++ b/mojo/edk/system/raw_channel_posix.cc
@@ -135,8 +135,7 @@ void RawChannelPosix::EnqueueMessageNoLock(
            i += embedder::kPlatformChannelMaxNumHandles) {
         scoped_ptr<MessageInTransit> fd_message(new MessageInTransit(
             MessageInTransit::kTypeRawChannel,
-            MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles,
-            0,
+            MessageInTransit::kSubtypeRawChannelPosixExtraPlatformHandles, 0,
             nullptr));
         embedder::ScopedPlatformHandleVectorPtr fds(
             new embedder::PlatformHandleVector(
@@ -253,8 +252,8 @@ RawChannel::IOResult RawChannelPosix::WriteNoLock(
     DCHECK(!buffers.empty());
 
     if (buffers.size() == 1) {
-      write_result = embedder::PlatformChannelWrite(
-          fd_.get(), buffers[0].addr, buffers[0].size);
+      write_result = embedder::PlatformChannelWrite(fd_.get(), buffers[0].addr,
+                                                    buffers[0].size);
     } else {
       const size_t kMaxBufferCount = 10;
       iovec iov[kMaxBufferCount];
@@ -302,11 +301,8 @@ RawChannel::IOResult RawChannelPosix::ScheduleWriteNoLock() {
   }
 
   if (message_loop_for_io()->WatchFileDescriptor(
-          fd_.get().fd,
-          false,
-          base::MessageLoopForIO::WATCH_WRITE,
-          write_watcher_.get(),
-          this)) {
+          fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE,
+          write_watcher_.get(), this)) {
     pending_write_ = true;
     return IO_PENDING;
   }
@@ -323,11 +319,8 @@ bool RawChannelPosix::OnInit() {
   write_watcher_.reset(new base::MessageLoopForIO::FileDescriptorWatcher());
 
   if (!message_loop_for_io()->WatchFileDescriptor(
-          fd_.get().fd,
-          true,
-          base::MessageLoopForIO::WATCH_READ,
-          read_watcher_.get(),
-          this)) {
+          fd_.get().fd, true, base::MessageLoopForIO::WATCH_READ,
+          read_watcher_.get(), this)) {
     // TODO(vtl): I'm not sure |WatchFileDescriptor()| actually fails cleanly
     // (in the sense of returning the message loop's state to what it was before
     // it was called).
@@ -421,7 +414,7 @@ RawChannel::IOResult RawChannelPosix::ReadImpl(size_t* bytes_read) {
     // then received the message data plus the first set of handles for the next
     // message in the subsequent |recvmsg()|.)
     if (read_platform_handles_.size() >
-        (TransportData::kMaxPlatformHandles +
+        (TransportData::GetMaxPlatformHandles() +
          embedder::kPlatformChannelMaxNumHandles)) {
       LOG(ERROR) << "Received too many platform handles";
       embedder::CloseAllPlatformHandles(&read_platform_handles_);
@@ -455,11 +448,8 @@ void RawChannelPosix::WaitToWrite() {
   DCHECK(write_watcher_);
 
   if (!message_loop_for_io()->WatchFileDescriptor(
-          fd_.get().fd,
-          false,
-          base::MessageLoopForIO::WATCH_WRITE,
-          write_watcher_.get(),
-          this)) {
+          fd_.get().fd, false, base::MessageLoopForIO::WATCH_WRITE,
+          write_watcher_.get(), this)) {
     {
       base::AutoLock locker(write_lock());
 
diff --git a/mojo/edk/system/raw_channel_unittest.cc b/mojo/edk/system/raw_channel_unittest.cc
index 9ee937d..7717f49 100644
--- a/mojo/edk/system/raw_channel_unittest.cc
+++ b/mojo/edk/system/raw_channel_unittest.cc
@@ -41,8 +41,7 @@ scoped_ptr<MessageInTransit> MakeTestMessage(uint32_t num_bytes) {
   return make_scoped_ptr(
       new MessageInTransit(MessageInTransit::kTypeMessagePipeEndpoint,
                            MessageInTransit::kSubtypeMessagePipeEndpointData,
-                           num_bytes,
-                           bytes.empty() ? nullptr : &bytes[0]));
+                           num_bytes, bytes.empty() ? nullptr : &bytes[0]));
 }
 
 bool CheckMessageData(const void* bytes, uint32_t num_bytes) {
@@ -63,8 +62,8 @@ bool WriteTestMessageToHandle(const embedder::PlatformHandle& handle,
   scoped_ptr<MessageInTransit> message(MakeTestMessage(num_bytes));
 
   size_t write_size = 0;
-  mojo::test::BlockingWrite(
-      handle, message->main_buffer(), message->main_buffer_size(), &write_size);
+  mojo::test::BlockingWrite(handle, message->main_buffer(),
+                            message->main_buffer_size(), &write_size);
   return write_size == message->main_buffer_size();
 }
 
@@ -135,8 +134,8 @@ class TestMessageReaderAndChecker {
 
     for (size_t i = 0; i < kMessageReaderMaxPollIterations;) {
       size_t read_size = 0;
-      CHECK(mojo::test::NonBlockingRead(
-          handle_, buffer, sizeof(buffer), &read_size));
+      CHECK(mojo::test::NonBlockingRead(handle_, buffer, sizeof(buffer),
+                                        &read_size));
 
       // Append newly-read data to |bytes_|.
       bytes_.insert(bytes_.end(), buffer, buffer + read_size);
@@ -144,8 +143,7 @@ class TestMessageReaderAndChecker {
       // If we have the header....
       size_t message_size;
       if (MessageInTransit::GetNextMessageSize(
-              bytes_.empty() ? nullptr : &bytes_[0],
-              bytes_.size(),
+              bytes_.empty() ? nullptr : &bytes_[0], bytes_.size(),
               &message_size)) {
         // If we've read the whole message....
         if (bytes_.size() >= message_size) {
@@ -378,16 +376,14 @@ TEST_F(RawChannelTest, WriteMessageAndOnReadMessage) {
   WriteOnlyRawChannelDelegate writer_delegate;
   scoped_ptr<RawChannel> writer_rc(RawChannel::Create(handles[0].Pass()));
   io_thread()->PostTaskAndWait(FROM_HERE,
-                               base::Bind(&InitOnIOThread,
-                                          writer_rc.get(),
+                               base::Bind(&InitOnIOThread, writer_rc.get(),
                                           base::Unretained(&writer_delegate)));
 
   ReadCountdownRawChannelDelegate reader_delegate(kNumWriterThreads *
                                                   kNumWriteMessagesPerThread);
   scoped_ptr<RawChannel> reader_rc(RawChannel::Create(handles[1].Pass()));
   io_thread()->PostTaskAndWait(FROM_HERE,
-                               base::Bind(&InitOnIOThread,
-                                          reader_rc.get(),
+                               base::Bind(&InitOnIOThread, reader_rc.get(),
                                           base::Unretained(&reader_delegate)));
 
   {
diff --git a/mojo/edk/system/raw_channel_win.cc b/mojo/edk/system/raw_channel_win.cc
index 98380a9..27b9ccf 100644
--- a/mojo/edk/system/raw_channel_win.cc
+++ b/mojo/edk/system/raw_channel_win.cc
@@ -371,11 +371,9 @@ RawChannel::IOResult RawChannelWin::Read(size_t* bytes_read) {
   size_t bytes_to_read = 0;
   read_buffer()->GetBuffer(&buffer, &bytes_to_read);
 
-  BOOL result = ReadFile(io_handler_->handle(),
-                         buffer,
-                         static_cast<DWORD>(bytes_to_read),
-                         nullptr,
-                         &io_handler_->read_context()->overlapped);
+  BOOL result =
+      ReadFile(io_handler_->handle(), buffer, static_cast<DWORD>(bytes_to_read),
+               nullptr, &io_handler_->read_context()->overlapped);
   if (!result) {
     DWORD error = GetLastError();
     if (error == ERROR_BROKEN_PIPE)
@@ -388,11 +386,9 @@ RawChannel::IOResult RawChannelWin::Read(size_t* bytes_read) {
 
   if (result && skip_completion_port_on_success_) {
     DWORD bytes_read_dword = 0;
-    BOOL get_size_result =
-        GetOverlappedResult(io_handler_->handle(),
-                            &io_handler_->read_context()->overlapped,
-                            &bytes_read_dword,
-                            FALSE);
+    BOOL get_size_result = GetOverlappedResult(
+        io_handler_->handle(), &io_handler_->read_context()->overlapped,
+        &bytes_read_dword, FALSE);
     DPCHECK(get_size_result);
     *bytes_read = bytes_read_dword;
     return IO_SUCCEEDED;
@@ -426,12 +422,10 @@ RawChannel::IOResult RawChannelWin::ScheduleRead() {
     // |io_handler_| won't go away before the task is run, so it is safe to use
     // |base::Unretained()|.
     message_loop_for_io()->PostTask(
-        FROM_HERE,
-        base::Bind(&RawChannelIOHandler::OnIOCompleted,
-                   base::Unretained(io_handler_),
-                   base::Unretained(io_handler_->read_context()),
-                   static_cast<DWORD>(bytes_read),
-                   ERROR_SUCCESS));
+        FROM_HERE, base::Bind(&RawChannelIOHandler::OnIOCompleted,
+                              base::Unretained(io_handler_),
+                              base::Unretained(io_handler_->read_context()),
+                              static_cast<DWORD>(bytes_read), ERROR_SUCCESS));
     return IO_PENDING;
   }
 
@@ -465,11 +459,10 @@ RawChannel::IOResult RawChannelWin::WriteNoLock(
 
   // TODO(yzshen): Handle multi-segment writes more efficiently.
   DWORD bytes_written_dword = 0;
-  BOOL result = WriteFile(io_handler_->handle(),
-                          buffers[0].addr,
-                          static_cast<DWORD>(buffers[0].size),
-                          &bytes_written_dword,
-                          &io_handler_->write_context_no_lock()->overlapped);
+  BOOL result =
+      WriteFile(io_handler_->handle(), buffers[0].addr,
+                static_cast<DWORD>(buffers[0].size), &bytes_written_dword,
+                &io_handler_->write_context_no_lock()->overlapped);
   if (!result) {
     DWORD error = GetLastError();
     if (error == ERROR_BROKEN_PIPE)
@@ -521,8 +514,7 @@ RawChannel::IOResult RawChannelWin::ScheduleWriteNoLock() {
         base::Bind(&RawChannelIOHandler::OnIOCompleted,
                    base::Unretained(io_handler_),
                    base::Unretained(io_handler_->write_context_no_lock()),
-                   static_cast<DWORD>(bytes_written),
-                   ERROR_SUCCESS));
+                   static_cast<DWORD>(bytes_written), ERROR_SUCCESS));
     return IO_PENDING;
   }
 
diff --git a/mojo/edk/system/remote_message_pipe_unittest.cc b/mojo/edk/system/remote_message_pipe_unittest.cc
index d3a95df..e3a320e 100644
--- a/mojo/edk/system/remote_message_pipe_unittest.cc
+++ b/mojo/edk/system/remote_message_pipe_unittest.cc
@@ -48,16 +48,14 @@ class RemoteMessagePipeTest : public testing::Test {
 
   void SetUp() override {
     io_thread_.PostTaskAndWait(
-        FROM_HERE,
-        base::Bind(&RemoteMessagePipeTest::SetUpOnIOThread,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&RemoteMessagePipeTest::SetUpOnIOThread,
+                              base::Unretained(this)));
   }
 
   void TearDown() override {
     io_thread_.PostTaskAndWait(
-        FROM_HERE,
-        base::Bind(&RemoteMessagePipeTest::TearDownOnIOThread,
-                   base::Unretained(this)));
+        FROM_HERE, base::Bind(&RemoteMessagePipeTest::TearDownOnIOThread,
+                              base::Unretained(this)));
   }
 
  protected:
@@ -69,9 +67,7 @@ class RemoteMessagePipeTest : public testing::Test {
     io_thread_.PostTaskAndWait(
         FROM_HERE,
         base::Bind(&RemoteMessagePipeTest::BootstrapChannelEndpointsOnIOThread,
-                   base::Unretained(this),
-                   ep0,
-                   ep1));
+                   base::Unretained(this), ep0, ep1));
   }
 
   // This bootstraps |ep| on |channels_[channel_index]|. It assumes/requires
@@ -82,9 +78,7 @@ class RemoteMessagePipeTest : public testing::Test {
     io_thread_.PostTask(
         FROM_HERE,
         base::Bind(&RemoteMessagePipeTest::BootstrapChannelEndpointOnIOThread,
-                   base::Unretained(this),
-                   channel_index,
-                   ep));
+                   base::Unretained(this), channel_index, ep));
   }
 
   void RestoreInitialState() {
@@ -198,12 +192,10 @@ TEST_F(RemoteMessagePipeTest, Basic) {
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   // Write to MP 0, port 0.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(kHello),
-                              sizeof(kHello),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -217,11 +209,8 @@ TEST_F(RemoteMessagePipeTest, Basic) {
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
@@ -233,12 +222,10 @@ TEST_F(RemoteMessagePipeTest, Basic) {
       MOJO_RESULT_OK,
       mp0->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
 
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->WriteMessage(1,
-                              UserPointer<const void>(kWorld),
-                              sizeof(kWorld),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(456u, context);
@@ -251,11 +238,8 @@ TEST_F(RemoteMessagePipeTest, Basic) {
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kWorld, buffer);
@@ -320,10 +304,8 @@ TEST_F(RemoteMessagePipeTest, Multiplex) {
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(&remote_id),
-                              sizeof(remote_id),
-                              nullptr,
+            mp0->WriteMessage(0, UserPointer<const void>(&remote_id),
+                              sizeof(remote_id), nullptr,
                               MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -338,11 +320,8 @@ TEST_F(RemoteMessagePipeTest, Multiplex) {
   ChannelEndpointId received_id;
   buffer_size = static_cast<uint32_t>(sizeof(received_id));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(&received_id),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(&received_id),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(received_id), static_cast<size_t>(buffer_size));
   EXPECT_EQ(remote_id, received_id);
@@ -359,12 +338,10 @@ TEST_F(RemoteMessagePipeTest, Multiplex) {
       MOJO_RESULT_OK,
       mp3->AddWaiter(0, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
 
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp2->WriteMessage(0,
-                              UserPointer<const void>(kHello),
-                              sizeof(kHello),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp2->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(789u, context);
@@ -378,37 +355,25 @@ TEST_F(RemoteMessagePipeTest, Multiplex) {
   // Make sure there's nothing on MP 0, port 0 or MP 1, port 1 or MP 2, port 0.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp0->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp2->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp2->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
 
   // Read from MP 3, port 1.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp3->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp3->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
@@ -420,12 +385,10 @@ TEST_F(RemoteMessagePipeTest, Multiplex) {
       MOJO_RESULT_OK,
       mp1->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 123, nullptr));
 
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(kWorld),
-                              sizeof(kWorld),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
   EXPECT_EQ(123u, context);
@@ -439,36 +402,24 @@ TEST_F(RemoteMessagePipeTest, Multiplex) {
   // Make sure there's nothing on the other ports.
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp0->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp0->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp2->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp2->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_SHOULD_WAIT,
-            mp3->ReadMessage(0,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp3->ReadMessage(0, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
 
   buffer_size = static_cast<uint32_t>(sizeof(buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kWorld, buffer);
@@ -495,12 +446,10 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeAttachAndRun) {
   scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
 
   // Write to MP 0, port 0.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(kHello),
-                              sizeof(kHello),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Close MP 0, port 0 before it's even been attached to the channel and run.
   mp0->Close(0);
@@ -533,11 +482,8 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeAttachAndRun) {
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
@@ -562,12 +508,10 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) {
   scoped_refptr<MessagePipe> mp0(MessagePipe::CreateLocalProxy(&ep0));
 
   // Write to MP 0, port 0.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->WriteMessage(0,
-                              UserPointer<const void>(kHello),
-                              sizeof(kHello),
-                              nullptr,
-                              MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                        nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   BootstrapChannelEndpointNoWait(0, ep0);
 
@@ -600,11 +544,8 @@ TEST_F(RemoteMessagePipeTest, CloseBeforeConnect) {
 
   // Read from MP 1, port 1.
   EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(buffer),
-                             MakeUserPointer(&buffer_size),
-                             nullptr,
-                             nullptr,
+            mp1->ReadMessage(1, UserPointer<void>(buffer),
+                             MakeUserPointer(&buffer_size), nullptr, nullptr,
                              MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(buffer_size));
   EXPECT_STREQ(kHello, buffer);
@@ -646,12 +587,10 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) {
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kHello),
-                                sizeof(kHello),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -675,13 +614,11 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) {
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
@@ -695,16 +632,14 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) {
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddWaiter(
-                &waiter, MOJO_HANDLE_SIGNAL_READABLE, 456, nullptr));
+            dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 456,
+                                  nullptr));
 
   // Write to "local_mp", port 1.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->WriteMessage(1,
-                                   UserPointer<const void>(kHello),
-                                   sizeof(kHello),
-                                   nullptr,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // TODO(vtl): FIXME -- We (racily) crash if I close |dispatcher| immediately
   // here. (We don't crash if I sleep and then close.)
@@ -724,25 +659,21 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) {
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
-                                    MakeUserPointer(&read_buffer_size),
-                                    0,
-                                    nullptr,
-                                    MOJO_READ_MESSAGE_FLAG_NONE));
+                                    MakeUserPointer(&read_buffer_size), 0,
+                                    nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            local_mp->AddWaiter(
-                1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+            local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                nullptr));
 
   // Write to the dispatcher.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            dispatcher->WriteMessage(UserPointer<const void>(kHello),
-                                     sizeof(kHello),
-                                     nullptr,
-                                     MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
+                                UserPointer<const void>(kHello), sizeof(kHello),
+                                nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -758,12 +689,9 @@ TEST_F(RemoteMessagePipeTest, HandlePassing) {
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->ReadMessage(1,
-                                  UserPointer<void>(read_buffer),
-                                  MakeUserPointer(&read_buffer_size),
-                                  nullptr,
-                                  nullptr,
-                                  MOJO_READ_MESSAGE_FLAG_NONE));
+            local_mp->ReadMessage(1, UserPointer<void>(read_buffer),
+                                  MakeUserPointer(&read_buffer_size), nullptr,
+                                  nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
@@ -796,24 +724,20 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) {
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
   // Write to the other end (|local_mp|, port 1), and then close it.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->WriteMessage(1,
-                                   UserPointer<const void>(kHello),
-                                   sizeof(kHello),
-                                   nullptr,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfiable_signals);
   // Then the second message....
-  EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->WriteMessage(1,
-                                   UserPointer<const void>(kWorld),
-                                   sizeof(kWorld),
-                                   nullptr,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      local_mp->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
   hss = local_mp->GetHandleSignalsState(0);
   EXPECT_EQ(MOJO_HANDLE_SIGNAL_READABLE | MOJO_HANDLE_SIGNAL_WRITABLE,
             hss.satisfied_signals);
@@ -843,12 +767,10 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) {
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kHello),
-                                sizeof(kHello),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -872,13 +794,11 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) {
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
@@ -898,10 +818,8 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) {
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
-                                    MakeUserPointer(&read_buffer_size),
-                                    0,
-                                    nullptr,
-                                    MOJO_READ_MESSAGE_FLAG_NONE));
+                                    MakeUserPointer(&read_buffer_size), 0,
+                                    nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   // It should still be readable.
@@ -913,10 +831,8 @@ TEST_F(RemoteMessagePipeTest, HandlePassingHalfClosed) {
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
-                                    MakeUserPointer(&read_buffer_size),
-                                    0,
-                                    nullptr,
-                                    MOJO_READ_MESSAGE_FLAG_NONE));
+                                    MakeUserPointer(&read_buffer_size), 0,
+                                    nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   // Now it should no longer be readable.
@@ -950,19 +866,16 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) {
 
   // We'll try to pass this dispatcher.
   scoped_refptr<SharedBufferDispatcher> dispatcher;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher));
+  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+                                platform_support(),
+                                SharedBufferDispatcher::kDefaultCreateOptions,
+                                100, &dispatcher));
   ASSERT_TRUE(dispatcher.get());
 
   // Make a mapping.
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping0;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+                                0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping0));
   ASSERT_TRUE(mapping0);
   ASSERT_TRUE(mapping0->GetBase());
   ASSERT_EQ(100u, mapping0->GetLength());
@@ -985,12 +898,10 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) {
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kHello),
-                                sizeof(kHello),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -1014,13 +925,11 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) {
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
@@ -1033,9 +942,8 @@ TEST_F(RemoteMessagePipeTest, MAYBE_SharedBufferPassing) {
 
   // Make another mapping.
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping1;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+                                0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
   ASSERT_TRUE(mapping1);
   ASSERT_TRUE(mapping1->GetBase());
   ASSERT_EQ(100u, mapping1->GetLength());
@@ -1110,12 +1018,10 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) {
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kWorld),
-                                sizeof(kWorld),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kWorld), sizeof(kWorld),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -1139,13 +1045,11 @@ TEST_F(RemoteMessagePipeTest, MAYBE_PlatformHandlePassing) {
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
@@ -1252,12 +1156,10 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) {
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp0->WriteMessage(0,
-                                UserPointer<const void>(kHello),
-                                sizeof(kHello),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp0->WriteMessage(0, UserPointer<const void>(kHello), sizeof(kHello),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -1281,13 +1183,11 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) {
   uint32_t read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   DispatcherVector read_dispatchers;
   uint32_t read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp1->ReadMessage(1,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp1->ReadMessage(1, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
@@ -1316,12 +1216,10 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) {
 
     std::vector<DispatcherTransport> transports;
     transports.push_back(transport);
-    EXPECT_EQ(MOJO_RESULT_OK,
-              mp1->WriteMessage(1,
-                                UserPointer<const void>(kWorld),
-                                sizeof(kWorld),
-                                &transports,
-                                MOJO_WRITE_MESSAGE_FLAG_NONE));
+    EXPECT_EQ(
+        MOJO_RESULT_OK,
+        mp1->WriteMessage(1, UserPointer<const void>(kWorld), sizeof(kWorld),
+                          &transports, MOJO_WRITE_MESSAGE_FLAG_NONE));
     transport.End();
 
     // |dispatcher| should have been closed. This is |DCHECK()|ed when the
@@ -1343,13 +1241,11 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) {
   // Read from MP 0, port 0.
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   read_num_dispatchers = 10;  // Maximum to get.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            mp0->ReadMessage(0,
-                             UserPointer<void>(read_buffer),
-                             MakeUserPointer(&read_buffer_size),
-                             &read_dispatchers,
-                             &read_num_dispatchers,
-                             MOJO_READ_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      mp0->ReadMessage(0, UserPointer<void>(read_buffer),
+                       MakeUserPointer(&read_buffer_size), &read_dispatchers,
+                       &read_num_dispatchers, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kWorld), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kWorld, read_buffer);
   EXPECT_EQ(1u, read_dispatchers.size());
@@ -1364,16 +1260,14 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) {
   // Add the waiter now, before it becomes readable to avoid a race.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            dispatcher->AddWaiter(
-                &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+            dispatcher->AddWaiter(&waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                  nullptr));
 
   // Write to "local_mp", port 1.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->WriteMessage(1,
-                                   UserPointer<const void>(kHello),
-                                   sizeof(kHello),
-                                   nullptr,
-                                   MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(
+      MOJO_RESULT_OK,
+      local_mp->WriteMessage(1, UserPointer<const void>(kHello), sizeof(kHello),
+                             nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait for the dispatcher to become readable.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -1390,25 +1284,21 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) {
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
             dispatcher->ReadMessage(UserPointer<void>(read_buffer),
-                                    MakeUserPointer(&read_buffer_size),
-                                    0,
-                                    nullptr,
-                                    MOJO_READ_MESSAGE_FLAG_NONE));
+                                    MakeUserPointer(&read_buffer_size), 0,
+                                    nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
   // Prepare to wait on "local_mp", port 1.
   waiter.Init();
   ASSERT_EQ(MOJO_RESULT_OK,
-            local_mp->AddWaiter(
-                1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789, nullptr));
+            local_mp->AddWaiter(1, &waiter, MOJO_HANDLE_SIGNAL_READABLE, 789,
+                                nullptr));
 
   // Write to the dispatcher.
-  EXPECT_EQ(MOJO_RESULT_OK,
-            dispatcher->WriteMessage(UserPointer<const void>(kHello),
-                                     sizeof(kHello),
-                                     nullptr,
-                                     MOJO_WRITE_MESSAGE_FLAG_NONE));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->WriteMessage(
+                                UserPointer<const void>(kHello), sizeof(kHello),
+                                nullptr, MOJO_WRITE_MESSAGE_FLAG_NONE));
 
   // Wait.
   EXPECT_EQ(MOJO_RESULT_OK, waiter.Wait(MOJO_DEADLINE_INDEFINITE, &context));
@@ -1424,12 +1314,9 @@ TEST_F(RemoteMessagePipeTest, PassMessagePipeHandleAcrossAndBack) {
   memset(read_buffer, 0, sizeof(read_buffer));
   read_buffer_size = static_cast<uint32_t>(sizeof(read_buffer));
   EXPECT_EQ(MOJO_RESULT_OK,
-            local_mp->ReadMessage(1,
-                                  UserPointer<void>(read_buffer),
-                                  MakeUserPointer(&read_buffer_size),
-                                  nullptr,
-                                  nullptr,
-                                  MOJO_READ_MESSAGE_FLAG_NONE));
+            local_mp->ReadMessage(1, UserPointer<void>(read_buffer),
+                                  MakeUserPointer(&read_buffer_size), nullptr,
+                                  nullptr, MOJO_READ_MESSAGE_FLAG_NONE));
   EXPECT_EQ(sizeof(kHello), static_cast<size_t>(read_buffer_size));
   EXPECT_STREQ(kHello, read_buffer);
 
diff --git a/mojo/edk/system/run_all_unittests.cc b/mojo/edk/system/run_all_unittests.cc
index 2855e96..3ea1682 100644
--- a/mojo/edk/system/run_all_unittests.cc
+++ b/mojo/edk/system/run_all_unittests.cc
@@ -15,7 +15,6 @@ int main(int argc, char** argv) {
   base::TestSuite test_suite(argc, argv);
 
   return base::LaunchUnitTests(
-      argc,
-      argv,
+      argc, argv,
       base::Bind(&base::TestSuite::Run, base::Unretained(&test_suite)));
 }
diff --git a/mojo/edk/system/shared_buffer_dispatcher.cc b/mojo/edk/system/shared_buffer_dispatcher.cc
index 7e345d9..698ef4e 100644
--- a/mojo/edk/system/shared_buffer_dispatcher.cc
+++ b/mojo/edk/system/shared_buffer_dispatcher.cc
@@ -10,7 +10,7 @@
 #include "base/memory/scoped_ptr.h"
 #include "mojo/edk/embedder/platform_support.h"
 #include "mojo/edk/system/channel.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/memory.h"
 #include "mojo/edk/system/options_validation.h"
 #include "mojo/public/c/system/macros.h"
@@ -69,7 +69,7 @@ MojoResult SharedBufferDispatcher::Create(
     scoped_refptr<SharedBufferDispatcher>* result) {
   if (!num_bytes)
     return MOJO_RESULT_INVALID_ARGUMENT;
-  if (num_bytes > kMaxSharedMemoryNumBytes)
+  if (num_bytes > GetConfiguration().max_shared_memory_num_bytes)
     return MOJO_RESULT_RESOURCE_EXHAUSTED;
 
   scoped_refptr<embedder::PlatformSharedBuffer> shared_buffer(
@@ -95,7 +95,7 @@ scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize(
 
   if (size != sizeof(SerializedSharedBufferDispatcher)) {
     LOG(ERROR) << "Invalid serialized shared buffer dispatcher (bad size)";
-    return scoped_refptr<SharedBufferDispatcher>();
+    return nullptr;
   }
 
   const SerializedSharedBufferDispatcher* serialization =
@@ -106,13 +106,13 @@ scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize(
   if (!num_bytes) {
     LOG(ERROR)
         << "Invalid serialized shared buffer dispatcher (invalid num_bytes)";
-    return scoped_refptr<SharedBufferDispatcher>();
+    return nullptr;
   }
 
   if (!platform_handles || platform_handle_index >= platform_handles->size()) {
     LOG(ERROR)
         << "Invalid serialized shared buffer dispatcher (missing handles)";
-    return scoped_refptr<SharedBufferDispatcher>();
+    return nullptr;
   }
 
   // Starts off invalid, which is what we want.
@@ -129,7 +129,7 @@ scoped_refptr<SharedBufferDispatcher> SharedBufferDispatcher::Deserialize(
   if (!shared_buffer.get()) {
     LOG(ERROR)
         << "Invalid serialized shared buffer dispatcher (invalid num_bytes?)";
-    return scoped_refptr<SharedBufferDispatcher>();
+    return nullptr;
   }
 
   return scoped_refptr<SharedBufferDispatcher>(
@@ -163,8 +163,8 @@ MojoResult SharedBufferDispatcher::ValidateDuplicateOptions(
   if (!reader.is_valid())
     return MOJO_RESULT_INVALID_ARGUMENT;
 
-  if (!OPTIONS_STRUCT_HAS_MEMBER(
-          MojoDuplicateBufferHandleOptions, flags, reader))
+  if (!OPTIONS_STRUCT_HAS_MEMBER(MojoDuplicateBufferHandleOptions, flags,
+                                 reader))
     return MOJO_RESULT_OK;
   if ((reader.options().flags & ~kKnownFlags))
     return MOJO_RESULT_UNIMPLEMENTED;
diff --git a/mojo/edk/system/shared_buffer_dispatcher_unittest.cc b/mojo/edk/system/shared_buffer_dispatcher_unittest.cc
index a80f71d..5866089 100644
--- a/mojo/edk/system/shared_buffer_dispatcher_unittest.cc
+++ b/mojo/edk/system/shared_buffer_dispatcher_unittest.cc
@@ -58,9 +58,8 @@ TEST_F(SharedBufferDispatcherTest, ValidateCreateOptionsValid) {
   // Default options.
   {
     MojoCreateSharedBufferOptions validated_options = {};
-    EXPECT_EQ(MOJO_RESULT_OK,
-              SharedBufferDispatcher::ValidateCreateOptions(
-                  NullUserPointer(), &validated_options));
+    EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::ValidateCreateOptions(
+                                  NullUserPointer(), &validated_options));
     RevalidateCreateOptions(validated_options);
   }
 
@@ -115,20 +114,17 @@ TEST_F(SharedBufferDispatcherTest, ValidateCreateOptionsInvalid) {
 
 TEST_F(SharedBufferDispatcherTest, CreateAndMapBuffer) {
   scoped_refptr<SharedBufferDispatcher> dispatcher;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher));
+  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+                                platform_support(),
+                                SharedBufferDispatcher::kDefaultCreateOptions,
+                                100, &dispatcher));
   ASSERT_TRUE(dispatcher.get());
   EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher->GetType());
 
   // Make a couple of mappings.
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping1;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+                                0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping1));
   ASSERT_TRUE(mapping1);
   ASSERT_TRUE(mapping1->GetBase());
   EXPECT_EQ(100u, mapping1->GetLength());
@@ -136,9 +132,8 @@ TEST_F(SharedBufferDispatcherTest, CreateAndMapBuffer) {
   static_cast<char*>(mapping1->GetBase())[50] = 'x';
 
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping2;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher->MapBuffer(50, 50, MOJO_MAP_BUFFER_FLAG_NONE, &mapping2));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher->MapBuffer(
+                                50, 50, MOJO_MAP_BUFFER_FLAG_NONE, &mapping2));
   ASSERT_TRUE(mapping2);
   ASSERT_TRUE(mapping2->GetBase());
   EXPECT_EQ(50u, mapping2->GetLength());
@@ -154,35 +149,30 @@ TEST_F(SharedBufferDispatcherTest, CreateAndMapBuffer) {
 
 TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandle) {
   scoped_refptr<SharedBufferDispatcher> dispatcher1;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher1));
+  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+                                platform_support(),
+                                SharedBufferDispatcher::kDefaultCreateOptions,
+                                100, &dispatcher1));
 
   // Map and write something.
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher1->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->MapBuffer(
+                                0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
   static_cast<char*>(mapping->GetBase())[0] = 'x';
   mapping.reset();
 
   // Duplicate |dispatcher1| and then close it.
   scoped_refptr<Dispatcher> dispatcher2;
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher1->DuplicateBufferHandle(NullUserPointer(), &dispatcher2));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->DuplicateBufferHandle(
+                                NullUserPointer(), &dispatcher2));
   ASSERT_TRUE(dispatcher2.get());
   EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType());
 
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->Close());
 
   // Map |dispatcher2| and read something.
-  EXPECT_EQ(
-      MOJO_RESULT_OK,
-      dispatcher2->MapBuffer(0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
+  EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->MapBuffer(
+                                0, 100, MOJO_MAP_BUFFER_FLAG_NONE, &mapping));
   EXPECT_EQ('x', static_cast<char*>(mapping->GetBase())[0]);
 
   EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close());
@@ -190,12 +180,10 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandle) {
 
 TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) {
   scoped_refptr<SharedBufferDispatcher> dispatcher1;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher1));
+  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+                                platform_support(),
+                                SharedBufferDispatcher::kDefaultCreateOptions,
+                                100, &dispatcher1));
 
   MojoDuplicateBufferHandleOptions options[] = {
       {sizeof(MojoDuplicateBufferHandleOptions),
@@ -203,9 +191,8 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) {
       {sizeof(MojoDuplicateBufferHandleOptionsFlags), ~0u}};
   for (size_t i = 0; i < arraysize(options); i++) {
     scoped_refptr<Dispatcher> dispatcher2;
-    EXPECT_EQ(MOJO_RESULT_OK,
-              dispatcher1->DuplicateBufferHandle(MakeUserPointer(&options[i]),
-                                                 &dispatcher2));
+    EXPECT_EQ(MOJO_RESULT_OK, dispatcher1->DuplicateBufferHandle(
+                                  MakeUserPointer(&options[i]), &dispatcher2));
     ASSERT_TRUE(dispatcher2.get());
     EXPECT_EQ(Dispatcher::kTypeSharedBuffer, dispatcher2->GetType());
     EXPECT_EQ(MOJO_RESULT_OK, dispatcher2->Close());
@@ -216,12 +203,10 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsValid) {
 
 TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) {
   scoped_refptr<SharedBufferDispatcher> dispatcher1;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher1));
+  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+                                platform_support(),
+                                SharedBufferDispatcher::kDefaultCreateOptions,
+                                100, &dispatcher1));
 
   // Invalid |struct_size|.
   {
@@ -251,32 +236,27 @@ TEST_F(SharedBufferDispatcherTest, DuplicateBufferHandleOptionsInvalid) {
 TEST_F(SharedBufferDispatcherTest, CreateInvalidNumBytes) {
   // Size too big.
   scoped_refptr<SharedBufferDispatcher> dispatcher;
-  EXPECT_EQ(MOJO_RESULT_RESOURCE_EXHAUSTED,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                std::numeric_limits<uint64_t>::max(),
-                &dispatcher));
+  EXPECT_EQ(
+      MOJO_RESULT_RESOURCE_EXHAUSTED,
+      SharedBufferDispatcher::Create(
+          platform_support(), SharedBufferDispatcher::kDefaultCreateOptions,
+          std::numeric_limits<uint64_t>::max(), &dispatcher));
   EXPECT_FALSE(dispatcher.get());
 
   // Zero size.
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
             SharedBufferDispatcher::Create(
                 platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                0,
-                &dispatcher));
+                SharedBufferDispatcher::kDefaultCreateOptions, 0, &dispatcher));
   EXPECT_FALSE(dispatcher.get());
 }
 
 TEST_F(SharedBufferDispatcherTest, MapBufferInvalidArguments) {
   scoped_refptr<SharedBufferDispatcher> dispatcher;
-  EXPECT_EQ(MOJO_RESULT_OK,
-            SharedBufferDispatcher::Create(
-                platform_support(),
-                SharedBufferDispatcher::kDefaultCreateOptions,
-                100,
-                &dispatcher));
+  EXPECT_EQ(MOJO_RESULT_OK, SharedBufferDispatcher::Create(
+                                platform_support(),
+                                SharedBufferDispatcher::kDefaultCreateOptions,
+                                100, &dispatcher));
 
   scoped_ptr<embedder::PlatformSharedBufferMapping> mapping;
   EXPECT_EQ(MOJO_RESULT_INVALID_ARGUMENT,
diff --git a/mojo/edk/system/simple_dispatcher_unittest.cc b/mojo/edk/system/simple_dispatcher_unittest.cc
index 502e34b..f23ff68 100644
--- a/mojo/edk/system/simple_dispatcher_unittest.cc
+++ b/mojo/edk/system/simple_dispatcher_unittest.cc
@@ -343,14 +343,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     {
       d->SetSatisfiedSignals(MOJO_HANDLE_SIGNAL_READABLE);
-      test::WaiterThread thread(d,
-                                MOJO_HANDLE_SIGNAL_READABLE,
-                                MOJO_DEADLINE_INDEFINITE,
-                                1,
-                                &did_wait,
-                                &result,
-                                &context,
-                                &hss);
+      test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+                                MOJO_DEADLINE_INDEFINITE, 1, &did_wait, &result,
+                                &context, &hss);
       stopwatch.Start();
       thread.Start();
     }  // Joins the thread.
@@ -368,14 +363,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) {
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     {
-      test::WaiterThread thread(d,
-                                MOJO_HANDLE_SIGNAL_READABLE,
-                                MOJO_DEADLINE_INDEFINITE,
-                                2,
-                                &did_wait,
-                                &result,
-                                &context,
-                                &hss);
+      test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+                                MOJO_DEADLINE_INDEFINITE, 2, &did_wait, &result,
+                                &context, &hss);
       stopwatch.Start();
       thread.Start();
       base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -397,14 +387,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) {
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     {
-      test::WaiterThread thread(d,
-                                MOJO_HANDLE_SIGNAL_READABLE,
-                                MOJO_DEADLINE_INDEFINITE,
-                                3,
-                                &did_wait,
-                                &result,
-                                &context,
-                                &hss);
+      test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+                                MOJO_DEADLINE_INDEFINITE, 3, &did_wait, &result,
+                                &context, &hss);
       stopwatch.Start();
       thread.Start();
       base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -424,14 +409,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) {
   // Wait for readable and dispatcher gets closed.
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
-    test::WaiterThread thread(d,
-                              MOJO_HANDLE_SIGNAL_READABLE,
-                              MOJO_DEADLINE_INDEFINITE,
-                              4,
-                              &did_wait,
-                              &result,
-                              &context,
-                              &hss);
+    test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+                              MOJO_DEADLINE_INDEFINITE, 4, &did_wait, &result,
+                              &context, &hss);
     stopwatch.Start();
     thread.Start();
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -450,14 +430,9 @@ TEST(SimpleDispatcherTest, MAYBE_BasicThreaded) {
   {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     {
-      test::WaiterThread thread(d,
-                                MOJO_HANDLE_SIGNAL_READABLE,
-                                2 * test::EpsilonTimeout().InMicroseconds(),
-                                5,
-                                &did_wait,
-                                &result,
-                                &context,
-                                &hss);
+      test::WaiterThread thread(d, MOJO_HANDLE_SIGNAL_READABLE,
+                                2 * test::EpsilonTimeout().InMicroseconds(), 5,
+                                &did_wait, &result, &context, &hss);
       stopwatch.Start();
       thread.Start();
       base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
@@ -496,14 +471,9 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
     for (uint32_t i = 0; i < kNumWaiters; i++) {
-      threads.push_back(new test::WaiterThread(d,
-                                               MOJO_HANDLE_SIGNAL_READABLE,
-                                               MOJO_DEADLINE_INDEFINITE,
-                                               i,
-                                               &did_wait[i],
-                                               &result[i],
-                                               &context[i],
-                                               &hss[i]));
+      threads.push_back(new test::WaiterThread(
+          d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
+          &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -524,25 +494,15 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
     for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
-      threads.push_back(new test::WaiterThread(d,
-                                               MOJO_HANDLE_SIGNAL_READABLE,
-                                               MOJO_DEADLINE_INDEFINITE,
-                                               i,
-                                               &did_wait[i],
-                                               &result[i],
-                                               &context[i],
-                                               &hss[i]));
+      threads.push_back(new test::WaiterThread(
+          d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
+          &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
-      threads.push_back(new test::WaiterThread(d,
-                                               MOJO_HANDLE_SIGNAL_WRITABLE,
-                                               MOJO_DEADLINE_INDEFINITE,
-                                               i,
-                                               &did_wait[i],
-                                               &result[i],
-                                               &context[i],
-                                               &hss[i]));
+      threads.push_back(new test::WaiterThread(
+          d, MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE, i,
+          &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
@@ -571,25 +531,15 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
     for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
-      threads.push_back(new test::WaiterThread(d,
-                                               MOJO_HANDLE_SIGNAL_READABLE,
-                                               MOJO_DEADLINE_INDEFINITE,
-                                               i,
-                                               &did_wait[i],
-                                               &result[i],
-                                               &context[i],
-                                               &hss[i]));
+      threads.push_back(new test::WaiterThread(
+          d, MOJO_HANDLE_SIGNAL_READABLE, MOJO_DEADLINE_INDEFINITE, i,
+          &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
-      threads.push_back(new test::WaiterThread(d,
-                                               MOJO_HANDLE_SIGNAL_WRITABLE,
-                                               MOJO_DEADLINE_INDEFINITE,
-                                               i,
-                                               &did_wait[i],
-                                               &result[i],
-                                               &context[i],
-                                               &hss[i]));
+      threads.push_back(new test::WaiterThread(
+          d, MOJO_HANDLE_SIGNAL_WRITABLE, MOJO_DEADLINE_INDEFINITE, i,
+          &did_wait[i], &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     base::PlatformThread::Sleep(1 * test::EpsilonTimeout());
@@ -619,27 +569,17 @@ TEST(SimpleDispatcherTest, MAYBE_MultipleWaiters) {
     scoped_refptr<MockSimpleDispatcher> d(new MockSimpleDispatcher());
     ScopedVector<test::WaiterThread> threads;
     for (uint32_t i = 0; i < kNumWaiters / 2; i++) {
-      threads.push_back(
-          new test::WaiterThread(d,
-                                 MOJO_HANDLE_SIGNAL_READABLE,
-                                 3 * test::EpsilonTimeout().InMicroseconds(),
-                                 i,
-                                 &did_wait[i],
-                                 &result[i],
-                                 &context[i],
-                                 &hss[i]));
+      threads.push_back(new test::WaiterThread(
+          d, MOJO_HANDLE_SIGNAL_READABLE,
+          3 * test::EpsilonTimeout().InMicroseconds(), i, &did_wait[i],
+          &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     for (uint32_t i = kNumWaiters / 2; i < kNumWaiters; i++) {
-      threads.push_back(
-          new test::WaiterThread(d,
-                                 MOJO_HANDLE_SIGNAL_WRITABLE,
-                                 1 * test::EpsilonTimeout().InMicroseconds(),
-                                 i,
-                                 &did_wait[i],
-                                 &result[i],
-                                 &context[i],
-                                 &hss[i]));
+      threads.push_back(new test::WaiterThread(
+          d, MOJO_HANDLE_SIGNAL_WRITABLE,
+          1 * test::EpsilonTimeout().InMicroseconds(), i, &did_wait[i],
+          &result[i], &context[i], &hss[i]));
       threads.back()->Start();
     }
     base::PlatformThread::Sleep(2 * test::EpsilonTimeout());
diff --git a/mojo/edk/system/test_utils.h b/mojo/edk/system/test_utils.h
index 3ab1907..b8dee66 100644
--- a/mojo/edk/system/test_utils.h
+++ b/mojo/edk/system/test_utils.h
@@ -5,10 +5,7 @@
 #ifndef MOJO_EDK_SYSTEM_TEST_UTILS_H_
 #define MOJO_EDK_SYSTEM_TEST_UTILS_H_
 
-#include <stdint.h>
-
 #include "base/callback_forward.h"
-#include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/task_runner.h"
diff --git a/mojo/edk/system/transport_data.cc b/mojo/edk/system/transport_data.cc
index 774b744..300b731 100644
--- a/mojo/edk/system/transport_data.cc
+++ b/mojo/edk/system/transport_data.cc
@@ -9,7 +9,7 @@
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "mojo/edk/system/channel.h"
-#include "mojo/edk/system/constants.h"
+#include "mojo/edk/system/configuration.h"
 #include "mojo/edk/system/message_in_transit.h"
 
 namespace mojo {
@@ -32,19 +32,20 @@ STATIC_CONST_MEMBER_DEFINITION const size_t
     TransportData::kMaxSerializedDispatcherPlatformHandles;
 
 // static
-const size_t TransportData::kMaxPlatformHandles =
-    kMaxMessageNumHandles * kMaxSerializedDispatcherPlatformHandles;
+size_t TransportData::GetMaxBufferSize() {
+  // In additional to the header, for each attached (Mojo) handle there'll be a
+  // handle table entry and serialized dispatcher data.
+  return sizeof(Header) +
+         GetConfiguration().max_message_num_handles *
+             (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize) +
+         GetMaxPlatformHandles() * kMaxSizePerPlatformHandle;
+}
 
-// In additional to the header, for each attached (Mojo) handle there'll be a
-// handle table entry and serialized dispatcher data.
-// Note: This definition must follow the one for |kMaxPlatformHandles|;
-// otherwise, we get a static initializer with gcc (but not clang).
 // static
-const size_t TransportData::kMaxBufferSize =
-    sizeof(Header) +
-    kMaxMessageNumHandles *
-        (sizeof(HandleTableEntry) + kMaxSerializedDispatcherSize) +
-    kMaxPlatformHandles * kMaxSizePerPlatformHandle;
+size_t TransportData::GetMaxPlatformHandles() {
+  return GetConfiguration().max_message_num_handles *
+         kMaxSerializedDispatcherPlatformHandles;
+}
 
 struct TransportData::PrivateStructForCompileAsserts {
   static_assert(sizeof(Header) % MessageInTransit::kMessageAlignment == 0,
@@ -90,11 +91,11 @@ TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers,
 
       DCHECK_LE(max_size, kMaxSerializedDispatcherSize);
       estimated_size += MessageInTransit::RoundUpMessageAlignment(max_size);
-      DCHECK_LE(estimated_size, kMaxBufferSize);
+      DCHECK_LE(estimated_size, GetMaxBufferSize());
 
       DCHECK_LE(max_platform_handles, kMaxSerializedDispatcherPlatformHandles);
       estimated_num_platform_handles += max_platform_handles;
-      DCHECK_LE(estimated_num_platform_handles, kMaxPlatformHandles);
+      DCHECK_LE(estimated_num_platform_handles, GetMaxPlatformHandles());
 
 #if DCHECK_IS_ON
       all_max_sizes[i] = max_size;
@@ -109,7 +110,7 @@ TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers,
     DCHECK_LE(size_per_platform_handle, kMaxSizePerPlatformHandle);
     estimated_size += estimated_num_platform_handles * size_per_platform_handle;
     estimated_size = MessageInTransit::RoundUpMessageAlignment(estimated_size);
-    DCHECK_LE(estimated_size, kMaxBufferSize);
+    DCHECK_LE(estimated_size, GetMaxBufferSize());
   }
 
   buffer_.reset(static_cast<char*>(
@@ -148,10 +149,7 @@ TransportData::TransportData(scoped_ptr<DispatcherVector> dispatchers,
     void* destination = buffer_.get() + current_offset;
     size_t actual_size = 0;
     if (Dispatcher::TransportDataAccess::EndSerializeAndClose(
-            dispatcher,
-            channel,
-            destination,
-            &actual_size,
+            dispatcher, channel, destination, &actual_size,
             platform_handles_.get())) {
       handle_table[i].type = static_cast<int32_t>(dispatcher->GetType());
       handle_table[i].offset = static_cast<uint32_t>(current_offset);
@@ -216,7 +214,7 @@ const char* TransportData::ValidateBuffer(
 
   // Always make sure that the buffer size is sane; if it's not, someone's
   // messing with us.
-  if (buffer_size < sizeof(Header) || buffer_size > kMaxBufferSize ||
+  if (buffer_size < sizeof(Header) || buffer_size > GetMaxBufferSize() ||
       buffer_size % MessageInTransit::kMessageAlignment != 0)
     return "Invalid message secondary buffer size";
 
@@ -233,7 +231,7 @@ const char* TransportData::ValidateBuffer(
 #endif
 
   // Sanity-check |num_handles| (before multiplying it against anything).
-  if (num_handles > kMaxMessageNumHandles)
+  if (num_handles > GetConfiguration().max_message_num_handles)
     return "Message handle payload too large";
 
   if (buffer_size < sizeof(Header) + num_handles * sizeof(HandleTableEntry))
diff --git a/mojo/edk/system/transport_data.h b/mojo/edk/system/transport_data.h
index 395bc73..d54ad2a 100644
--- a/mojo/edk/system/transport_data.h
+++ b/mojo/edk/system/transport_data.h
@@ -84,10 +84,10 @@ class MOJO_SYSTEM_IMPL_EXPORT TransportData {
   static const size_t kMaxSerializedDispatcherPlatformHandles = 2;
 
   // The maximum possible size of a valid transport data buffer.
-  static const size_t kMaxBufferSize;
+  static size_t GetMaxBufferSize();
 
   // The maximum total number of platform handles that may be attached.
-  static const size_t kMaxPlatformHandles;
+  static size_t GetMaxPlatformHandles();
 
   TransportData(scoped_ptr<DispatcherVector> dispatchers, Channel* channel);
 
diff --git a/mojo/edk/system/waiter_test_utils.cc b/mojo/edk/system/waiter_test_utils.cc
index 06a4033..39cb14e 100644
--- a/mojo/edk/system/waiter_test_utils.cc
+++ b/mojo/edk/system/waiter_test_utils.cc
@@ -55,8 +55,8 @@ WaiterThread::~WaiterThread() {
 void WaiterThread::Run() {
   waiter_.Init();
 
-  *result_out_ = dispatcher_->AddWaiter(
-      &waiter_, handle_signals_, context_, signals_state_out_);
+  *result_out_ = dispatcher_->AddWaiter(&waiter_, handle_signals_, context_,
+                                        signals_state_out_);
   if (*result_out_ != MOJO_RESULT_OK)
     return;