Strip trailing whitespace in the WebCore/css C++ code.
authorapavlov@chromium.org <apavlov@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 19 Oct 2011 13:31:03 +0000 (13:31 +0000)
committerapavlov@chromium.org <apavlov@chromium.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Wed, 19 Oct 2011 13:31:03 +0000 (13:31 +0000)
https://bugs.webkit.org/show_bug.cgi?id=70410

Reviewed by Dirk Schulze.

Only affected file names retained below for brevity.
Multiline boolean expression were fixed where necessary to avoid patch style violations.

* css/CSSBorderImageSliceValue.cpp:
* css/CSSBorderImageSliceValue.h:
* css/CSSBorderImageValue.cpp:
* css/CSSCanvasValue.cpp:
* css/CSSCanvasValue.h:
* css/CSSComputedStyleDeclaration.cpp:
* css/CSSCursorImageValue.cpp:
* css/CSSFontFace.cpp:
* css/CSSFontFace.h:
* css/CSSFontFaceSource.cpp:
* css/CSSFontFaceSource.h:
* css/CSSFontFaceSrcValue.cpp:
* css/CSSFontFaceSrcValue.h:
* css/CSSFontSelector.cpp:
* css/CSSFontSelector.h:
* css/CSSFunctionValue.cpp:
* css/CSSFunctionValue.h:
* css/CSSGradientValue.cpp:
* css/CSSGradientValue.h:
* css/CSSImageGeneratorValue.cpp:
* css/CSSImageGeneratorValue.h:
* css/CSSImageValue.cpp:
* css/CSSImageValue.h:
* css/CSSImportRule.cpp:
* css/CSSInitialValue.cpp:
* css/CSSInitialValue.h:
* css/CSSMutableStyleDeclaration.cpp:
* css/CSSMutableStyleDeclaration.h:
* css/CSSParser.cpp:
* css/CSSParser.h:
* css/CSSParserValues.cpp:
* css/CSSParserValues.h:
* css/CSSPrimitiveValue.cpp:
* css/CSSPrimitiveValue.h:
* css/CSSPrimitiveValueCache.cpp:
* css/CSSPrimitiveValueCache.h:
* css/CSSPrimitiveValueMappings.h:
* css/CSSProperty.cpp:
* css/CSSProperty.h:
* css/CSSPropertyLonghand.cpp:
* css/CSSReflectValue.cpp:
* css/CSSReflectValue.h:
* css/CSSReflectionDirection.h:
* css/CSSSegmentedFontFace.cpp:
* css/CSSSegmentedFontFace.h:
* css/CSSSelector.cpp:
* css/CSSSelector.h:
* css/CSSSelectorList.cpp:
* css/CSSSelectorList.h:
* css/CSSStyleApplyProperty.cpp:
* css/CSSStyleDeclaration.h:
* css/CSSStyleSelector.cpp:
* css/CSSStyleSelector.h:
* css/CSSStyleSheet.cpp:
* css/CSSTimingFunctionValue.cpp:
* css/CSSTimingFunctionValue.h:
* css/CSSUnicodeRangeValue.cpp:
* css/CSSUnicodeRangeValue.h:
* css/CSSValueList.cpp:
* css/CSSWrapShapes.cpp:
* css/CSSWrapShapes.h:
* css/FontValue.cpp:
* css/MediaList.cpp:
* css/MediaQuery.cpp:
* css/MediaQuery.h:
* css/MediaQueryEvaluator.h:
* css/MediaQueryExp.cpp:
* css/MediaQueryExp.h:
* css/Pair.h:
* css/SVGCSSComputedStyleDeclaration.cpp:
* css/SVGCSSParser.cpp:
* css/SVGCSSStyleSelector.cpp:
* css/SelectorChecker.cpp:
* css/SelectorChecker.h:
* css/StyleBase.cpp:
* css/StyleMedia.cpp:
* css/StyleMedia.h:
* css/StyleSheetList.cpp:
* css/StyleSheetList.h:
* css/WebKitCSSFilterValue.cpp:
* css/WebKitCSSFilterValue.h:
* css/WebKitCSSKeyframeRule.cpp:
* css/WebKitCSSKeyframeRule.h:
* css/WebKitCSSKeyframesRule.cpp:
* css/WebKitCSSKeyframesRule.h:
* css/WebKitCSSMatrix.cpp:
* css/WebKitCSSMatrix.h:
* css/WebKitCSSTransformValue.cpp:
* css/WebKitCSSTransformValue.h:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@97854 268f45cc-cd09-0410-ab3c-d52691b4dbfc

90 files changed:
Source/WebCore/ChangeLog
Source/WebCore/css/CSSBorderImageSliceValue.cpp
Source/WebCore/css/CSSBorderImageSliceValue.h
Source/WebCore/css/CSSBorderImageValue.cpp
Source/WebCore/css/CSSCanvasValue.cpp
Source/WebCore/css/CSSCanvasValue.h
Source/WebCore/css/CSSComputedStyleDeclaration.cpp
Source/WebCore/css/CSSCursorImageValue.cpp
Source/WebCore/css/CSSFontFace.cpp
Source/WebCore/css/CSSFontFace.h
Source/WebCore/css/CSSFontFaceSource.cpp
Source/WebCore/css/CSSFontFaceSource.h
Source/WebCore/css/CSSFontFaceSrcValue.cpp
Source/WebCore/css/CSSFontFaceSrcValue.h
Source/WebCore/css/CSSFontSelector.cpp
Source/WebCore/css/CSSFontSelector.h
Source/WebCore/css/CSSFunctionValue.cpp
Source/WebCore/css/CSSFunctionValue.h
Source/WebCore/css/CSSGradientValue.cpp
Source/WebCore/css/CSSGradientValue.h
Source/WebCore/css/CSSImageGeneratorValue.cpp
Source/WebCore/css/CSSImageGeneratorValue.h
Source/WebCore/css/CSSImageValue.cpp
Source/WebCore/css/CSSImageValue.h
Source/WebCore/css/CSSImportRule.cpp
Source/WebCore/css/CSSInitialValue.cpp
Source/WebCore/css/CSSInitialValue.h
Source/WebCore/css/CSSMutableStyleDeclaration.cpp
Source/WebCore/css/CSSMutableStyleDeclaration.h
Source/WebCore/css/CSSParser.cpp
Source/WebCore/css/CSSParser.h
Source/WebCore/css/CSSParserValues.cpp
Source/WebCore/css/CSSParserValues.h
Source/WebCore/css/CSSPrimitiveValue.cpp
Source/WebCore/css/CSSPrimitiveValue.h
Source/WebCore/css/CSSPrimitiveValueCache.cpp
Source/WebCore/css/CSSPrimitiveValueCache.h
Source/WebCore/css/CSSPrimitiveValueMappings.h
Source/WebCore/css/CSSProperty.cpp
Source/WebCore/css/CSSProperty.h
Source/WebCore/css/CSSPropertyLonghand.cpp
Source/WebCore/css/CSSReflectValue.cpp
Source/WebCore/css/CSSReflectValue.h
Source/WebCore/css/CSSReflectionDirection.h
Source/WebCore/css/CSSSegmentedFontFace.cpp
Source/WebCore/css/CSSSegmentedFontFace.h
Source/WebCore/css/CSSSelector.cpp
Source/WebCore/css/CSSSelector.h
Source/WebCore/css/CSSSelectorList.cpp
Source/WebCore/css/CSSSelectorList.h
Source/WebCore/css/CSSStyleApplyProperty.cpp
Source/WebCore/css/CSSStyleDeclaration.h
Source/WebCore/css/CSSStyleSelector.cpp
Source/WebCore/css/CSSStyleSelector.h
Source/WebCore/css/CSSStyleSheet.cpp
Source/WebCore/css/CSSTimingFunctionValue.cpp
Source/WebCore/css/CSSTimingFunctionValue.h
Source/WebCore/css/CSSUnicodeRangeValue.cpp
Source/WebCore/css/CSSUnicodeRangeValue.h
Source/WebCore/css/CSSValueList.cpp
Source/WebCore/css/CSSWrapShapes.cpp
Source/WebCore/css/CSSWrapShapes.h
Source/WebCore/css/FontValue.cpp
Source/WebCore/css/MediaList.cpp
Source/WebCore/css/MediaQuery.cpp
Source/WebCore/css/MediaQuery.h
Source/WebCore/css/MediaQueryEvaluator.h
Source/WebCore/css/MediaQueryExp.cpp
Source/WebCore/css/MediaQueryExp.h
Source/WebCore/css/Pair.h
Source/WebCore/css/SVGCSSComputedStyleDeclaration.cpp
Source/WebCore/css/SVGCSSParser.cpp
Source/WebCore/css/SVGCSSStyleSelector.cpp
Source/WebCore/css/SelectorChecker.cpp
Source/WebCore/css/SelectorChecker.h
Source/WebCore/css/StyleBase.cpp
Source/WebCore/css/StyleMedia.cpp
Source/WebCore/css/StyleMedia.h
Source/WebCore/css/StyleSheetList.cpp
Source/WebCore/css/StyleSheetList.h
Source/WebCore/css/WebKitCSSFilterValue.cpp
Source/WebCore/css/WebKitCSSFilterValue.h
Source/WebCore/css/WebKitCSSKeyframeRule.cpp
Source/WebCore/css/WebKitCSSKeyframeRule.h
Source/WebCore/css/WebKitCSSKeyframesRule.cpp
Source/WebCore/css/WebKitCSSKeyframesRule.h
Source/WebCore/css/WebKitCSSMatrix.cpp
Source/WebCore/css/WebKitCSSMatrix.h
Source/WebCore/css/WebKitCSSTransformValue.cpp
Source/WebCore/css/WebKitCSSTransformValue.h

index 706f1fa3f95f4bbdd8fa072f38c451098bc3b62f..da8340ec8640423537bf8729bcb9e9f721fbcbc9 100644 (file)
@@ -1,3 +1,103 @@
+2011-10-19  Alexander Pavlov  <apavlov@chromium.org>
+
+        Strip trailing whitespace in the WebCore/css C++ code.
+        https://bugs.webkit.org/show_bug.cgi?id=70410
+
+        Reviewed by Dirk Schulze.
+
+        Only affected file names retained below for brevity.
+        Multiline boolean expression were fixed where necessary to avoid patch style violations.
+
+        * css/CSSBorderImageSliceValue.cpp:
+        * css/CSSBorderImageSliceValue.h:
+        * css/CSSBorderImageValue.cpp:
+        * css/CSSCanvasValue.cpp:
+        * css/CSSCanvasValue.h:
+        * css/CSSComputedStyleDeclaration.cpp:
+        * css/CSSCursorImageValue.cpp:
+        * css/CSSFontFace.cpp:
+        * css/CSSFontFace.h:
+        * css/CSSFontFaceSource.cpp:
+        * css/CSSFontFaceSource.h:
+        * css/CSSFontFaceSrcValue.cpp:
+        * css/CSSFontFaceSrcValue.h:
+        * css/CSSFontSelector.cpp:
+        * css/CSSFontSelector.h:
+        * css/CSSFunctionValue.cpp:
+        * css/CSSFunctionValue.h:
+        * css/CSSGradientValue.cpp:
+        * css/CSSGradientValue.h:
+        * css/CSSImageGeneratorValue.cpp:
+        * css/CSSImageGeneratorValue.h:
+        * css/CSSImageValue.cpp:
+        * css/CSSImageValue.h:
+        * css/CSSImportRule.cpp:
+        * css/CSSInitialValue.cpp:
+        * css/CSSInitialValue.h:
+        * css/CSSMutableStyleDeclaration.cpp:
+        * css/CSSMutableStyleDeclaration.h:
+        * css/CSSParser.cpp:
+        * css/CSSParser.h:
+        * css/CSSParserValues.cpp:
+        * css/CSSParserValues.h:
+        * css/CSSPrimitiveValue.cpp:
+        * css/CSSPrimitiveValue.h:
+        * css/CSSPrimitiveValueCache.cpp:
+        * css/CSSPrimitiveValueCache.h:
+        * css/CSSPrimitiveValueMappings.h:
+        * css/CSSProperty.cpp:
+        * css/CSSProperty.h:
+        * css/CSSPropertyLonghand.cpp:
+        * css/CSSReflectValue.cpp:
+        * css/CSSReflectValue.h:
+        * css/CSSReflectionDirection.h:
+        * css/CSSSegmentedFontFace.cpp:
+        * css/CSSSegmentedFontFace.h:
+        * css/CSSSelector.cpp:
+        * css/CSSSelector.h:
+        * css/CSSSelectorList.cpp:
+        * css/CSSSelectorList.h:
+        * css/CSSStyleApplyProperty.cpp:
+        * css/CSSStyleDeclaration.h:
+        * css/CSSStyleSelector.cpp:
+        * css/CSSStyleSelector.h:
+        * css/CSSStyleSheet.cpp:
+        * css/CSSTimingFunctionValue.cpp:
+        * css/CSSTimingFunctionValue.h:
+        * css/CSSUnicodeRangeValue.cpp:
+        * css/CSSUnicodeRangeValue.h:
+        * css/CSSValueList.cpp:
+        * css/CSSWrapShapes.cpp:
+        * css/CSSWrapShapes.h:
+        * css/FontValue.cpp:
+        * css/MediaList.cpp:
+        * css/MediaQuery.cpp:
+        * css/MediaQuery.h:
+        * css/MediaQueryEvaluator.h:
+        * css/MediaQueryExp.cpp:
+        * css/MediaQueryExp.h:
+        * css/Pair.h:
+        * css/SVGCSSComputedStyleDeclaration.cpp:
+        * css/SVGCSSParser.cpp:
+        * css/SVGCSSStyleSelector.cpp:
+        * css/SelectorChecker.cpp:
+        * css/SelectorChecker.h:
+        * css/StyleBase.cpp:
+        * css/StyleMedia.cpp:
+        * css/StyleMedia.h:
+        * css/StyleSheetList.cpp:
+        * css/StyleSheetList.h:
+        * css/WebKitCSSFilterValue.cpp:
+        * css/WebKitCSSFilterValue.h:
+        * css/WebKitCSSKeyframeRule.cpp:
+        * css/WebKitCSSKeyframeRule.h:
+        * css/WebKitCSSKeyframesRule.cpp:
+        * css/WebKitCSSKeyframesRule.h:
+        * css/WebKitCSSMatrix.cpp:
+        * css/WebKitCSSMatrix.h:
+        * css/WebKitCSSTransformValue.cpp:
+        * css/WebKitCSSTransformValue.h:
+
 2011-10-19  Dirk Schulze  <krit@webkit.org>
 
         Make FilterEffect::apply() independent of image data management
