Make undocked DevTools window invisible to extensions API.

chrome/browser/extensions/api/tabs/tabs_test.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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
+#include "chrome/browser/devtools/devtools_window_testing.h"
 #include "chrome/browser/extensions/api/tabs/tabs_api.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_commands.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
@@ skipping 157 matching lines @@
   const size_t NUM_WINDOWS = 5;
   std::set<int> window_ids;
   std::set<int> result_ids;
   window_ids.insert(ExtensionTabUtil::GetWindowId(browser()));
 
   for (size_t i = 0; i < NUM_WINDOWS - 1; ++i) {
     Browser* new_browser = CreateBrowser(browser()->profile());
     window_ids.insert(ExtensionTabUtil::GetWindowId(new_browser));
   }
 
+  // Undocked DevTools window should not be accessible.
+  DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
+      browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
+
   scoped_refptr<WindowsGetAllFunction> function = new WindowsGetAllFunction();
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
   scoped_ptr<base::ListValue> result(utils::ToList(
       utils::RunFunctionAndReturnSingleResult(function.get(),
                                               "[]",
                                               browser())));
 
   base::ListValue* windows = result.get();
   EXPECT_EQ(NUM_WINDOWS, windows->GetSize());
@@ skipping 23 matching lines @@
     base::DictionaryValue* result_window = NULL;
     EXPECT_TRUE(windows->GetDictionary(i, &result_window));
     result_ids.insert(utils::GetInteger(result_window, "id"));
 
     // "populate" was enabled so tabs should be populated.
     base::ListValue* tabs = NULL;
     EXPECT_TRUE(result_window->GetList(keys::kTabsKey, &tabs));
   }
   // The returned ids should contain all the current browser instance ids.
   EXPECT_EQ(window_ids, result_ids);
+
+  DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, UpdateNoPermissions) {
   // The test empty extension has no permissions, therefore it should not get
   // tab data in the function result.
   scoped_refptr<TabsUpdateFunction> update_tab_function(
       new TabsUpdateFunction());
   scoped_refptr<Extension> empty_extension(test_util::CreateEmptyExtension());
   update_tab_function->set_extension(empty_extension.get());
   // Without a callback the function will not generate a result.
@@ skipping 186 matching lines @@
   result_tabs = result.get();
   // We should have one tab for each extra window.
   EXPECT_EQ(kExtraWindows, result_tabs->GetSize());
   for (size_t i = 0; i < kExtraWindows; ++i) {
     base::DictionaryValue* result_tab = NULL;
     EXPECT_TRUE(result_tabs->GetDictionary(i, &result_tab));
     EXPECT_NE(window_id, utils::GetInteger(result_tab, keys::kWindowIdKey));
   }
 }
 
+IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, QueryAllTabsWithDevTools) {
+  const size_t kNumWindows = 3;
+  std::set<int> window_ids;
+  window_ids.insert(ExtensionTabUtil::GetWindowId(browser()));
+  for (size_t i = 0; i < kNumWindows - 1; ++i) {
+    Browser* new_browser = CreateBrowser(browser()->profile());
+    window_ids.insert(ExtensionTabUtil::GetWindowId(new_browser));
+  }
+
+  // Undocked DevTools window should not be accessible.
+  DevToolsWindow* devtools = DevToolsWindowTesting::OpenDevToolsWindowSync(
+      browser()->tab_strip_model()->GetWebContentsAt(0), false /* is_docked */);
+
+  // Get tabs in the 'current' window called from non-focused browser.
+  scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
+  function->set_extension(test_util::CreateEmptyExtension().get());
+  scoped_ptr<base::ListValue> result(utils::ToList(
+      utils::RunFunctionAndReturnSingleResult(function.get(),
+                                              "[{}]",
+                                              browser())));
+
+  std::set<int> result_ids;
+  base::ListValue* result_tabs = result.get();
+  // We should have one tab per browser except for DevTools.
+  EXPECT_EQ(kNumWindows, result_tabs->GetSize());
+  for (size_t i = 0; i < result_tabs->GetSize(); ++i) {
+    base::DictionaryValue* result_tab = NULL;
+    EXPECT_TRUE(result_tabs->GetDictionary(i, &result_tab));
+    result_ids.insert(utils::GetInteger(result_tab, keys::kWindowIdKey));
+  }
+  EXPECT_EQ(window_ids, result_ids);
+
+  DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
+}
+
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, DontCreateTabInClosingPopupWindow) {
   // Test creates new popup window, closes it right away and then tries to open
   // a new tab in it. Tab should not be opened in the popup window, but in a
   // tabbed browser window.
   Browser* popup_browser = new Browser(
       Browser::CreateParams(Browser::TYPE_POPUP, browser()->profile(),
                             browser()->host_desktop_type()));
   int window_id = ExtensionTabUtil::GetWindowId(popup_browser);
   chrome::CloseWindow(popup_browser);
 
@@ skipping 465 matching lines @@
   // Test chrome.tabs.setZoom().
   error = RunSetZoomExpectError(tab_id, 3.14159);
   EXPECT_TRUE(MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 
   // chrome.tabs.setZoomSettings().
   error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
   EXPECT_TRUE(MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 }
 
 }  // namespace extensions