nsFxrCommandLineHandler.cpp

Enable keyboard shortcuts

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

// vim:cindent:tabstop=4:expandtab:shiftwidth=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/. */

#ifndef XP_WIN

#  error "nsFxrCommandLineHandler currently only supported on Windows"

#endif

#include "nsFxrCommandLineHandler.h"

#include "FxRWindowManager.h"

#include "nsICommandLine.h"

#include "nsIWindowWatcher.h"

#include "mozIDOMWindow.h"

#include "nsPIDOMWindow.h"

#include "mozilla/WidgetUtils.h"

#include "nsIWidget.h"

#include "nsServiceManagerUtils.h"

#include "nsString.h"

#include "nsArray.h"

#include "nsCOMPtr.h"

#include "mozilla/StaticPrefs_extensions.h"

#include <windows.h>

#include "WinUtils.h"

#include "VRShMem.h"

NS_IMPL_ISUPPORTS(nsFxrCommandLineHandler, nsICommandLineHandler)

// nsFxrCommandLineHandler acts in the middle of bootstrapping Firefox

// Reality with desktop Firefox. Details of the processes involved are

// described below:

//

//      Host

// (vrhost!CreateVRWindow)      Fx Main                 Fx GPU

//       |                         +                       +

//  VRShMem creates shared         +                       +

//  memory in OS                   +                       +

//       |                         +                       +

//  Launch firefox.exe             +                       +

//  with --fxr                     +                       +

//       |                         |                       +

//  Wait for Signal...       nsFxrCLH handles param        +

//       |                   joins VRShMem                 +

//       |                   creates new window            |

//       |                   sets .hwndFx in VRShMem       |

//       |                         |                       |

//       |                         |                  After compositor and

//       |                         |                  swapchain created,

//       |                         |                  share texture handle to

//       |                         |                  VRShMem and set signal

//  CreateVRWindow returns         |                       |

//  to host with relevant          |                       |

//  return data from VRShMem       |                       |

//       |                   Fx continues to run           |

//       |                         |                  Fx continues to render

//       |                         |                       |

//      ...                       ...                     ...

NS_IMETHODIMP

nsFxrCommandLineHandler::Handle(nsICommandLine* aCmdLine) {

  bool handleFlagRetVal = false;

  nsresult result = aCmdLine->HandleFlag(u"fxr"_ns, false, &handleFlagRetVal);

  if (result == NS_OK && handleFlagRetVal) {

    if (XRE_IsParentProcess() && !XRE_IsE10sParentProcess()) {

      MOZ_CRASH("--fxr not supported without e10s");

    MOZ_ASSERT(mozilla::StaticPrefs::extensions_webextensions_remote(),

               "Remote extensions are the only supported configuration on "

               "desktop platforms");

    aCmdLine->SetPreventDefault(true);

    nsCOMPtr<nsIWindowWatcher> wwatch =

        do_GetService(NS_WINDOWWATCHER_CONTRACTID);

    NS_ENSURE_TRUE(wwatch, NS_ERROR_FAILURE);

    nsCOMPtr<mozIDOMWindowProxy> newWindow;

    result = wwatch->OpenWindow(

        nullptr,                                        // aParent

        "chrome://fxr/content/fxrui.html"_ns,           // aUrl

        "_blank"_ns,                                    // aName

        "chrome,dialog=no,all,private,alwaysontop"_ns,  // aFeatures

        nullptr,                                        // aArguments

        getter_AddRefs(newWindow));

    MOZ_ASSERT(result == NS_OK);

    nsPIDOMWindowOuter* newWindowOuter = nsPIDOMWindowOuter::From(newWindow);

    FxRWindowManager::GetInstance()->AddWindow(newWindowOuter);

    // Set ForceFullScreenInWidget so that full-screen (in an FxR window)

    // fills only the window and thus the same texture that will already be

    // shared with the host. Also, this is set here per-window because

    // changing the related pref would impact all browser window instances.

    newWindowOuter->ForceFullScreenInWidget();

    // Send the window's HWND to vrhost through VRShMem

    mozilla::gfx::VRShMem shmem(nullptr, true /*aRequiresMutex*/);

    if (shmem.JoinShMem()) {

      mozilla::gfx::VRWindowState windowState = {0};

      shmem.PullWindowState(windowState);

      nsCOMPtr<nsIWidget> newWidget =

          mozilla::widget::WidgetUtils::DOMWindowToWidget(newWindowOuter);

      HWND hwndWidget = (HWND)newWidget->GetNativeData(NS_NATIVE_WINDOW);

      // The CLH should populate these members first

      MOZ_ASSERT(windowState.hwndFx == 0);

      MOZ_ASSERT(windowState.textureFx == nullptr);

      windowState.hwndFx = (uint64_t)hwndWidget;

      shmem.PushWindowState(windowState);

      shmem.LeaveShMem();

      // The GPU process will notify the host that window creation is complete

      // after output data is set in VRShMem

      newWidget->RequestFxrOutput();

    } else {

#ifndef NIGHTLY_BUILD

      MOZ_CRASH("failed to start with --fxr");

#endif

  return NS_OK;

NS_IMETHODIMP

nsFxrCommandLineHandler::GetHelpInfo(nsACString& aResult) {

  aResult.AssignLiteral(

      "  --fxr Creates a new window for Firefox Reality on Desktop when "

      "available\n");

  return NS_OK;