Add m-esr52 at 52.6.0

1 files changed, 1541 insertions, 0 deletions

diff --git a/toolkit/xre/nsNativeAppSupportWin.cpp b/toolkit/xre/nsNativeAppSupportWin.cpp
new file mode 100644
index 000000000..0605ccb5a
--- /dev/null
+++ b/toolkit/xre/nsNativeAppSupportWin.cpp
@@ -0,0 +1,1541 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/* 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 "nsNativeAppSupportBase.h"
+#include "nsNativeAppSupportWin.h"
+#include "nsAppRunner.h"
+#include "nsXULAppAPI.h"
+#include "nsString.h"
+#include "nsIBrowserDOMWindow.h"
+#include "nsICommandLineRunner.h"
+#include "nsCOMPtr.h"
+#include "nsXPIDLString.h"
+#include "nsIComponentManager.h"
+#include "nsIServiceManager.h"
+#include "nsIDOMChromeWindow.h"
+#include "nsXPCOM.h"
+#include "nsISupportsPrimitives.h"
+#include "nsIWindowWatcher.h"
+#include "nsPIDOMWindow.h"
+#include "nsGlobalWindow.h"
+#include "nsIDocShell.h"
+#include "nsIDocShellTreeItem.h"
+#include "nsIBaseWindow.h"
+#include "nsIWidget.h"
+#include "nsIAppShellService.h"
+#include "nsIXULWindow.h"
+#include "nsIInterfaceRequestor.h"
+#include "nsIInterfaceRequestorUtils.h"
+#include "nsIPromptService.h"
+#include "nsNetCID.h"
+#include "nsNetUtil.h"
+#include "mozilla/Services.h"
+#include "nsIFile.h"
+#include "nsIObserver.h"
+#include "nsIObserverService.h"
+#include "nsIDOMLocation.h"
+#include "nsIWebNavigation.h"
+#include "nsIWindowMediator.h"
+#include "nsNativeCharsetUtils.h"
+#include "nsIAppStartup.h"
+
+#include <windows.h>
+#include <shellapi.h>
+#include <ddeml.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <io.h>
+#include <direct.h>
+#include <fcntl.h>
+
+using namespace mozilla;
+
+static HWND hwndForDOMWindow( mozIDOMWindowProxy * );
+
+static
+nsresult
+GetMostRecentWindow(const char16_t* aType, mozIDOMWindowProxy** aWindow) {
+    nsresult rv;
+    nsCOMPtr<nsIWindowMediator> med( do_GetService( NS_WINDOWMEDIATOR_CONTRACTID, &rv ) );
+    if ( NS_FAILED( rv ) )
+        return rv;
+
+    if ( med )
+        return med->GetMostRecentWindow( aType, aWindow );
+
+    return NS_ERROR_FAILURE;
+}
+
+static
+void
+activateWindow( mozIDOMWindowProxy *win ) {
+    // Try to get native window handle.
+    HWND hwnd = hwndForDOMWindow( win );
+    if ( hwnd ) {
+        // Restore the window if it is minimized.
+        if ( ::IsIconic( hwnd ) ) {
+            ::ShowWindow( hwnd, SW_RESTORE );
+        }
+        // Use the OS call, if possible.
+        ::SetForegroundWindow( hwnd );
+    } else {
+        // Use internal method.
+        nsCOMPtr<nsPIDOMWindowOuter> piWin = nsPIDOMWindowOuter::From(win);
+        piWin->Focus();
+    }
+}
+
+
+#ifdef DEBUG_law
+#undef MOZ_DEBUG_DDE
+#define MOZ_DEBUG_DDE 1
+#endif
+
+// Simple Win32 mutex wrapper.
+struct Win32Mutex {
+    Win32Mutex( const char16_t *name )
+        : mName( name ),
+          mHandle( 0 ),
+          mState( -1 ) {
+        mHandle = CreateMutexW( 0, FALSE, mName.get() );
+#if MOZ_DEBUG_DDE
+        printf( "CreateMutex error = 0x%08X\n", (int)GetLastError() );
+#endif
+    }
+    ~Win32Mutex() {
+        if ( mHandle ) {
+            // Make sure we release it if we own it.
+            Unlock();
+
+            BOOL rc = CloseHandle( mHandle );
+#if MOZ_DEBUG_DDE
+            if ( !rc ) {
+                printf( "CloseHandle error = 0x%08X\n", (int)GetLastError() );
+            }
+#endif
+        }
+    }
+    BOOL Lock( DWORD timeout ) {
+        if ( mHandle ) {
+#if MOZ_DEBUG_DDE
+            printf( "Waiting (%d msec) for DDE mutex...\n", (int)timeout );
+#endif
+            mState = WaitForSingleObject( mHandle, timeout );
+#if MOZ_DEBUG_DDE
+            printf( "...wait complete, result = 0x%08X, GetLastError=0x%08X\n", (int)mState, (int)::GetLastError() );
+#endif
+            return mState == WAIT_OBJECT_0 || mState == WAIT_ABANDONED;
+        } else {
+            return FALSE;
+        }
+    }
+    void Unlock() {
+        if ( mHandle && mState == WAIT_OBJECT_0 ) {
+#if MOZ_DEBUG_DDE
+            printf( "Releasing DDE mutex\n" );
+#endif
+            ReleaseMutex( mHandle );
+            mState = -1;
+        }
+    }
+private:
+    nsString  mName;
+    HANDLE    mHandle;
+    DWORD     mState;
+};
+
+/* DDE Notes
+ *
+ * This section describes the Win32 DDE service implementation for
+ * Mozilla.  DDE is used on Win32 platforms to communicate between
+ * separate instances of mozilla.exe (or other Mozilla-based
+ * executables), or, between the Win32 desktop shell and Mozilla.
+ *
+ * The first instance of Mozilla will become the "server" and
+ * subsequent executables (and the shell) will use DDE to send
+ * requests to that process.  The requests are DDE "execute" requests
+ * that pass the command line arguments.
+ *
+ * Mozilla registers the DDE application "Mozilla" and currently
+ * supports only the "WWW_OpenURL" topic.  This should be reasonably
+ * compatible with applications that interfaced with Netscape
+ * Communicator (and its predecessors?).  Note that even that topic
+ * may not be supported in a compatible fashion as the command-line
+ * options for Mozilla are different than for Communiator.
+ *
+ * It is imperative that at most one instance of Mozilla execute in
+ * "server mode" at any one time.  The "native app support" in Mozilla
+ * on Win32 ensures that only the server process performs XPCOM
+ * initialization (that is not required for subsequent client processes
+ * to communicate with the server process).
+ *
+ * To guarantee that only one server starts up, a Win32 "mutex" is used
+ * to ensure only one process executes the server-detection code.  That
+ * code consists of initializing DDE and doing a DdeConnect to Mozilla's
+ * application/topic.  If that connection succeeds, then a server process
+ * must be running already.
+ *
+ * Otherwise, no server has started.  In that case, the current process
+ * calls DdeNameService to register that application/topic.  Only at that
+ * point does the mutex get released.
+ *
+ * There are a couple of subtleties that one should be aware of:
+ *
+ * 1. It is imperative that DdeInitialize be called only after the mutex
+ *    lock has been obtained.  The reason is that at shutdown, DDE
+ *    notifications go out to all initialized DDE processes.  Thus, if
+ *    the mutex is owned by a terminating intance of Mozilla, then
+ *    calling DdeInitialize and then WaitForSingleObject will cause the
+ *    DdeUninitialize from the terminating process to "hang" until the
+ *    process waiting for the mutex times out (and can then service the
+ *    notification that the DDE server is terminating).  So, don't mess
+ *    with the sequence of things in the startup/shutdown logic.
+ *
+ * 2. All mutex requests are made with a reasonably long timeout value and
+ *    are designed to "fail safe" (i.e., a timeout is treated as failure).
+ *
+ * 3. An attempt has been made to minimize the degree to which the main
+ *    Mozilla application logic needs to be aware of the DDE mechanisms
+ *    implemented herein.  As a result, this module surfaces a very
+ *    large-grained interface, consisting of simple start/stop methods.
+ *    As a consequence, details of certain scenarios can be "lost."
+ *    Particularly, incoming DDE requests can arrive after this module
+ *    initiates the DDE server, but before Mozilla is initialized to the
+ *    point where those requests can be serviced (e.g., open a browser
+ *    window to a particular URL).  Since the client process sends the
+ *    request early on, it may not be prepared to respond to that error.
+ *    Thus, such situations may fail silently.  The design goal is that
+ *    they fail harmlessly.  Refinements on this point will be made as
+ *    details emerge (and time permits).
+ */
+
+/* Update 2001 March
+ *
+ * A significant DDE bug in Windows is causing Mozilla to get wedged at
+ * startup.  This is detailed in Bugzill bug 53952
+ * (http://bugzilla.mozilla.org/show_bug.cgi?id=53952).
+ *
+ * To resolve this, we are using a new strategy:
+ *   o Use a "message window" to detect that Mozilla is already running and
+ *     to pass requests from a second instance back to the first;
+ *   o Run only as a "DDE server" (not as DDE client); this avoids the
+ *     problematic call to DDEConnect().
+ *
+ * We still use the mutex semaphore to protect the code that detects
+ * whether Mozilla is already running.
+ */
+
+/* Update 2007 January
+ *
+ * A change in behavior was implemented in July 2004 which made the
+ * application on launch to add and on quit to remove the ddexec registry key.
+ * See bug 246078.
+ * Windows Vista has changed the methods used to set an application as default
+ * and the new methods are incompatible with removing the ddeexec registry key.
+ * See bug 353089.
+ *
+ * OS DDE Sequence:
+ * 1. OS checks if the dde name is registered.
+ * 2. If it is registered the OS sends a DDE request with the WWW_OpenURL topic
+ *    and the params as specified in the default value of the ddeexec registry
+ *    key for the verb (e.g. open).
+ * 3. If it isn't registered the OS launches the executable defined in the
+ *    verb's (e.g. open) command registry key.
+ * 4. If the ifexec registry key is not present the OS sends a DDE request with
+ *    the WWW_OpenURL topic and the params as specified in the default value of
+ *    the ddeexec registry key for the verb (e.g. open).
+ * 5. If the ifexec registry key is present the OS sends a DDE request with the
+ *    WWW_OpenURL topic and the params as specified in the ifexec registry key
+ *    for the verb (e.g. open).
+ *
+ * Application DDE Sequence:
+ * 1. If the application is running a DDE request is received with the
+ *    WWW_OpenURL topic and the params as specified in the default value of the
+ *    ddeexec registry key (e.g. "%1",,0,0,,,, where '%1' is the url to open)
+ *    for the verb (e.g. open).
+ * 2. If the application is not running it is launched with the --requestPending
+ *    and the --url argument.
+ * 2.1  If the application does not need to restart and the --requestPending
+ *      argument is present the accompanying url will not be used. Instead the
+ *      application will wait for the DDE message to open the url.
+ * 2.2  If the application needs to restart the --requestPending argument is
+ *      removed from the arguments used to restart the application and the url
+ *      will be handled normally.
+ *
+ * Note: Due to a bug in IE the ifexec key should not be used (see bug 355650).
+ */
+
+class nsNativeAppSupportWin : public nsNativeAppSupportBase,
+                              public nsIObserver
+{
+public:
+    NS_DECL_NSIOBSERVER
+    NS_DECL_ISUPPORTS_INHERITED
+
+    // Overrides of base implementation.
+    NS_IMETHOD Start( bool *aResult );
+    NS_IMETHOD Stop( bool *aResult );
+    NS_IMETHOD Quit();
+    NS_IMETHOD Enable();
+    // The "old" Start method (renamed).
+    NS_IMETHOD StartDDE();
+    // Utility function to handle a Win32-specific command line
+    // option: "--console", which dynamically creates a Windows
+    // console.
+    void CheckConsole();
+
+private:
+    ~nsNativeAppSupportWin() {}
+    static void HandleCommandLine(const char* aCmdLineString, nsIFile* aWorkingDir, uint32_t aState);
+    static HDDEDATA CALLBACK HandleDDENotification( UINT     uType,
+                                                    UINT     uFmt,
+                                                    HCONV    hconv,
+                                                    HSZ      hsz1,
+                                                    HSZ      hsz2,
+                                                    HDDEDATA hdata,
+                                                    ULONG_PTR dwData1,
+                                                    ULONG_PTR dwData2 );
+    static void ParseDDEArg( HSZ args, int index, nsString& string);
+    static void ParseDDEArg( const WCHAR* args, int index, nsString& aString);
+    static HDDEDATA CreateDDEData( DWORD value );
+    static HDDEDATA CreateDDEData( LPBYTE value, DWORD len );
+    static bool     InitTopicStrings();
+    static int      FindTopic( HSZ topic );
+    static void ActivateLastWindow();
+    static nsresult OpenWindow( const char *urlstr, const char *args );
+    static nsresult OpenBrowserWindow();
+    static void     SetupSysTrayIcon();
+    static void     RemoveSysTrayIcon();
+
+    static int   mConversations;
+    enum {
+        topicOpenURL,
+        topicActivate,
+        topicCancelProgress,
+        topicVersion,
+        topicRegisterViewer,
+        topicUnRegisterViewer,
+        topicGetWindowInfo,
+        // Note: Insert new values above this line!!!!!
+        topicCount // Count of the number of real topics
+    };
+    static HSZ   mApplication, mTopics[ topicCount ];
+    static DWORD mInstance;
+    static bool mCanHandleRequests;
+    static char16_t mMutexName[];
+    friend struct MessageWindow;
+}; // nsNativeAppSupportWin
+
+NS_INTERFACE_MAP_BEGIN(nsNativeAppSupportWin)
+    NS_INTERFACE_MAP_ENTRY(nsIObserver)
+NS_INTERFACE_MAP_END_INHERITING(nsNativeAppSupportBase)
+
+NS_IMPL_ADDREF_INHERITED(nsNativeAppSupportWin, nsNativeAppSupportBase)
+NS_IMPL_RELEASE_INHERITED(nsNativeAppSupportWin, nsNativeAppSupportBase)
+
+void
+UseParentConsole()
+{
+    // Try to attach console to the parent process.
+    // It will succeed when the parent process is a command line,
+    // so that stdio will be displayed in it.
+    if (AttachConsole(ATTACH_PARENT_PROCESS)) {
+        // Change std handles to refer to new console handles.
+        // Before doing so, ensure that stdout/stderr haven't been
+        // redirected to a valid file.
+        // The return value for _fileno(<a std handle>) for GUI apps was changed over.
+        // Until VC7, it was -1. Starting from VC8, it was changed to -2.
+        // http://msdn.microsoft.com/en-us/library/zs6wbdhx%28v=vs.80%29.aspx
+        // Starting from VC11, the return value was cahnged to 0 for stdin,
+        // 1 for stdout, 2 for stdout. Accroding to Microsoft, this is a bug
+        // which will be fixed in VC14.
+        // https://connect.microsoft.com/VisualStudio/feedback/details/785119/
+        // Although the document does not make it explicit, it looks like
+        // the return value from _get_osfhandle(_fileno(<a std handle>)) also
+        // changed to -2 and VC11 and 12 do not have a bug about _get_osfhandle().
+        // We support VC10 or later, so it's sufficient to compare the return
+        // value with -2.
+        if (_fileno(stdout) == -2 ||
+            _get_osfhandle(fileno(stdout)) == -2)
+            freopen("CONOUT$", "w", stdout);
+        // Merge stderr into CONOUT$ since there isn't any `CONERR$`.
+        // http://msdn.microsoft.com/en-us/library/windows/desktop/ms683231%28v=vs.85%29.aspx
+        if (_fileno(stderr) == -2 ||
+            _get_osfhandle(fileno(stderr)) == -2)
+            freopen("CONOUT$", "w", stderr);
+        if (_fileno(stdin) == -2 || _get_osfhandle(fileno(stdin)) == -2)
+            freopen("CONIN$", "r", stdin);
+    }
+}
+
+void
+nsNativeAppSupportWin::CheckConsole() {
+    for ( int i = 1; i < gArgc; i++ ) {
+        if ( strcmp( "-console", gArgv[i] ) == 0 ||
+             strcmp( "--console", gArgv[i] ) == 0 ||
+             strcmp( "/console", gArgv[i] ) == 0 ) {
+            // Users wants to make sure we have a console.
+            // Try to allocate one.
+            BOOL rc = ::AllocConsole();
+            if ( rc ) {
+                // Console allocated.  Fix it up so that output works in
+                // all cases.  See http://support.microsoft.com/support/kb/articles/q105/3/05.asp.
+
+                // stdout
+                int hCrt = ::_open_osfhandle( (intptr_t)GetStdHandle( STD_OUTPUT_HANDLE ),
+                                            _O_TEXT );
+                if ( hCrt != -1 ) {
+                    FILE *hf = ::_fdopen( hCrt, "w" );
+                    if ( hf ) {
+                        *stdout = *hf;
+#ifdef DEBUG
+                        ::fprintf( stdout, "stdout directed to dynamic console\n" );
+#endif
+                    }
+                }
+
+                // stderr
+                hCrt = ::_open_osfhandle( (intptr_t)::GetStdHandle( STD_ERROR_HANDLE ),
+                                          _O_TEXT );
+                if ( hCrt != -1 ) {
+                    FILE *hf = ::_fdopen( hCrt, "w" );
+                    if ( hf ) {
+                        *stderr = *hf;
+#ifdef DEBUG
+                        ::fprintf( stderr, "stderr directed to dynamic console\n" );
+#endif
+                    }
+                }
+
+                // stdin?
+                /* Don't bother for now.
+                hCrt = ::_open_osfhandle( (long)::GetStdHandle( STD_INPUT_HANDLE ),
+                                          _O_TEXT );
+                if ( hCrt != -1 ) {
+                    FILE *hf = ::_fdopen( hCrt, "r" );
+                    if ( hf ) {
+                        *stdin = *hf;
+                    }
+                }
+                */
+            } else {
+                // Failed.  Probably because there already is one.
+                // There's little we can do, in any case.
+            }
+            // Remove the console argument from the command line.
+            do {
+                gArgv[i] = gArgv[i + 1];
+                ++i;
+            } while (gArgv[i]);
+
+            --gArgc;
+
+        } else if ( strcmp( "-attach-console", gArgv[i] ) == 0
+                    ||
+                    strcmp( "/attach-console", gArgv[i] ) == 0 ) {
+            UseParentConsole();
+        }
+    }
+
+    return;
+}
+
+
+// Create and return an instance of class nsNativeAppSupportWin.
+nsresult
+NS_CreateNativeAppSupport( nsINativeAppSupport **aResult ) {
+    nsNativeAppSupportWin *pNative = new nsNativeAppSupportWin;
+    if (!pNative) return NS_ERROR_OUT_OF_MEMORY;
+
+    // Check for dynamic console creation request.
+    pNative->CheckConsole();
+
+    *aResult = pNative;
+    NS_ADDREF( *aResult );
+
+    return NS_OK;
+}
+
+// Constants
+#define MOZ_DDE_APPLICATION    "Mozilla"
+#define MOZ_MUTEX_NAMESPACE    L"Local\\"
+#define MOZ_STARTUP_MUTEX_NAME L"StartupMutex"
+#define MOZ_DDE_START_TIMEOUT 30000
+#define MOZ_DDE_STOP_TIMEOUT  15000
+#define MOZ_DDE_EXEC_TIMEOUT  15000
+
+// The array entries must match the enum ordering!
+const char * const topicNames[] = { "WWW_OpenURL",
+                                    "WWW_Activate",
+                                    "WWW_CancelProgress",
+                                    "WWW_Version",
+                                    "WWW_RegisterViewer",
+                                    "WWW_UnRegisterViewer",
+                                    "WWW_GetWindowInfo" };
+
+// Static member definitions.
+int   nsNativeAppSupportWin::mConversations = 0;
+HSZ   nsNativeAppSupportWin::mApplication   = 0;
+HSZ   nsNativeAppSupportWin::mTopics[nsNativeAppSupportWin::topicCount] = { 0 };
+DWORD nsNativeAppSupportWin::mInstance      = 0;
+bool nsNativeAppSupportWin::mCanHandleRequests   = false;
+
+char16_t nsNativeAppSupportWin::mMutexName[ 128 ] = { 0 };
+
+
+// Message window encapsulation.
+struct MessageWindow {
+    // ctor/dtor are simplistic
+    MessageWindow() {
+        // Try to find window.
+        mHandle = ::FindWindowW( className(), 0 );
+    }
+
+    // Act like an HWND.
+    operator HWND() {
+        return mHandle;
+    }
+
+    // Class name: appName + "MessageWindow"
+    static const wchar_t *className() {
+        static wchar_t classNameBuffer[128];
+        static wchar_t *mClassName = 0;
+        if ( !mClassName ) {
+            ::_snwprintf(classNameBuffer,
+                         128,   // size of classNameBuffer in PRUnichars
+                         L"%s%s",
+                         static_cast<const wchar_t*>(NS_ConvertUTF8toUTF16(gAppData->remotingName).get()),
+                         L"MessageWindow" );
+            mClassName = classNameBuffer;
+        }
+        return mClassName;
+    }
+
+    // Create: Register class and create window.
+    NS_IMETHOD Create() {
+        WNDCLASSW classStruct = { 0,                          // style
+                                 &MessageWindow::WindowProc, // lpfnWndProc
+                                 0,                          // cbClsExtra
+                                 0,                          // cbWndExtra
+                                 0,                          // hInstance
+                                 0,                          // hIcon
+                                 0,                          // hCursor
+                                 0,                          // hbrBackground
+                                 0,                          // lpszMenuName
+                                 className() };              // lpszClassName
+
+        // Register the window class.
+        NS_ENSURE_TRUE( ::RegisterClassW( &classStruct ), NS_ERROR_FAILURE );
+
+        // Create the window.
+        NS_ENSURE_TRUE( ( mHandle = ::CreateWindowW(className(),
+                                                    0,          // title
+                                                    WS_CAPTION, // style
+                                                    0,0,0,0,    // x, y, cx, cy
+                                                    0,          // parent
+                                                    0,          // menu
+                                                    0,          // instance
+                                                    0 ) ),      // create struct
+                        NS_ERROR_FAILURE );
+
+#if MOZ_DEBUG_DDE
+        printf( "Message window = 0x%08X\n", (int)mHandle );
+#endif
+
+        return NS_OK;
+    }
+
+    // Destory:  Get rid of window and reset mHandle.
+    NS_IMETHOD Destroy() {
+        nsresult retval = NS_OK;
+
+        if ( mHandle ) {
+            // DestroyWindow can only destroy windows created from
+            //  the same thread.
+            BOOL desRes = DestroyWindow( mHandle );
+            if ( FALSE != desRes ) {
+                mHandle = nullptr;
+            }
+            else {
+                retval = NS_ERROR_FAILURE;
+            }
+        }
+
+        return retval;
+    }
+
+    // SendRequest: Pass the command line via WM_COPYDATA to message window.
+    NS_IMETHOD SendRequest() {
+        WCHAR *cmd = ::GetCommandLineW();
+        WCHAR cwd[MAX_PATH];
+        _wgetcwd(cwd, MAX_PATH);
+
+        // Construct a narrow UTF8 buffer <commandline>\0<workingdir>\0
+        NS_ConvertUTF16toUTF8 utf8buffer(cmd);
+        utf8buffer.Append('\0');
+        AppendUTF16toUTF8(cwd, utf8buffer);
+        utf8buffer.Append('\0');
+
+        // We used to set dwData to zero, when we didn't send the working dir.
+        // Now we're using it as a version number.
+        COPYDATASTRUCT cds = {
+            1,
+            utf8buffer.Length(),
+            (void*) utf8buffer.get()
+        };
+        // Bring the already running Mozilla process to the foreground.
+        // nsWindow will restore the window (if minimized) and raise it.
+        ::SetForegroundWindow( mHandle );
+        ::SendMessage( mHandle, WM_COPYDATA, 0, (LPARAM)&cds );
+        return NS_OK;
+    }
+
+    // Window proc.
+    static LRESULT CALLBACK WindowProc( HWND msgWindow, UINT msg, WPARAM wp, LPARAM lp ) {
+        if ( msg == WM_COPYDATA ) {
+            if (!nsNativeAppSupportWin::mCanHandleRequests)
+                return FALSE;
+
+            // This is an incoming request.
+            COPYDATASTRUCT *cds = (COPYDATASTRUCT*)lp;
+#if MOZ_DEBUG_DDE
+            printf( "Incoming request: %s\n", (const char*)cds->lpData );
+#endif
+            nsCOMPtr<nsIFile> workingDir;
+
+            if (1 >= cds->dwData) {
+                char* wdpath = (char*) cds->lpData;
+                // skip the command line, and get the working dir of the
+                // other process, which is after the first null char
+                while (*wdpath)
+                    ++wdpath;
+
+                ++wdpath;
+
+#ifdef MOZ_DEBUG_DDE
+                printf( "Working dir: %s\n", wdpath);
+#endif
+
+                NS_NewLocalFile(NS_ConvertUTF8toUTF16(wdpath),
+                                false,
+                                getter_AddRefs(workingDir));
+            }
+            (void)nsNativeAppSupportWin::HandleCommandLine((char*)cds->lpData, workingDir, nsICommandLine::STATE_REMOTE_AUTO);
+
+            // Get current window and return its window handle.
+            nsCOMPtr<mozIDOMWindowProxy> win;
+            GetMostRecentWindow( 0, getter_AddRefs( win ) );
+            return win ? (LRESULT)hwndForDOMWindow( win ) : 0;
+        }
+        return DefWindowProc( msgWindow, msg, wp, lp );
+    }
+
+private:
+    HWND mHandle;
+}; // struct MessageWindow
+
+/* Start: Tries to find the "message window" to determine if it
+ *        exists.  If so, then Mozilla is already running.  In that
+ *        case, we use the handle to the "message" window and send
+ *        a request corresponding to this process's command line
+ *        options.
+ *
+ *        If not, then this is the first instance of Mozilla.  In
+ *        that case, we create and set up the message window.
+ *
+ *        The checking for existence of the message window must
+ *        be protected by use of a mutex semaphore.
+ */
+NS_IMETHODIMP
+nsNativeAppSupportWin::Start( bool *aResult ) {
+    NS_ENSURE_ARG( aResult );
+    NS_ENSURE_TRUE( mInstance == 0, NS_ERROR_NOT_INITIALIZED );
+    NS_ENSURE_STATE( gAppData );
+
+    if (getenv("MOZ_NO_REMOTE"))
+    {
+        *aResult = true;
+        return NS_OK;
+    }
+
+    nsresult rv = NS_ERROR_FAILURE;
+    *aResult = false;
+
+    // Grab mutex first.
+
+    // Build mutex name from app name.
+    ::_snwprintf(reinterpret_cast<wchar_t*>(mMutexName),
+                 sizeof mMutexName / sizeof(char16_t), L"%s%s%s",
+                 MOZ_MUTEX_NAMESPACE,
+                 static_cast<const wchar_t*>(NS_ConvertUTF8toUTF16(gAppData->name).get()),
+                 MOZ_STARTUP_MUTEX_NAME );
+    Win32Mutex startupLock = Win32Mutex( mMutexName );
+
+    NS_ENSURE_TRUE( startupLock.Lock( MOZ_DDE_START_TIMEOUT ), NS_ERROR_FAILURE );
+
+    // Search for existing message window.
+    MessageWindow msgWindow;
+    if ( (HWND)msgWindow ) {
+        // We are a client process.  Pass request to message window.
+        rv = msgWindow.SendRequest();
+    } else {
+        // We will be server.
+        rv = msgWindow.Create();
+        if ( NS_SUCCEEDED( rv ) ) {
+            // Start up DDE server.
+            this->StartDDE();
+            // Tell caller to spin message loop.
+            *aResult = true;
+        }
+    }
+
+    startupLock.Unlock();
+
+    return rv;
+}
+
+bool
+nsNativeAppSupportWin::InitTopicStrings() {
+    for ( int i = 0; i < topicCount; i++ ) {
+        if ( !( mTopics[ i ] = DdeCreateStringHandleA( mInstance, const_cast<char *>(topicNames[ i ]), CP_WINANSI ) ) ) {
+            return false;
+        }
+    }
+    return true;
+}
+
+int
+nsNativeAppSupportWin::FindTopic( HSZ topic ) {
+    for ( int i = 0; i < topicCount; i++ ) {
+        if ( DdeCmpStringHandles( topic, mTopics[i] ) == 0 ) {
+            return i;
+        }
+    }
+    return -1;
+}
+
+
+// Start DDE server.
+//
+// This used to be the Start() method when we were using DDE as the
+// primary IPC mechanism between secondary Mozilla processes and the
+// initial "server" process.
+//
+// Now, it simply initializes the DDE server.  The caller must check
+// that this process is to be the server, and, must acquire the DDE
+// startup mutex semaphore prior to calling this routine.  See ::Start(),
+// above.
+NS_IMETHODIMP
+nsNativeAppSupportWin::StartDDE() {
+    NS_ENSURE_TRUE( mInstance == 0, NS_ERROR_NOT_INITIALIZED );
+
+    // Initialize DDE.
+    NS_ENSURE_TRUE( DMLERR_NO_ERROR == DdeInitialize( &mInstance,
+                                                      nsNativeAppSupportWin::HandleDDENotification,
+                                                      APPCLASS_STANDARD,
+                                                      0 ),
+                    NS_ERROR_FAILURE );
+
+    // Allocate DDE strings.
+    NS_ENSURE_TRUE( ( mApplication = DdeCreateStringHandleA( mInstance, (char*) gAppData->name, CP_WINANSI ) ) && InitTopicStrings(),
+                    NS_ERROR_FAILURE );
+
+    // Next step is to register a DDE service.
+    NS_ENSURE_TRUE( DdeNameService( mInstance, mApplication, 0, DNS_REGISTER ), NS_ERROR_FAILURE );
+
+#if MOZ_DEBUG_DDE
+    printf( "DDE server started\n" );
+#endif
+
+    return NS_OK;
+}
+
+// If no DDE conversations are pending, terminate DDE.
+NS_IMETHODIMP
+nsNativeAppSupportWin::Stop( bool *aResult ) {
+    NS_ENSURE_ARG( aResult );
+    NS_ENSURE_TRUE( mInstance, NS_ERROR_NOT_INITIALIZED );
+
+    nsresult rv = NS_OK;
+    *aResult = true;
+
+    Win32Mutex ddeLock( mMutexName );
+
+    if ( ddeLock.Lock( MOZ_DDE_STOP_TIMEOUT ) ) {
+        if ( mConversations == 0 ) {
+            this->Quit();
+        } else {
+            *aResult = false;
+        }
+
+        ddeLock.Unlock();
+    }
+    else {
+        // No DDE application name specified, but that's OK.  Just
+        // forge ahead.
+        *aResult = true;
+    }
+
+    return rv;
+}
+
+NS_IMETHODIMP
+nsNativeAppSupportWin::Observe(nsISupports* aSubject, const char* aTopic,
+                               const char16_t* aData)
+{
+    if (strcmp(aTopic, "quit-application") == 0) {
+        Quit();
+    } else {
+        NS_ERROR("Unexpected observer topic.");
+    }
+
+    return NS_OK;
+}
+
+// Terminate DDE regardless.
+NS_IMETHODIMP
+nsNativeAppSupportWin::Quit() {
+    // If another process wants to look for the message window, they need
+    // to wait to hold the lock, in which case they will not find the
+    // window as we will destroy ours under our lock.
+    // When the mutex goes off the stack, it is unlocked via destructor.
+    Win32Mutex mutexLock(mMutexName);
+    NS_ENSURE_TRUE(mutexLock.Lock(MOZ_DDE_START_TIMEOUT), NS_ERROR_FAILURE);
+
+    // If we've got a message window to receive IPC or new window requests,
+    // get rid of it as we are shutting down.
+    // Note:  Destroy calls DestroyWindow, which will only work on a window
+    //  created by the same thread.
+    MessageWindow mw;
+    mw.Destroy();
+
+    if ( mInstance ) {
+        // Unregister application name.
+        DdeNameService( mInstance, mApplication, 0, DNS_UNREGISTER );
+        // Clean up strings.
+        if ( mApplication ) {
+            DdeFreeStringHandle( mInstance, mApplication );
+            mApplication = 0;
+        }
+        for ( int i = 0; i < topicCount; i++ ) {
+            if ( mTopics[i] ) {
+                DdeFreeStringHandle( mInstance, mTopics[i] );
+                mTopics[i] = 0;
+            }
+        }
+        DdeUninitialize( mInstance );
+        mInstance = 0;
+#if MOZ_DEBUG_DDE
+    printf( "DDE server stopped\n" );
+#endif
+    }
+
+    return NS_OK;
+}
+
+NS_IMETHODIMP
+nsNativeAppSupportWin::Enable()
+{
+    mCanHandleRequests = true;
+
+    nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
+    if (obs) {
+        obs->AddObserver(this, "quit-application", false);
+    } else {
+        NS_ERROR("No observer service?");
+    }
+
+    return NS_OK;
+}
+
+#if MOZ_DEBUG_DDE
+// Macro to generate case statement for a given XTYP value.
+#define XTYP_CASE(t) \
+    case t: result = #t; break
+
+static nsCString uTypeDesc( UINT uType ) {
+    nsCString result;
+    switch ( uType ) {
+    XTYP_CASE(XTYP_ADVSTART);
+    XTYP_CASE(XTYP_CONNECT);
+    XTYP_CASE(XTYP_ADVREQ);
+    XTYP_CASE(XTYP_REQUEST);
+    XTYP_CASE(XTYP_WILDCONNECT);
+    XTYP_CASE(XTYP_ADVDATA);
+    XTYP_CASE(XTYP_EXECUTE);
+    XTYP_CASE(XTYP_POKE);
+    XTYP_CASE(XTYP_ADVSTOP);
+    XTYP_CASE(XTYP_CONNECT_CONFIRM);
+    XTYP_CASE(XTYP_DISCONNECT);
+    XTYP_CASE(XTYP_ERROR);
+    XTYP_CASE(XTYP_MONITOR);
+    XTYP_CASE(XTYP_REGISTER);
+    XTYP_CASE(XTYP_XACT_COMPLETE);
+    XTYP_CASE(XTYP_UNREGISTER);
+    default: result = "XTYP_?????";
+    }
+    return result;
+}
+
+static nsCString hszValue( DWORD instance, HSZ hsz ) {
+    // Extract string from HSZ.
+    nsCString result("[");
+    DWORD len = DdeQueryString( instance, hsz, nullptr, nullptr, CP_WINANSI );
+    if ( len ) {
+        char buffer[ 256 ];
+        DdeQueryString( instance, hsz, buffer, sizeof buffer, CP_WINANSI );
+        result += buffer;
+    }
+    result += "]";
+    return result;
+}
+#else
+// These are purely a safety measure to avoid the infamous "won't
+// build non-debug" type Tinderbox flames.
+static nsCString uTypeDesc( UINT ) {
+    return nsCString( "?" );
+}
+static nsCString hszValue( DWORD, HSZ ) {
+    return nsCString( "?" );
+}
+#endif
+
+
+// Utility function to escape double-quotes within a string.
+static void escapeQuotes( nsAString &aString ) {
+    int32_t offset = -1;
+    while( 1 ) {
+       // Find next '"'.
+       offset = aString.FindChar( '"', ++offset );
+       if ( offset == kNotFound ) {
+           // No more quotes, exit.
+           break;
+       } else {
+           // Insert back-slash ahead of the '"'.
+           aString.Insert( char16_t('\\'), offset );
+           // Increment offset because we just inserted a slash
+           offset++;
+       }
+    }
+    return;
+}
+
+HDDEDATA CALLBACK
+nsNativeAppSupportWin::HandleDDENotification( UINT uType,       // transaction type
+                                              UINT uFmt,        // clipboard data format
+                                              HCONV hconv,      // handle to the conversation
+                                              HSZ hsz1,         // handle to a string
+                                              HSZ hsz2,         // handle to a string
+                                              HDDEDATA hdata,   // handle to a global memory object
+                                              ULONG_PTR dwData1,    // transaction-specific data
+                                              ULONG_PTR dwData2 ) { // transaction-specific data
+
+    if (!mCanHandleRequests)
+        return 0;
+
+
+#if MOZ_DEBUG_DDE
+    printf( "DDE: uType  =%s\n",      uTypeDesc( uType ).get() );
+    printf( "     uFmt   =%u\n",      (unsigned)uFmt );
+    printf( "     hconv  =%08x\n",    (int)hconv );
+    printf( "     hsz1   =%08x:%s\n", (int)hsz1, hszValue( mInstance, hsz1 ).get() );
+    printf( "     hsz2   =%08x:%s\n", (int)hsz2, hszValue( mInstance, hsz2 ).get() );
+    printf( "     hdata  =%08x\n",    (int)hdata );
+    printf( "     dwData1=%08x\n",    (int)dwData1 );
+    printf( "     dwData2=%08x\n",    (int)dwData2 );
+#endif
+
+    HDDEDATA result = 0;
+    if ( uType & XCLASS_BOOL ) {
+        switch ( uType ) {
+            case XTYP_CONNECT:
+                // Make sure its for our service/topic.
+                if ( FindTopic( hsz1 ) != -1 ) {
+                    // We support this connection.
+                    result = (HDDEDATA)1;
+                }
+                break;
+            case XTYP_CONNECT_CONFIRM:
+                // We don't care about the conversation handle, at this point.
+                result = (HDDEDATA)1;
+                break;
+        }
+    } else if ( uType & XCLASS_DATA ) {
+        if ( uType == XTYP_REQUEST ) {
+            switch ( FindTopic( hsz1 ) ) {
+                case topicOpenURL: {
+                    // Open a given URL...
+
+                    // Get the URL from the first argument in the command.
+                    nsAutoString url;
+                    ParseDDEArg(hsz2, 0, url);
+
+                    // Read the 3rd argument in the command to determine if a
+                    // new window is to be used.
+                    nsAutoString windowID;
+                    ParseDDEArg(hsz2, 2, windowID);
+                    // "" means to open the URL in a new window.
+                    if ( windowID.IsEmpty() ) {
+                        url.Insert(NS_LITERAL_STRING("mozilla -new-window "), 0);
+                    }
+                    else {
+                        url.Insert(NS_LITERAL_STRING("mozilla -url "), 0);
+                    }
+
+#if MOZ_DEBUG_DDE
+                    printf( "Handling dde XTYP_REQUEST request: [%s]...\n", NS_ConvertUTF16toUTF8(url).get() );
+#endif
+                    // Now handle it.
+                    HandleCommandLine(NS_ConvertUTF16toUTF8(url).get(), nullptr, nsICommandLine::STATE_REMOTE_EXPLICIT);
+
+                    // Return pseudo window ID.
+                    result = CreateDDEData( 1 );
+                    break;
+                }
+                case topicGetWindowInfo: {
+                    // This topic has to get the current URL, get the current
+                    // page title and then format the output into the DDE
+                    // return string.  The return value is "URL","Page Title",
+                    // "Window ID" however the window ID is not used for this
+                    // command, therefore it is returned as a null string
+
+                    // This isn't really a loop.  We just use "break"
+                    // statements to bypass the remaining steps when
+                    // something goes wrong.
+                    do {
+                        // Get most recently used Nav window.
+                        nsCOMPtr<mozIDOMWindowProxy> navWin;
+                        GetMostRecentWindow( NS_LITERAL_STRING( "navigator:browser" ).get(),
+                                             getter_AddRefs( navWin ) );
+                        nsCOMPtr<nsPIDOMWindowOuter> piNavWin = do_QueryInterface(navWin);
+                        if ( !piNavWin ) {
+                            // There is not a window open
+                            break;
+                        }
+
+                        // Get content window.
+                        nsCOMPtr<nsPIDOMWindowOuter> internalContent = nsGlobalWindow::Cast(piNavWin)->GetContent();
+                        if ( !internalContent ) {
+                            break;
+                        }
+                        // Get location.
+                        nsCOMPtr<nsIDOMLocation> location = internalContent->GetLocation();
+                        if ( !location ) {
+                            break;
+                        }
+                        // Get href for URL.
+                        nsAutoString url;
+                        if ( NS_FAILED( location->GetHref( url ) ) ) {
+                            break;
+                        }
+                        // Escape any double-quotes.
+                        escapeQuotes( url );
+
+                        // Now for the title...
+
+                        // Get the base window from the doc shell...
+                        nsCOMPtr<nsIBaseWindow> baseWindow =
+                          do_QueryInterface( internalContent->GetDocShell() );
+                        if ( !baseWindow ) {
+                            break;
+                        }
+                        // And from the base window we can get the title.
+                        nsXPIDLString title;
+                        if(!baseWindow) {
+                            break;
+                        }
+                        baseWindow->GetTitle(getter_Copies(title));
+                        // Escape any double-quotes in the title.
+                        escapeQuotes( title );
+
+                        // Use a string buffer for the output data, first
+                        // save a quote.
+                        nsAutoCString   outpt( NS_LITERAL_CSTRING("\"") );
+                        // Now copy the URL converting the Unicode string
+                        // to a single-byte ASCII string
+                        nsAutoCString tmpNativeStr;
+                        NS_CopyUnicodeToNative( url, tmpNativeStr );
+                        outpt.Append( tmpNativeStr );
+                        // Add the "," used to separate the URL and the page
+                        // title
+                        outpt.Append( NS_LITERAL_CSTRING("\",\"") );
+                        // Now copy the current page title to the return string
+                        NS_CopyUnicodeToNative( title, tmpNativeStr );
+                        outpt.Append( tmpNativeStr );
+                        // Fill out the return string with the remainin ",""
+                        outpt.Append( NS_LITERAL_CSTRING( "\",\"\"" ));
+
+                        // Create a DDE handle to a char string for the data
+                        // being returned, this copies and creates a "shared"
+                        // copy of the DDE response until the calling APP
+                        // reads it and says it can be freed.
+                        result = CreateDDEData( (LPBYTE)(const char*)outpt.get(),
+                                                outpt.Length() + 1 );
+#if MOZ_DEBUG_DDE
+                        printf( "WWW_GetWindowInfo->%s\n", outpt.get() );
+#endif
+                    } while ( false );
+                    break;
+                }
+                case topicActivate: {
+                    // Activate a Nav window...
+                    nsAutoString windowID;
+                    ParseDDEArg(hsz2, 0, windowID);
+                    // 4294967295 is decimal for 0xFFFFFFFF which is also a
+                    //   correct value to do that Activate last window stuff
+                    if ( windowID.EqualsLiteral( "-1" ) ||
+                         windowID.EqualsLiteral( "4294967295" ) ) {
+                        // We only support activating the most recent window (or a new one).
+                        ActivateLastWindow();
+                        // Return pseudo window ID.
+                        result = CreateDDEData( 1 );
+                    }
+                    break;
+                }
+                case topicVersion: {
+                    // Return version.  We're restarting at 1.0!
+                    DWORD version = 1 << 16; // "1.0"
+                    result = CreateDDEData( version );
+                    break;
+                }
+                case topicRegisterViewer: {
+                    // Register new viewer (not implemented).
+                    result = CreateDDEData( false );
+                    break;
+                }
+                case topicUnRegisterViewer: {
+                    // Unregister new viewer (not implemented).
+                    result = CreateDDEData( false );
+                    break;
+                }
+                default:
+                    break;
+            }
+        } else if ( uType & XTYP_POKE ) {
+            switch ( FindTopic( hsz1 ) ) {
+                case topicCancelProgress: {
+                    // "Handle" progress cancel (actually, pretty much ignored).
+                    result = (HDDEDATA)DDE_FACK;
+                    break;
+                }
+                default:
+                    break;
+            }
+        }
+    } else if ( uType & XCLASS_FLAGS ) {
+        if ( uType == XTYP_EXECUTE ) {
+            // Prove that we received the request.
+            DWORD bytes;
+            LPBYTE request = DdeAccessData( hdata, &bytes );
+#if MOZ_DEBUG_DDE
+            printf( "Handling dde request: [%s]...\n", (char*)request );
+#endif
+
+            nsAutoString url;
+            ParseDDEArg((const WCHAR*) request, 0, url);
+
+            // Read the 3rd argument in the command to determine if a
+            // new window is to be used.
+            nsAutoString windowID;
+            ParseDDEArg((const WCHAR*) request, 2, windowID);
+
+            // "" means to open the URL in a new window.
+            if ( windowID.IsEmpty() ) {
+                url.Insert(NS_LITERAL_STRING("mozilla -new-window "), 0);
+            }
+            else {
+                url.Insert(NS_LITERAL_STRING("mozilla -url "), 0);
+            }
+#if MOZ_DEBUG_DDE
+            printf( "Handling dde XTYP_REQUEST request: [%s]...\n", NS_ConvertUTF16toUTF8(url).get() );
+#endif
+            // Now handle it.
+            HandleCommandLine(NS_ConvertUTF16toUTF8(url).get(), nullptr, nsICommandLine::STATE_REMOTE_EXPLICIT);
+
+            // Release the data.
+            DdeUnaccessData( hdata );
+            result = (HDDEDATA)DDE_FACK;
+        } else {
+            result = (HDDEDATA)DDE_FNOTPROCESSED;
+        }
+    } else if ( uType & XCLASS_NOTIFICATION ) {
+    }
+#if MOZ_DEBUG_DDE
+    printf( "DDE result=%d (0x%08X)\n", (int)result, (int)result );
+#endif
+    return result;
+}
+
+// Utility function to advance to end of quoted string.
+// p+offset must point to the comma preceding the arg on entry.
+// On return, p+result points to the closing '"' (or end of the string
+// if the closing '"' is missing) if the arg is quoted.  If the arg
+// is not quoted, then p+result will point to the first character
+// of the arg.
+static int32_t advanceToEndOfQuotedArg( const WCHAR *p, int32_t offset, int32_t len ) {
+    // Check whether the current arg is quoted.
+    if ( p[++offset] == '"' ) {
+        // Advance past the closing quote.
+        while ( offset < len && p[++offset] != '"' ) {
+            // If the current character is a backslash, then the
+            // next character can't be a *real* '"', so skip it.
+            if ( p[offset] == '\\' ) {
+                offset++;
+            }
+        }
+    }
+    return offset;
+}
+
+void nsNativeAppSupportWin::ParseDDEArg( const WCHAR* args, int index, nsString& aString) {
+    if ( args ) {
+        nsDependentString temp(args);
+
+        // offset points to the comma preceding the desired arg.
+        int32_t offset = -1;
+        // Skip commas till we get to the arg we want.
+        while( index-- ) {
+            // If this arg is quoted, then go to closing quote.
+            offset = advanceToEndOfQuotedArg( args, offset, temp.Length());
+            // Find next comma.
+            offset = temp.FindChar( ',', offset );
+            if ( offset == kNotFound ) {
+                // No more commas, give up.
+                aString = args;
+                return;
+            }
+        }
+        // The desired argument starts just past the preceding comma,
+        // which offset points to, and extends until the following
+        // comma (or the end of the string).
+        //
+        // Since the argument might be enclosed in quotes, we need to
+        // deal with that before searching for the terminating comma.
+        // We advance offset so it ends up pointing to the start of
+        // the argument we want.
+        int32_t end = advanceToEndOfQuotedArg( args, offset++, temp.Length() );
+        // Find next comma (or end of string).
+        end = temp.FindChar( ',', end );
+        if ( end == kNotFound ) {
+            // Arg is the rest of the string.
+            end = temp.Length();
+        }
+        // Extract result.
+        aString.Assign( args + offset, end - offset );
+    }
+    return;
+}
+
+// Utility to parse out argument from a DDE item string.
+void nsNativeAppSupportWin::ParseDDEArg( HSZ args, int index, nsString& aString) {
+    DWORD argLen = DdeQueryStringW( mInstance, args, nullptr, 0, CP_WINUNICODE );
+    // there wasn't any string, so return empty string
+    if ( !argLen ) return;
+    nsAutoString temp;
+    // Ensure result's buffer is sufficiently big.
+    temp.SetLength( argLen );
+    // Now get the string contents.
+    DdeQueryString( mInstance, args, reinterpret_cast<wchar_t*>(temp.BeginWriting()), temp.Length(), CP_WINUNICODE );
+    // Parse out the given arg.
+    ParseDDEArg(temp.get(), index, aString);
+    return;
+}
+
+HDDEDATA nsNativeAppSupportWin::CreateDDEData( DWORD value ) {
+    return CreateDDEData( (LPBYTE)&value, sizeof value );
+}
+
+HDDEDATA nsNativeAppSupportWin::CreateDDEData( LPBYTE value, DWORD len ) {
+    HDDEDATA result = DdeCreateDataHandle( mInstance,
+                                           value,
+                                           len,
+                                           0,
+                                           mApplication,
+                                           CF_TEXT,
+                                           0 );
+    return result;
+}
+
+void nsNativeAppSupportWin::ActivateLastWindow() {
+    nsCOMPtr<mozIDOMWindowProxy> navWin;
+    GetMostRecentWindow( u"navigator:browser", getter_AddRefs( navWin ) );
+    if ( navWin ) {
+        // Activate that window.
+        activateWindow( navWin );
+    } else {
+        // Need to create a Navigator window, then.
+        OpenBrowserWindow();
+    }
+}
+
+void
+nsNativeAppSupportWin::HandleCommandLine(const char* aCmdLineString,
+                                         nsIFile* aWorkingDir,
+                                         uint32_t aState)
+{
+    nsresult rv;
+
+    int justCounting = 1;
+    char **argv = 0;
+    // Flags, etc.
+    int init = 1;
+    int between, quoted, bSlashCount;
+    int argc;
+    const char *p;
+    nsAutoCString arg;
+
+    nsCOMPtr<nsICommandLineRunner> cmdLine
+        (do_CreateInstance("@mozilla.org/toolkit/command-line;1"));
+    if (!cmdLine) {
+        NS_ERROR("Couldn't create command line!");
+        return;
+    }
+
+    // Parse command line args according to MS spec
+    // (see "Parsing C++ Command-Line Arguments" at
+    // http://msdn.microsoft.com/library/devprods/vs6/visualc/vclang/_pluslang_parsing_c.2b2b_.command.2d.line_arguments.htm).
+    // We loop if we've not finished the second pass through.
+    while ( 1 ) {
+        // Initialize if required.
+        if ( init ) {
+            p = aCmdLineString;
+            between = 1;
+            argc = quoted = bSlashCount = 0;
+
+            init = 0;
+        }
+        if ( between ) {
+            // We are traversing whitespace between args.
+            // Check for start of next arg.
+            if (  *p != 0 && !isspace( *p ) ) {
+                // Start of another arg.
+                between = 0;
+                arg = "";
+                switch ( *p ) {
+                    case '\\':
+                        // Count the backslash.
+                        bSlashCount = 1;
+                        break;
+                    case '"':
+                        // Remember we're inside quotes.
+                        quoted = 1;
+                        break;
+                    default:
+                        // Add character to arg.
+                        arg += *p;
+                        break;
+                }
+            } else {
+                // Another space between args, ignore it.
+            }
+        } else {
+            // We are processing the contents of an argument.
+            // Check for whitespace or end.
+            if ( *p == 0 || ( !quoted && isspace( *p ) ) ) {
+                // Process pending backslashes (interpret them
+                // literally since they're not followed by a ").
+                while( bSlashCount ) {
+                    arg += '\\';
+                    bSlashCount--;
+                }
+                // End current arg.
+                if ( !justCounting ) {
+                    argv[argc] = new char[ arg.Length() + 1 ];
+                    strcpy( argv[argc], arg.get() );
+                }
+                argc++;
+                // We're now between args.
+                between = 1;
+            } else {
+                // Still inside argument, process the character.
+                switch ( *p ) {
+                    case '"':
+                        // First, digest preceding backslashes (if any).
+                        while ( bSlashCount > 1 ) {
+                            // Put one backsplash in arg for each pair.
+                            arg += '\\';
+                            bSlashCount -= 2;
+                        }
+                        if ( bSlashCount ) {
+                            // Quote is literal.
+                            arg += '"';
+                            bSlashCount = 0;
+                        } else {
+                            // Quote starts or ends a quoted section.
+                            if ( quoted ) {
+                                // Check for special case of consecutive double
+                                // quotes inside a quoted section.
+                                if ( *(p+1) == '"' ) {
+                                    // This implies a literal double-quote.  Fake that
+                                    // out by causing next double-quote to look as
+                                    // if it was preceded by a backslash.
+                                    bSlashCount = 1;
+                                } else {
+                                    quoted = 0;
+                                }
+                            } else {
+                                quoted = 1;
+                            }
+                        }
+                        break;
+                    case '\\':
+                        // Add to count.
+                        bSlashCount++;
+                        break;
+                    default:
+                        // Accept any preceding backslashes literally.
+                        while ( bSlashCount ) {
+                            arg += '\\';
+                            bSlashCount--;
+                        }
+                        // Just add next char to the current arg.
+                        arg += *p;
+                        break;
+                }
+            }
+        }
+        // Check for end of input.
+        if ( *p ) {
+            // Go to next character.
+            p++;
+        } else {
+            // If on first pass, go on to second.
+            if ( justCounting ) {
+                // Allocate argv array.
+                argv = new char*[ argc ];
+
+                // Start second pass
+                justCounting = 0;
+                init = 1;
+            } else {
+                // Quit.
+                break;
+            }
+        }
+    }
+
+    rv = cmdLine->Init(argc, argv, aWorkingDir, aState);
+
+    // Cleanup.
+    while ( argc ) {
+        delete [] argv[ --argc ];
+    }
+    delete [] argv;
+
+    if (NS_FAILED(rv)) {
+        NS_ERROR("Error initializing command line.");
+        return;
+    }
+
+    cmdLine->Run();
+}
+
+nsresult
+nsNativeAppSupportWin::OpenWindow( const char*urlstr, const char *args ) {
+
+  nsresult rv = NS_ERROR_FAILURE;
+
+  nsCOMPtr<nsIWindowWatcher> wwatch(do_GetService(NS_WINDOWWATCHER_CONTRACTID));
+  nsCOMPtr<nsISupportsCString> sarg(do_CreateInstance(NS_SUPPORTS_CSTRING_CONTRACTID));
+  if (sarg)
+    sarg->SetData(nsDependentCString(args));
+
+  if (wwatch && sarg) {
+    nsCOMPtr<mozIDOMWindowProxy> newWindow;
+    rv = wwatch->OpenWindow(0, urlstr, "_blank", "chrome,dialog=no,all",
+                   sarg, getter_AddRefs(newWindow));
+#if MOZ_DEBUG_DDE
+  } else {
+      printf("Get WindowWatcher (or create string) failed\n");
+#endif
+  }
+  return rv;
+}
+
+HWND hwndForDOMWindow(mozIDOMWindowProxy *window ) {
+    if ( !window ) {
+        return 0;
+    }
+    nsCOMPtr<nsPIDOMWindowOuter > pidomwindow = nsPIDOMWindowOuter::From(window);
+
+    nsCOMPtr<nsIBaseWindow> ppBaseWindow =
+        do_QueryInterface( pidomwindow->GetDocShell() );
+    if ( !ppBaseWindow ) {
+        return 0;
+    }
+
+    nsCOMPtr<nsIWidget> ppWidget;
+    ppBaseWindow->GetMainWidget( getter_AddRefs( ppWidget ) );
+
+    return (HWND)( ppWidget->GetNativeData( NS_NATIVE_WIDGET ) );
+}
+
+nsresult
+nsNativeAppSupportWin::OpenBrowserWindow()
+{
+    nsresult rv = NS_OK;
+
+    // Open the argument URL in the most recently used Navigator window.
+    // If there is no Nav window, open a new one.
+
+    // If at all possible, hand the request off to the most recent
+    // browser window.
+
+    nsCOMPtr<mozIDOMWindowProxy> navWin;
+    GetMostRecentWindow( NS_LITERAL_STRING( "navigator:browser" ).get(), getter_AddRefs( navWin ) );
+
+    // This isn't really a loop.  We just use "break" statements to fall
+    // out to the OpenWindow call when things go awry.
+    do {
+        // If caller requires a new window, then don't use an existing one.
+        if ( !navWin ) {
+            // Have to open a new one.
+            break;
+        }
+
+        nsCOMPtr<nsIBrowserDOMWindow> bwin;
+        { // scope a bunch of temporary cruft used to generate bwin
+          nsCOMPtr<nsIWebNavigation> navNav( do_GetInterface( navWin ) );
+          nsCOMPtr<nsIDocShellTreeItem> navItem( do_QueryInterface( navNav ) );
+          if ( navItem ) {
+            nsCOMPtr<nsIDocShellTreeItem> rootItem;
+            navItem->GetRootTreeItem( getter_AddRefs( rootItem ) );
+            nsCOMPtr<nsPIDOMWindowOuter> rootWin =
+              rootItem ? rootItem->GetWindow() : nullptr;
+            nsCOMPtr<nsIDOMChromeWindow> chromeWin(do_QueryInterface(rootWin));
+            if ( chromeWin )
+              chromeWin->GetBrowserDOMWindow( getter_AddRefs ( bwin ) );
+          }
+        }
+        if ( bwin ) {
+          nsCOMPtr<nsIURI> uri;
+          NS_NewURI( getter_AddRefs( uri ), NS_LITERAL_CSTRING("about:blank"), 0, 0 );
+          if ( uri ) {
+            nsCOMPtr<mozIDOMWindowProxy> container;
+            rv = bwin->OpenURI( uri, 0,
+                                nsIBrowserDOMWindow::OPEN_DEFAULTWINDOW,
+                                nsIBrowserDOMWindow::OPEN_EXTERNAL,
+                                getter_AddRefs( container ) );
+            if ( NS_SUCCEEDED( rv ) )
+              return NS_OK;
+          }
+        }
+
+        NS_ERROR("failed to hand off external URL to extant window");
+    } while ( false );
+
+    // open a new window if caller requested it or if anything above failed
+
+    char* argv[] = { 0 };
+    nsCOMPtr<nsICommandLineRunner> cmdLine
+        (do_CreateInstance("@mozilla.org/toolkit/command-line;1"));
+    NS_ENSURE_TRUE(cmdLine, NS_ERROR_FAILURE);
+
+    rv = cmdLine->Init(0, argv, nullptr, nsICommandLine::STATE_REMOTE_EXPLICIT);
+    NS_ENSURE_SUCCESS(rv, rv);
+
+    return cmdLine->Run();
+}
+