Implement OOPIFs within Devtools Extensions

chrome/browser/devtools/devtools_sanity_browsertest.cc

 // Copyright (c) 2012 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 <memory>

[ncarter (slow), 2017/03/15 20:01:02]

#include <vector>

[davidsac (gone - try alexmos), 2017/03/18 01:32:41]

Done.

 
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/files/file_path.h"
 #include "base/location.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
@@ skipping 14 matching lines @@
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/test_extension_dir.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/lifetime/application_lifetime.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/chrome_paths.h"
 #include "chrome/common/chrome_switches.h"
+#include "chrome/common/extensions/extension_process_policy.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/common/url_constants.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/test_chrome_web_ui_controller_factory.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/app_modal/javascript_app_modal_dialog.h"
 #include "components/app_modal/native_app_modal_dialog.h"
 #include "components/prefs/pref_service.h"
 #include "content/public/browser/child_process_data.h"
 #include "content/public/browser/content_browser_client.h"
 #include "content/public/browser/devtools_agent_host.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/notification_service.h"
+#include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/url_data_source.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_ui_controller.h"
 #include "content/public/browser/worker_service.h"
 #include "content/public/browser/worker_service_observer.h"
 #include "content/public/common/content_switches.h"
+#include "content/public/common/url_constants.h"
 #include "content/public/test/browser_test_utils.h"
 #include "content/public/test/test_navigation_observer.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "extensions/browser/notification_types.h"
 #include "extensions/common/switches.h"
 #include "extensions/common/value_builder.h"
 #include "net/dns/mock_host_resolver.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "net/test/url_request/url_request_mock_http_job.h"
@@ skipping 431 matching lines @@
     }
     size_t num_after = registry->enabled_extensions().size();
     if (num_after != (num_before + 1))
       return nullptr;
 
     if (!WaitForExtensionViewsToLoad())
       return nullptr;
 
     return GetExtensionByPath(registry->enabled_extensions(), path);
   }
 

[ncarter (slow), 2017/03/15 20:01:02]

  // Loads a dynamically generated extension populated with a bunch of test
  // pages. |name| is the extension name to use in the manifest.
  // |devtools_page|, if non-empty, indicates which test page should be be
  // listed as a devtools_page in the manifest. |panel_iframe_src| controls the
  // src= attribute of the <iframe> element in the 'panel.html' test page.

[davidsac (gone - try alexmos), 2017/03/18 01:32:41]

Done.  Good call on a comment here.  I also mentioned that a blank
|devtools_page| will create a non-devtools extension.

