ipc/ipc_channel_win.h

   1 // Copyright (c) 2011 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_WIN_H_
   6 #define IPC_IPC_CHANNEL_WIN_H_
   7 #pragma once
   8
   9 #include "ipc/ipc_channel.h"
  10
  11 #include <queue>
  12 #include <string>
  13
  14 #include "base/memory/scoped_ptr.h"
  15 #include "base/message_loop.h"
  16
  17 namespace base {
  18 class NonThreadSafe;
  19 }
  20
  21 namespace IPC {
  22
  23 class Channel::ChannelImpl : public MessageLoopForIO::IOHandler {
  24  public:
  25   // Mirror methods of Channel, see ipc_channel.h for description.
  26   ChannelImpl(const IPC::ChannelHandle &channel_handle, Mode mode,
  27               Listener* listener);
  28   ~ChannelImpl();
  29   bool Connect();
  30   void Close();
  31   void set_listener(Listener* listener) { listener_ = listener; }
  32   bool Send(Message* message);
  33  private:
  34   const std::wstring PipeName(const std::string& channel_id) const;
  35   bool CreatePipe(const IPC::ChannelHandle &channel_handle, Mode mode);
  36
  37   bool ProcessConnection();
  38   bool ProcessIncomingMessages(MessageLoopForIO::IOContext* context,
  39                                DWORD bytes_read);
  40   bool ProcessOutgoingMessages(MessageLoopForIO::IOContext* context,
  41                                DWORD bytes_written);
  42
  43   // MessageLoop::IOHandler implementation.
  44   virtual void OnIOCompleted(MessageLoopForIO::IOContext* context,
  45                              DWORD bytes_transfered, DWORD error);
  46  private:
  47   struct State {
  48     explicit State(ChannelImpl* channel);
  49     ~State();
  50     MessageLoopForIO::IOContext context;
  51     bool is_pending;
  52   };
  53
  54   State input_state_;
  55   State output_state_;
  56
  57   HANDLE pipe_;
  58
  59   Listener* listener_;
  60
  61   // Messages to be sent are queued here.
  62   std::queue<Message*> output_queue_;
  63
  64   // We read from the pipe into this buffer
  65   char input_buf_[Channel::kReadBufferSize];
  66
  67   // Large messages that span multiple pipe buffers, get built-up using
  68   // this buffer.
  69   std::string input_overflow_buf_;
  70
  71   // In server-mode, we have to wait for the client to connect before we
  72   // can begin reading.  We make use of the input_state_ when performing
  73   // the connect operation in overlapped mode.
  74   bool waiting_connect_;
  75
  76   // This flag is set when processing incoming messages.  It is used to
  77   // avoid recursing through ProcessIncomingMessages, which could cause
  78   // problems.  TODO(darin): make this unnecessary
  79   bool processing_incoming_;
  80
  81   ScopedRunnableMethodFactory<ChannelImpl> factory_;
  82
  83   scoped_ptr<base::NonThreadSafe> thread_check_;
  84
  85   DISALLOW_COPY_AND_ASSIGN(ChannelImpl);
  86 };
  87
  88 }  // namespace IPC
  89
  90 #endif  // IPC_IPC_CHANNEL_WIN_H_