content/browser/media/webrtc_internals_unittest.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/memory/scoped_ptr.h"
   6 #include "base/message_loop/message_loop.h"
   7 #include "base/values.h"
   8 #include "content/browser/media/webrtc_internals.h"
   9 #include "content/browser/media/webrtc_internals_ui_observer.h"
  10 #include "content/public/test/test_browser_thread.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace content {
  14
  15 namespace {
  16
  17 static const std::string kContraints = "c";
  18 static const std::string kRtcConfiguration = "r";
  19 static const std::string kUrl = "u";
  20
  21 class MockWebRTCInternalsProxy : public WebRTCInternalsUIObserver {
  22  public:
  23   void OnUpdate(const std::string& command, const base::Value* value) override {
  24     command_ = command;
  25     if (value)
  26       value_.reset(value->DeepCopy());
  27   }
  28
  29   std::string command() {
  30     return command_;
  31   }
  32
  33   base::Value* value() {
  34     return value_.get();
  35   }
  36
  37  private:
  38    std::string command_;
  39    scoped_ptr<base::Value> value_;
  40 };
  41
  42 class WebRTCInternalsTest : public testing::Test {
  43  public:
  44   WebRTCInternalsTest() : io_thread_(BrowserThread::UI, &io_loop_) {
  45     WebRTCInternals::GetInstance()->ResetForTesting();
  46   }
  47
  48  protected:
  49   void VerifyString(const base::DictionaryValue* dict,
  50                     const std::string& key,
  51                     const std::string& expected) {
  52     std::string actual;
  53     EXPECT_TRUE(dict->GetString(key, &actual));
  54     EXPECT_EQ(expected, actual);
  55   }
  56
  57   void VerifyInt(const base::DictionaryValue* dict,
  58                  const std::string& key,
  59                  int expected) {
  60     int actual;
  61     EXPECT_TRUE(dict->GetInteger(key, &actual));
  62     EXPECT_EQ(expected, actual);
  63   }
  64
  65   void VerifyList(const base::DictionaryValue* dict,
  66                   const std::string& key,
  67                   const base::ListValue& expected) {
  68     const base::ListValue* actual = NULL;
  69     EXPECT_TRUE(dict->GetList(key, &actual));
  70     EXPECT_TRUE(expected.Equals(actual));
  71   }
  72
  73   void VerifyGetUserMediaData(base::Value* actual_data,
  74                               int rid,
  75                               int pid,
  76                               const std::string& origin,
  77                               const std::string& audio,
  78                               const std::string& video) {
  79     base::DictionaryValue* dict = NULL;
  80     EXPECT_TRUE(actual_data->GetAsDictionary(&dict));
  81
  82     VerifyInt(dict, "rid", rid);
  83     VerifyInt(dict, "pid", pid);
  84     VerifyString(dict, "origin", origin);
  85     VerifyString(dict, "audio", audio);
  86     VerifyString(dict, "video", video);
  87   }
  88
  89   base::MessageLoop io_loop_;
  90   TestBrowserThread io_thread_;
  91 };
  92
  93 }  // namespace
  94
  95 TEST_F(WebRTCInternalsTest, AddRemoveObserver) {
  96   scoped_ptr<MockWebRTCInternalsProxy> observer(
  97       new MockWebRTCInternalsProxy());
  98   WebRTCInternals::GetInstance()->AddObserver(observer.get());
  99   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 100   WebRTCInternals::GetInstance()->OnAddPeerConnection(
 101       0, 3, 4, kUrl, kRtcConfiguration, kContraints);
 102   EXPECT_EQ("", observer->command());
 103
 104   WebRTCInternals::GetInstance()->OnRemovePeerConnection(3, 4);
 105 }
 106
 107 TEST_F(WebRTCInternalsTest, SendAddPeerConnectionUpdate) {
 108   scoped_ptr<MockWebRTCInternalsProxy> observer(
 109       new MockWebRTCInternalsProxy());
 110   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 111   WebRTCInternals::GetInstance()->OnAddPeerConnection(
 112       0, 1, 2, kUrl, kRtcConfiguration, kContraints);
 113   EXPECT_EQ("addPeerConnection", observer->command());
 114
 115   base::DictionaryValue* dict = NULL;
 116   EXPECT_TRUE(observer->value()->GetAsDictionary(&dict));
 117
 118   VerifyInt(dict, "pid", 1);
 119   VerifyInt(dict, "lid", 2);
 120   VerifyString(dict, "url", kUrl);
 121   VerifyString(dict, "rtcConfiguration", kRtcConfiguration);
 122   VerifyString(dict, "constraints", kContraints);
 123
 124   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 125   WebRTCInternals::GetInstance()->OnRemovePeerConnection(1, 2);
 126 }
 127
 128 TEST_F(WebRTCInternalsTest, SendRemovePeerConnectionUpdate) {
 129   scoped_ptr<MockWebRTCInternalsProxy> observer(
 130       new MockWebRTCInternalsProxy());
 131   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 132   WebRTCInternals::GetInstance()->OnAddPeerConnection(
 133       0, 1, 2, kUrl, kRtcConfiguration, kContraints);
 134   WebRTCInternals::GetInstance()->OnRemovePeerConnection(1, 2);
 135   EXPECT_EQ("removePeerConnection", observer->command());
 136
 137   base::DictionaryValue* dict = NULL;
 138   EXPECT_TRUE(observer->value()->GetAsDictionary(&dict));
 139
 140   VerifyInt(dict, "pid", 1);
 141   VerifyInt(dict, "lid", 2);
 142
 143   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 144 }
 145
 146 TEST_F(WebRTCInternalsTest, SendUpdatePeerConnectionUpdate) {
 147   scoped_ptr<MockWebRTCInternalsProxy> observer(
 148       new MockWebRTCInternalsProxy());
 149   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 150   WebRTCInternals::GetInstance()->OnAddPeerConnection(
 151       0, 1, 2, kUrl, kRtcConfiguration, kContraints);
 152
 153   const std::string update_type = "fakeType";
 154   const std::string update_value = "fakeValue";
 155   WebRTCInternals::GetInstance()->OnUpdatePeerConnection(
 156       1, 2, update_type, update_value);
 157
 158   EXPECT_EQ("updatePeerConnection", observer->command());
 159
 160   base::DictionaryValue* dict = NULL;
 161   EXPECT_TRUE(observer->value()->GetAsDictionary(&dict));
 162
 163   VerifyInt(dict, "pid", 1);
 164   VerifyInt(dict, "lid", 2);
 165   VerifyString(dict, "type", update_type);
 166   VerifyString(dict, "value", update_value);
 167
 168   std::string time;
 169   EXPECT_TRUE(dict->GetString("time", &time));
 170   EXPECT_FALSE(time.empty());
 171
 172   WebRTCInternals::GetInstance()->OnRemovePeerConnection(1, 2);
 173   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 174 }
 175
 176 TEST_F(WebRTCInternalsTest, AddGetUserMedia) {
 177   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 178
 179   // Add one observer before "getUserMedia".
 180   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 181
 182   const int rid = 1;
 183   const int pid = 2;
 184   const std::string audio_constraint = "aaa";
 185   const std::string video_constraint = "vvv";
 186   WebRTCInternals::GetInstance()->OnGetUserMedia(
 187       rid, pid, kUrl, true, true, audio_constraint, video_constraint);
 188
 189   EXPECT_EQ("addGetUserMedia", observer->command());
 190   VerifyGetUserMediaData(
 191       observer->value(), rid, pid, kUrl, audio_constraint, video_constraint);
 192
 193   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 194 }
 195
 196 TEST_F(WebRTCInternalsTest, SendAllUpdateWithGetUserMedia) {
 197   const int rid = 1;
 198   const int pid = 2;
 199   const std::string audio_constraint = "aaa";
 200   const std::string video_constraint = "vvv";
 201   WebRTCInternals::GetInstance()->OnGetUserMedia(
 202       rid, pid, kUrl, true, true, audio_constraint, video_constraint);
 203
 204   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 205   // Add one observer after "getUserMedia".
 206   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 207   WebRTCInternals::GetInstance()->UpdateObserver(observer.get());
 208
 209   EXPECT_EQ("addGetUserMedia", observer->command());
 210   VerifyGetUserMediaData(
 211       observer->value(), rid, pid, kUrl, audio_constraint, video_constraint);
 212
 213   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 214 }
 215
 216 TEST_F(WebRTCInternalsTest, SendAllUpdatesWithPeerConnectionUpdate) {
 217   const int rid = 0, pid = 1, lid = 2;
 218   const std::string update_type = "fakeType";
 219   const std::string update_value = "fakeValue";
 220
 221   WebRTCInternals::GetInstance()->OnAddPeerConnection(
 222       rid, pid, lid, kUrl, kRtcConfiguration, kContraints);
 223   WebRTCInternals::GetInstance()->OnUpdatePeerConnection(
 224       pid, lid, update_type, update_value);
 225
 226   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 227   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 228
 229   WebRTCInternals::GetInstance()->UpdateObserver(observer.get());
 230
 231   EXPECT_EQ("updateAllPeerConnections", observer->command());
 232
 233   base::ListValue* list = NULL;
 234   EXPECT_TRUE(observer->value()->GetAsList(&list));
 235   EXPECT_EQ(1U, list->GetSize());
 236
 237   base::DictionaryValue* dict = NULL;
 238   EXPECT_TRUE((*list->begin())->GetAsDictionary(&dict));
 239
 240   VerifyInt(dict, "rid", rid);
 241   VerifyInt(dict, "pid", pid);
 242   VerifyInt(dict, "lid", lid);
 243   VerifyString(dict, "url", kUrl);
 244   VerifyString(dict, "rtcConfiguration", kRtcConfiguration);
 245   VerifyString(dict, "constraints", kContraints);
 246
 247   base::ListValue* log = NULL;
 248   EXPECT_TRUE(dict->GetList("log", &log));
 249   EXPECT_EQ(1U, log->GetSize());
 250
 251   EXPECT_TRUE((*log->begin())->GetAsDictionary(&dict));
 252   VerifyString(dict, "type", update_type);
 253   VerifyString(dict, "value", update_value);
 254   std::string time;
 255   EXPECT_TRUE(dict->GetString("time", &time));
 256   EXPECT_FALSE(time.empty());
 257 }
 258
 259 TEST_F(WebRTCInternalsTest, OnAddStats) {
 260   const int rid = 0, pid = 1, lid = 2;
 261   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 262   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 263   WebRTCInternals::GetInstance()->OnAddPeerConnection(
 264       rid, pid, lid, kUrl, kRtcConfiguration, kContraints);
 265
 266   base::ListValue list;
 267   list.AppendString("xxx");
 268   list.AppendString("yyy");
 269   WebRTCInternals::GetInstance()->OnAddStats(pid, lid, list);
 270
 271   EXPECT_EQ("addStats", observer->command());
 272   base::DictionaryValue* dict = NULL;
 273   EXPECT_TRUE(observer->value()->GetAsDictionary(&dict));
 274
 275   VerifyInt(dict, "pid", pid);
 276   VerifyInt(dict, "lid", lid);
 277   VerifyList(dict, "reports", list);
 278 }
 279
 280 TEST_F(WebRTCInternalsTest, AecRecordingFileSelectionCanceled) {
 281   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 282   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 283   WebRTCInternals::GetInstance()->FileSelectionCanceled(NULL);
 284   EXPECT_EQ("aecRecordingFileSelectionCancelled", observer->command());
 285   EXPECT_EQ(NULL, observer->value());
 286 }
 287
 288 }  // namespace content