content/browser/media/webrtc_internals_browsertest.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/command_line.h"
   6 #include "base/json/json_reader.h"
   7 #include "base/strings/utf_string_conversions.h"
   8 #include "base/time/time.h"
   9 #include "base/values.h"
  10 #include "content/public/common/content_switches.h"
  11 #include "content/public/test/browser_test_utils.h"
  12 #include "content/public/test/content_browser_test.h"
  13 #include "content/public/test/content_browser_test_utils.h"
  14 #include "content/shell/browser/shell.h"
  15 #include "media/base/media_switches.h"
  16 #include "net/test/embedded_test_server/embedded_test_server.h"
  17
  18 using std::string;
  19 namespace content {
  20
  21 struct SsrcEntry {
  22   string GetSsrcAttributeString() const {
  23     std::stringstream ss;
  24     ss << "a=ssrc:" << id;
  25     std::map<string, string>::const_iterator iter;
  26     for (iter = properties.begin(); iter != properties.end(); ++iter) {
  27       ss << " " << iter->first << ":" << iter->second;
  28     }
  29     return ss.str();
  30   }
  31
  32   string GetAsJSON() const {
  33     std::stringstream ss;
  34     ss << "{";
  35     std::map<string, string>::const_iterator iter;
  36     for (iter = properties.begin(); iter != properties.end(); ++iter) {
  37       if (iter != properties.begin())
  38         ss << ",";
  39       ss << "\"" << iter->first << "\":\"" << iter->second << "\"";
  40     }
  41     ss << "}";
  42     return ss.str();
  43   }
  44
  45   string id;
  46   std::map<string, string> properties;
  47 };
  48
  49 struct EventEntry {
  50   string type;
  51   string value;
  52 };
  53
  54 struct StatsUnit {
  55   string GetString() const {
  56     std::stringstream ss;
  57     ss << "{timestamp:" << timestamp << ", values:[";
  58     std::map<string, string>::const_iterator iter;
  59     for (iter = values.begin(); iter != values.end(); ++iter) {
  60       ss << "'" << iter->first << "','" << iter->second << "',";
  61     }
  62     ss << "]}";
  63     return ss.str();
  64   }
  65
  66   int64 timestamp;
  67   std::map<string, string> values;
  68 };
  69
  70 struct StatsEntry {
  71   string type;
  72   string id;
  73   StatsUnit stats;
  74 };
  75
  76 typedef std::map<string, std::vector<string> > StatsMap;
  77
  78 class PeerConnectionEntry {
  79  public:
  80   PeerConnectionEntry(int pid, int lid) : pid_(pid), lid_(lid) {}
  81
  82   void AddEvent(const string& type, const string& value) {
  83     EventEntry entry = {type, value};
  84     events_.push_back(entry);
  85   }
  86
  87   string getIdString() const {
  88     std::stringstream ss;
  89     ss << pid_ << "-" << lid_;
  90     return ss.str();
  91   }
  92
  93   string getLogIdString() const {
  94     std::stringstream ss;
  95     ss << pid_ << "-" << lid_ << "-update-log";
  96     return ss.str();
  97   }
  98
  99   string getAllUpdateString() const {
 100     std::stringstream ss;
 101     ss << "{pid:" << pid_ << ", lid:" << lid_ << ", log:[";
 102     for (size_t i = 0; i < events_.size(); ++i) {
 103       ss << "{type:'" << events_[i].type <<
 104           "', value:'" << events_[i].value << "'},";
 105     }
 106     ss << "]}";
 107     return ss.str();
 108   }
 109
 110   int pid_;
 111   int lid_;
 112   std::vector<EventEntry> events_;
 113   // This is a record of the history of stats value reported for each stats
 114   // report id (e.g. ssrc-1234) for each stats name (e.g. framerate).
 115   // It a 2-D map with each map entry is a vector of reported values.
 116   // It is used to verify the graph data series.
 117   std::map<string, StatsMap> stats_;
 118 };
 119
 120 class UserMediaRequestEntry {
 121  public:
 122   UserMediaRequestEntry(int pid,
 123                         int rid,
 124                         const std::string& origin,
 125                         const std::string& audio_constraints,
 126                         const std::string& video_constraints)
 127       : pid(pid),
 128         rid(rid),
 129         origin(origin),
 130         audio_constraints(audio_constraints),
 131         video_constraints(video_constraints) {}
 132
 133   int pid;
 134   int rid;
 135   std::string origin;
 136   std::string audio_constraints;
 137   std::string video_constraints;
 138 };
 139
 140 static const int64 FAKE_TIME_STAMP = 3600000;
 141
 142 #if defined(OS_WIN)
 143 // All tests are flaky on Windows: crbug.com/277322.
 144 #define MAYBE_WebRtcInternalsBrowserTest DISABLED_WebRtcInternalsBrowserTest
 145 #else
 146 #define MAYBE_WebRtcInternalsBrowserTest WebRtcInternalsBrowserTest
 147 #endif
 148
 149 class MAYBE_WebRtcInternalsBrowserTest: public ContentBrowserTest {
 150  public:
 151   MAYBE_WebRtcInternalsBrowserTest() {}
 152   virtual ~MAYBE_WebRtcInternalsBrowserTest() {}
 153
 154   virtual void SetUpOnMainThread() OVERRIDE {
 155     // We need fake devices in this test since we want to run on naked VMs. We
 156     // assume these switches are set by default in content_browsertests.
 157     ASSERT_TRUE(CommandLine::ForCurrentProcess()->HasSwitch(
 158         switches::kUseFakeDeviceForMediaStream));
 159     ASSERT_TRUE(CommandLine::ForCurrentProcess()->HasSwitch(
 160         switches::kUseFakeUIForMediaStream));
 161   }
 162
 163  protected:
 164   bool ExecuteJavascript(const string& javascript) {
 165     return ExecuteScript(shell()->web_contents(), javascript);
 166   }
 167
 168   void ExpectTitle(const std::string& expected_title) const {
 169     base::string16 expected_title16(base::ASCIIToUTF16(expected_title));
 170     TitleWatcher title_watcher(shell()->web_contents(), expected_title16);
 171     EXPECT_EQ(expected_title16, title_watcher.WaitAndGetTitle());
 172   }
 173
 174   // Execute the javascript of addPeerConnection.
 175   void ExecuteAddPeerConnectionJs(const PeerConnectionEntry& pc) {
 176     std::stringstream ss;
 177     ss << "{pid:" << pc.pid_ <<", lid:" << pc.lid_ << ", " <<
 178            "url:'u', servers:'s', constraints:'c'}";
 179     ASSERT_TRUE(ExecuteJavascript("addPeerConnection(" + ss.str() + ");"));
 180   }
 181
 182   // Execute the javascript of removePeerConnection.
 183   void ExecuteRemovePeerConnectionJs(const PeerConnectionEntry& pc) {
 184     std::stringstream ss;
 185     ss << "{pid:" << pc.pid_ <<", lid:" << pc.lid_ << "}";
 186
 187     ASSERT_TRUE(ExecuteJavascript("removePeerConnection(" + ss.str() + ");"));
 188   }
 189
 190   // Execute the javascript of addGetUserMedia.
 191   void ExecuteAddGetUserMediaJs(const UserMediaRequestEntry& request) {
 192     std::stringstream ss;
 193     ss << "{pid:" << request.pid << ", rid:" << request.rid << ", origin:'"
 194        << request.origin << "', audio:'" << request.audio_constraints
 195        << "', video:'" << request.video_constraints << "'}";
 196
 197     ASSERT_TRUE(ExecuteJavascript("addGetUserMedia(" + ss.str() + ");"));
 198   }
 199
 200   // Execute the javascript of removeGetUserMediaForRenderer.
 201   void ExecuteRemoveGetUserMediaForRendererJs(int rid) {
 202     std::stringstream ss;
 203     ss << "{rid:" << rid << "}";
 204     ASSERT_TRUE(
 205         ExecuteJavascript("removeGetUserMediaForRenderer(" + ss.str() + ");"));
 206   }
 207
 208   // Verifies that the DOM element with id |id| exists.
 209   void VerifyElementWithId(const string& id) {
 210     bool result = false;
 211     ASSERT_TRUE(ExecuteScriptAndExtractBool(
 212         shell()->web_contents(),
 213         "window.domAutomationController.send($('" + id + "') != null);",
 214         &result));
 215     EXPECT_TRUE(result);
 216   }
 217
 218   // Verifies that the DOM element with id |id| does not exist.
 219   void VerifyNoElementWithId(const string& id) {
 220     bool result = false;
 221     ASSERT_TRUE(ExecuteScriptAndExtractBool(
 222         shell()->web_contents(),
 223         "window.domAutomationController.send($('" + id + "') == null);",
 224         &result));
 225     EXPECT_TRUE(result);
 226   }
 227
 228   // Verifies the JS Array of userMediaRequests matches |requests|.
 229   void VerifyUserMediaRequest(
 230       const std::vector<UserMediaRequestEntry>& requests) {
 231     string json_requests;
 232     ASSERT_TRUE(ExecuteScriptAndExtractString(
 233         shell()->web_contents(),
 234         "window.domAutomationController.send("
 235         "JSON.stringify(userMediaRequests));",
 236         &json_requests));
 237     scoped_ptr<base::Value> value_requests;
 238     value_requests.reset(base::JSONReader::Read(json_requests));
 239
 240     EXPECT_EQ(base::Value::TYPE_LIST, value_requests->GetType());
 241
 242     base::ListValue* list_request =
 243         static_cast<base::ListValue*>(value_requests.get());
 244     EXPECT_EQ(requests.size(), list_request->GetSize());
 245
 246     for (size_t i = 0; i < requests.size(); ++i) {
 247       base::DictionaryValue* dict = NULL;
 248       ASSERT_TRUE(list_request->GetDictionary(i, &dict));
 249       int pid, rid;
 250       std::string origin, audio, video;
 251       ASSERT_TRUE(dict->GetInteger("pid", &pid));
 252       ASSERT_TRUE(dict->GetInteger("rid", &rid));
 253       ASSERT_TRUE(dict->GetString("origin", &origin));
 254       ASSERT_TRUE(dict->GetString("audio", &audio));
 255       ASSERT_TRUE(dict->GetString("video", &video));
 256       EXPECT_EQ(requests[i].pid, pid);
 257       EXPECT_EQ(requests[i].rid, rid);
 258       EXPECT_EQ(requests[i].origin, origin);
 259       EXPECT_EQ(requests[i].audio_constraints, audio);
 260       EXPECT_EQ(requests[i].video_constraints, video);
 261     }
 262   }
 263
 264   // Verifies that DOM for |pc| is correctly created with the right content.
 265   void VerifyPeerConnectionEntry(const PeerConnectionEntry& pc) {
 266     VerifyElementWithId(pc.getIdString());
 267     if (pc.events_.size() == 0)
 268       return;
 269
 270     string log_id = pc.getLogIdString();
 271     VerifyElementWithId(log_id);
 272     string result;
 273     for (size_t i = 0; i < pc.events_.size(); ++i) {
 274       std::stringstream ss;
 275       ss << "var row = $('" << log_id << "').rows[" << (i + 1) << "];"
 276             "var cell = row.lastChild;"
 277             "window.domAutomationController.send(cell.firstChild.textContent);";
 278       ASSERT_TRUE(ExecuteScriptAndExtractString(
 279           shell()->web_contents(), ss.str(), &result));
 280       EXPECT_EQ(pc.events_[i].type + pc.events_[i].value, result);
 281     }
 282   }
 283
 284   // Executes the javascript of updatePeerConnection and verifies the result.
 285   void ExecuteAndVerifyUpdatePeerConnection(
 286       PeerConnectionEntry& pc, const string& type, const string& value) {
 287     pc.AddEvent(type, value);
 288
 289     std::stringstream ss;
 290     ss << "{pid:" << pc.pid_ <<", lid:" << pc.lid_ <<
 291          ", type:'" << type << "', value:'" << value << "'}";
 292     ASSERT_TRUE(ExecuteJavascript("updatePeerConnection(" + ss.str() + ")"));
 293
 294     VerifyPeerConnectionEntry(pc);
 295   }
 296
 297   // Execute addStats and verifies that the stats table has the right content.
 298   void ExecuteAndVerifyAddStats(
 299       PeerConnectionEntry& pc, const string& type, const string& id,
 300       StatsUnit& stats) {
 301     StatsEntry entry = {type, id, stats};
 302
 303     // Adds each new value to the map of stats history.
 304     std::map<string, string>::iterator iter;
 305     for (iter = stats.values.begin(); iter != stats.values.end(); iter++) {
 306       pc.stats_[id][iter->first].push_back(iter->second);
 307     }
 308     std::stringstream ss;
 309     ss << "{pid:" << pc.pid_ << ", lid:" << pc.lid_ << ","
 310            "reports:[" << "{id:'" << id << "', type:'" << type << "', "
 311                            "stats:" << stats.GetString() << "}]}";
 312
 313     ASSERT_TRUE(ExecuteJavascript("addStats(" + ss.str() + ")"));
 314     VerifyStatsTable(pc, entry);
 315   }
 316
 317
 318   // Verifies that the stats table has the right content.
 319   void VerifyStatsTable(const PeerConnectionEntry& pc,
 320                         const StatsEntry& report) {
 321     string table_id =
 322         pc.getIdString() + "-table-" + report.id;
 323     VerifyElementWithId(table_id);
 324
 325     std::map<string, string>::const_iterator iter;
 326     for (iter = report.stats.values.begin();
 327          iter != report.stats.values.end(); iter++) {
 328       VerifyStatsTableRow(table_id, iter->first, iter->second);
 329     }
 330   }
 331
 332   // Verifies that the row named as |name| of the stats table |table_id| has
 333   // the correct content as |name| : |value|.
 334   void VerifyStatsTableRow(const string& table_id,
 335                            const string& name,
 336                            const string& value) {
 337     VerifyElementWithId(table_id + "-" + name);
 338
 339     string result;
 340     ASSERT_TRUE(ExecuteScriptAndExtractString(
 341         shell()->web_contents(),
 342         "var row = $('" + table_id + "-" + name + "');"
 343         "var name = row.cells[0].textContent;"
 344         "var value = row.cells[1].textContent;"
 345         "window.domAutomationController.send(name + ':' + value)",
 346         &result));
 347     EXPECT_EQ(name + ":" + value, result);
 348   }
 349
 350   // Verifies that the graph data series consistent with pc.stats_.
 351   void VerifyStatsGraph(const PeerConnectionEntry& pc) {
 352     std::map<string, StatsMap>::const_iterator stream_iter;
 353     for (stream_iter = pc.stats_.begin();
 354          stream_iter != pc.stats_.end(); stream_iter++) {
 355       StatsMap::const_iterator stats_iter;
 356       for (stats_iter = stream_iter->second.begin();
 357            stats_iter != stream_iter->second.end();
 358            stats_iter++) {
 359         string graph_id = stream_iter->first + "-" + stats_iter->first;
 360         for (size_t i = 0; i < stats_iter->second.size(); ++i) {
 361           float number;
 362           std::stringstream stream(stats_iter->second[i]);
 363           stream >> number;
 364           if (stream.fail())
 365             continue;
 366           VerifyGraphDataPoint(
 367               pc.getIdString(), graph_id, i, stats_iter->second[i]);
 368         }
 369       }
 370     }
 371   }
 372
 373   // Verifies that the graph data point at index |index| has value |value|.
 374   void VerifyGraphDataPoint(const string& pc_id, const string& graph_id,
 375                             int index, const string& value) {
 376     bool result = false;
 377     ASSERT_TRUE(ExecuteScriptAndExtractBool(
 378         shell()->web_contents(),
 379         "window.domAutomationController.send("
 380            "graphViews['" + pc_id + "-" + graph_id + "'] != null)",
 381         &result));
 382     EXPECT_TRUE(result);
 383
 384     std::stringstream ss;
 385     ss << "var dp = peerConnectionDataStore['" << pc_id << "']"
 386           ".getDataSeries('" << graph_id << "').dataPoints_[" << index << "];"
 387           "window.domAutomationController.send(dp.value.toString())";
 388     string actual_value;
 389     ASSERT_TRUE(ExecuteScriptAndExtractString(
 390         shell()->web_contents(), ss.str(), &actual_value));
 391     EXPECT_EQ(value, actual_value);
 392   }
 393
 394   // Get the JSON string of the ssrc info from the page.
 395   string GetSsrcInfo(const string& ssrc_id) {
 396     string result;
 397     EXPECT_TRUE(ExecuteScriptAndExtractString(
 398         shell()->web_contents(),
 399         "window.domAutomationController.send(JSON.stringify("
 400            "ssrcInfoManager.streamInfoContainer_['" + ssrc_id + "']))",
 401         &result));
 402     return result;
 403   }
 404
 405   int GetSsrcInfoBlockCount(Shell* shell) {
 406     int count = 0;
 407     EXPECT_TRUE(ExecuteScriptAndExtractInt(
 408         shell->web_contents(),
 409         "window.domAutomationController.send("
 410             "document.getElementsByClassName("
 411                 "ssrcInfoManager.SSRC_INFO_BLOCK_CLASS).length);",
 412         &count));
 413     return count;
 414   }
 415
 416   // Verifies |dump| contains |peer_connection_number| peer connection dumps,
 417   // each containing |update_number| updates and |stats_number| stats tables.
 418   void VerifyPageDumpStructure(base::Value* dump,
 419                                int peer_connection_number,
 420                                int update_number,
 421                                int stats_number) {
 422     EXPECT_NE((base::Value*)NULL, dump);
 423     EXPECT_EQ(base::Value::TYPE_DICTIONARY, dump->GetType());
 424
 425     base::DictionaryValue* dict_dump =
 426         static_cast<base::DictionaryValue*>(dump);
 427     EXPECT_EQ((size_t) peer_connection_number, dict_dump->size());
 428
 429     base::DictionaryValue::Iterator it(*dict_dump);
 430     for (; !it.IsAtEnd(); it.Advance()) {
 431       base::Value* value = NULL;
 432       dict_dump->Get(it.key(), &value);
 433       EXPECT_EQ(base::Value::TYPE_DICTIONARY, value->GetType());
 434       base::DictionaryValue* pc_dump =
 435           static_cast<base::DictionaryValue*>(value);
 436       EXPECT_TRUE(pc_dump->HasKey("updateLog"));
 437       EXPECT_TRUE(pc_dump->HasKey("stats"));
 438
 439       // Verifies the number of updates.
 440       pc_dump->Get("updateLog", &value);
 441       EXPECT_EQ(base::Value::TYPE_LIST, value->GetType());
 442       base::ListValue* list = static_cast<base::ListValue*>(value);
 443       EXPECT_EQ((size_t) update_number, list->GetSize());
 444
 445       // Verifies the number of stats tables.
 446       pc_dump->Get("stats", &value);
 447       EXPECT_EQ(base::Value::TYPE_DICTIONARY, value->GetType());
 448       base::DictionaryValue* dict = static_cast<base::DictionaryValue*>(value);
 449       EXPECT_EQ((size_t) stats_number, dict->size());
 450     }
 451   }
 452
 453   // Verifies |dump| contains the correct statsTable and statsDataSeries for
 454   // |pc|.
 455   void VerifyStatsDump(base::Value* dump,
 456                        const PeerConnectionEntry& pc,
 457                        const string& report_type,
 458                        const string& report_id,
 459                        const StatsUnit& stats) {
 460     EXPECT_NE((base::Value*)NULL, dump);
 461     EXPECT_EQ(base::Value::TYPE_DICTIONARY, dump->GetType());
 462
 463     base::DictionaryValue* dict_dump =
 464         static_cast<base::DictionaryValue*>(dump);
 465     base::Value* value = NULL;
 466     dict_dump->Get(pc.getIdString(), &value);
 467     base::DictionaryValue* pc_dump = static_cast<base::DictionaryValue*>(value);
 468
 469     // Verifies there is one data series per stats name.
 470     value = NULL;
 471     pc_dump->Get("stats", &value);
 472     EXPECT_EQ(base::Value::TYPE_DICTIONARY, value->GetType());
 473
 474     base::DictionaryValue* dataSeries =
 475         static_cast<base::DictionaryValue*>(value);
 476     EXPECT_EQ(stats.values.size(), dataSeries->size());
 477   }
 478 };
 479
 480 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest,
 481                        AddAndRemovePeerConnection) {
 482   GURL url("chrome://webrtc-internals");
 483   NavigateToURL(shell(), url);
 484
 485   // Add two PeerConnections and then remove them.
 486   PeerConnectionEntry pc_1(1, 0);
 487   ExecuteAddPeerConnectionJs(pc_1);
 488   VerifyPeerConnectionEntry(pc_1);
 489
 490   PeerConnectionEntry pc_2(2, 1);
 491   ExecuteAddPeerConnectionJs(pc_2);
 492   VerifyPeerConnectionEntry(pc_2);
 493
 494   ExecuteRemovePeerConnectionJs(pc_1);
 495   VerifyNoElementWithId(pc_1.getIdString());
 496   VerifyPeerConnectionEntry(pc_2);
 497
 498   ExecuteRemovePeerConnectionJs(pc_2);
 499   VerifyNoElementWithId(pc_2.getIdString());
 500 }
 501
 502 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest,
 503                        UpdateAllPeerConnections) {
 504   GURL url("chrome://webrtc-internals");
 505   NavigateToURL(shell(), url);
 506
 507   PeerConnectionEntry pc_0(1, 0);
 508   pc_0.AddEvent("e1", "v1");
 509   pc_0.AddEvent("e2", "v2");
 510   PeerConnectionEntry pc_1(1, 1);
 511   pc_1.AddEvent("e3", "v3");
 512   pc_1.AddEvent("e4", "v4");
 513   string pc_array = "[" + pc_0.getAllUpdateString() + ", " +
 514                           pc_1.getAllUpdateString() + "]";
 515   EXPECT_TRUE(ExecuteJavascript("updateAllPeerConnections(" + pc_array + ");"));
 516   VerifyPeerConnectionEntry(pc_0);
 517   VerifyPeerConnectionEntry(pc_1);
 518 }
 519
 520 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest, UpdatePeerConnection) {
 521   GURL url("chrome://webrtc-internals");
 522   NavigateToURL(shell(), url);
 523
 524   // Add one PeerConnection and send one update.
 525   PeerConnectionEntry pc_1(1, 0);
 526   ExecuteAddPeerConnectionJs(pc_1);
 527
 528   ExecuteAndVerifyUpdatePeerConnection(pc_1, "e1", "v1");
 529
 530   // Add another PeerConnection and send two updates.
 531   PeerConnectionEntry pc_2(1, 1);
 532   ExecuteAddPeerConnectionJs(pc_2);
 533
 534   SsrcEntry ssrc1, ssrc2;
 535   ssrc1.id = "ssrcid1";
 536   ssrc1.properties["msid"] = "mymsid";
 537   ssrc2.id = "ssrcid2";
 538   ssrc2.properties["label"] = "mylabel";
 539   ssrc2.properties["cname"] = "mycname";
 540
 541   ExecuteAndVerifyUpdatePeerConnection(pc_2, "setRemoteDescription",
 542       ssrc1.GetSsrcAttributeString());
 543
 544   ExecuteAndVerifyUpdatePeerConnection(pc_2, "setLocalDescription",
 545       ssrc2.GetSsrcAttributeString());
 546
 547   EXPECT_EQ(ssrc1.GetAsJSON(), GetSsrcInfo(ssrc1.id));
 548   EXPECT_EQ(ssrc2.GetAsJSON(), GetSsrcInfo(ssrc2.id));
 549
 550   StatsUnit stats = {FAKE_TIME_STAMP};
 551   stats.values["ssrc"] = ssrc1.id;
 552   ExecuteAndVerifyAddStats(pc_2, "ssrc", "dummyId", stats);
 553   EXPECT_GT(GetSsrcInfoBlockCount(shell()), 0);
 554 }
 555
 556 // Tests that adding random named stats updates the dataSeries and graphs.
 557 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest, AddStats) {
 558   GURL url("chrome://webrtc-internals");
 559   NavigateToURL(shell(), url);
 560
 561   PeerConnectionEntry pc(1, 0);
 562   ExecuteAddPeerConnectionJs(pc);
 563
 564   const string type = "ssrc";
 565   const string id = "ssrc-1234";
 566   StatsUnit stats = {FAKE_TIME_STAMP};
 567   stats.values["trackId"] = "abcd";
 568   stats.values["bitrate"] = "2000";
 569   stats.values["framerate"] = "30";
 570
 571   // Add new stats and verify the stats table and graphs.
 572   ExecuteAndVerifyAddStats(pc, type, id, stats);
 573   VerifyStatsGraph(pc);
 574
 575   // Update existing stats and verify the stats table and graphs.
 576   stats.values["bitrate"] = "2001";
 577   stats.values["framerate"] = "31";
 578   ExecuteAndVerifyAddStats(pc, type, id, stats);
 579   VerifyStatsGraph(pc);
 580 }
 581
 582 // Tests that the bandwidth estimation values are drawn on a single graph.
 583 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest, BweCompoundGraph) {
 584   GURL url("chrome://webrtc-internals");
 585   NavigateToURL(shell(), url);
 586
 587   PeerConnectionEntry pc(1, 0);
 588   ExecuteAddPeerConnectionJs(pc);
 589
 590   StatsUnit stats = {FAKE_TIME_STAMP};
 591   stats.values["googAvailableSendBandwidth"] = "1000000";
 592   stats.values["googTargetEncBitrate"] = "1000";
 593   stats.values["googActualEncBitrate"] = "1000000";
 594   stats.values["googRetransmitBitrate"] = "10";
 595   stats.values["googTransmitBitrate"] = "1000000";
 596   const string stats_type = "bwe";
 597   const string stats_id = "videobwe";
 598   ExecuteAndVerifyAddStats(pc, stats_type, stats_id, stats);
 599
 600   string graph_id =
 601       pc.getIdString() + "-" + stats_id + "-bweCompound";
 602   bool result = false;
 603   // Verify that the bweCompound graph exists.
 604   ASSERT_TRUE(ExecuteScriptAndExtractBool(
 605         shell()->web_contents(),
 606         "window.domAutomationController.send("
 607         "   graphViews['" + graph_id + "'] != null)",
 608         &result));
 609   EXPECT_TRUE(result);
 610
 611   // Verify that the bweCompound graph contains multiple dataSeries.
 612   int count = 0;
 613   ASSERT_TRUE(ExecuteScriptAndExtractInt(
 614         shell()->web_contents(),
 615         "window.domAutomationController.send("
 616         "   graphViews['" + graph_id + "'].getDataSeriesCount())",
 617         &count));
 618   EXPECT_EQ((int)stats.values.size(), count);
 619 }
 620
 621 // Tests that the total packet/byte count is converted to count per second,
 622 // and the converted data is drawn.
 623 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest, ConvertedGraphs) {
 624   GURL url("chrome://webrtc-internals");
 625   NavigateToURL(shell(), url);
 626
 627   PeerConnectionEntry pc(1, 0);
 628   ExecuteAddPeerConnectionJs(pc);
 629
 630   const string stats_type = "s";
 631   const string stats_id = "1";
 632   const int num_converted_stats = 4;
 633   const string stats_names[] =
 634       {"packetsSent", "bytesSent", "packetsReceived", "bytesReceived"};
 635   const string converted_names[] =
 636       {"packetsSentPerSecond", "bitsSentPerSecond",
 637        "packetsReceivedPerSecond", "bitsReceivedPerSecond"};
 638   const string first_value = "1000";
 639   const string second_value = "2000";
 640   const string converted_values[] = {"1000", "8000", "1000", "8000"};
 641
 642   // Send the first data point.
 643   StatsUnit stats = {FAKE_TIME_STAMP};
 644   for (int i = 0; i < num_converted_stats; ++i)
 645     stats.values[stats_names[i]] = first_value;
 646
 647   ExecuteAndVerifyAddStats(pc, stats_type, stats_id, stats);
 648
 649   // Send the second data point at 1000ms after the first data point.
 650   stats.timestamp += 1000;
 651   for (int i = 0; i < num_converted_stats; ++i)
 652     stats.values[stats_names[i]] = second_value;
 653   ExecuteAndVerifyAddStats(pc, stats_type, stats_id, stats);
 654
 655   // Verifies the graph data matches converted_values.
 656   for (int i = 0; i < num_converted_stats; ++i) {
 657     VerifyGraphDataPoint(pc.getIdString(), stats_id + "-" + converted_names[i],
 658                          1, converted_values[i]);
 659   }
 660 }
 661
 662 // Timing out on ARM linux bot: http://crbug.com/238490
 663 // Disabling due to failure on Linux, Mac, Win: http://crbug.com/272413
 664 // Sanity check of the page content under a real PeerConnection call.
 665 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest,
 666                        DISABLED_WithRealPeerConnectionCall) {
 667   // Start a peerconnection call in the first window.
 668   ASSERT_TRUE(embedded_test_server()->InitializeAndWaitUntilReady());
 669   GURL url(embedded_test_server()->GetURL("/media/peerconnection-call.html"));
 670   NavigateToURL(shell(), url);
 671   ASSERT_TRUE(ExecuteJavascript("call({video:true});"));
 672   ExpectTitle("OK");
 673
 674   // Open webrtc-internals in the second window.
 675   GURL url2("chrome://webrtc-internals");
 676   Shell* shell2 = CreateBrowser();
 677   NavigateToURL(shell2, url2);
 678
 679   const int NUMBER_OF_PEER_CONNECTIONS = 2;
 680
 681   // Verifies the number of peerconnections.
 682   int count = 0;
 683   ASSERT_TRUE(ExecuteScriptAndExtractInt(
 684       shell2->web_contents(),
 685       "window.domAutomationController.send("
 686           "$('peer-connections-list').getElementsByTagName('li').length);",
 687       &count));
 688   EXPECT_EQ(NUMBER_OF_PEER_CONNECTIONS, count);
 689
 690   // Verifies the the event tables.
 691   ASSERT_TRUE(ExecuteScriptAndExtractInt(
 692       shell2->web_contents(),
 693       "window.domAutomationController.send($('peer-connections-list')"
 694           ".getElementsByClassName('update-log-table').length);",
 695       &count));
 696   EXPECT_EQ(NUMBER_OF_PEER_CONNECTIONS, count);
 697
 698   ASSERT_TRUE(ExecuteScriptAndExtractInt(
 699       shell2->web_contents(),
 700       "window.domAutomationController.send($('peer-connections-list')"
 701           ".getElementsByClassName('update-log-table')[0].rows.length);",
 702       &count));
 703   EXPECT_GT(count, 1);
 704
 705   ASSERT_TRUE(ExecuteScriptAndExtractInt(
 706       shell2->web_contents(),
 707       "window.domAutomationController.send($('peer-connections-list')"
 708           ".getElementsByClassName('update-log-table')[1].rows.length);",
 709       &count));
 710   EXPECT_GT(count, 1);
 711
 712   // Wait until the stats table containers are created.
 713   count = 0;
 714   while (count != NUMBER_OF_PEER_CONNECTIONS) {
 715     ASSERT_TRUE(ExecuteScriptAndExtractInt(
 716         shell2->web_contents(),
 717         "window.domAutomationController.send("
 718             "$('peer-connections-list').getElementsByClassName("
 719                 "'stats-table-container').length);",
 720         &count));
 721   }
 722
 723   // Verifies each stats table having more than one rows.
 724   bool result = false;
 725   ASSERT_TRUE(ExecuteScriptAndExtractBool(
 726       shell2->web_contents(),
 727       "var tableContainers = $('peer-connections-list')"
 728           ".getElementsByClassName('stats-table-container');"
 729       "var result = true;"
 730       "for (var i = 0; i < tableContainers.length && result; ++i) {"
 731         "var tables = tableContainers[i].getElementsByTagName('table');"
 732         "for (var j = 0; j < tables.length && result; ++j) {"
 733           "result = (tables[j].rows.length > 1);"
 734         "}"
 735         "if (!result) {"
 736           "console.log(tableContainers[i].innerHTML);"
 737         "}"
 738       "}"
 739       "window.domAutomationController.send(result);",
 740       &result));
 741
 742   EXPECT_TRUE(result);
 743
 744   count = GetSsrcInfoBlockCount(shell2);
 745   EXPECT_GT(count, 0);
 746 }
 747
 748 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest, CreatePageDump) {
 749   GURL url("chrome://webrtc-internals");
 750   NavigateToURL(shell(), url);
 751
 752   PeerConnectionEntry pc_0(1, 0);
 753   pc_0.AddEvent("e1", "v1");
 754   pc_0.AddEvent("e2", "v2");
 755   PeerConnectionEntry pc_1(1, 1);
 756   pc_1.AddEvent("e3", "v3");
 757   pc_1.AddEvent("e4", "v4");
 758   string pc_array =
 759       "[" + pc_0.getAllUpdateString() + ", " + pc_1.getAllUpdateString() + "]";
 760   EXPECT_TRUE(ExecuteJavascript("updateAllPeerConnections(" + pc_array + ");"));
 761
 762   // Verifies the peer connection data store can be created without stats.
 763   string dump_json;
 764   ASSERT_TRUE(ExecuteScriptAndExtractString(
 765       shell()->web_contents(),
 766       "window.domAutomationController.send("
 767       "JSON.stringify(peerConnectionDataStore));",
 768       &dump_json));
 769   scoped_ptr<base::Value> dump;
 770   dump.reset(base::JSONReader::Read(dump_json));
 771   VerifyPageDumpStructure(dump.get(),
 772                           2 /*peer_connection_number*/,
 773                           2 /*update_number*/,
 774                           0 /*stats_number*/);
 775
 776   // Adds a stats report.
 777   const string type = "dummy";
 778   const string id = "1234";
 779   StatsUnit stats = { FAKE_TIME_STAMP };
 780   stats.values["bitrate"] = "2000";
 781   stats.values["framerate"] = "30";
 782   ExecuteAndVerifyAddStats(pc_0, type, id, stats);
 783
 784   ASSERT_TRUE(ExecuteScriptAndExtractString(
 785       shell()->web_contents(),
 786       "window.domAutomationController.send("
 787       "JSON.stringify(peerConnectionDataStore));",
 788       &dump_json));
 789   dump.reset(base::JSONReader::Read(dump_json));
 790   VerifyStatsDump(dump.get(), pc_0, type, id, stats);
 791 }
 792
 793 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest, UpdateGetUserMedia) {
 794   GURL url("chrome://webrtc-internals");
 795   NavigateToURL(shell(), url);
 796
 797   UserMediaRequestEntry request1(1, 1, "origin", "ac", "vc");
 798   UserMediaRequestEntry request2(2, 2, "origin2", "ac2", "vc2");
 799   ExecuteAddGetUserMediaJs(request1);
 800   ExecuteAddGetUserMediaJs(request2);
 801
 802   std::vector<UserMediaRequestEntry> list;
 803   list.push_back(request1);
 804   list.push_back(request2);
 805   VerifyUserMediaRequest(list);
 806
 807   ExecuteRemoveGetUserMediaForRendererJs(1);
 808   list.erase(list.begin());
 809   VerifyUserMediaRequest(list);
 810
 811   ExecuteRemoveGetUserMediaForRendererJs(2);
 812   list.erase(list.begin());
 813   VerifyUserMediaRequest(list);
 814 }
 815
 816 // Tests that the received propagation delta values are converted and drawn
 817 // correctly.
 818 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest,
 819                        ReceivedPropagationDelta) {
 820   GURL url("chrome://webrtc-internals");
 821   NavigateToURL(shell(), url);
 822
 823   PeerConnectionEntry pc(1, 0);
 824   ExecuteAddPeerConnectionJs(pc);
 825
 826   StatsUnit stats = {FAKE_TIME_STAMP};
 827   stats.values["googReceivedPacketGroupArrivalTimeDebug"] =
 828       "[1000, 1100, 1200]";
 829   stats.values["googReceivedPacketGroupPropagationDeltaDebug"] =
 830       "[10, 20, 30]";
 831   const string stats_type = "bwe";
 832   const string stats_id = "videobwe";
 833   ExecuteAndVerifyAddStats(pc, stats_type, stats_id, stats);
 834
 835   string graph_id = pc.getIdString() + "-" + stats_id +
 836       "-googReceivedPacketGroupPropagationDeltaDebug";
 837   string data_series_id =
 838       stats_id + "-googReceivedPacketGroupPropagationDeltaDebug";
 839   bool result = false;
 840   // Verify that the graph exists.
 841   ASSERT_TRUE(ExecuteScriptAndExtractBool(
 842       shell()->web_contents(),
 843       "window.domAutomationController.send("
 844       "   graphViews['" + graph_id + "'] != null)",
 845       &result));
 846   EXPECT_TRUE(result);
 847
 848   // Verify that the graph contains multiple data points.
 849   int count = 0;
 850   ASSERT_TRUE(ExecuteScriptAndExtractInt(
 851       shell()->web_contents(),
 852       "window.domAutomationController.send("
 853       "   graphViews['" + graph_id + "'].getDataSeriesCount())",
 854       &count));
 855   EXPECT_EQ(1, count);
 856   ASSERT_TRUE(ExecuteScriptAndExtractInt(
 857       shell()->web_contents(),
 858       "window.domAutomationController.send("
 859       "   peerConnectionDataStore['" + pc.getIdString() + "']" +
 860       "       .getDataSeries('" + data_series_id + "').getCount())",
 861       &count));
 862   EXPECT_EQ(3, count);
 863 }
 864
 865 }  // namespace content