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 kServers = "s";
  19 static const std::string kUrl = "u";
  20
  21 class MockWebRTCInternalsProxy : public WebRTCInternalsUIObserver {
  22  public:
  23   virtual void OnUpdate(const std::string& command,
  24                         const base::Value* value) OVERRIDE {
  25     command_ = command;
  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, kServers, 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, kServers, 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, "servers", kServers);
 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, kServers, 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, kServers, 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   WebRTCInternals::GetInstance()->OnRemovePeerConnection(1, 2);
 169   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 170 }
 171
 172 TEST_F(WebRTCInternalsTest, AddGetUserMedia) {
 173   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 174
 175   // Add one observer before "getUserMedia".
 176   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 177
 178   const int rid = 1;
 179   const int pid = 2;
 180   const std::string audio_constraint = "aaa";
 181   const std::string video_constraint = "vvv";
 182   WebRTCInternals::GetInstance()->OnGetUserMedia(
 183       rid, pid, kUrl, true, true, audio_constraint, video_constraint);
 184
 185   EXPECT_EQ("addGetUserMedia", observer->command());
 186   VerifyGetUserMediaData(
 187       observer->value(), rid, pid, kUrl, audio_constraint, video_constraint);
 188
 189   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 190 }
 191
 192 TEST_F(WebRTCInternalsTest, SendAllUpdateWithGetUserMedia) {
 193   const int rid = 1;
 194   const int pid = 2;
 195   const std::string audio_constraint = "aaa";
 196   const std::string video_constraint = "vvv";
 197   WebRTCInternals::GetInstance()->OnGetUserMedia(
 198       rid, pid, kUrl, true, true, audio_constraint, video_constraint);
 199
 200   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 201   // Add one observer after "getUserMedia".
 202   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 203   WebRTCInternals::GetInstance()->UpdateObserver(observer.get());
 204
 205   EXPECT_EQ("addGetUserMedia", observer->command());
 206   VerifyGetUserMediaData(
 207       observer->value(), rid, pid, kUrl, audio_constraint, video_constraint);
 208
 209   WebRTCInternals::GetInstance()->RemoveObserver(observer.get());
 210 }
 211
 212 TEST_F(WebRTCInternalsTest, SendAllUpdatesWithPeerConnectionUpdate) {
 213   const int rid = 0, pid = 1, lid = 2;
 214   const std::string update_type = "fakeType";
 215   const std::string update_value = "fakeValue";
 216
 217   WebRTCInternals::GetInstance()->OnAddPeerConnection(
 218       rid, pid, lid, kUrl, kServers, kContraints);
 219   WebRTCInternals::GetInstance()->OnUpdatePeerConnection(
 220       pid, lid, update_type, update_value);
 221
 222   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 223   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 224
 225   WebRTCInternals::GetInstance()->UpdateObserver(observer.get());
 226
 227   EXPECT_EQ("updateAllPeerConnections", observer->command());
 228
 229   base::ListValue* list = NULL;
 230   EXPECT_TRUE(observer->value()->GetAsList(&list));
 231   EXPECT_EQ(1U, list->GetSize());
 232
 233   base::DictionaryValue* dict = NULL;
 234   EXPECT_TRUE((*list->begin())->GetAsDictionary(&dict));
 235
 236   VerifyInt(dict, "rid", rid);
 237   VerifyInt(dict, "pid", pid);
 238   VerifyInt(dict, "lid", lid);
 239   VerifyString(dict, "url", kUrl);
 240   VerifyString(dict, "servers", kServers);
 241   VerifyString(dict, "constraints", kContraints);
 242
 243   base::ListValue* log = NULL;
 244   EXPECT_TRUE(dict->GetList("log", &log));
 245   EXPECT_EQ(1U, log->GetSize());
 246
 247   EXPECT_TRUE((*log->begin())->GetAsDictionary(&dict));
 248   VerifyString(dict, "type", update_type);
 249   VerifyString(dict, "value", update_value);
 250 }
 251
 252 TEST_F(WebRTCInternalsTest, OnAddStats) {
 253   const int rid = 0, pid = 1, lid = 2;
 254   scoped_ptr<MockWebRTCInternalsProxy> observer(new MockWebRTCInternalsProxy());
 255   WebRTCInternals::GetInstance()->AddObserver(observer.get());
 256   WebRTCInternals::GetInstance()->OnAddPeerConnection(
 257       rid, pid, lid, kUrl, kServers, kContraints);
 258
 259   base::ListValue list;
 260   list.AppendString("xxx");
 261   list.AppendString("yyy");
 262   WebRTCInternals::GetInstance()->OnAddStats(pid, lid, list);
 263
 264   EXPECT_EQ("addStats", observer->command());
 265   base::DictionaryValue* dict = NULL;
 266   EXPECT_TRUE(observer->value()->GetAsDictionary(&dict));
 267
 268   VerifyInt(dict, "pid", pid);
 269   VerifyInt(dict, "lid", lid);
 270   VerifyList(dict, "reports", list);
 271 }
 272
 273 }  // namespace content