Adding a new authenticator which can be used to validate the remote user

remoting/protocol/protocol_mock_objects.h

 // Copyright (c) 2012 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 REMOTING_PROTOCOL_PROTOCOL_MOCK_OBJECTS_H_
 #define REMOTING_PROTOCOL_PROTOCOL_MOCK_OBJECTS_H_
 
-#include <stdint.h>
-
+#include <cstdint>
 #include <map>
+#include <memory>
 #include <string>
 
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/single_thread_task_runner.h"
 #include "base/values.h"
 #include "net/base/ip_endpoint.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/proto/video.pb.h"
 #include "remoting/protocol/authenticator.h"
+#include "remoting/protocol/channel_authenticator.h"
 #include "remoting/protocol/client_stub.h"
 #include "remoting/protocol/clipboard_stub.h"
 #include "remoting/protocol/connection_to_client.h"
 #include "remoting/protocol/host_stub.h"
 #include "remoting/protocol/input_stub.h"
 #include "remoting/protocol/pairing_registry.h"
 #include "remoting/protocol/session.h"
 #include "remoting/protocol/session_manager.h"
 #include "remoting/protocol/transport.h"
 #include "remoting/protocol/video_stub.h"
 #include "testing/gmock/include/gmock/gmock.h"
+#include "third_party/webrtc/libjingle/xmllite/xmlelement.h"
 
 namespace remoting {
 namespace protocol {
 
+class MockAuthenticator : public Authenticator {
+ public:
+  MockAuthenticator();
+  ~MockAuthenticator() override;
+
+  MOCK_CONST_METHOD0(state, Authenticator::State());
+  MOCK_CONST_METHOD0(started, bool());
+  MOCK_CONST_METHOD0(rejection_reason, Authenticator::RejectionReason());
+  MOCK_CONST_METHOD0(GetAuthKey, const std::string&());
+  MOCK_CONST_METHOD0(CreateChannelAuthenticatorPtr, ChannelAuthenticator*());
+  MOCK_METHOD2(ProcessMessage,
+               void(const buzz::XmlElement* message,
+                    const base::Closure& resume_callback));
+  MOCK_METHOD0(GetNextMessagePtr, buzz::XmlElement*());
+
+  std::unique_ptr<ChannelAuthenticator> CreateChannelAuthenticator()
+      const override {
+    return base::WrapUnique(CreateChannelAuthenticatorPtr());
+  }
+
+  std::unique_ptr<buzz::XmlElement> GetNextMessage() override {
+    return base::WrapUnique(GetNextMessagePtr());
+  }
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(MockAuthenticator);
+};
+
 class MockConnectionToClientEventHandler
     : public ConnectionToClient::EventHandler {
  public:
   MockConnectionToClientEventHandler();
   ~MockConnectionToClientEventHandler() override;
 
   MOCK_METHOD1(OnConnectionAuthenticating,
                void(ConnectionToClient* connection));
   MOCK_METHOD1(OnConnectionAuthenticated, void(ConnectionToClient* connection));
   MOCK_METHOD1(CreateVideoStreams, void(ConnectionToClient* connection));
@@ skipping 191 matching lines @@
   // Runs tasks synchronously instead of posting them to |task_runner|.
   void PostTask(const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
                 const tracked_objects::Location& from_here,
                 const base::Closure& task) override;
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_PROTOCOL_MOCK_OBJECTS_H_