sbWindowWatcher.cpp

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set sw=2 :miv */
/*
 *=BEGIN SONGBIRD GPL
 *
 * This file is part of the Songbird web player.
 *
 * Copyright(c) 2005-2009 POTI, Inc.
 * http://www.songbirdnest.com
 *
 * This file may be licensed under the terms of of the
 * GNU General Public License Version 2 (the ``GPL'').
 *
 * Software distributed under the License is distributed
 * on an ``AS IS'' basis, WITHOUT WARRANTY OF ANY KIND, either
 * express or implied. See the GPL for the specific language
 * governing rights and limitations.
 *
 * You should have received a copy of the GPL along with this
 * program. If not, go to http://www.gnu.org/licenses/gpl.html
 * or write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 *
 *=END SONGBIRD GPL
 */

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Songbird window watcher.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Songbird window watcher imported services.
//
//------------------------------------------------------------------------------

// Self imports.
#include "sbWindowWatcher.h"

// Songbird imports.
#include <sbThreadUtils.h>

// Mozilla imports.
#include <nsAutoLock.h>
#include <nsIDOMDocument.h>
#include <nsIDOMElement.h>
#include <nsIDOMEvent.h>
#include <nsIProxyObjectManager.h>
#include <nsMemory.h>
#include <nsServiceManagerUtils.h>
#include <prlog.h>

#ifdef PR_LOGGING
static PRLogModuleInfo* gWindowWatcherLog = nsnull;
#define TRACE(args) PR_LOG(gWindowWatcherLog, PR_LOG_DEBUG, args)
#define LOG(args)   PR_LOG(gWindowWatcherLog, PR_LOG_WARN, args)
#else
#define TRACE(args) /* nothing */
#define LOG(args)   /* nothing */
#endif

//------------------------------------------------------------------------------
//
// Songbird window watcher preprocessor definitions.
//
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Songbird window watcher nsISupports implementation.
//
//------------------------------------------------------------------------------

NS_IMPL_THREADSAFE_ISUPPORTS3(sbWindowWatcher,
                              sbIWindowWatcher,
                              nsIObserver,
                              nsISupportsWeakReference)


//------------------------------------------------------------------------------
//
// Songbird window watcher sbIWindowWatcher implementation.
//
//------------------------------------------------------------------------------


NS_IMETHODIMP
sbWindowWatcher::CallWithWindow(const nsAString&           aWindowType,
                                sbICallWithWindowCallback* aCallback,
                                PRBool                     aWait)
{
  // Validate arguments.
  NS_ENSURE_ARG_POINTER(aCallback);

  // Function variables.
  nsresult rv;

  // If not on main thread, call back through a proxy.
  if (!SB_IsMainThread(mThreadManager)) {
    // Get a main thread proxy to this instance.
    nsCOMPtr<sbIWindowWatcher> proxyWindowWatcher;
    rv = GetProxiedWindowWatcher(getter_AddRefs(proxyWindowWatcher));
    NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);

    // Call back through the proxy.  Wait for window if specified to do so.
    rv = NS_OK;
    while (1) {
      // Call the proxied window watcher.  Exit loop on success or if not
      // waiting.
      rv = proxyWindowWatcher->CallWithWindow(aWindowType, aCallback, aWait);
      if (NS_SUCCEEDED(rv) || !aWait)
        break;
      if (rv != NS_ERROR_NOT_AVAILABLE)
        NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);

      // Wait for a window if none available.
      rv = WaitForWindow(aWindowType);
      NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);
    }
    NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);

    return NS_OK;
  }

  // Operate within the monitor.
  nsAutoMonitor autoMonitor(mMonitor);

  // Check if window is already available.
  nsCOMPtr<nsIDOMWindow> window;
  rv = GetWindow(aWindowType, getter_AddRefs(window));
  NS_ENSURE_SUCCESS(rv, NS_ERROR_FAILURE);

  // If a window is available or this instance is shutting down, call the
  // callback.  Otherwise, place the call with window information on the call
  // with window list.
  if (window || mIsShuttingDown) {
    aCallback->HandleWindowCallback(window);
  } else {
    // If specified to wait and the window is not available, return a not
    // available error indication instead of enqueuing onto the call with window
    // list.
    if (aWait)
      return NS_ERROR_NOT_AVAILABLE;

    // Place the call with window information on the call with window list.
    CallWithWindowInfo callWithWindowInfo;
    callWithWindowInfo.windowType = aWindowType;
    callWithWindowInfo.callback = aCallback;
    mCallWithWindowList.AppendElement(callWithWindowInfo);
  }

  return NS_OK;
}


