Discarded property on chrome.tabs.Tab and chrome.tabs.query()

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 <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
 #include <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/strings/pattern.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/values.h"
 #include "build/build_config.h"
 #include "chrome/browser/apps/app_browsertest_util.h"
+#include "chrome/browser/browser_process.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_apitest.h"
 #include "chrome/browser/extensions/extension_function_test_utils.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/window_controller.h"
+#include "chrome/browser/memory/tab_manager.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"
 #include "chrome/browser/ui/views/frame/browser_view.h"
 #include "chrome/browser/ui/zoom/chrome_zoom_level_prefs.h"
 #include "chrome/test/base/ui_test_utils.h"
 #include "components/prefs/pref_service.h"
@@ skipping 590 matching lines @@
   for (size_t i = 0; i < result_tabs->GetSize(); ++i) {
     base::DictionaryValue* result_tab = nullptr;
     EXPECT_TRUE(result_tabs->GetDictionary(i, &result_tab));
     result_ids.insert(GetTabWindowId(result_tab));
   }
   EXPECT_EQ(window_ids, result_ids);
 
   DevToolsWindowTesting::CloseDevToolsWindowSync(devtools);
 }
 
+IN_PROC_BROWSER_TEST_F(ExtensionTabsTest, QueryDiscardedProperty) {
+  ASSERT_TRUE(g_browser_process && g_browser_process->GetTabManager());

[Devlin, 2016/06/21 20:31:51]

Do these have to be browser tests?  Can we not put them in the unit test?

[Anderson Silva, 2016/06/27 18:21:53]

We create these as browser tests because we need TabManager to be running in
order to discard the tabs. TabManager lives in g_browser_process, which is
running only in browser tests.

[Devlin, 2016/06/28 20:14:30]

TestingBrowserProcess creates g_browser_process for tests, and we could modify
it to conditionally have a TabManager.  Are there any extra browser components
that tab manager relies on that make this infeasible?

+  memory::TabManager* tab_manager = g_browser_process->GetTabManager();
+
+  // Create two new tabs.
+  content::OpenURLParams params(GURL(url::kAboutBlankURL), content::Referrer(),
+                                NEW_BACKGROUND_TAB, ui::PAGE_TRANSITION_LINK,
+                                false);
+  content::WebContents* web_contents_a = browser()->OpenURL(params);
+  content::WebContents* web_contents_b = browser()->OpenURL(params);
+
+  // Get non-discarded tabs.
+  {
+    const char* kQueryInfo = "[{\"discarded\": false}]";
+    scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
+    function->set_extension(test_util::CreateEmptyExtension().get());
+    std::unique_ptr<base::ListValue> result(
+        utils::ToList(utils::RunFunctionAndReturnSingleResult(
+            function.get(), kQueryInfo, browser())));
+
+    // We should have the initial plus two new non-discarded tabs.
+    EXPECT_EQ(3u, result.get()->GetSize());
+  }
+
+  // Get discarded tabs.
+  {
+    const char* kQueryInfo = "[{\"discarded\": true}]";
+    scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
+    function->set_extension(test_util::CreateEmptyExtension().get());
+    std::unique_ptr<base::ListValue> result(
+        utils::ToList(utils::RunFunctionAndReturnSingleResult(
+            function.get(), kQueryInfo, browser())));
+
+    // We should have zero discarded tabs.
+    EXPECT_EQ(0u, result.get()->GetSize());
+  }
+
+  // Discards one tab.
+  EXPECT_TRUE(
+      tab_manager->DiscardTabById(reinterpret_cast<int64_t>(web_contents_a)));
+
+  // Get non-discarded tabs after discarding one tab.
+  {
+    const char* kQueryInfo = "[{\"discarded\": false}]";
+    scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
+    function->set_extension(test_util::CreateEmptyExtension().get());
+    std::unique_ptr<base::ListValue> result(
+        utils::ToList(utils::RunFunctionAndReturnSingleResult(
+            function.get(), kQueryInfo, browser())));
+
+    // Now we should have two non-discarded tabs after discarding one.
+    EXPECT_EQ(2u, result.get()->GetSize());
+  }
+
+  // Get discarded tabs after discarding one tab.
+  {
+    const char* kQueryInfo = "[{\"discarded\": true}]";
+    scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
+    function->set_extension(test_util::CreateEmptyExtension().get());
+    std::unique_ptr<base::ListValue> result(
+        utils::ToList(utils::RunFunctionAndReturnSingleResult(
+            function.get(), kQueryInfo, browser())));
+
+    // Only one tab was discarded.
+    EXPECT_EQ(1u, result.get()->GetSize());
+  }
+
+  // Discards the other created tab.
+  EXPECT_TRUE(
+      tab_manager->DiscardTabById(reinterpret_cast<int64_t>(web_contents_b)));
+
+  // Get non-discarded tabs after discarding all created tabs.
+  {
+    const char* kQueryInfo = "[{\"discarded\": false}]";
+    scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
+    function->set_extension(test_util::CreateEmptyExtension().get());
+    std::unique_ptr<base::ListValue> result(
+        utils::ToList(utils::RunFunctionAndReturnSingleResult(
+            function.get(), kQueryInfo, browser())));
+
+    // Now only the initial tab wasn't discarded.
+    EXPECT_EQ(1u, result.get()->GetSize());
+  }
+
+  // Get discarded tabs after discarding all created tabs.
+  {
+    const char* kQueryInfo = "[{\"discarded\": true}]";
+    scoped_refptr<TabsQueryFunction> function = new TabsQueryFunction();
+    function->set_extension(test_util::CreateEmptyExtension().get());
+    std::unique_ptr<base::ListValue> result(
+        utils::ToList(utils::RunFunctionAndReturnSingleResult(
+            function.get(), kQueryInfo, browser())));
+
+    // Both created tabs were discarded.
+    EXPECT_EQ(2u, result.get()->GetSize());
+  }

[Georges Khalil, 2016/06/21 15:31:20]

I think we're missing one more transition: Add reloading of a discarded tab then
make sure the numbers still make sense.

[Anderson Silva, 2016/06/27 18:21:53]

Done.

+}
+
 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()));
   int window_id = ExtensionTabUtil::GetWindowId(popup_browser);
   chrome::CloseWindow(popup_browser);
 
   scoped_refptr<TabsCreateFunction> create_tab_function(
@@ skipping 1091 matching lines @@
   EXPECT_TRUE(
       base::MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 
   // chrome.tabs.setZoomSettings().
   error = RunSetZoomSettingsExpectError(tab_id, "manual", "per-tab");
   EXPECT_TRUE(
       base::MatchPattern(error, manifest_errors::kCannotAccessChromeUrl));
 }
 
 }  // namespace extensions