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

/* vim: set ts=8 sts=2 et sw=2 tw=80: */

/* 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 "mozilla/ArrayUtils.h"

#include "mozilla/UniquePtr.h"

#include "mozilla/TextEventDispatcher.h"

#include "mozilla/TextEventDispatcherListener.h"

#include "mozilla/layers/CompositorBridgeChild.h"

#include "mozilla/layers/CompositorBridgeParent.h"

#include "mozilla/layers/PLayerTransactionChild.h"

#include "mozilla/layers/ImageBridgeChild.h"

#include "LiveResizeListener.h"

#include "nsBaseWidget.h"

#include "nsDeviceContext.h"

#include "nsCOMPtr.h"

#include "nsGfxCIID.h"

#include "nsWidgetsCID.h"

#include "nsServiceManagerUtils.h"

#include "nsIKeyEventInPluginCallback.h"

#include "nsIScreenManager.h"

#include "nsAppDirectoryServiceDefs.h"

#include "nsISimpleEnumerator.h"

#include "nsIContent.h"

#include "nsIDocument.h"

#include "nsIPresShell.h"

#include "nsIServiceManager.h"

#include "mozilla/Preferences.h"

#include "BasicLayers.h"

#include "ClientLayerManager.h"

#include "mozilla/layers/Compositor.h"

#include "nsIXULRuntime.h"

#include "nsIXULWindow.h"

#include "nsIBaseWindow.h"

#include "nsXULPopupManager.h"

#include "nsXBLWindowKeyHandler.h"

#include "nsIWidgetListener.h"

#include "nsIGfxInfo.h"

#include "npapi.h"

#include "X11UndefineNone.h"

#include "base/thread.h"

#include "prdtoa.h"

#include "prenv.h"

#include "mozilla/Attributes.h"

#include "mozilla/Unused.h"

#include "nsContentUtils.h"

#include "gfxPrefs.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/MouseEvents.h"

#include "GLConsts.h"

#include "mozilla/Unused.h"

#include "mozilla/IMEStateManager.h"

#include "mozilla/VsyncDispatcher.h"

#include "mozilla/layers/IAPZCTreeManager.h"

#include "mozilla/layers/APZEventState.h"

#include "mozilla/layers/APZThreadUtils.h"

#include "mozilla/layers/ChromeProcessController.h"

#include "mozilla/layers/CompositorOptions.h"

#include "mozilla/layers/InputAPZContext.h"

#include "mozilla/layers/APZCCallbackHelper.h"

#include "mozilla/layers/WebRenderLayerManager.h"

#include "mozilla/dom/ContentChild.h"

#include "mozilla/dom/TabParent.h"

#include "mozilla/gfx/GPUProcessManager.h"

#include "mozilla/gfx/gfxVars.h"

#include "mozilla/Move.h"

#include "mozilla/Services.h"

#include "mozilla/Sprintf.h"

#include "mozilla/webrender/WebRenderTypes.h"

#include "nsRefPtrHashtable.h"

#include "TouchEvents.h"

#include "WritingModes.h"

#include "InputData.h"

#include "FrameLayerBuilder.h"

#ifdef ACCESSIBILITY

#include "nsAccessibilityService.h"

#endif

#include "gfxConfig.h"

#include "mozilla/layers/CompositorSession.h"

#include "VRManagerChild.h"

#include "gfxConfig.h"

#ifdef DEBUG

#include "nsIObserver.h"

static void debug_RegisterPrefCallbacks();

#endif

#ifdef NOISY_WIDGET_LEAKS

static int32_t gNumWidgets;

#endif

#ifdef XP_MACOSX

#include "nsCocoaFeatures.h"

#endif

#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)

static nsRefPtrHashtable<nsVoidPtrHashKey, nsIWidget>* sPluginWidgetList;

#endif

nsIRollupListener* nsBaseWidget::gRollupListener = nullptr;

using namespace mozilla::dom;

using namespace mozilla::layers;

using namespace mozilla::ipc;

using namespace mozilla::widget;

using namespace mozilla;

using base::Thread;

// Global user preference for disabling native theme. Used

// in NativeWindowTheme.

bool gDisableNativeTheme = false;

// Async pump timer during injected long touch taps

#define TOUCH_INJECT_PUMP_TIMER_MSEC 50

#define TOUCH_INJECT_LONG_TAP_DEFAULT_MSEC 1500

int32_t nsIWidget::sPointerIdCounter = 0;

// Some statics from nsIWidget.h

/*static*/ uint64_t AutoObserverNotifier::sObserverId = 0;

