The Tor Browser: layout/style/nsROCSSPrimitiveValue.cpp@141e0f1194b1 (annotated)

layout/style/nsROCSSPrimitiveValue.cpp@141e0f1194b1 (annotated)

layout/style/nsROCSSPrimitiveValue.cpp

Wed, 31 Dec 2014 07:16:47 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 07:16:47 +0100
branch: TOR_BUG_9701
changeset 3: 141e0f1194b1
permissions: -rw-r--r--

Revert simplistic fix pending revisit of Mozilla integration attempt.

 /* -*- 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/. */
 /* DOM object representing values in DOM computed style */
 #include "nsROCSSPrimitiveValue.h"
 #include "mozilla/dom/CSSPrimitiveValueBinding.h"
 #include "nsPresContext.h"
 #include "nsStyleUtil.h"
 #include "nsDOMCSSRGBColor.h"
 #include "nsDOMCSSRect.h"
 #include "nsIURI.h"
 #include "nsError.h"
 using namespace mozilla;
 nsROCSSPrimitiveValue::nsROCSSPrimitiveValue()
   : CSSValue(), mType(CSS_PX)
 {
   mValue.mAppUnits = 0;
   SetIsDOMBinding();
 }
 nsROCSSPrimitiveValue::~nsROCSSPrimitiveValue()
 {
   Reset();
 }
 NS_IMPL_CYCLE_COLLECTING_ADDREF(nsROCSSPrimitiveValue)
 NS_IMPL_CYCLE_COLLECTING_RELEASE(nsROCSSPrimitiveValue)
 // QueryInterface implementation for nsROCSSPrimitiveValue
 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(nsROCSSPrimitiveValue)
   NS_WRAPPERCACHE_INTERFACE_MAP_ENTRY
   NS_INTERFACE_MAP_ENTRY(nsIDOMCSSPrimitiveValue)
   NS_INTERFACE_MAP_ENTRY(nsIDOMCSSValue)
   NS_INTERFACE_MAP_ENTRY_AMBIGUOUS(nsISupports, CSSValue)
 NS_INTERFACE_MAP_END
 NS_IMPL_CYCLE_COLLECTION_CLASS(nsROCSSPrimitiveValue)
 NS_IMPL_CYCLE_COLLECTION_TRACE_WRAPPERCACHE(nsROCSSPrimitiveValue)
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_BEGIN(nsROCSSPrimitiveValue)
   if (tmp->mType == CSS_URI) {
     NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mURI)
   } else if (tmp->mType == CSS_RGBCOLOR) {
     NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mColor)
   } else if (tmp->mType == CSS_RECT) {
     NS_IMPL_CYCLE_COLLECTION_TRAVERSE_RAWPTR(mValue.mRect)
   }
   NS_IMPL_CYCLE_COLLECTION_TRAVERSE_SCRIPT_OBJECTS
 NS_IMPL_CYCLE_COLLECTION_TRAVERSE_END
 NS_IMPL_CYCLE_COLLECTION_UNLINK_BEGIN(nsROCSSPrimitiveValue)
   NS_IMPL_CYCLE_COLLECTION_UNLINK_PRESERVED_WRAPPER
   tmp->Reset();
 NS_IMPL_CYCLE_COLLECTION_UNLINK_END
 JSObject*
 nsROCSSPrimitiveValue::WrapObject(JSContext *cx)
 {
   return dom::CSSPrimitiveValueBinding::Wrap(cx, this);
 }
 // nsIDOMCSSValue
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::GetCssText(nsAString& aCssText)
 {
   nsAutoString tmpStr;
   aCssText.Truncate();
   nsresult result = NS_OK;
   switch (mType) {
     case CSS_PX :
       {
         float val = nsPresContext::AppUnitsToFloatCSSPixels(mValue.mAppUnits);
         nsStyleUtil::AppendCSSNumber(val, tmpStr);
         tmpStr.AppendLiteral("px");
         break;
       }
     case CSS_IDENT :
       {
         AppendUTF8toUTF16(nsCSSKeywords::GetStringValue(mValue.mKeyword),
                           tmpStr);
         break;
       }
     case CSS_STRING :
     case CSS_COUNTER : /* FIXME: COUNTER should use an object */
       {
         tmpStr.Append(mValue.mString);
         break;
       }
     case CSS_URI :
       {
         if (mValue.mURI) {
           nsAutoCString specUTF8;
           mValue.mURI->GetSpec(specUTF8);
           tmpStr.AssignLiteral("url(");
           nsStyleUtil::AppendEscapedCSSString(NS_ConvertUTF8toUTF16(specUTF8),
                                               tmpStr);
           tmpStr.AppendLiteral(")");
         } else {
           // http://dev.w3.org/csswg/css3-values/#attr defines
           // 'about:invalid' as the default value for url attributes,
           // so let's also use it here as the default computed value
           // for invalid URLs.
           tmpStr.Assign(NS_LITERAL_STRING("url(about:invalid)"));
         }
         break;
       }
     case CSS_ATTR :
       {
         tmpStr.AppendLiteral("attr(");
         tmpStr.Append(mValue.mString);
         tmpStr.Append(char16_t(')'));
         break;
       }
     case CSS_PERCENTAGE :
       {
         nsStyleUtil::AppendCSSNumber(mValue.mFloat * 100, tmpStr);
         tmpStr.Append(char16_t('%'));
         break;
       }
     case CSS_NUMBER :
       {
         nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
         break;
       }
     case CSS_NUMBER_INT32 :
       {
         tmpStr.AppendInt(mValue.mInt32);
         break;
       }
     case CSS_NUMBER_UINT32 :
       {
         tmpStr.AppendInt(mValue.mUint32);
         break;
       }
     case CSS_DEG :
       {
         nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
         tmpStr.AppendLiteral("deg");
         break;
       }
     case CSS_GRAD :
       {
         nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
         tmpStr.AppendLiteral("grad");
         break;
       }
     case CSS_RAD :
       {
         nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
         tmpStr.AppendLiteral("rad");
         break;
       }
     case CSS_TURN :
       {
         nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
         tmpStr.AppendLiteral("turn");
         break;
       }
     case CSS_RECT :
       {
         NS_ASSERTION(mValue.mRect, "mValue.mRect should never be null");
         NS_NAMED_LITERAL_STRING(comma, ", ");
         nsCOMPtr<nsIDOMCSSPrimitiveValue> sideCSSValue;
         nsAutoString sideValue;
         tmpStr.AssignLiteral("rect(");
         // get the top
         result = mValue.mRect->GetTop(getter_AddRefs(sideCSSValue));
         if (NS_FAILED(result))
           break;
         result = sideCSSValue->GetCssText(sideValue);
         if (NS_FAILED(result))
           break;
         tmpStr.Append(sideValue + comma);
         // get the right
         result = mValue.mRect->GetRight(getter_AddRefs(sideCSSValue));
         if (NS_FAILED(result))
           break;
         result = sideCSSValue->GetCssText(sideValue);
         if (NS_FAILED(result))
           break;
         tmpStr.Append(sideValue + comma);
         // get the bottom
         result = mValue.mRect->GetBottom(getter_AddRefs(sideCSSValue));
         if (NS_FAILED(result))
           break;
         result = sideCSSValue->GetCssText(sideValue);
         if (NS_FAILED(result))
           break;
         tmpStr.Append(sideValue + comma);
         // get the left
         result = mValue.mRect->GetLeft(getter_AddRefs(sideCSSValue));
         if (NS_FAILED(result))
           break;
         result = sideCSSValue->GetCssText(sideValue);
         if (NS_FAILED(result))
           break;
         tmpStr.Append(sideValue + NS_LITERAL_STRING(")"));
         break;
       }
     case CSS_RGBCOLOR :
       {
         NS_ASSERTION(mValue.mColor, "mValue.mColor should never be null");
         ErrorResult error;
         NS_NAMED_LITERAL_STRING(comma, ", ");
         nsAutoString colorValue;
         if (mValue.mColor->HasAlpha())
           tmpStr.AssignLiteral("rgba(");
         else
           tmpStr.AssignLiteral("rgb(");
         // get the red component
         mValue.mColor->Red()->GetCssText(colorValue, error);
         if (error.Failed())
           break;
         tmpStr.Append(colorValue + comma);
         // get the green component
         mValue.mColor->Green()->GetCssText(colorValue, error);
         if (error.Failed())
           break;
         tmpStr.Append(colorValue + comma);
         // get the blue component
         mValue.mColor->Blue()->GetCssText(colorValue, error);
         if (error.Failed())
           break;
         tmpStr.Append(colorValue);
         if (mValue.mColor->HasAlpha()) {
           // get the alpha component
           mValue.mColor->Alpha()->GetCssText(colorValue, error);
           if (error.Failed())
             break;
           tmpStr.Append(comma + colorValue);
         }
         tmpStr.Append(NS_LITERAL_STRING(")"));
         break;
       }
     case CSS_S :
       {
         nsStyleUtil::AppendCSSNumber(mValue.mFloat, tmpStr);
         tmpStr.AppendLiteral("s");
         break;
       }
     case CSS_CM :
     case CSS_MM :
     case CSS_IN :
     case CSS_PT :
     case CSS_PC :
     case CSS_UNKNOWN :
     case CSS_EMS :
     case CSS_EXS :
     case CSS_MS :
     case CSS_HZ :
     case CSS_KHZ :
     case CSS_DIMENSION :
       NS_ERROR("We have a bogus value set.  This should not happen");
       return NS_ERROR_DOM_INVALID_ACCESS_ERR;
   }
   if (NS_SUCCEEDED(result)) {
     aCssText.Assign(tmpStr);
   }
   return NS_OK;
 }
 void
 nsROCSSPrimitiveValue::GetCssText(nsString& aText, ErrorResult& aRv)
 {
   aRv = GetCssText(aText);
 }
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::SetCssText(const nsAString& aCssText)
 {
   return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
 }
 void
 nsROCSSPrimitiveValue::SetCssText(const nsAString& aText, ErrorResult& aRv)
 {
   aRv = SetCssText(aText);
 }
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::GetCssValueType(uint16_t* aValueType)
 {
   NS_ENSURE_ARG_POINTER(aValueType);
   *aValueType = nsIDOMCSSValue::CSS_PRIMITIVE_VALUE;
   return NS_OK;
 }
 uint16_t
 nsROCSSPrimitiveValue::CssValueType() const
 {
   return nsIDOMCSSValue::CSS_PRIMITIVE_VALUE;
 }
 // nsIDOMCSSPrimitiveValue
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::GetPrimitiveType(uint16_t* aPrimitiveType)
 {
   NS_ENSURE_ARG_POINTER(aPrimitiveType);
   *aPrimitiveType = PrimitiveType();
   return NS_OK;
 }
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::SetFloatValue(uint16_t aUnitType, float aFloatValue)
 {
   return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
 }
 void
 nsROCSSPrimitiveValue::SetFloatValue(uint16_t aType, float aVal,
                                      ErrorResult& aRv)
 {
   aRv = SetFloatValue(aType, aVal);
 }
 float
 nsROCSSPrimitiveValue::GetFloatValue(uint16_t aUnitType, ErrorResult& aRv)
 {
   switch(aUnitType) {
     case CSS_PX :
       if (mType == CSS_PX) {
         return nsPresContext::AppUnitsToFloatCSSPixels(mValue.mAppUnits);
       }
       break;
     case CSS_CM :
       if (mType == CSS_PX) {
         return mValue.mAppUnits * CM_PER_INCH_FLOAT /
           nsPresContext::AppUnitsPerCSSInch();
       }
       break;
     case CSS_MM :
       if (mType == CSS_PX) {
         return mValue.mAppUnits * MM_PER_INCH_FLOAT /
           nsPresContext::AppUnitsPerCSSInch();
       }
       break;
     case CSS_IN :
       if (mType == CSS_PX) {
         return mValue.mAppUnits / nsPresContext::AppUnitsPerCSSInch();
       }
       break;
     case CSS_PT :
       if (mType == CSS_PX) {
         return mValue.mAppUnits * POINTS_PER_INCH_FLOAT /
           nsPresContext::AppUnitsPerCSSInch();
       }
       break;
     case CSS_PC :
       if (mType == CSS_PX) {
         return mValue.mAppUnits * 6.0f /
           nsPresContext::AppUnitsPerCSSInch();
       }
       break;
     case CSS_PERCENTAGE :
       if (mType == CSS_PERCENTAGE) {
         return mValue.mFloat * 100;
       }
       break;
     case CSS_NUMBER :
       if (mType == CSS_NUMBER) {
         return mValue.mFloat;
       }
       if (mType == CSS_NUMBER_INT32) {
         return mValue.mInt32;
       }
       if (mType == CSS_NUMBER_UINT32) {
         return mValue.mUint32;
       }
       break;
     case CSS_UNKNOWN :
     case CSS_EMS :
     case CSS_EXS :
     case CSS_DEG :
     case CSS_RAD :
     case CSS_GRAD :
     case CSS_MS :
     case CSS_S :
     case CSS_HZ :
     case CSS_KHZ :
     case CSS_DIMENSION :
     case CSS_STRING :
     case CSS_URI :
     case CSS_IDENT :
     case CSS_ATTR :
     case CSS_COUNTER :
     case CSS_RECT :
     case CSS_RGBCOLOR :
       break;
   }
   aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
   return 0;
 }
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::GetFloatValue(uint16_t aType, float *aVal)
 {
   ErrorResult rv;
   *aVal = GetFloatValue(aType, rv);
   return rv.ErrorCode();
 }
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::SetStringValue(uint16_t aStringType,
                                       const nsAString& aStringValue)
 {
   return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
 }
 void
 nsROCSSPrimitiveValue::SetStringValue(uint16_t aType, const nsAString& aString,
                                       mozilla::ErrorResult& aRv)
 {
   aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
 }
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::GetStringValue(nsAString& aReturn)
 {
   switch (mType) {
     case CSS_IDENT:
       CopyUTF8toUTF16(nsCSSKeywords::GetStringValue(mValue.mKeyword), aReturn);
       break;
     case CSS_STRING:
     case CSS_ATTR:
       aReturn.Assign(mValue.mString);
       break;
     case CSS_URI: {
       nsAutoCString spec;
       if (mValue.mURI)
         mValue.mURI->GetSpec(spec);
       CopyUTF8toUTF16(spec, aReturn);
       } break;
     default:
       aReturn.Truncate();
       return NS_ERROR_DOM_INVALID_ACCESS_ERR;
   }
   return NS_OK;
 }
 void
 nsROCSSPrimitiveValue::GetStringValue(nsString& aString, ErrorResult& aRv)
 {
   aRv = GetStringValue(aString);
 }
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::GetCounterValue(nsIDOMCounter** aReturn)
 {
   return NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR;
 }
 already_AddRefed<nsIDOMCounter>
 nsROCSSPrimitiveValue::GetCounterValue(ErrorResult& aRv)
 {
   aRv.Throw(NS_ERROR_DOM_NO_MODIFICATION_ALLOWED_ERR);
   return nullptr;
 }
 nsDOMCSSRect*
 nsROCSSPrimitiveValue::GetRectValue(ErrorResult& aRv)
 {
   if (mType != CSS_RECT) {
     aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
     return nullptr;
   }
   NS_ASSERTION(mValue.mRect, "mValue.mRect should never be null");
   return mValue.mRect;
 }
 NS_IMETHODIMP
 nsROCSSPrimitiveValue::GetRectValue(nsIDOMRect** aRect)
 {
   ErrorResult error;
   NS_IF_ADDREF(*aRect = GetRectValue(error));
   return error.ErrorCode();
 }
 nsDOMCSSRGBColor*
 nsROCSSPrimitiveValue::GetRGBColorValue(ErrorResult& aRv)
 {
   if (mType != CSS_RGBCOLOR) {
     aRv.Throw(NS_ERROR_DOM_INVALID_ACCESS_ERR);
     return nullptr;
   }
   NS_ASSERTION(mValue.mColor, "mValue.mColor should never be null");
   return mValue.mColor;
 }
 void
 nsROCSSPrimitiveValue::SetNumber(float aValue)
 {
     Reset();
     mValue.mFloat = aValue;
     mType = CSS_NUMBER;
 }
 void
 nsROCSSPrimitiveValue::SetNumber(int32_t aValue)
 {
   Reset();
   mValue.mInt32 = aValue;
   mType = CSS_NUMBER_INT32;
 }
 void
 nsROCSSPrimitiveValue::SetNumber(uint32_t aValue)
 {
   Reset();
   mValue.mUint32 = aValue;
   mType = CSS_NUMBER_UINT32;
 }
 void
 nsROCSSPrimitiveValue::SetPercent(float aValue)
 {
   Reset();
   mValue.mFloat = aValue;
   mType = CSS_PERCENTAGE;
 }
 void
 nsROCSSPrimitiveValue::SetDegree(float aValue)
 {
   Reset();
   mValue.mFloat = aValue;
   mType = CSS_DEG;
 }
 void
 nsROCSSPrimitiveValue::SetGrad(float aValue)
 {
   Reset();
   mValue.mFloat = aValue;
   mType = CSS_GRAD;
 }
 void
 nsROCSSPrimitiveValue::SetRadian(float aValue)
 {
   Reset();
   mValue.mFloat = aValue;
   mType = CSS_RAD;
 }
 void
 nsROCSSPrimitiveValue::SetTurn(float aValue)
 {
   Reset();
   mValue.mFloat = aValue;
   mType = CSS_TURN;
 }
 void
 nsROCSSPrimitiveValue::SetAppUnits(nscoord aValue)
 {
   Reset();
   mValue.mAppUnits = aValue;
   mType = CSS_PX;
 }
 void
 nsROCSSPrimitiveValue::SetAppUnits(float aValue)
 {
   SetAppUnits(NSToCoordRound(aValue));
 }
 void
 nsROCSSPrimitiveValue::SetIdent(nsCSSKeyword aKeyword)
 {
   NS_PRECONDITION(aKeyword != eCSSKeyword_UNKNOWN &&
 <= aKeyword && aKeyword < eCSSKeyword_COUNT,
                   "bad keyword");
   Reset();
   mValue.mKeyword = aKeyword;
   mType = CSS_IDENT;
 }
 // FIXME: CSS_STRING should imply a string with "" and a need for escaping.
 void
 nsROCSSPrimitiveValue::SetString(const nsACString& aString, uint16_t aType)
 {
   Reset();
   mValue.mString = ToNewUnicode(aString);
   if (mValue.mString) {
     mType = aType;
   } else {
     // XXXcaa We should probably let the caller know we are out of memory
     mType = CSS_UNKNOWN;
   }
 }
 // FIXME: CSS_STRING should imply a string with "" and a need for escaping.
 void
 nsROCSSPrimitiveValue::SetString(const nsAString& aString, uint16_t aType)
 {
   Reset();
   mValue.mString = ToNewUnicode(aString);
   if (mValue.mString) {
     mType = aType;
   } else {
     // XXXcaa We should probably let the caller know we are out of memory
     mType = CSS_UNKNOWN;
   }
 }
 void
 nsROCSSPrimitiveValue::SetURI(nsIURI *aURI)
 {
   Reset();
   mValue.mURI = aURI;
   NS_IF_ADDREF(mValue.mURI);
   mType = CSS_URI;
 }
 void
 nsROCSSPrimitiveValue::SetColor(nsDOMCSSRGBColor* aColor)
 {
   NS_PRECONDITION(aColor, "Null RGBColor being set!");
   Reset();
   mValue.mColor = aColor;
   if (mValue.mColor) {
     NS_ADDREF(mValue.mColor);
     mType = CSS_RGBCOLOR;
   }
   else {
     mType = CSS_UNKNOWN;
   }
 }
 void
 nsROCSSPrimitiveValue::SetRect(nsDOMCSSRect* aRect)
 {
   NS_PRECONDITION(aRect, "Null rect being set!");
   Reset();
   mValue.mRect = aRect;
   if (mValue.mRect) {
     NS_ADDREF(mValue.mRect);
     mType = CSS_RECT;
   }
   else {
     mType = CSS_UNKNOWN;
   }
 }
 void
 nsROCSSPrimitiveValue::SetTime(float aValue)
 {
   Reset();
   mValue.mFloat = aValue;
   mType = CSS_S;
 }
 void
 nsROCSSPrimitiveValue::Reset()
 {
   switch (mType) {
     case CSS_IDENT:
       break;
     case CSS_STRING:
     case CSS_ATTR:
     case CSS_COUNTER: // FIXME: Counter should use an object
       NS_ASSERTION(mValue.mString, "Null string should never happen");
       nsMemory::Free(mValue.mString);
       mValue.mString = nullptr;
       break;
     case CSS_URI:
       NS_IF_RELEASE(mValue.mURI);
       break;
     case CSS_RECT:
       NS_ASSERTION(mValue.mRect, "Null Rect should never happen");
       NS_RELEASE(mValue.mRect);
       break;
     case CSS_RGBCOLOR:
       NS_ASSERTION(mValue.mColor, "Null RGBColor should never happen");
       NS_RELEASE(mValue.mColor);
       break;
   }
   mType = CSS_UNKNOWN;
 }

The Tor Browser / annotate

layout/style/nsROCSSPrimitiveValue.cpp@141e0f1194b1 (annotated)

layout/style/nsROCSSPrimitiveValue.cpp