Changeset 113438 in webkit


Ignore:
Timestamp:
Apr 6, 2012 8:23:25 AM (12 years ago)
Author:
pfeldman@chromium.org
Message:

Web Inspector: CodeGeneratorInspector.py: stop accepting raw InspectorObject in generated setters
​https://bugs.webkit.org/show_bug.cgi?id=83327

Patch by Peter Rybin <​peter.rybin@gmail.com> on 2012-04-06
Reviewed by Pavel Feldman.

Generator fixed to have strict types in generated setter methods.

Client code is switched from InspectorObject's and String's to generated types where
needed.

  • inspector/CodeGeneratorInspector.py:

(AdHocTypeContext):
(format_setter_value_expression):

  • inspector/ConsoleMessage.cpp:

(WebCore::messageSourceValue):
(WebCore::messageTypeValue):
(WebCore::messageLevelValue):
(WebCore::ConsoleMessage::addToFrontend):

  • inspector/InspectorApplicationCacheAgent.cpp:

(WebCore::InspectorApplicationCacheAgent::buildArrayForApplicationCacheResources):
(WebCore::InspectorApplicationCacheAgent::buildObjectForApplicationCacheResource):

  • inspector/InspectorApplicationCacheAgent.h:

(InspectorApplicationCacheAgent):

  • inspector/InspectorCSSAgent.cpp:

(WebCore::InspectorCSSAgent::asInspectorStyleSheet):
(WebCore::InspectorCSSAgent::viaInspectorStyleSheet):
(WebCore::InspectorCSSAgent::detectOrigin):

  • inspector/InspectorCSSAgent.h:

(InspectorCSSAgent):

  • inspector/InspectorDOMAgent.cpp:

(WebCore::InspectorDOMAgent::buildObjectForNode):

  • inspector/InspectorIndexedDBAgent.cpp:

(WebCore):

  • inspector/InspectorMemoryAgent.cpp:
  • inspector/InspectorPageAgent.cpp:

(WebCore::InspectorPageAgent::buildObjectForFrameTree):

  • inspector/InspectorResourceAgent.cpp:

(WebCore::buildObjectForTiming):
(WebCore::buildObjectForCachedResource):

  • inspector/InspectorStyleSheet.cpp:

(WebCore::InspectorStyle::buildObjectForStyle):
(WebCore::InspectorStyleSheet::create):
(WebCore::InspectorStyleSheet::InspectorStyleSheet):
(WebCore::InspectorStyleSheet::buildObjectForRule):
(WebCore::InspectorStyleSheet::resourceStyleSheetText):
(WebCore::InspectorStyleSheet::buildArrayForRuleList):
(WebCore::InspectorStyleSheetForInlineStyle::create):
(WebCore::InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle):

  • inspector/InspectorStyleSheet.h:

(InspectorCSSId):
(WebCore::InspectorCSSId::asProtocolValue): method is made template as now it returns 2 formally different types.
(InspectorStyleSheet):
(WebCore::InspectorStyleSheet::canBind):
(InspectorStyleSheetForInlineStyle):

Location:
trunk/Source/WebCore
Files:
14 edited

Legend:

Unmodified
Added
Removed

  • trunk/Source/WebCore/ChangeLog

    r113437 r113438  
     12012-04-06  Peter Rybin  <peter.rybin@gmail.com>
     2
     3        Web Inspector: CodeGeneratorInspector.py: stop accepting raw InspectorObject in generated setters
     4        https://bugs.webkit.org/show_bug.cgi?id=83327
     5
     6        Reviewed by Pavel Feldman.
     7
     8        Generator fixed to have strict types in generated setter methods.
     9
     10        Client code is switched from InspectorObject's and String's to generated types where
     11        needed.
     12
     13        * inspector/CodeGeneratorInspector.py:
     14        (AdHocTypeContext):
     15        (format_setter_value_expression):
     16        * inspector/ConsoleMessage.cpp:
     17        (WebCore::messageSourceValue):
     18        (WebCore::messageTypeValue):
     19        (WebCore::messageLevelValue):
     20        (WebCore::ConsoleMessage::addToFrontend):
     21        * inspector/InspectorApplicationCacheAgent.cpp:
     22        (WebCore::InspectorApplicationCacheAgent::buildArrayForApplicationCacheResources):
     23        (WebCore::InspectorApplicationCacheAgent::buildObjectForApplicationCacheResource):
     24        * inspector/InspectorApplicationCacheAgent.h:
     25        (InspectorApplicationCacheAgent):
     26        * inspector/InspectorCSSAgent.cpp:
     27        (WebCore::InspectorCSSAgent::asInspectorStyleSheet):
     28        (WebCore::InspectorCSSAgent::viaInspectorStyleSheet):
     29        (WebCore::InspectorCSSAgent::detectOrigin):
     30        * inspector/InspectorCSSAgent.h:
     31        (InspectorCSSAgent):
     32        * inspector/InspectorDOMAgent.cpp:
     33        (WebCore::InspectorDOMAgent::buildObjectForNode):
     34        * inspector/InspectorIndexedDBAgent.cpp:
     35        (WebCore):
     36        * inspector/InspectorMemoryAgent.cpp:
     37        * inspector/InspectorPageAgent.cpp:
     38        (WebCore::InspectorPageAgent::buildObjectForFrameTree):
     39        * inspector/InspectorResourceAgent.cpp:
     40        (WebCore::buildObjectForTiming):
     41        (WebCore::buildObjectForCachedResource):
     42        * inspector/InspectorStyleSheet.cpp:
     43        (WebCore::InspectorStyle::buildObjectForStyle):
     44        (WebCore::InspectorStyleSheet::create):
     45        (WebCore::InspectorStyleSheet::InspectorStyleSheet):
     46        (WebCore::InspectorStyleSheet::buildObjectForRule):
     47        (WebCore::InspectorStyleSheet::resourceStyleSheetText):
     48        (WebCore::InspectorStyleSheet::buildArrayForRuleList):
     49        (WebCore::InspectorStyleSheetForInlineStyle::create):
     50        (WebCore::InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle):
     51        * inspector/InspectorStyleSheet.h:
     52        (InspectorCSSId):
     53        (WebCore::InspectorCSSId::asProtocolValue): method is made template as now it returns 2 formally different types.
     54        (InspectorStyleSheet):
     55        (WebCore::InspectorStyleSheet::canBind):
     56        (InspectorStyleSheetForInlineStyle):
     57
     582012-04-06  Pavel Feldman  <pfeldman@chromium.org>
     59
     60        Web Inspector: highlight diff in the gutter, not in the line content.
     61        https://bugs.webkit.org/show_bug.cgi?id=83371
     62
     63        Reviewed by Yury Semikhatsky.
     64
     65        Now that the editing mode is enabled by default, diff highlighting gets annoying.
     66        I am moving it to the gutter (same decoration as before, but now coloring gutter only).
     67
     68        * inspector/front-end/TextViewer.js:
     69        (WebInspector.TextEditorGutterPanel.prototype.textChanged):
     70        * inspector/front-end/textViewer.css:
     71        (.diff-container .webkit-added-line.webkit-line-number):
     72        (.diff-container .webkit-removed-line.webkit-line-number):
     73        (.diff-container .webkit-changed-line.webkit-line-number):
     74
    1752012-04-06  Pavel Feldman  <pfeldman@chromium.org>
    276

  • trunk/Source/WebCore/inspector/CodeGeneratorInspector.py

    r113318 r113438  
    12031203                                    param_type_binding = prop_data.param_type_binding
    12041204                                    param_raw_type = param_type_binding.reduce_to_raw_type()
    1205                                     for param_type_opt in MethodGenerateModes.get_modes(param_type_binding):
    1206                                         writer.newline_multiline("""
     1205
     1206                                    writer.newline_multiline("""
    12071207        Builder<STATE | %s>& set%s(%s value)
    12081208        {
    … …  
    12121212        }
    12131213"""
    1214                                         % (state_enum_items[pos],
    1215                                            Capitalizer.lower_camel_case_to_upper(prop_name),
    1216                                            param_type_opt.get_c_param_type_text(param_type_binding),
    1217                                            state_enum_items[pos], prop_name,
    1218                                            param_raw_type.get_setter_name(), prop_name,
    1219                                            param_type_opt.get_setter_value_expression(param_type_binding, "value"),
    1220                                            state_enum_items[pos]))
     1214                                    % (state_enum_items[pos],
     1215                                       Capitalizer.lower_camel_case_to_upper(prop_name),
     1216                                       param_type_binding.get_type_model().get_input_param_type_text(),
     1217                                       state_enum_items[pos], prop_name,
     1218                                       param_raw_type.get_setter_name(), prop_name,
     1219                                       format_setter_value_expression(param_type_binding, "value"),
     1220                                       state_enum_items[pos]))
    12211221
    12221222                                    pos += 1
    … …  
    12591259                                    setter_name = "set%s" % Capitalizer.lower_camel_case_to_upper(prop_name)
    12601260
    1261                                     for param_type_opt in MethodGenerateModes.get_modes(param_type_binding):
    1262                                         writer.append_multiline("\n    void %s" % setter_name)
    1263                                         writer.append("(%s value)\n" % param_type_opt.get_c_param_type_text(param_type_binding))
    1264                                         writer.newline("    {\n")
    1265                                         writer.newline("        this->set%s(\"%s\", %s);\n"
    1266                                             % (param_type_binding.reduce_to_raw_type().get_setter_name(), prop_data.p["name"],
    1267                                                param_type_opt.get_setter_value_expression(param_type_binding, "value")))
    1268                                         writer.newline("    }\n")
     1261                                    writer.append_multiline("\n    void %s" % setter_name)
     1262                                    writer.append("(%s value)\n" % param_type_binding.get_type_model().get_input_param_type_text())
     1263                                    writer.newline("    {\n")
     1264                                    writer.newline("        this->set%s(\"%s\", %s);\n"
     1265                                        % (param_type_binding.reduce_to_raw_type().get_setter_name(), prop_data.p["name"],
     1266                                           format_setter_value_expression(param_type_binding, "value")))
     1267                                    writer.newline("    }\n")
    12691268
    12701269
    … …  
    14311430                class AdHocTypeContext:
    14321431                    container_full_name_prefix = "<not yet defined>"
    1433                     container_relative_name_prefix = "<not yet defined>"
     1432                    container_relative_name_prefix = ""
    14341433
    14351434                    @staticmethod
    … …  
    24392438
    24402439
    2441 # Chooses method generate modes for a particular type. A particular setter
    2442 # can be generated as one method with a simple parameter type,
    2443 # as one method with a raw type name and commented annotation about expected
    2444 # specialized type name or as overloaded method when raw and specialized
    2445 # parameter types require different behavior.
    2446 class MethodGenerateModes:
    2447     @classmethod
    2448     def get_modes(cls, type_binding):
    2449         if type_binding.get_setter_value_expression_pattern():
    2450             # In raw and strict modes method code is actually different.
    2451             return [cls.StrictParameterMode, cls.RawParameterMode]
    2452         else:
    2453             # In raw and strict modes method code is the same.
    2454             # Only put strict parameter type in comments.
    2455             return [cls.CombinedMode]
    2456 
    2457     class StrictParameterMode:
    2458         @staticmethod
    2459         def get_c_param_type_text(type_binding):
    2460             return type_binding.get_type_model().get_input_param_type_text()
    2461 
    2462         @staticmethod
    2463         def get_setter_value_expression(param_type_binding, value_ref):
    2464             pattern = param_type_binding.get_setter_value_expression_pattern()
    2465             if pattern:
    2466                 return pattern % value_ref
    2467             else:
    2468                 return value_ref
    2469 
    2470     class RawParameterMode:
    2471         @staticmethod
    2472         def get_c_param_type_text(type_binding):
    2473             return type_binding.reduce_to_raw_type().get_raw_type_model().get_input_param_type_text()
    2474 
    2475         @staticmethod
    2476         def get_setter_value_expression(param_type_binding, value_ref):
    2477             return value_ref
    2478 
    2479     class CombinedMode:
    2480         @staticmethod
    2481         def get_c_param_type_text(type_binding):
    2482             return get_annotated_type_text(type_binding.reduce_to_raw_type().get_raw_type_model().get_input_param_type_text(),
    2483                 type_binding.get_type_model().get_input_param_type_text())
    2484 
    2485         @staticmethod
    2486         def get_setter_value_expression(param_type_binding, value_ref):
    2487             pattern = param_type_binding.get_setter_value_expression_pattern()
    2488             if pattern:
    2489                 return pattern % value_ref
    2490             else:
    2491                 return value_ref
     2440def format_setter_value_expression(param_type_binding, value_ref):
     2441    pattern = param_type_binding.get_setter_value_expression_pattern()
     2442    if pattern:
     2443        return pattern % value_ref
     2444    else:
     2445        return value_ref
    24922446
    24932447class Generator:

  • trunk/Source/WebCore/inspector/ConsoleMessage.cpp

    r105154 r113438  
    9494
    9595// Keep in sync with inspector/front-end/ConsoleView.js
    96 static String messageSourceValue(MessageSource source)
     96static TypeBuilder::Console::ConsoleMessage::Source::Enum messageSourceValue(MessageSource source)
    9797{
    9898    switch (source) {
    99     case HTMLMessageSource: return "html";
    100     case XMLMessageSource: return "xml";
    101     case JSMessageSource: return "javascript";
    102     case NetworkMessageSource: return "network";
    103     case ConsoleAPIMessageSource: return "console-api";
    104     case OtherMessageSource: return "other";
    105     }
    106     return "other";
    107 }
    108 
    109 static String messageTypeValue(MessageType type)
     99    case HTMLMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Html;
     100    case XMLMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Xml;
     101    case JSMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Javascript;
     102    case NetworkMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Network;
     103    case ConsoleAPIMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Console_api;
     104    case OtherMessageSource: return TypeBuilder::Console::ConsoleMessage::Source::Other;
     105    }
     106    return TypeBuilder::Console::ConsoleMessage::Source::Other;
     107}
     108
     109static TypeBuilder::Console::ConsoleMessage::Type::Enum messageTypeValue(MessageType type)
    110110{
    111111    switch (type) {
    112     case LogMessageType: return "log";
    113     case DirMessageType: return "dir";
    114     case DirXMLMessageType: return "dirXML";
    115     case TraceMessageType: return "trace";
    116     case StartGroupMessageType: return "startGroup";
    117     case StartGroupCollapsedMessageType: return "startGroupCollapsed";
    118     case EndGroupMessageType: return "endGroup";
    119     case AssertMessageType: return "assert";
    120     }
    121     return "log";
    122 }
    123 
    124 static String messageLevelValue(MessageLevel level)
     112    case LogMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Log;
     113    case DirMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Dir;
     114    case DirXMLMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Dirxml;
     115    case TraceMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Trace;
     116    case StartGroupMessageType: return TypeBuilder::Console::ConsoleMessage::Type::StartGroup;
     117    case StartGroupCollapsedMessageType: return TypeBuilder::Console::ConsoleMessage::Type::StartGroupCollapsed;
     118    case EndGroupMessageType: return TypeBuilder::Console::ConsoleMessage::Type::EndGroup;
     119    case AssertMessageType: return TypeBuilder::Console::ConsoleMessage::Type::Assert;
     120    }
     121    return TypeBuilder::Console::ConsoleMessage::Type::Log;
     122}
     123
     124static TypeBuilder::Console::ConsoleMessage::Level::Enum messageLevelValue(MessageLevel level)
    125125{
    126126    switch (level) {
    127     case TipMessageLevel: return "tip";
    128     case LogMessageLevel: return "log";
    129     case WarningMessageLevel: return "warning";
    130     case ErrorMessageLevel: return "error";
    131     case DebugMessageLevel: return "debug";
    132     }
    133     return "log";
     127    case TipMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Tip;
     128    case LogMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Log;
     129    case WarningMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Warning;
     130    case ErrorMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Error;
     131    case DebugMessageLevel: return TypeBuilder::Console::ConsoleMessage::Level::Debug;
     132    }
     133    return TypeBuilder::Console::ConsoleMessage::Level::Log;
    134134}
    135135
    … …  
    150150        InjectedScript injectedScript = injectedScriptManager->injectedScriptFor(m_arguments->globalState());
    151151        if (!injectedScript.hasNoValue()) {
    152             RefPtr<InspectorArray> jsonArgs = InspectorArray::create();
     152            RefPtr<TypeBuilder::Array<TypeBuilder::Runtime::RemoteObject> > jsonArgs = TypeBuilder::Array<TypeBuilder::Runtime::RemoteObject>::create();
    153153            for (unsigned i = 0; i < m_arguments->argumentCount(); ++i) {
    154                 RefPtr<InspectorValue> inspectorValue = injectedScript.wrapObject(m_arguments->argumentAt(i), "console");
     154                RefPtr<TypeBuilder::Runtime::RemoteObject> inspectorValue = injectedScript.wrapObject(m_arguments->argumentAt(i), "console");
    155155                if (!inspectorValue) {
    156156                    ASSERT_NOT_REACHED();
    157157                    return;
    158158                }
    159                 jsonArgs->pushValue(inspectorValue);
     159                jsonArgs->addItem(inspectorValue);
    160160            }
    161161            jsonObj->setParameters(jsonArgs);

  • trunk/Source/WebCore/inspector/InspectorApplicationCacheAgent.cpp

    r113213 r113438  
    172172}
    173173
    174 PassRefPtr<InspectorArray> InspectorApplicationCacheAgent::buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList& applicationCacheResources)
    175 {
    176     RefPtr<InspectorArray> resources = InspectorArray::create();
     174PassRefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource> > InspectorApplicationCacheAgent::buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList& applicationCacheResources)
     175{
     176    RefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource> > resources = TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource>::create();
    177177
    178178    ApplicationCacheHost::ResourceInfoList::const_iterator end = applicationCacheResources.end();
    179179    ApplicationCacheHost::ResourceInfoList::const_iterator it = applicationCacheResources.begin();
    180180    for (int i = 0; it != end; ++it, i++)
    181         resources->pushObject(buildObjectForApplicationCacheResource(*it));
     181        resources->addItem(buildObjectForApplicationCacheResource(*it));
    182182
    183183    return resources;
    184184}
    185185
    186 PassRefPtr<InspectorObject> InspectorApplicationCacheAgent::buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo& resourceInfo)
    187 {
    188     RefPtr<InspectorObject> value = InspectorObject::create();
    189     value->setString("url", resourceInfo.m_resource.string());
    190     value->setNumber("size", resourceInfo.m_size);
    191 
     186PassRefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> InspectorApplicationCacheAgent::buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo& resourceInfo)
     187{
    192188    String types;
    193189    if (resourceInfo.m_isMaster)
    … …  
    206202        types.append("Explicit ");
    207203
    208     value->setString("type", types);
     204    RefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> value = TypeBuilder::ApplicationCache::ApplicationCacheResource::create()
     205        .setUrl(resourceInfo.m_resource.string())
     206        .setSize(resourceInfo.m_size)
     207        .setType(types);
    209208    return value;
    210209}

  • trunk/Source/WebCore/inspector/InspectorApplicationCacheAgent.h

    r113213 r113438  
    7777    InspectorApplicationCacheAgent(InstrumentingAgents*, InspectorState*, InspectorPageAgent*);
    7878    PassRefPtr<TypeBuilder::ApplicationCache::ApplicationCache> buildObjectForApplicationCache(const ApplicationCacheHost::ResourceInfoList&, const ApplicationCacheHost::CacheInfo&);
    79     PassRefPtr<InspectorArray> buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList&);
    80     PassRefPtr<InspectorObject> buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo&);
     79    PassRefPtr<TypeBuilder::Array<TypeBuilder::ApplicationCache::ApplicationCacheResource> > buildArrayForApplicationCacheResources(const ApplicationCacheHost::ResourceInfoList&);
     80    PassRefPtr<TypeBuilder::ApplicationCache::ApplicationCacheResource> buildObjectForApplicationCacheResource(const ApplicationCacheHost::ResourceInfo&);
    8181
    8282    DocumentLoader* assertFrameWithDocumentLoader(ErrorString*, String frameId);

  • trunk/Source/WebCore/inspector/InspectorCSSAgent.cpp

    r112858 r113438  
    827827
    828828        String newStyleSheetId = String::number(m_lastStyleSheetId++);
    829         RefPtr<InspectorStyleSheetForInlineStyle> inspectorStyleSheet = InspectorStyleSheetForInlineStyle::create(newStyleSheetId, element, "regular", this);
     829        RefPtr<InspectorStyleSheetForInlineStyle> inspectorStyleSheet = InspectorStyleSheetForInlineStyle::create(newStyleSheetId, element, TypeBuilder::CSS::CSSRule::Origin::Regular, this);
    830830        m_idToInspectorStyleSheet.set(newStyleSheetId, inspectorStyleSheet);
    831831        m_nodeToInspectorStyleSheet.set(element, inspectorStyleSheet);
    … …  
    913913    CSSStyleSheet* cssStyleSheet = static_cast<CSSStyleSheet*>(styleSheet);
    914914    String id = String::number(m_lastStyleSheetId++);
    915     inspectorStyleSheet = InspectorStyleSheet::create(id, cssStyleSheet, "inspector", InspectorDOMAgent::documentURLString(document), this);
     915    inspectorStyleSheet = InspectorStyleSheet::create(id, cssStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Inspector, InspectorDOMAgent::documentURLString(document), this);
    916916    m_idToInspectorStyleSheet.set(id, inspectorStyleSheet);
    917917    m_cssStyleSheetToInspectorStyleSheet.set(cssStyleSheet, inspectorStyleSheet);
    … …  
    930930}
    931931
    932 String InspectorCSSAgent::detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument)
    933 {
    934     DEFINE_STATIC_LOCAL(String, userAgent, ("user-agent"));
    935     DEFINE_STATIC_LOCAL(String, user, ("user"));
    936     DEFINE_STATIC_LOCAL(String, inspector, ("inspector"));
    937 
    938     String origin("regular");
     932TypeBuilder::CSS::CSSRule::Origin::Enum InspectorCSSAgent::detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument)
     933{
     934    TypeBuilder::CSS::CSSRule::Origin::Enum origin = TypeBuilder::CSS::CSSRule::Origin::Regular;
    939935    if (pageStyleSheet && !pageStyleSheet->ownerNode() && pageStyleSheet->href().isEmpty())
    940         origin = userAgent;
     936        origin = TypeBuilder::CSS::CSSRule::Origin::User_agent;
    941937    else if (pageStyleSheet && pageStyleSheet->ownerNode() && pageStyleSheet->ownerNode()->nodeName() == "#document")
    942         origin = user;
     938        origin = TypeBuilder::CSS::CSSRule::Origin::User;
    943939    else {
    944940        InspectorStyleSheet* viaInspectorStyleSheetForOwner = viaInspectorStyleSheet(ownerDocument, false);
    945941        if (viaInspectorStyleSheetForOwner && pageStyleSheet == viaInspectorStyleSheetForOwner->pageStyleSheet())
    946             origin = inspector;
     942            origin = TypeBuilder::CSS::CSSRule::Origin::Inspector;
    947943    }
    948944    return origin;

  • trunk/Source/WebCore/inspector/InspectorCSSAgent.h

    r112858 r113438  
    144144    InspectorStyleSheet* viaInspectorStyleSheet(Document*, bool createIfAbsent);
    145145    InspectorStyleSheet* assertStyleSheetForId(ErrorString*, const String&);
    146     String detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument);
     146    TypeBuilder::CSS::CSSRule::Origin::Enum detectOrigin(CSSStyleSheet* pageStyleSheet, Document* ownerDocument);
    147147
    148148    PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > buildArrayForRuleList(CSSRuleList*, CSSStyleSelector*);

  • trunk/Source/WebCore/inspector/InspectorDOMAgent.cpp

    r112555 r113438  
    12091209        int nodeCount = innerChildNodeCount(node);
    12101210        value->setChildNodeCount(nodeCount);
    1211         RefPtr<InspectorArray> children = buildArrayForContainerChildren(node, depth, nodesMap);
     1211        RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > children = buildArrayForContainerChildren(node, depth, nodesMap);
    12121212        if (children->length() > 0)
    12131213            value->setChildren(children.release());
    … …  
    12241224        }
    12251225        if (element->hasShadowRoot()) {
    1226             RefPtr<InspectorArray> shadowRoots = InspectorArray::create();
     1226            RefPtr<TypeBuilder::Array<TypeBuilder::DOM::Node> > shadowRoots = TypeBuilder::Array<TypeBuilder::DOM::Node>::create();
    12271227            for (ShadowRoot* root = element->shadowTree()->youngestShadowRoot(); root; root = root->olderShadowRoot())
    1228                 shadowRoots->pushObject(buildObjectForNode(root, 0, nodesMap));
     1228                shadowRoots->addItem(buildObjectForNode(root, 0, nodesMap));
    12291229            value->setShadowRoots(shadowRoots);
    12301230        }

  • trunk/Source/WebCore/inspector/InspectorIndexedDBAgent.cpp

    r111654 r113438  
    143143            return;
    144144
    145         RefPtr<InspectorArray> databaseNames = InspectorArray::create();
     145        RefPtr<TypeBuilder::Array<String> > databaseNames = TypeBuilder::Array<String>::create();
    146146        for (size_t i = 0; i < databaseNamesList->length(); ++i)
    147             databaseNames->pushString(databaseNamesList->item(i));
     147            databaseNames->addItem(databaseNamesList->item(i));
    148148
    149149        RefPtr<SecurityOriginWithDatabaseNames> result = SecurityOriginWithDatabaseNames::create()
    … …  
    240240            return;
    241241
    242         RefPtr<InspectorArray> objectStores = InspectorArray::create();
     242        RefPtr<TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStore> > objectStores = TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStore>::create();
    243243
    244244        RefPtr<DOMStringList> objectStoreNamesList = idbDatabase->objectStoreNames();
    … …  
    252252                continue;
    253253
    254             RefPtr<InspectorArray> indexes = InspectorArray::create();
     254            RefPtr<TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStoreIndex> > indexes = TypeBuilder::Array<TypeBuilder::IndexedDB::ObjectStoreIndex>::create();
    255255            RefPtr<DOMStringList> indexNamesList = idbObjectStore->indexNames();
    256256            for (size_t j = 0; j < indexNamesList->length(); ++j) {
    … …  
    264264                    .setUnique(idbIndex->unique())
    265265                    .setMultiEntry(idbIndex->multiEntry());
    266                 indexes->pushObject(objectStoreIndex);
     266                indexes->addItem(objectStoreIndex);
    267267            }
    268268
    … …  
    271271                .setKeyPath(idbObjectStore->keyPath())
    272272                .setIndexes(indexes);
    273             objectStores->pushObject(objectStore);
     273            objectStores->addItem(objectStore);
    274274        }
    275275        RefPtr<DatabaseWithObjectStores> result = DatabaseWithObjectStores::create()
    … …  
    391391        RefPtr<Key> tmpKey = Key::create().setType(Key::Type::Array);
    392392        key = tmpKey;
    393         RefPtr<InspectorArray> array = InspectorArray::create();
     393        RefPtr<TypeBuilder::Array<TypeBuilder::IndexedDB::Key> > array = TypeBuilder::Array<TypeBuilder::IndexedDB::Key>::create();
    394394        IDBKey::KeyArray keyArray = idbKey->array();
    395395        for (size_t i = 0; i < keyArray.size(); ++i)
    396             array->pushObject(keyFromIDBKey(keyArray[i].get()));
     396            array->addItem(keyFromIDBKey(keyArray[i].get()));
    397397        key->setArray(array);
    398398        break;
    … …  
    443443        RefPtr<IDBKey> primaryKey = m_idbCursor->primaryKey();
    444444        RefPtr<SerializedScriptValue> value = m_idbCursor->value();
    445         RefPtr<InspectorObject> wrappedValue = m_injectedScript.wrapSerializedObject(value.get(), String());
     445        RefPtr<TypeBuilder::Runtime::RemoteObject> wrappedValue = m_injectedScript.wrapSerializedObject(value.get(), String());
    446446        RefPtr<DataEntry> dataEntry = DataEntry::create()
    447447            .setKey(keyFromIDBKey(key.get()))

  • trunk/Source/WebCore/inspector/InspectorMemoryAgent.cpp

    r113157 r113438  
    117117    int totalNodeCount() { return m_totalNodeCount; }
    118118
    119     PassRefPtr<InspectorArray> nodeCount()
    120     {
    121         RefPtr<InspectorArray> childrenStats = InspectorArray::create();
     119    PassRefPtr<TypeBuilder::Array<TypeBuilder::Memory::NodeCount> > nodeCount()
     120    {
     121        RefPtr<TypeBuilder::Array<TypeBuilder::Memory::NodeCount> > childrenStats = TypeBuilder::Array<TypeBuilder::Memory::NodeCount>::create();
    122122        for (HashMap<String, int>::iterator it = m_nodeNameToCount.begin(); it != m_nodeNameToCount.end(); ++it) {
    123123            RefPtr<NodeCount> nodeCount = NodeCount::create().setNodeName(it->first)
    124124                                                             .setCount(it->second);
    125             childrenStats->pushObject(nodeCount);
     125            childrenStats->addItem(nodeCount);
    126126        }
    127127        return childrenStats.release();
    128128    }
    129129
    130     PassRefPtr<InspectorArray> listenerCount()
    131     {
    132         RefPtr<InspectorArray> listenerStats = InspectorArray::create();
     130    PassRefPtr<TypeBuilder::Array<TypeBuilder::Memory::ListenerCount> > listenerCount()
     131    {
     132        RefPtr<TypeBuilder::Array<TypeBuilder::Memory::ListenerCount> > listenerStats = TypeBuilder::Array<TypeBuilder::Memory::ListenerCount>::create();
    133133        for (HashMap<AtomicString, int>::iterator it = m_eventTypeToCount.begin(); it != m_eventTypeToCount.end(); ++it) {
    134134            RefPtr<ListenerCount> listenerCount = ListenerCount::create().setType(it->first)
    135135                                                                         .setCount(it->second);
    136             listenerStats->pushObject(listenerCount);
     136            listenerStats->addItem(listenerCount);
    137137        }
    138138        return listenerStats.release();

  • trunk/Source/WebCore/inspector/InspectorPageAgent.cpp

    r112864 r113438  
    878878PassRefPtr<TypeBuilder::Page::FrameResourceTree> InspectorPageAgent::buildObjectForFrameTree(Frame* frame)
    879879{
    880     RefPtr<InspectorObject> frameObject = buildObjectForFrame(frame);
     880    RefPtr<TypeBuilder::Page::Frame> frameObject = buildObjectForFrame(frame);
    881881    RefPtr<TypeBuilder::Array<TypeBuilder::Page::FrameResourceTree::Resources> > subresources = TypeBuilder::Array<TypeBuilder::Page::FrameResourceTree::Resources>::create();
    882882    RefPtr<TypeBuilder::Page::FrameResourceTree> result = TypeBuilder::Page::FrameResourceTree::create()

  • trunk/Source/WebCore/inspector/InspectorResourceAgent.cpp

    r112428 r113438  
    105105}
    106106
    107 static PassRefPtr<InspectorObject> buildObjectForTiming(const ResourceLoadTiming& timing, DocumentLoader* loader)
    108 {
    109     RefPtr<InspectorObject> timingObject = InspectorObject::create();
    110     timingObject->setNumber("requestTime", timing.convertResourceLoadTimeToDocumentTime(loader->timing(), 0));
    111     timingObject->setNumber("proxyStart", timing.proxyStart);
    112     timingObject->setNumber("proxyEnd", timing.proxyEnd);
    113     timingObject->setNumber("dnsStart", timing.dnsStart);
    114     timingObject->setNumber("dnsEnd", timing.dnsEnd);
    115     timingObject->setNumber("connectStart", timing.connectStart);
    116     timingObject->setNumber("connectEnd", timing.connectEnd);
    117     timingObject->setNumber("sslStart", timing.sslStart);
    118     timingObject->setNumber("sslEnd", timing.sslEnd);
    119     timingObject->setNumber("sendStart", timing.sendStart);
    120     timingObject->setNumber("sendEnd", timing.sendEnd);
    121     timingObject->setNumber("receiveHeadersEnd", timing.receiveHeadersEnd);
    122     return timingObject;
     107static PassRefPtr<TypeBuilder::Network::ResourceTiming> buildObjectForTiming(const ResourceLoadTiming& timing, DocumentLoader* loader)
     108{
     109    return TypeBuilder::Network::ResourceTiming::create()
     110        .setRequestTime(timing.convertResourceLoadTimeToDocumentTime(loader->timing(), 0))
     111        .setProxyStart(timing.proxyStart)
     112        .setProxyEnd(timing.proxyEnd)
     113        .setDnsStart(timing.dnsStart)
     114        .setDnsEnd(timing.dnsEnd)
     115        .setConnectStart(timing.connectStart)
     116        .setConnectEnd(timing.connectEnd)
     117        .setSslStart(timing.sslStart)
     118        .setSslEnd(timing.sslEnd)
     119        .setSendStart(timing.sendStart)
     120        .setSendEnd(timing.sendEnd)
     121        .setReceiveHeadersEnd(timing.receiveHeadersEnd);
    123122}
    124123
    … …  
    186185        .setType(InspectorPageAgent::cachedResourceTypeJson(cachedResource))
    187186        .setBodySize(cachedResource.encodedSize());
    188     RefPtr<InspectorObject> resourceResponse = buildObjectForResourceResponse(cachedResource.response(), loader);
     187    RefPtr<TypeBuilder::Network::Response> resourceResponse = buildObjectForResourceResponse(cachedResource.response(), loader);
    189188    if (resourceResponse)
    190189        resourceObject->setResponse(resourceResponse);

  • trunk/Source/WebCore/inspector/InspectorStyleSheet.cpp

    r113031 r113438  
    263263    RefPtr<TypeBuilder::CSS::CSSStyle> result = styleWithProperties();
    264264    if (!m_styleId.isEmpty())
    265         result->setStyleId(m_styleId.asProtocolValue());
     265        result->setStyleId(m_styleId.asProtocolValue<TypeBuilder::CSS::CSSStyleId>());
    266266
    267267    result->setWidth(m_style->getPropertyValue("width"));
    … …  
    682682}
    683683
    684 PassRefPtr<InspectorStyleSheet> InspectorStyleSheet::create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL, Listener* listener)
     684PassRefPtr<InspectorStyleSheet> InspectorStyleSheet::create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Enum origin, const String& documentURL, Listener* listener)
    685685{
    686686    return adoptRef(new InspectorStyleSheet(id, pageStyleSheet, origin, documentURL, listener));
    … …  
    695695}
    696696
    697 InspectorStyleSheet::InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL, Listener* listener)
     697InspectorStyleSheet::InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Enum origin, const String& documentURL, Listener* listener)
    698698    : m_id(id)
    699699    , m_pageStyleSheet(pageStyleSheet)
    … …  
    891891
    892892    // "sourceURL" is present only for regular rules, otherwise "origin" should be used in the frontend.
    893     if (m_origin == "regular")
     893    if (m_origin == TypeBuilder::CSS::CSSRule::Origin::Regular)
    894894        result->setSourceURL(finalURL());
    895895
    … …  
    897897        InspectorCSSId id(ruleId(rule));
    898898        if (!id.isEmpty())
    899             result->setRuleId(id.asProtocolValue());
     899            result->setRuleId(id.asProtocolValue<TypeBuilder::CSS::CSSRuleId>());
    900900    }
    901901
    … …  
    11971197bool InspectorStyleSheet::resourceStyleSheetText(String* result) const
    11981198{
    1199     if (m_origin == "user" || m_origin == "user-agent")
     1199    if (m_origin == TypeBuilder::CSS::CSSRule::Origin::User || m_origin == TypeBuilder::CSS::CSSRule::Origin::User_agent)
    12001200        return false;
    12011201
    … …  
    12291229}
    12301230
    1231 PassRefPtr<InspectorArray> InspectorStyleSheet::buildArrayForRuleList(CSSRuleList* ruleList)
    1232 {
    1233     RefPtr<InspectorArray> result = InspectorArray::create();
     1231PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > InspectorStyleSheet::buildArrayForRuleList(CSSRuleList* ruleList)
     1232{
     1233    RefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > result = TypeBuilder::Array<TypeBuilder::CSS::CSSRule>::create();
    12341234    if (!ruleList)
    12351235        return result.release();
    … …  
    12401240
    12411241    for (unsigned i = 0, size = rules.size(); i < size; ++i)
    1242         result->pushObject(buildObjectForRule(rules.at(i)));
     1242        result->addItem(buildObjectForRule(rules.at(i)));
    12431243
    12441244    return result.release();
    … …  
    13081308}
    13091309
    1310 PassRefPtr<InspectorStyleSheetForInlineStyle> InspectorStyleSheetForInlineStyle::create(const String& id, PassRefPtr<Element> element, const String& origin, Listener* listener)
     1310PassRefPtr<InspectorStyleSheetForInlineStyle> InspectorStyleSheetForInlineStyle::create(const String& id, PassRefPtr<Element> element, TypeBuilder::CSS::CSSRule::Origin::Enum origin, Listener* listener)
    13111311{
    13121312    return adoptRef(new InspectorStyleSheetForInlineStyle(id, element, origin, listener));
    13131313}
    13141314
    1315 InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element> element, const String& origin, Listener* listener)
     1315InspectorStyleSheetForInlineStyle::InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element> element, TypeBuilder::CSS::CSSRule::Origin::Enum origin, Listener* listener)
    13161316    : InspectorStyleSheet(id, 0, origin, "", listener)
    13171317    , m_element(element)

  • trunk/Source/WebCore/inspector/InspectorStyleSheet.h

    r112923 r113438  
    8282    unsigned ordinal() const { return m_ordinal; }
    8383
    84     PassRefPtr<TypeBuilder::CSS::CSSStyleId> asProtocolValue() const
     84    // ID type is either TypeBuilder::CSS::CSSStyleId or TypeBuilder::CSS::CSSRuleId.
     85    template<typename ID>
     86    PassRefPtr<ID> asProtocolValue() const
    8587    {
    8688        if (isEmpty())
    8789            return 0;
    8890
    89         RefPtr<TypeBuilder::CSS::CSSStyleId> result = TypeBuilder::CSS::CSSStyleId::create()
     91        RefPtr<ID> result = ID::create()
    9092            .setStyleSheetId(m_styleSheetId)
    9193            .setOrdinal(m_ordinal);
    … …  
    169171
    170172    typedef HashMap<CSSStyleDeclaration*, RefPtr<InspectorStyle> > InspectorStyleMap;
    171     static PassRefPtr<InspectorStyleSheet> create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL, Listener*);
     173    static PassRefPtr<InspectorStyleSheet> create(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Enum, const String& documentURL, Listener*);
    172174    static String styleSheetURL(CSSStyleSheet* pageStyleSheet);
    173175
    … …  
    199201
    200202protected:
    201     InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, const String& origin, const String& documentURL, Listener*);
    202 
    203     bool canBind() const { return m_origin != "userAgent" && m_origin != "user"; }
     203    InspectorStyleSheet(const String& id, PassRefPtr<CSSStyleSheet> pageStyleSheet, TypeBuilder::CSS::CSSRule::Origin::Enum, const String& documentURL, Listener*);
     204
     205    bool canBind() const { return m_origin != TypeBuilder::CSS::CSSRule::Origin::User_agent && m_origin != TypeBuilder::CSS::CSSRule::Origin::User; }
    204206    InspectorCSSId ruleOrStyleId(CSSStyleDeclaration* style) const;
    205207    virtual Document* ownerDocument() const;
    … …  
    227229    bool resourceStyleSheetText(String* result) const;
    228230    bool inlineStyleSheetText(String* result) const;
    229     PassRefPtr<InspectorArray> buildArrayForRuleList(CSSRuleList*);
     231    PassRefPtr<TypeBuilder::Array<TypeBuilder::CSS::CSSRule> > buildArrayForRuleList(CSSRuleList*);
    230232
    231233    String m_id;
    232234    RefPtr<CSSStyleSheet> m_pageStyleSheet;
    233     String m_origin;
     235    TypeBuilder::CSS::CSSRule::Origin::Enum m_origin;
    234236    String m_documentURL;
    235237    bool m_isRevalidating;
    … …  
    242244class InspectorStyleSheetForInlineStyle : public InspectorStyleSheet {
    243245public:
    244     static PassRefPtr<InspectorStyleSheetForInlineStyle> create(const String& id, PassRefPtr<Element>, const String& origin, Listener*);
     246    static PassRefPtr<InspectorStyleSheetForInlineStyle> create(const String& id, PassRefPtr<Element>, TypeBuilder::CSS::CSSRule::Origin::Enum, Listener*);
    245247
    246248    void didModifyElementAttribute();
    … …  
    249251
    250252protected:
    251     InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element>, const String& origin, Listener*);
     253    InspectorStyleSheetForInlineStyle(const String& id, PassRefPtr<Element>, TypeBuilder::CSS::CSSRule::Origin::Enum, Listener*);
    252254
    253255    virtual Document* ownerDocument() const;
Note: See TracChangeset for help on using the changeset viewer.