/*static*/ nsDataHashtable<nsUint64HashKey, nsCOMPtr<nsIObserver>>

    AutoObserverNotifier::sSavedObservers;

// The maximum amount of time to let the EnableDragDrop runnable wait in the

// idle queue before timing out and moving it to the regular queue. Value is in

// milliseconds.

const uint32_t kAsyncDragDropTimeout = 1000;

namespace mozilla {

namespace widget {

void IMENotification::SelectionChangeDataBase::SetWritingMode(

    const WritingMode& aWritingMode) {

  mWritingMode = aWritingMode.mWritingMode;

}

WritingMode IMENotification::SelectionChangeDataBase::GetWritingMode() const {

  return WritingMode(mWritingMode);

}

}  // namespace widget

}  // namespace mozilla

NS_IMPL_ISUPPORTS(nsBaseWidget, nsIWidget, nsISupportsWeakReference)

//-------------------------------------------------------------------------

//

// nsBaseWidget constructor

//

//-------------------------------------------------------------------------

nsBaseWidget::nsBaseWidget()

    : mWidgetListener(nullptr),

      mAttachedWidgetListener(nullptr),

      mPreviouslyAttachedWidgetListener(nullptr),

      mLayerManager(nullptr),

      mCompositorVsyncDispatcher(nullptr),

      mCursor(eCursor_standard),

      mBorderStyle(eBorderStyle_none),

      mBounds(0, 0, 0, 0),

      mOriginalBounds(nullptr),

      mClipRectCount(0),

      mSizeMode(nsSizeMode_Normal),

      mPopupLevel(ePopupLevelTop),

      mPopupType(ePopupTypeAny),

      mHasRemoteContent(false),

      mUpdateCursor(true),

      mUseAttachedEvents(false),

      mIMEHasFocus(false),

      mIsFullyOccluded(false) {

#ifdef NOISY_WIDGET_LEAKS

  gNumWidgets++;

  printf("WIDGETS+ = %d\n", gNumWidgets);

#endif

#ifdef DEBUG

  debug_RegisterPrefCallbacks();

#endif

#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)

  if (!sPluginWidgetList) {

    sPluginWidgetList = new nsRefPtrHashtable<nsVoidPtrHashKey, nsIWidget>();

  }

#endif

  mShutdownObserver = new WidgetShutdownObserver(this);

}

NS_IMPL_ISUPPORTS(WidgetShutdownObserver, nsIObserver)

WidgetShutdownObserver::WidgetShutdownObserver(nsBaseWidget* aWidget)

    : mWidget(aWidget), mRegistered(false) {

  Register();

}

WidgetShutdownObserver::~WidgetShutdownObserver() {

  // No need to call Unregister(), we can't be destroyed until nsBaseWidget

  // gets torn down. The observer service and nsBaseWidget have a ref on us

  // so nsBaseWidget has to call Unregister and then clear its ref.

}

NS_IMETHODIMP

WidgetShutdownObserver::Observe(nsISupports* aSubject, const char* aTopic,

                                const char16_t* aData) {

  if (mWidget && !strcmp(aTopic, NS_XPCOM_SHUTDOWN_OBSERVER_ID)) {

    RefPtr<nsBaseWidget> widget(mWidget);

    widget->Shutdown();

  }

  return NS_OK;

}