+  const Extension* LoadExtensionForTest(const std::string& name,
+                                        const std::string& devtools_page_url,

[ncarter (slow), 2017/03/15 20:01:02]

this actually isn't an URL, it's a file, right? Calling this 'devtools_page'
might be a better name.

[davidsac (gone - try alexmos), 2017/03/18 01:32:41]

Done.

+                                        const std::string& test_page_url) {

[ncarter (slow), 2017/03/15 20:01:02]

Rename "test_page_url -> panel_iframe_src"

[davidsac (gone - try alexmos), 2017/03/18 01:32:41]

Done.

+    test_extension_dirs_.push_back(
+        base::MakeUnique<extensions::TestExtensionDir>());
+    extensions::TestExtensionDir* dir = test_extension_dirs_.back().get();
+
+    extensions::DictionaryBuilder manifest;
+    manifest.Set("name", name)
+        .Set("version", "1")
+        .Set("manifest_version", 2)
+        // popup_test_page.html is currently the only page referenced outside of
+        // its own extension in the tests
+        .Set("web_accessible_resources",
+             extensions::ListBuilder().Append("popup_test_page.html").Build());
+    if (!devtools_page_url.empty()) {
+      manifest.Set("devtools_page", devtools_page_url);
+    }
+
+    dir->WriteManifest(manifest.ToJSON());
+
+    GURL http_popup_url =
+        embedded_test_server()->GetURL("a.com", "/popup_iframe.html");
+
+    dir->WriteFile(FILE_PATH_LITERAL("popup_devtools_page.html"),
+                   "<html><head></head><body><iframe src='" +
+                       http_popup_url.spec() + "'></iframe></body></html>");
+
+    dir->WriteFile(
+        FILE_PATH_LITERAL("panel_devtools_page.html"),
+        "<html><head><script "
+        "src='panel_devtools_page.js'></script></head><body></body></html>");
+
+    dir->WriteFile(
+        FILE_PATH_LITERAL("panel_devtools_page.js"),
+        "chrome.devtools.panels.create('iframe_panel',\n"
+        "    null,\n"
+        "    'panel.html',\n"
+        "    function(panel) {\n"
+        "      "
+        "chrome.devtools.inspectedWindow.eval('console.log("
+        "\"PASS\")');\n"
+        "    }\n"
+        ");\n"
+        "chrome.devtools.panels.elements.createSidebarPane('iframe_pane',\n"
+        "function(sidebar) {\n"
+        "chrome.devtools.inspectedWindow.eval('console.log(\"PASS\")');\n"
+        "sidebar.setPage('panel.html');\n"
+        "});\n");
+
+    dir->WriteFile(FILE_PATH_LITERAL("panel.html"),
+                   "<html><body><iframe src='" + test_page_url +
+                       "'></iframe></body></html>");
+
+    dir->WriteFile(FILE_PATH_LITERAL("simple_devtools_page.html"),
+                   "<html><head></head><body></body></html>");
+
+    dir->WriteFile(FILE_PATH_LITERAL("popup_test_page.html"),
+                   "<html><head><script "
+                   "src='popup_test_page.js'></script></head><body>This "
+                   "is a test</body></html>");
+
+    dir->WriteFile(FILE_PATH_LITERAL("popup_test_page.js"),
+                   "window.onload = function() {\n"
+                   "  domAutomationController.setAutomationId(0);\n"
+                   "  domAutomationController.send('DONE');\n"
+                   "}\n");
+
+    dir->WriteFile(FILE_PATH_LITERAL("simple_test_page.html"),
+                   "<html><head></head><body>This is a test</body></html>");
+
+    GURL about_blank_url = GURL(url::kAboutBlankURL);
+
+    GURL data_url = GURL("data:text/html,foo");
+
+    dir->WriteFile(FILE_PATH_LITERAL("renavigation_test_page.html"),
+                   "<html><body><iframe src='" + about_blank_url.spec() +
+                       "'></iframe><iframe src='" + data_url.spec() +
+                       "'></iframe><iframe src='" + http_popup_url.spec() +
+                       "'></iframe></body></html>");
+
+    // Install the extension.
+    const Extension* extension = LoadExtensionFromPath(dir->UnpackedPath());
+    return extension;
+  }
+
  private:
   const Extension* GetExtensionByPath(
       const extensions::ExtensionSet& extensions,
       const base::FilePath& path) {
     base::FilePath extension_path = base::MakeAbsoluteFilePath(path);
     EXPECT_TRUE(!extension_path.empty());
     for (const scoped_refptr<const Extension>& extension : extensions) {
       if (extension->path() == extension_path) {
         return extension.get();
       }
@@ skipping 38 matching lines @@
       case extensions::NOTIFICATION_EXTENSION_LOADED_DEPRECATED:
       case extensions::NOTIFICATION_EXTENSION_HOST_DID_STOP_FIRST_LOAD:
         base::MessageLoopForUI::current()->QuitWhenIdle();
         break;
       default:
         NOTREACHED();
         break;
     }
   }
 
+  std::vector<std::unique_ptr<extensions::TestExtensionDir>>
+      test_extension_dirs_;
   base::FilePath test_extensions_dir_;
 };
 
 class DevToolsExperimentalExtensionTest : public DevToolsExtensionTest {
  public:
   void SetUpCommandLine(base::CommandLine* command_line) override {
     command_line->AppendSwitch(
         extensions::switches::kEnableExperimentalExtensionApis);
   }
 };
@@ skipping 312 matching lines @@
           kDebuggerTestPage);
 }
 
 // Tests that chrome.devtools extension is correctly exposed.
 IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
                        TestDevToolsExtensionAPI) {
   LoadExtension("devtools_extension");
   RunTest("waitForTestResultsInConsole", std::string());
 }
 