index 15fd93900285be2c702d167524ea77a9b12061fe..bce30aa72820cd668431e7a736432a664bbeb0f7 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -45,7 +45,7 @@ String CSSBorderImageSliceValue::cssText() const
 {
     // Dump the slices first.
     String text = m_slices->cssText();
-    
+
     // Now the fill keywords if it is present.
     if (m_fill)
         text += " fill";
index d74ead7464d5276a194621a632d5fe6f53c56d44..c6adbaa9dae392097827b14354d655ff97191e55 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSBorderImageSliceValue_h
index b7788f7ff827063e8e2f029b6b451544767332d5..825d0fbf68a81c5c014ddb3a67af331f65138049 100644 (file)
@@ -44,7 +44,7 @@ String CSSBorderImageValue::cssText() const
 {
     // Image first.
     String text;
-    
+
     if (m_image)
         text += m_image->cssText();
 
index 3473963c650d19bbbea5cf5b5d7e98ae8d73c4d6..76e77f6eab173cebebd5c0bc7ddd5451c631598b 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index 27b8f2b1fe8121b1c37fee88b5457870b595485b..6f389855e8ede1293a1ec1649e7ac7f8968ee74d 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSCanvasValue_h
@@ -57,7 +57,7 @@ private:
     virtual void canvasDestroyed(HTMLCanvasElement*);
 
     HTMLCanvasElement* element(Document*);
-     
+
     // The name of the canvas.
     String m_name;
     // The document supplies the element and owns it.
index 7768ff3a9a1f0727974852843009105dd036dd69..d085aeae2bc9092f8ce96a7b6e659845b03f13a5 100644 (file)
@@ -350,8 +350,8 @@ static PassRefPtr<CSSBorderImageSliceValue> valueForNinePieceImageSlice(const Ni
         top = primitiveValueCache->createValue(image.imageSlices().top().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
     else
         top = primitiveValueCache->createValue(image.imageSlices().top().value(), CSSPrimitiveValue::CSS_NUMBER);
-    
-    if (image.imageSlices().right() == image.imageSlices().top() && image.imageSlices().bottom() == image.imageSlices().top() 
+
+    if (image.imageSlices().right() == image.imageSlices().top() && image.imageSlices().bottom() == image.imageSlices().top()
         && image.imageSlices().left() == image.imageSlices().top()) {
         right = top;
         bottom = top;
@@ -361,7 +361,7 @@ static PassRefPtr<CSSBorderImageSliceValue> valueForNinePieceImageSlice(const Ni
             right = primitiveValueCache->createValue(image.imageSlices().right().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
         else
             right = primitiveValueCache->createValue(image.imageSlices().right().value(), CSSPrimitiveValue::CSS_NUMBER);
-            
+
         if (image.imageSlices().bottom() == image.imageSlices().top() && image.imageSlices().right() == image.imageSlices().left()) {
             bottom = top;
             left = right;
@@ -370,7 +370,7 @@ static PassRefPtr<CSSBorderImageSliceValue> valueForNinePieceImageSlice(const Ni
                 bottom = primitiveValueCache->createValue(image.imageSlices().bottom().value(), CSSPrimitiveValue::CSS_PERCENTAGE);
             else
                 bottom = primitiveValueCache->createValue(image.imageSlices().bottom().value(), CSSPrimitiveValue::CSS_NUMBER);
-            
+
             if (image.imageSlices().left() == image.imageSlices().right())
                 left = right;
             else {
@@ -413,7 +413,7 @@ static PassRefPtr<CSSPrimitiveValue> valueForNinePieceImageQuad(const LengthBox&
             right = primitiveValueCache->createValue(box.right().value(), CSSPrimitiveValue::CSS_NUMBER);
         else
             right = primitiveValueCache->createValue(box.right());
-        
+
         if (box.bottom() == box.top() && box.right() == box.left()) {
             bottom = top;
             left = right;
@@ -422,7 +422,7 @@ static PassRefPtr<CSSPrimitiveValue> valueForNinePieceImageQuad(const LengthBox&
                 bottom = primitiveValueCache->createValue(box.bottom().value(), CSSPrimitiveValue::CSS_NUMBER);
             else
                 bottom = primitiveValueCache->createValue(box.bottom());
-    
+
             if (box.left() == box.right())
                 left = right;
             else {
@@ -447,7 +447,7 @@ static PassRefPtr<CSSValue> valueForNinePieceImageRepeat(const NinePieceImage& i
 {
     RefPtr<CSSPrimitiveValue> horizontalRepeat;
     RefPtr<CSSPrimitiveValue> verticalRepeat;
-    
+
     horizontalRepeat = primitiveValueCache->createIdentifierValue(valueForRepeatRule(image.horizontalRule()));
     if (image.horizontalRule() == image.verticalRule())
         verticalRepeat = horizontalRepeat;
@@ -460,15 +460,15 @@ static PassRefPtr<CSSValue> valueForNinePieceImage(const NinePieceImage& image,
 {
     if (!image.hasImage())
         return primitiveValueCache->createIdentifierValue(CSSValueNone);
-    
+
     // Image first.
     RefPtr<CSSValue> imageValue;
     if (image.image())
         imageValue = image.image()->cssValue();
-    
+
     // Create the image slice.
     RefPtr<CSSBorderImageSliceValue> imageSlices = valueForNinePieceImageSlice(image, primitiveValueCache);
-    
+
     // Create the border area slices.
     RefPtr<CSSValue> borderSlices = valueForNinePieceImageQuad(image.borderSlices(), primitiveValueCache);
 
@@ -508,7 +508,7 @@ static PassRefPtr<CSSValue> valueForReflection(const StyleReflection* reflection
         offset = primitiveValueCache->createValue(reflection->offset().percent(), CSSPrimitiveValue::CSS_PERCENTAGE);
     else
         offset = zoomAdjustedPixelValue(reflection->offset().value(), style, primitiveValueCache);
-    
+
     return CSSReflectValue::create(reflection->direction(), offset.release(), valueForNinePieceImage(reflection->mask(), primitiveValueCache));
 }
 
@@ -582,7 +582,7 @@ static LayoutRect sizingBox(RenderObject* renderer)
 {
     if (!renderer->isBox())
         return LayoutRect();
-    
+
     RenderBox* box = toRenderBox(renderer);
     return box->style()->boxSizing() == CONTENT_BOX ? box->contentBoxRect() : box->borderBoxRect();
 }
@@ -596,7 +596,7 @@ static PassRefPtr<CSSValue> computedTransform(RenderObject* renderer, const Rend
 {
     if (!renderer || style->transform().operations().isEmpty())
         return primitiveValueCache->createIdentifierValue(CSSValueNone);
-    
+
     IntRect box = sizingBox(renderer);
 
     TransformationMatrix transform;
@@ -650,11 +650,11 @@ static PassRefPtr<CSSValue> computedFilter(RenderObject* renderer, const RenderS
 {
     if (!renderer || style->filter().operations().isEmpty())
         return primitiveValueCache->createIdentifierValue(CSSValueNone);
-    
+
     RefPtr<CSSValueList> list = CSSValueList::createSpaceSeparated();
 
     RefPtr<WebKitCSSFilterValue> filterValue;
-    
+
     Vector<RefPtr<FilterOperation> >::const_iterator end = style->filter().operations().end();
     for (Vector<RefPtr<FilterOperation> >::const_iterator it = style->filter().operations().begin(); it != end; ++it) {
         FilterOperation* filterOperation = (*it).get();
@@ -730,7 +730,7 @@ static PassRefPtr<CSSValue> computedFilter(RenderObject* renderer, const RenderS
         }
         list->append(filterValue);
     }
-    
+
     return list.release();
 }
 #endif
@@ -851,7 +851,7 @@ PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getFontSizeCSSValuePreferringK
     RefPtr<RenderStyle> style = m_node->computedStyle(m_pseudoElementSpecifier);
     if (!style)
         return 0;
-    
+
     CSSPrimitiveValueCache* primitiveValueCache = m_node->document()->cssPrimitiveValueCache().get();
 
     if (int keywordSize = style->fontDescription().keywordSize())
@@ -1016,7 +1016,7 @@ static void logUnimplementedPropertyID(int propertyID)
         return;
 
     LOG_ERROR("WebKit does not yet implement getComputedStyle for '%s'.", getPropertyName(static_cast<CSSPropertyID>(propertyID)));
-} 
+}
 
 static PassRefPtr<CSSValueList> fontFamilyFromStyle(RenderStyle* style, CSSPrimitiveValueCache* primitiveValueCache)
 {
@@ -1110,7 +1110,7 @@ PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int proper
 
     if (!style)
         return 0;
-    
+
     CSSPrimitiveValueCache* primitiveValueCache = node->document()->cssPrimitiveValueCache().get();
 
     propertyID = CSSProperty::resolveDirectionAwareProperty(propertyID, style->direction(), style->writingMode());
@@ -1204,7 +1204,7 @@ PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int proper
                 EFillBox box = isClip ? layers->clip() : layers->origin();
                 return primitiveValueCache->createValue(box);
             }
-            
+
             RefPtr<CSSValueList> list = CSSValueList::createCommaSeparated();
             for (const FillLayer* currLayer = layers; currLayer; currLayer = currLayer->next()) {
                 EFillBox box = isClip ? currLayer->clip() : currLayer->origin();
@@ -1266,7 +1266,7 @@ PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int proper
             list->append(zoomAdjustedPixelValue(style->horizontalBorderSpacing(), style.get(), primitiveValueCache));
             list->append(zoomAdjustedPixelValue(style->verticalBorderSpacing(), style.get(), primitiveValueCache));
             return list.release();
-        }  
+        }
         case CSSPropertyWebkitBorderHorizontalSpacing:
             return zoomAdjustedPixelValue(style->horizontalBorderSpacing(), style.get(), primitiveValueCache);
         case CSSPropertyWebkitBorderVerticalSpacing:
@@ -1887,7 +1887,7 @@ PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int proper
             else {
                 list->append(zoomAdjustedPixelValueForLength(style->perspectiveOriginX(), style.get(), primitiveValueCache));
                 list->append(zoomAdjustedPixelValueForLength(style->perspectiveOriginY(), style.get(), primitiveValueCache));
-                
+
             }
             return list.release();
         }
@@ -1896,7 +1896,7 @@ PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getPropertyCSSValue(int proper
 #if ENABLE(TOUCH_EVENTS)
         case CSSPropertyWebkitTapHighlightColor:
             return currentColorOrValidColor(style.get(), style->tapHighlightColor());
-#endif            
+#endif
         case CSSPropertyWebkitUserDrag:
             return primitiveValueCache->createValue(style->userDrag());
         case CSSPropertyWebkitUserSelect:
index db92a7512fcef7a1b2409677b93644e752799162..24ef8ffc29ac8c5287cbb620ca8eeee115126a10 100644 (file)
@@ -17,7 +17,7 @@
  * along with this library; see the file COPYING.LIB.  If not, write to
  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  * Boston, MA 02110-1301, USA.
- */ 
+ */
 
 #include "config.h"
 #include "CSSCursorImageValue.h"
@@ -116,7 +116,7 @@ StyleCachedImage* CSSCursorImageValue::cachedImage(CachedResourceLoader* loader)
 {
     String url = getStringValue();
 
-#if ENABLE(SVG) 
+#if ENABLE(SVG)
     if (isSVGCursorIdentifier(url) && loader && loader->document()) {
         // FIXME: This will fail if the <cursor> element is in a shadow DOM (bug 59827)
         if (SVGCursorElement* cursorElement = resourceReferencedByCursorElement(url, loader->document()))
index 2c50a0472a19f047651d8f58f231ef270d05c679..7b1b70fd9185cd7b5c64c652915df3630e00f108 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index 55e048c9e144c8f8c9ee863903bfa6cde2b3fce7..85023a3a3e288763e72451ae5dbaef6e0fdbad2f 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSFontFace_h
index 970189ae3060cadecac8752617d62e1bdf973475..5d1b12aebdc563eedcff9cee60a832a6c3974873 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -215,8 +215,8 @@ SVGFontFaceElement* CSSFontFaceSource::svgFontFaceElement() const
     return m_svgFontFaceElement.get();
 }
 
-void CSSFontFaceSource::setSVGFontFaceElement(PassRefPtr<SVGFontFaceElement> element) 
-{ 
+void CSSFontFaceSource::setSVGFontFaceElement(PassRefPtr<SVGFontFaceElement> element)
+{
     m_svgFontFaceElement = element;
 }
 
index 703daeb73630bdb59ccef6ba44097a0d52f57c1f..99db592158af4d8f7d90f9191f57b6eccc2b8f28 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSFontFaceSource_h
@@ -58,9 +58,9 @@ public:
     void setFontFace(CSSFontFace* face) { m_face = face; }
 
     virtual void fontLoaded(CachedFont*);
-    
+
     SimpleFontData* getFontData(const FontDescription&, bool syntheticBold, bool syntheticItalic, CSSFontSelector*);
-    
+
     void pruneTable();
 
 #if ENABLE(SVG_FONTS)
index 03edbcb3eef54905cba0f3099fdf1b2c44e7144a..5b4c3115443cd842ffcb7cf9fcaa960fc957c1fb 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index a6c8bb9687ffa23eea74b03f8cdff3c8e38ef62b..baefb62474a8a5817a313833670b71915c6ecb4e 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSFontFaceSrcValue_h
index 5665f1dec3006352edfad5caa66dfbbf5117304f..58e2131763ffed203705679b06d095fad8e0bc04 100644 (file)
@@ -21,7 +21,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index 61baa9fb812e28eba3ea7d1855e5d651d0eceb6d..e7ea02b158c72f480d6bd13f254666017742c9db 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSFontSelector_h
@@ -51,7 +51,7 @@ public:
     virtual ~CSSFontSelector();
 
     virtual FontData* getFontData(const FontDescription& fontDescription, const AtomicString& familyName);
-    
+
     void clearDocument() { m_document = 0; }
 
     void addFontFaceRule(const CSSFontFaceRule*);
index 52a29534626ce31f31a01da88c97c6fd983be930..d33f204678a3de7bb6f2ded35c2eb96dcfd41509 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index be382065a8ac967f09451e04fd4dc4b399f0661c..0a187a9476fd17254031b257af6048471b0cc86d 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSFunctionValue_h
@@ -41,12 +41,12 @@ public:
     }
 
     virtual ~CSSFunctionValue();
-    
+
     virtual String cssText() const;
 
 private:
     explicit CSSFunctionValue(CSSParserFunction*);
-    
+
     String m_name;
     RefPtr<CSSValueList> m_args;
 };
index 266e4e910c2856e6386103edc1ae31d0247940c4..cda14fb1eb47254569523e2bf87e8d7200a1bb82 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -56,7 +56,7 @@ PassRefPtr<Image> CSSGradientValue::image(RenderObject* renderer, const IntSize&
         if (result)
             return result;
     }
-    
+
     // We need to create an image.
     RefPtr<Image> newImage = GeneratedImage::create(createGradient(renderer, size), size);
     if (cacheable)
@@ -70,7 +70,7 @@ static inline bool compareStops(const CSSGradientColorStop& a, const CSSGradient
 {
     double aVal = a.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER);
     double bVal = b.m_position->getDoubleValue(CSSPrimitiveValue::CSS_NUMBER);
-    
+
     return aVal < bVal;
 }
 
@@ -85,7 +85,7 @@ void CSSGradientValue::sortStopsIfNeeded()
 }
 
 static inline int blend(int from, int to, float progress)
-{  
+{
     return int(from + (to - from) * progress);
 }
 
@@ -102,7 +102,7 @@ struct GradientStop {
     Color color;
     float offset;
     bool specified;
-    
+
     GradientStop()
         : offset(0)
         , specified(false)
@@ -112,7 +112,7 @@ struct GradientStop {
 void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, RenderStyle* rootStyle, float maxLengthForRepeat)
 {
     RenderStyle* style = renderer->style();
-    
+
     if (m_deprecatedType) {
         sortStopsIfNeeded();
 
@@ -126,7 +126,7 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
                 offset = stop.m_position->getFloatValue(CSSPrimitiveValue::CSS_PERCENTAGE) / 100;
             else
                 offset = stop.m_position->getFloatValue(CSSPrimitiveValue::CSS_NUMBER);
-            
+
             gradient->addColorStop(offset, color);
         }
 
@@ -136,19 +136,19 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
     }
 
     size_t numStops = m_stops.size();
-    
+
     Vector<GradientStop> stops(numStops);
-    
+
     float gradientLength = 0;
     bool computedGradientLength = false;
-    
+
     FloatPoint gradientStart = gradient->p0();
     FloatPoint gradientEnd;
     if (isLinearGradient())
         gradientEnd = gradient->p1();
     else if (isRadialGradient())
         gradientEnd = gradientStart + FloatSize(gradient->endRadius(), 0);
-        
+
     for (size_t i = 0; i < numStops; ++i) {
         const CSSGradientColorStop& stop = m_stops[i];
 
@@ -191,14 +191,14 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
                 if (stops[prevSpecifiedIndex].specified)
                     break;
             }
-            
+
             if (stops[i].offset < stops[prevSpecifiedIndex].offset)
                 stops[i].offset = stops[prevSpecifiedIndex].offset;
         }
     }
 
     ASSERT(stops[0].specified && stops[numStops - 1].specified);
-    
+
     // If any color-stop still does not have a position, then, for each run of adjacent
     // color-stops without positions, set their positions so that they are evenly spaced
     // between the preceding and following color-stops with positions.
@@ -217,7 +217,7 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
                     float lastSpecifiedOffset = stops[unspecifiedRunStart - 1].offset;
                     float nextSpecifiedOffset = stops[unspecifiedRunEnd].offset;
                     float delta = (nextSpecifiedOffset - lastSpecifiedOffset) / (unspecifiedRunEnd - unspecifiedRunStart + 1);
-                    
+
                     for (size_t j = unspecifiedRunStart; j < unspecifiedRunEnd; ++j)
                         stops[j].offset = lastSpecifiedOffset + (j - unspecifiedRunStart + 1) * delta;
                 }
@@ -249,7 +249,7 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
                     FloatSize gradientSize(gradientStart - gradientEnd);
                     gradientLength = gradientSize.diagonalLength();
                 }
-                
+
                 if (maxLengthForRepeat > gradientLength)
                     maxExtent = maxLengthForRepeat / gradientLength;
             }
@@ -262,7 +262,7 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
             if (firstOffset > 0) {
                 float currOffset = firstOffset;
                 size_t srcStopOrdinal = originalNumStops - 1;
-                
+
                 while (true) {
                     GradientStop newStop = stops[originalFirstStopIndex + srcStopOrdinal];
                     newStop.offset = currOffset;
@@ -276,7 +276,7 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
                     srcStopOrdinal = (srcStopOrdinal + originalNumStops - 1) % originalNumStops;
                 }
             }
-            
+
             // Work forwards from the end, adding stops until we get one after 1.
             float lastOffset = stops[stops.size() - 1].offset;
             if (lastOffset < maxExtent) {
@@ -297,9 +297,9 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
             }
         }
     }
-    
+
     numStops = stops.size();
-    
+
     // If the gradient goes outside the 0-1 range, normalize it by moving the endpoints, and adjusting the stops.
     if (numStops > 1 && (stops[0].offset < 0 || stops[numStops - 1].offset > 1)) {
         if (isLinearGradient()) {
@@ -328,12 +328,12 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
                     break;
                 }
             }
-            
+
             if (firstZeroOrGreaterIndex > 0) {
                 if (firstZeroOrGreaterIndex < numStops && stops[firstZeroOrGreaterIndex].offset > 0) {
                     float prevOffset = stops[firstZeroOrGreaterIndex - 1].offset;
                     float nextOffset = stops[firstZeroOrGreaterIndex].offset;
-                    
+
                     float interStopProportion = -prevOffset / (nextOffset - prevOffset);
                     Color blendedColor = blend(stops[firstZeroOrGreaterIndex - 1].color, stops[firstZeroOrGreaterIndex].color, interStopProportion);
 
@@ -348,15 +348,15 @@ void CSSGradientValue::addStops(Gradient* gradient, RenderObject* renderer, Rend
                         stops[i].offset = 0;
                 }
             }
-            
+
             for (size_t i = 0; i < numStops; ++i)
                 stops[i].offset /= scale;
-            
+
             gradient->setStartRadius(gradient->startRadius() * scale);
             gradient->setEndRadius(gradient->endRadius() * scale);
         }
     }
-    
+
     for (unsigned i = 0; i < numStops; i++)
         gradient->addColorStop(stops[i].offset, stops[i].color);
 
@@ -404,7 +404,7 @@ FloatPoint CSSGradientValue::computeEndPoint(CSSPrimitiveValue* first, CSSPrimit
 
     if (second)
         result.setY(positionFromValue(second, style, rootStyle, size, false));
-        
+
     return result;
 }
 
@@ -424,7 +424,7 @@ bool CSSGradientValue::isCacheable() const
         if (unitType == CSSPrimitiveValue::CSS_EMS || unitType == CSSPrimitiveValue::CSS_EXS || unitType == CSSPrimitiveValue::CSS_REMS)
             return false;
     }
-    
+
     return true;
 }
 
@@ -483,13 +483,13 @@ static void endPointsFromAngle(float angleDeg, const IntSize& size, FloatPoint&
     angleDeg = fmodf(angleDeg, 360);
     if (angleDeg < 0)
         angleDeg += 360;
-    
+
     if (!angleDeg) {
         firstPoint.set(0, 0);
         secondPoint.set(size.width(), 0);
         return;
     }
-    
+
     if (angleDeg == 90) {
         firstPoint.set(0, size.height());
         secondPoint.set(0, 0);
@@ -501,7 +501,7 @@ static void endPointsFromAngle(float angleDeg, const IntSize& size, FloatPoint&
         secondPoint.set(0, 0);
         return;
     }
-    
+
     if (angleDeg == 270) {
         firstPoint.set(0, 0);
         secondPoint.set(0, size.height());
@@ -513,7 +513,7 @@ static void endPointsFromAngle(float angleDeg, const IntSize& size, FloatPoint&
     // We find the endpoint by computing the intersection of the line formed by the slope,
     // and a line perpendicular to it that intersects the corner.
     float perpendicularSlope = -1 / slope;
-    
+
     // Compute start corner relative to center.
     float halfHeight = size.height() / 2;
     float halfWidth = size.width() / 2;
@@ -531,7 +531,7 @@ static void endPointsFromAngle(float angleDeg, const IntSize& size, FloatPoint&
     float c = endCorner.y() - perpendicularSlope * endCorner.x();
     float endX = c / (slope - perpendicularSlope);
     float endY = perpendicularSlope * endX + c;
-    
+
     // We computed the end point, so set the second point, flipping the Y to account for angles going anticlockwise.
     secondPoint.set(halfWidth + endX, size.height() - (halfHeight + endY));
     // Reflect around the center for the start point.
@@ -541,7 +541,7 @@ static void endPointsFromAngle(float angleDeg, const IntSize& size, FloatPoint&
 PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(RenderObject* renderer, const IntSize& size)
 {
     ASSERT(!size.isEmpty());
-    
+
     RenderStyle* rootStyle = renderer->document()->documentElement()->renderStyle();
 
     FloatPoint firstPoint;
@@ -551,7 +551,7 @@ PassRefPtr<Gradient> CSSLinearGradientValue::createGradient(RenderObject* render
         endPointsFromAngle(angle, size, firstPoint, secondPoint);
     } else {
         firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);
-        
+
         if (m_secondX || m_secondY)
             secondPoint = computeEndPoint(m_secondX.get(), m_secondY.get(), renderer->style(), rootStyle, size);
         else {
@@ -650,7 +650,7 @@ float CSSRadialGradientValue::resolveRadius(CSSPrimitiveValue* radius, RenderSty
         result = *widthOrHeight * radius->getFloatValue() / 100;
     else
         result = radius->computeLength<float>(style, rootStyle, zoomFactor);
+
     return result;
 }
 
@@ -734,7 +734,7 @@ static inline float horizontalEllipseRadius(const FloatSize& p, float aspectRati
 PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderObject* renderer, const IntSize& size)
 {
     ASSERT(!size.isEmpty());
-    
+
     RenderStyle* rootStyle = renderer->document()->documentElement()->renderStyle();
 
     FloatPoint firstPoint = computeEndPoint(m_firstX.get(), m_firstY.get(), renderer->style(), rootStyle, size);
@@ -748,7 +748,7 @@ PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderObject* render
         secondPoint.setX(size.width() / 2);
     if (!m_secondY)
         secondPoint.setY(size.height() / 2);
-    
+
     float firstRadius = 0;
     if (m_firstRadius)
         firstRadius = resolveRadius(m_firstRadius.get(), renderer->style(), rootStyle);
@@ -767,10 +767,10 @@ PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderObject* render
         GradientShape shape = Ellipse;
         if (m_shape && m_shape->primitiveType() == CSSPrimitiveValue::CSS_IDENT && m_shape->getIdent() == CSSValueCircle)
             shape = Circle;
-        
+
         enum GradientFill { ClosestSide, ClosestCorner, FarthestSide, FarthestCorner };
         GradientFill fill = FarthestCorner;
-        
+
         if (m_sizingBehavior && m_sizingBehavior->primitiveType() == CSSPrimitiveValue::CSS_IDENT) {
             switch (m_sizingBehavior->getIdent()) {
             case CSSValueContain:
@@ -789,9 +789,9 @@ PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderObject* render
                 break;
             }
         }
-        
+
         // Now compute the end radii based on the second point, shape and fill.
-        
+
         // Horizontal
         switch (fill) {
         case ClosestSide: {
@@ -828,7 +828,7 @@ PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderObject* render
                 // that it would if closest-side or farthest-side were specified, as appropriate.
                 float xDist = min(secondPoint.x(), size.width() - secondPoint.x());
                 float yDist = min(secondPoint.y(), size.height() - secondPoint.y());
-                
+
                 secondRadius = horizontalEllipseRadius(corner - secondPoint, xDist / yDist);
                 aspectRatio = xDist / yDist;
             }
@@ -845,7 +845,7 @@ PassRefPtr<Gradient> CSSRadialGradientValue::createGradient(RenderObject* render
                 // that it would if closest-side or farthest-side were specified, as appropriate.
                 float xDist = max(secondPoint.x(), size.width() - secondPoint.x());
                 float yDist = max(secondPoint.y(), size.height() - secondPoint.y());
-                
+
                 secondRadius = horizontalEllipseRadius(corner - secondPoint, xDist / yDist);
                 aspectRatio = xDist / yDist;
             }
index b19548e72c00dc695a6b7d9c2282b0a8dc25782b..44ee1c85d87890c0236218a796f9e0dae9cf93af 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSGradientValue_h
@@ -52,16 +52,16 @@ public:
     void setFirstY(PassRefPtr<CSSPrimitiveValue> val) { m_firstY = val; }
     void setSecondX(PassRefPtr<CSSPrimitiveValue> val) { m_secondX = val; }
     void setSecondY(PassRefPtr<CSSPrimitiveValue> val) { m_secondY = val; }
-    
+
     void addStop(const CSSGradientColorStop& stop) { m_stops.append(stop); }
 
     Vector<CSSGradientColorStop>& stops() { return m_stops; }
 
     void sortStopsIfNeeded();
-    
+
     virtual bool isLinearGradient() const { return false; }
     virtual bool isRadialGradient() const { return false; }
-    
+
     bool isRepeating() const { return m_repeating; }
 
     bool deprecatedType() const { return m_deprecatedType; } // came from -webkit-gradient
@@ -73,7 +73,7 @@ protected:
         , m_repeating(repeat == Repeating)
     {
     }
-    
+
     void addStops(Gradient*, RenderObject*, RenderStyle* rootStyle, float maxLengthForRepeat = 0);
 
     // Create the gradient for a given size.
@@ -81,16 +81,16 @@ protected:
 
     // Resolve points/radii to front end values.
     FloatPoint computeEndPoint(CSSPrimitiveValue*, CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, const IntSize&);
-    
+
     bool isCacheable() const;
 
     // Points. Some of these may be null for linear gradients.
     RefPtr<CSSPrimitiveValue> m_firstX;
     RefPtr<CSSPrimitiveValue> m_firstY;
-    
+
     RefPtr<CSSPrimitiveValue> m_secondX;
     RefPtr<CSSPrimitiveValue> m_secondY;
-    
+
     // Stops
     Vector<CSSGradientColorStop> m_stops;
     bool m_stopsSorted;
@@ -152,10 +152,10 @@ private:
 
     // Create the gradient for a given size.
     virtual PassRefPtr<Gradient> createGradient(RenderObject*, const IntSize&);
-    
+
     // Resolve points/radii to front end values.
     float resolveRadius(CSSPrimitiveValue*, RenderStyle*, RenderStyle* rootStyle, float* widthOrHeight = 0);
-    
+
     // These may be null for non-deprecated gradients.
     RefPtr<CSSPrimitiveValue> m_firstRadius;
     RefPtr<CSSPrimitiveValue> m_secondRadius;
index cf18f6a3ec0f37fd53d0ea469f6c682fc89621c4..48fdeb7900106c23eb1011356b7bbc96cda121ad 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index a53c965ac1370053d9ae5e0297cb892ef293c9d1..fe391f53531fd2e12a8feaa69fa5194d51db66b6 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSImageGeneratorValue_h
@@ -44,13 +44,13 @@ public:
     virtual PassRefPtr<Image> image(RenderObject*, const IntSize&) = 0;
 
     StyleGeneratedImage* generatedImage();
-    
+
     virtual bool isFixedSize() const { return false; }
     virtual IntSize fixedSize(const RenderObject*) { return IntSize(); }
-    
+
 protected:
     CSSImageGeneratorValue();
-    
+
     Image* getImage(RenderObject*, const IntSize&);
     void putImage(const IntSize&, PassRefPtr<Image>);
     const RenderObjectSizeCountMap& clients() const { return m_imageCache.clients(); }
index ffc6763376c4ae443d6e2d351a59b09794631d66..0836b625182249c962b384c0903da3e805368fc1 100644 (file)
@@ -78,7 +78,7 @@ StyleCachedImage* CSSImageValue::cachedImage(CachedResourceLoader* loader, const
             m_image = StyleCachedImage::create(cachedImage);
         }
     }
-    
+
     return (m_image && m_image->isCachedImage()) ? static_cast<StyleCachedImage*>(m_image.get()) : 0;
 }
 
index 645a17358e7fff70edc4a2ef8a3e9d32367eef93..7091eabce64dbed9a39fe5ef379213dd34473645 100644 (file)
@@ -41,7 +41,7 @@ public:
     virtual StyleCachedImage* cachedImage(CachedResourceLoader*);
     // Returns a StyleCachedImage if the image is cached already, otherwise a StylePendingImage.
     StyleImage* cachedOrPendingImage();
-    
+
 protected:
     CSSImageValue(const String& url);
 
index ada91f0f70efd868dbe8c3346c9d957475d6674a..061486ba0afac10af7d2bb7a9f1662b8e8c4bccf 100644 (file)
@@ -128,7 +128,7 @@ void CSSImportRule::insertedIntoParent()
     // in our parent chain with the same URL, then just bail.
     StyleBase* root = this;
     for (StyleBase* curr = parent(); curr; curr = curr->parent()) {
-        // FIXME: This is wrong if the finalURL was updated via document::updateBaseURL. 
+        // FIXME: This is wrong if the finalURL was updated via document::updateBaseURL.
         if (curr->isCSSStyleSheet() && absHref == static_cast<CSSStyleSheet*>(curr)->finalURL().string())
             return;
         root = curr;
index cbe776b0dcc89cc5de4ccc3202f5bc8b86808261..0d0c55cc4db33da7d358410397d2ddae4dcfc3e0 100644 (file)
@@ -26,8 +26,8 @@
 namespace WebCore {
 
 unsigned short CSSInitialValue::cssValueType() const
-{ 
-    return CSS_INITIAL; 
+{
+    return CSS_INITIAL;
 }
 
 String CSSInitialValue::cssText() const
index 9ee2f2919ab2fd4fd2890e49ee90ee193e9db0aa..01bb63d9b413e5e654a818c5f898e206d3042db1 100644 (file)
@@ -40,7 +40,7 @@ public:
     }
 
     virtual String cssText() const;
-        
+
 private:
     CSSInitialValue(bool implicit)
         : m_implicit(implicit)
index 1e6fe219ce90bf26bed95671e130a9d2ae878df7..58dca9dacc455493d14699176c6d1aaee8421162 100644 (file)
@@ -107,7 +107,7 @@ CSSMutableStyleDeclaration::~CSSMutableStyleDeclaration()
         static_cast<CSSMutableValue*>(value)->setNode(0);
     }
 }
+
 CSSMutableStyleDeclaration& CSSMutableStyleDeclaration::operator=(const CSSMutableStyleDeclaration& other)
 {
     ASSERT(!m_iteratorCount);
@@ -140,14 +140,14 @@ String CSSMutableStyleDeclaration::getPropertyValue(int propertyID) const
         }
         case CSSPropertyBackground: {
             const int properties[9] = { CSSPropertyBackgroundColor,
-                                        CSSPropertyBackgroundImage, 
-                                        CSSPropertyBackgroundRepeatX, 
-                                        CSSPropertyBackgroundRepeatY, 
-                                        CSSPropertyBackgroundAttachment, 
-                                        CSSPropertyBackgroundPositionX, 
-                                        CSSPropertyBackgroundPositionY, 
+                                        CSSPropertyBackgroundImage,
+                                        CSSPropertyBackgroundRepeatX,
+                                        CSSPropertyBackgroundRepeatY,
+                                        CSSPropertyBackgroundAttachment,
+                                        CSSPropertyBackgroundPositionX,
+                                        CSSPropertyBackgroundPositionY,
                                         CSSPropertyBackgroundClip,
-                                        CSSPropertyBackgroundOrigin }; 
+                                        CSSPropertyBackgroundOrigin };
             return getLayeredShorthandValue(properties);
         }
         case CSSPropertyBorder: {
@@ -243,7 +243,7 @@ String CSSMutableStyleDeclaration::getPropertyValue(int propertyID) const
             return getLayeredShorthandValue(properties);
         }
         case CSSPropertyWebkitMask: {
-            const int properties[] = { CSSPropertyWebkitMaskImage, CSSPropertyWebkitMaskRepeat, 
+            const int properties[] = { CSSPropertyWebkitMaskImage, CSSPropertyWebkitMaskRepeat,
                                        CSSPropertyWebkitMaskAttachment, CSSPropertyWebkitMaskPosition, CSSPropertyWebkitMaskClip,
                                        CSSPropertyWebkitMaskOrigin };
             return getLayeredShorthandValue(properties);
@@ -327,7 +327,7 @@ String CSSMutableStyleDeclaration::getLayeredShorthandValue(const int* propertie
     // Begin by collecting the properties into an array.
     Vector< RefPtr<CSSValue> > values(size);
     size_t numLayers = 0;
-    
+
     for (size_t i = 0; i < size; ++i) {
         values[i] = getPropertyCSSValue(properties[i]);
         if (values[i]) {
@@ -338,7 +338,7 @@ String CSSMutableStyleDeclaration::getLayeredShorthandValue(const int* propertie
                 numLayers = max<size_t>(1U, numLayers);
         }
     }
-    
+
     // Now stitch the properties together.  Implicit initial values are flagged as such and
     // can safely be omitted.
     for (size_t i = 0; i < numLayers; i++) {
@@ -353,7 +353,7 @@ String CSSMutableStyleDeclaration::getLayeredShorthandValue(const int* propertie
                     value = static_cast<CSSValueList*>(values[j].get())->item(i);
                 else {
                     value = values[j];
-                    
+
                     // Color only belongs in the last layer.
                     if (properties[j] == CSSPropertyBackgroundColor) {
                         if (i != numLayers - 1)
@@ -365,7 +365,7 @@ String CSSMutableStyleDeclaration::getLayeredShorthandValue(const int* propertie
 
             // We need to report background-repeat as it was written in the CSS. If the property is implicit,
             // then it was written with only one value. Here we figure out which value that was so we can
-            // report back correctly. 
+            // report back correctly.
             if (properties[j] == CSSPropertyBackgroundRepeatX && isPropertyImplicit(properties[j])) {
 
                 // BUG 49055: make sure the value was not reset in the layer check just above.
@@ -376,7 +376,7 @@ String CSSMutableStyleDeclaration::getLayeredShorthandValue(const int* propertie
                         yValue = static_cast<CSSValueList*>(nextValue.get())->itemWithoutBoundsCheck(i);
                     else
                         yValue = nextValue;
-                        
+
                     int xId = static_cast<CSSPrimitiveValue*>(value.get())->getIdent();
                     int yId = static_cast<CSSPrimitiveValue*>(yValue.get())->getIdent();
                     if (xId != yId) {
@@ -393,7 +393,7 @@ String CSSMutableStyleDeclaration::getLayeredShorthandValue(const int* propertie
                     }
                 }
             }
-            
+
             if (value && !value->isImplicitInitialValue()) {
                 if (!layerRes.isNull())
                     layerRes += " ";
@@ -410,7 +410,7 @@ String CSSMutableStyleDeclaration::getLayeredShorthandValue(const int* propertie
                     layerRes += value->cssText();
             }
         }
-        
+
         if (!layerRes.isNull()) {
             if (!res.isNull())
                 res += ", ";
@@ -463,7 +463,7 @@ PassRefPtr<CSSValue> CSSMutableStyleDeclaration::getPropertyCSSValue(int propert
     return property ? property->value() : 0;
 }
 
-bool CSSMutableStyleDeclaration::removeShorthandProperty(int propertyID, bool notifyChanged) 
+bool CSSMutableStyleDeclaration::removeShorthandProperty(int propertyID, bool notifyChanged)
 {
     CSSPropertyLonghand longhand = longhandForProperty(propertyID);
     if (longhand.length()) {
@@ -481,11 +481,11 @@ String CSSMutableStyleDeclaration::removeProperty(int propertyID, bool notifyCha
         // FIXME: Return an equivalent shorthand when possible.
         return String();
     }
-   
+
     CSSProperty* foundProperty = findPropertyWithId(propertyID);
     if (!foundProperty)
         return String();
-    
+
     String value = returnText ? foundProperty->value()->cssText() : String();
 
     // A more efficient removal strategy would involve marking entries as empty
@@ -580,7 +580,7 @@ bool CSSMutableStyleDeclaration::setProperty(int propertyID, const String& value
 
     return success;
 }
-    
+
 void CSSMutableStyleDeclaration::setPropertyInternal(const CSSProperty& property, CSSProperty* slot)
 {
     ASSERT(!m_iteratorCount);
@@ -687,12 +687,12 @@ String CSSMutableStyleDeclaration::item(unsigned i) const
 String CSSMutableStyleDeclaration::cssText() const
 {
     String result = "";
-    
+
     const CSSProperty* positionXProp = 0;
     const CSSProperty* positionYProp = 0;
     const CSSProperty* repeatXProp = 0;
     const CSSProperty* repeatYProp = 0;
-    
+
     unsigned size = m_properties.size();
     for (unsigned n = 0; n < size; ++n) {
         const CSSProperty& prop = m_properties[n];
@@ -707,21 +707,21 @@ String CSSMutableStyleDeclaration::cssText() const
         else
             result += prop.cssText();
     }
-    
+
     // FIXME: This is a not-so-nice way to turn x/y positions into single background-position in output.
-    // It is required because background-position-x/y are non-standard properties and WebKit generated output 
+    // It is required because background-position-x/y are non-standard properties and WebKit generated output
     // would not work in Firefox (<rdar://problem/5143183>)
     // It would be a better solution if background-position was CSS_PAIR.
     if (positionXProp && positionYProp && positionXProp->isImportant() == positionYProp->isImportant()) {
         String positionValue;
         const int properties[2] = { CSSPropertyBackgroundPositionX, CSSPropertyBackgroundPositionY };
-        if (positionXProp->value()->isValueList() || positionYProp->value()->isValueList()) 
+        if (positionXProp->value()->isValueList() || positionYProp->value()->isValueList())
             positionValue = getLayeredShorthandValue(properties);
         else
             positionValue = positionXProp->value()->cssText() + " " + positionYProp->value()->cssText();
         result += "background-position: " + positionValue + (positionXProp->isImportant() ? " !important" : "") + "; ";
     } else {
-        if (positionXProp) 
+        if (positionXProp)
             result += positionXProp->cssText();
         if (positionYProp)
             result += positionYProp->cssText();
@@ -731,13 +731,13 @@ String CSSMutableStyleDeclaration::cssText() const
     if (repeatXProp && repeatYProp && repeatXProp->isImportant() == repeatYProp->isImportant()) {
         String repeatValue;
         const int repeatProperties[2] = { CSSPropertyBackgroundRepeatX, CSSPropertyBackgroundRepeatY };
-        if (repeatXProp->value()->isValueList() || repeatYProp->value()->isValueList()) 
+        if (repeatXProp->value()->isValueList() || repeatYProp->value()->isValueList())
             repeatValue = getLayeredShorthandValue(repeatProperties);
         else
             repeatValue = repeatXProp->value()->cssText() + " " + repeatYProp->value()->cssText();
         result += "background-repeat: " + repeatValue + (repeatXProp->isImportant() ? " !important" : "") + "; ";
     } else {
-        if (repeatXProp) 
+        if (repeatXProp)
             result += repeatXProp->cssText();
         if (repeatYProp)
             result += repeatYProp->cssText();
@@ -825,18 +825,18 @@ void CSSMutableStyleDeclaration::removeBlockProperties()
 void CSSMutableStyleDeclaration::removePropertiesInSet(const int* set, unsigned length, bool notifyChanged)
 {
     ASSERT(!m_iteratorCount);
-    
+
     if (m_properties.isEmpty())
         return;
-    
+
     // FIXME: This is always used with static sets and in that case constructing the hash repeatedly is pretty pointless.
     HashSet<int> toRemove;
     for (unsigned i = 0; i < length; ++i)
         toRemove.add(set[i]);
-    
+
     Vector<CSSProperty, 4> newProperties;
     newProperties.reserveInitialCapacity(m_properties.size());
-    
+
     unsigned size = m_properties.size();
     for (unsigned n = 0; n < size; ++n) {
         const CSSProperty& property = m_properties[n];
@@ -850,7 +850,7 @@ void CSSMutableStyleDeclaration::removePropertiesInSet(const int* set, unsigned
 
     bool changed = newProperties.size() != m_properties.size();
     m_properties = newProperties;
-    
+
     if (changed && notifyChanged)
         setNeedsStyleRecalc();
 }
@@ -866,7 +866,7 @@ PassRefPtr<CSSMutableStyleDeclaration> CSSMutableStyleDeclaration::copy() const
 }
 
 const CSSProperty* CSSMutableStyleDeclaration::findPropertyWithId(int propertyID) const
-{    
+{
     for (int n = m_properties.size() - 1 ; n >= 0; --n) {
         if (propertyID == m_properties[n].m_id)
             return &m_properties[n];
index ea8ab3f98d665e23b47985207062f00f4fceadc3..309230850e12ca473df0294d025e7234ba307d4b 100644 (file)
@@ -38,15 +38,15 @@ public:
     CSSMutableStyleDeclarationConstIterator(const CSSMutableStyleDeclaration* decl, CSSProperty* current);
     CSSMutableStyleDeclarationConstIterator(const CSSMutableStyleDeclarationConstIterator& o);
     ~CSSMutableStyleDeclarationConstIterator();
-    
+
     const CSSProperty& operator*() const { return *m_current; }
     const CSSProperty* operator->() const { return m_current; }
-    
+
     bool operator!=(const CSSMutableStyleDeclarationConstIterator& o) { ASSERT(m_decl == o.m_decl); return m_current != o.m_current; }
     bool operator==(const CSSMutableStyleDeclarationConstIterator& o) { ASSERT(m_decl == o.m_decl); return m_current == o.m_current; }
-    
+
     CSSMutableStyleDeclarationConstIterator& operator=(const CSSMutableStyleDeclarationConstIterator& o);
-    
+
     CSSMutableStyleDeclarationConstIterator& operator++();
     CSSMutableStyleDeclarationConstIterator& operator--();
 
@@ -77,7 +77,7 @@ public:
     }
 
     CSSMutableStyleDeclaration& operator=(const CSSMutableStyleDeclaration&);
-    
+
     typedef CSSMutableStyleDeclarationConstIterator const_iterator;
 
     const_iterator begin() { return const_iterator(this, m_properties.begin()); }
@@ -113,7 +113,7 @@ public:
     bool setProperty(int propertyID, const String& value, bool important = false, bool notifyChanged = true);
 
     String removeProperty(int propertyID, bool notifyChanged = true, bool returnText = false);
+
     // setLengthProperty treats integers as pixels! (Needed for conversion of HTML attributes.)
     void setLengthProperty(int propertyId, const String& value, bool important, bool multiLength = false);
     void setStringProperty(int propertyId, const String& value, CSSPrimitiveValue::UnitTypes, bool important = false); // parsed string value
@@ -127,7 +127,7 @@ public:
     void addParsedProperties(const CSSProperty* const *, int numProperties);
     // This does no change notifications since it's only called by createMarkup.
     void addParsedProperty(const CSSProperty&);
+
     PassRefPtr<CSSMutableStyleDeclaration> copyBlockProperties() const;
     void removeBlockProperties();
     void removePropertiesInSet(const int* set, unsigned length, bool notifyChanged = true);
@@ -138,7 +138,7 @@ public:
     bool useStrictParsing() const { return m_strictParsing; }
 
     void addSubresourceStyleURLs(ListHashSet<KURL>&);
-    
+
     bool propertiesEqual(const CSSMutableStyleDeclaration* o) const { return m_properties == o->m_properties; }
 
     bool isInlineStyleDeclaration();
@@ -181,13 +181,13 @@ private:
 
     friend class CSSMutableStyleDeclarationConstIterator;
 };
-    
-inline CSSMutableStyleDeclarationConstIterator::CSSMutableStyleDeclarationConstIterator(const CSSMutableStyleDeclaration* decl, CSSProperty* current) 
+
+inline CSSMutableStyleDeclarationConstIterator::CSSMutableStyleDeclarationConstIterator(const CSSMutableStyleDeclaration* decl, CSSProperty* current)
 : m_decl(decl)
 , m_current(current)
-{ 
+{
 #ifndef NDEBUG
-    const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++; 
+    const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++;
 #endif
 }
 
@@ -196,11 +196,11 @@ inline CSSMutableStyleDeclarationConstIterator::CSSMutableStyleDeclarationConstI
 , m_current(o.m_current)
 {
 #ifndef NDEBUG
-    const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++; 
+    const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++;
 #endif
 }
 
-inline CSSMutableStyleDeclarationConstIterator::~CSSMutableStyleDeclarationConstIterator() 
+inline CSSMutableStyleDeclarationConstIterator::~CSSMutableStyleDeclarationConstIterator()
 {
 #ifndef NDEBUG
     const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount--;
@@ -212,22 +212,22 @@ inline CSSMutableStyleDeclarationConstIterator& CSSMutableStyleDeclarationConstI
     m_decl = o.m_decl;
     m_current = o.m_current;
 #ifndef NDEBUG
-    const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++; 
+    const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_iteratorCount++;
 #endif
     return *this;
 }
-    
-inline CSSMutableStyleDeclarationConstIterator& CSSMutableStyleDeclarationConstIterator::operator++() 
-{ 
+
+inline CSSMutableStyleDeclarationConstIterator& CSSMutableStyleDeclarationConstIterator::operator++()
+{
     ASSERT(m_current != const_cast<CSSMutableStyleDeclaration*>(m_decl)->m_properties.end());
     ++m_current;
-    return *this; 
+    return *this;
 }
 
-inline CSSMutableStyleDeclarationConstIterator& CSSMutableStyleDeclarationConstIterator::operator--() 
-{ 
-    --m_current; 
-    return *this; 
+inline CSSMutableStyleDeclarationConstIterator& CSSMutableStyleDeclarationConstIterator::operator--()
+{
+    --m_current;
+    return *this;
 }
 
 } // namespace WebCore
index 305b0cff30009daf17b97045aae44122a07beadd..c19447ba2f5eeaba91dba8b89efce3da44540dee 100644 (file)
@@ -366,7 +366,7 @@ static inline bool isSimpleLengthPropertyID(int propertyId, bool& acceptsNegativ
     case CSSPropertyMinWidth:
     case CSSPropertyPaddingBottom:
     case CSSPropertyPaddingLeft:
-    case CSSPropertyPaddingRight: 
+    case CSSPropertyPaddingRight:
     case CSSPropertyPaddingTop:
     case CSSPropertyWebkitLogicalWidth:
     case CSSPropertyWebkitLogicalHeight:
@@ -381,8 +381,8 @@ static inline bool isSimpleLengthPropertyID(int propertyId, bool& acceptsNegativ
     case CSSPropertyBottom:
     case CSSPropertyLeft:
     case CSSPropertyMarginBottom:
-    case CSSPropertyMarginLeft: 
-    case CSSPropertyMarginRight: 
+    case CSSPropertyMarginLeft:
+    case CSSPropertyMarginRight:
     case CSSPropertyMarginTop:
     case CSSPropertyRight:
     case CSSPropertyTextIndent:
@@ -642,7 +642,7 @@ void CSSParser::clearProperties()
     m_numParsedPropertiesBeforeMarginBox = INVALID_NUM_PARSED_PROPERTIES;
     m_hasFontFaceOnlyValues = false;
 }
-    
+
 void CSSParser::setStyleSheet(CSSStyleSheet* styleSheet)
 {
     m_styleSheet = styleSheet;
@@ -1260,11 +1260,11 @@ bool CSSParser::parseValue(int propId, bool important)
             validPrimitive = true;
         break;
     case CSSPropertySpeak:           // none | normal | spell-out | digits | literal-punctuation | no-punctuation | inherit
-        if (id == CSSValueNone || id == CSSValueNormal || id == CSSValueSpellOut || id == CSSValueDigits 
+        if (id == CSSValueNone || id == CSSValueNormal || id == CSSValueSpellOut || id == CSSValueDigits
             || id == CSSValueLiteralPunctuation || id == CSSValueNoPunctuation)
             validPrimitive = true;
         break;
-            
+
     case CSSPropertyTextIndent:          // <length> | <percentage> | inherit
         validPrimitive = (!id && validUnit(value, FLength | FPercent, m_strict));
         break;
@@ -1602,7 +1602,7 @@ bool CSSParser::parseValue(int propId, bool important)
         validPrimitive = id == CSSValueStart || id == CSSValueEnd || id == CSSValueCenter || id == CSSValueBaseline || id == CSSValueStretch;
         break;
     case CSSPropertyWebkitFlexFlow:
-        // FIXME: -webkit-flex-flow takes a second "wrap" value.    
+        // FIXME: -webkit-flex-flow takes a second "wrap" value.
         validPrimitive = id == CSSValueRow || id == CSSValueRowReverse || id == CSSValueColumn || id == CSSValueColumnReverse;
         break;
 #endif
@@ -2246,7 +2246,7 @@ bool CSSParser::parseFillShorthand(int propId, const int* properties, int numPro
                     if ((properties[i] == CSSPropertyBackgroundOrigin || properties[i] == CSSPropertyWebkitMaskOrigin) && !parsedProperty[i]) {
                         // If background-origin wasn't present, then reset background-clip also.
                         addFillValue(clipValue, CSSInitialValue::createImplicit());
-                    }                    
+                    }
                 }
                 parsedProperty[i] = false;
             }
@@ -3332,7 +3332,7 @@ PassRefPtr<CSSValue> CSSParser::parseAnimationTimingFunction()
 
         return CSSStepsTimingFunctionValue::create(numSteps, stepAtStart);
     }
-    
+
     if (equalIgnoringCase(value->function->name, "cubic-bezier(")) {
         // For cubic bezier, 4 values must be specified.
         if (!args || args->size() != 7)
@@ -3352,7 +3352,7 @@ PassRefPtr<CSSValue> CSSParser::parseAnimationTimingFunction()
 
         return CSSCubicBezierTimingFunctionValue::create(x1, y1, x2, y2);
     }
-    
+
     return 0;
 }
 
@@ -3705,20 +3705,20 @@ bool CSSParser::parseShape(int propId, bool important)
 PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeRect(CSSParserValueList* args)
 {
     ASSERT(args);
-    
+
     // rect(x, y, width, height, [[rx], ry])
     if (args->size() != 7 && args->size() != 9 && args->size() != 11)
         return 0;
-    
+
     RefPtr<CSSWrapShapeRect> shape = CSSWrapShapeRect::create();
-    
+
     unsigned argumentNumber = 0;
     CSSParserValue* argument = args->current();
     while (argument) {
         if (!validUnit(argument, FLength, m_strict))
             return 0;
-        
-        RefPtr<CSSPrimitiveValue> length = primitiveValueCache()->createValue(argument->fValue, 
+
+        RefPtr<CSSPrimitiveValue> length = primitiveValueCache()->createValue(argument->fValue,
             (CSSPrimitiveValue::UnitTypes) argument->unit);
         ASSERT(argumentNumber < 6);
         switch (argumentNumber) {
@@ -3745,34 +3745,34 @@ PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeRect(CSSParserValueList* args)
         if (argument) {
             if (argument->unit != CSSParserValue::Operator || argument->iValue != ',')
                 return 0;
-            
+
             argument = args->next();
         }
         argumentNumber++;
     }
-    
+
     if (argumentNumber < 4)
-        return 0;    
+        return 0;
     return shape;
 }
 
 PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeCircle(CSSParserValueList* args)
 {
     ASSERT(args);
-    
+
     // circle(x, y, r)
     if (args->size() != 5)
         return 0;
-        
+
     RefPtr<CSSWrapShapeCircle> shape = CSSWrapShapeCircle::create();
-    
+
     unsigned argumentNumber = 0;
     CSSParserValue* argument = args->current();
     while (argument) {
         if (!validUnit(argument, FLength, m_strict))
             return 0;
 
-        RefPtr<CSSPrimitiveValue> length = primitiveValueCache()->createValue(argument->fValue, 
+        RefPtr<CSSPrimitiveValue> length = primitiveValueCache()->createValue(argument->fValue,
             (CSSPrimitiveValue::UnitTypes) argument->unit);
         ASSERT(argumentNumber < 3);
         switch (argumentNumber) {
@@ -3786,37 +3786,37 @@ PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeCircle(CSSParserValueList* arg
             shape->setRadius(length);
             break;
         }
-        
+
         argument = args->next();
         if (argument) {
             if (argument->unit != CSSParserValue::Operator || argument->iValue != ',')
-                return 0;            
+                return 0;
             argument = args->next();
         }
         argumentNumber++;
     }
-    
+
     if (argumentNumber < 3)
-        return 0;    
+        return 0;
     return shape;
 }
 
 PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeEllipse(CSSParserValueList* args)
 {
     ASSERT(args);
-    
+
     // ellipse(x, y, rx, ry)
     if (args->size() != 7)
         return 0;
-        
+
     RefPtr<CSSWrapShapeEllipse> shape = CSSWrapShapeEllipse::create();
     unsigned argumentNumber = 0;
     CSSParserValue* argument = args->current();
     while (argument) {
         if (!validUnit(argument, FLength, m_strict))
             return 0;
-        
-        RefPtr<CSSPrimitiveValue> length = primitiveValueCache()->createValue(argument->fValue, 
+
+        RefPtr<CSSPrimitiveValue> length = primitiveValueCache()->createValue(argument->fValue,
             (CSSPrimitiveValue::UnitTypes) argument->unit);
         ASSERT(argumentNumber < 4);
         switch (argumentNumber) {
@@ -3833,7 +3833,7 @@ PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeEllipse(CSSParserValueList* ar
             shape->setRadiusY(length);
             break;
         }
-        
+
         argument = args->next();
         if (argument) {
             if (argument->unit != CSSParserValue::Operator || argument->iValue != ',')
@@ -3842,7 +3842,7 @@ PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapeEllipse(CSSParserValueList* ar
         }
         argumentNumber++;
     }
-    
+
     if (argumentNumber < 4)
         return 0;
     return shape;
@@ -3855,7 +3855,7 @@ PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapePolygon(CSSParserValueList* ar
     unsigned size = args->size();
     if (!size)
         return 0;
-    
+
     RefPtr<CSSWrapShapePolygon> shape = CSSWrapShapePolygon::create();
 
     CSSParserValue* argument = args->current();
@@ -3869,34 +3869,34 @@ PassRefPtr<CSSWrapShape> CSSParser::parseWrapShapePolygon(CSSParserValueList* ar
         argument = args->next();
         size -= 2;
     }
-    
+
     // <length>, <length> ... <length>, <length> -> each pair has 3 elements
     if (!size || (size % 3))
         return 0;
-    
+
     CSSParserValue* argumentX = argument;
     while (argumentX) {
         if (!validUnit(argumentX, FLength, m_strict))
             return 0;
-        
+
         CSSParserValue* comma = args->next();
         if (!comma || comma->unit != CSSParserValue::Operator || comma->iValue != ',')
             return 0;
-        
+
         CSSParserValue* argumentY = args->next();
         if (!argumentY || !validUnit(argumentY, FLength, m_strict))
             return 0;
-        
-        RefPtr<CSSPrimitiveValue> xLength = primitiveValueCache()->createValue(argumentX->fValue, 
+
+        RefPtr<CSSPrimitiveValue> xLength = primitiveValueCache()->createValue(argumentX->fValue,
             (CSSPrimitiveValue::UnitTypes) argumentX->unit);
-        RefPtr<CSSPrimitiveValue> yLength = primitiveValueCache()->createValue(argumentY->fValue, 
+        RefPtr<CSSPrimitiveValue> yLength = primitiveValueCache()->createValue(argumentY->fValue,
             (CSSPrimitiveValue::UnitTypes) argumentY->unit);
-        
+
         shape->appendPoint(xLength.release(), yLength.release());
-        
+
         argumentX = args->next();
     }
-    
+
     return shape;
 }
 
@@ -3907,9 +3907,9 @@ bool CSSParser::parseWrapShape(bool important)
 
     if (!args)
         return false;
-    
+
     RefPtr<CSSWrapShape> shape;
-    
+
     if (equalIgnoringCase(value->function->name, "rect("))
         shape = parseWrapShapeRect(args);
     else if (equalIgnoringCase(value->function->name, "circle("))
@@ -5139,7 +5139,7 @@ struct BorderImageParseContext {
     , m_allowRepeat(true)
     , m_allowSlash(false)
     , m_requireWidth(false)
-    , m_requireOutset(false)    
+    , m_requireOutset(false)
     {}
 
     bool canAdvance() const { return m_canAdvance; }
@@ -5153,7 +5153,7 @@ struct BorderImageParseContext {
 
     bool requireWidth() const { return m_requireWidth; }
     bool requireOutset() const { return m_requireOutset; }
-    
+
     void commitImage(PassRefPtr<CSSValue> image)
     {
         m_image = image;
@@ -5217,7 +5217,7 @@ struct BorderImageParseContext {
         // Make our new border image value now.
         return CSSBorderImageValue::create(m_image, m_imageSlice, m_borderSlice, m_outset, m_repeat);
     }
-    
+
     CSSPrimitiveValueCache* m_primitiveValueCache;
 
     bool m_canAdvance;
@@ -5227,7 +5227,7 @@ struct BorderImageParseContext {
     bool m_allowImageSlice;
     bool m_allowRepeat;
     bool m_allowSlash;
-    
+
     bool m_requireWidth;
     bool m_requireOutset;
 
@@ -5248,7 +5248,7 @@ bool CSSParser::parseBorderImage(int propId, RefPtr<CSSValue>& result)
 
         if (!context.canAdvance() && context.allowSlash() && val->unit == CSSParserValue::Operator && val->iValue == '/')
             context.commitSlash();
-        
+
         if (!context.canAdvance() && context.allowImage()) {
             if (val->unit == CSSPrimitiveValue::CSS_URI && m_styleSheet) {
                 // FIXME: The completeURL call should be done when using the CSSImageValue,
@@ -5263,34 +5263,34 @@ bool CSSParser::parseBorderImage(int propId, RefPtr<CSSValue>& result)
             } else if (val->id == CSSValueNone)
                 context.commitImage(CSSImageValue::create());
         }
-        
+
         if (!context.canAdvance() && context.allowImageSlice()) {
             RefPtr<CSSBorderImageSliceValue> imageSlice;
             if (parseBorderImageSlice(propId, imageSlice))
                 context.commitImageSlice(imageSlice.release());
-        } 
-        
+        }
+
         if (!context.canAdvance() && context.allowRepeat()) {
             RefPtr<CSSValue> repeat;
             if (parseBorderImageRepeat(repeat))
                 context.commitRepeat(repeat);
         }
-        
+
         if (!context.canAdvance() && context.requireWidth()) {
             RefPtr<CSSPrimitiveValue> borderSlice;
             if (parseBorderImageWidth(borderSlice))
                 context.commitBorderWidth(borderSlice.release());
-        } 
-        
+        }
+
         if (!context.canAdvance() && context.requireOutset()) {
             RefPtr<CSSPrimitiveValue> borderOutset;
             if (parseBorderImageOutset(borderOutset))
                 context.commitBorderOutset(borderOutset.release());
-        } 
-        
+        }
+
         if (!context.canAdvance())
             return false;
-    
+
         m_valueList->next();
     }
 
@@ -5317,7 +5317,7 @@ bool CSSParser::parseBorderImageRepeat(RefPtr<CSSValue>& result)
         firstValue = primitiveValueCache()->createIdentifierValue(val->id);
     else
         return false;
-    
+
     val = m_valueList->next();
     if (val) {
         if (isBorderImageRepeatKeyword(val->id))
@@ -5402,7 +5402,7 @@ public:
         // Make our new border image value now.
         return CSSBorderImageSliceValue::create(m_primitiveValueCache->createValue(quad.release()), m_fill);
     }
-    
+
 private:
     CSSPrimitiveValueCache* m_primitiveValueCache;
 
@@ -5414,7 +5414,7 @@ private:
     RefPtr<CSSPrimitiveValue> m_right;
     RefPtr<CSSPrimitiveValue> m_bottom;
     RefPtr<CSSPrimitiveValue> m_left;
-    
+
     bool m_fill;
 };
 
@@ -5473,7 +5473,7 @@ public:
             val = m_primitiveValueCache->createIdentifierValue(v->id);
         else
             val = m_primitiveValueCache->createValue(v->fValue, (CSSPrimitiveValue::UnitTypes)v->unit);
-        
+
         if (!m_top)
             m_top = val;
         else if (!m_right)
@@ -5518,7 +5518,7 @@ public:
         // Make our new value now.
         return m_primitiveValueCache->createValue(quad.release());
     }
-    
+
 private:
     CSSPrimitiveValueCache* m_primitiveValueCache;
 
@@ -5685,11 +5685,11 @@ static PassRefPtr<CSSPrimitiveValue> parseDeprecatedGradientPoint(CSSParserValue
 {
     RefPtr<CSSPrimitiveValue> result;
     if (a->unit == CSSPrimitiveValue::CSS_IDENT) {
-        if ((equalIgnoringCase(a->string, "left") && horizontal) || 
-            (equalIgnoringCase(a->string, "top") && !horizontal))
+        if ((equalIgnoringCase(a->string, "left") && horizontal)
+            || (equalIgnoringCase(a->string, "top") && !horizontal))
             result = primitiveValueCache->createValue(0., CSSPrimitiveValue::CSS_PERCENTAGE);
-        else if ((equalIgnoringCase(a->string, "right") && horizontal) ||
-                 (equalIgnoringCase(a->string, "bottom") && !horizontal))
+        else if ((equalIgnoringCase(a->string, "right") && horizontal)
+                 || (equalIgnoringCase(a->string, "bottom") && !horizontal))
             result = primitiveValueCache->createValue(100., CSSPrimitiveValue::CSS_PERCENTAGE);
         else if (equalIgnoringCase(a->string, "center"))
             result = primitiveValueCache->createValue(50., CSSPrimitiveValue::CSS_PERCENTAGE);
@@ -5712,8 +5712,8 @@ static bool parseDeprecatedGradientColorStop(CSSParser* p, CSSParserValue* a, CS
     if (!args)
         return false;
 
-    if (equalIgnoringCase(a->function->name, "from(") || 
-        equalIgnoringCase(a->function->name, "to(")) {
+    if (equalIgnoringCase(a->function->name, "from(")
+        || equalIgnoringCase(a->function->name, "to(")) {
         // The "from" and "to" stops expect 1 argument.
         if (args->size() != 1)
             return false;
@@ -5924,7 +5924,7 @@ static PassRefPtr<CSSPrimitiveValue> parseGradientColorOrKeyword(CSSParser* p, C
 bool CSSParser::parseLinearGradient(RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
 {
     RefPtr<CSSLinearGradientValue> result = CSSLinearGradientValue::create(repeating);
-    
+
     // Walk the arguments.
     CSSParserValueList* args = m_valueList->current()->function->args.get();
     if (!args || !args->size())
@@ -5938,13 +5938,13 @@ bool CSSParser::parseLinearGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
     // Look for angle.
     if (validUnit(a, FAngle, true)) {
         result->setAngle(createPrimitiveNumericValue(a));
-        
+
         a = args->next();
         expectComma = true;
     } else {
         // Look one or two optional keywords that indicate a side or corner.
         RefPtr<CSSPrimitiveValue> startX, startY;
-        
+
         RefPtr<CSSPrimitiveValue> location;
         bool isHorizontal = false;
         if ((location = valueFromSideKeyword(a, isHorizontal, primitiveValueCache()))) {
@@ -5952,7 +5952,7 @@ bool CSSParser::parseLinearGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
                 startX = location;
             else
                 startY = location;
-            
+
             a = args->next();
             if (a) {
                 if ((location = valueFromSideKeyword(a, isHorizontal, primitiveValueCache()))) {
@@ -5972,10 +5972,10 @@ bool CSSParser::parseLinearGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
 
             expectComma = true;
         }
-        
+
         if (!startX && !startY)
             startY = primitiveValueCache()->createIdentifierValue(CSSValueTop);
-            
+
         result->setFirstX(startX.release());
         result->setFirstY(startY.release());
     }
@@ -5994,7 +5994,7 @@ bool CSSParser::parseLinearGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
 bool CSSParser::parseRadialGradient(RefPtr<CSSValue>& gradient, CSSGradientRepeat repeating)
 {
     RefPtr<CSSRadialGradientValue> result = CSSRadialGradientValue::create(repeating);
-    
+
     // Walk the arguments.
     CSSParserValueList* args = m_valueList->current()->function->args.get();
     if (!args || !args->size())
@@ -6014,7 +6014,7 @@ bool CSSParser::parseRadialGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
     a = args->current();
     if (!a)
         return false;
-    
+
     if (centerX || centerY) {
         // Comma
         if (a->unit != CSSParserValue::Operator || a->iValue != ',')
@@ -6024,7 +6024,7 @@ bool CSSParser::parseRadialGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
         if (!a)
             return false;
     }
-    
+
     ASSERT(!centerX || centerX->isPrimitiveValue());
     ASSERT(!centerY || centerY->isPrimitiveValue());
 
@@ -6033,7 +6033,7 @@ bool CSSParser::parseRadialGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
     // CSS3 radial gradients always share the same start and end point.
     result->setFirstY(static_cast<CSSPrimitiveValue*>(centerY.get()));
     result->setSecondY(static_cast<CSSPrimitiveValue*>(centerY.get()));
-    
+
     RefPtr<CSSPrimitiveValue> shapeValue;
     RefPtr<CSSPrimitiveValue> sizeValue;
 
@@ -6041,7 +6041,7 @@ bool CSSParser::parseRadialGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
     for (int i = 0; i < 2; ++i) {
         if (a->unit != CSSPrimitiveValue::CSS_IDENT)
             break;
-    
+
         bool foundValue = false;
         switch (a->id) {
         case CSSValueCircle:
@@ -6068,10 +6068,10 @@ bool CSSParser::parseRadialGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
             expectComma = true;
         }
     }
-    
+
     result->setShape(shapeValue);
     result->setSizingBehavior(sizeValue);
-    
+
     // Or, two lengths or percentages
     RefPtr<CSSPrimitiveValue> horizontalSize;
     RefPtr<CSSPrimitiveValue> verticalSize;
@@ -6099,7 +6099,7 @@ bool CSSParser::parseRadialGradient(RefPtr<CSSValue>& gradient, CSSGradientRepea
     // Must have neither or both.
     if (!horizontalSize != !verticalSize)
         return false;
-    
+
     result->setEndHorizontalSize(horizontalSize);
     result->setEndVerticalSize(verticalSize);
 
@@ -6139,7 +6139,7 @@ bool CSSParser::parseGradientColorStops(CSSParserValueList* valueList, CSSGradie
                 a = valueList->next();
             }
         }
-        
+
         gradient->addStop(stop);
         expectComma = true;
     }
@@ -6417,7 +6417,7 @@ bool CSSParser::isValidFilterArgument(CSSParserValue* argument, WebKitCSSFilterV
             return false;
     } else if (!validUnit(argument, FNumber, true))
         return false;
-    
+
     // Check parameter values.
     if (filterType == WebKitCSSFilterValue::GrayscaleFilterOperation
         || filterType == WebKitCSSFilterValue::SepiaFilterOperation
@@ -6466,12 +6466,12 @@ PassRefPtr<CSSValueList> CSSParser::parseFilter()
             RefPtr<WebKitCSSFilterValue> referenceFilterValue = WebKitCSSFilterValue::create(WebKitCSSFilterValue::ReferenceFilterOperation);
             list->append(referenceFilterValue);
             referenceFilterValue->append(primitiveValueCache()->createValue(value->string, CSSPrimitiveValue::CSS_STRING));
-        } else {        
+        } else {
             const CSSParserString name = value->function->name;
             unsigned maximumArgumentCount = 1;
 
             filterInfoForName(name, filterType, maximumArgumentCount);
-            
+
             if (filterType == WebKitCSSFilterValue::UnknownFilterOperation)
                 return 0;
 
@@ -6482,7 +6482,7 @@ PassRefPtr<CSSValueList> CSSParser::parseFilter()
             // Create the new WebKitCSSFilterValue for this operation and add it to our list.
             RefPtr<WebKitCSSFilterValue> filterValue = WebKitCSSFilterValue::create(filterType);
             list->append(filterValue);
-            
+
             CSSParserValue* argument = args->current();
             unsigned argumentCount = 0;
 
@@ -6737,7 +6737,7 @@ bool CSSParser::parseLineBoxContain(bool important)
         } else
             return false;
     }
-    
+
     if (!lineBoxContain)
         return false;
 
@@ -7251,7 +7251,7 @@ CSSRule* CSSParser::createFontFaceRule()
             property->m_value = CSSValueList::createCommaSeparated();
             static_cast<CSSValueList*>(property->value())->append(value.release());
         } else if (id == CSSPropertyFontFamily && (!property->value()->isValueList() || static_cast<CSSValueList*>(property->value())->length() != 1)) {
-            // Unlike font-family property, font-family descriptor in @font-face rule 
+            // Unlike font-family property, font-family descriptor in @font-face rule
             // has to be a value list with exactly one family name. It cannot have a
             // have 'initial' value and cannot 'inherit' from parent.
             // See http://dev.w3.org/csswg/css3-fonts/#font-family-desc
index e391b39cabf64b518ac47b310cf247717c358f13..c804e4b6b9a60fba8899c5db1b6ec7891e61c801 100644 (file)
@@ -98,7 +98,7 @@ public:
     PassRefPtr<CSSValue> parseFillPositionX(CSSParserValueList*);
     PassRefPtr<CSSValue> parseFillPositionY(CSSParserValueList*);
     void parseFillPosition(CSSParserValueList*, RefPtr<CSSValue>&, RefPtr<CSSValue>&);
-    
+
     void parseFillRepeat(RefPtr<CSSValue>&, RefPtr<CSSValue>&);
     PassRefPtr<CSSValue> parseFillSize(int propId, bool &allowComma);
 
@@ -305,7 +305,7 @@ public:
 
 private:
     void setStyleSheet(CSSStyleSheet*);
-    
+
     void recheckAtKeyword(const UChar* str, int len);
 
     void setupParser(const char* prefix, const String&, const char* suffix);
@@ -385,7 +385,7 @@ private:
     static bool validUnit(CSSParserValue*, Units, bool strict);
 
     bool parseBorderImageQuad(Units, RefPtr<CSSPrimitiveValue>&);
-    
+
     PassRefPtr<CSSPrimitiveValue> createPrimitiveNumericValue(CSSParserValue*);
     PassRefPtr<CSSPrimitiveValue> createPrimitiveStringValue(CSSParserValue*);
 
index 3e97013fc7fb544619a0cc6fd30fa68fbabf3855..0688316e081db94a0948fa1e2aac780c8eabbd11 100644 (file)
@@ -27,7 +27,7 @@
 #include "CSSSelectorList.h"
 
 namespace WebCore {
-        
+
 using namespace WTF;
 
 CSSParserValueList::~CSSParserValueList()
@@ -50,7 +50,7 @@ void CSSParserValueList::insertValueAt(unsigned i, const CSSParserValue& v)
 }
 
 void CSSParserValueList::deleteValueAt(unsigned i)
-{ 
+{
     m_values.remove(i);
 }
 
@@ -85,7 +85,7 @@ PassRefPtr<CSSValue> CSSParserValue::createCSSValue()
         parsedValue = CSSPrimitiveValue::createAllowingMarginQuirk(fValue, CSSPrimitiveValue::CSS_EMS);
     return parsedValue;
 }
-    
+
 CSSParserSelector::CSSParserSelector()
     : m_selector(adoptPtr(fastNew<CSSSelector>()))
 {
index 49f01d0bc2c469476b9d8cd0d7c86ea5bd100571..cb5c903bbe8e68d9c6a7dba91d1bca20583b9dd0 100644 (file)
@@ -56,8 +56,8 @@ struct CSSParserValue {
         Q_EMS    = 0x100002
     };
     int unit;
-    
-    
+
+
     PassRefPtr<CSSValue> createCSSValue();
 };
 
@@ -69,7 +69,7 @@ public:
     {
     }
     ~CSSParserValueList();
-    
+
     void addValue(const CSSParserValue&);
     void insertValueAt(unsigned, const CSSParserValue&);
     void deleteValueAt(unsigned);
@@ -87,7 +87,7 @@ public:
     }
 
     CSSParserValue* valueAt(unsigned i) { return i < m_values.size() ? &m_values[i] : 0; }
-        
+
     void clear() { m_values.clear(); }
 
 private:
@@ -109,7 +109,7 @@ public:
     ~CSSParserSelector();
 
     PassOwnPtr<CSSSelector> releaseSelector() { return m_selector.release(); }
-    
+
     void setTag(const QualifiedName& value) { m_selector->setTag(value); }
     void setValue(const AtomicString& value) { m_selector->setValue(value); }
     void setAttribute(const QualifiedName& value) { m_selector->setAttribute(value); }
index 4564e31e911f6807ddecabc694cbd8a0dd4a3293..5f9a6e18f001feb8f9fad15036c3a187c4541546 100644 (file)
@@ -412,7 +412,7 @@ double CSSPrimitiveValue::computeLengthDouble(RenderStyle* style, RenderStyle* r
     double result = getDoubleValue() * factor;
     if (!applyZoomMultiplier || multiplier == 1.0)
         return result;
-     
+
     // Any original result that was >= 1 should not be allowed to fall below 1.  This keeps border lines from
     // vanishing.
     double zoomedResult = result * multiplier;
@@ -423,7 +423,7 @@ double CSSPrimitiveValue::computeLengthDouble(RenderStyle* style, RenderStyle* r
 
 void CSSPrimitiveValue::setFloatValue(unsigned short, double, ExceptionCode& ec)
 {
-    // Keeping values immutable makes optimizations easier and allows sharing of the primitive value objects. 
+    // Keeping values immutable makes optimizations easier and allows sharing of the primitive value objects.
     // No other engine supports mutating style through this API. Computed style is always read-only anyway.
     // Supporting setter would require making primitive value copy-on-write and taking care of style invalidation.
     ec = NO_MODIFICATION_ALLOWED_ERR;
@@ -568,7 +568,7 @@ bool CSSPrimitiveValue::getDoubleValueInternal(UnitTypes requestedUnitType, doub
 
 void CSSPrimitiveValue::setStringValue(unsigned short, const String&, ExceptionCode& ec)
 {
-    // Keeping values immutable makes optimizations easier and allows sharing of the primitive value objects. 
+    // Keeping values immutable makes optimizations easier and allows sharing of the primitive value objects.
     // No other engine supports mutating style through this API. Computed style is always read-only anyway.
     // Supporting setter would require making primitive value copy-on-write and taking care of style invalidation.
     ec = NO_MODIFICATION_ALLOWED_ERR;
index 6e565ab41e274c37e830fb5b2c3565119a4acd46..46f364215cf029b1cc6e8247f23d6c9e11dc6823 100644 (file)
@@ -83,15 +83,15 @@ public:
         CSS_PAIR = 100, // We envision this being exposed as a means of getting computed style values for pairs (border-spacing/radius, background-position, etc.)
         CSS_DASHBOARD_REGION = 101, // FIXME: Dashboard region should not be a primitive value.
         CSS_UNICODE_RANGE = 102,
-        
+
         // These next types are just used internally to allow us to translate back and forth from CSSPrimitiveValues to CSSParserValues.
         CSS_PARSER_OPERATOR = 103,
         CSS_PARSER_INTEGER = 104,
         CSS_PARSER_HEXCOLOR = 105,
-        
-        // This is used internally for unknown identifiers 
+
+        // This is used internally for unknown identifiers
         CSS_PARSER_IDENTIFIER = 106,
-        
+
         // These are from CSS3 Values and Units, but that isn't a finished standard yet
         CSS_TURN = 107,
         CSS_REMS = 108,
@@ -101,11 +101,11 @@ public:
 
         // This is used by the CSS Exclusions draft
         CSS_SHAPE = 110,
-        
+
         // Used by border images.
         CSS_QUAD = 111
     };
-    
+
     // This enum follows the CSSParser::Units enum augmented with UNIT_FREQUENCY for frequencies.
     enum UnitCategory {
         UNumber,
@@ -126,7 +126,7 @@ public:
     static PassRefPtr<CSSPrimitiveValue> createColor(unsigned rgbValue) { return adoptRef(new CSSPrimitiveValue(rgbValue)); }
     static PassRefPtr<CSSPrimitiveValue> create(double value, UnitTypes type) { return adoptRef(new CSSPrimitiveValue(value, type)); }
     static PassRefPtr<CSSPrimitiveValue> create(const String& value, UnitTypes type) { return adoptRef(new CSSPrimitiveValue(value, type)); }
-    
+
     template<typename T> static PassRefPtr<CSSPrimitiveValue> create(T value)
     {
         return adoptRef(new CSSPrimitiveValue(value));
@@ -163,7 +163,7 @@ public:
 
     // use with care!!!
     void setPrimitiveType(unsigned short type) { m_type = type; }
-    
+
     double getDoubleValue(unsigned short unitType, ExceptionCode&) const;
     double getDoubleValue(unsigned short unitType) const;
     double getDoubleValue() const { return m_value.num; }
@@ -193,7 +193,7 @@ public:
 
     Quad* getQuadValue(ExceptionCode&) const;
     Quad* getQuadValue() const { return m_type != CSS_QUAD ? 0 : m_value.quad; }
-    
+
     PassRefPtr<RGBColor> getRGBColorValue(ExceptionCode&) const;
     RGBA32 getRGBA32Value() const { return m_type != CSS_RGBCOLOR ? 0 : m_value.rgbcolor; }
 
index 3adadf89b7402c4e45a3f5c7904ba47c2247cfc2..a5b588e5f9bd09ea6aef45f6e10670ce2895c493 100644 (file)
@@ -65,7 +65,7 @@ PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValueCache::createColorValue(unsigned
     // Just because it is common.
     if (rgbValue == Color::black)
         return m_colorBlack;
-    
+
     // Just wipe out the cache and start rebuilding if it gets too big.
     const int maximumColorCacheSize = 512;
     if (m_colorValueCache.size() > maximumColorCacheSize)
@@ -88,7 +88,7 @@ PassRefPtr<CSSPrimitiveValue> CSSPrimitiveValueCache::createValue(double value,
     int intValue = static_cast<int>(value);
     if (value != intValue)
         return CSSPrimitiveValue::create(value, type);
-    
+
     IntegerValueCache* cache;
     switch (type) {
     case CSSPrimitiveValue::CSS_PX:
index 8be3b526f6fe62ca52b50ac440b2144bc49b8f29..632ac1bbbe1208d454a590fbb3cbf12b745cb5b1 100644 (file)
@@ -22,7 +22,7 @@
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
+
 #ifndef CSSPrimitiveValueCache_h
 #define CSSPrimitiveValueCache_h
 
@@ -31,7 +31,7 @@
 #include <wtf/RefPtr.h>
 
 namespace WebCore {
-    
+
 class CSSPrimitiveValueCache : public RefCounted<CSSPrimitiveValueCache> {
 public:
     static PassRefPtr<CSSPrimitiveValueCache> create() { return adoptRef(new CSSPrimitiveValueCache); }
@@ -42,7 +42,7 @@ public:
     PassRefPtr<CSSPrimitiveValue> createValue(double value, CSSPrimitiveValue::UnitTypes);
     PassRefPtr<CSSPrimitiveValue> createValue(const String& value, CSSPrimitiveValue::UnitTypes type) { return CSSPrimitiveValue::create(value, type); }
     template<typename T> static PassRefPtr<CSSPrimitiveValue> createValue(T value) { return CSSPrimitiveValue::create(value); }
-    
+
 private:
     CSSPrimitiveValueCache();
 
@@ -54,7 +54,7 @@ private:
     RefPtr<CSSPrimitiveValue> m_colorTransparent;
     RefPtr<CSSPrimitiveValue> m_colorWhite;
     RefPtr<CSSPrimitiveValue> m_colorBlack;
-    
+
     typedef HashMap<int, RefPtr<CSSPrimitiveValue> > IntegerValueCache;
     RefPtr<CSSPrimitiveValue> m_pixelZero;
     RefPtr<CSSPrimitiveValue> m_percentZero;
index 0b9cc8dd6494df5538dad10777e5ec1d60a5ccdb..14f8353a311ac154e31db1a501e8beb5799fceee 100644 (file)
@@ -8,13 +8,13 @@
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
- * 
+ *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
@@ -2708,7 +2708,7 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(FontSmoothingMode smoothi
         m_value.ident = CSSValueSubpixelAntialiased;
         return;
     }
-    
+
     ASSERT_NOT_REACHED();
     m_value.ident = CSSValueAuto;
 }
@@ -2725,7 +2725,7 @@ template<> inline CSSPrimitiveValue::operator FontSmoothingMode() const
     case CSSValueSubpixelAntialiased:
         return SubpixelAntialiased;
     }
-    
+
     ASSERT_NOT_REACHED();
     return AutoSmoothing;
 }
@@ -2985,7 +2985,7 @@ template<> inline CSSPrimitiveValue::CSSPrimitiveValue(ESpeak e)
         break;
     }
 }
-    
+
 template<> inline CSSPrimitiveValue::operator Order() const
 {
     switch (m_value.ident) {
@@ -3610,7 +3610,7 @@ template<> inline CSSPrimitiveValue::operator EVectorEffect() const
         return VE_NONE;
     }
 }
-    
+
 #endif
 
 }
index 1e04da7330321dd15c04b3aa908265dfbb2b1770..69b2f6654eb07975714b2cb6695a4ee0a855e4e5 100644 (file)
@@ -48,7 +48,7 @@ static int resolveToPhysicalProperty(TextDirection direction, WritingMode writin
             // Left = Start, Right = End, Before = Top, After = Bottom
             return properties[logicalSide];
         }
-        
+
         if (writingMode == BottomToTopWritingMode) {
             // Start = Left, End = Right, Before = Bottom, After = Top.
             switch (logicalSide) {
@@ -62,7 +62,7 @@ static int resolveToPhysicalProperty(TextDirection direction, WritingMode writin
                 return properties[TopSide];
             }
         }
-        
+
         if (writingMode == LeftToRightWritingMode) {
             // Start = Top, End = Bottom, Before = Left, After = Right.
             switch (logicalSide) {
@@ -76,7 +76,7 @@ static int resolveToPhysicalProperty(TextDirection direction, WritingMode writin
                 return properties[RightSide];
             }
         }
-        
+
         // Start = Top, End = Bottom, Before = Right, After = Left
         switch (logicalSide) {
         case StartSide:
@@ -103,7 +103,7 @@ static int resolveToPhysicalProperty(TextDirection direction, WritingMode writin
             return properties[BottomSide];
         }
     }
-    
+
     if (writingMode == BottomToTopWritingMode) {
         // Start = Right, End = Left, Before = Bottom, After = Top
         switch (logicalSide) {
@@ -117,7 +117,7 @@ static int resolveToPhysicalProperty(TextDirection direction, WritingMode writin
             return properties[TopSide];
         }
     }
-    
+
     if (writingMode == LeftToRightWritingMode) {
         // Start = Bottom, End = Top, Before = Left, After = Right
         switch (logicalSide) {
@@ -131,7 +131,7 @@ static int resolveToPhysicalProperty(TextDirection direction, WritingMode writin
             return properties[RightSide];
         }
     }
-    
+
     // Start = Bottom, End = Top, Before = Right, After = Left
     switch (logicalSide) {
     case StartSide:
@@ -153,7 +153,7 @@ static int resolveToPhysicalProperty(WritingMode writingMode, LogicalExtent logi
         return properties[logicalSide];
     return logicalSide == LogicalWidth ? properties[1] : properties[0];
 }
-        
+
 int CSSProperty::resolveDirectionAwareProperty(int propertyID, TextDirection direction, WritingMode writingMode)
 {
     switch (static_cast<CSSPropertyID>(propertyID)) {
index 4a46fc266564c86d0a3245f37419d136ef0de63f..27c86fc0b8e67b3748d443ffd1799c8f65bef5fa 100644 (file)
@@ -58,7 +58,7 @@ public:
     bool isImplicit() const { return m_implicit; }
 
     CSSValue* value() const { return m_value.get(); }
-    
+
     String cssText() const;
 
     static int resolveDirectionAwareProperty(int propertyID, TextDirection, WritingMode);
index 7372a54fe1951d3e05e9c4d20e7f69b5183ab0ed..7d18262d48be32b7192917d5b0ff9d0a4ee9b00b 100644 (file)
@@ -206,13 +206,13 @@ static void initShorthandMap(ShorthandMap& shorthandMap)
         CSSPropertyWebkitTransformOriginY
     };
     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSSPropertyWebkitTransformOrigin, transformOriginProperties);
-    
+
     static const int textEmphasisProperties[] = {
         CSSPropertyWebkitTextEmphasisColor,
         CSSPropertyWebkitTextEmphasisStyle
     };
     SET_SHORTHAND_MAP_ENTRY(shorthandMap, CSSPropertyWebkitTextEmphasis, textEmphasisProperties);
-    
+
     #undef SET_SHORTHAND_MAP_ENTRY
 }
 
index a8ca59e9a186b2b05e9f16095ce9f3b25241cae9..ddc3cefc8dacaefc2d57c6485f7713bbdfefcdc0 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -52,7 +52,7 @@ String CSSReflectValue::cssText() const
         default:
             break;
     }
-    
+
     result += m_offset->cssText() + " ";
     if (m_mask)
         result += m_mask->cssText();
index 1dcb1becbfcfb87a0394ee9db41253da9afbcfa3..58076ea9daae3bfd585f70d9abae95daab1a9d78 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSReflectValue_h
@@ -61,7 +61,7 @@ private:
     }
 
     virtual bool isReflectValue() const { return true; }
-    
+
     CSSReflectionDirection m_direction;
     RefPtr<CSSPrimitiveValue> m_offset;
     RefPtr<CSSValue> m_mask;
index 5a0c203559a3cefd35413c91c10a4d3b487ca32b..e30bc1c131aafe4b0fe17da54ac8bff8507eb1e3 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSReflectionDirection_h
index 809f4ab5cd744f8cb0e1479c1825146e1b5ab448..4a458c1a8cf1e110ba68c48376d885c4b1ca2e0f 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index 03ebe4aab31f8de81b0f666395fe7086251e9b16..3efc47a63fc4a01f6f82f7785ea5a068529a16ce 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSSegmentedFontFace_h
index 6bea99b7f6fcec80de4741bdc2fcd19279d4f093..e95d25c93208279f34ec030f60dd185d158dd991 100644 (file)
 namespace WebCore {
 
 using namespace HTMLNames;
-    
+
 void CSSSelector::createRareData()
 {
-    if (m_hasRareData) 
+    if (m_hasRareData)
         return;
     // Move the value to the rare data stucture.
     m_data.m_rareData = new RareData(adoptRef(m_data.m_value));
@@ -150,7 +150,7 @@ PseudoId CSSSelector::pseudoId(PseudoType type)
     case PseudoAnimatingFullScreenTransition:
         return ANIMATING_FULL_SCREEN_TRANSITION;
 #endif
-            
+
     case PseudoInputListButton:
 #if ENABLE(DATALIST)
         return INPUT_LIST_BUTTON;
@@ -640,21 +640,21 @@ String CSSSelector::selectorText() const
     return str;
 }
 
-void CSSSelector::setAttribute(const QualifiedName& value) 
-{ 
-    createRareData(); 
-    m_data.m_rareData->m_attribute = value; 
+void CSSSelector::setAttribute(const QualifiedName& value)
+{
+    createRareData();
+    m_data.m_rareData->m_attribute = value;
 }
-    
-void CSSSelector::setArgument(const AtomicString& value) 
-{ 
-    createRareData(); 
-    m_data.m_rareData->m_argument = value; 
+
+void CSSSelector::setArgument(const AtomicString& value)
+{
+    createRareData();
+    m_data.m_rareData->m_argument = value;
 }
-    
+
 void CSSSelector::setSelectorList(PassOwnPtr<CSSSelectorList> selectorList)
 {
-    createRareData(); 
+    createRareData();
     m_data.m_rareData->m_selectorList = selectorList;
 }
 
@@ -713,15 +713,15 @@ CSSSelector::RareData::~RareData()
     if (m_value)
         m_value->deref();
 }
-    
+
 // a helper function for parsing nth-arguments
 bool CSSSelector::RareData::parseNth()
 {
     String argument = m_argument.lower();
-    
+
     if (argument.isEmpty())
         return false;
-    
+
     m_a = 0;
     m_b = 0;
     if (argument == "odd") {
@@ -742,7 +742,7 @@ bool CSSSelector::RareData::parseNth()
                 m_a = 1; // n == 1n
             else
                 m_a = argument.substring(0, n).toInt();
-            
+
             size_t p = argument.find('+', n);
             if (p != notFound)
                 m_b = argument.substring(p + 1, argument.length() - p - 1).toInt();
index 6161af9f0012684532f98fef4f271f37440cb2b2..afd52def9b7c6ee1969c03c4c8bbed3a313e2608 100644 (file)
@@ -215,12 +215,12 @@ namespace WebCore {
         static bool isUnknownPseudoType(const AtomicString&);
         static PseudoId pseudoId(PseudoType);
 
-        // Selectors are kept in an array by CSSSelectorList. The next component of the selector is 
+        // Selectors are kept in an array by CSSSelectorList. The next component of the selector is
         // the next item in the array.
         CSSSelector* tagHistory() const { return m_isLastInTagHistory ? 0 : const_cast<CSSSelector*>(this + 1); }
 
         bool hasTag() const { return m_tag != anyQName(); }
-        
+
         const QualifiedName& tag() const { return m_tag; }
         // AtomicString is really just an AtomicStringImpl* so the cast below is safe.
         // FIXME: Perhaps call sites could be changed to accept AtomicStringImpl?
@@ -234,7 +234,7 @@ namespace WebCore {
         void setAttribute(const QualifiedName&);
         void setArgument(const AtomicString&);
         void setSelectorList(PassOwnPtr<CSSSelectorList>);
-        
+
         bool parseNth();
         bool matchNth(int count);
 
@@ -258,9 +258,9 @@ namespace WebCore {
         unsigned m_relation           : 3; // enum Relation
         mutable unsigned m_match      : 4; // enum Match
         mutable unsigned m_pseudoType : 8; // PseudoType
-        
+
     private:
-        bool m_parsedNth              : 1; // Used for :nth-* 
+        bool m_parsedNth              : 1; // Used for :nth-*
         bool m_isLastInSelectorList   : 1;
         bool m_isLastInTagHistory     : 1;
         bool m_hasRareData            : 1;
@@ -287,25 +287,25 @@ namespace WebCore {
             OwnPtr<CSSSelectorList> m_selectorList; // Used for :-webkit-any and :not
         };
         void createRareData();
-        
+
         union DataUnion {
             DataUnion() : m_value(0) { }
             AtomicStringImpl* m_value;
             RareData* m_rareData;
         } m_data;
-        
+
         QualifiedName m_tag;
     };
 
 inline const QualifiedName& CSSSelector::attribute() const
-{ 
+{
     ASSERT(isAttributeSelector());
     ASSERT(m_hasRareData);
     return m_data.m_rareData->m_attribute;
 }
-    
-inline bool CSSSelector::matchesPseudoElement() const 
-{ 
+
+inline bool CSSSelector::matchesPseudoElement() const
+{
     if (m_pseudoType == PseudoUnknown)
         extractPseudoType();
     return m_match == PseudoElement;
@@ -361,7 +361,7 @@ inline void CSSSelector::setValue(const AtomicString& value)
     m_data.m_value->ref();
 }
 
-inline void move(PassOwnPtr<CSSSelector> from, CSSSelector* to) 
+inline void move(PassOwnPtr<CSSSelector> from, CSSSelector* to)
 {
     memcpy(to, from.get(), sizeof(CSSSelector));
     // We want to free the memory (which was allocated with fastNew), but we
index 84ac9ec05424a6940468996c7f83cc6bf61eb7cc..9b0fa8002407e74cb0b5467d5dc1818636893cd6 100644 (file)
@@ -21,7 +21,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 
 namespace WebCore {
 
-CSSSelectorList::~CSSSelectorList() 
+CSSSelectorList::~CSSSelectorList()
 {
     deleteSelectors();
 }
-    
+
 void CSSSelectorList::adopt(CSSSelectorList& list)
 {
     deleteSelectors();
@@ -48,7 +48,7 @@ void CSSSelectorList::adoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& se
     deleteSelectors();
     const size_t vectorSize = selectorVector.size();
     size_t flattenedSize = 0;
-    for (size_t i = 0; i < vectorSize; ++i) {        
+    for (size_t i = 0; i < vectorSize; ++i) {
         for (CSSParserSelector* selector = selectorVector[i].get(); selector; selector = selector->tagHistory())
             ++flattenedSize;
     }
index 219d74e372421f2b317b23ac6783ebab512080e2..7d45a6a5438f3ffb573e85081da5caf3ed37cc16 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSSelectorList_h
@@ -29,9 +29,9 @@
 #include "CSSSelector.h"
 
 namespace WebCore {
-    
+
 class CSSParserSelector;
-    
+
 class CSSSelectorList {
     WTF_MAKE_NONCOPYABLE(CSSSelectorList); WTF_MAKE_FAST_ALLOCATED;
 public:
@@ -40,7 +40,7 @@ public:
 
     void adopt(CSSSelectorList& list);
     void adoptSelectorVector(Vector<OwnPtr<CSSParserSelector> >& selectorVector);
-    
+
     CSSSelector* first() const { return m_selectorArray ? m_selectorArray : 0; }
     static CSSSelector* next(CSSSelector*);
     bool hasOneSelector() const { return m_selectorArray && !next(m_selectorArray); }
index fbb23ac988a2912446f75091c96862eb8f55f98d..178cb358f775aa217f15af69a79b520f3ecd3da7 100644 (file)
@@ -264,7 +264,7 @@ private:
                 (selector->style()->*m_visitedLinkSetter)(selector->getColorFromPrimitiveValue(primitiveValue, true));
         }
     }
-    
+
     void applyColorValue(CSSStyleSelector* selector, const Color& color) const
     {
         if (selector->applyPropertyToRegularStyle())
index 4c9f63074f3ea907f5c713551cd682e8a75ebc88..4479752e0b597b11a90783014c744cbdf8ec2ddb 100644 (file)
@@ -52,7 +52,7 @@ public:
     String getPropertyPriority(const String& propertyName);
     String getPropertyShorthand(const String& propertyName);
     bool isPropertyImplicit(const String& propertyName);
-    
+
     virtual PassRefPtr<CSSValue> getPropertyCSSValue(int propertyID) const = 0;
     virtual String getPropertyValue(int propertyID) const = 0;
     virtual bool getPropertyPriority(int propertyID) const = 0;
@@ -67,7 +67,7 @@ public:
 
     virtual PassRefPtr<CSSMutableStyleDeclaration> copy() const = 0;
     virtual PassRefPtr<CSSMutableStyleDeclaration> makeMutable() = 0;
+
     void diff(CSSMutableStyleDeclaration*) const;
 
     PassRefPtr<CSSMutableStyleDeclaration> copyPropertiesInSet(const int* set, unsigned length) const;
index 97c594adddfe8913c7e3c1a700909953df95c98b..ab21a8c2a0cea8f5232a4b3cae554c4dc755a349 100644 (file)
@@ -163,7 +163,7 @@ if (id == propID) { \
     m_style->set##Prop(m_parentStyle->prop()); \
     return; \
 }
-    
+
 #define HANDLE_INHERIT_COND_WITH_BACKUP(propID, prop, propAlt, Prop) \
 if (id == propID) { \
     if (m_parentStyle->prop().isValid()) \
@@ -192,19 +192,19 @@ public:
     unsigned position() const { return m_position; }
     CSSStyleRule* rule() const { return m_rule; }
     CSSSelector* selector() const { return m_selector; }
-    
+
     bool hasFastCheckableSelector() const { return m_hasFastCheckableSelector; }
     bool hasMultipartSelector() const { return m_hasMultipartSelector; }
     bool hasRightmostSelectorMatchingHTMLBasedOnRuleHash() const { return m_hasRightmostSelectorMatchingHTMLBasedOnRuleHash; }
     bool containsUncommonAttributeSelector() const { return m_containsUncommonAttributeSelector; }
     unsigned specificity() const { return m_specificity; }
     unsigned linkMatchType() const { return m_linkMatchType; }
-    
+
     // Try to balance between memory usage (there can be lots of RuleData objects) and good filtering performance.
     static const unsigned maximumIdentifierCount = 4;
     const unsigned* descendantSelectorIdentifierHashes() const { return m_descendantSelectorIdentifierHashes; }
 
-private:    
+private:
     CSSStyleRule* m_rule;
     CSSSelector* m_selector;
     unsigned m_specificity;
@@ -223,9 +223,9 @@ class RuleSet {
 public:
     RuleSet();
     ~RuleSet();
-    
+
     typedef HashMap<AtomicStringImpl*, Vector<RuleData>*> AtomRuleMap;
-    
+
     void addRulesFromSheet(CSSStyleSheet*, const MediaQueryEvaluator&, CSSStyleSelector* = 0);
 
     void addStyleRule(CSSStyleRule* item);
@@ -237,7 +237,7 @@ public:
     void disableAutoShrinkToFit() { m_autoShrinkToFitEnabled = false; }
 
     void collectFeatures(CSSStyleSelector::Features&) const;
-    
+
     const Vector<RuleData>* idRules(AtomicStringImpl* key) const { return m_idRules.get(key); }
     const Vector<RuleData>* classRules(AtomicStringImpl* key) const { return m_classRules.get(key); }
     const Vector<RuleData>* tagRules(AtomicStringImpl* key) const { return m_tagRules.get(key); }
@@ -246,7 +246,7 @@ public:
     const Vector<RuleData>* focusPseudoClassRules() const { return &m_focusPseudoClassRules; }
     const Vector<RuleData>* universalRules() const { return &m_universalRules; }
     const Vector<RuleData>* pageRules() const { return &m_pageRules; }
-    
+
 public:
     AtomRuleMap m_idRules;
     AtomRuleMap m_classRules;
@@ -265,7 +265,7 @@ static RuleSet* defaultQuirksStyle;
 static RuleSet* defaultPrintStyle;
 static RuleSet* defaultViewSourceStyle;
 static CSSStyleSheet* simpleDefaultStyleSheet;
-    
+
 static RuleSet* siblingRulesInDefaultStyle;
 static RuleSet* uncommonAttributeRulesInDefaultStyle;
 
@@ -301,7 +301,7 @@ static inline void assertNoSiblingRulesInDefaultStyle()
     ASSERT(!siblingRulesInDefaultStyle);
 #endif
 }
-    
+
 static const MediaQueryEvaluator& screenEval()
 {
     DEFINE_STATIC_LOCAL(const MediaQueryEvaluator, staticScreenEval, ("screen"));
@@ -418,7 +418,7 @@ CSSStyleSelector::CSSStyleSelector(Document* document, StyleSheetList* styleShee
         StyleSheet* sheet = styleSheets->item(i);
         if (sheet->isCSSStyleSheet() && !sheet->disabled())
             m_authorStyle->addRulesFromSheet(static_cast<CSSStyleSheet*>(sheet), *m_medium, this);
-    }    
+    }
     // Collect all ids and rules using sibling selectors (:first-child and similar)
     // in the current set of stylesheets. Style sharing code uses this information to reject
     // sharing candidates.
@@ -458,8 +458,8 @@ CSSStyleSelector::~CSSStyleSelector()
     m_fontSelector->clearDocument();
     deleteAllValues(m_viewportDependentMediaQueryResults);
 }
-    
-CSSStyleSelector::Features::Features() 
+
+CSSStyleSelector::Features::Features()
     : usesFirstLineRules(false)
     , usesBeforeAfterRules(false)
     , usesLinkRules(false)
@@ -515,7 +515,7 @@ static void loadSimpleDefaultStyle()
 {
     ASSERT(!defaultStyle);
     ASSERT(!simpleDefaultStyleSheet);
-    
+
     defaultStyle = new RuleSet;
     // There are no media-specific rules in the simple default style.
     defaultPrintStyle = defaultStyle;
@@ -523,10 +523,10 @@ static void loadSimpleDefaultStyle()
 
     simpleDefaultStyleSheet = parseUASheet(simpleUserAgentStyleSheet, strlen(simpleUserAgentStyleSheet));
     defaultStyle->addRulesFromSheet(simpleDefaultStyleSheet, screenEval());
-    
+
     // No need to initialize quirks sheet yet as there are no quirk rules for elements allowed in simple default style.
 }
-    
+
 static void loadViewSourceStyle()
 {
     ASSERT(!defaultViewSourceStyle);
@@ -541,7 +541,7 @@ static void ensureDefaultStyleSheetsForElement(Element* element)
         assertNoSiblingRulesInDefaultStyle();
         collectSpecialRulesInDefaultStyle();
     }
-    
+
 #if ENABLE(SVG)
     static bool loadedSVGUserAgentSheet;
     if (element->isSVGElement() && !loadedSVGUserAgentSheet) {
@@ -554,7 +554,7 @@ static void ensureDefaultStyleSheetsForElement(Element* element)
         collectSpecialRulesInDefaultStyle();
     }
 #endif
-    
+
 #if ENABLE(MATHML)
     static bool loadedMathMLUserAgentSheet;
     if (element->isMathMLElement() && !loadedMathMLUserAgentSheet) {
@@ -567,7 +567,7 @@ static void ensureDefaultStyleSheetsForElement(Element* element)
         collectSpecialRulesInDefaultStyle();
     }
 #endif
-    
+
 #if ENABLE(VIDEO)
     static bool loadedMediaStyleSheet;
     if (!loadedMediaStyleSheet && (element->hasTagName(videoTag) || element->hasTagName(audioTag))) {
@@ -579,7 +579,7 @@ static void ensureDefaultStyleSheetsForElement(Element* element)
         collectSpecialRulesInDefaultStyle();
     }
 #endif
-    
+
 #if ENABLE(FULLSCREEN_API)
     static bool loadedFullScreenStyleSheet;
     if (!loadedFullScreenStyleSheet && element->document()->webkitIsFullScreen()) {
@@ -604,7 +604,7 @@ void CSSStyleSelector::matchRules(RuleSet* rules, int& firstRuleIndex, int& last
 
     if (!rules || !m_element)
         return;
-    
+
     // We need to collect the rules for id, class, tag, and everything else into a buffer and
     // then sort the buffer.
     if (m_element->hasID())
@@ -627,14 +627,14 @@ void CSSStyleSelector::matchRules(RuleSet* rules, int& firstRuleIndex, int& last
         matchRulesForList(rules->focusPseudoClassRules(), firstRuleIndex, lastRuleIndex, includeEmptyRules);
     matchRulesForList(rules->tagRules(m_element->localName().impl()), firstRuleIndex, lastRuleIndex, includeEmptyRules);
     matchRulesForList(rules->universalRules(), firstRuleIndex, lastRuleIndex, includeEmptyRules);
-    
+
     // If we didn't match any rules, we're done.
     if (m_matchedRules.isEmpty())
         return;
-    
+
     // Sort the set of matched rules.
     sortMatchedRules();
-    
+
     // Now transfer the set of matched rules over to our list of decls.
     if (!m_checker.isCollectingRulesOnly()) {
         // FIXME: This sucks, the inspector should get the style from the visited style itself.
@@ -712,8 +712,8 @@ void CSSStyleSelector::matchRulesForList(const Vector<RuleData>* rules, int& fir
             if (!decl || (!decl->length() && !includeEmptyRules))
                 continue;
             if (m_sameOriginOnly && !m_checker.document()->securityOrigin()->canRequest(rule->baseURL()))
-                continue; 
-            // If we're matching normal rules, set a pseudo bit if 
+                continue;
+            // If we're matching normal rules, set a pseudo bit if
             // we really just matched a pseudo-element.
             if (m_dynamicPseudo != NOPSEUDO && m_checker.pseudoStyle() == NOPSEUDO) {
                 if (m_checker.isCollectingRulesOnly())
@@ -737,14 +737,14 @@ static inline bool compareRules(const RuleData* r1, const RuleData* r2)
 {
     unsigned specificity1 = r1->specificity();
     unsigned specificity2 = r2->specificity();
-    return (specificity1 == specificity2) ? r1->position() < r2->position() : specificity1 < specificity2; 
+    return (specificity1 == specificity2) ? r1->position() < r2->position() : specificity1 < specificity2;
 }
 
 void CSSStyleSelector::sortMatchedRules()
 {
     std::sort(m_matchedRules.begin(), m_matchedRules.end(), compareRules);
 }
-    
+
 inline void CSSStyleSelector::initElement(Element* e)
 {
     if (m_element != e) {
@@ -842,22 +842,22 @@ bool CSSStyleSelector::canShareStyleWithControl(StyledElement* element) const
     if (element->hasTagName(progressTag)) {
         if (!m_element->hasTagName(progressTag))
             return false;
-        
+
         HTMLProgressElement* thisProgressElement = static_cast<HTMLProgressElement*>(element);
         HTMLProgressElement* otherProgressElement = static_cast<HTMLProgressElement*>(m_element);
         if (thisProgressElement->isDeterminate() != otherProgressElement->isDeterminate())
             return false;
-        
+
         return true;
     }
 #endif
-    
+
     HTMLInputElement* thisInputElement = element->toInputElement();
     HTMLInputElement* otherInputElement = m_element->toInputElement();
-    
+
     if (!thisInputElement || !otherInputElement)
         return false;
-    
+
     if (thisInputElement->isAutofilled() != otherInputElement->isAutofilled())
         return false;
     if (thisInputElement->shouldAppearChecked() != otherInputElement->shouldAppearChecked())
@@ -866,30 +866,30 @@ bool CSSStyleSelector::canShareStyleWithControl(StyledElement* element) const
         return false;
     if (thisInputElement->required() != otherInputElement->required())
         return false;
-    
+
     if (element->isEnabledFormControl() != m_element->isEnabledFormControl())
         return false;
-    
+
     if (element->isDefaultButtonForForm() != m_element->isDefaultButtonForForm())
         return false;
 
     if (!m_element->document()->containsValidityStyleRules())
         return false;
-    
+
     bool willValidate = element->willValidate();
-    
+
     if (willValidate != m_element->willValidate())
         return false;
-    
+
     if (willValidate && (element->isValidFormControlElement() != m_element->isValidFormControlElement()))
         return false;
-    
+
     if (element->isInRange() != m_element->isInRange())
         return false;
-    
+
     if (element->isOutOfRange() != m_element->isOutOfRange())
         return false;
-    
+
     return true;
 }
 
@@ -978,7 +978,7 @@ bool CSSStyleSelector::canShareStyleWithElement(Node* node) const
 
     return true;
 }
-    
+
 inline Node* CSSStyleSelector::findSiblingForStyleSharing(Node* node, unsigned& count) const
 {
     for (; node; node = node->previousSibling()) {
@@ -994,7 +994,7 @@ inline Node* CSSStyleSelector::findSiblingForStyleSharing(Node* node, unsigned&
 
 static inline bool parentStylePreventsSharing(const RenderStyle* parentStyle)
 {
-    return parentStyle->childrenAffectedByPositionalRules() 
+    return parentStyle->childrenAffectedByPositionalRules()
         || parentStyle->childrenAffectedByFirstChildRules()
         || parentStyle->childrenAffectedByLastChildRules();
 }
@@ -1052,7 +1052,7 @@ void CSSStyleSelector::matchUARules(int& firstUARule, int& lastUARule)
     // In quirks mode, we match rules from the quirks user agent sheet.
     if (!m_checker.strictParsing())
         matchRules(defaultQuirksStyle, firstUARule, lastUARule, false);
-        
+
     // If document uses view source styles (in view source mode or in xml viewer mode), then we match rules from the view source style sheet.
     if (m_checker.document()->isViewSource()) {
         if (!defaultViewSourceStyle)
@@ -1110,7 +1110,7 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForDocument(Document* document)
 
     documentStyle->setFontDescription(fontDescription);
     documentStyle->font().update(0);
-        
+
     return documentStyle.release();
 }
 
@@ -1218,7 +1218,7 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* element, Rend
                     addMatchedDeclaration(textDirection == LTR ? leftToRightDeclaration() : rightToLeftDeclaration());
             }
         }
-    
+
         // 6. Check the rules in author sheets next.
         if (m_matchAuthorAndUserStyles)
             matchRules(m_authorStyle.get(), firstAuthorRule, lastAuthorRule, false);
@@ -1234,7 +1234,7 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* element, Rend
             }
         }
     }
-    
+
     // Now we have all of the matched rules in the appropriate order.  Walk the rules and apply
     // high-priority properties first, i.e., those properties that other properties depend on.
     // The order is (1) high-priority not important, (2) high-priority important, (3) normal not important
@@ -1246,7 +1246,7 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* element, Rend
         applyDeclarations<true>(true, firstUserRule, lastUserRule);
     }
     applyDeclarations<true>(true, firstUARule, lastUARule);
-    
+
     // If our font got dirtied, go ahead and update it now.
     updateFont();
 
@@ -1256,10 +1256,10 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* element, Rend
 
     // Now do the normal priority UA properties.
     applyDeclarations<false>(false, firstUARule, lastUARule);
-    
+
     // Cache our border and background so that we can examine them later.
     cacheBorderAndBackground();
-    
+
     // Now do the author and user normal priority properties and all the !important properties.
     if (!resolveForRootDefault) {
         applyDeclarations<false>(false, lastUARule + 1, m_matchedDecls.size() - 1);
@@ -1269,7 +1269,7 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForElement(Element* element, Rend
     applyDeclarations<false>(true, firstUARule, lastUARule);
 
     ASSERT(!m_fontDirty);
-    // If our font got dirtied by one of the non-essential font props, 
+    // If our font got dirtied by one of the non-essential font props,
     // go ahead and update it a second time.
     updateFont();
 
@@ -1342,24 +1342,24 @@ PassRefPtr<RenderStyle> CSSStyleSelector::styleForKeyframe(const RenderStyle* el
 void CSSStyleSelector::keyframeStylesForAnimation(Element* e, const RenderStyle* elementStyle, KeyframeList& list)
 {
     list.clear();
-    
+
     // Get the keyframesRule for this name
     if (!e || list.animationName().isEmpty())
         return;
 
     m_keyframesRuleMap.checkConsistency();
-   
+
     if (!m_keyframesRuleMap.contains(list.animationName().impl()))
         return;
-        
+
     const WebKitCSSKeyframesRule* rule = m_keyframesRuleMap.find(list.animationName().impl()).get()->second.get();
-    
+
     // Construct and populate the style for each keyframe
     for (unsigned i = 0; i < rule->length(); ++i) {
         // Apply the declaration to the style. This is a simplified version of the logic in styleForElement
         initElement(e);
         initForStyleResolve(e);
-        
+
         const WebKitCSSKeyframeRule* keyframeRule = rule->item(i);
 
         KeyframeValue keyframe(0, 0);
@@ -1373,7 +1373,7 @@ void CSSStyleSelector::keyframeStylesForAnimation(Element* e, const RenderStyle*
             list.insert(keyframe);
         }
     }
-    
+
     // If the 0% keyframe is missing, create it (but only if there is at least one other keyframe)
     int initialListSize = list.size();
     if (initialListSize > 0 && list[0].key() != 0) {
@@ -1403,13 +1403,13 @@ PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForElement(PseudoId pseudo,
 
     initForStyleResolve(e, parentStyle, pseudo);
     m_style = RenderStyle::create();
-    
+
     if (m_parentStyle)
         m_style->inheritFrom(m_parentStyle);
 
     // Since we don't use pseudo-elements in any of our quirk/print user agent rules, don't waste time walking
     // those rules.
-    
+
     // Check UA, user and author rules.
     int firstUARule = -1, lastUARule = -1, firstUserRule = -1, lastUserRule = -1, firstAuthorRule = -1, lastAuthorRule = -1;
     matchUARules(firstUARule, lastUARule);
@@ -1423,7 +1423,7 @@ PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForElement(PseudoId pseudo,
         return 0;
 
     m_style->setStyleType(pseudo);
-    
+
     m_lineHeightValue = 0;
 
     // High-priority properties.
@@ -1431,26 +1431,26 @@ PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForElement(PseudoId pseudo,
     applyDeclarations<true>(true, firstAuthorRule, lastAuthorRule);
     applyDeclarations<true>(true, firstUserRule, lastUserRule);
     applyDeclarations<true>(true, firstUARule, lastUARule);
-    
+
     // If our font got dirtied, go ahead and update it now.
     updateFont();
 
     // Line-height is set when we are sure we decided on the font-size
     if (m_lineHeightValue)
         applyProperty(CSSPropertyLineHeight, m_lineHeightValue);
-    
+
     // Now do the normal priority properties.
     applyDeclarations<false>(false, firstUARule, lastUARule);
-    
+
     // Cache our border and background so that we can examine them later.
     cacheBorderAndBackground();
-    
+
     applyDeclarations<false>(false, lastUARule + 1, m_matchedDecls.size() - 1);
     applyDeclarations<false>(true, firstAuthorRule, lastAuthorRule);
     applyDeclarations<false>(true, firstUserRule, lastUserRule);
     applyDeclarations<false>(true, firstUARule, lastUARule);
-    
-    // If our font got dirtied by one of the non-essential font props, 
+
+    // If our font got dirtied by one of the non-essential font props,
     // go ahead and update it a second time.
     updateFont();
 
@@ -1459,7 +1459,7 @@ PassRefPtr<RenderStyle> CSSStyleSelector::pseudoStyleForElement(PseudoId pseudo,
 
     // Start loading images referenced by this style.
     loadPendingImages();
-        
+
     // Now return the style.
     return m_style.release();
 }
@@ -1500,7 +1500,7 @@ static void addIntrinsicMargins(RenderStyle* style)
 {
     // Intrinsic margin value.
     const int intrinsicMargin = 2 * style->effectiveZoom();
-    
+
     // FIXME: Using width/height alone and not also dealing with min-width/max-width is flawed.
     // FIXME: Using "quirk" to decide the margin wasn't set is kind of lame.
     if (style->width().isIntrinsicOrAuto()) {
@@ -1587,12 +1587,12 @@ void CSSStyleSelector::adjustRenderStyle(RenderStyle* style, RenderStyle* parent
             else
                 style->setDisplay(BLOCK);
         }
-        
+
         // FIXME: Don't support this mutation for pseudo styles like first-letter or first-line, since it's not completely
         // clear how that should work.
         if (style->display() == INLINE && style->styleType() == NOPSEUDO && parentStyle && style->writingMode() != parentStyle->writingMode())
             style->setDisplay(INLINE_BLOCK);
-        
+
         // After performing the display mutation, check table rows.  We do not honor position:relative on
         // table rows or cells.  This has been established in CSS2.1 (and caused a crash in containingBlock()
         // on some sites).
@@ -1622,8 +1622,8 @@ void CSSStyleSelector::adjustRenderStyle(RenderStyle* style, RenderStyle* parent
     // Auto z-index becomes 0 for the root element and transparent objects.  This prevents
     // cases where objects that should be blended as a single unit end up with a non-transparent
     // object wedged in between them.  Auto z-index also becomes 0 for objects that specify transforms/masks/reflections.
-    if (style->hasAutoZIndex() && ((e && e->document()->documentElement() == e) || style->opacity() < 1.0f || 
-        style->hasTransformRelatedProperty() || style->hasMask() || style->boxReflect()))
+    if (style->hasAutoZIndex() && ((e && e->document()->documentElement() == e) || style->opacity() < 1.0f
+        || style->hasTransformRelatedProperty() || style->hasMask() || style->boxReflect()))
         style->setZIndex(0);
 
     // Textarea considers overflow visible as auto.
@@ -1639,7 +1639,7 @@ void CSSStyleSelector::adjustRenderStyle(RenderStyle* style, RenderStyle* parent
         style->setTextDecorationsInEffect(style->textDecoration());
     else
         style->addToTextDecorationsInEffect(style->textDecoration());
-    
+
     // If either overflow value is not visible, change to auto.
     if (style->overflowX() == OMARQUEE && style->overflowY() != OMARQUEE)
         style->setOverflowY(OMARQUEE);
@@ -1654,9 +1654,9 @@ void CSSStyleSelector::adjustRenderStyle(RenderStyle* style, RenderStyle* parent
     // FIXME: Eventually table sections will support auto and scroll.
     if (style->display() == TABLE || style->display() == INLINE_TABLE ||
         style->display() == TABLE_ROW_GROUP || style->display() == TABLE_ROW) {
-        if (style->overflowX() != OVISIBLE && style->overflowX() != OHIDDEN) 
+        if (style->overflowX() != OVISIBLE && style->overflowX() != OHIDDEN)
             style->setOverflowX(OVISIBLE);
-        if (style->overflowY() != OVISIBLE && style->overflowY() != OHIDDEN) 
+        if (style->overflowY() != OVISIBLE && style->overflowY() != OHIDDEN)
             style->setOverflowY(OVISIBLE);
     }
 
@@ -1767,7 +1767,7 @@ PassRefPtr<CSSRuleList> CSSStyleSelector::pseudoStyleRulesForElement(Element* e,
     }
 
     m_checker.setCollectingRulesOnly(false);
-   
+
     return m_ruleList.release();
 }
 
@@ -1849,7 +1849,7 @@ static inline bool containsUncommonAttributeSelector(const CSSSelector* selector
         selector = selector->tagHistory();
     };
 
-    for (selector = selector->tagHistory(); selector; selector = selector->tagHistory()) {            
+    for (selector = selector->tagHistory(); selector; selector = selector->tagHistory()) {
         if (selector->isAttributeSelector())
             return true;
         if (selectorListContainsUncommonAttributeSelector(selector))
@@ -1879,7 +1879,7 @@ RuleSet::RuleSet()
 }
 
 RuleSet::~RuleSet()
-{ 
+{
     deleteAllValues(m_idRules);
     deleteAllValues(m_classRules);
     deleteAllValues(m_shadowPseudoElementRules);
@@ -2008,7 +2008,7 @@ void RuleSet::addStyleRule(CSSStyleRule* rule)
             addRule(rule, s);
     }
 }
-    
+
 static inline void collectFeaturesFromSelector(CSSStyleSelector::Features& features, const CSSSelector* selector)
 {
     if (selector->m_match == CSSSelector::Id && !selector->value().isEmpty())
@@ -2053,12 +2053,12 @@ static void collectFeaturesFromList(CSSStyleSelector::Features& features, const
         if (foundSiblingSelector) {
             if (!features.siblingRules)
                 features.siblingRules = adoptPtr(new RuleSet);
-            features.siblingRules->addRule(ruleData.rule(), ruleData.selector());   
+            features.siblingRules->addRule(ruleData.rule(), ruleData.selector());
         }
         if (ruleData.containsUncommonAttributeSelector()) {
             if (!features.uncommonAttributeRules)
                 features.uncommonAttributeRules = adoptPtr(new RuleSet);
-            features.uncommonAttributeRules->addRule(ruleData.rule(), ruleData.selector()); 
+            features.uncommonAttributeRules->addRule(ruleData.rule(), ruleData.selector());
         }
     }
 }
@@ -2081,14 +2081,14 @@ void RuleSet::collectFeatures(CSSStyleSelector::Features& features) const
     collectFeaturesFromList(features, m_focusPseudoClassRules);
     collectFeaturesFromList(features, m_universalRules);
 }
-    
+
 static inline void shrinkMapVectorsToFit(RuleSet::AtomRuleMap& map)
 {
     RuleSet::AtomRuleMap::iterator end = map.end();
     for (RuleSet::AtomRuleMap::iterator it = map.begin(); it != end; ++it)
         it->second->shrinkToFit();
 }
-    
+
 void RuleSet::shrinkToFit()
 {
     shrinkMapVectorsToFit(m_idRules);
@@ -2115,7 +2115,7 @@ static Length convertToLength(CSSPrimitiveValue* primitiveValue, RenderStyle* st
             *ok = false;
     } else {
         int type = primitiveValue->primitiveType();
-        
+
         if (!style && (type == CSSPrimitiveValue::CSS_EMS || type == CSSPrimitiveValue::CSS_EXS || type == CSSPrimitiveValue::CSS_REMS)) {
             if (ok)
                 *ok = false;
@@ -2134,7 +2134,7 @@ static Length convertToLength(CSSPrimitiveValue* primitiveValue, RenderStyle* st
     }
     return l;
 }
-    
+
 static Length convertToIntLength(CSSPrimitiveValue* primitiveValue, RenderStyle* style, RenderStyle* rootStyle, double multiplier = 1, bool *ok = 0)
 {
     return convertToLength(primitiveValue, style, rootStyle, false, multiplier, ok);
@@ -2144,24 +2144,24 @@ static Length convertToFloatLength(CSSPrimitiveValue* primitiveValue, RenderStyl
 {
     return convertToLength(primitiveValue, style, rootStyle, true, multiplier, ok);
 }
-    
+
 template <bool applyFirst>
 void CSSStyleSelector::applyDeclaration(CSSMutableStyleDeclaration* styleDeclaration, bool isImportant)
 {
     CSSMutableStyleDeclaration::const_iterator end = styleDeclaration->end();
     for (CSSMutableStyleDeclaration::const_iterator it = styleDeclaration->begin(); it != end; ++it) {
         const CSSProperty& current = *it;
-        
+
         if (isImportant != current.isImportant())
             continue;
-        
+
         int property = current.id();
-        
+
         if (applyFirst) {
             COMPILE_ASSERT(firstCSSProperty == CSSPropertyColor, CSS_color_is_first_property);
             COMPILE_ASSERT(CSSPropertyZoom == CSSPropertyColor + 16, CSS_zoom_is_end_of_first_prop_range);
             COMPILE_ASSERT(CSSPropertyLineHeight == CSSPropertyZoom + 1, CSS_line_height_is_after_zoom);
-            
+
             // give special priority to font-xxx, color properties, etc
             if (property > CSSPropertyLineHeight)
                 continue;
@@ -2192,13 +2192,13 @@ void CSSStyleSelector::applyDeclarations(bool isImportant, int startIndex, int e
             m_applyPropertyToRegularStyle = linkMatchType & SelectorChecker::MatchLink;
             m_applyPropertyToVisitedLinkStyle = linkMatchType & SelectorChecker::MatchVisited;
 
-            applyDeclaration<applyFirst>(styleDeclaration, isImportant);        
+            applyDeclaration<applyFirst>(styleDeclaration, isImportant);
         }
         m_applyPropertyToRegularStyle = true;
         m_applyPropertyToVisitedLinkStyle = false;
         return;
     }
-    for (int i = startIndex; i <= endIndex; ++i)        
+    for (int i = startIndex; i <= endIndex; ++i)
         applyDeclaration<applyFirst>(m_matchedDecls[i].styleDeclaration, isImportant);
 }
 
@@ -2405,7 +2405,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
     CSSPrimitiveValue* primitiveValue = value->isPrimitiveValue() ? static_cast<CSSPrimitiveValue*>(value) : 0;
 
     float zoomFactor = m_style->effectiveZoom();
-    
+
     // What follows is a list that maps the CSS properties into their corresponding front-end
     // RenderStyle values.  Shorthands (e.g. border, background) occur in this list as well and
     // are only hit when mapping "inherit" or "initial" into front-end values.
@@ -2446,10 +2446,10 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
     case CSSPropertyTableLayout:
         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(tableLayout, TableLayout)
         return;
-    case CSSPropertyUnicodeBidi: 
+    case CSSPropertyUnicodeBidi:
         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(unicodeBidi, UnicodeBidi)
         return;
-    case CSSPropertyTextTransform: 
+    case CSSPropertyTextTransform:
         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(textTransform, TextTransform)
         return;
     case CSSPropertyVisibility:
@@ -2500,7 +2500,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
                 r = settings->textAreasAreResizable() ? RESIZE_BOTH : RESIZE_NONE;
         } else
             r = *primitiveValue;
-            
+
         m_style->setResize(r);
         return;
     }
@@ -2532,7 +2532,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
         fontDescription.setKeywordSize(0);
         float oldSize = 0;
         float size = 0;
-        
+
         bool parentIsAbsoluteSize = false;
         if (m_parentNode) {
             oldSize = m_parentStyle->fontDescription().specifiedSize();
@@ -2570,16 +2570,16 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
                     return;
             }
 
-            fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize && 
-                                              (primitiveValue->getIdent() == CSSValueLarger ||
-                                               primitiveValue->getIdent() == CSSValueSmaller));
+            fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize
+                                              && (primitiveValue->getIdent() == CSSValueLarger
+                                                  || primitiveValue->getIdent() == CSSValueSmaller));
         } else {
             int type = primitiveValue->primitiveType();
-            fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize ||
-                                              (type != CSSPrimitiveValue::CSS_PERCENTAGE &&
-                                               type != CSSPrimitiveValue::CSS_EMS && 
-                                               type != CSSPrimitiveValue::CSS_EXS &&
-                                               type != CSSPrimitiveValue::CSS_REMS));
+            fontDescription.setIsAbsoluteSize(parentIsAbsoluteSize
+                                              || (type != CSSPrimitiveValue::CSS_PERCENTAGE
+                                                  && type != CSSPrimitiveValue::CSS_EMS
+                                                  && type != CSSPrimitiveValue::CSS_EXS
+                                                  && type != CSSPrimitiveValue::CSS_REMS));
             if (CSSPrimitiveValue::isUnitTypeLength(type))
                 size = primitiveValue->computeLength<float>(m_parentStyle, m_rootElementStyle, 1.0, true);
             else if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
@@ -2684,7 +2684,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
         }
         m_style->setClip(top, right, bottom, left);
         m_style->setHasClip(hasClip);
-    
+
         // rect, ident
         return;
     }
@@ -2700,7 +2700,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
             m_style->clearContent();
             return;
         }
-        
+
         if (!value->isValueList())
             return;
 
@@ -2833,7 +2833,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
             setFontDescription(fontDescription);
             return;
         }
-        
+
         if (!value->isValueList())
             return;
         FontDescription fontDescription = m_style->fontDescription();
@@ -2996,7 +2996,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
         } else if (primitiveValue) {
             m_style->setLineHeight(RenderStyle::initialLineHeight());
             m_lineHeightValue = 0;
-            
+
             FontDescription fontDescription;
             RenderTheme::defaultTheme()->systemFont(primitiveValue->getIdent(), fontDescription);
 
@@ -3009,7 +3009,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
                     return;
                 fontDescription.setRenderingMode(settings->fontRenderingMode());
                 fontDescription.setUsePrinterFont(m_checker.document()->printing());
-           
+
                 // Handle the zoom factor.
                 fontDescription.setComputedSize(getComputedSizeFromSpecifiedSize(m_checker.document(), m_style.get(), fontDescription.isAbsoluteSize(), fontDescription.specifiedSize(), useSVGZoomRules()));
                 setFontDescription(fontDescription);
@@ -3085,7 +3085,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
             image.setOutset(LengthBox());
         else
             image.setOutset(mapNinePieceImageQuad(value));
-        
+
         if (isBorderImage)
             m_style->setBorderImage(image);
         else
@@ -3103,7 +3103,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
             image.setVerticalRule(StretchImageRule);
         } else
             mapNinePieceImageRepeat(value, image);
-        
+
         if (isBorderImage)
             m_style->setBorderImage(image);
         else
@@ -3122,7 +3122,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
             image.setFill(false);
         } else
             mapNinePieceImageSlice(value, image);
-        
+
         if (isBorderImage)
             m_style->setBorderImage(image);
         else
@@ -3191,7 +3191,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
             m_style->setBoxReflect(RenderStyle::initialBoxReflect());
             return;
         }
-        
+
         if (!value->isReflectValue())
             return;
 
@@ -3209,7 +3209,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
         mask.setMaskDefaults();
         mapNinePieceImage(property, reflectValue->mask(), mask);
         reflection->setMask(mask);
-        
+
         m_style->setBoxReflect(reflection.release());
         return;
     }
@@ -3315,7 +3315,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
         return;
     }
     case CSSPropertyWebkitMarqueeSpeed: {
-        HANDLE_INHERIT_AND_INITIAL(marqueeSpeed, MarqueeSpeed)      
+        HANDLE_INHERIT_AND_INITIAL(marqueeSpeed, MarqueeSpeed)
         if (!primitiveValue)
             return;
         if (primitiveValue->getIdent()) {
@@ -3365,7 +3365,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
         return;
     }
     case CSSPropertyWebkitMarqueeStyle:
-        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(marqueeBehavior, MarqueeBehavior)      
+        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(marqueeBehavior, MarqueeBehavior)
         return;
     case CSSPropertyWebkitFlowInto:
         HANDLE_INHERIT_AND_INITIAL(flowThread, FlowThread);
@@ -3388,13 +3388,13 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(marqueeDirection, MarqueeDirection)
         return;
     case CSSPropertyWebkitUserDrag:
-        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(userDrag, UserDrag)      
+        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(userDrag, UserDrag)
         return;
     case CSSPropertyWebkitUserModify:
-        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(userModify, UserModify)      
+        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(userModify, UserModify)
         return;
     case CSSPropertyWebkitUserSelect:
-        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(userSelect, UserSelect)      
+        HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(userSelect, UserSelect)
         return;
 
     case CSSPropertyTextOverflow: {
@@ -3480,7 +3480,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
         DashboardRegion *region = primitiveValue->getDashboardRegionValue();
         if (!region)
             return;
-            
+
         DashboardRegion *first = region;
         while (region) {
             Length top = convertToIntLength(region->top(), style(), m_rootElementStyle);
@@ -3493,12 +3493,12 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
                 m_style->setDashboardRegion(StyleDashboardRegion::Rectangle, region->m_label, top, right, bottom, left, region == first ? false : true);
             region = region->m_next.get();
         }
-        
+
         m_element->document()->setHasDashboardRegions(true);
-        
+
         return;
     }
-#endif        
+#endif
     case CSSPropertyWebkitRtlOrdering:
         HANDLE_INHERIT_AND_INITIAL_AND_PRIMITIVE(rtlOrdering, RTLOrdering)
         return;
@@ -3540,7 +3540,7 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
             m_style->setPerspective(0);
             return;
         }
-        
+
         float perspectiveValue;
         int type = primitiveValue->primitiveType();
         if (CSSPrimitiveValue::isUnitTypeLength(type))
@@ -3682,20 +3682,20 @@ void CSSStyleSelector::applyProperty(int id, CSSValue *value)
             m_style->setLineBoxContain(LineBoxContainNone);
             return;
         }
-        
+
         if (!value->isCSSLineBoxContainValue())
             return;
-        
+
         CSSLineBoxContainValue* lineBoxContainValue = static_cast<CSSLineBoxContainValue*>(value);
         m_style->setLineBoxContain(lineBoxContainValue->value());
         return;
     }
-    
+
     case CSSPropertyWebkitWrapShape:
         HANDLE_INHERIT_AND_INITIAL(wrapShape, WrapShape);
         if (!primitiveValue)
             return;
-        
+
         if (primitiveValue->getIdent() == CSSValueAuto)
             m_style->setWrapShape(0);
         else if (primitiveValue->primitiveType() == CSSPrimitiveValue::CSS_SHAPE)
@@ -4085,7 +4085,7 @@ void CSSStyleSelector::mapFillComposite(CSSPropertyID, FillLayer* layer, CSSValu
         layer->setComposite(FillLayer::initialFillComposite(layer->type()));
         return;
     }
-    
+
     if (!value->isPrimitiveValue())
         return;
 
@@ -4142,7 +4142,7 @@ void CSSStyleSelector::mapFillRepeatX(CSSPropertyID, FillLayer* layer, CSSValue*
         layer->setRepeatX(FillLayer::initialFillRepeatX(layer->type()));
         return;
     }
-    
+
     if (!value->isPrimitiveValue())
         return;
 
@@ -4156,7 +4156,7 @@ void CSSStyleSelector::mapFillRepeatY(CSSPropertyID, FillLayer* layer, CSSValue*
         layer->setRepeatY(FillLayer::initialFillRepeatY(layer->type()));
         return;
     }
-    
+
     if (!value->isPrimitiveValue())
         return;
 
@@ -4178,9 +4178,9 @@ void CSSStyleSelector::mapFillSize(CSSPropertyID, FillLayer* layer, CSSValue* va
         layer->setSizeType(Cover);
     else
         layer->setSizeType(SizeLength);
-    
+
     LengthSize b = FillLayer::initialFillSizeLength(layer->type());
-    
+
     if (value->cssValueType() == CSSValue::CSS_INITIAL || primitiveValue->getIdent() == CSSValueContain
         || primitiveValue->getIdent() == CSSValueCover) {
         layer->setSizeLength(b);
@@ -4191,7 +4191,7 @@ void CSSStyleSelector::mapFillSize(CSSPropertyID, FillLayer* layer, CSSValue* va
 
     CSSPrimitiveValue* first = pair ? static_cast<CSSPrimitiveValue*>(pair->first()) : primitiveValue;
     CSSPrimitiveValue* second = pair ? static_cast<CSSPrimitiveValue*>(pair->second()) : 0;
-    
+
     Length firstLength, secondLength;
     int firstType = first->primitiveType();
     int secondType = second ? second->primitiveType() : 0;
@@ -4215,7 +4215,7 @@ void CSSStyleSelector::mapFillSize(CSSPropertyID, FillLayer* layer, CSSValue* va
         secondLength = Length(second->getDoubleValue(), Percent);
     else
         return;
-    
+
     b.setWidth(firstLength);
     b.setHeight(secondLength);
     layer->setSizeLength(b);
@@ -4227,7 +4227,7 @@ void CSSStyleSelector::mapFillXPosition(CSSPropertyID, FillLayer* layer, CSSValu
         layer->setXPosition(FillLayer::initialFillXPosition(layer->type()));
         return;
     }
-    
+
     if (!value->isPrimitiveValue())
         return;
 
@@ -4251,12 +4251,12 @@ void CSSStyleSelector::mapFillYPosition(CSSPropertyID, FillLayer* layer, CSSValu
         layer->setYPosition(FillLayer::initialFillYPosition(layer->type()));
         return;
     }
-    
+
     if (!value->isPrimitiveValue())
         return;
 
     float zoomFactor = m_style->effectiveZoom();
-    
+
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     Length l;
     int type = primitiveValue->primitiveType();
@@ -4418,7 +4418,7 @@ void CSSStyleSelector::mapAnimationTimingFunction(Animation* animation, CSSValue
         animation->setTimingFunction(Animation::initialAnimationTimingFunction());
         return;
     }
-    
+
     if (value->isPrimitiveValue()) {
         CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
         switch (primitiveValue->getIdent()) {
@@ -4446,7 +4446,7 @@ void CSSStyleSelector::mapAnimationTimingFunction(Animation* animation, CSSValue
         }
         return;
     }
-    
+
     if (value->isTimingFunctionValue()) {
         CSSTimingFunctionValue* timingFunction = static_cast<CSSTimingFunctionValue*>(value);
         if (timingFunction->isCubicBezierTimingFunctionValue()) {
@@ -4468,7 +4468,7 @@ void CSSStyleSelector::mapNinePieceImage(CSSPropertyID property, CSSValue* value
 
     // Retrieve the border image value.
     CSSBorderImageValue* borderImage = static_cast<CSSBorderImageValue*>(value);
-    
+
     // Set the image (this kicks off the load).
     CSSPropertyID imageProperty;
     if (property == CSSPropertyWebkitBorderImage || property == CSSPropertyBorderImage)
@@ -4477,7 +4477,7 @@ void CSSStyleSelector::mapNinePieceImage(CSSPropertyID property, CSSValue* value
         imageProperty = CSSPropertyWebkitMaskBoxImageSource;
     else
         imageProperty = property;
-        
+
     if (CSSValue* imageValue = borderImage->imageValue())
         image.setImage(styleImage(imageProperty, imageValue));
 
@@ -4487,7 +4487,7 @@ void CSSStyleSelector::mapNinePieceImage(CSSPropertyID property, CSSValue* value
     // Map in the border slices.
     if (borderImage->m_borderSlice)
         image.setBorderSlices(mapNinePieceImageQuad(borderImage->m_borderSlice.get()));
-    
+
     // Map in the outset.
     if (borderImage->m_outset)
         image.setOutset(mapNinePieceImageQuad(borderImage->m_outset.get()));
@@ -4592,7 +4592,7 @@ void CSSStyleSelector::mapNinePieceImageRepeat(CSSValue* value, NinePieceImage&
 {
     if (!value || !value->isPrimitiveValue())
         return;
-    
+
     CSSPrimitiveValue* primitiveValue = static_cast<CSSPrimitiveValue*>(value);
     Pair* pair = primitiveValue->getPairValue();
     if (!pair || !pair->first() || !pair->second())
@@ -4640,7 +4640,7 @@ void CSSStyleSelector::checkForTextSizeAdjust()
 {
     if (m_style->textSizeAdjust())
         return;
+
     FontDescription newFontDescription(m_style->fontDescription());
     newFontDescription.setComputedSize(newFontDescription.specifiedSize());
     m_style->setFontDescription(newFontDescription);
@@ -4650,7 +4650,7 @@ void CSSStyleSelector::checkForZoomChange(RenderStyle* style, RenderStyle* paren
 {
     if (style->effectiveZoom() == parentStyle->effectiveZoom())
         return;
-    
+
     const FontDescription& childFont = style->fontDescription();
     FontDescription newFontDescription(childFont);
     setFontSize(newFontDescription, childFont.specifiedSize());
@@ -4660,7 +4660,7 @@ void CSSStyleSelector::checkForZoomChange(RenderStyle* style, RenderStyle* paren
 void CSSStyleSelector::checkForGenericFamilyChange(RenderStyle* style, RenderStyle* parentStyle)
 {
     const FontDescription& childFont = style->fontDescription();
-  
+
     if (childFont.isAbsoluteSize() || !parentStyle)
         return;
 
@@ -4731,7 +4731,7 @@ float CSSStyleSelector::getComputedSizeFromSpecifiedSize(Document* document, flo
     // With the smart minimum, we never want to get smaller than the minimum font size to keep fonts readable.
     // However we always allow the page to set an explicit pixel size that is smaller,
     // since sites will mis-render otherwise (e.g., http://www.gamespot.com with a 9px minimum).
-    
+
     Settings* settings = document->settings();
     if (!settings)
         return 1.0f;
@@ -4750,7 +4750,7 @@ float CSSStyleSelector::getComputedSizeFromSpecifiedSize(Document* document, flo
     // doing so won't disrupt the layout.
     if (useSmartMinimumForFontSize && zoomedSize < minLogicalSize && (specifiedSize >= minLogicalSize || !isAbsoluteSize))
         zoomedSize = minLogicalSize;
-    
+
     // Also clamp to a reasonable maximum to prevent insane font sizes from causing crashes on various
     // platforms (I'm looking at you, Windows.)
     return min(1000000.0f, zoomedSize);
@@ -4812,7 +4812,7 @@ float CSSStyleSelector::fontSizeForKeyword(Document* document, int keyword, bool
         int col = (keyword - CSSValueXxSmall);
         return quirksMode ? quirksFontSizeTable[row][col] : strictFontSizeTable[row][col];
     }
-    
+
     // Value is outside the range of the table. Apply the scale factor instead.
     float minLogicalSize = max(settings->minimumLogicalFontSize(), 1);
     return max(fontSizeFactors[keyword - CSSValueXxSmall]*mediumSize, minLogicalSize);
@@ -4848,14 +4848,14 @@ int CSSStyleSelector::legacyFontSize(Document* document, int pixelFontSize, bool
 float CSSStyleSelector::largerFontSize(float size, bool) const
 {
     // FIXME: Figure out where we fall in the size ranges (xx-small to xxx-large) and scale up to
-    // the next size level.  
+    // the next size level.
     return size * 1.2f;
 }
 
 float CSSStyleSelector::smallerFontSize(float size, bool) const
 {
     // FIXME: Figure out where we fall in the size ranges (xx-small to xxx-large) and scale down to
-    // the next size level. 
+    // the next size level.
     return size / 1.2f;
 }
 
@@ -4994,9 +4994,9 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
         }
         if (haveNonPrimitiveValue)
             continue;
-        
+
         CSSPrimitiveValue* firstValue = static_cast<CSSPrimitiveValue*>(transformValue->itemWithoutBoundsCheck(0));
-         
+
         switch (transformValue->operationType()) {
             case WebKitCSSTransformValue::ScaleTransformOperation:
             case WebKitCSSTransformValue::ScaleXTransformOperation:
@@ -5005,13 +5005,13 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                 double sy = 1.0;
                 if (transformValue->operationType() == WebKitCSSTransformValue::ScaleYTransformOperation)
                     sy = firstValue->getDoubleValue();
-                else { 
+                else {
                     sx = firstValue->getDoubleValue();
                     if (transformValue->operationType() != WebKitCSSTransformValue::ScaleXTransformOperation) {
                         if (transformValue->length() > 1) {
                             CSSPrimitiveValue* secondValue = static_cast<CSSPrimitiveValue*>(transformValue->itemWithoutBoundsCheck(1));
                             sy = secondValue->getDoubleValue();
-                        } else 
+                        } else
                             sy = sx;
                     }
                 }
@@ -5027,7 +5027,7 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                     sz = firstValue->getDoubleValue();
                 else if (transformValue->operationType() == WebKitCSSTransformValue::ScaleYTransformOperation)
                     sy = firstValue->getDoubleValue();
-                else { 
+                else {
                     sx = firstValue->getDoubleValue();
                     if (transformValue->operationType() != WebKitCSSTransformValue::ScaleXTransformOperation) {
                         if (transformValue->length() > 2) {
@@ -5037,7 +5037,7 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                         if (transformValue->length() > 1) {
                             CSSPrimitiveValue* secondValue = static_cast<CSSPrimitiveValue*>(transformValue->itemWithoutBoundsCheck(1));
                             sy = secondValue->getDoubleValue();
-                        } else 
+                        } else
                             sy = sx;
                     }
                 }
@@ -5052,7 +5052,7 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                 Length ty = Length(0, Fixed);
                 if (transformValue->operationType() == WebKitCSSTransformValue::TranslateYTransformOperation)
                     ty = convertToFloatLength(firstValue, style, rootStyle, zoomFactor, &ok);
-                else { 
+                else {
                     tx = convertToFloatLength(firstValue, style, rootStyle, zoomFactor, &ok);
                     if (transformValue->operationType() != WebKitCSSTransformValue::TranslateXTransformOperation) {
                         if (transformValue->length() > 1) {
@@ -5078,7 +5078,7 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                     tz = convertToFloatLength(firstValue, style, rootStyle, zoomFactor, &ok);
                 else if (transformValue->operationType() == WebKitCSSTransformValue::TranslateYTransformOperation)
                     ty = convertToFloatLength(firstValue, style, rootStyle, zoomFactor, &ok);
-                else { 
+                else {
                     tx = convertToFloatLength(firstValue, style, rootStyle, zoomFactor, &ok);
                     if (transformValue->operationType() != WebKitCSSTransformValue::TranslateXTransformOperation) {
                         if (transformValue->length() > 2) {
@@ -5106,7 +5106,7 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                     angle = grad2deg(angle);
                 else if (firstValue->primitiveType() == CSSPrimitiveValue::CSS_TURN)
                     angle = turn2deg(angle);
-                
+
                 operations.operations().append(RotateTransformOperation::create(0, 0, 1, angle, getTransformOperationType(transformValue->operationType())));
                 break;
             }
@@ -5121,7 +5121,7 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                     angle = rad2deg(angle);
                 else if (firstValue->primitiveType() == CSSPrimitiveValue::CSS_GRAD)
                     angle = grad2deg(angle);
-                
+
                 if (transformValue->operationType() == WebKitCSSTransformValue::RotateXTransformOperation)
                     x = 1;
                 else if (transformValue->operationType() == WebKitCSSTransformValue::RotateYTransformOperation)
@@ -5213,7 +5213,7 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                                    static_cast<CSSPrimitiveValue*>(transformValue->itemWithoutBoundsCheck(15))->getDoubleValue());
                 operations.operations().append(Matrix3DTransformOperation::create(matrix));
                 break;
-            }   
+            }
             case WebKitCSSTransformValue::PerspectiveTransformOperation: {
                 bool ok = true;
                 Length p = Length(0, Fixed);
@@ -5225,7 +5225,7 @@ bool CSSStyleSelector::createTransformOperations(CSSValue* inValue, RenderStyle*
                     ok = val >= 0;
                     p = Length(clampToPositiveInteger(val), Fixed);
                 }
-                
+
                 if (!ok)
                     return false;
 
@@ -5280,7 +5280,7 @@ bool CSSStyleSelector::createFilterOperations(CSSValue* inValue, RenderStyle* st
         outOperations.clear();
         return false;
     }
-    
+
     float zoomFactor = style ? style->effectiveZoom() : 1;
     FilterOperations operations;
     for (CSSValueListIterator i = inValue; i.hasMore(); i.advance()) {
@@ -5411,13 +5411,13 @@ void CSSStyleSelector::loadPendingImages()
 {
     if (m_pendingImageProperties.isEmpty())
         return;
-        
+
     HashSet<int>::const_iterator end = m_pendingImageProperties.end();
     for (HashSet<int>::const_iterator it = m_pendingImageProperties.begin(); it != end; ++it) {
         CSSPropertyID currentProperty = static_cast<CSSPropertyID>(*it);
 
         CachedResourceLoader* cachedResourceLoader = m_element->document()->cachedResourceLoader();
-        
+
         switch (currentProperty) {
             case CSSPropertyBackgroundImage: {
                 for (FillLayer* backgroundLayer = m_style->accessBackgroundLayers(); backgroundLayer; backgroundLayer = backgroundLayer->next()) {
index b02b229e3eb08e861b6efab1c115e1a66947b01a..67e4b46c32438e49c42926882c41992b147a7594 100644 (file)
@@ -93,13 +93,13 @@ public:
                      CSSStyleSheet* pageUserSheet, const Vector<RefPtr<CSSStyleSheet> >* pageGroupUserSheets, const Vector<RefPtr<CSSStyleSheet> >* documentUserSheets,
                      bool strictParsing, bool matchAuthorAndUserStyles);
     ~CSSStyleSelector();
-    
+
     // Using these during tree walk will allow style selector to optimize child and descendant selector lookups.
     void pushParent(Element* parent) { m_checker.pushParent(parent); }
     void popParent(Element* parent) { m_checker.popParent(parent); }
 
     PassRefPtr<RenderStyle> styleForElement(Element*, RenderStyle* parentStyle = 0, bool allowSharing = true, bool resolveForRootDefault = false);
-    
+
     void keyframeStylesForAnimation(Element*, const RenderStyle*, KeyframeList&);
 
     PassRefPtr<RenderStyle> pseudoStyleForElement(PseudoId, Element*, RenderStyle* parentStyle = 0);
@@ -163,7 +163,7 @@ public:
     void setStyle(PassRefPtr<RenderStyle> s) { m_style = s; } // Used by the document when setting up its root style.
 
     void applyPropertyToStyle(int id, CSSValue*, RenderStyle*);
-    
+
     static float getComputedSizeFromSpecifiedSize(Document*, float zoomFactor, bool isAbsoluteSize, float specifiedSize, ESmartMinimumForFontSize = UseSmartMinimumForFontFize);
 
 private:
@@ -229,7 +229,7 @@ private:
     void matchRulesForList(const Vector<RuleData>*, int& firstRuleIndex, int& lastRuleIndex, bool includeEmptyRules);
     bool fastRejectSelector(const RuleData&) const;
     void sortMatchedRules();
-    
+
     bool checkSelector(const RuleData&);
 
     template <bool firstPass>
@@ -243,7 +243,7 @@ private:
     bool isRightPage(int pageIndex) const { return !isLeftPage(pageIndex); }
     bool isFirstPage(int pageIndex) const;
     String pageName(int pageIndex) const;
-    
+
     OwnPtr<RuleSet> m_authorStyle;
     OwnPtr<RuleSet> m_userStyle;
 
@@ -264,7 +264,7 @@ public:
 
     StyleImage* styleImage(CSSPropertyID, CSSValue*);
     StyleImage* cachedOrPendingFromValue(CSSPropertyID, CSSImageValue*);
-    
+
     bool applyPropertyToRegularStyle() const { return m_applyPropertyToRegularStyle; }
     bool applyPropertyToVisitedLinkStyle() const { return m_applyPropertyToVisitedLinkStyle; }
 
@@ -330,7 +330,7 @@ private:
     Vector<const RuleData*, 32> m_matchedRules;
 
     RefPtr<CSSRuleList> m_ruleList;
-    
+
     HashSet<int> m_pendingImageProperties; // Hash of CSSPropertyIDs
 
     OwnPtr<MediaQueryEvaluator> m_medium;
@@ -351,7 +351,7 @@ private:
     bool m_fontDirty;
     bool m_matchAuthorAndUserStyles;
     bool m_sameOriginOnly;
-    
+
     RefPtr<CSSFontSelector> m_fontSelector;
     Vector<CSSMutableStyleDeclaration*> m_additionalAttributeStyleDecls;
     Vector<MediaQueryResult*> m_viewportDependentMediaQueryResults;
@@ -359,7 +359,7 @@ private:
     bool m_applyPropertyToRegularStyle;
     bool m_applyPropertyToVisitedLinkStyle;
     const CSSStyleApplyProperty& m_applyProperty;
-    
+
     friend class CSSStyleApplyProperty;
 };
 
index 660106bc22c6c272d75c7c1a85860d36cbadd59e..6d4e7c4dfbdbe2a56d76a116c35fd7ab179e5a3b 100644 (file)
@@ -46,7 +46,7 @@ static bool isAcceptableCSSStyleSheetParent(Node* parentNode)
         || parentNode->hasTagName(HTMLNames::styleTag)
 #if ENABLE(SVG)
         || parentNode->hasTagName(SVGNames::styleTag)
-#endif    
+#endif
         || parentNode->nodeType() == Node::PROCESSING_INSTRUCTION_NODE;
 }
 #endif
@@ -147,9 +147,9 @@ unsigned CSSStyleSheet::insertRule(const String& rule, unsigned index, Exception
     CSSRule* c = r.get();
     m_children.insert(index, r.release());
     c->insertedIntoParent();
-    
+
     styleSheetChanged();
-    
+
     return index;
 }
 
@@ -193,7 +193,7 @@ void CSSStyleSheet::addNamespace(CSSParser* p, const AtomicString& prefix, const
         return;
 
     m_namespaces = adoptPtr(new CSSNamespace(prefix, uri, m_namespaces.release()));
-    
+
     if (prefix.isEmpty())
         // Set the default namespace on the parser so that selectors that omit namespace info will
         // be able to pick it up easily.
@@ -281,7 +281,7 @@ void CSSStyleSheet::styleSheetChanged()
     while (StyleBase* parent = root->parent())
         root = parent;
     Document* documentToUpdate = root->isCSSStyleSheet() ? static_cast<CSSStyleSheet*>(root)->document() : 0;
-    
+
     /* FIXME: We don't need to do everything updateStyleSelector does,
      * basically we just need to recreate the document's selector with the
      * already existing style sheets.
index 9eecb2c76b01ddac8c34079b8fd28647340fb5dc..d29c2df759dff276649f1b6c9dc5171a85bc228f 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index 27e899bd59f6b5d779d12961714413761078afc9..e3691f4e86cb84174f8febedb7449e2b166eae8d 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSTimingFunctionValue_h
@@ -53,7 +53,7 @@ public:
     {
         return adoptRef(new CSSLinearTimingFunctionValue);
     }
-    
+
 private:
     CSSLinearTimingFunctionValue()
     {
@@ -63,7 +63,7 @@ private:
 
     virtual bool isLinearTimingFunctionValue() const { return true; }
 };
-    
+
 class CSSCubicBezierTimingFunctionValue : public CSSTimingFunctionValue {
 public:
     static PassRefPtr<CSSCubicBezierTimingFunctionValue> create(double x1, double y1, double x2, double y2)
@@ -104,7 +104,7 @@ public:
 
     int numberOfSteps() const { return m_steps; }
     bool stepAtStart() const { return m_stepAtStart; }
-    
+
 private:
     CSSStepsTimingFunctionValue(int steps, bool stepAtStart)
         : m_steps(steps)
@@ -119,7 +119,7 @@ private:
     int m_steps;
     bool m_stepAtStart;
 };
-    
+
 } // namespace
 
 #endif
index 599c0783432ba25c966eb37c9e63cbba9797bb8f..f7b877952db586d9873a06708fc2fb2a2f22d36f 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index 0ba1980eaeec7378b065e40214016a1b2e7d6654..2f2c0126f9a3e77ac61cc454336cb24594a13b9c 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef CSSUnicodeRangeValue_h
index c4d91b14508bfe7b62cef3649a60ac449b0fb116..2e4d7a09223f27dff0d185ba19f541dcc884d972 100644 (file)
@@ -72,10 +72,10 @@ bool CSSValueList::removeAll(CSSValue* val)
             found = true;
         }
     }
-    
+
     return found;
 }
-    
+
 bool CSSValueList::hasValue(CSSValue* val) const
 {
     // FIXME: we should be implementing operator== to CSSValue and its derived classes
index 6cf28098fc707f8b8634974ffdf06aa9208d66ee..e5e9f98c3838e1e6ccb72bc71ab74ff5f1a60e59 100644 (file)
@@ -12,7 +12,7 @@
  *    copyright notice, this list of conditions and the following
  *    disclaimer in the documentation and/or other materials
  *    provided with the distribution.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
@@ -41,7 +41,7 @@ String CSSWrapShapeRect::cssText() const
 {
     DEFINE_STATIC_LOCAL(const String, rectParen, ("rect("));
     DEFINE_STATIC_LOCAL(const String, comma, (", "));
-    
+
     StringBuilder result;
     result.reserveCapacity(32);
     result.append(rectParen);
@@ -56,7 +56,7 @@ String CSSWrapShapeRect::cssText() const
     result.append(comma);
 
     result.append(m_height->cssText());
-    
+
     if (m_radiusX.get()) {
         result.append(comma);
         result.append(m_radiusX->cssText());
@@ -66,9 +66,9 @@ String CSSWrapShapeRect::cssText() const
             result.append(m_radiusY->cssText());
         }
     }
-    
+
     result.append(')');
-            
+
     return result.toString();
 }
 
@@ -76,7 +76,7 @@ String CSSWrapShapeCircle::cssText() const
 {
     DEFINE_STATIC_LOCAL(const String, circleParen, ("circle("));
     DEFINE_STATIC_LOCAL(const String, comma, (", "));
-    
+
     StringBuilder result;
     result.reserveCapacity(32);
     result.append(circleParen);
@@ -89,7 +89,7 @@ String CSSWrapShapeCircle::cssText() const
 
     result.append(m_radius->cssText());
     result.append(')');
-            
+
     return result.toString();
 }
 
@@ -97,7 +97,7 @@ String CSSWrapShapeEllipse::cssText() const
 {
     DEFINE_STATIC_LOCAL(const String, ellipseParen, ("ellipse("));
     DEFINE_STATIC_LOCAL(const String, comma, (", "));
-    
+
     StringBuilder result;
     result.reserveCapacity(32);
     result.append(ellipseParen);
@@ -113,7 +113,7 @@ String CSSWrapShapeEllipse::cssText() const
 
     result.append(m_radiusY->cssText());
     result.append(')');
-            
+
     return result.toString();
 }
 
@@ -122,7 +122,7 @@ String CSSWrapShapePolygon::cssText() const
     DEFINE_STATIC_LOCAL(const String, polygonParenEvenOdd, ("polygon(evenodd, "));
     DEFINE_STATIC_LOCAL(const String, polygonParenNonZero, ("polygon(nonzero, "));
     DEFINE_STATIC_LOCAL(const String, comma, (", "));
-    
+
     StringBuilder result;
     result.reserveCapacity(32);
     if (m_windRule == RULE_EVENODD)
@@ -139,9 +139,9 @@ String CSSWrapShapePolygon::cssText() const
         result.append(comma);
         result.append(m_values.at(i + 1)->cssText());
     }
-    
+
     result.append(')');
-            
+
     return result.toString();
 }
 
index 9178ebbbecb02d83cfa3dd3381b89538d3cadc0e..3ff9fab83f79552b62d8e3afbd6835aa6c059bbc 100644 (file)
@@ -12,7 +12,7 @@
  *    copyright notice, this list of conditions and the following
  *    disclaimer in the documentation and/or other materials
  *    provided with the distribution.
- * 
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER “AS IS” AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
@@ -45,15 +45,15 @@ public:
         CSS_WRAP_SHAPE_CIRCLE = 2,
         CSS_WRAP_SHAPE_ELLIPSE = 3,
         CSS_WRAP_SHAPE_POLYGON = 4,
-        CSS_WRAP_SHAPE_PATH = 5        
+        CSS_WRAP_SHAPE_PATH = 5
     };
-    
+
     virtual Type type() = 0;
     virtual String cssText() const = 0;
 
 public:
     virtual ~CSSWrapShape() { }
-    
+
 protected:
     CSSWrapShape() { }
 };
@@ -68,7 +68,7 @@ public:
     CSSPrimitiveValue* height() const { return m_height.get(); }
     CSSPrimitiveValue* radiusX() const { return m_radiusX.get(); }
     CSSPrimitiveValue* radiusY() const { return m_radiusY.get(); }
-    
+
     void setLeft(PassRefPtr<CSSPrimitiveValue> left) { m_left = left; }
     void setTop(PassRefPtr<CSSPrimitiveValue> top) { m_top = top; }
     void setWidth(PassRefPtr<CSSPrimitiveValue> width) { m_width = width; }
@@ -78,10 +78,10 @@ public:
 
     virtual Type type() { return CSS_WRAP_SHAPE_RECT; }
     virtual String cssText() const;
-    
+
 private:
     CSSWrapShapeRect() { }
-    
+
     RefPtr<CSSPrimitiveValue> m_top;
     RefPtr<CSSPrimitiveValue> m_left;
     RefPtr<CSSPrimitiveValue> m_width;
@@ -97,17 +97,17 @@ public:
     CSSPrimitiveValue* left() const { return m_left.get(); }
     CSSPrimitiveValue* top() const { return m_top.get(); }
     CSSPrimitiveValue* radius() const { return m_radius.get(); }
-    
+
     void setLeft(PassRefPtr<CSSPrimitiveValue> left) { m_left = left; }
     void setTop(PassRefPtr<CSSPrimitiveValue> top) { m_top = top; }
     void setRadius(PassRefPtr<CSSPrimitiveValue> radius) { m_radius = radius; }
 
     virtual Type type() { return CSS_WRAP_SHAPE_CIRCLE; }
     virtual String cssText() const;
-    
+
 private:
     CSSWrapShapeCircle() { }
-    
+
     RefPtr<CSSPrimitiveValue> m_top;
     RefPtr<CSSPrimitiveValue> m_left;
     RefPtr<CSSPrimitiveValue> m_radius;
@@ -121,7 +121,7 @@ public:
     CSSPrimitiveValue* top() const { return m_top.get(); }
     CSSPrimitiveValue* radiusX() const { return m_radiusX.get(); }
     CSSPrimitiveValue* radiusY() const { return m_radiusY.get(); }
-    
+
     void setLeft(PassRefPtr<CSSPrimitiveValue> left) { m_left = left; }
     void setTop(PassRefPtr<CSSPrimitiveValue> top) { m_top = top; }
     void setRadiusX(PassRefPtr<CSSPrimitiveValue> radiusX) { m_radiusX = radiusX; }
@@ -129,10 +129,10 @@ public:
 
     virtual Type type() { return CSS_WRAP_SHAPE_ELLIPSE; }
     virtual String cssText() const;
-    
+
 private:
     CSSWrapShapeEllipse() { }
-    
+
     RefPtr<CSSPrimitiveValue> m_top;
     RefPtr<CSSPrimitiveValue> m_left;
     RefPtr<CSSPrimitiveValue> m_radiusX;
@@ -142,30 +142,30 @@ private:
 class CSSWrapShapePolygon : public CSSWrapShape {
 public:
     static PassRefPtr<CSSWrapShapePolygon> create() { return adoptRef(new CSSWrapShapePolygon); }
-    
+
     void appendPoint(PassRefPtr<CSSPrimitiveValue> x, PassRefPtr<CSSPrimitiveValue> y)
-    { 
+    {
         m_values.append(x);
         m_values.append(y);
     }
-    
+
     PassRefPtr<CSSPrimitiveValue> getXAt(unsigned i) { return m_values.at(i * 2); }
     PassRefPtr<CSSPrimitiveValue> getYAt(unsigned i) { return m_values.at(i * 2 + 1); }
-    
+
     void setWindRule(WindRule w) { m_windRule = w; }
     WindRule windRule() const { return m_windRule; }
-    
+
     virtual Type type() { return CSS_WRAP_SHAPE_POLYGON; }
     virtual String cssText() const;
-    
+
 private:
     CSSWrapShapePolygon()
         : m_windRule(RULE_NONZERO)
     {
     }
-    
+
     Vector<RefPtr<CSSPrimitiveValue> > m_values;
-    WindRule m_windRule;    
+    WindRule m_windRule;
 };
 
 } // namespace WebCore
index 991fc6e5b330ff41679e082dbc2b008a63724879..6b092b3d7a39a54d41cabb691e96ffdc30717304 100644 (file)
@@ -28,7 +28,7 @@ namespace WebCore {
 
 String FontValue::cssText() const
 {
-    // font variant weight size / line-height family 
+    // font variant weight size / line-height family
 
     String result("");
 
index 5fe050a2ee2481c01d3e3470ed1707fe7696342c..86ee2f206fab8657d91107308188c6e0cfb87334 100644 (file)
@@ -72,7 +72,7 @@ MediaList::MediaList(CSSStyleSheet* parentStyleSheet, const String& media, bool
     // FIXME: parsing can fail. The problem with failing constructor is that
     // we would need additional flag saying MediaList is not valid
     // Parse can fail only when fallbackToDescriptor == false, i.e when HTML4 media descriptor
-    // forward-compatible syntax is not in use. 
+    // forward-compatible syntax is not in use.
     // DOMImplementationCSS seems to mandate that media descriptors are used
     // for both html and svg, even though svg:style doesn't use media descriptors
     // Currently the only places where parsing can fail are
@@ -150,7 +150,7 @@ void MediaList::deleteMedium(const String& oldMedium, ExceptionCode& ec)
             }
         }
     }
-    
+
     if (!ec)
         notifyChanged();
 }
@@ -191,11 +191,11 @@ void MediaList::setMediaText(const String& value, ExceptionCode& ec)
                     ec = SYNTAX_ERR;
                     return;
                 }
-            }          
+            }
         } else if (!m_fallback) {
             ec = SYNTAX_ERR;
             return;
-        }            
+        }
     }
     // ",,,," falls straight through, but is not valid unless fallback
     if (!m_fallback && list.begin() == list.end()) {
@@ -205,7 +205,7 @@ void MediaList::setMediaText(const String& value, ExceptionCode& ec)
             return;
         }
     }
-    
+
     ec = 0;
     deleteAllValues(m_queries);
     m_queries = tempMediaList->m_queries;
@@ -236,7 +236,7 @@ void MediaList::appendMedium(const String& newMedium, ExceptionCode& ec)
             ec = 0;
         }
     }
-    
+
     if (!ec)
         notifyChanged();
 }
index c476a2141f9b6b65a48f81d42f1ab6f2fd37e249..8fa5820dfe6dd94e017aa1f073fbaa80394c6f42 100644 (file)
@@ -23,7 +23,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -69,7 +69,7 @@ String MediaQuery::serialize() const
     return result.toString();
 }
 
-static bool expressionCompare(const OwnPtr<MediaQueryExp>& a, const OwnPtr<MediaQueryExp>& b) 
+static bool expressionCompare(const OwnPtr<MediaQueryExp>& a, const OwnPtr<MediaQueryExp>& b)
 {
     return codePointCompare(a->serialize(), b->serialize()) < 0;
 }
@@ -95,7 +95,7 @@ MediaQuery::MediaQuery(Restrictor r, const String& mediaType, PassOwnPtr<Vector<
         // if not all of the expressions is valid the media query must be ignored.
         if (!m_ignored)
             m_ignored = !m_expressions->at(i)->isValid();
+
         if (m_expressions->at(i)->serialize() == key)
             m_expressions->remove(i);
         else
index 4cc366548debd971d0155cd0af14de46d37f0f1d..cb14154df5becaf6d7edbb11189f9dc8f3d32db9 100644 (file)
@@ -23,7 +23,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef MediaQuery_h
index 05c8dc9c4e79613be8dcedcbfd4c69ae2874d167..ba838f207722ad38b58ba65cce9509f4601308df 100644 (file)
@@ -22,7 +22,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef MediaQueryEvaluator_h
index e970400a7133c539210c8e4c9ec35bd73799a06a..1f53221832058a146f4084c22b465885541b6fdc 100644 (file)
@@ -23,7 +23,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index 7e4d477ff688bb07ff26dc3d3469f1cd26aac5dd..feb61c084a3d0d60a5739311322b2feb85ca2476 100644 (file)
@@ -23,7 +23,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef MediaQueryExp_h
@@ -57,16 +57,16 @@ public:
 
     bool isValid() const { return m_isValid; }
 
-    bool isViewportDependent() const { return m_mediaFeature == MediaFeatureNames::widthMediaFeature || 
-                                              m_mediaFeature == MediaFeatureNames::heightMediaFeature ||
-                                              m_mediaFeature == MediaFeatureNames::min_widthMediaFeature ||
-                                              m_mediaFeature == MediaFeatureNames::min_heightMediaFeature ||
-                                              m_mediaFeature == MediaFeatureNames::max_widthMediaFeature ||
-                                              m_mediaFeature == MediaFeatureNames::max_heightMediaFeature ||
-                                              m_mediaFeature == MediaFeatureNames::orientationMediaFeature ||
-                                              m_mediaFeature == MediaFeatureNames::aspect_ratioMediaFeature ||
-                                              m_mediaFeature == MediaFeatureNames::min_aspect_ratioMediaFeature ||
-                                              m_mediaFeature == MediaFeatureNames::max_aspect_ratioMediaFeature;  }
+    bool isViewportDependent() const { return m_mediaFeature == MediaFeatureNames::widthMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::heightMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::min_widthMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::min_heightMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::max_widthMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::max_heightMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::orientationMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::aspect_ratioMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::min_aspect_ratioMediaFeature
+                                            || m_mediaFeature == MediaFeatureNames::max_aspect_ratioMediaFeature;  }
 
     String serialize() const;
 
index c76bd821ae04c04c73669d984abe18aaebbc6e6c..a95370dc30153d68dcbdc3b88f3c05a7d1500892 100644 (file)
@@ -53,7 +53,7 @@ private:
     Pair() : m_first(0), m_second(0) { }
     Pair(PassRefPtr<CSSPrimitiveValue> first, PassRefPtr<CSSPrimitiveValue> second)
         : m_first(first), m_second(second) { }
-    
+
     RefPtr<CSSPrimitiveValue> m_first;
     RefPtr<CSSPrimitiveValue> m_second;
 };
index 0c2aaff9967856c04951d2eef5a3132d73799a17..7ef3b07d39fb8cfa1c423661386e91f5fbd88ef7 100644 (file)
@@ -73,19 +73,19 @@ PassRefPtr<CSSValue> CSSComputedStyleDeclaration::getSVGPropertyCSSValue(int pro
     Node* node = m_node.get();
     if (!node)
         return 0;
-    
+
     // Make sure our layout is up to date before we allow a query on these attributes.
     if (updateLayout)
         node->document()->updateLayout();
-        
+
     RenderStyle* style = node->computedStyle();
     if (!style)
         return 0;
-    
+
     const SVGRenderStyle* svgStyle = style->svgStyle();
     if (!svgStyle)
         return 0;
-    
+
     switch (static_cast<CSSPropertyID>(propertyID)) {
         case CSSPropertyClipRule:
             return CSSPrimitiveValue::create(svgStyle->clipRule());
index 6d72b355f2087d761746d080ae1a783f2598c705..6b623cd749aa1f5654d6898530c4c5baaf60984d 100644 (file)
@@ -145,7 +145,7 @@ bool CSSParser::parseSVGValue(int propId, bool important)
         break;
 
     case CSSPropertyColorInterpolation:   // auto | sRGB | linearRGB | inherit
-    case CSSPropertyColorInterpolationFilters:  
+    case CSSPropertyColorInterpolationFilters:
         if (id == CSSValueAuto || id == CSSValueSrgb || id == CSSValueLinearrgb)
             valid_primitive = true;
         break;
@@ -227,7 +227,7 @@ bool CSSParser::parseSVGValue(int propId, bool important)
             m_valueList->next();
 
         break;
-        
+
     case CSSPropertyVectorEffect: // none | non-scaling-stroke | inherit
         if (id == CSSValueNone || id == CSSValueNonScalingStroke)
             valid_primitive = true;
index 87a8521ee89a13ceed5de5e2e488dfa0b0b31bd7..dd4e56c99b2c471a183b076e351b9ce17850ab36 100644 (file)
@@ -111,7 +111,7 @@ void CSSStyleSelector::applySVGProperty(int id, CSSValue* value)
 
     SVGRenderStyle* svgstyle = m_style->accessSVGStyle();
     unsigned short valueType = value->cssValueType();
-    
+
     bool isInherit = m_parentNode && valueType == CSSPrimitiveValue::CSS_INHERIT;
     bool isInitial = valueType == CSSPrimitiveValue::CSS_INITIAL || (!m_parentNode && valueType == CSSPrimitiveValue::CSS_INHERIT);
 
@@ -127,7 +127,7 @@ void CSSStyleSelector::applySVGProperty(int id, CSSValue* value)
             HANDLE_INHERIT_AND_INITIAL(alignmentBaseline, AlignmentBaseline)
             if (!primitiveValue)
                 break;
-            
+
             svgstyle->setAlignmentBaseline(*primitiveValue);
             break;
         }
@@ -299,8 +299,8 @@ void CSSStyleSelector::applySVGProperty(int id, CSSValue* value)
             HANDLE_INHERIT_AND_INITIAL(fillOpacity, FillOpacity)
             if (!primitiveValue)
                 return;
-        
-            float f = 0.0f;    
+
+            float f = 0.0f;
             int type = primitiveValue->primitiveType();
             if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
                 f = primitiveValue->getFloatValue() / 100.0f;
@@ -317,8 +317,8 @@ void CSSStyleSelector::applySVGProperty(int id, CSSValue* value)
             HANDLE_INHERIT_AND_INITIAL(strokeOpacity, StrokeOpacity)
             if (!primitiveValue)
                 return;
-        
-            float f = 0.0f;    
+
+            float f = 0.0f;
             int type = primitiveValue->primitiveType();
             if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
                 f = primitiveValue->getFloatValue() / 100.0f;
@@ -335,8 +335,8 @@ void CSSStyleSelector::applySVGProperty(int id, CSSValue* value)
             HANDLE_INHERIT_AND_INITIAL(stopOpacity, StopOpacity)
             if (!primitiveValue)
                 return;
-        
-            float f = 0.0f;    
+
+            float f = 0.0f;
             int type = primitiveValue->primitiveType();
             if (type == CSSPrimitiveValue::CSS_PERCENTAGE)
                 f = primitiveValue->getFloatValue() / 100.0f;
@@ -447,7 +447,7 @@ void CSSStyleSelector::applySVGProperty(int id, CSSValue* value)
                 s = primitiveValue->getStringValue();
             else
                 return;
-            
+
             svgstyle->setMaskerResource(SVGURIReference::fragmentIdentifierFromIRIString(s, m_element->document()));
             break;
         }
@@ -582,7 +582,7 @@ void CSSStyleSelector::applySVGProperty(int id, CSSValue* value)
             // -webkit-svg-shadow does should not have a spread or style
             ASSERT(!item->spread);
             ASSERT(!item->style);
-                
+
             OwnPtr<ShadowData> shadowData = adoptPtr(new ShadowData(x, y, blur, 0, Normal, false, color.isValid() ? color : Color::transparent));
             svgstyle->setShadow(shadowData.release());
             return;
index 4ab110c0dd4f091f0224a70ca841920057a2f7fc..29297a6af259624e79fe2e905aa172b2fb8e9260 100644 (file)
@@ -62,9 +62,9 @@
 #endif
 
 namespace WebCore {
-    
+
 using namespace HTMLNames;
-    
+
 static bool htmlAttributeHasCaseInsensitiveValue(const QualifiedName& attr);
 
 SelectorChecker::SelectorChecker(Document* document, bool strictParsing)
@@ -175,8 +175,8 @@ void SelectorChecker::collectIdentifierHashes(const CSSSelector* selector, unsig
     unsigned* hash = identifierHashes;
     unsigned* end = identifierHashes + maximumIdentifierCount;
     CSSSelector::Relation relation = selector->relation();
-    
-    // Skip the topmost selector. It is handled quickly by the rule hashes.    
+
+    // Skip the topmost selector. It is handled quickly by the rule hashes.
     bool skipOverSubselectors = true;
     for (selector = selector->tagHistory(); selector; selector = selector->tagHistory()) {
         // Only collect identifiers that match ancestors.
@@ -207,24 +207,24 @@ static inline const AtomicString* linkAttribute(Node* node)
 {
     if (!node->isLink())
         return 0;
-    
+
     ASSERT(node->isElementNode());
     Element* element = static_cast<Element*>(node);
     if (element->isHTMLElement())
         return &element->fastGetAttribute(hrefAttr);
-    
+
 #if ENABLE(SVG)
     if (element->isSVGElement())
         return &element->getAttribute(XLinkNames::hrefAttr);
 #endif
-    
+
     return 0;
 }
 
 EInsideLink SelectorChecker::determineLinkStateSlowCase(Element* element) const
 {
     ASSERT(element->isLink());
-    
+
     const AtomicString* attr = linkAttribute(element);
     if (!attr || attr->isNull())
         return NotInsideLink;
@@ -241,13 +241,13 @@ EInsideLink SelectorChecker::determineLinkStateSlowCase(Element* element) const
     Frame* frame = m_document->frame();
     if (!frame)
         return InsideUnvisitedLink;
-    
+
     Page* page = frame->page();
     if (!page)
         return InsideUnvisitedLink;
-    
+
     m_linksCheckedForVisitedState.add(hash);
-    
+
 #if USE(PLATFORM_STRATEGIES)
     return platformStrategies()->visitedLinkStrategy()->isLinkVisited(page, hash, m_document->baseURL(), *attr) ? InsideVisitedLink : InsideUnvisitedLink;
 #else
@@ -289,7 +289,7 @@ inline bool fastCheckSingleSelector(const CSSSelector*& selector, const Element*
         }
         if (topChildOrSubselector) {
             // Child or subselector check failed.
-            // If the match element is null, topChildOrSubselector was also the very topmost selector and had to match 
+            // If the match element is null, topChildOrSubselector was also the very topmost selector and had to match
             // the original element we were checking.
             if (!topChildOrSubselectorMatchElement)
                 return false;
@@ -304,12 +304,12 @@ inline bool fastCheckSingleSelector(const CSSSelector*& selector, const Element*
     return false;
 }
 
-inline bool checkClassValue(const Element* element, AtomicStringImpl* value, const QualifiedName&) 
+inline bool checkClassValue(const Element* element, AtomicStringImpl* value, const QualifiedName&)
 {
     return element->hasClass() && static_cast<const StyledElement*>(element)->classNames().contains(value);
 }
 
-inline bool checkIDValue(const Element* element, AtomicStringImpl* value, const QualifiedName&) 
+inline bool checkIDValue(const Element* element, AtomicStringImpl* value, const QualifiedName&)
 {
     return element->hasID() && element->idForStyleResolution().impl() == value;
 }
@@ -323,7 +323,7 @@ inline bool checkTagValue(const Element*, AtomicStringImpl*, const QualifiedName
 {
     return true;
 }
-    
+
 }
 
 inline bool SelectorChecker::fastCheckRightmostSelector(const CSSSelector* selector, const Element* element, VisitedMatchType visitedMatchType) const
@@ -358,12 +358,12 @@ bool SelectorChecker::fastCheckSelector(const CSSSelector* selector, const Eleme
     const Element* topChildOrSubselectorMatchElement = 0;
     if (selector->relation() == CSSSelector::Child || selector->relation() == CSSSelector::SubSelector)
         topChildOrSubselector = selector;
-    
+
     if (selector->relation() != CSSSelector::SubSelector)
         element = element->parentElement();
-    
+
     selector = selector->tagHistory();
-    
+
     // We know this compound selector has descendant, child and subselector combinators only and all components are simple.
     while (selector) {
         switch (selector->m_match) {
@@ -442,10 +442,10 @@ SelectorChecker::SelectorMatch SelectorChecker::checkSelector(CSSSelector* sel,
     // first selector has to match
     if (!checkOneSelector(sel, e, dynamicPseudo, isSubSelector, visitedMatchType, elementStyle, elementParentStyle))
         return SelectorFailsLocally;
-    
+
     // The rest of the selectors has to match
     CSSSelector::Relation relation = sel->relation();
-    
+
     // Prepare next sel
     sel = sel->tagHistory();
     if (!sel)
@@ -455,7 +455,7 @@ SelectorChecker::SelectorMatch SelectorChecker::checkSelector(CSSSelector* sel,
         // Bail-out if this selector is irrelevant for the pseudoStyle
         if (m_pseudoStyle != NOPSEUDO && m_pseudoStyle != dynamicPseudo)
             return SelectorFailsCompletely;
-    
+
         // Disable :visited matching when we see the first link or try to match anything else than an ancestors.
         if (!isSubSelector && (e->isLink() || (relation != CSSSelector::Descendant && relation != CSSSelector::Child)))
             visitedMatchType = VisitedMatchDisabled;
@@ -473,7 +473,7 @@ SelectorChecker::SelectorMatch SelectorChecker::checkSelector(CSSSelector* sel,
                 return match;
         }
         break;
-    case CSSSelector::Child: 
+    case CSSSelector::Child:
         {
             ContainerNode* n = e->parentNode();
             if (!n || !n->isElementNode())
@@ -531,7 +531,7 @@ SelectorChecker::SelectorMatch SelectorChecker::checkSelector(CSSSelector* sel,
             return checkSelector(sel, e, dynamicPseudo, false, visitedMatchType);
         }
     }
-    
+
     return SelectorFailsCompletely;
 }
 
@@ -545,7 +545,7 @@ static HashSet<AtomicStringImpl*>* createHtmlCaseInsensitiveAttributesSet()
     // This is the list of attributes in HTML 4.01 with values marked as "[CI]" or case-insensitive
     // Mozilla treats all other values as case-sensitive, thus so do we.
     HashSet<AtomicStringImpl*>* attrSet = new HashSet<AtomicStringImpl*>;
-    
+
     addLocalNameToSet(attrSet, accept_charsetAttr);
     addLocalNameToSet(attrSet, acceptAttr);
     addLocalNameToSet(attrSet, alignAttr);
@@ -591,7 +591,7 @@ static HashSet<AtomicStringImpl*>* createHtmlCaseInsensitiveAttributesSet()
     addLocalNameToSet(attrSet, valignAttr);
     addLocalNameToSet(attrSet, valuetypeAttr);
     addLocalNameToSet(attrSet, vlinkAttr);
-    
+
     return attrSet;
 }
 
@@ -607,7 +607,7 @@ static bool attributeValueMatches(Attribute* attributeItem, CSSSelector::Match m
     const AtomicString& value = attributeItem->value();
     if (value.isNull())
         return false;
-    
+
     switch (match) {
     case CSSSelector::Exact:
         if (caseSensitive ? selectorValue != value : !equalIgnoringCase(selectorValue, value))
@@ -618,7 +618,7 @@ static bool attributeValueMatches(Attribute* attributeItem, CSSSelector::Match m
             // Ignore empty selectors or selectors containing spaces
             if (selectorValue.contains(' ') || selectorValue.isEmpty())
                 return false;
-            
+
             unsigned startSearchAt = 0;
             while (true) {
                 size_t foundPos = value.find(selectorValue, startSearchAt, caseSensitive);
@@ -629,7 +629,7 @@ static bool attributeValueMatches(Attribute* attributeItem, CSSSelector::Match m
                     if (endStr == value.length() || value[endStr] == ' ')
                         break; // We found a match.
                 }
-                
+
                 // No match. Keep looking.
                 startSearchAt = foundPos + 1;
             }
@@ -661,7 +661,7 @@ static bool attributeValueMatches(Attribute* attributeItem, CSSSelector::Match m
     default:
         break;
     }
-    
+
     return true;
 }
 
@@ -669,14 +669,14 @@ static bool anyAttributeMatches(NamedNodeMap* attributes, CSSSelector::Match mat
 {
     for (size_t i = 0; i < attributes->length(); ++i) {
         Attribute* attributeItem = attributes->attributeItem(i);
-        
+
         if (!SelectorChecker::attributeNameMatches(attributeItem, selectorAttr))
             continue;
-        
+
         if (attributeValueMatches(attributeItem, match, selectorValue, caseSensitive))
             return true;
     }
-    
+
     return false;
 }
 
@@ -685,26 +685,26 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
     ASSERT(e);
     if (!SelectorChecker::tagMatches(e, sel))
         return false;
-    
+
     if (sel->m_match == CSSSelector::Class)
         return e->hasClass() && static_cast<StyledElement*>(e)->classNames().contains(sel->value());
-    
+
     if (sel->m_match == CSSSelector::Id)
         return e->hasID() && e->idForStyleResolution() == sel->value();
-    
+
     if (sel->isAttributeSelector()) {
         const QualifiedName& attr = sel->attribute();
-        
+
         NamedNodeMap* attributes = e->attributes(true);
         if (!attributes)
             return false;
-        
+
         bool caseSensitive = !m_documentIsHTML || !htmlAttributeHasCaseInsensitiveValue(attr);
-        
+
         if (!anyAttributeMatches(attributes, static_cast<CSSSelector::Match>(sel->m_match), attr, sel->value(), caseSensitive))
             return false;
     }
-    
+
     if (sel->m_match == CSSSelector::PseudoClass) {
         // Handle :not up front.
         if (sel->pseudoType() == CSSSelector::PseudoNot) {
@@ -728,7 +728,7 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
             if (sel->pseudoType() == CSSSelector::PseudoWindowInactive)
                 return !m_document->page()->focusController()->isActive();
         }
-        
+
         // Normal element pseudo class checking.
         switch (sel->pseudoType()) {
             // Pseudo classes:
@@ -848,7 +848,7 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
             if (Element* parentElement = e->parentElement()) {
                 bool firstChild = false;
                 bool lastChild = false;
-                
+
                 Node* n = e->previousSibling();
                 while (n && !n->isElementNode())
                     n = n->previousSibling();
@@ -930,7 +930,7 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
                     }
                     n = n->previousSibling();
                 }
-                
+
                 if (!m_isCollectingRulesOnly) {
                     RenderStyle* childStyle = elementStyle ? elementStyle : e->renderStyle();
                     RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
@@ -939,7 +939,7 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
                     if (parentStyle)
                         parentStyle->setChildrenAffectedByForwardPositionalRules();
                 }
-                
+
                 if (sel->matchNth(count))
                     return true;
             }
@@ -956,13 +956,13 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
                         count++;
                     n = n->previousSibling();
                 }
-                
+
                 if (!m_isCollectingRulesOnly) {
                     RenderStyle* parentStyle = elementStyle ? elementParentStyle : parentElement->renderStyle();
                     if (parentStyle)
                         parentStyle->setChildrenAffectedByForwardPositionalRules();
                 }
-                
+
                 if (sel->matchNth(count))
                     return true;
             }
@@ -1059,7 +1059,7 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
             break;
         case CSSSelector::PseudoActive:
             // If we're in quirks mode, then :active should never match anchors with no
-            // href and *:active should not match anything. 
+            // href and *:active should not match anything.
             if (m_strictParsing || isSubSelector || (sel->hasTag() && !e->hasTagName(aTag)) || e->isLink()) {
                 if (elementStyle)
                     elementStyle->setAffectedByActiveRules(true);
@@ -1086,7 +1086,7 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
             if (!e || !e->isFormControlElement())
                 return false;
             return e->isTextFormControl() && e->isReadOnlyFormControl();
-        case CSSSelector::PseudoReadWrite: 
+        case CSSSelector::PseudoReadWrite:
             if (!e || !e->isFormControlElement())
                 return false;
             return e->isTextFormControl() && !e->isReadOnlyFormControl();
@@ -1153,9 +1153,9 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
             }
 #if ENABLE(FULLSCREEN_API)
         case CSSSelector::PseudoFullScreen:
-            // While a Document is in the fullscreen state, and the document's current fullscreen 
-            // element is an element in the document, the 'full-screen' pseudoclass applies to 
-            // that element. Also, an <iframe>, <object> or <embed> element whose child browsing 
+            // While a Document is in the fullscreen state, and the document's current fullscreen
+            // element is an element in the document, the 'full-screen' pseudoclass applies to
+            // that element. Also, an <iframe>, <object> or <embed> element whose child browsing
             // context's Document is in the fullscreen state has the 'full-screen' pseudoclass applied.
             if (e->isFrameElementBase() && static_cast<HTMLFrameElementBase*>(e)->containsFullScreenElement())
                 return true;
@@ -1169,7 +1169,7 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
         case CSSSelector::PseudoFullScreenAncestor:
             return e->containsFullScreenElement();
         case CSSSelector::PseudoFullScreenDocument:
-            // While a Document is in the fullscreen state, the 'full-screen-document' pseudoclass applies 
+            // While a Document is in the fullscreen state, the 'full-screen-document' pseudoclass applies
             // to all elements of that Document.
             if (!e->document()->webkitIsFullScreen())
                 return false;
@@ -1196,12 +1196,12 @@ bool SelectorChecker::checkOneSelector(CSSSelector* sel, Element* e, PseudoId& d
     if (sel->m_match == CSSSelector::PseudoElement) {
         if (!elementStyle && !m_isCollectingRulesOnly)
             return false;
-        
+
         if (sel->isUnknownPseudoElement()) {
             m_hasUnknownPseudoElements = true;
             return e->shadowPseudoId() == sel->value();
         }
-        
+
         PseudoId pseudoId = CSSSelector::pseudoId(sel->pseudoType());
         if (pseudoId == FIRST_LETTER) {
             if (Document* document = e->document())
@@ -1218,15 +1218,15 @@ bool SelectorChecker::checkScrollbarPseudoClass(CSSSelector* sel, PseudoId&) con
 {
     RenderScrollbar* scrollbar = RenderScrollbar::scrollbarForStyleResolve();
     ScrollbarPart part = RenderScrollbar::partForStyleResolve();
-    
+
     // FIXME: This is a temporary hack for resizers and scrollbar corners. Eventually :window-inactive should become a real
     // pseudo class and just apply to everything.
     if (sel->pseudoType() == CSSSelector::PseudoWindowInactive)
         return !m_document->page()->focusController()->isActive();
-    
+
     if (!scrollbar)
         return false;
-    
+
     ASSERT(sel->m_match == CSSSelector::PseudoClass);
     switch (sel->pseudoType()) {
     case CSSSelector::PseudoEnabled:
@@ -1263,7 +1263,7 @@ bool SelectorChecker::checkScrollbarPseudoClass(CSSSelector* sel, PseudoId&) con
         return part == BackButtonStartPart || part == ForwardButtonStartPart || part == BackTrackPart;
     case CSSSelector::PseudoEnd:
         return part == BackButtonEndPart || part == ForwardButtonEndPart || part == ForwardTrackPart;
-    case CSSSelector::PseudoDoubleButton: 
+    case CSSSelector::PseudoDoubleButton:
         {
             ScrollbarButtonsPlacement buttonsPlacement = scrollbar->theme()->buttonsPlacement();
             if (part == BackButtonStartPart || part == ForwardButtonStartPart || part == BackTrackPart)
@@ -1271,7 +1271,7 @@ bool SelectorChecker::checkScrollbarPseudoClass(CSSSelector* sel, PseudoId&) con
             if (part == BackButtonEndPart || part == ForwardButtonEndPart || part == ForwardTrackPart)
                 return buttonsPlacement == ScrollbarButtonsDoubleEnd || buttonsPlacement == ScrollbarButtonsDoubleBoth;
             return false;
-        } 
+        }
     case CSSSelector::PseudoSingleButton:
         {
             ScrollbarButtonsPlacement buttonsPlacement = scrollbar->theme()->buttonsPlacement();
@@ -1336,7 +1336,7 @@ bool SelectorChecker::commonPseudoClassSelectorMatches(const Element* element, c
 unsigned SelectorChecker::determineLinkMatchType(const CSSSelector* selector)
 {
     unsigned linkMatchType = MatchAll;
-    
+
     // Statically determine if this selector will match a link in visited, unvisited or any state, or never.
     // :visited never matches other elements than the innermost link element.
     for (; selector; selector = selector->tagHistory()) {
index f59b74aa3b17e9cb8b9a040ff410c801b80add17..760ba5207be574c5dfe8a9a04b9700e4d0cdf28d 100644 (file)
@@ -67,10 +67,10 @@ public:
     EInsideLink determineLinkState(Element*) const;
     void allVisitedStateChanged();
     void visitedStateChanged(LinkHash visitedHash);
-    
+
     Document* document() const { return m_document; }
     bool strictParsing() const { return m_strictParsing; }
-    
+
     bool isCollectingRulesOnly() const { return m_isCollectingRulesOnly; }
     void setCollectingRulesOnly(bool b) { m_isCollectingRulesOnly = b; }
 
@@ -79,14 +79,14 @@ public:
 
     bool hasUnknownPseudoElements() const { return m_hasUnknownPseudoElements; }
     void clearHasUnknownPseudoElements() { m_hasUnknownPseudoElements = false; }
-    
+
     static bool tagMatches(const Element*, const CSSSelector*);
     static bool attributeNameMatches(const Attribute*, const QualifiedName&);
     static bool isCommonPseudoClassSelector(const CSSSelector*);
     bool matchesFocusPseudoClass(const Element*) const;
     static bool fastCheckRightmostAttributeSelector(const Element*, const CSSSelector*);
     static bool checkExactAttribute(const Element*, const QualifiedName& selectorAttributeName, const AtomicStringImpl* value);
-    
+
     enum LinkMatchMask { MatchLink = 1, MatchVisited = 2, MatchAll = MatchLink | MatchVisited };
     static unsigned determineLinkMatchType(const CSSSelector*);
 
@@ -94,7 +94,7 @@ private:
     bool checkOneSelector(CSSSelector*, Element*, PseudoId& dynamicPseudo, bool isSubSelector, VisitedMatchType, RenderStyle*, RenderStyle* elementParentStyle) const;
     bool checkScrollbarPseudoClass(CSSSelector*, PseudoId& dynamicPseudo) const;
     static bool isFrameFocused(const Element*);
-    
+
     bool fastCheckRightmostSelector(const CSSSelector*, const Element*, VisitedMatchType) const;
     bool commonPseudoClassSelectorMatches(const Element*, const CSSSelector*, VisitedMatchType) const;
 
@@ -130,7 +130,7 @@ inline EInsideLink SelectorChecker::determineLinkState(Element* element) const
         return NotInsideLink;
     return determineLinkStateSlowCase(element);
 }
-    
+
 template <unsigned maximumIdentifierCount>
 inline bool SelectorChecker::fastRejectSelector(const unsigned* identifierHashes) const
 {
@@ -141,7 +141,7 @@ inline bool SelectorChecker::fastRejectSelector(const unsigned* identifierHashes
     }
     return false;
 }
-    
+
 inline bool SelectorChecker::isCommonPseudoClassSelector(const CSSSelector* selector)
 {
     if (selector->m_match != CSSSelector::PseudoClass)
@@ -159,7 +159,7 @@ inline bool SelectorChecker::matchesFocusPseudoClass(const Element* element) con
         return true;
     return element->focused() && isFrameFocused(element);
 }
-    
+
 inline bool SelectorChecker::tagMatches(const Element* element, const CSSSelector* selector)
 {
     if (!selector->hasTag())
@@ -170,14 +170,14 @@ inline bool SelectorChecker::tagMatches(const Element* element, const CSSSelecto
     const AtomicString& namespaceURI = selector->tag().namespaceURI();
     return namespaceURI == starAtom || namespaceURI == element->namespaceURI();
 }
-    
+
 inline bool SelectorChecker::attributeNameMatches(const Attribute* attribute, const QualifiedName& selectorAttributeName)
 {
     if (selectorAttributeName.localName() != attribute->localName())
         return false;
     return selectorAttributeName.prefix() == starAtom || selectorAttributeName.namespaceURI() == attribute->namespaceURI();
 }
-    
+
 inline bool SelectorChecker::checkExactAttribute(const Element* element, const QualifiedName& selectorAttributeName, const AtomicStringImpl* value)
 {
     NamedNodeMap* attributeMap = element->attributeMap();
@@ -191,7 +191,7 @@ inline bool SelectorChecker::checkExactAttribute(const Element* element, const Q
     }
     return false;
 }
-    
+
 inline bool SelectorChecker::fastCheckRightmostAttributeSelector(const Element* element, const CSSSelector* selector)
 {
     if (selector->m_match == CSSSelector::Exact || selector->m_match == CSSSelector::Set)
index a7b536bcb107c6d2aca7356e657fb1dea8f9c36d..a42d7be6a17b2f9e0e3a1de1f0c1f514ae6be742 100644 (file)
@@ -72,7 +72,7 @@ KURL StyleBase::baseURL() const
         return sheet->finalURL();
     if (sheet->parent())
         return sheet->parent()->baseURL();
-    if (!sheet->ownerNode()) 
+    if (!sheet->ownerNode())
         return KURL();
     return sheet->ownerNode()->document()->baseURL();
 }
index e0ff4402ef8e13cfd23848bd84332f50e7d74c34..90b5740172dd2000e7621ff4a5c311d0a742d99a 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
index 398a0b15c8e18aca387696151f3ed9df66b56b48..239c38d7a64c38eb6bc06546b19ea4fc6b76f517 100644 (file)
@@ -21,7 +21,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef StyleMedia_h
index 2c90258731debfb914830ca0bbd54103d8bfa85c..bbefd318b60401e3e1f7152aa10af40f98778e8e 100644 (file)
@@ -65,7 +65,7 @@ HTMLStyleElement* StyleSheetList::getNamedItem(const String& name) const
     // ### Bad implementation because returns a single element (are IDs always unique?)
     // and doesn't look for name attribute.
     // But unicity of stylesheet ids is good practice anyway ;)
-    
+
     Element* element = m_doc->getElementById(name);
     if (element && element->hasTagName(styleTag))
         return static_cast<HTMLStyleElement*>(element);
index a0196919d8d3cef5d6eb356012e99eee20ce6887..4eb7d6a2781faf4511538c142388b8da4e1ef676 100644 (file)
@@ -55,7 +55,7 @@ public:
     {
         return m_doc;
     }
-    
+
 private:
     StyleSheetList(Document*);
 
index bf1c9563793eb0eab20742dbc7b1be79a8c88572..25058319aeff92d618b96948a8087bec8fe17a76 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -84,7 +84,7 @@ String WebKitCSSFilterValue::cssText() const
     default:
         break;
     }
-    
+
     return result + CSSValueList::cssText() + ")";
 }
 
index 8d6ee82b04268621966ca8e11f9b121e37b478df..d4d08e12734d09bc1dbdfdfea89744ad47e2faa5 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebKitCSSFilterValue_h
@@ -60,9 +60,9 @@ public:
     virtual ~WebKitCSSFilterValue();
 
     virtual String cssText() const;
+
     FilterOperationType operationType() const { return m_type; }
-    
+
 private:
     WebKitCSSFilterValue(FilterOperationType);
 
index 8f3d676e3f0f0afd68ee8f2fba4668824b289576..cd6fd60204d662a4e43a03ef5cc3b87518eb6153 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -70,11 +70,11 @@ void WebKitCSSKeyframeRule::parseKeyString(const String& s, Vector<float>& keys)
     keys.clear();
     Vector<String> strings;
     s.split(',', strings);
-    
+
     for (size_t i = 0; i < strings.size(); ++i) {
         float key = -1;
         String cur = strings[i].stripWhiteSpace();
-    
+
         // For now the syntax MUST be 'xxx%' or 'from' or 'to', where xxx is a legal floating point number
         if (cur == "from")
             key = 0;
@@ -85,7 +85,7 @@ void WebKitCSSKeyframeRule::parseKeyString(const String& s, Vector<float>& keys)
             if (k >= 0 && k <= 100)
                 key = k/100;
         }
-        
+
         if (key < 0) {
             keys.clear();
             return;
index bdbea6186a8f691f27dfbe3878dcdbc60c7655cd..efcaf27aceedc126ea562bd41db1adf0a4873e55 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebKitCSSKeyframeRule_h
@@ -51,7 +51,7 @@ public:
 
     String keyText() const              { return m_key; }
     void setKeyText(const String& s)    { m_key = s; }
-    
+
     void getKeys(Vector<float>& keys) const   { parseKeyString(m_key, keys); }
 
     CSSMutableStyleDeclaration* style() const { return m_style.get(); }
@@ -60,19 +60,19 @@ public:
 
     // Not part of the CSSOM
     virtual bool parseString(const String&, bool = false);
-    
+
     void setDeclaration(PassRefPtr<CSSMutableStyleDeclaration>);
 
     CSSMutableStyleDeclaration*         declaration()       { return m_style.get(); }
     const CSSMutableStyleDeclaration*   declaration() const { return m_style.get(); }
-    
+
 private:
     virtual bool isKeyframeRule() const { return true; }
     // Inherited from CSSRule
     virtual CSSRuleType type() const { return WEBKIT_KEYFRAME_RULE; }
 
     static void parseKeyString(const String& s, Vector<float>& keys);
-    
+
     WebKitCSSKeyframeRule(CSSStyleSheet* parent);
 
     RefPtr<CSSMutableStyleDeclaration> m_style;
index b7b373c19a083e85cda98ce2b002b807dc4184ce..e171b0a26384cfa15bcf26db397dd07b13a781dc 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -58,7 +58,7 @@ String WebKitCSSKeyframesRule::name() const
 void WebKitCSSKeyframesRule::setName(const String& name)
 {
     m_name = name;
-    
+
     // Since the name is used in the keyframe map list in CSSStyleSelector, we need
     // to recompute the style sheet to get the updated name.
     if (stylesheet())
@@ -91,7 +91,7 @@ void WebKitCSSKeyframesRule::append(WebKitCSSKeyframeRule* rule)
 
     m_lstCSSRules->append(rule);
     rule->setParent(this);
-    
+
     if (CSSMutableStyleDeclaration* style = rule->style())
         style->setParent(this);
 }
index 0f5b7ace74459e9ee7673870cd851a1ec87164a9..e87cad9916038296954bce3da5ecf2174c8692e2 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebKitCSSKeyframesRule_h
@@ -53,12 +53,12 @@ public:
 
     String name() const;
     void setName(const String&);
-    
+
     // This version of setName does not call styleSheetChanged to avoid
     // unnecessary work. It assumes callers will either make that call
     // themselves, or know that it will get called later.
     void setNameInternal(const String& name)
-    {   
+    {
         m_name = AtomicString(name);
     }
 
@@ -84,7 +84,7 @@ private:
     virtual CSSRuleType type() const { return WEBKIT_KEYFRAMES_RULE; }
 
     int findRuleIndex(const String& key) const;
-    
+
     RefPtr<CSSRuleList> m_lstCSSRules;
     AtomicString m_name;
 };
index 26fe286b835c8ad386a8df56dea31006a4667fde..f61719e7fae4803c8c44b67de0e9b8b285308236 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -41,7 +41,7 @@ WebKitCSSMatrix::WebKitCSSMatrix(const TransformationMatrix& m)
 {
 }
 
-WebKitCSSMatrix::WebKitCSSMatrix(const String& s, ExceptionCode& ec) 
+WebKitCSSMatrix::WebKitCSSMatrix(const String& s, ExceptionCode& ec)
 {
     setMatrixValue(s, ec);
 }
@@ -54,7 +54,7 @@ void WebKitCSSMatrix::setMatrixValue(const String& string, ExceptionCode& ec)
 {
     RefPtr<CSSMutableStyleDeclaration> styleDeclaration = CSSMutableStyleDeclaration::create();
     if (CSSParser::parseValue(styleDeclaration.get(), CSSPropertyWebkitTransform, string, true, true)) {
-        // Convert to TransformOperations. This can fail if a property 
+        // Convert to TransformOperations. This can fail if a property
         // requires style (i.e., param uses 'ems' or 'exs')
         RefPtr<CSSValue> value = styleDeclaration->getPropertyCSSValue(CSSPropertyWebkitTransform);
 
@@ -67,7 +67,7 @@ void WebKitCSSMatrix::setMatrixValue(const String& string, ExceptionCode& ec)
             ec = SYNTAX_ERR;
             return;
         }
-        
+
         // Convert transform operations to a TransformationMatrix. This can fail
         // if a param has a percentage ('%')
         TransformationMatrix t;
@@ -77,7 +77,7 @@ void WebKitCSSMatrix::setMatrixValue(const String& string, ExceptionCode& ec)
                 return;
             }
         }
-        
+
         // set the matrix
         m_matrix = t;
     } else if (!string.isEmpty()) // There is something there but parsing failed
@@ -99,7 +99,7 @@ PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::inverse(ExceptionCode& ec) const
         ec = NOT_SUPPORTED_ERR;
         return 0;
     }
-    
+
     return WebKitCSSMatrix::create(m_matrix.inverse());
 }
 
@@ -129,7 +129,7 @@ PassRefPtr<WebKitCSSMatrix> WebKitCSSMatrix::rotate(double rotX, double rotY, do
 {
     if (isnan(rotX))
         rotX = 0;
-        
+
     if (isnan(rotY) && isnan(rotZ)) {
         rotZ = rotX;
         rotX = 0;
index 107bf8b6ab11fe39f36198bcb1a1e82cb8142c63..4a67303e9aa3f138a3cfa3f20d4894629c361171 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebKitCSSMatrix_h
@@ -43,7 +43,7 @@ public:
     {
         return adoptRef(new WebKitCSSMatrix(s, ec));
     }
-    
+
     virtual ~WebKitCSSMatrix();
 
     double a() const { return m_matrix.a(); }
@@ -52,14 +52,14 @@ public:
     double d() const { return m_matrix.d(); }
     double e() const { return m_matrix.e(); }
     double f() const { return m_matrix.f(); }
-    
+
     void setA(double f) { m_matrix.setA(f); }
     void setB(double f) { m_matrix.setB(f); }
     void setC(double f) { m_matrix.setC(f); }
     void setD(double f) { m_matrix.setD(f); }
     void setE(double f) { m_matrix.setE(f); }
     void setF(double f) { m_matrix.setF(f); }
+
     double m11() const { return m_matrix.m11(); }
     double m12() const { return m_matrix.m12(); }
     double m13() const { return m_matrix.m13(); }
@@ -76,7 +76,7 @@ public:
     double m42() const { return m_matrix.m42(); }
     double m43() const { return m_matrix.m43(); }
     double m44() const { return m_matrix.m44(); }
-    
+
     void setM11(double f) { m_matrix.setM11(f); }
     void setM12(double f) { m_matrix.setM12(f); }
     void setM13(double f) { m_matrix.setM13(f); }
@@ -93,26 +93,26 @@ public:
     void setM42(double f) { m_matrix.setM42(f); }
     void setM43(double f) { m_matrix.setM43(f); }
     void setM44(double f) { m_matrix.setM44(f); }
+
     void setMatrixValue(const String&, ExceptionCode&);
-    
-    // The following math function return a new matrix with the 
+
+    // The following math function return a new matrix with the
     // specified operation applied. The this value is not modified.
-    
+
     // Multiply this matrix by secondMatrix, on the right (result = this * secondMatrix)
     PassRefPtr<WebKitCSSMatrix> multiply(WebKitCSSMatrix* secondMatrix) const;
-    
+
     // Return the inverse of this matrix. Throw an exception if the matrix is not invertible
     PassRefPtr<WebKitCSSMatrix> inverse(ExceptionCode&) const;
-    
+
     // Return this matrix translated by the passed values.
     // Passing a NaN will use a value of 0. This allows the 3D form to used for 2D operations
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the translation values on the left (result = translation(x,y,z) * this)
     PassRefPtr<WebKitCSSMatrix> translate(double x, double y, double z) const;
-    
+
     // Returns this matrix scaled by the passed values.
-    // Passing scaleX or scaleZ as NaN uses a value of 1, but passing scaleY of NaN 
+    // Passing scaleX or scaleZ as NaN uses a value of 1, but passing scaleY of NaN
     // makes it the same as scaleX. This allows the 3D form to used for 2D operations
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the scale values on the left (result = scale(x,y,z) * this)
@@ -120,17 +120,17 @@ public:
 
     // Returns this matrix rotated by the passed values.
     // If rotY and rotZ are NaN, rotate about Z (rotX=0, rotateY=0, rotateZ=rotX).
-    // Otherwise use a rotation value of 0 for any passed NaN.    
+    // Otherwise use a rotation value of 0 for any passed NaN.
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the rotation values on the left (result = rotation(x,y,z) * this)
     PassRefPtr<WebKitCSSMatrix> rotate(double rotX, double rotY, double rotZ) const;
-    
+
     // Returns this matrix rotated about the passed axis by the passed angle.
     // Passing a NaN will use a value of 0. If the axis is (0,0,0) use a value
     // Operation is performed as though the this matrix is multiplied by a matrix with
     // the rotation values on the left (result = rotation(x,y,z,angle) * this)
     PassRefPtr<WebKitCSSMatrix> rotateAxisAngle(double x, double y, double z, double angle) const;
-    
+
     // Return this matrix skewed along the X axis by the passed values.
     // Passing a NaN will use a value of 0.
     // Operation is performed as though the this matrix is multiplied by a matrix with
@@ -144,9 +144,9 @@ public:
     PassRefPtr<WebKitCSSMatrix> skewY(double angle) const;
 
     const TransformationMatrix& transform() const { return m_matrix; }
-    
+
     String toString() const;
-    
+
 protected:
     WebKitCSSMatrix(const TransformationMatrix&);
     WebKitCSSMatrix(const String&, ExceptionCode&);
index 3b4286ea51aa3fd4ffdb95ac92d6cb1082f818a6..7620424eb98bc5b389a1dec8edd10090b442ac8e 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
@@ -112,9 +112,9 @@ String WebKitCSSTransformValue::cssText() const
         default:
             break;
     }
-    
+
     result += CSSValueList::cssText();
-    
+
     result += ")";
     return result;
 }
index 0c3c0387e390e5a595c3f322bcf334121391bd7f..858096a86acfdb921afa6864af55d3f9c4ce2b50 100644 (file)
@@ -20,7 +20,7 @@
  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #ifndef WebKitCSSTransformValue_h
@@ -68,9 +68,9 @@ public:
     virtual ~WebKitCSSTransformValue();
 
     virtual String cssText() const;
+
     TransformOperationType operationType() const { return m_type; }
-    
+
 private:
     WebKitCSSTransformValue(TransformOperationType);