NS_IMETHODIMP
sbWindowWatcher::GetWindow(const nsAString& aWindowType,
                           nsIDOMWindow**   _retval)
{
  // Validate arguments.
  NS_ENSURE_ARG_POINTER(_retval);

  // Function variables.
  nsCOMPtr<nsIDOMWindow> retWindow;
  PRBool                 success;
  nsresult               rv;

  // This method may only be called on the main thread.
  NS_ENSURE_TRUE(SB_IsMainThread(mThreadManager), NS_ERROR_UNEXPECTED);

  // Operate within the monitor.
  nsAutoMonitor autoMonitor(mMonitor);

  // Get an enumerator of all windows of the specified type, sorted from oldest
  // to youngest.
  nsCOMPtr<nsISimpleEnumerator> enumerator;
  rv = mWindowMediator->GetEnumerator(aWindowType.BeginReading(),
                                      getter_AddRefs(enumerator));
  NS_ENSURE_SUCCESS(rv, rv);

  // Search for the most recently focused ready window of the specified type.
  // The enumerator enumerates from oldest to youngest (least recently focused
  // to most recently), so the last matching window is the most recently focused
  // one.
  PRBool hasMoreElements;
  rv = enumerator->HasMoreElements(&hasMoreElements);
  NS_ENSURE_SUCCESS(rv, rv);
  while (hasMoreElements) {
    // Get the window.  Skip if not ready.
    nsCOMPtr<nsISupports> _window;
    nsCOMPtr<nsIDOMWindow> window;
    rv = enumerator->GetNext(getter_AddRefs(_window));
    NS_ENSURE_SUCCESS(rv, rv);
    window = do_QueryInterface(_window, &rv);
    NS_ENSURE_SUCCESS(rv, rv);
    rv = enumerator->HasMoreElements(&hasMoreElements);
    NS_ENSURE_SUCCESS(rv, rv);

    // Skip window if not ready.
    WindowInfo* windowInfo;
    success = mWindowInfoTable.Get(window, &windowInfo);
    if (!success || !(windowInfo->isReady))
      continue;

    // Get the window type.
    nsAutoString windowType;
    rv = GetWindowType(window, windowType);
    if (NS_FAILED(rv))
      continue;

    // Check for a match.
    if (aWindowType.Equals(windowType)) {
      retWindow = window;
    }
  }

  // Return results.
  NS_IF_ADDREF(*_retval = retWindow);

  return NS_OK;
}


NS_IMETHODIMP
sbWindowWatcher::WaitForWindow(const nsAString& aWindowType)
{
  nsresult rv;

  // This method may not be called on the main thread.
  NS_ENSURE_TRUE(!SB_IsMainThread(mThreadManager), NS_ERROR_UNEXPECTED);

  // Don't wait if this instance is shutting down.
  {
    // Check is shutting down within the monitor.
    nsAutoMonitor autoMonitor(mMonitor);
    if (mIsShuttingDown)
      return NS_OK;
  }

  // Create a wait for window object.
  nsRefPtr<sbWindowWatcherWaitForWindow> waitForWindow;
  rv = sbWindowWatcherWaitForWindow::New(getter_AddRefs(waitForWindow));
  NS_ENSURE_SUCCESS(rv, rv);

  // Wait for the window.
  rv = waitForWindow->Wait(aWindowType);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}


//
// Getters/setters.
//