-// Tests a chrome.devtools extension panel that embeds an http:// iframe.
-IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest, DevToolsExtensionWithHttpIframe) {
-  ASSERT_TRUE(embedded_test_server()->Start());
-
-  // Our extension must load an URL from the test server, whose port is only
-  // known at runtime. So, to embed the URL, we must dynamically generate the
-  // extension, rather than loading it from static content.
-  std::unique_ptr<extensions::TestExtensionDir> dir(
-      new extensions::TestExtensionDir());
-
-  extensions::DictionaryBuilder manifest;
-  dir->WriteManifest(extensions::DictionaryBuilder()
-                         .Set("name", "Devtools Panel w/ HTTP Iframe")
-                         .Set("version", "1")
-                         .Set("manifest_version", 2)
-                         .Set("devtools_page", "devtools.html")
-                         .ToJSON());
-
-  dir->WriteFile(
-      FILE_PATH_LITERAL("devtools.html"),
-      "<html><head><script src='devtools.js'></script></head></html>");
-
-  dir->WriteFile(
-      FILE_PATH_LITERAL("devtools.js"),
-      "chrome.devtools.panels.create('iframe_panel',\n"
-      "    null,\n"
-      "    'panel.html',\n"
-      "    function(panel) {\n"
-      "      chrome.devtools.inspectedWindow.eval('console.log(\"PASS\")');\n"
-      "    }\n"
-      ");\n");
-
-  GURL http_iframe =
+// The following three tests check that http Iframes within the three "devtools

[ncarter (slow), 2017/03/15 20:01:02]

A comment that applies to 'the next three tests' is likely to fall out of date,
because it's unlikely that it'll be updated if the tests are rearranged or a new
one is inserted.

I think it's better to just give each test a standalone comment. The contents of
this summary paragraph can go either into those standalone comments, or into the
CL description.

[davidsac (gone - try alexmos), 2017/03/18 01:32:41]

Done.

+// pages" (the visible devtools panel for the devtools extension, the sidebar
+// pane page for the devtools extension that is visible in the elemanets panel,
+// and the devtools background page, which is different from the extension's
+// background page)(https://developer.chrome.com/extensions/devtools) are
+// rendered in their own processes and not in the devtools process or the
+// extension's process.
+
+// Tests that http Iframes within the visible devtools panel for the devtools
+// extension are rendered in their own processes and not in the devtools process
+// or the extension's process.  Also tests that data URLs and about blank URLs
+// are rendered in the devtools process, unless an OOPIF is navigated to
+// about:blank, in which case it does not end up back in the devtools process.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       HttpIframeInDevToolsExtensionPanel) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  // Install the dynamically-generated extension.
+  const Extension* extension =
+      LoadExtensionForTest("Devtools Extension", "panel_devtools_page.html",
+                           "/renavigation_test_page.html");
+  ASSERT_TRUE(extension);
+
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  // Wait for the panel extension to finish loading -- it'll output 'PASS'
+  // when it's installed. waitForTestResultsInConsole waits until that 'PASS'.
+  RunTestFunction(window_, "waitForTestResultsInConsole");
+
+  // Now that we know the panel is loaded, switch to it. We'll wait until we
+  // see a 'DONE' message sent from popup_iframe.html, indicating that it
+  // loaded successfully.
+  content::DOMMessageQueue message_queue;
+  std::string message;
+  SwitchToExtensionPanel(window_, extension, "iframe_panel");
+
+  while (true) {
+    ASSERT_TRUE(message_queue.WaitForMessage(&message));
+    if (message == "\"DONE\"")
+      break;
+  }
+
+  std::vector<content::RenderFrameHost*> rfhs =
+      main_web_contents()->GetAllFrames();
+  EXPECT_EQ(7U, rfhs.size());
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+  content::RenderFrameHost* devtools_extension_devtools_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* devtools_panel_extension_rfh =
+      ChildFrameAt(main_devtools_rfh, 1);
+  content::RenderFrameHost* test_frame_rfh =
+      ChildFrameAt(devtools_panel_extension_rfh, 0);
+  content::RenderFrameHost* about_blank_frame_rfh =
+      ChildFrameAt(test_frame_rfh, 0);
+  content::RenderFrameHost* data_frame_rfh = ChildFrameAt(test_frame_rfh, 1);
+  content::RenderFrameHost* about_blank_http_iframe_rfh =
+      ChildFrameAt(test_frame_rfh, 2);
+
+  GURL http_popup_url =
       embedded_test_server()->GetURL("a.com", "/popup_iframe.html");
-  dir->WriteFile(FILE_PATH_LITERAL("panel.html"),
-                 "<html><body>Extension panel.<iframe src='" +
-                     http_iframe.spec() + "'></iframe>");
-
-  // Install the extension.
-  const Extension* extension = LoadExtensionFromPath(dir->UnpackedPath());
+  GURL about_blank_url = GURL(url::kAboutBlankURL);
+  GURL data_url = GURL("data:text/html,foo");
+
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(extension->GetResourceURL("/panel_devtools_page.html"),
+            devtools_extension_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension->GetResourceURL("/panel.html"),
+            devtools_panel_extension_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension->GetResourceURL("/renavigation_test_page.html"),
+            test_frame_rfh->GetLastCommittedURL());
+  EXPECT_EQ(about_blank_url, about_blank_frame_rfh->GetLastCommittedURL());
+  EXPECT_EQ(data_url, data_frame_rfh->GetLastCommittedURL());
+  EXPECT_EQ(http_popup_url, about_blank_http_iframe_rfh->GetLastCommittedURL());
+
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_devtools_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_panel_extension_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            test_frame_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            about_blank_frame_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            data_frame_rfh->GetSiteInstance());
+  EXPECT_EQ(
+      http_popup_url.host(),
+      about_blank_http_iframe_rfh->GetSiteInstance()->GetSiteURL().host());
+
+  std::string about_blank_javascript =
+      "location.href='" + about_blank_url.spec() + "';";
+
+  content::TestNavigationManager manager(main_web_contents(), about_blank_url);
+
+  ASSERT_TRUE(content::ExecuteScript(about_blank_http_iframe_rfh,
+                                     about_blank_javascript));
+
+  manager.WaitForNavigationFinished();
+
+  EXPECT_EQ(about_blank_url,
+            about_blank_http_iframe_rfh->GetLastCommittedURL());
+  EXPECT_EQ(
+      http_popup_url.host(),
+      about_blank_http_iframe_rfh->GetSiteInstance()->GetSiteURL().host());
+}
+
+// Tests that http Iframes within the sidebar pane page for the devtools
+// extension that is visible in the elemanets panel are rendered in their own

