Home | History | Annotate | Download | only in ipc 
      1 // Copyright 2014 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #ifndef IPC_IPC_CHANNEL_MOJO_H_
      6 #define IPC_IPC_CHANNEL_MOJO_H_
      7 
      8 #include <stdint.h>
      9 
     10 #include <map>
     11 #include <memory>
     12 #include <string>
     13 #include <vector>
     14 
     15 #include "base/component_export.h"
     16 #include "base/macros.h"
     17 #include "base/memory/ref_counted.h"
     18 #include "base/memory/weak_ptr.h"
     19 #include "base/single_thread_task_runner.h"
     20 #include "base/synchronization/lock.h"
     21 #include "base/task_runner.h"
     22 #include "base/threading/thread_task_runner_handle.h"
     23 #include "build/build_config.h"
     24 #include "ipc/ipc.mojom.h"
     25 #include "ipc/ipc_channel.h"
     26 #include "ipc/ipc_channel_factory.h"
     27 #include "ipc/ipc_message_pipe_reader.h"
     28 #include "ipc/ipc_mojo_bootstrap.h"
     29 #include "mojo/public/cpp/bindings/thread_safe_interface_ptr.h"
     30 #include "mojo/public/cpp/system/core.h"
     31 
     32 namespace IPC {
     33 
     34 // Mojo-based IPC::Channel implementation over a Mojo message pipe.
     35 //
     36 // ChannelMojo builds a Mojo MessagePipe using the provided message pipe
     37 // |handle| and builds an associated interface for each direction on the
     38 // channel.
     39 //
     40 // TODO(morrita): Add APIs to create extra MessagePipes to let
     41 //                Mojo-based objects talk over this Channel.
     42 //
     43 class COMPONENT_EXPORT(IPC) ChannelMojo
     44     : public Channel,
     45       public Channel::AssociatedInterfaceSupport,
     46       public internal::MessagePipeReader::Delegate {
     47  public:
     48   // Creates a ChannelMojo.
     49   static std::unique_ptr<ChannelMojo> Create(
     50       mojo::ScopedMessagePipeHandle handle,
     51       Mode mode,
     52       Listener* listener,
     53       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner,
     54       const scoped_refptr<base::SingleThreadTaskRunner>& proxy_task_runner);
     55 
     56   // Create a factory object for ChannelMojo.
     57   // The factory is used to create Mojo-based ChannelProxy family.
     58   // |host| must not be null.
     59   static std::unique_ptr<ChannelFactory> CreateServerFactory(
     60       mojo::ScopedMessagePipeHandle handle,
     61       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner,
     62       const scoped_refptr<base::SingleThreadTaskRunner>& proxy_task_runner);
     63 
     64   static std::unique_ptr<ChannelFactory> CreateClientFactory(
     65       mojo::ScopedMessagePipeHandle handle,
     66       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner,
     67       const scoped_refptr<base::SingleThreadTaskRunner>& proxy_task_runner);
     68 
     69   ~ChannelMojo() override;
     70 
     71   // Channel implementation
     72   bool Connect() override;
     73   void Pause() override;
     74   void Unpause(bool flush) override;
     75   void Flush() override;
     76   void Close() override;
     77   bool Send(Message* message) override;
     78   Channel::AssociatedInterfaceSupport* GetAssociatedInterfaceSupport() override;
     79 
     80   // These access protected API of IPC::Message, which has ChannelMojo
     81   // as a friend class.
     82   static MojoResult WriteToMessageAttachmentSet(
     83       base::Optional<std::vector<mojo::native::SerializedHandlePtr>> handles,
     84       Message* message);
     85   static MojoResult ReadFromMessageAttachmentSet(
     86       Message* message,
     87       base::Optional<std::vector<mojo::native::SerializedHandlePtr>>* handles);
     88 
     89   // MessagePipeReader::Delegate
     90   void OnPeerPidReceived(int32_t peer_pid) override;
     91   void OnMessageReceived(const Message& message) override;
     92   void OnBrokenDataReceived() override;
     93   void OnPipeError() override;
     94   void OnAssociatedInterfaceRequest(
     95       const std::string& name,
     96       mojo::ScopedInterfaceEndpointHandle handle) override;
     97 
     98  private:
     99   ChannelMojo(
    100       mojo::ScopedMessagePipeHandle handle,
    101       Mode mode,
    102       Listener* listener,
    103       const scoped_refptr<base::SingleThreadTaskRunner>& ipc_task_runner,
    104       const scoped_refptr<base::SingleThreadTaskRunner>& proxy_task_runner);
    105 
    106   void ForwardMessageFromThreadSafePtr(mojo::Message message);
    107   void ForwardMessageWithResponderFromThreadSafePtr(
    108       mojo::Message message,
    109       std::unique_ptr<mojo::MessageReceiver> responder);
    110 
    111   // Channel::AssociatedInterfaceSupport:
    112   std::unique_ptr<mojo::ThreadSafeForwarder<mojom::Channel>>
    113   CreateThreadSafeChannel() override;
    114   void AddGenericAssociatedInterface(
    115       const std::string& name,
    116       const GenericAssociatedInterfaceFactory& factory) override;
    117   void GetGenericRemoteAssociatedInterface(
    118       const std::string& name,
    119       mojo::ScopedInterfaceEndpointHandle handle) override;
    120 
    121   base::WeakPtr<ChannelMojo> weak_ptr_;
    122 
    123   // A TaskRunner which runs tasks on the ChannelMojo's owning thread.
    124   scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
    125 
    126   const mojo::MessagePipeHandle pipe_;
    127   std::unique_ptr<MojoBootstrap> bootstrap_;
    128   Listener* listener_;
    129 
    130   std::unique_ptr<internal::MessagePipeReader> message_reader_;
    131 
    132   base::Lock associated_interface_lock_;
    133   std::map<std::string, GenericAssociatedInterfaceFactory>
    134       associated_interfaces_;
    135 
    136   base::WeakPtrFactory<ChannelMojo> weak_factory_;
    137 
    138   DISALLOW_COPY_AND_ASSIGN(ChannelMojo);
    139 };
    140 
    141 }  // namespace IPC
    142 
    143 #endif  // IPC_IPC_CHANNEL_MOJO_H_
    144