Added populate parameter to chrome.windows.get, chrome.windows.getCurrent,

chrome/browser/extensions/extension_tabs_test.cc

 // Copyright (c) 2011 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 "chrome/browser/extensions/extension_tabs_module.h"
 
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/stringprintf.h"
 #include "base/string_util.h"
 #include "base/values.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_tabs_module_constants.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_window.h"
 #include "chrome/test/base/in_process_browser_test.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "ui/gfx/rect.h"
 
 using namespace extension_function_test_utils;
+namespace keys = extension_tabs_module_constants;
 
 namespace {
 
 class ExtensionTabsTest : public InProcessBrowserTest {
 };
-
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetWindow) {
   int window_id = ExtensionTabUtil::GetWindowId(browser());
 
   // Invalid window ID error.
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new GetWindowFunction(),
           base::StringPrintf("[%u]", window_id + 1),
           browser()),
-      extension_tabs_module_constants::kWindowNotFoundError));
+      keys::kWindowNotFoundError));
 
   // Basic window details.
   // Need GetRestoredBound instead of GetBounds.
   // See crbug.com/98759.
   gfx::Rect bounds = browser()->window()->GetRestoredBounds();
 
   scoped_ptr<base::DictionaryValue> result(ToDictionary(
       RunFunctionAndReturnResult(
           new GetWindowFunction(),
           base::StringPrintf("[%u]", window_id),
           browser())));
   EXPECT_EQ(window_id, GetInteger(result.get(), "id"));
   EXPECT_FALSE(GetBoolean(result.get(), "incognito"));
   EXPECT_EQ("normal", GetString(result.get(), "type"));
   EXPECT_EQ(bounds.x(), GetInteger(result.get(), "left"));
   EXPECT_EQ(bounds.y(), GetInteger(result.get(), "top"));
   EXPECT_EQ(bounds.width(), GetInteger(result.get(), "width"));
   EXPECT_EQ(bounds.height(), GetInteger(result.get(), "height"));
 
+  // With populate enabled
+  result.reset(ToDictionary(
+      RunFunctionAndReturnResult(
+          new GetWindowFunction(),
+          base::StringPrintf("[%u, {\"populate\": true}]", window_id),
+          browser())));
+
+  EXPECT_EQ(window_id, GetInteger(result.get(), "id"));
+  // populate was enabled so tabs should be populated
+  ListValue* tabs;

[Aaron Boodman, 2011/12/17 07:12:58]

*twitch*

+  EXPECT_TRUE(result.get()->GetList(keys::kTabsKey, &tabs));
+
   // TODO(aa): Can't assume window is focused. On mac, calling Activate() from a
   // browser test doesn't seem to do anything, so can't test the opposite
   // either.
   EXPECT_EQ(browser()->window()->IsActive(),
             GetBoolean(result.get(), "focused"));
 
   // TODO(aa): Minimized and maximized dimensions. Is there a way to set
   // minimize/maximize programmatically?
 
   // Popup.
@@ skipping 21 matching lines @@
   // Incognito.
   Browser* incognito_browser = CreateIncognitoBrowser();
   int incognito_window_id = ExtensionTabUtil::GetWindowId(incognito_browser);
 
   // Without "include_incognito".
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new GetWindowFunction(),
           base::StringPrintf("[%u]", incognito_window_id),
           browser()),
-      extension_tabs_module_constants::kWindowNotFoundError));
+      keys::kWindowNotFoundError));
 
   // With "include_incognito".
   result.reset(ToDictionary(
       RunFunctionAndReturnResult(
           new GetWindowFunction(),
           base::StringPrintf("[%u]", incognito_window_id),
           browser(),
           INCLUDE_INCOGNITO)));
   EXPECT_TRUE(GetBoolean(result.get(), "incognito"));
 }
 
+IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetCurrentWindow) {
+  int window_id = ExtensionTabUtil::GetWindowId(browser());
+  Browser* new_browser = CreateBrowser(browser()->profile());
+  int new_id = ExtensionTabUtil::GetWindowId(new_browser);
+
+  // Get the current window using new_browser
+  scoped_ptr<base::DictionaryValue> result(ToDictionary(
+      RunFunctionAndReturnResult(
+          new GetCurrentWindowFunction(),
+          "[]",
+          new_browser)));
+
+  // id should match the window that was passed to RunFunction

[Aaron Boodman, 2011/12/17 07:12:58]

Comment doesn't make sense. You mean something like: returned id should match
new_browser's id. Same comment multiple places in this file.

[Aaron Boodman, 2011/12/17 07:12:58]

Also, nit, but comments should generally be complete sentences, with
capitalization and periods (except in the case of end-of-line comments that
document a parameter).

[Matt Tytel, 2011/12/17 07:43:32]

Here I want to distinguish between the functionality of GetLastFocusedWindow.
That it should match whatever browser we "called" the GetCurrentWindowFunction
from.

[Aaron Boodman, 2011/12/17 08:02:40]

Ok, fair enough. In that case, it might be a little more clear to say something
like "...should match the window_id of the Browser instance that was passed to
RunFunction"  - to tie things back to the Browser class and new_browser
variable.

+  EXPECT_EQ(new_id, GetInteger(result.get(), "id"));
+  ListValue* tabs;

[Aaron Boodman, 2011/12/17 07:12:58]

!

+  EXPECT_FALSE(result.get()->GetList(keys::kTabsKey, &tabs));
+
+  // Get the current window using the old window and make the tabs populated
+  result.reset(ToDictionary(
+      RunFunctionAndReturnResult(
+          new GetCurrentWindowFunction(),
+          "[{\"populate\": true}]",
+          browser())));
+
+  // id should match the window that was passed to RunFunction
+  EXPECT_EQ(window_id, GetInteger(result.get(), "id"));
+  // populate was enabled so tabs should be populated
+  EXPECT_TRUE(result.get()->GetList(keys::kTabsKey, &tabs));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetLastFocusedWindow) {
+  // Create a new window which making it the "last focused" window.
+  // Note that "last focused" means the "top" most window

[Aaron Boodman, 2011/12/17 07:12:58]

Missing final period.

+  Browser* new_browser = CreateBrowser(browser()->profile());
+  int focus_id = ExtensionTabUtil::GetWindowId(new_browser);

[Aaron Boodman, 2011/12/17 07:12:58]

focused_window_id?

+
+  scoped_ptr<base::DictionaryValue> result(ToDictionary(
+      RunFunctionAndReturnResult(
+          new GetLastFocusedWindowFunction(),
+          "[]",
+          new_browser)));
+
+  // id should match the last focused window
+  EXPECT_EQ(focus_id, GetInteger(result.get(), "id"));
+  ListValue* tabs;

[Aaron Boodman, 2011/12/17 07:12:58]

!! (I'm going to stop pointing these out now)

+  EXPECT_FALSE(result.get()->GetList(keys::kTabsKey, &tabs));
+
+  result.reset(ToDictionary(
+      RunFunctionAndReturnResult(
+          new GetLastFocusedWindowFunction(),
+          "[{\"populate\": true}]",
+          browser())));
+
+  // id should match the last focused window, not the window it was called from
+  EXPECT_EQ(focus_id, GetInteger(result.get(), "id"));
+  // populate was enabled so tabs should be populated
+  EXPECT_TRUE(result.get()->GetList(keys::kTabsKey, &tabs));
+}
+
+IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, GetAllWindows) {
+  const size_t NUM_WINDOWS = 5;
+  std::vector<int> window_ids;
+  std::vector<int> result_ids;
+  window_ids.push_back(ExtensionTabUtil::GetWindowId(browser()));
+
+  for (uint i = 0; i < NUM_WINDOWS - 1; ++i) {
+    Browser* bro = CreateBrowser(browser()->profile());

[Aaron Boodman, 2011/12/17 07:12:58]

Avoid abbreviations. Just use the term "new_browser" here.

[Matt Tytel, 2011/12/17 07:43:32]

You got it bro ;)

+    window_ids.push_back(ExtensionTabUtil::GetWindowId(bro));
+  }
+  std::sort(window_ids.begin(), window_ids.end());
+
+  scoped_ptr<base::ListValue> result(ToList(
+      RunFunctionAndReturnResult(
+          new GetAllWindowsFunction(),
+          "[]",
+          browser())));
+
+  ListValue* windows = result.get();
+  EXPECT_EQ(NUM_WINDOWS, windows->GetSize());
+  for (uint i = 0; i < NUM_WINDOWS; ++i) {
+    DictionaryValue* result_window;
+    EXPECT_TRUE(windows->GetDictionary(i, &result_window));
+    result_ids.push_back(GetInteger(result_window, "id"));
+
+    // populate was not passed in so tabs are not populated
+    ListValue* tabs;
+    EXPECT_FALSE(result_window->GetList(keys::kTabsKey, &tabs));
+  }
+
+  std::sort(window_ids.begin(), window_ids.end());

[Aaron Boodman, 2011/12/17 07:12:58]

You should just use std::set. They come with an equality operator, so you don't
need to do this by hand. And you also don't need to sort them.