[ncarter (slow), 2017/03/15 20:01:02]

elemanets is a typo (occurs a couple times in this file).

[davidsac (gone - try alexmos), 2017/03/18 01:32:41]

Done.

+// processes and not in the devtools process or the extension's process.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       HttpIframeInDevToolsExtensionSideBarPane) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  GURL http_iframe_url =
+      embedded_test_server()->GetURL("a.com", "/popup_iframe.html");
+
+  // Install the dynamically-generated extension.
+  const Extension* extension = LoadExtensionForTest(
+      "Devtools Extension", "panel_devtools_page.html", http_iframe_url.spec());
   ASSERT_TRUE(extension);
 
-  // Open a devtools window.
   OpenDevToolsWindow(kDebuggerTestPage, false);
 
   // Wait for the panel extension to finish loading -- it'll output 'PASS'
+  // when it's installed. waitForTestResultsInConsole waits until that 'PASS'.
+  RunTestFunction(window_, "waitForTestResultsInConsole");
+
+  // Now that we know the panel is loaded, switch to it.
+  content::DOMMessageQueue message_queue;
+  SwitchToPanel(window_, "elements");
+  // This is a bit of a hack to switch to the sidebar pane in the elements panel
+  // that the Iframe has been added to.  We'll wait until we see a 'DONE'
+  // message sent from popup_iframe.html, indicating that it loaded
+  // successfully.
+  SwitchToPanel(window_, "iframe_pane");
+  std::string message;
+
+  while (true) {
+    ASSERT_TRUE(message_queue.WaitForMessage(&message));
+    if (message == "\"DONE\"")
+      break;
+  }
+
+  std::vector<content::RenderFrameHost*> rfhs =
+      main_web_contents()->GetAllFrames();
+  EXPECT_EQ(4U, rfhs.size());
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+  content::RenderFrameHost* devtools_extension_devtools_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* devtools_sidebar_pane_extension_rfh =
+      ChildFrameAt(main_devtools_rfh, 1);
+  content::RenderFrameHost* http_iframe_rfh =
+      ChildFrameAt(devtools_sidebar_pane_extension_rfh, 0);
+
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(extension->GetResourceURL("/panel_devtools_page.html"),
+            devtools_extension_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension->GetResourceURL("/panel.html"),
+            devtools_sidebar_pane_extension_rfh->GetLastCommittedURL());
+  EXPECT_EQ(http_iframe_url, http_iframe_rfh->GetLastCommittedURL());
+
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_devtools_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_sidebar_pane_extension_rfh->GetSiteInstance());
+  EXPECT_EQ(http_iframe_url.host(),
+            http_iframe_rfh->GetSiteInstance()->GetSiteURL().host());
+}
+
+// Tests that http Iframes within the devtools background page, which is
+// different from the extension's background page, are rendered in their own
+// processes and not in the devtools process or the extension's process.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       HttpIframeInDevToolsExtensionDevtools) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  // Install the dynamically-generated extension.
+  const Extension* extension = LoadExtensionForTest(
+      "Devtools Extension", "popup_devtools_page.html", "" /* test_page_url */);
+  ASSERT_TRUE(extension);
+
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  // Now that we know the panel is loaded, switch to it. We'll wait until we
+  // see a 'DONE' message sent from popup_iframe.html, indicating that it
+  // loaded successfully.
+  content::DOMMessageQueue message_queue;
+  std::string message;
+
+  while (true) {
+    ASSERT_TRUE(message_queue.WaitForMessage(&message));
+    if (message == "\"DONE\"")
+      break;
+  }
+
+  std::vector<content::RenderFrameHost*> rfhs =
+      main_web_contents()->GetAllFrames();
+  EXPECT_EQ(3U, rfhs.size());
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+  content::RenderFrameHost* devtools_extension_devtools_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* http_iframe_rfh =
+      ChildFrameAt(devtools_extension_devtools_rfh, 0);
+
+  GURL http_iframe_url =
+      embedded_test_server()->GetURL("a.com", "/popup_iframe.html");
+
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(extension->GetResourceURL("/popup_devtools_page.html"),
+            devtools_extension_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(http_iframe_url, http_iframe_rfh->GetLastCommittedURL());
+
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_devtools_rfh->GetSiteInstance());
+  EXPECT_EQ(http_iframe_url.host(),
+            http_iframe_rfh->GetSiteInstance()->GetSiteURL().host());
+}
+
+// Tests that iframes to a non-devtools extension embedded in a devtools
+// extension will be isolated from devtools and the devtools extension.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       NonDevToolsExtensionInDevToolsExtension) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  // Install the dynamically-generated non-devtools extension.
+  const Extension* non_devtools_extension =
+      LoadExtensionForTest("Non-DevTools Extension", "" /* devtools_page_url */,
+                           "" /* test_page_url */);
+  ASSERT_TRUE(non_devtools_extension);
+
+  GURL non_dt_extension_test_url =
+      non_devtools_extension->GetResourceURL("/popup_test_page.html");
+
+  // Install the dynamically-generated devtools extension.
+  const Extension* devtools_extension =
+      LoadExtensionForTest("Devtools Extension", "panel_devtools_page.html",
+                           non_dt_extension_test_url.spec());
+  ASSERT_TRUE(devtools_extension);
+
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  // Wait for the panel extension to finish loading -- it'll output 'PASS'
+  // when it's installed. waitForTestResultsInConsole waits until that 'PASS'.
+  RunTestFunction(window_, "waitForTestResultsInConsole");
+
+  // Now that we know the panel is loaded, switch to it. We'll wait until we
+  // see a 'DONE' message sent from popup_iframe.html, indicating that it
+  // loaded successfully.
+  content::DOMMessageQueue message_queue;
+  SwitchToExtensionPanel(window_, devtools_extension, "iframe_panel");
+  std::string message;
+
+  while (true) {
+    ASSERT_TRUE(message_queue.WaitForMessage(&message));
+    if (message == "\"DONE\"")
+      break;
+  }
+
+  std::vector<content::RenderFrameHost*> rfhs =
+      main_web_contents()->GetAllFrames();
+  EXPECT_EQ(4U, rfhs.size());
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+  content::RenderFrameHost* devtools_extension_devtools_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* devtools_extension_panel_rfh =
+      ChildFrameAt(main_devtools_rfh, 1);
+  content::RenderFrameHost* non_devtools_extension_test_rfh =
+      ChildFrameAt(devtools_extension_panel_rfh, 0);
+
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(devtools_extension->GetResourceURL("/panel_devtools_page.html"),
+            devtools_extension_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(devtools_extension->GetResourceURL("/panel.html"),
+            devtools_extension_panel_rfh->GetLastCommittedURL());
+  EXPECT_EQ(non_dt_extension_test_url,
+            non_devtools_extension_test_rfh->GetLastCommittedURL());
+
+  // popup_test_page.html's frame should be in extension b's
+  // process, not in devtools or extension a's process.
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_devtools_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_panel_rfh->GetSiteInstance());
+  EXPECT_EQ(non_dt_extension_test_url.GetOrigin(),
+            non_devtools_extension_test_rfh->GetSiteInstance()->GetSiteURL());
+}
+
+// Tests that if a devtools extension's devtools panel page has a subframe to a
+// page for another devtools extension, the subframe is rendered in the devtools
+// process as well.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       DevToolsExtensionInDevToolsExtension) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  // Install the dynamically-generated extension.
+  const Extension* devtools_b_extension =
+      LoadExtensionForTest("Devtools Extension B", "simple_devtools_page.html",
+                           "" /* test_page_url */);
+  ASSERT_TRUE(devtools_b_extension);
+
+  GURL extension_b_test_url =
+      devtools_b_extension->GetResourceURL("/popup_test_page.html");
+
+  // Install the dynamically-generated extension.
+  const Extension* devtools_a_extension =
+      LoadExtensionForTest("Devtools Extension A", "panel_devtools_page.html",
+                           extension_b_test_url.spec());
+  ASSERT_TRUE(devtools_a_extension);
+
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  // Wait for the panel extension to finish loading -- it'll output 'PASS'
+  // when it's installed. waitForTestResultsInConsole waits until that 'PASS'.
+  RunTestFunction(window_, "waitForTestResultsInConsole");
+
+  // Now that we know the panel is loaded, switch to it. We'll wait until we
+  // see a 'DONE' message sent from popup_iframe.html, indicating that it
+  // loaded successfully.
+  content::DOMMessageQueue message_queue;
+  SwitchToExtensionPanel(window_, devtools_a_extension, "iframe_panel");
+  std::string message;
+
+  while (true) {
+    ASSERT_TRUE(message_queue.WaitForMessage(&message));
+    if (message == "\"DONE\"")
+      break;
+  }
+
+  std::vector<content::RenderFrameHost*> rfhs =
+      main_web_contents()->GetAllFrames();
+  EXPECT_EQ(5U, rfhs.size());
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+
+  content::RenderFrameHost* devtools_extension_a_devtools_rfh =
+      content::FrameMatchingPredicate(
+          main_web_contents(),
+          base::Bind(&content::FrameHasSourceUrl,
+                     devtools_a_extension->GetResourceURL(
+                         "/panel_devtools_page.html")));
+  EXPECT_TRUE(devtools_extension_a_devtools_rfh);
+  content::RenderFrameHost* devtools_extension_b_devtools_rfh =
+      content::FrameMatchingPredicate(
+          main_web_contents(),
+          base::Bind(&content::FrameHasSourceUrl,
+                     devtools_b_extension->GetResourceURL(
+                         "/simple_devtools_page.html")));
+  EXPECT_TRUE(devtools_extension_b_devtools_rfh);
+
+  content::RenderFrameHost* devtools_extension_a_panel_rfh =
+      ChildFrameAt(main_devtools_rfh, 2);
+  content::RenderFrameHost* devtools_extension_b_test_rfh =
+      ChildFrameAt(devtools_extension_a_panel_rfh, 0);
+
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(devtools_a_extension->GetResourceURL("/panel_devtools_page.html"),
+            devtools_extension_a_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(devtools_b_extension->GetResourceURL("/simple_devtools_page.html"),
+            devtools_extension_b_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(devtools_a_extension->GetResourceURL("/panel.html"),
+            devtools_extension_a_panel_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension_b_test_url,
+            devtools_extension_b_test_rfh->GetLastCommittedURL());
+
+  // all frames should be in the devtools process.
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_a_devtools_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_b_devtools_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_a_panel_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_b_test_rfh->GetSiteInstance());
+}
+
+// Tests that a devtools extension can still have subframes to itself in a
+// "devtools page" and that they will be rendered within the devtools process as
+// well, not in the extension process.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest, DevToolsExtensionInItself) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  // Install the dynamically-generated extension.
+  const Extension* extension =
+      LoadExtensionForTest("Devtools Extension", "panel_devtools_page.html",
+                           "/popup_test_page.html");
+  ASSERT_TRUE(extension);
+
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  // Wait for the panel extension to finish loading -- it'll output 'PASS'
   // when it's installed. waitForTestResultsInConsole waits until that 'PASS'.
   RunTestFunction(window_, "waitForTestResultsInConsole");
 
   // Now that we know the panel is loaded, switch to it. We'll wait until we
   // see a 'DONE' message sent from popup_iframe.html, indicating that it
   // loaded successfully.
   content::DOMMessageQueue message_queue;
   SwitchToExtensionPanel(window_, extension, "iframe_panel");
   std::string message;
