extensions: windows: list all windows from the current profile

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/json/json_writer.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/prefs/pref_service.h"
+#include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
+#include "chrome/browser/apps/app_browsertest_util.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"
@@ skipping 10 matching lines @@
 #include "extensions/common/test_util.h"
 #include "net/test/spawned_test_server/spawned_test_server.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace extensions {
 
 namespace keys = tabs_constants;
 namespace utils = extension_function_test_utils;
 
 namespace {
-using ExtensionTabsTest = InProcessBrowserTest;
+using ExtensionTabsTest = PlatformAppBrowserTest;
 
 class ExtensionWindowCreateTest : public InProcessBrowserTest {
  public:
   // Runs chrome.windows.create(), expecting an error.
   std::string RunCreateWindowExpectError(const std::string& args) {
     scoped_refptr<WindowsCreateFunction> function(new WindowsCreateFunction);
     function->set_extension(test_util::CreateEmptyExtension().get());
     return api_test_utils::RunFunctionAndReturnError(function.get(), args,
                                                      browser()->profile());
   }
@@ skipping 141 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));
   }
 
+  // Application windows should not be accessible without the
+  // windows.global permission.
+  AppWindow* app_window = CreateTestAppWindow("{}");
+
   // 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(),
                                               "[]",
@@ skipping 29 matching lines @@
     result_ids.insert(api_test_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);
+
+  CloseAppWindow(app_window);
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetAllWindowsGlobal) {
+  const size_t NUM_WINDOWS = 5;

[dcheng, 2015/06/29 18:15:49]

Nit: kNumWindows is the naming convention for constants.

[llandwerlin-old, 2015/06/30 10:20:47]

Done.

+  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));
+  }
+
+  // Application windows should be visible with the windows.global
+  // permission.
+  AppWindow* app_window = CreateTestAppWindow("{}");
+  window_ids.insert(app_window->session_id().id());
+
+  // 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_ptr<base::DictionaryValue> global_extension_value(
+      api_test_utils::ParseDictionary(
+          "{\"name\": \"Global\", \"version\": \"1.0\", \"permissions\": "
+          "[\"windows.global\"]}"));
+  scoped_refptr<Extension> extension(
+      api_test_utils::CreateExtension(global_extension_value.get()));
+  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 + 1, windows->GetSize());
+  for (size_t i = 0; i < result->GetSize(); ++i) {
+    base::DictionaryValue* result_window = NULL;
+    EXPECT_TRUE(windows->GetDictionary(i, &result_window));
+    result_ids.insert(api_test_utils::GetInteger(result_window, "id"));
+
+    // "populate" was not passed in so tabs are not populated.
+    base::ListValue* tabs = NULL;
+    EXPECT_FALSE(result_window->GetList(keys::kTabsKey, &tabs));
+  }
+  // The returned ids should contain all the current browser instance ids.
+  EXPECT_EQ(window_ids, result_ids);
+
+  result_ids.clear();
+  function = new WindowsGetAllFunction();
+  function->set_extension(extension.get());
+  result.reset(utils::ToList(utils::RunFunctionAndReturnSingleResult(
+      function.get(), "[{\"populate\": true}]", browser())));
+
+  windows = result.get();
+  EXPECT_EQ(NUM_WINDOWS + 1, windows->GetSize());
+  for (size_t i = 0; i < windows->GetSize(); ++i) {
+    base::DictionaryValue* result_window = NULL;
+    EXPECT_TRUE(windows->GetDictionary(i, &result_window));
+    result_ids.insert(api_test_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);
+
+  CloseAppWindow(app_window);
 }
 
 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 301 matching lines @@
   function = new WindowsUpdateFunction();
   function->set_extension(extension.get());
   EXPECT_TRUE(MatchPattern(
       utils::RunFunctionAndReturnError(
           function.get(),
           base::StringPrintf(kArgsMaximizedWithBounds, window_id),
           browser()),
       keys::kInvalidWindowStateError));
 }
 
+IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, UpdateAppWindowSizeConstraint) {
+  AppWindow* app_window = CreateTestAppWindow(
+      "{\"outerBounds\": "
+      "{\"width\": 300, \"height\": 300,"
+      " \"minWidth\": 200, \"minHeight\": 200,"
+      " \"maxWidth\": 400, \"maxHeight\": 400}}");
+
+  scoped_refptr<WindowsGetFunction> get_function = new WindowsGetFunction();
+  scoped_ptr<base::DictionaryValue> extension_value(
+      api_test_utils::ParseDictionary(
+          "{\"name\": \"Global\", \"version\": \"1.0\", \"permissions\": "
+          "[\"windows.global\"]}"));
+  scoped_refptr<Extension> extension(
+      api_test_utils::CreateExtension(extension_value.get()));
+  get_function->set_extension(extension.get());
+  scoped_ptr<base::DictionaryValue> result(
+      utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
+          get_function.get(),
+          base::StringPrintf("[%u]", app_window->session_id().id()),
+          browser())));
+
+  EXPECT_EQ(300, api_test_utils::GetInteger(result.get(), "width"));
+  EXPECT_EQ(300, api_test_utils::GetInteger(result.get(), "height"));
+
+  // Verify the min width/height of the application window are
+  // respected.
+  scoped_refptr<WindowsUpdateFunction> update_min_function =
+      new WindowsUpdateFunction();
+  result.reset(utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
+      update_min_function.get(),
+      base::StringPrintf("[%u, {\"width\": 100, \"height\": 100}]",
+                         app_window->session_id().id()),
+      browser())));
+
+  EXPECT_EQ(200, api_test_utils::GetInteger(result.get(), "width"));
+  EXPECT_EQ(200, api_test_utils::GetInteger(result.get(), "height"));
+
+  // Verify the max width/height of the application window are
+  // respected.
+  scoped_refptr<WindowsUpdateFunction> update_max_function =
+      new WindowsUpdateFunction();
+  result.reset(utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
+      update_max_function.get(),
+      base::StringPrintf("[%u, {\"width\": 500, \"height\": 500}]",
+                         app_window->session_id().id()),
+      browser())));
+
+  EXPECT_EQ(400, api_test_utils::GetInteger(result.get(), "width"));
+  EXPECT_EQ(400, api_test_utils::GetInteger(result.get(), "height"));
+
+  CloseAppWindow(app_window);
+}
+
 IN_PROC_BROWSER_TEST_F(ExtensionWindowCreateTest, AcceptState) {
   scoped_refptr<WindowsCreateFunction> function(new WindowsCreateFunction());
   scoped_refptr<Extension> extension(test_util::CreateEmptyExtension());
   function->set_extension(extension.get());
 
   scoped_ptr<base::DictionaryValue> result(
       utils::ToDictionary(utils::RunFunctionAndReturnSingleResult(
           function.get(), "[{\"state\": \"minimized\"}]", browser(),
           utils::INCLUDE_INCOGNITO)));
   int window_id = api_test_utils::GetInteger(result.get(), "id");
@@ skipping 579 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