+  std::sort(result_ids.begin(), result_ids.end());
+  for (uint i = 0; i < NUM_WINDOWS; ++i)
+    EXPECT_EQ(window_ids[i], result_ids[i]);
+
+  result_ids.clear();
+  result.reset(ToList(
+      RunFunctionAndReturnResult(
+          new GetAllWindowsFunction(),
+          "[{\"populate\": true}]",
+          browser())));
+
+  windows = result.get();
+  EXPECT_EQ(NUM_WINDOWS, windows->GetSize());
+  for (uint i = 0; i < windows->GetSize(); ++i) {
+    DictionaryValue* result_window;
+    EXPECT_TRUE(windows->GetDictionary(i, &result_window));
+    result_ids.push_back(GetInteger(result_window, "id"));
+
+    // populate was enabled so tabs should be populated
+    ListValue* tabs;
+    EXPECT_TRUE(result_window->GetList(keys::kTabsKey, &tabs));
+  }
+
+  std::sort(result_ids.begin(), result_ids.end());
+  for (uint i = 0; i < NUM_WINDOWS; ++i)
+    EXPECT_EQ(window_ids[i], result_ids[i]);
+}
+
 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<UpdateTabFunction> update_tab_function(new UpdateTabFunction());
   scoped_refptr<Extension> empty_extension(CreateEmptyExtension());
   update_tab_function->set_extension(empty_extension.get());
   // Without a callback the function will not generate a result.
   update_tab_function->set_has_callback(true);
 
   scoped_ptr<base::Value> result(RunFunctionAndReturnResult(
@@ skipping 83 matching lines @@
   // Force Incognito mode.
   IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(),
                                       IncognitoModePrefs::FORCED);
 
   // Run with an explicit "incognito" param.
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new CreateWindowFunction(),
           kArgsWithExplicitIncognitoParam,
           browser()),
-      extension_tabs_module_constants::kIncognitoModeIsForced));
+      keys::kIncognitoModeIsForced));
 
   // Now try opening a normal window from incognito window.
   Browser* incognito_browser = CreateIncognitoBrowser();
   // Run with an explicit "incognito" param.
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new CreateWindowFunction(),
           kArgsWithExplicitIncognitoParam,
           incognito_browser),
-      extension_tabs_module_constants::kIncognitoModeIsForced));
+      keys::kIncognitoModeIsForced));
 }
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest,
                        DontCreateIncognitoWindowWhenIncognitoDisabled) {
   static const char kArgs[] =
       "[{\"url\": \"about:blank\", \"incognito\": true }]";
 
   Browser* incognito_browser = CreateIncognitoBrowser();
   // Disable Incognito mode.
   IncognitoModePrefs::SetAvailability(browser()->profile()->GetPrefs(),
                                       IncognitoModePrefs::DISABLED);
   // Run in normal window.
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new CreateWindowFunction(),
           kArgs,
           browser()),
-      extension_tabs_module_constants::kIncognitoModeIsDisabled));
+      keys::kIncognitoModeIsDisabled));
 
   // Run in incognito window.
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new CreateWindowFunction(),
           kArgs,
           incognito_browser),
-      extension_tabs_module_constants::kIncognitoModeIsDisabled));
+      keys::kIncognitoModeIsDisabled));
 }
 
 #if defined(USE_AURA)
 // crbug.com/105173.
 #define MAYBE_InvalidUpdateWindowState DISABLED_InvalidUpdateWindowState
 #else
 #define MAYBE_InvalidUpdateWindowState InvalidUpdateWindowState
 #endif
 
 IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, MAYBE_InvalidUpdateWindowState) {
   static const char kArgsMinimizedWithFocus[] =
       "[%u, {\"state\": \"minimized\", \"focused\": true}]";
   static const char kArgsMaximizedWithoutFocus[] =
       "[%u, {\"state\": \"maximized\", \"focused\": false}]";
   static const char kArgsMinimizedWithBounds[] =
       "[%u, {\"state\": \"minimized\", \"width\": 500}]";
   static const char kArgsMaximizedWithBounds[] =
       "[%u, {\"state\": \"maximized\", \"width\": 500}]";
   int window_id = ExtensionTabUtil::GetWindowId(browser());
 
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new UpdateWindowFunction(),
           base::StringPrintf(kArgsMinimizedWithFocus, window_id),
           browser()),
-      extension_tabs_module_constants::kInvalidWindowStateError));
+      keys::kInvalidWindowStateError));
 
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new UpdateWindowFunction(),
           base::StringPrintf(kArgsMaximizedWithoutFocus, window_id),
           browser()),
-      extension_tabs_module_constants::kInvalidWindowStateError));
+      keys::kInvalidWindowStateError));
 
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new UpdateWindowFunction(),
           base::StringPrintf(kArgsMinimizedWithBounds, window_id),
           browser()),
-      extension_tabs_module_constants::kInvalidWindowStateError));
+      keys::kInvalidWindowStateError));
 
   EXPECT_TRUE(MatchPattern(
       RunFunctionAndReturnError(
           new UpdateWindowFunction(),
           base::StringPrintf(kArgsMaximizedWithBounds, window_id),
           browser()),
-      extension_tabs_module_constants::kInvalidWindowStateError));
+      keys::kInvalidWindowStateError));
 }