Add basic perf tests for chromoting protocol.

remoting/protocol/connection_to_host.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_CONNECTION_TO_HOST_H_
 #define REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_
 
 #include <set>
 #include <string>
 
 #include "base/callback_forward.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/threading/non_thread_safe.h"
 #include "base/timer/timer.h"
 #include "remoting/proto/internal.pb.h"
 #include "remoting/protocol/clipboard_filter.h"
 #include "remoting/protocol/errors.h"
 #include "remoting/protocol/input_filter.h"
 #include "remoting/protocol/message_reader.h"
 #include "remoting/protocol/monitored_video_stub.h"
 #include "remoting/protocol/session.h"
+#include "remoting/protocol/session_config.h"
 #include "remoting/protocol/session_manager.h"
 #include "remoting/signaling/signal_strategy.h"
 
 namespace remoting {
 
 class XmppProxy;
 class VideoPacket;
 
 namespace protocol {
 
@@ skipping 43 matching lines @@
     virtual void OnConnectionReady(bool ready) = 0;
 
     // Called when the route type (direct vs. STUN vs. proxied) changes.
     virtual void OnRouteChanged(const std::string& channel_name,
                                 const protocol::TransportRoute& route) = 0;
   };
 
   ConnectionToHost();
   virtual ~ConnectionToHost();
 
+  // Allows to set a custom protocol configuration (e.g. for tests). Cannot be
+  // called after Connect().
+  void set_candidate_config(scoped_ptr<CandidateSessionConfig> config);

[rmsousa, 2014/07/16 23:06:00]

nit, feel free to ignore:
this name (and the corresponding class name) is a bit confusing.

Before I saw the actual code, I assumed candidate_config to be something
configuring candidates (like transport candidates), not a configuration
candidate (i.e. tentative configuration).

Since there is already a precedent for set_protocol_config (on the host side), I
suggest following that pattern instead, but I'm fine if you prefer to keep the
current name to match the underlying class.

[Sergey Ulanov, 2014/07/17 01:47:58]

Yeah I agree, that it might be confusing, but set_protocol_config() might be
equally confusing. There is a config() in this class that returns negotiated
protocol config. candidate_config is a term that's already used in other places,
e.g. in JingleSession there candidate_config() and config().

I renamed the new method in ChromotingClient to SetProtocolConfigForTests() - to
match what we have in the ChromotingHost. 

+
   // Set the stubs which will handle messages from the host.
   // The caller must ensure that stubs out-live the connection.
   // Unless otherwise specified, all stubs must be set before Connect()
   // is called.
   void set_client_stub(ClientStub* client_stub);
   void set_clipboard_stub(ClipboardStub* clipboard_stub);
   void set_video_stub(VideoStub* video_stub);
   // If no audio stub is specified then audio will not be requested.
   void set_audio_stub(AudioStub* audio_stub);
 
@@ skipping 53 matching lines @@
   void CloseChannels();
 
   void SetState(State state, ErrorCode error);
 
   std::string host_jid_;
   std::string host_public_key_;
   scoped_ptr<Authenticator> authenticator_;
 
   HostEventCallback* event_callback_;
 
+  scoped_ptr<CandidateSessionConfig> candidate_config_;
+
   // Stub for incoming messages.
   ClientStub* client_stub_;
   ClipboardStub* clipboard_stub_;
   AudioStub* audio_stub_;
 
   SignalStrategy* signal_strategy_;
   scoped_ptr<SessionManager> session_manager_;
   scoped_ptr<Session> session_;
   scoped_ptr<MonitoredVideoStub> monitored_video_stub_;
 
   scoped_ptr<VideoReader> video_reader_;
   scoped_ptr<AudioReader> audio_reader_;
   scoped_ptr<ClientControlDispatcher> control_dispatcher_;
   scoped_ptr<ClientEventDispatcher> event_dispatcher_;
   ClipboardFilter clipboard_forwarder_;
   InputFilter event_forwarder_;
 
   // Internal state of the connection.
   State state_;
   ErrorCode error_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(ConnectionToHost);
 };
 
 }  // namespace protocol
 }  // namespace remoting
 
 #endif  // REMOTING_PROTOCOL_CONNECTION_TO_HOST_H_