extensions: windows: list all windows from the current profile

chrome/browser/extensions/api/tabs/windows_event_router.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 "chrome/browser/extensions/api/tabs/windows_event_router.h"
 
 #include "base/values.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/extensions/api/tabs/app_base_window.h"
 #include "chrome/browser/extensions/api/tabs/app_window_controller.h"
@@ skipping 120 matching lines @@
     const content::NotificationDetails& details) {
 #if defined(OS_MACOSX)
   if (chrome::NOTIFICATION_NO_KEY_WINDOW == type) {
     OnActiveWindowChanged(nullptr);
     return;
   }
 #endif
 }
 
 static bool WillDispatchWindowFocusedEvent(
-    BrowserContext* new_active_context,
-    int window_id,
+    WindowController* window_controller,
     BrowserContext* context,
     const Extension* extension,
     base::ListValue* event_args,
     const base::DictionaryValue* listener_filter) {
+  int window_id = window_controller ? window_controller->GetWindowId()
+                                    : extension_misc::kUnknownWindowId;
+  Profile* new_active_context =
+      window_controller ? window_controller->profile() : nullptr;
+
   // When switching between windows in the default and incognito profiles,
   // dispatch WINDOW_ID_NONE to extensions whose profile lost focus that
   // can't see the new focused window across the incognito boundary.
   // See crbug.com/46610.
   if (new_active_context && new_active_context != context &&
       !util::CanCrossIncognito(extension, context)) {
     event_args->Clear();
     event_args->Append(new base::FundamentalValue(
         extension_misc::kUnknownWindowId));
   } else {
@@ skipping 21 matching lines @@
   focused_profile_ = window_profile;
   focused_window_id_ = window_id;
 
   if (!HasEventListener(windows::OnFocusChanged::kEventName))
     return;
 
   scoped_ptr<Event> event(new Event(events::WINDOWS_ON_FOCUS_CHANGED,
                                     windows::OnFocusChanged::kEventName,
                                     make_scoped_ptr(new base::ListValue())));
   event->will_dispatch_callback =
-      base::Bind(&WillDispatchWindowFocusedEvent,
-                 static_cast<BrowserContext*>(window_profile),
-                 window_id);
+      base::Bind(&WillDispatchWindowFocusedEvent, window_controller);
+  // Set the window type to 'normal' if we don't have a window
+  // controller, so the event is not filtered.
+  event->filter_info.SetWindowType(window_controller
+                                       ? window_controller->GetWindowTypeText()
+                                       : keys::kWindowTypeValueNormal);
   EventRouter::Get(profile_)->BroadcastEvent(event.Pass());
 }
 
 void WindowsEventRouter::DispatchEvent(events::HistogramValue histogram_value,
                                        const std::string& event_name,
                                        WindowController* window_controller,
                                        scoped_ptr<base::ListValue> args) {
   scoped_ptr<Event> event(new Event(histogram_value, event_name, args.Pass()));
   event->restrict_to_browser_context = window_controller->profile();
+  event->filter_info.SetWindowType(window_controller->GetWindowTypeText());
   EventRouter::Get(profile_)->BroadcastEvent(event.Pass());
 }
 
 bool WindowsEventRouter::HasEventListener(const std::string& event_name) {
   return EventRouter::Get(profile_)->HasEventListener(event_name);
 }
 
 void WindowsEventRouter::AddAppWindow(extensions::AppWindow* app_window) {
   scoped_ptr<AppWindowController> controller(new AppWindowController(
       app_window, make_scoped_ptr(new AppBaseWindow(app_window)), profile_));
   app_windows_.set(app_window->session_id().id(), controller.Pass());
 }
 
 }  // namespace extensions