Extend the ToRenderFrameHost magic to FrameTreeNode* and Shell*

content/browser/media/webrtc/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 <stddef.h>
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/json/json_reader.h"
 #include "base/strings/utf_string_conversions.h"
@@ skipping 146 matching lines @@
 
   void SetUpOnMainThread() override {
     base::CommandLine::ForCurrentProcess()->AppendSwitch(
         switches::kUseFakeUIForMediaStream);
     ASSERT_TRUE(base::CommandLine::ForCurrentProcess()->HasSwitch(
         switches::kUseFakeDeviceForMediaStream));
   }
 
  protected:
   bool ExecuteJavascript(const string& javascript) {
-    return ExecuteScript(shell()->web_contents(), javascript);
+    return ExecuteScript(shell(), javascript);
   }
 
   void ExpectTitle(const std::string& expected_title) const {
     base::string16 expected_title16(base::ASCIIToUTF16(expected_title));
     TitleWatcher title_watcher(shell()->web_contents(), expected_title16);
     EXPECT_EQ(expected_title16, title_watcher.WaitAndGetTitle());
   }
 
   // Execute the javascript of addPeerConnection.
   void ExecuteAddPeerConnectionJs(const PeerConnectionEntry& pc) {
@@ skipping 26 matching lines @@
     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(),
+        shell(),
         "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(),
+        shell(),
         "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));
+    ASSERT_TRUE(
+        ExecuteScriptAndExtractString(shell(),
+                                      "window.domAutomationController.send("
+                                      "    JSON.stringify(userMediaRequests));",
+                                      &json_requests));
     std::unique_ptr<base::Value> value_requests =
         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);
     }
 
     bool user_media_tab_existed = false;
-    ASSERT_TRUE(ExecuteScriptAndExtractBool(
-        shell()->web_contents(),
-        "window.domAutomationController.send("
-            "$('user-media-tab-id') != null);",
-        &user_media_tab_existed));
+    ASSERT_TRUE(
+        ExecuteScriptAndExtractBool(shell(),
+                                    "window.domAutomationController.send("
+                                    "    $('user-media-tab-id') != null);",
+                                    &user_media_tab_existed));
     EXPECT_EQ(!requests.empty(), user_media_tab_existed);
 
     if (user_media_tab_existed) {
       int user_media_request_count = -1;
       ASSERT_TRUE(ExecuteScriptAndExtractInt(
-          shell()->web_contents(),
+          shell(),
           "window.domAutomationController.send("
-              "$('user-media-tab-id').childNodes.length);",
+          "    $('user-media-tab-id').childNodes.length);",
           &user_media_request_count));
       ASSERT_EQ(requests.size(), static_cast<size_t>(user_media_request_count));
     }
   }
 
   // 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) {
       std::stringstream ss;
       ss << "var row = $('" << log_id << "').rows[" << (i + 1) << "];"
             "var cell = row.lastChild;"
             "window.domAutomationController.send(cell.firstChild.textContent);";
