Add getUserMedia info to the dump and add browser tests.

content/browser/media/webrtc_internals_browsertest.cc

 // Copyright (c) 2013 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.
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/time/time.h"
 #include "base/values.h"
 #include "content/public/common/content_switches.h"
@@ skipping 98 matching lines @@
   int pid_;
   int lid_;
   std::vector<EventEntry> events_;
   // This is a record of the history of stats value reported for each stats
   // report id (e.g. ssrc-1234) for each stats name (e.g. framerate).
   // It a 2-D map with each map entry is a vector of reported values.
   // It is used to verify the graph data series.
   std::map<string, StatsMap> stats_;
 };
 
+class UserMediaRequestEntry {
+ public:
+  UserMediaRequestEntry(int pid,
+                        int rid,
+                        const std::string& origin,
+                        const std::string& audio_constraints,
+                        const std::string& video_constraints)
+      : pid(pid),
+        rid(rid),
+        origin(origin),
+        audio_constraints(audio_constraints),
+        video_constraints(video_constraints) {}
+
+  int pid;
+  int rid;
+  std::string origin;
+  std::string audio_constraints;
+  std::string video_constraints;
+};
+
 static const int64 FAKE_TIME_STAMP = 3600000;
 
 #if defined(OS_WIN)
 // All tests are flaky on Windows: crbug.com/277322.
 #define MAYBE_WebRTCInternalsBrowserTest DISABLED_WebRTCInternalsBrowserTest
 #else
 #define MAYBE_WebRTCInternalsBrowserTest WebRTCInternalsBrowserTest
 #endif
 
 class MAYBE_WebRTCInternalsBrowserTest: public ContentBrowserTest {
@@ skipping 30 matching lines @@
   }
 
   // Execute the javascript of removePeerConnection.
   void ExecuteRemovePeerConnectionJs(const PeerConnectionEntry& pc) {
     std::stringstream ss;
     ss << "{pid:" << pc.pid_ <<", lid:" << pc.lid_ << "}";
 
     ASSERT_TRUE(ExecuteJavascript("removePeerConnection(" + ss.str() + ");"));
   }
 
+  // Execute the javascript of addGetUserMedia.
+  void ExecuteAddGetUserMediaJs(const UserMediaRequestEntry& request) {
+    std::stringstream ss;
+    ss << "{pid:" << request.pid << ", rid:" << request.rid << ", origin:'"
+       << request.origin << "', audio:'" << request.audio_constraints
+       << "', video:'" << request.video_constraints << "'}";
+
+    ASSERT_TRUE(ExecuteJavascript("addGetUserMedia(" + ss.str() + ");"));
+  }
+
+  // Execute the javascript of removeGetUserMediaForRenderer.
+  void ExecuteRemoveGetUserMediaForRendererJs(int rid) {
+    std::stringstream ss;
+    ss << "{rid:" << rid << "}";
+    ASSERT_TRUE(
+        ExecuteJavascript("removeGetUserMediaForRenderer(" + ss.str() + ");"));
+  }
+
   // Verifies that the DOM element with id |id| exists.
   void VerifyElementWithId(const string& id) {
     bool result = false;
     ASSERT_TRUE(ExecuteScriptAndExtractBool(
         shell()->web_contents(),
         "window.domAutomationController.send($('" + id + "') != null);",
         &result));
     EXPECT_TRUE(result);
   }
 
   // Verifies that the DOM element with id |id| does not exist.
   void VerifyNoElementWithId(const string& id) {
     bool result = false;
     ASSERT_TRUE(ExecuteScriptAndExtractBool(
         shell()->web_contents(),
         "window.domAutomationController.send($('" + id + "') == null);",
         &result));
     EXPECT_TRUE(result);
   }
 
+  // Verifies the JS Array of userMediaRequests matches |requests|.
+  void VerifyUserMediaRequest(
+      const std::vector<UserMediaRequestEntry>& requests) {
+    string json_requests;
+    ASSERT_TRUE(ExecuteScriptAndExtractString(
+        shell()->web_contents(),
+        "window.domAutomationController.send("
+        "JSON.stringify(userMediaRequests));",
+        &json_requests));
+    scoped_ptr<base::Value> value_requests;
+    value_requests.reset(base::JSONReader::Read(json_requests));
+
+    EXPECT_EQ(base::Value::TYPE_LIST, value_requests->GetType());
+
+    base::ListValue* list_request =
+        static_cast<base::ListValue*>(value_requests.get());
+    EXPECT_EQ(requests.size(), list_request->GetSize());
+
+    for (size_t i = 0; i < requests.size(); ++i) {
+      base::DictionaryValue* dict = NULL;
+      ASSERT_TRUE(list_request->GetDictionary(i, &dict));
+      int pid, rid;
+      std::string origin, audio, video;
+      ASSERT_TRUE(dict->GetInteger("pid", &pid));
+      ASSERT_TRUE(dict->GetInteger("rid", &rid));
+      ASSERT_TRUE(dict->GetString("origin", &origin));
+      ASSERT_TRUE(dict->GetString("audio", &audio));
+      ASSERT_TRUE(dict->GetString("video", &video));
+      EXPECT_EQ(requests[i].pid, pid);
+      EXPECT_EQ(requests[i].rid, rid);
+      EXPECT_EQ(requests[i].origin, origin);
+      EXPECT_EQ(requests[i].audio_constraints, audio);
+      EXPECT_EQ(requests[i].video_constraints, video);
+    }
+  }
+
   // Verifies that DOM for |pc| is correctly created with the right content.
   void VerifyPeerConnectionEntry(const PeerConnectionEntry& pc) {
     VerifyElementWithId(pc.getIdString());
     if (pc.events_.size() == 0)
       return;
 
     string log_id = pc.getLogIdString();
     VerifyElementWithId(log_id);
     string result;
     for (size_t i = 0; i < pc.events_.size(); ++i) {
@@ skipping 509 matching lines @@
 
   ASSERT_TRUE(ExecuteScriptAndExtractString(
       shell()->web_contents(),
       "window.domAutomationController.send("
       "JSON.stringify(peerConnectionDataStore));",
       &dump_json));
   dump.reset(base::JSONReader::Read(dump_json));
   VerifyStatsDump(dump.get(), pc_0, type, id, stats);
 }
 
+IN_PROC_BROWSER_TEST_F(MAYBE_WebRTCInternalsBrowserTest, UpdateGetUserMedia) {
+  GURL url("chrome://webrtc-internals");
+  NavigateToURL(shell(), url);
+
+  UserMediaRequestEntry request1(1, 1, "origin", "ac", "vc");
+  UserMediaRequestEntry request2(2, 2, "origin2", "ac2", "vc2");
+  ExecuteAddGetUserMediaJs(request1);
+  ExecuteAddGetUserMediaJs(request2);
+
+  std::vector<UserMediaRequestEntry> list;
+  list.push_back(request1);
+  list.push_back(request2);
+  VerifyUserMediaRequest(list);
+
+  ExecuteRemoveGetUserMediaForRendererJs(1);
+  list.erase(list.begin());
+  VerifyUserMediaRequest(list);
+
+  ExecuteRemoveGetUserMediaForRendererJs(2);
+  list.erase(list.begin());
+  VerifyUserMediaRequest(list);
+}
 }  // namespace content