extensions: windows: list all windows from the current profile

chrome/browser/extensions/api/tabs/windows_util.h

 // Copyright 2013 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.
 
 #ifndef CHROME_BROWSER_EXTENSIONS_API_TABS_WINDOWS_UTIL_H__
 #define CHROME_BROWSER_EXTENSIONS_API_TABS_WINDOWS_UTIL_H__
 
+#include "chrome/common/extensions/api/windows.h"
+
 class UIThreadExtensionFunction;
 
+namespace content {
+class BrowserContext;
+}
+
 namespace extensions {
+class Extension;
 class WindowController;
 }
 
 namespace windows_util {
 
+namespace windows = extensions::api::windows;
+
+const std::vector<windows::WindowType>& GetDefaultWindowTypeFilters();
+
+const std::vector<windows::WindowType>& GetNoWindowTypeFilters();

[stevenjb, 2015/07/30 19:00:37]

We should typedef std::vector<windows::WindowType> as something like
WindowTypeFilter.

Also, is there any particular reason to use a vector<> instead of a set<>?

[llandwerlin-old, 2015/07/31 13:58:32]

Done in WindowControllerList.

I kept vector<> because it prevents a conversion from the api parameters (which
is vector<>) to something else. That way I can just hand over the received
filter.
But maybe it makes sense to copy anyway?

[stevenjb, 2015/07/31 17:27:16]

I think a copy might be slightly cheaper than the vector lookups that would
become trivial with a set, but the number of types is so small it really doesn't
matter. I would go with whatever simplifies the code the most myself, but it's
fine either way. The typedef helps a lot for readability regardless.

[llandwerlin-old, 2015/08/03 10:11:54]

Switching to converting the array to a bit field.

+
+bool WindowMatchesTypeFilter(const extensions::WindowController* controller,
+                             const std::vector<windows::WindowType>& filters);
+
 // Populates |controller| for given |window_id|. If the window is not found,
 // returns false and sets UIThreadExtensionFunction error_.
 bool GetWindowFromWindowID(UIThreadExtensionFunction* function,
                            int window_id,
+                           const std::vector<windows::WindowType>& type_filter,
                            extensions::WindowController** controller);
 
 // Returns true if |function| (and the profile and extension that it was
 // invoked from) can operate on the window wrapped by |window_controller|.
+// If |all_window_types| is set this function will return true for any
+// kind of window (including app and devtools), otherwise it will
+// return true only for normal browser windows as well as windows
+// created by the extension.
 bool CanOperateOnWindow(const UIThreadExtensionFunction* function,
-                        const extensions::WindowController* controller);
+                        const extensions::WindowController* controller,
+                        const std::vector<windows::WindowType>& type_filter);
+
+// Same as |CanOperateOnWindow| but uses |extension| and |browser_context|
+// instead of a UIThreadExtensionFunction.
+bool ExtensionCanOperateOnWindow(
+    const extensions::Extension* extension,
+    content::BrowserContext* browser_context,
+    const extensions::WindowController* controller,
+    const std::vector<windows::WindowType>& type_filter);
 
 }  // namespace windows_util
 
 #endif  // CHROME_BROWSER_EXTENSIONS_API_TABS_WINDOWS_UTIL_H__