-      ASSERT_TRUE(ExecuteScriptAndExtractString(
-          shell()->web_contents(), ss.str(), &result));
+      ASSERT_TRUE(ExecuteScriptAndExtractString(shell(), ss.str(), &result));
       EXPECT_EQ(pc.events_[i].type + pc.events_[i].value, result);
     }
   }
 
   // Executes the javascript of updatePeerConnection and verifies the result.
   void ExecuteAndVerifyUpdatePeerConnection(
       PeerConnectionEntry& pc, const string& type, const string& value) {
     pc.AddEvent(type, value);
 
     std::stringstream ss;
@@ skipping 41 matching lines @@
 
   // Verifies that the row named as |name| of the stats table |table_id| has
   // the correct content as |name| : |value|.
   void VerifyStatsTableRow(const string& table_id,
                            const string& name,
                            const string& value) {
     VerifyElementWithId(table_id + "-" + name);
 
     string result;
     ASSERT_TRUE(ExecuteScriptAndExtractString(
-        shell()->web_contents(),
+        shell(),
         "var row = $('" + table_id + "-" + name + "');"
         "var name = row.cells[0].textContent;"
         "var value = row.cells[1].textContent;"
         "window.domAutomationController.send(name + ':' + value)",
         &result));
     EXPECT_EQ(name + ":" + value, result);
   }
 
   // Verifies that the graph data series consistent with pc.stats_.
   void VerifyStatsGraph(const PeerConnectionEntry& pc) {
@@ skipping 16 matching lines @@
         }
       }
     }
   }
 
   // Verifies that the graph data point at index |index| has value |value|.
   void VerifyGraphDataPoint(const string& pc_id, const string& graph_id,
                             int index, const string& value) {
     bool result = false;
     ASSERT_TRUE(ExecuteScriptAndExtractBool(
-        shell()->web_contents(),
+        shell(),
         "window.domAutomationController.send("
            "graphViews['" + pc_id + "-" + graph_id + "'] != null)",
         &result));
     EXPECT_TRUE(result);
 
     std::stringstream ss;
     ss << "var dp = peerConnectionDataStore['" << pc_id << "']"
           ".getDataSeries('" << graph_id << "').dataPoints_[" << index << "];"
           "window.domAutomationController.send(dp.value.toString())";
     string actual_value;
-    ASSERT_TRUE(ExecuteScriptAndExtractString(
-        shell()->web_contents(), ss.str(), &actual_value));
+    ASSERT_TRUE(
+        ExecuteScriptAndExtractString(shell(), ss.str(), &actual_value));
     EXPECT_EQ(value, actual_value);
   }
 
   // Get the JSON string of the ssrc info from the page.
   string GetSsrcInfo(const string& ssrc_id) {
     string result;
     EXPECT_TRUE(ExecuteScriptAndExtractString(
-        shell()->web_contents(),
+        shell(),
         "window.domAutomationController.send(JSON.stringify("
            "ssrcInfoManager.streamInfoContainer_['" + ssrc_id + "']))",
         &result));
     return result;
   }
 
   int GetSsrcInfoBlockCount(Shell* shell) {
     int count = 0;
     EXPECT_TRUE(ExecuteScriptAndExtractInt(
-        shell->web_contents(),
+        shell,
         "window.domAutomationController.send("
-            "document.getElementsByClassName("
-                "ssrcInfoManager.SSRC_INFO_BLOCK_CLASS).length);",
+        "    document.getElementsByClassName("
+        "        ssrcInfoManager.SSRC_INFO_BLOCK_CLASS).length);",
         &count));
     return count;
   }
 
   // Verifies |dump| contains |peer_connection_number| peer connection dumps,
   // each containing |update_number| updates and |stats_number| stats tables.
   void VerifyPageDumpStructure(base::Value* dump,
                                int peer_connection_number,
                                int update_number,
                                int stats_number) {
@@ skipping 173 matching lines @@
   stats.values["googTransmitBitrate"] = "1000000";
   const string stats_type = "bwe";
   const string stats_id = "videobwe";
   ExecuteAndVerifyAddStats(pc, stats_type, stats_id, stats);
 
   string graph_id =
       pc.getIdString() + "-" + stats_id + "-bweCompound";
   bool result = false;
   // Verify that the bweCompound graph exists.
   ASSERT_TRUE(ExecuteScriptAndExtractBool(
-        shell()->web_contents(),
+        shell(),
         "window.domAutomationController.send("
         "   graphViews['" + graph_id + "'] != null)",
         &result));
   EXPECT_TRUE(result);
 
   // Verify that the bweCompound graph contains multiple dataSeries.
   int count = 0;
   ASSERT_TRUE(ExecuteScriptAndExtractInt(
-        shell()->web_contents(),
+        shell(),
         "window.domAutomationController.send("
         "   graphViews['" + graph_id + "'].getDataSeriesCount())",
         &count));
   EXPECT_EQ((int)stats.values.size(), count);
 }
 
 // Tests that the total packet/byte count is converted to count per second,
 // and the converted data is drawn.
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest, ConvertedGraphs) {
   GURL url("chrome://webrtc-internals");
@@ skipping 49 matching lines @@
   // Open webrtc-internals in the second window.
   GURL url2("chrome://webrtc-internals");
   Shell* shell2 = CreateBrowser();
   NavigateToURL(shell2, url2);
 
   const int NUMBER_OF_PEER_CONNECTIONS = 2;
 
   // Verifies the number of peerconnections.
   int count = 0;
   ASSERT_TRUE(ExecuteScriptAndExtractInt(
-      shell2->web_contents(),
+      shell2,
       "window.domAutomationController.send("
-          "$('peer-connections-list').getElementsByTagName('li').length);",
+      "    $('peer-connections-list').getElementsByTagName('li').length);",
       &count));
   EXPECT_EQ(NUMBER_OF_PEER_CONNECTIONS, count);
 
   // Verifies the the event tables.
   ASSERT_TRUE(ExecuteScriptAndExtractInt(
-      shell2->web_contents(),
+      shell2,
       "window.domAutomationController.send($('peer-connections-list')"
-          ".getElementsByClassName('update-log-table').length);",
+      "    .getElementsByClassName('update-log-table').length);",
       &count));
   EXPECT_EQ(NUMBER_OF_PEER_CONNECTIONS, count);
 
   ASSERT_TRUE(ExecuteScriptAndExtractInt(
-      shell2->web_contents(),
+      shell2,
       "window.domAutomationController.send($('peer-connections-list')"
-          ".getElementsByClassName('update-log-table')[0].rows.length);",
+      "    .getElementsByClassName('update-log-table')[0].rows.length);",
       &count));
   EXPECT_GT(count, 1);
 
   ASSERT_TRUE(ExecuteScriptAndExtractInt(
-      shell2->web_contents(),
+      shell2,
       "window.domAutomationController.send($('peer-connections-list')"
-          ".getElementsByClassName('update-log-table')[1].rows.length);",
+      "    .getElementsByClassName('update-log-table')[1].rows.length);",
       &count));
   EXPECT_GT(count, 1);
 
   // Wait until the stats table containers are created.
   count = 0;
   while (count != NUMBER_OF_PEER_CONNECTIONS) {
     ASSERT_TRUE(ExecuteScriptAndExtractInt(
-        shell2->web_contents(),
+        shell2,
         "window.domAutomationController.send("
-            "$('peer-connections-list').getElementsByClassName("
-                "'stats-table-container').length);",
+        "    $('peer-connections-list').getElementsByClassName("
+        "        'stats-table-container').length);",
         &count));
   }
 
   // Verifies each stats table having more than one rows.
   bool result = false;
   ASSERT_TRUE(ExecuteScriptAndExtractBool(
-      shell2->web_contents(),
+      shell2,
       "var tableContainers = $('peer-connections-list')"
-          ".getElementsByClassName('stats-table-container');"
+      "    .getElementsByClassName('stats-table-container');"
       "var result = true;"
       "for (var i = 0; i < tableContainers.length && result; ++i) {"
-        "var tables = tableContainers[i].getElementsByTagName('table');"
-        "for (var j = 0; j < tables.length && result; ++j) {"
-          "result = (tables[j].rows.length > 1);"
-        "}"
-        "if (!result) {"
-          "console.log(tableContainers[i].innerHTML);"
-        "}"
+      "  var tables = tableContainers[i].getElementsByTagName('table');"
+      "  for (var j = 0; j < tables.length && result; ++j) {"
+      "    result = (tables[j].rows.length > 1);"
+      "  }"
+      "  if (!result) {"
+      "    console.log(tableContainers[i].innerHTML);"
+      "  }"
       "}"
       "window.domAutomationController.send(result);",
       &result));
 
   EXPECT_TRUE(result);
 
   count = GetSsrcInfoBlockCount(shell2);
   EXPECT_GT(count, 0);
 }
 
 IN_PROC_BROWSER_TEST_F(MAYBE_WebRtcInternalsBrowserTest, CreatePageDump) {
   GURL url("chrome://webrtc-internals");
   NavigateToURL(shell(), url);
 
   PeerConnectionEntry pc_0(1, 0);
   pc_0.AddEvent("e1", "v1");
   pc_0.AddEvent("e2", "v2");
   PeerConnectionEntry pc_1(1, 1);
   pc_1.AddEvent("e3", "v3");
   pc_1.AddEvent("e4", "v4");
   string pc_array =
       "[" + pc_0.getAllUpdateString() + ", " + pc_1.getAllUpdateString() + "]";
   EXPECT_TRUE(ExecuteJavascript("updateAllPeerConnections(" + pc_array + ");"));
 
   // Verifies the peer connection data store can be created without stats.
   string dump_json;
   ASSERT_TRUE(ExecuteScriptAndExtractString(
-      shell()->web_contents(),
+      shell(),
       "window.domAutomationController.send("
-      "JSON.stringify(peerConnectionDataStore));",
+      "    JSON.stringify(peerConnectionDataStore));",
       &dump_json));
   std::unique_ptr<base::Value> dump = base::JSONReader::Read(dump_json);
   VerifyPageDumpStructure(dump.get(),
                           2 /*peer_connection_number*/,
                           2 /*update_number*/,
                           0 /*stats_number*/);
 
   // Adds a stats report.
   const string type = "dummy";
   const string id = "1234";
   StatsUnit stats = { FAKE_TIME_STAMP };
   stats.values["bitrate"] = "2000";
   stats.values["framerate"] = "30";
   ExecuteAndVerifyAddStats(pc_0, type, id, stats);
 
   ASSERT_TRUE(ExecuteScriptAndExtractString(
-      shell()->web_contents(),
+      shell(),
       "window.domAutomationController.send("
-      "JSON.stringify(peerConnectionDataStore));",
+      "    JSON.stringify(peerConnectionDataStore));",
       &dump_json));
   dump = 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");
@@ skipping 34 matching lines @@
   const string stats_id = "videobwe";
   ExecuteAndVerifyAddStats(pc, stats_type, stats_id, stats);
 
   string graph_id = pc.getIdString() + "-" + stats_id +
       "-googReceivedPacketGroupPropagationDeltaDebug";
   string data_series_id =
       stats_id + "-googReceivedPacketGroupPropagationDeltaDebug";
   bool result = false;
   // Verify that the graph exists.
   ASSERT_TRUE(ExecuteScriptAndExtractBool(
-      shell()->web_contents(),
+      shell(),
       "window.domAutomationController.send("
       "   graphViews['" + graph_id + "'] != null)",
       &result));
   EXPECT_TRUE(result);
 
   // Verify that the graph contains multiple data points.
   int count = 0;
   ASSERT_TRUE(ExecuteScriptAndExtractInt(
-      shell()->web_contents(),
+      shell(),
       "window.domAutomationController.send("
       "   graphViews['" + graph_id + "'].getDataSeriesCount())",
       &count));
   EXPECT_EQ(1, count);
   ASSERT_TRUE(ExecuteScriptAndExtractInt(
-      shell()->web_contents(),
+      shell(),
       "window.domAutomationController.send("
       "   peerConnectionDataStore['" + pc.getIdString() + "']" +
       "       .getDataSeries('" + data_series_id + "').getCount())",
       &count));
   EXPECT_EQ(3, count);
 }
 
 }  // namespace content