+
   while (true) {
     ASSERT_TRUE(message_queue.WaitForMessage(&message));
     if (message == "\"DONE\"")
       break;
   }
+
+  GURL extension_test_url = extension->GetResourceURL("/popup_test_page.html");
+
+  std::vector<content::RenderFrameHost*> rfhs =
+      main_web_contents()->GetAllFrames();
+  EXPECT_EQ(4U, rfhs.size());
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+  content::RenderFrameHost* devtools_extension_devtools_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* devtools_extension_panel_rfh =
+      ChildFrameAt(main_devtools_rfh, 1);
+  content::RenderFrameHost* devtools_extension_test_rfh =
+      ChildFrameAt(devtools_extension_panel_rfh, 0);
+
+  // all frames should be in the devtools process, including test.html's frame
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(extension->GetResourceURL("/panel_devtools_page.html"),
+            devtools_extension_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension->GetResourceURL("/panel.html"),
+            devtools_extension_panel_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension_test_url,
+            devtools_extension_test_rfh->GetLastCommittedURL());
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_devtools_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_panel_rfh->GetSiteInstance());
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_extension_test_rfh->GetSiteInstance());
+}
+
+// Tests that a devtools (not a devtools extension) Iframe can still be injected

[ncarter (slow), 2017/03/15 20:01:02]