void WidgetShutdownObserver::Register() {

  if (!mRegistered) {

    mRegistered = true;

    nsContentUtils::RegisterShutdownObserver(this);

  }

}

void WidgetShutdownObserver::Unregister() {

  if (mRegistered) {

    mWidget = nullptr;

    nsContentUtils::UnregisterShutdownObserver(this);

    mRegistered = false;

  }

}

void nsBaseWidget::Shutdown() {

  NotifyLiveResizeStopped();

  RevokeTransactionIdAllocator();

  DestroyCompositor();

  FreeShutdownObserver();

#if defined(XP_WIN) || defined(MOZ_WIDGET_GTK)

  if (sPluginWidgetList) {

    delete sPluginWidgetList;

    sPluginWidgetList = nullptr;

  }

#endif

}

void nsBaseWidget::DestroyCompositor() {

  // We release this before releasing the compositor, since it may hold the

  // last reference to our ClientLayerManager. ClientLayerManager's dtor can

  // trigger a paint, creating a new compositor, and we don't want to re-use

  // the old vsync dispatcher.

  if (mCompositorVsyncDispatcher) {

    MOZ_ASSERT(mCompositorVsyncDispatcherLock.get());

    MutexAutoLock lock(*mCompositorVsyncDispatcherLock.get());

    mCompositorVsyncDispatcher->Shutdown();

    mCompositorVsyncDispatcher = nullptr;

  }

  // The compositor shutdown sequence looks like this:

  //  1. CompositorSession calls CompositorBridgeChild::Destroy.

  //  2. CompositorBridgeChild synchronously sends WillClose.

  //  3. CompositorBridgeParent releases some resources (such as the layer

  //     manager, compositor, and widget).

  //  4. CompositorBridgeChild::Destroy returns.

  //  5. Asynchronously, CompositorBridgeParent::ActorDestroy will fire on the

  //     compositor thread when the I/O thread closes the IPC channel.

  //  6. Step 5 will schedule DeferredDestroy on the compositor thread, which

  //     releases the reference CompositorBridgeParent holds to itself.

  //

  // When CompositorSession::Shutdown returns, we assume the compositor is gone

  // or will be gone very soon.

  if (mCompositorSession) {

    ReleaseContentController();

    mAPZC = nullptr;

    SetCompositorWidgetDelegate(nullptr);

    mCompositorBridgeChild = nullptr;

    // XXX CompositorBridgeChild and CompositorBridgeParent might be re-created

    // in ClientLayerManager destructor. See bug 1133426.

    RefPtr<CompositorSession> session = mCompositorSession.forget();

    session->Shutdown();

  }

}

// This prevents the layer manager from starting a new transaction during

// shutdown.

void nsBaseWidget::RevokeTransactionIdAllocator() {

  if (!mLayerManager) {

    return;

  }

  mLayerManager->SetTransactionIdAllocator(nullptr);

}

void nsBaseWidget::ReleaseContentController() {

  if (mRootContentController) {

    mRootContentController->Destroy();

    mRootContentController = nullptr;

  }

}

void nsBaseWidget::DestroyLayerManager() {

  if (mLayerManager) {

    mLayerManager->Destroy();

    mLayerManager = nullptr;

  }

  DestroyCompositor();

}

void nsBaseWidget::OnRenderingDeviceReset() { DestroyLayerManager(); }

void nsBaseWidget::FreeShutdownObserver() {

  if (mShutdownObserver) {

    mShutdownObserver->Unregister();

  }

  mShutdownObserver = nullptr;

}

//-------------------------------------------------------------------------

//

// nsBaseWidget destructor

//

//-------------------------------------------------------------------------

nsBaseWidget::~nsBaseWidget() {

  IMEStateManager::WidgetDestroyed(this);

  if (mLayerManager) {

    if (BasicLayerManager* mgr = mLayerManager->AsBasicLayerManager()) {

      mgr->ClearRetainerWidget();

    }

  }