[mojo] Add CreateSharedBuffer method to Broker.

mojo/edk/system/child_broker.h

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef MOJO_EDK_SYSTEM_CHILD_BROKER_H_
 #define MOJO_EDK_SYSTEM_CHILD_BROKER_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 28 matching lines @@
   // Broker implementation:
 #if defined(OS_WIN)
   void CreatePlatformChannelPair(ScopedPlatformHandle* server,
                                  ScopedPlatformHandle* client) override;
   void HandleToToken(const PlatformHandle* platform_handles,
                      size_t count,
                      uint64_t* tokens) override;
   void TokenToHandle(const uint64_t* tokens,
                      size_t count,
                      PlatformHandle* handles) override;
+#else
+  scoped_refptr<PlatformSharedBuffer> CreateSharedBuffer(
+      size_t num_bytes) override;
 #endif
+
   void ConnectMessagePipe(uint64_t pipe_id,
                           MessagePipeDispatcher* message_pipe) override;
   void CloseMessagePipe(uint64_t pipe_id,
                         MessagePipeDispatcher* message_pipe) override;
 
  private:
   friend struct base::DefaultSingletonTraits<ChildBroker>;
 
   ChildBroker();
   ~ChildBroker() override;
@@ skipping 20 matching lines @@
 
 #if defined(OS_WIN)
   // Helper method to write the given message and read back the result.
   bool WriteAndReadResponse(BrokerMessage* message,
                             void* response,
                             uint32_t response_size);
 
   void CreatePlatformChannelPairNoLock(ScopedPlatformHandle* server,
                                        ScopedPlatformHandle* client);
 
+#else
+  // Will fully write |message|, then read back some number of handles. Returns
+  // false if the write or read failed, or if there were no handles received.
+  bool WriteAndReadHandles(BrokerMessage* message,
+                           std::deque<PlatformHandle>* handles);
+#endif
+
   // Guards access to |parent_sync_channel_|.
   // We use LockImpl instead of Lock because the latter adds thread checking
   // that we don't want (since we lock in the constructor and unlock on another
   // thread.
   base::internal::LockImpl sync_channel_lock_;
 
   // Pipe used for communication to the parent process. We use a pipe directly
   // instead of bindings or RawChannel because we need to send synchronous
   // messages with replies from any thread.
   ScopedPlatformHandle parent_sync_channel_;
-#endif
 
   // RawChannel used for asynchronous communication to and from the parent
   // process. Since these messages are bidirectional, we can't use
   // |parent_sync_channel_| which is only used for sync messages to the parent.
   // However since the messages are asynchronous, we can use RawChannel for
   // convenience instead of writing and reading from pipes manually. Although it
   // would be convenient, we don't use Mojo IPC because it would be a layering
   // violation (and cirular dependency) if the system layer depended on
   // bindings.
   RoutedRawChannel* parent_async_channel_;
@@ skipping 31 matching lines @@
   RoutedRawChannel* in_process_pipes_channel1_;
   RoutedRawChannel* in_process_pipes_channel2_;
 
   DISALLOW_COPY_AND_ASSIGN(ChildBroker);
 };
 
 }  // namespace edk
 }  // namespace mojo
 
 #endif  // MOJO_EDK_SYSTEM_CHILD_BROKER_H_