The Tor Browser: dom/bindings/PrimitiveConversions.h@129ffea94266 (annotated)

dom/bindings/PrimitiveConversions.h@129ffea94266 (annotated)

dom/bindings/PrimitiveConversions.h

Sat, 03 Jan 2015 20:18:00 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Sat, 03 Jan 2015 20:18:00 +0100
branch: TOR_BUG_3246
changeset 7: 129ffea94266
permissions: -rw-r--r--

Conditionally enable double key logic according to:
private browsing mode or privacy.thirdparty.isolate preference and
implement in GetCookieStringCommon and FindCookie where it counts...
With some reservations of how to convince FindCookie users to test
condition and pass a nullptr when disabling double key logic.

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-*/
 /* vim: set ts=2 sw=2 et tw=79: */
 /* 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/. */
 /**
  * Conversions from jsval to primitive values
  */
 #ifndef mozilla_dom_PrimitiveConversions_h
 #define mozilla_dom_PrimitiveConversions_h
 #include <limits>
 #include <math.h>
 #include <stdint.h>
 #include "jsapi.h"
 #include "mozilla/Assertions.h"
 #include "mozilla/ErrorResult.h"
 #include "mozilla/FloatingPoint.h"
 namespace mozilla {
 namespace dom {
 template<typename T>
 struct TypeName {
 };
 template<>
 struct TypeName<int8_t> {
   static const char* value() {
     return "byte";
   }
 };
 template<>
 struct TypeName<uint8_t> {
   static const char* value() {
     return "octet";
   }
 };
 template<>
 struct TypeName<int16_t> {
   static const char* value() {
     return "short";
   }
 };
 template<>
 struct TypeName<uint16_t> {
   static const char* value() {
     return "unsigned short";
   }
 };
 template<>
 struct TypeName<int32_t> {
   static const char* value() {
     return "long";
   }
 };
 template<>
 struct TypeName<uint32_t> {
   static const char* value() {
     return "unsigned long";
   }
 };
 template<>
 struct TypeName<int64_t> {
   static const char* value() {
     return "long long";
   }
 };
 template<>
 struct TypeName<uint64_t> {
   static const char* value() {
     return "unsigned long long";
   }
 };
 enum ConversionBehavior {
   eDefault,
   eEnforceRange,
   eClamp
 };
 template<typename T, ConversionBehavior B>
 struct PrimitiveConversionTraits {
 };
 template<typename T>
 struct DisallowedConversion {
   typedef int jstype;
   typedef int intermediateType;
 private:
   static inline bool converter(JSContext* cx, JS::Handle<JS::Value> v,
                                jstype* retval) {
     MOZ_CRASH("This should never be instantiated!");
   }
 };
 struct PrimitiveConversionTraits_smallInt {
   // The output of JS::ToInt32 is determined as follows:
   //   1) The value is converted to a double
   //   2) Anything that's not a finite double returns 0
   //   3) The double is rounded towards zero to the nearest integer
   //   4) The resulting integer is reduced mod 2^32.  The output of this
   //      operation is an integer in the range [0, 2^32).
   //   5) If the resulting number is >= 2^31, 2^32 is subtracted from it.
   //
   // The result of all this is a number in the range [-2^31, 2^31)
   //
   // WebIDL conversions for the 8-bit, 16-bit, and 32-bit integer types
   // are defined in the same way, except that step 4 uses reduction mod
   // 2^8 and 2^16 for the 8-bit and 16-bit types respectively, and step 5
   // is only done for the signed types.
   //
   // C/C++ define integer conversion semantics to unsigned types as taking
   // your input integer mod (1 + largest value representable in the
   // unsigned type).  Since 2^32 is zero mod 2^8, 2^16, and 2^32,
   // converting to the unsigned int of the relevant width will correctly
   // perform step 4; in particular, the 2^32 possibly subtracted in step 5
   // will become 0.
   //
   // Once we have step 4 done, we're just going to assume 2s-complement
   // representation and cast directly to the type we really want.
   //
   // So we can cast directly for all unsigned types and for int32_t; for
   // the smaller-width signed types we need to cast through the
   // corresponding unsigned type.
   typedef int32_t jstype;
   typedef int32_t intermediateType;
   static inline bool converter(JSContext* cx, JS::Handle<JS::Value> v,
                                jstype* retval) {
     return JS::ToInt32(cx, v, retval);
   }
 };
 template<>
 struct PrimitiveConversionTraits<int8_t, eDefault> : PrimitiveConversionTraits_smallInt {
   typedef uint8_t intermediateType;
 };
 template<>
 struct PrimitiveConversionTraits<uint8_t, eDefault> : PrimitiveConversionTraits_smallInt {
 };
 template<>
 struct PrimitiveConversionTraits<int16_t, eDefault> : PrimitiveConversionTraits_smallInt {
   typedef uint16_t intermediateType;
 };
 template<>
 struct PrimitiveConversionTraits<uint16_t, eDefault> : PrimitiveConversionTraits_smallInt {
 };
 template<>
 struct PrimitiveConversionTraits<int32_t, eDefault> : PrimitiveConversionTraits_smallInt {
 };
 template<>
 struct PrimitiveConversionTraits<uint32_t, eDefault> : PrimitiveConversionTraits_smallInt {
 };
 template<>
 struct PrimitiveConversionTraits<int64_t, eDefault> {
   typedef int64_t jstype;
   typedef int64_t intermediateType;
   static inline bool converter(JSContext* cx, JS::Handle<JS::Value> v,
                                jstype* retval) {
     return JS::ToInt64(cx, v, retval);
   }
 };
 template<>
 struct PrimitiveConversionTraits<uint64_t, eDefault> {
   typedef uint64_t jstype;
   typedef uint64_t intermediateType;
   static inline bool converter(JSContext* cx, JS::Handle<JS::Value> v,
                                jstype* retval) {
     return JS::ToUint64(cx, v, retval);
   }
 };
 template<typename T>
 struct PrimitiveConversionTraits_Limits {
   static inline T min() {
     return std::numeric_limits<T>::min();
   }
   static inline T max() {
     return std::numeric_limits<T>::max();
   }
 };
 template<>
 struct PrimitiveConversionTraits_Limits<int64_t> {
   static inline int64_t min() {
     return -(1LL << 53);
   }
   static inline int64_t max() {
     return (1LL << 53);
   }
 };
 template<>
 struct PrimitiveConversionTraits_Limits<uint64_t> {
   static inline uint64_t min() {
     return 0;
   }
   static inline uint64_t max() {
     return (1LL << 53);
   }
 };
 template<typename T, bool (*Enforce)(JSContext* cx, const double& d, T* retval)>
 struct PrimitiveConversionTraits_ToCheckedIntHelper {
   typedef T jstype;
   typedef T intermediateType;
   static inline bool converter(JSContext* cx, JS::Handle<JS::Value> v,
                                jstype* retval) {
     double intermediate;
     if (!JS::ToNumber(cx, v, &intermediate)) {
       return false;
     }
     return Enforce(cx, intermediate, retval);
   }
 };
 template<typename T>
 inline bool
 PrimitiveConversionTraits_EnforceRange(JSContext* cx, const double& d, T* retval)
 {
   static_assert(std::numeric_limits<T>::is_integer,
                 "This can only be applied to integers!");
   if (!mozilla::IsFinite(d)) {
     return ThrowErrorMessage(cx, MSG_ENFORCE_RANGE_NON_FINITE, TypeName<T>::value());
   }
   bool neg = (d < 0);
   double rounded = floor(neg ? -d : d);
   rounded = neg ? -rounded : rounded;
   if (rounded < PrimitiveConversionTraits_Limits<T>::min() ||
       rounded > PrimitiveConversionTraits_Limits<T>::max()) {
     return ThrowErrorMessage(cx, MSG_ENFORCE_RANGE_OUT_OF_RANGE, TypeName<T>::value());
   }
   *retval = static_cast<T>(rounded);
   return true;
 }
 template<typename T>
 struct PrimitiveConversionTraits<T, eEnforceRange> :
   public PrimitiveConversionTraits_ToCheckedIntHelper<T, PrimitiveConversionTraits_EnforceRange<T> > {
 };
 template<typename T>
 inline bool
 PrimitiveConversionTraits_Clamp(JSContext* cx, const double& d, T* retval)
 {
   static_assert(std::numeric_limits<T>::is_integer,
                 "This can only be applied to integers!");
   if (mozilla::IsNaN(d)) {
     *retval = 0;
     return true;
   }
   if (d >= PrimitiveConversionTraits_Limits<T>::max()) {
     *retval = PrimitiveConversionTraits_Limits<T>::max();
     return true;
   }
   if (d <= PrimitiveConversionTraits_Limits<T>::min()) {
     *retval = PrimitiveConversionTraits_Limits<T>::min();
     return true;
   }
   MOZ_ASSERT(mozilla::IsFinite(d));
   // Banker's rounding (round ties towards even).
   // We move away from 0 by 0.5f and then truncate.  That gets us the right
   // answer for any starting value except plus or minus N.5.  With a starting
   // value of that form, we now have plus or minus N+1.  If N is odd, this is
   // the correct result.  If N is even, plus or minus N is the correct result.
   double toTruncate = (d < 0) ? d - 0.5 : d + 0.5;
   T truncated = static_cast<T>(toTruncate);
   if (truncated == toTruncate) {
     /*
      * It was a tie (since moving away from 0 by 0.5 gave us the exact integer
      * we want). Since we rounded away from 0, we either already have an even
      * number or we have an odd number but the number we want is one closer to
      * 0. So just unconditionally masking out the ones bit should do the trick
      * to get us the value we want.
      */
     truncated &= ~1;
   }
   *retval = truncated;
   return true;
 }
 template<typename T>
 struct PrimitiveConversionTraits<T, eClamp> :
   public PrimitiveConversionTraits_ToCheckedIntHelper<T, PrimitiveConversionTraits_Clamp<T> > {
 };
 template<ConversionBehavior B>
 struct PrimitiveConversionTraits<bool, B> : public DisallowedConversion<bool> {};
 template<>
 struct PrimitiveConversionTraits<bool, eDefault> {
   typedef bool jstype;
   typedef bool intermediateType;
   static inline bool converter(JSContext* /* unused */, JS::Handle<JS::Value> v,
                                jstype* retval) {
     *retval = JS::ToBoolean(v);
     return true;
   }
 };
 template<ConversionBehavior B>
 struct PrimitiveConversionTraits<float, B> : public DisallowedConversion<float> {};
 template<ConversionBehavior B>
 struct PrimitiveConversionTraits<double, B> : public DisallowedConversion<double> {};
 struct PrimitiveConversionTraits_float {
   typedef double jstype;
   typedef double intermediateType;
   static inline bool converter(JSContext* cx, JS::Handle<JS::Value> v,
                                jstype* retval) {
     return JS::ToNumber(cx, v, retval);
   }
 };
 template<>
 struct PrimitiveConversionTraits<float, eDefault> : PrimitiveConversionTraits_float {
 };
 template<>
 struct PrimitiveConversionTraits<double, eDefault> : PrimitiveConversionTraits_float {
 };
 template<typename T, ConversionBehavior B>
 bool ValueToPrimitive(JSContext* cx, JS::Handle<JS::Value> v, T* retval)
 {
   typename PrimitiveConversionTraits<T, B>::jstype t;
   if (!PrimitiveConversionTraits<T, B>::converter(cx, v, &t))
     return false;
   *retval = static_cast<T>(
     static_cast<typename PrimitiveConversionTraits<T, B>::intermediateType>(t));
   return true;
 }
 } // namespace dom
 } // namespace mozilla
 #endif /* mozilla_dom_PrimitiveConversions_h */

The Tor Browser / annotate

dom/bindings/PrimitiveConversions.h@129ffea94266 (annotated)

dom/bindings/PrimitiveConversions.h