Adding the base ChromotingInstance implementation and unittests. This class will be used by the ap…

remoting/protocol/protocol_mock_objects.h

Index: remoting/protocol/protocol_mock_objects.h
diff --git a/remoting/protocol/protocol_mock_objects.h b/remoting/protocol/protocol_mock_objects.h
index 758151fa24ceb6f1a0d95b3368ad5ad6b1ea5abc..edbdfbe049c7c76fc4758111516bd3ca0a9bd6fd 100644
--- a/remoting/protocol/protocol_mock_objects.h
+++ b/remoting/protocol/protocol_mock_objects.h
@@ -18,6 +18,7 @@
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/connection_to_client.h"
+#include "remoting/protocol/connection_to_host.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/pairing_registry.h"
@@ -34,7 +35,7 @@ class MockConnectionToClient : public ConnectionToClient {
  public:
   MockConnectionToClient(Session* session,
                          HostStub* host_stub);
-  virtual ~MockConnectionToClient();
+  ~MockConnectionToClient() override;
 
   MOCK_METHOD1(Init, void(Session* session));
   MOCK_METHOD0(video_stub, VideoStub*());
@@ -69,11 +70,53 @@ class MockConnectionToClient : public ConnectionToClient {
   DISALLOW_COPY_AND_ASSIGN(MockConnectionToClient);
 };
 
+class MockConnectionToHost : public ConnectionToHost {

[Sergey Ulanov, 2015/03/11 00:09:51]

This class is no longer used in this CL, can be removed.

[joedow, 2015/03/11 19:06:39]

Done.  I had left it in the CL in case someone else needed it, but I'm fine
removing it.

+ public:
+  MockConnectionToHost();
+  ~MockConnectionToHost() override;
+
+  MOCK_METHOD5(ConnectPtr,
+      void(SignalStrategy* signal_strategy,
+           TransportFactory* transport_factory,
+           Authenticator* authenticator,
+           const std::string& host_jid,
+           HostEventCallback* event_callback));
+  MOCK_METHOD0(config, const SessionConfig&());
+  MOCK_METHOD0(clipboard_forwarder, ClipboardStub*());
+  MOCK_METHOD0(host_stub, HostStub*());
+  MOCK_METHOD0(input_stub, InputStub* ());
+  MOCK_METHOD1(OnSignalStrategyStateChange, void(SignalStrategy::State state));
+  MOCK_METHOD1(OnSignalStrategyIncomingStanza,
+      bool(const buzz::XmlElement* stanza));
+  MOCK_METHOD0(OnSessionManagerReady, void());
+  MOCK_METHOD2(OnIncomingSession,
+      void(Session* session,
+           SessionManager::IncomingSessionResponse* response));
+  MOCK_METHOD1(OnSessionStateChange, void(Session::State state));
+  MOCK_METHOD2(OnSessionRouteChange,
+      void(const std::string& channel_name, const TransportRoute& route));
+  MOCK_METHOD1(OnChannelInitialized,
+      void(ChannelDispatcherBase* channel_dispatcher));
+  MOCK_METHOD2(OnChannelError,
+      void(ChannelDispatcherBase* channel_dispatcher, ErrorCode error));
+  MOCK_METHOD1(OnVideoChannelStatus, void(bool active));
+
+  // ConnectionToHost interface.
+  void Connect(SignalStrategy* signal_strategy,
+               scoped_ptr<TransportFactory> transport_factory,
+               scoped_ptr<Authenticator> authenticator,
+               const std::string& host_jid,
+               HostEventCallback* event_callback) override;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockConnectionToHost);
+};
+
 class MockConnectionToClientEventHandler :
       public ConnectionToClient::EventHandler {
  public:
   MockConnectionToClientEventHandler();
-  virtual ~MockConnectionToClientEventHandler();
+  ~MockConnectionToClientEventHandler() override;
 
   MOCK_METHOD1(OnConnectionAuthenticating,
                void(ConnectionToClient* connection));
@@ -95,7 +138,7 @@ class MockConnectionToClientEventHandler :
 class MockClipboardStub : public ClipboardStub {
  public:
   MockClipboardStub();
-  virtual ~MockClipboardStub();
+  ~MockClipboardStub() override;
 
   MOCK_METHOD1(InjectClipboardEvent, void(const ClipboardEvent& event));
 
@@ -118,7 +161,7 @@ class MockCursorShapeChangeCallback {
 class MockInputStub : public InputStub {
  public:
   MockInputStub();
-  virtual ~MockInputStub();
+  ~MockInputStub() override;
 
   MOCK_METHOD1(InjectKeyEvent, void(const KeyEvent& event));
   MOCK_METHOD1(InjectTextEvent, void(const TextEvent& event));
@@ -132,7 +175,7 @@ class MockInputStub : public InputStub {
 class MockHostStub : public HostStub {
  public:
   MockHostStub();
-  virtual ~MockHostStub();
+  ~MockHostStub() override;
 
   MOCK_METHOD1(NotifyClientResolution,
                void(const ClientResolution& resolution));
@@ -150,7 +193,7 @@ class MockHostStub : public HostStub {
 class MockClientStub : public ClientStub {
  public:
   MockClientStub();
-  virtual ~MockClientStub();
+  ~MockClientStub() override;
 
   // ClientStub mock implementation.
   MOCK_METHOD1(SetCapabilities, void(const Capabilities& capabilities));
@@ -171,7 +214,7 @@ class MockClientStub : public ClientStub {
 class MockCursorShapeStub : public CursorShapeStub {
  public:
   MockCursorShapeStub();
-  virtual ~MockCursorShapeStub();
+  ~MockCursorShapeStub() override;
 
   MOCK_METHOD1(SetCursorShape, void(const CursorShapeInfo& cursor_shape));
 
@@ -182,12 +225,12 @@ class MockCursorShapeStub : public CursorShapeStub {
 class MockVideoStub : public VideoStub {
  public:
   MockVideoStub();
-  virtual ~MockVideoStub();
+  ~MockVideoStub() override;
 
   MOCK_METHOD2(ProcessVideoPacketPtr, void(const VideoPacket* video_packet,
                                            const base::Closure& done));
-  virtual void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
-                                  const base::Closure& done) {
+  void ProcessVideoPacket(scoped_ptr<VideoPacket> video_packet,
+                          const base::Closure& done) override {
     ProcessVideoPacketPtr(video_packet.get(), done);
   }
 
@@ -198,7 +241,7 @@ class MockVideoStub : public VideoStub {
 class MockSession : public Session {
  public:
   MockSession();
-  virtual ~MockSession();
+  ~MockSession() override;
 
   MOCK_METHOD1(SetEventHandler, void(Session::EventHandler* event_handler));
   MOCK_METHOD0(error, ErrorCode());
@@ -223,7 +266,7 @@ class MockSession : public Session {
 class MockSessionManager : public SessionManager {
  public:
   MockSessionManager();
-  virtual ~MockSessionManager();
+  ~MockSessionManager() override;
 
   MOCK_METHOD2(Init, void(SignalStrategy*, Listener*));
   MOCK_METHOD3(ConnectPtr, Session*(
@@ -233,15 +276,15 @@ class MockSessionManager : public SessionManager {
   MOCK_METHOD0(Close, void());
   MOCK_METHOD1(set_authenticator_factory_ptr,
                void(AuthenticatorFactory* factory));
-  virtual scoped_ptr<Session> Connect(
+  scoped_ptr<Session> Connect(
       const std::string& host_jid,
       scoped_ptr<Authenticator> authenticator,
-      scoped_ptr<CandidateSessionConfig> config) {
+      scoped_ptr<CandidateSessionConfig> config) override {
     return make_scoped_ptr(
         ConnectPtr(host_jid, authenticator.get(), config.get()));
   }
-  virtual void set_authenticator_factory(
-      scoped_ptr<AuthenticatorFactory> authenticator_factory) {
+  void set_authenticator_factory(
+      scoped_ptr<AuthenticatorFactory> authenticator_factory) override {
     set_authenticator_factory_ptr(authenticator_factory.release());
   }