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>
 
 #include "base/bind.h"
 #include "base/cancelable_callback.h"
@@ skipping 20 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 432 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/02/21 22:19:53]

Remove these comments.

[davidsac (gone - try alexmos), 2017/03/09 19:36:47]

Done.

+
+  const Extension* LoadExtensionForTest(
+      const std::string& name,
+      extensions::TestExtensionDir* dir,
+      bool has_popup_test_page,
+      bool is_devtools_extension,
+      bool should_create_panel_and_pane,
+      const std::string& test_page_url = "test.html") {
+    extensions::DictionaryBuilder manifest;
+    manifest.Set("name", name)
+        .Set("version", "1")
+        .Set("manifest_version", 2)
+        .Set("web_accessible_resources",
+             extensions::ListBuilder().Append("test.html").Build());
+    if (is_devtools_extension) {
+      manifest.Set("devtools_page", "devtools.html");
+    }
+
+    dir->WriteManifest(manifest.ToJSON());
+
+    if (is_devtools_extension) {
+      if (should_create_panel_and_pane) {
+        dir->WriteFile(
+            FILE_PATH_LITERAL("devtools.html"),
+            "<html><head><script "
+            "src='devtools.js'></script></head><body></body></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"
+            "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>");
+
+      } else {
+        dir->WriteFile(FILE_PATH_LITERAL("devtools.html"),
+                       "<html><head></head><body></body></html>");
+      }
+    }
+    if (has_popup_test_page) {
+      dir->WriteFile(
+          FILE_PATH_LITERAL("test.html"),
+          "<html><head><script src='test.js'></script></head><body>This "
+          "is a test</body></html>");
+
+      dir->WriteFile(FILE_PATH_LITERAL("test.js"),
+                     "window.onload = function() {\n"
+                     "  domAutomationController.setAutomationId(0);\n"
+                     "  domAutomationController.send('DONE');\n"
+                     "}\n");
+    } else {
+      dir->WriteFile(FILE_PATH_LITERAL("test.html"),
+                     "<html><head></head><body>This is a test</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 370 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) {
+// Tests that http Iframes within the three "devtools 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.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       HttpIframeInDevToolsExtensionPanel) {
   ASSERT_TRUE(embedded_test_server()->Start());
 
-  // Our extension must load an URL from the test server, whose port is only
+  // Our extension must load a 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;
+  GURL http_iframe_url =
+      embedded_test_server()->GetURL("a.com", "/popup_iframe.html");
+
+  // Install the extension.
+  const Extension* extension = LoadExtensionForTest(
+      "Devtools Extension", dir.get(), false /* !has_popup_test_page */,
+      true /* is_devtools_extension */, true /* should_create_panel_and_pane */,
+      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. 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;
+  }
+
+  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_devtools_extension_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* devtools_panel_extension_rfh =
+      ChildFrameAt(main_devtools_rfh, 1);
+  content::RenderFrameHost* http_iframe_rfh =
+      ChildFrameAt(devtools_panel_extension_rfh, 0);
+
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(extension->GetResourceURL("/devtools.html"),
+            devtools_devtools_extension_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension->GetResourceURL("/panel.html"),
+            devtools_panel_extension_rfh->GetLastCommittedURL());
+  EXPECT_EQ(http_iframe_url, http_iframe_rfh->GetLastCommittedURL());
+
+  if (content::AreAllSitesIsolatedForTesting() ||
+      extensions::IsIsolateExtensionsEnabled()) {
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_devtools_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_TRUE(
+        devtools_panel_extension_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+            content::kChromeDevToolsScheme));
+    EXPECT_EQ(http_iframe_url.host(),
+              http_iframe_rfh->GetSiteInstance()->GetSiteURL().host());
+
+  } else {
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_devtools_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_TRUE(
+        devtools_panel_extension_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+            content::kChromeDevToolsScheme));
+    EXPECT_TRUE(http_iframe_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+  }
+}
+
+// Tests that http Iframes within the three "devtools 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.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       HttpIframeInDevToolsExtensionSideBarPane) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  // Our extension must load a 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());
+
+  GURL http_iframe_url =
+      embedded_test_server()->GetURL("a.com", "/popup_iframe.html");
+
+  // Install the extension.
+  const Extension* extension = LoadExtensionForTest(
+      "Devtools Extension", dir.get(), false /* !has_popup_test_page */,
+      true /* is_devtools_extension */, true /* should_create_panel_and_pane */,
+      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");
+
+  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.
+  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_devtools_extension_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("/devtools.html"),
+            devtools_devtools_extension_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension->GetResourceURL("/panel.html"),
+            devtools_sidebar_pane_extension_rfh->GetLastCommittedURL());
+  EXPECT_EQ(http_iframe_url, http_iframe_rfh->GetLastCommittedURL());
+
+  if (content::AreAllSitesIsolatedForTesting() ||
+      extensions::IsIsolateExtensionsEnabled()) {
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_devtools_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_sidebar_pane_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_EQ(http_iframe_url.host(),
+              http_iframe_rfh->GetSiteInstance()->GetSiteURL().host());
+
+  } else {
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_devtools_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_sidebar_pane_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_TRUE(http_iframe_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+  }
+}
+
+// Tests that http Iframes within the three "devtools 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.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       HttpIframeInDevToolsExtensionDevtools) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  GURL http_iframe_url =
+      embedded_test_server()->GetURL("a.com", "/popup_iframe.html");
+
+  // Our extension must load a 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());
+
+  // TODO(davidsac): is this worth refactoring to use |LoadExtensionForTest|?
   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 =
-      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>");
+  dir->WriteFile(FILE_PATH_LITERAL("devtools.html"),
+                 "<html><head></head><body><iframe src='" +
+                     http_iframe_url.spec() + "'></iframe></body></html>");
 
   // Install the extension.
   const Extension* extension = LoadExtensionFromPath(dir->UnpackedPath());
   ASSERT_TRUE(extension);
 
   // Open a devtools window.
+  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_devtools_extension_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* http_iframe_rfh =
+      ChildFrameAt(devtools_devtools_extension_rfh, 0);
+
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(extension->GetResourceURL("/devtools.html"),
+            devtools_devtools_extension_rfh->GetLastCommittedURL());
+  EXPECT_EQ(http_iframe_url, http_iframe_rfh->GetLastCommittedURL());
+
+  if (content::AreAllSitesIsolatedForTesting() ||
+      extensions::IsIsolateExtensionsEnabled()) {
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_devtools_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_EQ(http_iframe_url.host(),
+              http_iframe_rfh->GetSiteInstance()->GetSiteURL().host());
+
+  } else {
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_devtools_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_TRUE(http_iframe_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+  }
+}
+
+// tests that an iframe 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());
+
+  std::unique_ptr<extensions::TestExtensionDir> dir(
+      new extensions::TestExtensionDir());
+
+  // Install the extension.
+  const Extension* non_devtools_extension = LoadExtensionForTest(
+      "Non-DevTools Extension", dir.get(), true /* has_popup_test_page */,
+      false /* !is_devtools_extension */,
+      false /* !should_create_panel_and_pane */);
+  ASSERT_TRUE(non_devtools_extension);
+
+  GURL non_dt_extension_test_url =
+      non_devtools_extension->GetResourceURL("/test.html");
+
+  std::unique_ptr<extensions::TestExtensionDir> dir2(
+      new extensions::TestExtensionDir());
+
+  // Install the extension.
+  const Extension* devtools_extension = LoadExtensionForTest(
+      "Devtools Extension", dir2.get(), false /* !has_popup_test_page */,
+      true /* is_devtools_extension */, true /* should_create_panel_and_pane */,
+      non_dt_extension_test_url.spec());
+  ASSERT_TRUE(devtools_extension);
+
+  // 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 message1;

[ncarter (slow), 2017/02/21 22:19:53]

You use 'message1' in several places as a name, but there's never a 'message2'.
Why rename message -> message1?

[davidsac (gone - try alexmos), 2017/03/09 19:36:47]

Done.

+
+  while (true) {
+    ASSERT_TRUE(message_queue.WaitForMessage(&message1));
+    if (message1 == "\"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_devtools_extension_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* non_devtools_extension_rfh =
+      ChildFrameAt(devtools_devtools_extension_rfh, 0);
+
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(devtools_extension->GetResourceURL("/devtools.html"),
+            devtools_devtools_extension_rfh->GetLastCommittedURL());
+  EXPECT_EQ(non_dt_extension_test_url,
+            non_devtools_extension_rfh->GetLastCommittedURL());
+
+  if (content::AreAllSitesIsolatedForTesting() ||
+      extensions::IsIsolateExtensionsEnabled()) {
+    // test.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_TRUE(devtools_devtools_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_EQ(non_dt_extension_test_url.GetOrigin(),
+              non_devtools_extension_rfh->GetSiteInstance()->GetSiteURL());
+  } else {
+    // test.html's frame should be in the devtools process.
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(devtools_devtools_extension_rfh->GetSiteInstance()
+                    ->GetSiteURL()
+                    .SchemeIs(content::kChromeDevToolsScheme));
+    EXPECT_TRUE(
+        non_devtools_extension_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+            content::kChromeDevToolsScheme));
+  }
+}
+
+// Tests that if a devtools extension's devtools 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());
+
+  std::unique_ptr<extensions::TestExtensionDir> dir(
+      new extensions::TestExtensionDir());
+
+  const Extension* devtools_b_extension = LoadExtensionForTest(
+      "Devtools Extension B", dir.get(), true /* has_popup_test_page */,
+      true /* is_devtools_extension */,
+      false /* !should_create_panel_and_pane */);
+  ASSERT_TRUE(devtools_b_extension);
+
+  GURL extension_b_test_url =
+      devtools_b_extension->GetResourceURL("/test.html");
+
+  std::unique_ptr<extensions::TestExtensionDir> dir2(
+      new extensions::TestExtensionDir());
+
+  // Install the extension.
+  const Extension* devtools_a_extension = LoadExtensionForTest(
+      "Devtools Extension A", dir2.get(), false /* !has_popup_test_page */,
+      true /* is_devtools_extension */, true /* should_create_panel_and_pane */,
+      extension_b_test_url.spec());
+  ASSERT_TRUE(devtools_a_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. 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 message1;
+
+  while (true) {
+    ASSERT_TRUE(message_queue.WaitForMessage(&message1));
+    if (message1 == "\"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_a_devtools_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  content::RenderFrameHost* devtools_extension_b_devtools_rfh =
+      ChildFrameAt(devtools_extension_a_devtools_rfh, 0);
+
+  // TODO the expected result is the exact same as a non-devtools extension in
+  // devtools
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(devtools_a_extension->GetResourceURL("/devtools.html"),
+            devtools_extension_a_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension_b_test_url,
+            devtools_extension_b_devtools_rfh->GetLastCommittedURL());
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_TRUE(devtools_extension_a_devtools_rfh->GetSiteInstance()
+                  ->GetSiteURL()
+                  .SchemeIs(content::kChromeDevToolsScheme));
+  // test.html's frame should be in the devtools process.
+  EXPECT_TRUE(devtools_extension_b_devtools_rfh->GetSiteInstance()
+                  ->GetSiteURL()
+                  .SchemeIs(content::kChromeDevToolsScheme));
+}
+
+// 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());
+
+  std::unique_ptr<extensions::TestExtensionDir> dir(
+      new extensions::TestExtensionDir());
+  // Install the extension.
+  const Extension* extension = LoadExtensionForTest(
+      "Devtools Extension", dir.get(), true /* has_popup_test_page */,
+      true /* is_devtools_extension */,
+      true /* should_create_panel_and_pane */);
+  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. 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;
+  std::string message1;
+
   while (true) {
-    ASSERT_TRUE(message_queue.WaitForMessage(&message));
-    if (message == "\"DONE\"")
+    ASSERT_TRUE(message_queue.WaitForMessage(&message1));
+    if (message1 == "\"DONE\"")
       break;
   }
+
+  GURL extension_test_url = extension->GetResourceURL("/test.html");
+
+  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* devtools_extension_test_rfh =
+      ChildFrameAt(devtools_extension_devtools_rfh, 0);
+
+  // all frames should be in the devtools process.
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(extension->GetResourceURL("/devtools.html"),
+            devtools_extension_devtools_rfh->GetLastCommittedURL());
+  EXPECT_EQ(extension_test_url,
+            devtools_extension_test_rfh->GetLastCommittedURL());
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_TRUE(
+      devtools_extension_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+          content::kChromeDevToolsScheme));
+  // test.html's frame should be in the devtools process.
+  EXPECT_TRUE(
+      devtools_extension_test_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+          content::kChromeDevToolsScheme));
+}
+
+// Tests that an Iframe to a non-devtools extension cannot be injected into
+// devtools when not contained in a devtools extension.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       NonDevToolsExtensionInDevToolsOutsideDevToolsExtension) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  std::unique_ptr<extensions::TestExtensionDir> dir(
+      new extensions::TestExtensionDir());
+
+  // Install the extension.
+  const Extension* extension = LoadExtensionForTest(
+      "Non-DevTools Extension", dir.get(), false /* !has_popup_test_page */,
+      false /* !is_devtools_extension */,
+      false /* !should_create_panel_and_pane */);
+  ASSERT_TRUE(extension);
+
+  // Open a devtools window.
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  GURL extension_test_url = extension->GetResourceURL("/test.html");
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+
+  std::string javascript =
+      "var extensionFrame = document.createElement('iframe');"
+      "document.body.appendChild(extensionFrame);"
+      "extensionFrame.setAttribute('src', '" +
+      extension_test_url.spec() + "');";
+
+  content::TestNavigationManager manager(main_web_contents(),
+                                         extension_test_url);
+
+  ASSERT_TRUE(content::ExecuteScript(main_devtools_rfh, javascript));
+
+  if (content::AreAllSitesIsolatedForTesting() ||
+      extensions::IsIsolateExtensionsEnabled()) {
+    EXPECT_FALSE(manager.WaitForRequestStart());
+
+    std::vector<content::RenderFrameHost*> rfhs =
+        main_web_contents()->GetAllFrames();
+
+    EXPECT_EQ(1U, rfhs.size());
+
+    // TODO(davidsac):  check to make sure that the rfh is about:blank or
+    // something
+  } else {
+    manager.WaitForNavigationFinished();
+    std::vector<content::RenderFrameHost*> rfhs =
+        main_web_contents()->GetAllFrames();
+
+    EXPECT_EQ(2U, rfhs.size());
+
+    content::RenderFrameHost* extension_test_rfh =
+        ChildFrameAt(main_devtools_rfh, 0);
+    EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(extension_test_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_EQ(extension_test_url, extension_test_rfh->GetLastCommittedURL());
+  }
+}
+
+// Tests that a web Iframe cannot be injected into devtools when not contained
+// in a devtools extension.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest,
+                       HttpIframeInDevToolsOutsideDevToolsExtension) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  GURL simple_page_url =
+      embedded_test_server()->GetURL("a.com", "/title1.html");
+
+  // Open a devtools window.
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  std::string javascript =
+      "var httpFrame = document.createElement('iframe');"
+      "document.body.appendChild(httpFrame);"
+      "httpFrame.setAttribute('src', '" +
+      simple_page_url.spec() + "');";
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+
+  content::TestNavigationManager manager(main_web_contents(), simple_page_url);
+
+  ASSERT_TRUE(content::ExecuteScript(main_devtools_rfh, javascript));
+
+  if (content::AreAllSitesIsolatedForTesting() ||
+      extensions::IsIsolateExtensionsEnabled()) {
+    EXPECT_FALSE(manager.WaitForRequestStart());
+
+    std::vector<content::RenderFrameHost*> rfhs =
+        main_web_contents()->GetAllFrames();
+
+    EXPECT_EQ(1U, rfhs.size());
+    // TODO(davidsac):  check to make sure that the rfh is about:blank or
+    // something
+  } else {
+    manager.WaitForNavigationFinished();
+    std::vector<content::RenderFrameHost*> rfhs =
+        main_web_contents()->GetAllFrames();
+    EXPECT_EQ(2U, rfhs.size());
+    content::RenderFrameHost* http_iframe_rfh =
+        ChildFrameAt(main_devtools_rfh, 0);
+    EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_TRUE(http_iframe_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+        content::kChromeDevToolsScheme));
+    EXPECT_EQ(simple_page_url, http_iframe_rfh->GetLastCommittedURL());
+  }
+}
+
+// Tests that a devtools Iframe can still be injected into devtools.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest, DevtoolsInDevTools) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  // Open a devtools window.
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+
+  GURL devtools_url =
+      GURL("chrome-devtools://devtools/bundled/inspector.html?ws=");
+
+  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_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_TRUE(devtools_iframe_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_TRUE(devtools_iframe_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+}
+
+// Tests that a blank Iframe can still be injected into devtools.
+IN_PROC_BROWSER_TEST_F(DevToolsExtensionTest, AboutBlankInDevTools) {
+  ASSERT_TRUE(embedded_test_server()->Start());
+
+  GURL about_blank_url = GURL(url::kAboutBlankURL);
+
+  // Open a devtools window.
+  OpenDevToolsWindow(kDebuggerTestPage, false);
+  std::string javascript =
+      "var blankFrame = document.createElement('iframe');"
+      "document.body.appendChild(blankFrame);"
+      "blankFrame.setAttribute('src', '" +
+      about_blank_url.spec() + "');";
+
+  content::RenderFrameHost* main_devtools_rfh =
+      main_web_contents()->GetMainFrame();
+
+  content::TestNavigationManager manager(main_web_contents(), about_blank_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* about_blank_rfh =
+      ChildFrameAt(main_devtools_rfh, 0);
+  EXPECT_TRUE(main_devtools_rfh->GetLastCommittedURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_TRUE(main_devtools_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_TRUE(about_blank_rfh->GetSiteInstance()->GetSiteURL().SchemeIs(
+      content::kChromeDevToolsScheme));
+  EXPECT_EQ(about_blank_url, about_blank_rfh->GetLastCommittedURL());
 }
 
 // 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 591 matching lines @@
 
   DevToolsWindowTesting::CloseDevToolsWindowSync(window);
   content::WebUIControllerFactory::UnregisterFactoryForTesting(&test_factory);
 }
 
 // Tests scripts panel showing.
 IN_PROC_BROWSER_TEST_F(DevToolsSanityTest, TestDevToolsSharedWorker) {
   RunTest("testDevToolsSharedWorker", url::kAboutBlankURL);
 }