The Tor Browser: hal/cocoa/CocoaBattery.cpp@97036ab72558 (annotated)

hal/cocoa/CocoaBattery.cpp@97036ab72558 (annotated)

hal/cocoa/CocoaBattery.cpp

Tue, 06 Jan 2015 21:39:09 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Tue, 06 Jan 2015 21:39:09 +0100
branch: TOR_BUG_9701
changeset 8: 97036ab72558
permissions: -rw-r--r--

Conditionally force memory storage according to privacy.thirdparty.isolate;
This solves Tor bug #9701, complying with disk avoidance documented in
https://www.torproject.org/projects/torbrowser/design/#disk-avoidance.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
 /* vim set: sw=2 ts=2 et lcs=trail\:.,tab\:>~ : */
 /* 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/. */
 #import <CoreFoundation/CoreFoundation.h>
 #import <IOKit/ps/IOPowerSources.h>
 #import <IOKit/ps/IOPSKeys.h>
 #include <mozilla/Hal.h>
 #include <mozilla/dom/battery/Constants.h>
 #include <mozilla/Services.h>
 #include <nsIObserverService.h>
 #include <nsIObserver.h>
 #include <dlfcn.h>
 #define IOKIT_FRAMEWORK_PATH "/System/Library/Frameworks/IOKit.framework/IOKit"
 #ifndef kIOPSTimeRemainingUnknown
   #define kIOPSTimeRemainingUnknown ((CFTimeInterval)-1.0)
 #endif
 #ifndef kIOPSTimeRemainingUnlimited
   #define kIOPSTimeRemainingUnlimited ((CFTimeInterval)-2.0)
 #endif
 using namespace mozilla::dom::battery;
 namespace mozilla {
 namespace hal_impl {
 typedef CFTimeInterval (*IOPSGetTimeRemainingEstimateFunc)(void);
 class MacPowerInformationService
 {
 public:
   static MacPowerInformationService* GetInstance();
   static void Shutdown();
   void BeginListening();
   void StopListening();
   static void HandleChange(void *aContext);
   ~MacPowerInformationService();
 private:
   MacPowerInformationService();
   // The reference to the runloop that is notified of power changes.
   CFRunLoopSourceRef mRunLoopSource;
   double mLevel;
   bool mCharging;
   double mRemainingTime;
   bool mShouldNotify;
   friend void GetCurrentBatteryInformation(hal::BatteryInformation* aBatteryInfo);
   static MacPowerInformationService* sInstance;
   static void* sIOKitFramework;
   static IOPSGetTimeRemainingEstimateFunc sIOPSGetTimeRemainingEstimate;
 };
 void* MacPowerInformationService::sIOKitFramework;
 IOPSGetTimeRemainingEstimateFunc MacPowerInformationService::sIOPSGetTimeRemainingEstimate;
 /*
  * Implementation of mozilla::hal_impl::EnableBatteryNotifications,
  *                   mozilla::hal_impl::DisableBatteryNotifications,
  *               and mozilla::hal_impl::GetCurrentBatteryInformation.
  */
 void
 EnableBatteryNotifications()
 {
   MacPowerInformationService::GetInstance()->BeginListening();
 }
 void
 DisableBatteryNotifications()
 {
   MacPowerInformationService::GetInstance()->StopListening();
 }
 void
 GetCurrentBatteryInformation(hal::BatteryInformation* aBatteryInfo)
 {
   MacPowerInformationService* powerService = MacPowerInformationService::GetInstance();
   aBatteryInfo->level() = powerService->mLevel;
   aBatteryInfo->charging() = powerService->mCharging;
   aBatteryInfo->remainingTime() = powerService->mRemainingTime;
 }
 /*
  * Following is the implementation of MacPowerInformationService.
  */
 MacPowerInformationService* MacPowerInformationService::sInstance = nullptr;
 namespace {
 struct SingletonDestroyer MOZ_FINAL : public nsIObserver
 {
   NS_DECL_ISUPPORTS
   NS_DECL_NSIOBSERVER
 };
 NS_IMPL_ISUPPORTS(SingletonDestroyer, nsIObserver)
 NS_IMETHODIMP
 SingletonDestroyer::Observe(nsISupports*, const char* aTopic, const char16_t*)
 {
   MOZ_ASSERT(!strcmp(aTopic, "xpcom-shutdown"));
   MacPowerInformationService::Shutdown();
   return NS_OK;
 }
 } // anonymous namespace
 /* static */ MacPowerInformationService*
 MacPowerInformationService::GetInstance()
 {
   if (sInstance) {
     return sInstance;
   }
   sInstance = new MacPowerInformationService();
   nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
   if (obs) {
     obs->AddObserver(new SingletonDestroyer(), "xpcom-shutdown", false);
   }
   return sInstance;
 }
 void
 MacPowerInformationService::Shutdown()
 {
   delete sInstance;
   sInstance = nullptr;
 }
 MacPowerInformationService::MacPowerInformationService()
   : mRunLoopSource(nullptr)
   , mLevel(kDefaultLevel)
   , mCharging(kDefaultCharging)
   , mRemainingTime(kDefaultRemainingTime)
   , mShouldNotify(false)
 {
   // IOPSGetTimeRemainingEstimate (and the related constants) are only available
   // on 10.7, so we test for their presence at runtime.
   sIOKitFramework = dlopen(IOKIT_FRAMEWORK_PATH, RTLD_LAZY | RTLD_LOCAL);
   if (sIOKitFramework) {
     sIOPSGetTimeRemainingEstimate =
       (IOPSGetTimeRemainingEstimateFunc)dlsym(sIOKitFramework, "IOPSGetTimeRemainingEstimate");
   } else {
     sIOPSGetTimeRemainingEstimate = nullptr;
   }
 }
 MacPowerInformationService::~MacPowerInformationService()
 {
   MOZ_ASSERT(!mRunLoopSource,
                "The observers have not been correctly removed! "
                "(StopListening should have been called)");
   if (sIOKitFramework) {
     dlclose(sIOKitFramework);
   }
 }
 void
 MacPowerInformationService::BeginListening()
 {
   // Set ourselves up to be notified about changes.
   MOZ_ASSERT(!mRunLoopSource, "IOPS Notification Loop Source already set up. "
                               "(StopListening should have been called)");
   mRunLoopSource = ::IOPSNotificationCreateRunLoopSource(HandleChange, this);
   if (mRunLoopSource) {
     ::CFRunLoopAddSource(::CFRunLoopGetCurrent(), mRunLoopSource,
                          kCFRunLoopDefaultMode);
     // Invoke our callback now so we have data if GetCurrentBatteryInformation is
     // called before a change happens.
     HandleChange(this);
     mShouldNotify = true;
   }
 }
 void
 MacPowerInformationService::StopListening()
 {
   MOZ_ASSERT(mRunLoopSource, "IOPS Notification Loop Source not set up. "
                              "(StopListening without BeginListening)");
   ::CFRunLoopRemoveSource(::CFRunLoopGetCurrent(), mRunLoopSource,
                           kCFRunLoopDefaultMode);
   mRunLoopSource = nullptr;
 }
 void
 MacPowerInformationService::HandleChange(void* aContext) {
   MacPowerInformationService* power =
     static_cast<MacPowerInformationService*>(aContext);
   CFTypeRef data = ::IOPSCopyPowerSourcesInfo();
   if (!data) {
     ::CFRelease(data);
     return;
   }
   // Get the list of power sources.
   CFArrayRef list = ::IOPSCopyPowerSourcesList(data);
   if (!list) {
     ::CFRelease(list);
     return;
   }
   // Default values. These will be used if there are 0 sources or we can't find
   // better information.
   double level = kDefaultLevel;
   double charging = kDefaultCharging;
   double remainingTime = kDefaultRemainingTime;
   // Look for the first battery power source to give us the information we need.
   // Usually there's only 1 available, depending on current power source.
   for (CFIndex i = 0; i < ::CFArrayGetCount(list); ++i) {
     CFTypeRef source = ::CFArrayGetValueAtIndex(list, i);
     CFDictionaryRef currPowerSourceDesc = ::IOPSGetPowerSourceDescription(data, source);
     if (!currPowerSourceDesc) {
       continue;
     }
     // Get a battery level estimate. This key is required.
     int currentCapacity = 0;
     const void* cfRef = ::CFDictionaryGetValue(currPowerSourceDesc, CFSTR(kIOPSCurrentCapacityKey));
     ::CFNumberGetValue((CFNumberRef)cfRef, kCFNumberSInt32Type, &currentCapacity);
     // This key is also required.
     int maxCapacity = 0;
     cfRef = ::CFDictionaryGetValue(currPowerSourceDesc, CFSTR(kIOPSMaxCapacityKey));
     ::CFNumberGetValue((CFNumberRef)cfRef, kCFNumberSInt32Type, &maxCapacity);
     if (maxCapacity > 0) {
       level = static_cast<double>(currentCapacity)/static_cast<double>(maxCapacity);
     }
     // Find out if we're charging.
     // This key is optional, we fallback to kDefaultCharging if the current power
     // source doesn't have that info.
     if(::CFDictionaryGetValueIfPresent(currPowerSourceDesc, CFSTR(kIOPSIsChargingKey), &cfRef)) {
       charging = ::CFBooleanGetValue((CFBooleanRef)cfRef);
       // Get an estimate of how long it's going to take until we're fully charged.
       // This key is optional.
       if (charging) {
         // Default value that will be changed if we happen to find the actual
         // remaining time.
         remainingTime = level == 1.0 ? kDefaultRemainingTime : kUnknownRemainingTime;
         if (::CFDictionaryGetValueIfPresent(currPowerSourceDesc,
                 CFSTR(kIOPSTimeToFullChargeKey), &cfRef)) {
           int timeToCharge;
           ::CFNumberGetValue((CFNumberRef)cfRef, kCFNumberIntType, &timeToCharge);
           if (timeToCharge != kIOPSTimeRemainingUnknown) {
             remainingTime = timeToCharge*60;
           }
         }
       } else if (sIOPSGetTimeRemainingEstimate) { // not charging
         // See if we can get a time estimate.
         CFTimeInterval estimate = sIOPSGetTimeRemainingEstimate();
         if (estimate == kIOPSTimeRemainingUnlimited || estimate == kIOPSTimeRemainingUnknown) {
           remainingTime = kUnknownRemainingTime;
         } else {
           remainingTime = estimate;
         }
       }
     }
     break;
   }
   bool isNewData = level != power->mLevel || charging != power->mCharging ||
                    remainingTime != power->mRemainingTime;
   power->mRemainingTime = remainingTime;
   power->mCharging = charging;
   power->mLevel = level;
   // Notify the observers if stuff changed.
   if (power->mShouldNotify && isNewData) {
     hal::NotifyBatteryChange(hal::BatteryInformation(power->mLevel,
                                                      power->mCharging,
                                                      power->mRemainingTime));
   }
   ::CFRelease(data);
   ::CFRelease(list);
 }
 } // namespace hal_impl
 } // namespace mozilla

The Tor Browser / annotate

hal/cocoa/CocoaBattery.cpp@97036ab72558 (annotated)

hal/cocoa/CocoaBattery.cpp