The Tor Browser / file revision

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

 #include "mozilla/Hal.h"

 #include "WakeLock.h"

 #include "nsDOMClassInfoID.h"

 #include "nsIDOMWakeLockListener.h"

 #include "nsIDocument.h"

 #include "nsIPermissionManager.h"

 #include "nsIPowerManagerService.h"

 #include "nsIPrincipal.h"

 #include "nsPIDOMWindow.h"

 #include "nsServiceManagerUtils.h"

 #include "nsError.h"

 #include "mozilla/dom/MozPowerManagerBinding.h"

 namespace mozilla {

 namespace dom {

 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(PowerManager)

   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY

   NS_INTERFACE_MAP_ENTRY(nsISupports)

   NS_INTERFACE_MAP_ENTRY(nsIDOMMozWakeLockListener)

 NS_INTERFACE_MAP_END

 NS_IMPL_CYCLE_COLLECTION_WRAPPERCACHE_2(PowerManager, mListeners, mWindow)

 NS_IMPL_CYCLE_COLLECTING_ADDREF(PowerManager)

 NS_IMPL_CYCLE_COLLECTING_RELEASE(PowerManager)

 /* virtual */ JSObject*

 PowerManager::WrapObject(JSContext* aCx)

 {

   return MozPowerManagerBinding::Wrap(aCx, this);

 }

 nsresult

 PowerManager::Init(nsIDOMWindow *aWindow)

 {

   mWindow = aWindow;

   nsCOMPtr<nsIPowerManagerService> pmService =

     do_GetService(POWERMANAGERSERVICE_CONTRACTID);

   NS_ENSURE_STATE(pmService);

   // Add ourself to the global notification list.

   pmService->AddWakeLockListener(this);

   return NS_OK;

 }

 nsresult

 PowerManager::Shutdown()

 {

   nsCOMPtr<nsIPowerManagerService> pmService =

     do_GetService(POWERMANAGERSERVICE_CONTRACTID);

   NS_ENSURE_STATE(pmService);

   // Remove ourself from the global notification list.

   pmService->RemoveWakeLockListener(this);

   return NS_OK;

 }

 void

 PowerManager::Reboot(ErrorResult& aRv)

 {

   nsCOMPtr<nsIPowerManagerService> pmService =

     do_GetService(POWERMANAGERSERVICE_CONTRACTID);

   if (pmService) {

     pmService->Reboot();

   } else {

     aRv.Throw(NS_ERROR_UNEXPECTED);

   }

 }

 void

 PowerManager::FactoryReset()

 {

   hal::FactoryReset();

 }

 void

 PowerManager::PowerOff(ErrorResult& aRv)

 {

   nsCOMPtr<nsIPowerManagerService> pmService =

     do_GetService(POWERMANAGERSERVICE_CONTRACTID);

   if (pmService) {

     pmService->PowerOff();

   } else {

     aRv.Throw(NS_ERROR_UNEXPECTED);

   }

 }

 void

 PowerManager::AddWakeLockListener(nsIDOMMozWakeLockListener *aListener)

 {

   if (!mListeners.Contains(aListener)) {

     mListeners.AppendElement(aListener);

   }

 }

 void

 PowerManager::RemoveWakeLockListener(nsIDOMMozWakeLockListener *aListener)

 {

   mListeners.RemoveElement(aListener);

 }

 void

 PowerManager::GetWakeLockState(const nsAString& aTopic,

                                nsAString& aState,

                                ErrorResult& aRv)

 {

   nsCOMPtr<nsIPowerManagerService> pmService =

     do_GetService(POWERMANAGERSERVICE_CONTRACTID);

   if (pmService) {

     aRv = pmService->GetWakeLockState(aTopic, aState);

   } else {

     aRv.Throw(NS_ERROR_UNEXPECTED);

   }

 }

 NS_IMETHODIMP

 PowerManager::Callback(const nsAString &aTopic, const nsAString &aState)

 {

   /**

    * We maintain a local listener list instead of using the global

    * list so that when the window is destroyed we don't have to

    * cleanup the mess.

    * Copy the listeners list before we walk through the callbacks

    * because the callbacks may install new listeners. We expect no

    * more than one listener per window, so it shouldn't be too long.

    */

   nsAutoTArray<nsCOMPtr<nsIDOMMozWakeLockListener>, 2> listeners(mListeners);

   for (uint32_t i = 0; i < listeners.Length(); ++i) {

     listeners[i]->Callback(aTopic, aState);

   }

   return NS_OK;

 }

 bool

 PowerManager::ScreenEnabled()

 {

   return hal::GetScreenEnabled();

 }

 void

 PowerManager::SetScreenEnabled(bool aEnabled)

 {

   hal::SetScreenEnabled(aEnabled);

 }

 double

 PowerManager::ScreenBrightness()

 {

   return hal::GetScreenBrightness();

 }

 void

 PowerManager::SetScreenBrightness(double aBrightness, ErrorResult& aRv)

 {

   if (0 <= aBrightness && aBrightness <= 1) {

     hal::SetScreenBrightness(aBrightness);

   } else {

     aRv.Throw(NS_ERROR_INVALID_ARG);

   }

 }

 bool

 PowerManager::CpuSleepAllowed()

 {

   return hal::GetCpuSleepAllowed();

 }

 void

 PowerManager::SetCpuSleepAllowed(bool aAllowed)

 {

   hal::SetCpuSleepAllowed(aAllowed);

 }

 bool

 PowerManager::CheckPermission(nsPIDOMWindow* aWindow)

 {

   nsCOMPtr<nsIPermissionManager> permMgr =

     do_GetService(NS_PERMISSIONMANAGER_CONTRACTID);

   NS_ENSURE_TRUE(permMgr, false);

   uint32_t permission = nsIPermissionManager::DENY_ACTION;

   permMgr->TestPermissionFromWindow(aWindow, "power", &permission);

   return permission == nsIPermissionManager::ALLOW_ACTION;

 }

 already_AddRefed<PowerManager>

 PowerManager::CreateInstance(nsPIDOMWindow* aWindow)

 {

   nsRefPtr<PowerManager> powerManager = new PowerManager();

   if (NS_FAILED(powerManager->Init(aWindow))) {

     powerManager = nullptr;

   }

   return powerManager.forget();

 }

 } // dom

 } // mozilla