extensions: windows: list all windows from the current profile

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

 // 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.
 
+#include <string>
+#include <vector>
+
 #include "chrome/browser/extensions/api/tabs/windows_util.h"
 
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/chrome_extension_function.h"
 #include "chrome/browser/extensions/chrome_extension_function_details.h"
+#include "chrome/browser/extensions/extension_util.h"
 #include "chrome/browser/extensions/window_controller.h"
 #include "chrome/browser/extensions/window_controller_list.h"
 #include "chrome/browser/profiles/profile.h"
+#include "chrome/common/extensions/api/windows.h"
 #include "extensions/browser/extension_function.h"
 #include "extensions/browser/extension_function_dispatcher.h"
 #include "extensions/common/constants.h"
 #include "extensions/common/error_utils.h"
+#include "extensions/common/extension.h"
+
+namespace keys = extensions::tabs_constants;
+namespace windows = extensions::api::windows;
 
 namespace windows_util {
 
+namespace {
+
+extensions::WindowTypeFilter CreateTypeFilter(
+    int length,
+    const windows::WindowType types[]) {
+  extensions::WindowTypeFilter filter;
+  for (int i = 0; i < length; i++)
+    filter.push_back(types[i]);
+  return filter;
+}
+
+}  // namespace
+
+const extensions::WindowTypeFilter& GetDefaultWindowTypeFilters() {
+  static const windows::WindowType types[] = {windows::WINDOW_TYPE_NORMAL,
+                                              windows::WINDOW_TYPE_PANEL,
+                                              windows::WINDOW_TYPE_POPUP};

[not at google - send to devlin, 2015/07/31 21:48:03]

There are so few of these, you could model it as a bitmask? The whole
static-local-return-reference thing is more complicated than it needs to be, I
think. I'd also put the WindowMatchesTypeFilter function as a method on
WindowTypeFilter:

class WindowTypeFilter {
 public:
  bool MatchesType(WindowType window_type) {
    return filter_ & (1 << window_type);
  }

  ... whatever.

 private:
  // Bitmask of WindowTypes, or -1 to match all types.
  int filter_;
};

After that, just copy it everywhere rather than using references.

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

Switching to a bitmask.

+  CR_DEFINE_STATIC_LOCAL(extensions::WindowTypeFilter, filter,
+                         (CreateTypeFilter(arraysize(types), types)));
+  return filter;
+}
+
+const extensions::WindowTypeFilter& GetNoWindowTypeFilters() {

[not at google - send to devlin, 2015/07/31 21:48:03]

I don't understand this naming... looks like it matches all window types, not
"no"?

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

Done.

+  static const windows::WindowType types[] = {
+      windows::WINDOW_TYPE_APP, windows::WINDOW_TYPE_DEVTOOLS,
+      windows::WINDOW_TYPE_NORMAL, windows::WINDOW_TYPE_PANEL,
+      windows::WINDOW_TYPE_POPUP};
+  CR_DEFINE_STATIC_LOCAL(extensions::WindowTypeFilter, filter,
+                         (CreateTypeFilter(arraysize(types), types)));
+  return filter;
+}
+
+bool WindowMatchesTypeFilter(const extensions::WindowController* controller,
+                             const extensions::WindowTypeFilter& filters) {
+  int window_type = extensions::api::windows::ParseWindowType(

[not at google - send to devlin, 2015/07/31 21:48:03]

this should be a WindowType not an int.

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

Done.

+      controller->GetWindowTypeText());
+  for (const auto& iter : filters) {
+    if (window_type == iter)
+      return true;
+  }
+  return false;
+}
+
 bool GetWindowFromWindowID(UIThreadExtensionFunction* function,
                            int window_id,
+                           const extensions::WindowTypeFilter& type_filter,
                            extensions::WindowController** controller) {
   if (window_id == extension_misc::kCurrentWindowId) {
     extensions::WindowController* extension_window_controller =
         function->dispatcher()->GetExtensionWindowController();
     // If there is a window controller associated with this extension, use that.
     if (extension_window_controller) {
       *controller = extension_window_controller;
     } else {
       // Otherwise get the focused or most recently added window.
       *controller = extensions::WindowControllerList::GetInstance()
                         ->CurrentWindowForFunction(function);
     }
     if (!(*controller)) {
       function->SetError(extensions::tabs_constants::kNoCurrentWindowError);
       return false;
     }
   } else {
     *controller = extensions::WindowControllerList::GetInstance()
-                      ->FindWindowForFunctionById(function, window_id);
+                      ->FindWindowForFunctionByIdWithFilter(function, window_id,
+                                                            type_filter);
     if (!(*controller)) {
       function->SetError(extensions::ErrorUtils::FormatErrorMessage(
           extensions::tabs_constants::kWindowNotFoundError,
           base::IntToString(window_id)));
       return false;
     }
   }
   return true;
 }
 
+bool ExtensionCanOperateOnWindow(
+    const extensions::Extension* extension,
+    content::BrowserContext* browser_context,
+    const extensions::WindowController* controller,
+    const extensions::WindowTypeFilter& type_filter) {
+  if (!WindowMatchesTypeFilter(controller, type_filter))
+    return false;
+
+  if (browser_context == controller->profile())
+    return true;
+
+  if (!extensions::util::CanCrossIncognito(extension, browser_context))

[not at google - send to devlin, 2015/07/31 21:48:03]

The other implementation uses function->include_incognito() which eventually
comes from a call to ChromeExtensionsBrowserClient::CanExtensionCrossIncognito
(trace through to the call site of set_incognito_enabled).

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

It looks like the remaining of a previous iteration of this CL.
Removing as it's not used anymore.

+    return false;
+
+  Profile* profile = Profile::FromBrowserContext(browser_context);
+  return profile->HasOffTheRecordProfile() &&
+         profile->GetOffTheRecordProfile() == controller->profile();
+}
+
 bool CanOperateOnWindow(const UIThreadExtensionFunction* function,
-                        const extensions::WindowController* controller) {
-  if (function->extension() != NULL &&
-      !controller->IsVisibleToExtension(function->extension())) {
+                        const extensions::WindowController* controller,
+                        const extensions::WindowTypeFilter& type_filter) {
+  if (!WindowMatchesTypeFilter(controller, type_filter))
     return false;
-  }
 
   if (function->browser_context() == controller->profile())
     return true;
 
   if (!function->include_incognito())
     return false;
 
   Profile* profile = Profile::FromBrowserContext(function->browser_context());
   return profile->HasOffTheRecordProfile() &&
          profile->GetOffTheRecordProfile() == controller->profile();
 }
 
 }  // namespace windows_util