Mojo: add support for disallowing sync calls for a process.

mojo/edk/system/core.cc

 // 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.
 
 #include "mojo/edk/system/core.h"
 
 #include <string.h>
 
 #include <utility>
 
@@ skipping 359 matching lines @@
   DCHECK(dispatcher);
 
   std::unique_ptr<AsyncWaiter> waiter =
       base::WrapUnique(new AsyncWaiter(callback));
   MojoResult rv = dispatcher->AddAwakable(waiter.get(), signals, 0, nullptr);
   if (rv == MOJO_RESULT_OK)
     ignore_result(waiter.release());
   return rv;
 }
 
+MojoResult Core::SetProperty(MojoPropertyType type, const void* value) {
+  base::AutoLock locker(property_lock_);
+  switch (type) {
+    case MOJO_PROPERTY_TYPE_SYNC_CALL_ALLOWED:
+      property_sync_call_allowed_ = *static_cast<const bool*>(value);
+      return MOJO_RESULT_OK;
+    default:
+      return MOJO_RESULT_INVALID_ARGUMENT;
+  }
+}
+
 MojoTimeTicks Core::GetTimeTicksNow() {
   return base::TimeTicks::Now().ToInternalValue();
 }
 
 MojoResult Core::Close(MojoHandle handle) {
   RequestContext request_context;
   scoped_refptr<Dispatcher> dispatcher;
   {
     base::AutoLock lock(handles_lock_);
     MojoResult rv = handles_.GetAndRemoveDispatcher(handle, &dispatcher);
@@ skipping 129 matching lines @@
 
 MojoResult Core::GetMessageBuffer(MojoMessageHandle message, void** buffer) {
   if (!message)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   *buffer = reinterpret_cast<MessageForTransit*>(message)->mutable_bytes();
 
   return MOJO_RESULT_OK;
 }
 
+MojoResult Core::GetProperty(MojoPropertyType type, void* value) {
+  base::AutoLock locker(property_lock_);
+  switch (type) {
+    case MOJO_PROPERTY_TYPE_SYNC_CALL_ALLOWED:
+      *static_cast<bool*>(value) = property_sync_call_allowed_;
+      return MOJO_RESULT_OK;
+    default:
+      return MOJO_RESULT_INVALID_ARGUMENT;
+  }
+}
+
 MojoResult Core::CreateWaitSet(MojoHandle* wait_set_handle) {
   RequestContext request_context;
   if (!wait_set_handle)
     return MOJO_RESULT_INVALID_ARGUMENT;
 
   scoped_refptr<WaitSetDispatcher> dispatcher = new WaitSetDispatcher();
   MojoHandle h = AddDispatcher(dispatcher);
   if (h == MOJO_HANDLE_INVALID) {
     LOG(ERROR) << "Handle table full";
     dispatcher->Close();
@@ skipping 626 matching lines @@
     std::unique_ptr<NodeController> node_controller) {
   // It's OK to leak this reference. At this point we know the IO loop is still
   // running, and we know the NodeController will observe its eventual
   // destruction. This tells the NodeController to delete itself when that
   // happens.
   node_controller.release()->DestroyOnIOThreadShutdown();
 }
 
 }  // namespace edk
 }  // namespace mojo