NS_IMETHODIMP
sbWindowWatcher::GetIsShuttingDown(PRBool* aIsShuttingDown)
{
  // Validate arguments.
  NS_ENSURE_ARG_POINTER(aIsShuttingDown);

  // Operate within the monitor.
  nsAutoMonitor autoMonitor(mMonitor);

  // Return results.
  *aIsShuttingDown = mIsShuttingDown;

  return NS_OK;
}


//------------------------------------------------------------------------------
//
// Songbird window watcher nsIObserver implementation.
//
//------------------------------------------------------------------------------

NS_IMETHODIMP
sbWindowWatcher::Observe(nsISupports*     aSubject,
                         const char*      aTopic,
                         const PRUnichar* aData)
{
  nsresult rv;

  TRACE(("%s: observing %s", __FUNCTION__, aTopic));

  /* Dispatch processing of event. */
  if (!strcmp(aTopic, "domwindowopened")) {
    rv = OnDOMWindowOpened(aSubject, aData);
    NS_ENSURE_SUCCESS(rv, rv);
  } else if (!strcmp(aTopic, "domwindowclosed")) {
    rv = OnDOMWindowClosed(aSubject, aData);
    NS_ENSURE_SUCCESS(rv, rv);
  } else if (!strcmp(aTopic, "quit-application-granted")) {
    rv = OnQuitApplicationGranted();
    NS_ENSURE_SUCCESS(rv, rv);
  }

  return NS_OK;
}


