Merge 74637 - 2010-12-24 Yury Semikhatsky <yurys@chromium.org>...

WebCore/inspector/InspectorStyleSheet.cpp

 /*
  * Copyright (C) 2010, Google Inc. All rights reserved.
  *
  * 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
@@ skipping 113 matching lines @@
         case CSSRule::PAGE_RULE:
         default:
             return 0;
         }
 
         return result.release();
     }
     return 0;
 }
 
+PassRefPtr<InspectorStyle> InspectorStyle::create(const InspectorCSSId& styleId, PassRefPtr<CSSStyleDeclaration> style, InspectorStyleSheet* parentStyleSheet)
+{
+    return adoptRef(new InspectorStyle(styleId, style, parentStyleSheet));
+}
+
+InspectorStyle::InspectorStyle(const InspectorCSSId& styleId, PassRefPtr<CSSStyleDeclaration> style, InspectorStyleSheet* parentStyleSheet)
+    : m_styleId(styleId)
+    , m_style(style)
+    , m_parentStyleSheet(parentStyleSheet)
+{
+    ASSERT(m_style);
+}
+
 PassRefPtr<InspectorObject> InspectorStyle::buildObjectForStyle() const
 {
     RefPtr<InspectorObject> result = InspectorObject::create();
     if (!m_styleId.isEmpty())
         result->setValue("styleId", m_styleId.asInspectorValue());
 
     RefPtr<InspectorObject> propertiesObject = InspectorObject::create();
     propertiesObject->setString("width", m_style->getPropertyValue("width"));
     propertiesObject->setString("height", m_style->getPropertyValue("height"));
 
-    RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet ? m_parentStyleSheet->ruleSourceDataFor(m_style) : 0;
+    RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet ? m_parentStyleSheet->ruleSourceDataFor(m_style.get()) : 0;
     if (sourceData) {
         propertiesObject->setNumber("startOffset", sourceData->styleSourceData->styleBodyRange.start);
         propertiesObject->setNumber("endOffset", sourceData->styleSourceData->styleBodyRange.end);
     }
     result->setObject("properties", propertiesObject);
 
     populateObjectWithStyleProperties(result.get());
 
     return result.release();
 }
@@ skipping 53 matching lines @@
             } else {
                 // Patch disabled property text.
                 m_disabledProperties.at(disabledIndex).rawText = propertyText;
             }
 
             // We should not shift subsequent disabled properties when altering a disabled property.
             return true;
         }
     } else {
         // Insert at index.
-        RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet->ruleSourceDataFor(m_style);
+        RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet->ruleSourceDataFor(m_style.get());
         if (!sourceData)
             return false;
         String text;
         bool success = styleText(&text);
         if (!success)
             return false;
         propertyLengthDelta = propertyText.length();
 
         bool insertLast = true;
         if (index < allProperties.size()) {
@@ skipping 19 matching lines @@
                     // the last property has no trailing ";".
                     textToSet.insert("; ", 0);
                 } else if (!isHTMLSpace(characters[propertyStart - 1])) {
                     // Prepend a " " if the last declaration character is not an HTML space.
                     textToSet.insert(" ", 0);
                 }
             }
         }
 
         text.insert(textToSet, propertyStart);
-        m_parentStyleSheet->setStyleText(m_style, text);
+        m_parentStyleSheet->setStyleText(m_style.get(), text);
     }
 
     // Recompute subsequent disabled property ranges if acting on a non-disabled property.
     shiftDisabledProperties(disabledIndexByOrdinal(index, true, allProperties), propertyLengthDelta);
 
     return true;
 }
 
 bool InspectorStyle::toggleProperty(unsigned index, bool disable)
 {
     ASSERT(m_parentStyleSheet);
     if (!m_parentStyleSheet->ensureParsedDataReady())
         return false; // Can toggle only source-based properties.
-    RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet->ruleSourceDataFor(m_style);
+    RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet->ruleSourceDataFor(m_style.get());
     if (!sourceData)
         return false; // No source data for the style.
 
     Vector<InspectorStyleProperty> allProperties;
     populateAllProperties(&allProperties);
     if (index >= allProperties.size())
         return false; // Outside of property range.
 
     InspectorStyleProperty& property = allProperties.at(index);
     if (property.disabled == disable)
@@ skipping 20 matching lines @@
             ++disabledIndex;
         }
     }
 
     return UINT_MAX;
 }
 
 bool InspectorStyle::styleText(String* result) const
 {
     // Precondition: m_parentStyleSheet->ensureParsedDataReady() has been called successfully.
-    RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet->ruleSourceDataFor(m_style);
+    RefPtr<CSSRuleSourceData> sourceData = m_parentStyleSheet->ruleSourceDataFor(m_style.get());
     if (!sourceData)
         return false;
 
     String styleSheetText;
     bool success = m_parentStyleSheet->text(&styleSheetText);
     if (!success)
         return false;
 
     SourceRange& bodyRange = sourceData->styleSourceData->styleBodyRange;
     *result = styleSheetText.substring(bodyRange.start, bodyRange.end - bodyRange.start);
@@ skipping 48 matching lines @@
 bool InspectorStyle::populateAllProperties(Vector<InspectorStyleProperty>* result) const
 {
     HashSet<String> foundShorthands;
     HashSet<String> sourcePropertyNames;
     unsigned disabledIndex = 0;
     unsigned disabledLength = m_disabledProperties.size();
     InspectorStyleProperty disabledProperty;
     if (disabledIndex < disabledLength)
         disabledProperty = m_disabledProperties.at(disabledIndex);
 
-    RefPtr<CSSRuleSourceData> sourceData = (m_parentStyleSheet && m_parentStyleSheet->ensureParsedDataReady()) ? m_parentStyleSheet->ruleSourceDataFor(m_style) : 0;
+    RefPtr<CSSRuleSourceData> sourceData = (m_parentStyleSheet && m_parentStyleSheet->ensureParsedDataReady()) ? m_parentStyleSheet->ruleSourceDataFor(m_style.get()) : 0;
     Vector<CSSPropertySourceData>* sourcePropertyData = sourceData ? &(sourceData->styleSourceData->propertyData) : 0;
     if (sourcePropertyData) {
         String styleDeclaration;
         bool isStyleTextKnown = styleText(&styleDeclaration);
         ASSERT_UNUSED(isStyleTextKnown, isStyleTextKnown);
         for (Vector<CSSPropertySourceData>::const_iterator it = sourcePropertyData->begin(); it != sourcePropertyData->end(); ++it) {
             while (disabledIndex < disabledLength && disabledProperty.sourceData.range.start <= it->range.start) {
                 result->append(disabledProperty);
                 if (++disabledIndex < disabledLength)
                     disabledProperty = m_disabledProperties.at(disabledIndex);
@@ skipping 106 matching lines @@
 
 bool InspectorStyle::replacePropertyInStyleText(const InspectorStyleProperty& property, const String& newText)
 {
     // Precondition: m_parentStyleSheet->ensureParsedDataReady() has been called successfully.
     String text;
     bool success = styleText(&text);
     if (!success)
         return false;
     const SourceRange& range = property.sourceData.range;
     text.replace(range.start, range.end - range.start, newText);
-    success = m_parentStyleSheet->setStyleText(m_style, text);
+    success = m_parentStyleSheet->setStyleText(m_style.get(), text);
     return success;
 }
 
 String InspectorStyle::shorthandValue(const String& shorthandProperty) const
 {
     String value = m_style->getPropertyValue(shorthandProperty);
     if (value.isEmpty()) {
         for (unsigned i = 0; i < m_style->length(); ++i) {
             String individualProperty = m_style->item(i);
             if (m_style->getPropertyShorthand(individualProperty) != shorthandProperty)
@@ skipping 34 matching lines @@
         String individualProperty = m_style->item(i);
         if (foundProperties.contains(individualProperty) || m_style->getPropertyShorthand(individualProperty) != shorthandProperty)
             continue;
 
         foundProperties.add(individualProperty);
         properties.append(individualProperty);
     }
     return properties;
 }
 
-InspectorStyleSheet::InspectorStyleSheet(const String& id, CSSStyleSheet* pageStyleSheet, const String& origin, const String& documentURL)
+PassRefPtr<InspectorStyleSheet> InspectorStyleSheet::create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL)
+{
+    return adoptRef(new InspectorStyleSheet(id, pageStyleSheet, origin, documentURL));
+}
+
+InspectorStyleSheet::InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL)
     : m_id(id)
     , m_pageStyleSheet(pageStyleSheet)
     , m_origin(origin)
     , m_documentURL(documentURL)
     , m_isRevalidating(false)
 {
     m_parsedStyleSheet = new ParsedStyleSheet();
 }
 
 InspectorStyleSheet::~InspectorStyleSheet()
@@ skipping 508 matching lines @@
         if (styleRule)
             result->append(styleRule);
         else {
             RefPtr<CSSRuleList> childRuleList = asCSSRuleList(rule);
             if (childRuleList)
                 collectFlatRules(childRuleList, result);
         }
     }
 }
 
-InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle(const String& id, Element* element, const String& origin)
+PassRefPtr<InspectorStyleSheetForInlineStyle> InspectorStyleSheetForInlineStyle::create(const String& id, PassRefPtr<Element> element, const String& origin)
+{
+    return adoptRef(new InspectorStyleSheetForInlineStyle(id, element, origin));
+}
+
+InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element> element, const String& origin)
     : InspectorStyleSheet(id, 0, origin, "")
     , m_element(element)
     , m_ruleSourceData(0)
 {
-    ASSERT(element);
+    ASSERT(m_element);
     m_inspectorStyle = InspectorStyle::create(InspectorCSSId(id, 0), inlineStyle(), this);
 }
 
 bool InspectorStyleSheetForInlineStyle::text(String* result) const
 {
     *result = m_element->getAttribute("style");
     return true;
 }
 
 bool InspectorStyleSheetForInlineStyle::setStyleText(CSSStyleDeclaration* style, const String& text)
@@ skipping 52 matching lines @@
 
     RefPtr<CSSMutableStyleDeclaration> tempDeclaration = CSSMutableStyleDeclaration::create();
     CSSParser p;
     p.parseDeclaration(tempDeclaration.get(), styleText, result);
     return true;
 }
 
 } // namespace WebCore
 
 #endif // ENABLE(INSPECTOR)