'can still be' -> 'can be'

[davidsac (gone - try alexmos), 2017/03/18 01:32:41]

Done.

+// into devtools.
+IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, DevtoolsInDevTools) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  GURL devtools_url = GURL("chrome-devtools://devtools/bundled/inspector.html");
+
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  std::string javascript =
+      "var devtoolsFrame = document.createElement('iframe');"
+      "document.body.appendChild(devtoolsFrame);"
+      "devtoolsFrame.setAttribute('src', '" +
+      devtools_url.spec() + "');";
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+
+  content::TestNavigationManager manager(main_web_contents(), devtools_url);
+
+  ASSERT_TRUE(content::ExecuteScript(main_devtools_rfh, javascript));
+
+  manager.WaitForNavigationFinished();
+  std::vector<content::RenderFrameHost*> rfhs =
+      main_web_contents()->GetAllFrames();
+  EXPECT_EQ(2U, rfhs.size());
+  content::RenderFrameHost* devtools_iframe_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(devtools_url, devtools_iframe_rfh->GetLastCommittedURL());
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(main_devtools_rfh->GetSiteInstance(),
+            devtools_iframe_rfh->GetSiteInstance());

[ncarter (slow), 2017/03/15 20:01:02]

Might be worthwhile to interact with the loaded page too. E.g.:

EXPECT_TRUE(ExecuteScriptAndExtractString(devtools_iframe_rfh,
'domAutomationController.send(document.origin)', &message));
EXPECT_EQ('chrome-devtools://', messge);

[davidsac (gone - try alexmos), 2017/03/18 01:32:41]

Done.

 }
 
 // Some web features, when used from an extension, are subject to browser-side
 // security policy enforcement. Make sure they work properly from inside a
 // devtools extension.
 IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
                        DevToolsExtensionSecurityPolicyGrants) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
   std::unique_ptr<extensions::TestExtensionDir> dir(
@@ skipping 590 matching lines @@
   RunTestFunction(window, "testWindowInitializedOnNavigateBack");
 
   DevToolsWindowTesting::CloseDevToolsWindowSync(window);
   content::WebUIControllerFactory::UnregisterFactoryForTesting(&test_factory);
 }
 
 // Tests scripts panel showing.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestDevToolsSharedWorker) {
   RunTest("testDevToolsSharedWorker", url::kAboutBlankURL);
 }