1/*
2 * libjingle
3 * Copyright 2012 Google Inc.
4 *
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions are met:
7 *
8 *  1. Redistributions of source code must retain the above copyright notice,
9 *     this list of conditions and the following disclaimer.
10 *  2. Redistributions in binary form must reproduce the above copyright notice,
11 *     this list of conditions and the following disclaimer in the documentation
12 *     and/or other materials provided with the distribution.
13 *  3. The name of the author may not be used to endorse or promote products
14 *     derived from this software without specific prior written permission.
15 *
16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
17 * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
18 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
19 * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
20 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
22 * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
23 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
24 * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
25 * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26 */
27
28// This file contains mock implementations of observers used in PeerConnection.
29
30#ifndef TALK_APP_WEBRTC_TEST_MOCKPEERCONNECTIONOBSERVERS_H_
31#define TALK_APP_WEBRTC_TEST_MOCKPEERCONNECTIONOBSERVERS_H_
32
33#include <string>
34
35#include "talk/app/webrtc/datachannelinterface.h"
36
37namespace webrtc {
38
39class MockCreateSessionDescriptionObserver
40    : public webrtc::CreateSessionDescriptionObserver {
41 public:
42  MockCreateSessionDescriptionObserver()
43      : called_(false),
44        result_(false) {}
45  virtual ~MockCreateSessionDescriptionObserver() {}
46  virtual void OnSuccess(SessionDescriptionInterface* desc) {
47    called_ = true;
48    result_ = true;
49    desc_.reset(desc);
50  }
51  virtual void OnFailure(const std::string& error) {
52    called_ = true;
53    result_ = false;
54  }
55  bool called() const { return called_; }
56  bool result() const { return result_; }
57  SessionDescriptionInterface* release_desc() {
58    return desc_.release();
59  }
60
61 private:
62  bool called_;
63  bool result_;
64  rtc::scoped_ptr<SessionDescriptionInterface> desc_;
65};
66
67class MockSetSessionDescriptionObserver
68    : public webrtc::SetSessionDescriptionObserver {
69 public:
70  MockSetSessionDescriptionObserver()
71      : called_(false),
72        result_(false) {}
73  virtual ~MockSetSessionDescriptionObserver() {}
74  virtual void OnSuccess() {
75    called_ = true;
76    result_ = true;
77  }
78  virtual void OnFailure(const std::string& error) {
79    called_ = true;
80    result_ = false;
81  }
82  bool called() const { return called_; }
83  bool result() const { return result_; }
84
85 private:
86  bool called_;
87  bool result_;
88};
89
90class MockDataChannelObserver : public webrtc::DataChannelObserver {
91 public:
92  explicit MockDataChannelObserver(webrtc::DataChannelInterface* channel)
93     : channel_(channel), received_message_count_(0) {
94    channel_->RegisterObserver(this);
95    state_ = channel_->state();
96  }
97  virtual ~MockDataChannelObserver() {
98    channel_->UnregisterObserver();
99  }
100
101  void OnBufferedAmountChange(uint64_t previous_amount) override {}
102
103  void OnStateChange() override { state_ = channel_->state(); }
104  void OnMessage(const DataBuffer& buffer) override {
105    last_message_.assign(buffer.data.data<char>(), buffer.data.size());
106    ++received_message_count_;
107  }
108
109  bool IsOpen() const { return state_ == DataChannelInterface::kOpen; }
110  const std::string& last_message() const { return last_message_; }
111  size_t received_message_count() const { return received_message_count_; }
112
113 private:
114  rtc::scoped_refptr<webrtc::DataChannelInterface> channel_;
115  DataChannelInterface::DataState state_;
116  std::string last_message_;
117  size_t received_message_count_;
118};
119
120class MockStatsObserver : public webrtc::StatsObserver {
121 public:
122  MockStatsObserver() : called_(false), stats_() {}
123  virtual ~MockStatsObserver() {}
124
125  virtual void OnComplete(const StatsReports& reports) {
126    ASSERT(!called_);
127    called_ = true;
128    stats_.Clear();
129    stats_.number_of_reports = reports.size();
130    for (const auto* r : reports) {
131      if (r->type() == StatsReport::kStatsReportTypeSsrc) {
132        stats_.timestamp = r->timestamp();
133        GetIntValue(r, StatsReport::kStatsValueNameAudioOutputLevel,
134            &stats_.audio_output_level);
135        GetIntValue(r, StatsReport::kStatsValueNameAudioInputLevel,
136            &stats_.audio_input_level);
137        GetIntValue(r, StatsReport::kStatsValueNameBytesReceived,
138            &stats_.bytes_received);
139        GetIntValue(r, StatsReport::kStatsValueNameBytesSent,
140            &stats_.bytes_sent);
141      } else if (r->type() == StatsReport::kStatsReportTypeBwe) {
142        stats_.timestamp = r->timestamp();
143        GetIntValue(r, StatsReport::kStatsValueNameAvailableReceiveBandwidth,
144            &stats_.available_receive_bandwidth);
145      } else if (r->type() == StatsReport::kStatsReportTypeComponent) {
146        stats_.timestamp = r->timestamp();
147        GetStringValue(r, StatsReport::kStatsValueNameDtlsCipher,
148            &stats_.dtls_cipher);
149        GetStringValue(r, StatsReport::kStatsValueNameSrtpCipher,
150            &stats_.srtp_cipher);
151      }
152    }
153  }
154
155  bool called() const { return called_; }
156  size_t number_of_reports() const { return stats_.number_of_reports; }
157  double timestamp() const { return stats_.timestamp; }
158
159  int AudioOutputLevel() const {
160    ASSERT(called_);
161    return stats_.audio_output_level;
162  }
163
164  int AudioInputLevel() const {
165    ASSERT(called_);
166    return stats_.audio_input_level;
167  }
168
169  int BytesReceived() const {
170    ASSERT(called_);
171    return stats_.bytes_received;
172  }
173
174  int BytesSent() const {
175    ASSERT(called_);
176    return stats_.bytes_sent;
177  }
178
179  int AvailableReceiveBandwidth() const {
180    ASSERT(called_);
181    return stats_.available_receive_bandwidth;
182  }
183
184  std::string DtlsCipher() const {
185    ASSERT(called_);
186    return stats_.dtls_cipher;
187  }
188
189  std::string SrtpCipher() const {
190    ASSERT(called_);
191    return stats_.srtp_cipher;
192  }
193
194 private:
195  bool GetIntValue(const StatsReport* report,
196                   StatsReport::StatsValueName name,
197                   int* value) {
198    const StatsReport::Value* v = report->FindValue(name);
199    if (v) {
200      // TODO(tommi): We should really just be using an int here :-/
201      *value = rtc::FromString<int>(v->ToString());
202    }
203    return v != nullptr;
204  }
205
206  bool GetStringValue(const StatsReport* report,
207                      StatsReport::StatsValueName name,
208                      std::string* value) {
209    const StatsReport::Value* v = report->FindValue(name);
210    if (v)
211      *value = v->ToString();
212    return v != nullptr;
213  }
214
215  bool called_;
216  struct {
217    void Clear() {
218      number_of_reports = 0;
219      timestamp = 0;
220      audio_output_level = 0;
221      audio_input_level = 0;
222      bytes_received = 0;
223      bytes_sent = 0;
224      available_receive_bandwidth = 0;
225      dtls_cipher.clear();
226      srtp_cipher.clear();
227    }
228
229    size_t number_of_reports;
230    double timestamp;
231    int audio_output_level;
232    int audio_input_level;
233    int bytes_received;
234    int bytes_sent;
235    int available_receive_bandwidth;
236    std::string dtls_cipher;
237    std::string srtp_cipher;
238  } stats_;
239};
240
241}  // namespace webrtc
242
243#endif  // TALK_APP_WEBRTC_TEST_MOCKPEERCONNECTIONOBSERVERS_H_
244