remoting/protocol/protocol_mock_objects.h

   1 // Copyright (c) 2012 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 REMOTING_PROTOCOL_PROTOCOL_MOCK_OBJECTS_H_
   6 #define REMOTING_PROTOCOL_PROTOCOL_MOCK_OBJECTS_H_
   7
   8 #include <string>
   9
  10 #include "net/base/ip_endpoint.h"
  11 #include "remoting/proto/internal.pb.h"
  12 #include "remoting/proto/video.pb.h"
  13 #include "remoting/protocol/authenticator.h"
  14 #include "remoting/protocol/client_stub.h"
  15 #include "remoting/protocol/clipboard_stub.h"
  16 #include "remoting/protocol/connection_to_client.h"
  17 #include "remoting/protocol/host_stub.h"
  18 #include "remoting/protocol/input_stub.h"
  19 #include "remoting/protocol/session.h"
  20 #include "remoting/protocol/session_manager.h"
  21 #include "remoting/protocol/transport.h"
  22 #include "remoting/protocol/video_stub.h"
  23 #include "testing/gmock/include/gmock/gmock.h"
  24
  25 namespace remoting {
  26 namespace protocol {
  27
  28 class MockConnectionToClient : public ConnectionToClient {
  29  public:
  30   MockConnectionToClient(Session* session,
  31                          HostStub* host_stub);
  32   virtual ~MockConnectionToClient();
  33
  34   MOCK_METHOD1(Init, void(Session* session));
  35   MOCK_METHOD0(video_stub, VideoStub*());
  36   MOCK_METHOD0(client_stub, ClientStub*());
  37   MOCK_METHOD0(session, Session*());
  38   MOCK_METHOD0(Disconnect, void());
  39
  40  private:
  41   DISALLOW_COPY_AND_ASSIGN(MockConnectionToClient);
  42 };
  43
  44 class MockConnectionToClientEventHandler :
  45       public ConnectionToClient::EventHandler {
  46  public:
  47   MockConnectionToClientEventHandler();
  48   virtual ~MockConnectionToClientEventHandler();
  49
  50   MOCK_METHOD1(OnConnectionAuthenticated, void(ConnectionToClient* connection));
  51   MOCK_METHOD1(OnConnectionChannelsConnected,
  52                void(ConnectionToClient* connection));
  53   MOCK_METHOD2(OnConnectionClosed, void(ConnectionToClient* connection,
  54                                         ErrorCode error));
  55   MOCK_METHOD2(OnSequenceNumberUpdated, void(ConnectionToClient* connection,
  56                                              int64 sequence_number));
  57   MOCK_METHOD3(OnRouteChange, void(ConnectionToClient* connection,
  58                                    const std::string& channel_name,
  59                                    const TransportRoute& route));
  60
  61  private:
  62   DISALLOW_COPY_AND_ASSIGN(MockConnectionToClientEventHandler);
  63 };
  64
  65 class MockClipboardStub : public ClipboardStub {
  66  public:
  67   MockClipboardStub();
  68   virtual ~MockClipboardStub();
  69
  70   MOCK_METHOD1(InjectClipboardEvent, void(const ClipboardEvent& event));
  71
  72  private:
  73   DISALLOW_COPY_AND_ASSIGN(MockClipboardStub);
  74 };
  75
  76 class MockCursorShapeChangeCallback {
  77  public:
  78   MockCursorShapeChangeCallback();
  79   virtual ~MockCursorShapeChangeCallback();
  80
  81   MOCK_METHOD1(CursorShapeChangedPtr, void(CursorShapeInfo* info));
  82   void CursorShapeChanged(scoped_ptr<CursorShapeInfo> info);
  83
  84  private:
  85   DISALLOW_COPY_AND_ASSIGN(MockCursorShapeChangeCallback);
  86 };
  87
  88 class MockInputStub : public InputStub {
  89  public:
  90   MockInputStub();
  91   virtual ~MockInputStub();
  92
  93   MOCK_METHOD1(InjectKeyEvent, void(const KeyEvent& event));
  94   MOCK_METHOD1(InjectMouseEvent, void(const MouseEvent& event));
  95
  96  private:
  97   DISALLOW_COPY_AND_ASSIGN(MockInputStub);
  98 };
  99
 100 class MockHostStub : public HostStub {
 101  public:
 102   MockHostStub();
 103   virtual ~MockHostStub();
 104
 105   MOCK_METHOD1(NotifyClientResolution,
 106                void(const ClientResolution& resolution));
 107   MOCK_METHOD1(ControlVideo,
 108                void(const VideoControl& video_control));
 109   MOCK_METHOD1(ControlAudio,
 110                void(const AudioControl& audio_control));
 111
 112  private:
 113   DISALLOW_COPY_AND_ASSIGN(MockHostStub);
 114 };
 115
 116 class MockClientStub : public ClientStub {
 117  public:
 118   MockClientStub();
 119   virtual ~MockClientStub();
 120
 121   // ClipboardStub mock implementation.
 122   MOCK_METHOD1(InjectClipboardEvent, void(const ClipboardEvent& event));
 123
 124   // CursorShapeStub mock implementation.
 125   MOCK_METHOD1(SetCursorShape, void(const CursorShapeInfo& cursor_shape));
 126
 127  private:
 128   DISALLOW_COPY_AND_ASSIGN(MockClientStub);
 129 };
 130
 131 class MockVideoStub : public VideoStub {
 132  public:
 133   MockVideoStub();
 134   virtual ~MockVideoStub();
 135
 136   MOCK_METHOD2(ProcessVideoPacketPtr, void(const VideoPacket* video_packet,
 137                                            const base::Closure& done));
 138   virtual void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
 139                                   const base::Closure& done) {
 140     ProcessVideoPacketPtr(video_packet.get(), done);
 141   }
 142
 143  private:
 144   DISALLOW_COPY_AND_ASSIGN(MockVideoStub);
 145 };
 146
 147 class MockSession : public Session {
 148  public:
 149   MockSession();
 150   virtual ~MockSession();
 151
 152   MOCK_METHOD1(SetEventHandler, void(Session::EventHandler* event_handler));
 153   MOCK_METHOD0(error, ErrorCode());
 154   MOCK_METHOD0(GetTransportChannelFactory, ChannelFactory*());
 155   MOCK_METHOD0(GetMultiplexedChannelFactory, ChannelFactory*());
 156   MOCK_METHOD0(jid, const std::string&());
 157   MOCK_METHOD0(candidate_config, const CandidateSessionConfig*());
 158   MOCK_METHOD0(config, const SessionConfig&());
 159   MOCK_METHOD1(set_config, void(const SessionConfig& config));
 160   MOCK_METHOD0(initiator_token, const std::string&());
 161   MOCK_METHOD1(set_initiator_token, void(const std::string& initiator_token));
 162   MOCK_METHOD0(receiver_token, const std::string&());
 163   MOCK_METHOD1(set_receiver_token, void(const std::string& receiver_token));
 164   MOCK_METHOD1(set_shared_secret, void(const std::string& secret));
 165   MOCK_METHOD0(shared_secret, const std::string&());
 166   MOCK_METHOD0(Close, void());
 167
 168  private:
 169   DISALLOW_COPY_AND_ASSIGN(MockSession);
 170 };
 171
 172 class MockSessionManager : public SessionManager {
 173  public:
 174   MockSessionManager();
 175   virtual ~MockSessionManager();
 176
 177   MOCK_METHOD2(Init, void(SignalStrategy*, Listener*));
 178   MOCK_METHOD3(ConnectPtr, Session*(
 179       const std::string& host_jid,
 180       Authenticator* authenticator,
 181       CandidateSessionConfig* config));
 182   MOCK_METHOD0(Close, void());
 183   MOCK_METHOD1(set_authenticator_factory_ptr, void(AuthenticatorFactory*));
 184   virtual scoped_ptr<Session> Connect(
 185       const std::string& host_jid,
 186       scoped_ptr<Authenticator> authenticator,
 187       scoped_ptr<CandidateSessionConfig> config) {
 188     return scoped_ptr<Session>(ConnectPtr(
 189         host_jid, authenticator.get(), config.get()));
 190   };
 191   virtual void set_authenticator_factory(
 192       scoped_ptr<AuthenticatorFactory> authenticator_factory) {
 193     set_authenticator_factory_ptr(authenticator_factory.release());
 194   };
 195
 196  private:
 197   DISALLOW_COPY_AND_ASSIGN(MockSessionManager);
 198 };
 199
 200 }  // namespace protocol
 201 }  // namespace remoting
 202
 203 #endif  // REMOTING_PROTOCOL_PROTOCOL_MOCK_OBJECTS_H_