widget/nsIAppShell.idl
author Valentin Gosu <valentin.gosu@gmail.com>
Wed, 27 Aug 2014 05:42:13 +0300
changeset 209178 7e1d2aaeeec1b843ba061552d6e66bd9cc19df85
parent 166180 89f9304ff4baf44fa4893998dae116e6746d8783
child 256827 1b8f36a7ee321ca62cf87424910d0e2ed6fed076
permissions -rw-r--r--
Bug 786419 - Part 11 - Address possible issues with offline notifications in nsGlobalWindow and WorkerPrivate r=bent Part 2 of this bug adds nsGlobalWindow as an observer for the app-offline notification. There are however a few corner cases we haven't handled. For example: If the browser is offline, and an app is made offline, there should be no offline event dispatched. Also, WorkerPrivate should ignore offline events that cause no change in its offline state.

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#include "nsISupports.idl"

interface nsIRunnable;

/**
 * Interface for the native event system layer.  This interface is designed
 * to be used on the main application thread only.
 */
[uuid(2d10ca53-f143-439a-bb2e-c1fbc71f6a05)]
interface nsIAppShell : nsISupports
{
  /**
   * Enter an event loop.  Don't leave until exit() is called.
   */
  void run();

  /**
   * Exit the handle event loop
   */
  void exit();

  /**
   * Give hint to native event queue notification mechanism. If the native
   * platform needs to tradeoff performance vs. native event starvation this
   * hint tells the native dispatch code which to favor.  The default is to
   * prevent native event starvation.
   *
   * Calls to this function may be nested. When the number of calls that pass
   * PR_TRUE is subtracted from the number of calls that pass PR_FALSE is
   * greater than 0, performance is given precedence over preventing event
   * starvation.
   *
   * The starvationDelay arg is only used when favorPerfOverStarvation is
   * PR_FALSE. It is the amount of time in milliseconds to wait before the
   * PR_FALSE actually takes effect.
   */
  void favorPerformanceHint(in boolean favorPerfOverStarvation,
                            in unsigned long starvationDelay);

  /**
   * Suspends the use of additional platform-specific methods (besides the
   * nsIAppShell->run() event loop) to run Gecko events on the main
   * application thread.  Under some circumstances these "additional methods"
   * can cause Gecko event handlers to be re-entered, sometimes leading to
   * hangs and crashes.  Calls to suspendNative() and resumeNative() may be
   * nested.  On some platforms (those that don't use any "additional
   * methods") this will be a no-op.  Does not (in itself) stop Gecko events
   * from being processed on the main application thread.  But if the
   * nsIAppShell->run() event loop is blocked when this call is made, Gecko
   * events will stop being processed until resumeNative() is called (even
   * if a plugin or library is temporarily processing events on a nested
   * event loop).
   */
  void suspendNative();

  /**
   * Resumes the use of additional platform-specific methods to run Gecko
   * events on the main application thread.  Calls to suspendNative() and
   * resumeNative() may be nested.  On some platforms this will be a no-op.
   */
  void resumeNative();

  /**
   * The current event loop nesting level.
   */
  readonly attribute unsigned long eventloopNestingLevel;
  
  /**
   * Allows running of a "synchronous section", in the form of an nsIRunnable
   * once the event loop has reached a "stable state". We've reached a stable
   * state when the currently executing task/event has finished, see:
   * http://www.whatwg.org/specs/web-apps/current-work/multipage/webappapis.html#synchronous-section
   * In practice this runs aRunnable once the currently executing event
   * finishes. If called multiple times per task/event, all the runnables will
   * be executed, in the order in which runInStableState() was called.
   */
  void runInStableState(in nsIRunnable runnable);

  /**
   * Run the given runnable before the next iteration of the event loop (this
   * includes native events too). If a nested loop is spawned within the current
   * event then the runnable will not be run until that loop has terminated.
   */
  void runBeforeNextEvent(in nsIRunnable runnable);
};