nsresult
sbWindowWatcher::OnDOMWindowOpened(nsISupports*     aSubject,
                                   const PRUnichar* aData)
{
  // Validate arguments and state.
  NS_ASSERTION(aSubject, "aSubject is null");
  NS_ASSERTION(SB_IsMainThread(mThreadManager), "not on main thread");

  // Function variables.
  nsresult rv;

  // Get the event window.
  nsCOMPtr<nsIDOMWindow> window = do_QueryInterface(aSubject, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // Add the window.
  rv = AddWindow(window);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}


nsresult
sbWindowWatcher::OnDOMWindowClosed(nsISupports*     aSubject,
                                   const PRUnichar* aData)
{
  // Validate arguments and state.
  NS_ASSERTION(aSubject, "aSubject is null");
  NS_ASSERTION(SB_IsMainThread(mThreadManager), "not on main thread");

  // Function variables.
  nsresult rv;

  // Get the event window.
  nsCOMPtr<nsIDOMWindow> window = do_QueryInterface(aSubject, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // Remove the window.
  rv = RemoveWindow(window);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}


nsresult
sbWindowWatcher::OnQuitApplicationGranted()
{
  // Validate state.
  NS_ASSERTION(SB_IsMainThread(mThreadManager), "not on main thread");

  // Shutdown the Songbird window watcher services.
  Shutdown();

  return NS_OK;
}


//------------------------------------------------------------------------------
//
// Songbird window watcher services.
//
//------------------------------------------------------------------------------

sbWindowWatcher::sbWindowWatcher() :
  mSentMainWinPresentedNotification(PR_FALSE),
  mIsShuttingDown(PR_FALSE),
  mServicingCallWithWindowList(PR_FALSE)
{
  #if PR_LOGGING
    if (!gWindowWatcherLog)
      gWindowWatcherLog= PR_NewLogModule("sbWindowWatcher");
  #endif /* PR_LOGGING */
}


sbWindowWatcher::~sbWindowWatcher()
{
  // Finalize the window watcher.
  Finalize();
}


nsresult
sbWindowWatcher::Init()
{
  nsresult rv;

  // Get the window watcher service.
  mWindowWatcher = do_GetService("@mozilla.org/embedcomp/window-watcher;1",
                                 &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // Get the window mediator service.
  mWindowMediator = do_GetService("@mozilla.org/appshell/window-mediator;1",
                                  &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // Get the observer service.
  mObserverService = do_GetService("@mozilla.org/observer-service;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // Get the thread manager.  This is used so that main thread checks work
  // during XPCOM shutdown.
  mThreadManager = do_GetService("@mozilla.org/thread-manager;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // Create a monitor.
  mMonitor = nsAutoMonitor::NewMonitor("sbWindowWatcher::mMonitor");
  NS_ENSURE_TRUE(mMonitor, NS_ERROR_OUT_OF_MEMORY);

  // Initialize the window information table.
  mWindowInfoTable.Init();

  // Add a window watcher observer.
  rv = mWindowWatcher->RegisterNotification(this);
  NS_ENSURE_SUCCESS(rv, rv);

  // Add quit-application-granted observer.
  rv = mObserverService->AddObserver(this,
                                     "quit-application-granted",
                                     PR_FALSE);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}


void
sbWindowWatcher::Finalize()
{
  TRACE(("%s", __FUNCTION__));
  // Ensure this instance is shut down.
  Shutdown();

  // Remove all windows.
  RemoveAllWindows();

  // Dispose of monitor.
  if (mMonitor)
    nsAutoMonitor::DestroyMonitor(mMonitor);
  mMonitor = nsnull;

  // Remove object references.
  mWindowWatcher = nsnull;
  mWindowMediator = nsnull;
  mWindowList.Clear();
  mWindowInfoTable.Clear();
  mCallWithWindowList.Clear();
}


//------------------------------------------------------------------------------
//
// Internal Songbird window watcher services.
//
//------------------------------------------------------------------------------

void
sbWindowWatcher::Shutdown()
{
  // Validate state.
  NS_ASSERTION(SB_IsMainThread(mThreadManager), "not on main thread");

  // Operate within the monitor.
  {
    nsAutoMonitor autoMonitor(mMonitor);

    // Do nothing if already shutting down.
    if (mIsShuttingDown)
      return;

    // Indicate that this instance is shutting down.
    mIsShuttingDown = PR_TRUE;
  }

  // Remove quit-application-granted observer.
  mObserverService->RemoveObserver(this, "quit-application-granted");

  // Invoke all call with window callbacks.
  InvokeCallWithWindowCallbacks(nsnull);

  // Remove window watcher observer.
  if (mWindowWatcher)
    mWindowWatcher->UnregisterNotification(this);
}


nsresult
sbWindowWatcher::AddWindow(nsIDOMWindow* aWindow)
{
  // Validate arguments and state.
  NS_ASSERTION(aWindow, "aWindow is null");

  // Function variables.
  PRBool success;
  nsresult rv;

  // Operate within the monitor.
  nsAutoMonitor autoMonitor(mMonitor);

  // Create the window info object.
  nsAutoPtr<WindowInfo> windowInfo;
  windowInfo = new WindowInfo();
  NS_ENSURE_TRUE(windowInfo, NS_ERROR_OUT_OF_MEMORY);
  windowInfo->window = aWindow;

  // Get the window event target.
  nsCOMPtr<nsIDOMWindow2> window2 = do_QueryInterface(aWindow, &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  nsCOMPtr<nsIDOMEventTarget> windowEventTarget;
  rv = window2->GetWindowRoot(getter_AddRefs(windowEventTarget));
  NS_ENSURE_SUCCESS(rv, rv);
  windowInfo->eventTarget = windowEventTarget;

  // Create a window event listener.
  nsRefPtr<sbWindowWatcherEventListener> eventListener;
  rv = sbWindowWatcherEventListener::New(getter_AddRefs(eventListener),
                                         this,
                                         aWindow);
  NS_ENSURE_SUCCESS(rv, rv);
  windowInfo->eventListener = eventListener;

  // Add the window info to the window info table.
  success = mWindowInfoTable.Put(aWindow, windowInfo.forget());
  NS_ENSURE_TRUE(success, NS_ERROR_OUT_OF_MEMORY);

  // Add the opened window to the window list.
  success = mWindowList.AppendObject(aWindow);
  NS_ENSURE_TRUE(success, NS_ERROR_FAILURE);

  // Listen for when the window has opened completely.
  // Due to annoying platform differences, we need to figure out when the
  // _last_ of a combination of events to occur (but the first instance of each)
  const char* DOM_WINDOW_READY_EVENT_TYPES[] = {  "resize", "sb-overlay-load" };

  for (unsigned int i = 0; i < NS_ARRAY_LENGTH(DOM_WINDOW_READY_EVENT_TYPES); ++i) {
    rv = eventListener->AddEventListener(DOM_WINDOW_READY_EVENT_TYPES[i]);
    NS_ENSURE_SUCCESS(rv, rv);
  }

  return NS_OK;
}


nsresult
sbWindowWatcher::RemoveWindow(nsIDOMWindow* aWindow)
{
  // Validate arguments.
  NS_ASSERTION(aWindow, "aWindow is null");

  // Function variables.
  PRBool success;
  nsresult rv;

  // Operate within the monitor.
  nsAutoMonitor autoMonitor(mMonitor);

  // Get the removed window information.
  WindowInfo* windowInfo;
  success = mWindowInfoTable.Get(aWindow, &windowInfo);
  if (!success)
    windowInfo = nsnull;

  // Remove listener for the end of window overlay load events.
  if (windowInfo) {
    rv = windowInfo->eventListener->ClearEventListeners();
    NS_ENSURE_SUCCESS(rv, rv);
  }

  // Remove the closed window from the window information map.
  mWindowInfoTable.Remove(aWindow);

  // Remove the closed window from the window list.
  mWindowList.RemoveObject(aWindow);

  return NS_OK;
}


void
sbWindowWatcher::RemoveAllWindows()
{
  // Operate within the monitor.
  nsAutoMonitor autoMonitor(mMonitor);

  // Remove all of the windows.
  PRInt32 windowCount = mWindowList.Count();
  for (PRInt32 i = windowCount - 1; i >= 0; i--) {
    RemoveWindow(mWindowList[i]);
  }
}


void
sbWindowWatcher::OnWindowReady(nsIDOMWindow* aWindow)
{
  // Validate arguments.
  NS_ENSURE_TRUE(aWindow, /* void */);

  // Function variables.
  PRBool   success;
  nsresult rv;

  // If window is the main Songbird window, notify observers.
  if (!mSentMainWinPresentedNotification) {
    nsAutoString windowType;
    rv = GetWindowType(aWindow, windowType);
    NS_ENSURE_SUCCESS(rv, /* void */);
    if (windowType.EqualsLiteral("Songbird:Main")) {
      rv = mObserverService->NotifyObservers(aWindow,
                                             "songbird-main-window-presented",
                                             nsnull);
      NS_ENSURE_SUCCESS(rv, /* void */);
      mSentMainWinPresentedNotification = PR_TRUE;
    }
  }

  // Operate within the monitor.
  {
    nsAutoMonitor autoMonitor(mMonitor);

    // Get the window information.  Do nothing if not available.
    WindowInfo* windowInfo;
    success = mWindowInfoTable.Get(aWindow, &windowInfo);
    NS_ENSURE_TRUE(success, /* void */);

    // Indicate that the window is ready.
    windowInfo->isReady = PR_TRUE;
  }

  // Invoke call with window callbacks.
  InvokeCallWithWindowCallbacks(aWindow);
}


nsresult
sbWindowWatcher::GetWindowType(nsIDOMWindow* aWindow,
                               nsAString&    aWindowType)
{
  // Validate arguments.
  NS_ASSERTION(aWindow, "aWindow is null.");

  // Function variables.
  nsresult rv;

  // Get the window element.  The window won't neccessariy have one.
  nsCOMPtr<nsIDOMElement> element;
  nsCOMPtr<nsIDOMDocument> document;
  rv = aWindow->GetDocument(getter_AddRefs(document));
  NS_ENSURE_SUCCESS(rv, rv);
  if (!document)
    return NS_ERROR_NOT_AVAILABLE;
  rv = document->GetDocumentElement(getter_AddRefs(element));
  NS_ENSURE_SUCCESS(rv, rv);
  if (!element)
    return NS_ERROR_NOT_AVAILABLE;

  // Get the window type attribute.
  rv = element->GetAttribute(NS_LITERAL_STRING("windowtype"), aWindowType);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}


nsresult
sbWindowWatcher::InvokeCallWithWindowCallbacks(nsIDOMWindow* aWindow)
{
  // Function variables.
  nsresult rv;

  // Get the window type.
  nsAutoString windowType;
  if (aWindow) {
    rv = GetWindowType(aWindow, windowType);
    NS_ENSURE_SUCCESS(rv, rv);
  }

  // Operate within the monitor.
  nsAutoMonitor autoMonitor(mMonitor);

  // Do nothing if the call with window list is already being serviced.
  if (mServicingCallWithWindowList)
    return NS_OK;

  // Mark that the call with window list is being serviced
  mServicingCallWithWindowList = PR_TRUE;

  // Call all of the matching callbacks.
  for (PRUint32 i = 0; i < mCallWithWindowList.Length();) {
    // Get the call with window info.
    CallWithWindowInfo& callWithWindowInfo = mCallWithWindowList[i];

    // If the info matches, call callback and remove info from list.  Otherwise,
    // advance to the next info item in list.
    if (!aWindow || windowType.Equals(callWithWindowInfo.windowType)) {
      callWithWindowInfo.callback->HandleWindowCallback(aWindow);
      mCallWithWindowList.RemoveElementAt(i);
    } else {
      i++;
    }
  }

  // Mark that the call with window list is no longer being serviced
  mServicingCallWithWindowList = PR_FALSE;

  return NS_OK;
}


nsresult
sbWindowWatcher::GetProxiedWindowWatcher(sbIWindowWatcher** aWindowWatcher)
{
  // Validate arguments.
  NS_ASSERTION(aWindowWatcher, "aWindowWatcher is null");

  // Function variables.
  nsresult rv;

  // Create a main thread proxy for the window watcher.
  nsCOMPtr<nsIProxyObjectManager>
    proxyObjectManager = do_GetService("@mozilla.org/xpcomproxy;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  rv = proxyObjectManager->GetProxyForObject
                             (NS_PROXY_TO_MAIN_THREAD,
                              NS_GET_IID(sbIWindowWatcher),
                              NS_ISUPPORTS_CAST(sbIWindowWatcher *, this),
                                nsIProxyObjectManager::INVOKE_SYNC |
                                nsIProxyObjectManager::FORCE_PROXY_CREATION,
                              (void**) aWindowWatcher);
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}


//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Songbird window watcher event listener class.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Songbird window watcher event listener nsISupports implementation.
//
//------------------------------------------------------------------------------

NS_IMPL_THREADSAFE_ISUPPORTS1(sbWindowWatcherEventListener,
                              nsIDOMEventListener)


//------------------------------------------------------------------------------
//
// Songbird window watcher event listener nsIDOMEventListener implementation.
//
//------------------------------------------------------------------------------


NS_IMETHODIMP
sbWindowWatcherEventListener::HandleEvent(nsIDOMEvent* event)
{
  // Validate arguments.
  NS_ENSURE_ARG_POINTER(event);

  #if PR_LOGGING
  {
    nsString type;
    nsresult rv = event->GetType(type);
    if (NS_SUCCEEDED(rv)) {
      TRACE(("%s: got event %s",
             __FUNCTION__,
             NS_ConvertUTF16toUTF8(type).get()));
    }
  }
  #endif

  // Function variables.
  nsresult rv;

  // Ensure the window watcher still exists.
  nsCOMPtr<sbIWindowWatcher>
    windowWatcher = do_QueryReferent(mWeakSBWindowWatcher, &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // Get the event type.
  nsAutoString eventType;
  rv = event->GetType(eventType);
  NS_ENSURE_SUCCESS(rv, rv);

  // Dispatch processing of event.
  if (mOutstandingEvents.Contains(eventType)) {
    nsCOMPtr<nsIDOMEventTarget> target;
    rv = event->GetCurrentTarget(getter_AddRefs(target));
    NS_ENSURE_SUCCESS(rv, rv);
    rv = target->RemoveEventListener(eventType, this, PR_TRUE);
    NS_ENSURE_SUCCESS(rv, rv);
    mOutstandingEvents.RemoveElement(eventType);
    TRACE(("%s: removed event %s listener %p from %p",
           __FUNCTION__,
           NS_ConvertUTF16toUTF8(eventType).get(),
           this,
           target.get()));
    if (mOutstandingEvents.IsEmpty()) {
      mSBWindowWatcher->OnWindowReady(mWindow);
    }
  }

  return NS_OK;
}


//------------------------------------------------------------------------------
//
// Songbird window watcher event listener implementation.
//
//------------------------------------------------------------------------------

/* static */
nsresult
sbWindowWatcherEventListener::New
  (sbWindowWatcherEventListener** aListener,
   sbWindowWatcher*               aSBWindowWatcher,
   nsIDOMWindow*                  aWindow)
{
  // Validate arguments.
  NS_ENSURE_ARG_POINTER(aListener);

  // Function variables.
  nsresult rv;

  // Create the listener object.
  nsRefPtr<sbWindowWatcherEventListener> listener;
  listener = new sbWindowWatcherEventListener(aSBWindowWatcher, aWindow);
  NS_ENSURE_TRUE(listener, NS_ERROR_OUT_OF_MEMORY);

  // Initialize the listener object.
  rv = listener->Initialize();
  NS_ENSURE_SUCCESS(rv, rv);

  // Return results.
  return CallQueryInterface(listener.get(), aListener);
}


//------------------------------------------------------------------------------
//
// Internal Songbird window watcher event listener implementation.
//
//------------------------------------------------------------------------------

nsresult
sbWindowWatcherEventListener::Initialize()
{
  nsresult rv;

  // Get a weak reference to the window watcher object.
  nsCOMPtr<nsISupportsWeakReference>
    weakSBWindowWatcher =
      do_QueryInterface(NS_ISUPPORTS_CAST(sbIWindowWatcher*, mSBWindowWatcher),
                        &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  rv = weakSBWindowWatcher->GetWeakReference
                              (getter_AddRefs(mWeakSBWindowWatcher));
  NS_ENSURE_SUCCESS(rv, rv);

  // Get the window event target.
  nsCOMPtr<nsIDOMWindow2> window2 = do_QueryInterface(mWindow, &rv);
  NS_ENSURE_SUCCESS(rv, rv);
  rv = window2->GetWindowRoot(getter_AddRefs(mEventTarget));
  NS_ENSURE_SUCCESS(rv, rv);

  return NS_OK;
}


nsresult
sbWindowWatcherEventListener::AddEventListener(const char* aEventName)
{
  nsresult rv;

  NS_ENSURE_TRUE(mEventTarget, NS_ERROR_NOT_INITIALIZED);

  NS_ConvertASCIItoUTF16 eventName(aEventName);

  if (mOutstandingEvents.Contains(eventName)) {
    return NS_OK;
  }

  rv = mEventTarget->AddEventListener(eventName, this, PR_TRUE);
  NS_ENSURE_SUCCESS(rv, rv);

  mOutstandingEvents.AppendElement(eventName);
  TRACE(("%s: Added event %s listener %p to %p",
         __FUNCTION__,
         aEventName,
         this,
         mEventTarget.get()));

  return NS_OK;
}

nsresult
sbWindowWatcherEventListener::ClearEventListeners()
{
  nsresult rv;

  TRACE(("%s: clearing %p from %p",
         __FUNCTION__,
         this,
         mEventTarget.get()));

  NS_ENSURE_TRUE(mEventTarget, NS_ERROR_NOT_INITIALIZED);

  for (PRUint32 i = mOutstandingEvents.Length() - 1; i != PRUint32(-1); --i) {
    TRACE(("%s: Removing event %s listener %p from %p",
           __FUNCTION__,
           NS_ConvertUTF16toUTF8(mOutstandingEvents[i]).get(),
           this,
           mEventTarget.get()));
    rv = mEventTarget->RemoveEventListener(mOutstandingEvents[i],
                                           this,
                                           PR_TRUE);
    NS_ENSURE_SUCCESS(rv, rv);
    mOutstandingEvents.RemoveElementAt(i);
  }
  NS_ASSERTION(mOutstandingEvents.IsEmpty(),
               "unexpected outstanding listeners!");
  return NS_OK;
}

//------------------------------------------------------------------------------
//------------------------------------------------------------------------------
//
// Songbird window watcher wait for window class.
//
//------------------------------------------------------------------------------
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
//
// Songbird window watcher wait for window nsISupports implementation.
//
//------------------------------------------------------------------------------

NS_IMPL_THREADSAFE_ISUPPORTS1(sbWindowWatcherWaitForWindow,
                              sbICallWithWindowCallback)


//------------------------------------------------------------------------------
//
// Songbird window watcher wait for window sbICallWithWindowCallback
// implementation.
//
//------------------------------------------------------------------------------


NS_IMETHODIMP
sbWindowWatcherWaitForWindow::HandleWindowCallback(nsIDOMWindow* aWindow)
{
  // Operate under the ready monitor.
  nsAutoMonitor autoReadyMonitor(mReadyMonitor);

  // Get the ready window.
  mWindow = aWindow;
  mReady = PR_TRUE;

  // Send notification that the window is ready.
  autoReadyMonitor.Notify();

  return NS_OK;
}


//------------------------------------------------------------------------------
//
// Songbird window watcher wait for window implementation.
//
//------------------------------------------------------------------------------

/* static */
nsresult
sbWindowWatcherWaitForWindow::New(sbWindowWatcherWaitForWindow** aWaitForWindow)
{
  // Validate arguments.
  NS_ENSURE_ARG_POINTER(aWaitForWindow);

  // Function variables.
  nsresult rv;

  // Create the wait for window object.
  nsRefPtr<sbWindowWatcherWaitForWindow> waitForWindow;
  waitForWindow = new sbWindowWatcherWaitForWindow();
  NS_ENSURE_TRUE(waitForWindow, NS_ERROR_OUT_OF_MEMORY);

  // Initialize the wait for window object.
  rv = waitForWindow->Initialize();
  NS_ENSURE_SUCCESS(rv, rv);

  // Return results.
  NS_ADDREF(*aWaitForWindow = waitForWindow);

  return NS_OK;
}


sbWindowWatcherWaitForWindow::~sbWindowWatcherWaitForWindow()
{
  // Dispose of the monitor.
  if (mReadyMonitor)
    nsAutoMonitor::DestroyMonitor(mReadyMonitor);
  mReadyMonitor = nsnull;

  // Remove object references.
  mSBWindowWatcher = nsnull;
  mWindow = nsnull;
}


nsresult
sbWindowWatcherWaitForWindow::Wait(const nsAString& aWindowType)
{
  nsresult rv;

  // Set up to call this instance with a matching window.
  rv = mSBWindowWatcher->CallWithWindow(aWindowType, this, false);
  NS_ENSURE_SUCCESS(rv, rv);

  // Operate under the ready monitor.
  nsAutoMonitor autoReadyMonitor(mReadyMonitor);

  // Wait for a window to be ready.
  if (!mReady) {
    rv = autoReadyMonitor.Wait();
    NS_ENSURE_SUCCESS(rv, rv);
  }

  return NS_OK;
}


//------------------------------------------------------------------------------
//
// Internal Songbird window watcher wait for window implementation.
//
//------------------------------------------------------------------------------

sbWindowWatcherWaitForWindow::sbWindowWatcherWaitForWindow() :
  mReadyMonitor(nsnull),
  mReady(PR_FALSE)
{
}


nsresult
sbWindowWatcherWaitForWindow::Initialize()
{
  nsresult rv;

  // Get the Songbird window watcher service.
  mSBWindowWatcher =
    do_GetService("@songbirdnest.com/Songbird/window-watcher;1", &rv);
  NS_ENSURE_SUCCESS(rv, rv);

  // Create a monitor.
  mReadyMonitor =
    nsAutoMonitor::NewMonitor("sbWindowWatcherWaitForWindow::mReadyMonitor");
  NS_ENSURE_TRUE(mReadyMonitor, NS_ERROR_OUT_OF_MEMORY);

  return NS_OK;
}