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

remoting/protocol/fake_connection_to_host.cc

+// Copyright 2015 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.
+
+#include "remoting/protocol/fake_connection_to_host.h"
+
+#include "remoting/protocol/authenticator.h"
+
+namespace remoting {
+namespace test {
+
+FakeConnectionToHost::FakeConnectionToHost()
+    : state_(INITIALIZING),
+      session_config_(protocol::SessionConfig::ForTest()) {
+}
+
+FakeConnectionToHost::~FakeConnectionToHost() {
+}
+
+void FakeConnectionToHost::set_candidate_config(
+    scoped_ptr<protocol::CandidateSessionConfig> config) {
+}
+
+void FakeConnectionToHost::set_client_stub(protocol::ClientStub* client_stub) {
+}
+
+void FakeConnectionToHost::set_clipboard_stub(
+    protocol::ClipboardStub* clipboard_stub) {
+}
+
+void FakeConnectionToHost::set_video_stub(protocol::VideoStub* video_stub) {
+}
+
+void FakeConnectionToHost::set_audio_stub(protocol::AudioStub* audio_stub) {
+}
+
+void FakeConnectionToHost::Connect(
+    SignalStrategy* signal_strategy,
+    scoped_ptr<protocol::TransportFactory> transport_factory,
+    scoped_ptr<protocol::Authenticator> authenticator,
+    const std::string& host_jid,
+    HostEventCallback* event_callback) {
+  DCHECK(event_callback);
+
+  event_callback_ = event_callback;
+
+  SetState(CONNECTING, protocol::OK);
+}
+
+void FakeConnectionToHost::SignalStateChange(protocol::Session::State state,
+                                             protocol::ErrorCode error) {
+  DCHECK(event_callback_);
+
+  switch (state) {
+    case protocol::Session::INITIALIZING:
+    case protocol::Session::CONNECTING:
+    case protocol::Session::ACCEPTING:
+    case protocol::Session::AUTHENTICATING:
+      // No updates for these events.
+      break;
+
+    case protocol::Session::CONNECTED:
+      SetState(CONNECTED, error);
+      break;
+
+    case protocol::Session::AUTHENTICATED:
+      SetState(AUTHENTICATED, error);
+      break;
+
+    case protocol::Session::CLOSED:
+      SetState(CLOSED, error);
+      break;
+
+    case protocol::Session::FAILED:
+      DCHECK(error != protocol::ErrorCode::OK);
+      SetState(FAILED, error);
+      break;
+  }
+}
+
+void FakeConnectionToHost::SignalConnectionReady(bool ready) {
+  DCHECK(event_callback_);
+
+  event_callback_->OnConnectionReady(ready);
+}
+
+const protocol::SessionConfig& FakeConnectionToHost::config() {
+  return session_config_;
+}
+
+protocol::ClipboardStub* FakeConnectionToHost::clipboard_forwarder() {
+  return &mock_clipboard_stub_;
+}
+
+protocol::HostStub* FakeConnectionToHost::host_stub() {
+  return &mock_host_stub_;
+}
+
+protocol::InputStub* FakeConnectionToHost::input_stub() {
+  return &mock_input_stub_;
+}
+
+protocol::ConnectionToHost::State FakeConnectionToHost::state() const {
+  return state_;
+}
+
+void FakeConnectionToHost::SetState(State state, protocol::ErrorCode error) {
+  // |error| should be specified only when |state| is set to FAILED.
+  DCHECK(state == FAILED || error == protocol::OK);
+
+  if (state != state_) {
+    state_ = state;
+    event_callback_->OnConnectionState(state_, error);
+  }
+}
+
+}  // namespace test
+}  // namespace remoting